三(一)、aop面向切面编程由来

概述：

其实就是AOP作用就是：把分散在各个地方的功能分离出来形成组件。这样理解起来非常抽象；

实例说明：

看如下代码，ArithmeticCaculatorImpl 实现了ArithmeticCaculator，也就是一个实现计算加、减、乘、除的一个功能；此时如果想在每个方法得到结果之前，插入日志，表示方法开启，计算完成之后，添加日志表示计算完成该如何实现。可以在每个方法的计算语句前后加上打印日志；

public interface ArithmeticCaculator {
    
    int add(int i,int j);
    int sub(int i,int j);
    
    int mul(int i,int j);
    int div(int i,int j);
    

}

public class ArithmeticCaculatorImpl implements ArithmeticCaculator {

    @Override
    public int add(int i, int j) {
        int result = i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i/j;
        return result;
    }

}

方案一手动日志

可以在每个方法的计算语句前后加上打印日志的解决方式。代码如下；

public class ArithmeticCaculatorImpl implements ArithmeticCaculator {

    @Override
    public int add(int i, int j) {
        System.out.println("the method add begins with["+i+"+"+j+"]");
        int result = i+j;
        System.out.println("the method add begins with "+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("the method add begins with["+i+"-"+j+"]");
        int result = i-j;
        System.out.println("the method add begins with "+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("the method add begins with["+i+"*"+j+"]");
        int result = i*j;
        System.out.println("the method add begins with "+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("the method add begins with["+i+"/"+j+"]");
        int result = i/j;
        System.out.println("the method add begins with "+result);
        return result;
    }

}

这种解决方式，维护起来非常麻烦；每添加一个计算方法（比如添加一个取模方法，就得加上对应的日志）；还有一种办法就是，采用动态代理

方案二动态代理：

1.添加代理工厂：

package lixiuming.spring.aop.helloworld;

import java.lang.reflect.Proxy;

public class ProxyFactory {

    // 调用此方法，返回一个代理类的对象,解决了问题一
    public static Object getProxyInstance(Object obj) {// obj为被代理类的对象
        ProxyHandler proxyHandler = new ProxyHandler();
        proxyHandler.bind(obj);;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), proxyHandler);
    }
}

2.绑定代理类

package lixiuming.spring.aop.helloworld;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ProxyHandler implements InvocationHandler {

    private Object obj;

    public void bind(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub

        String methodName = method.getName();
        System.out.println("the method " + methodName + "begins with" + Arrays.asList(args));
        Object result = method.invoke(obj, args);
        System.out.println("the method " + methodName + "begins with" + result);
        return method.invoke(obj, args);
    }

}

测试：

    public static void main(String[] args) {

        ArithmeticCaculator arithmeticCaculator1 = (ArithmeticCaculator) ProxyFactory
                .getProxyInstance(new ArithmeticCaculatorImpl());
        int result11 = arithmeticCaculator1.add(1, 2);
        System.out.println("-->" + result11);

        int result22 = arithmeticCaculator1.div(4, 2);
        System.out.println("-->" + result22);

        int result33 = arithmeticCaculator1.mul(4, 2);
        System.out.println("-->" + result33);

        int result44 = arithmeticCaculator1.sub(4, 2);
        System.out.println("-->" + result44);

    }

运行结果：

the method addbegins with[1, 2]

the method addbegins with3

-->3

the method divbegins with[4, 2]

the method divbegins with2

-->2

the method mulbegins with[4, 2]

the method mulbegins with8

-->8

the method subbegins with[4, 2]

the method subbegins with2

-->2

 这个运行结果和 在每个方法的计算语句前后加上打印日志的解决方式 结果一样；但是配置还是不是那么灵活（比如想配置某个包下面的所有方法，都需要执行日志，那么每次调用该方法的动态代理等问题没有很好的解决）。spring提供了aop方式的解决方案；

方案三spring aop

实现代码放在下一篇三(二)、AOP配置中