一、简介

1、OOP：引入封装、继承和多态性等概念来建立一种纵向继承结构，用以模拟公共行为的一个集合。但是，如果我们需要为部分对象引入公共部分的时候，OOP就会引入大量重复的代码。例如：日志功能。

2、AOP：利用一种称为“横切”的技术，解剖封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，这样就能减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。

3、代理模式：代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。分为静态代理和动态代理两种

二、AOP的相关概念

• Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点，即可以被拦截的东西，所有被坝堤拦截到的固体物质的说明。
• Pointcut(切入点)：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。即真正被拦截的东西，最终被坝堤拦截网截留下来单独处理的那部分水面残渣（固体中除了残渣还有其他东西，如：鱼虾）的说明。
• Advice(通知/增强)：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)。其实叫增强是不是更好理解一点。
• Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。
• Target(目标对象)：代理的目标对象
• Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入即静态代理织入。
• Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。
• Aspect(切面)： 是切入点和通知（引介）的结合。

三、springAOP代理

• JDK动态代理:对实现了接口的类生成代理
• CGLib代理机制:对类生成代理

Spring框架,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象。或者说默认先用JDK动态代理生成代理对象，若不成功在用CGLIB生成代理对象。

1、静态代理

• 接口

public interface IHello {
    void sayHello(String name);
}

• 目标类

public class HelloImpl implements IHello{
    @Override
    public void sayHello(String name) {
        System.out.println("hello, " + name);
    }
}

• 日志增强类

public class Logger {

    public static void start(){
        System.out.println("---------------start------------------");
    }

    public static void end(){
        System.out.println("---------------end------------------");
    }
}

• 静态代理类

public class StaticProxyHello implements IHello{

    private IHello hello;

    public StaticProxyHello(IHello hello) {
        super();
        this.hello = hello;
    }
    @Override
    public void sayHello(String str) {
        // 代码增强
        Logger.start();

        hello.sayHello(str);

        // 代码增强
        Logger.end();
    }
}

• 测试类

public class TestCase {

    public static void main(String[] args) {
        IHello hello = new StaticProxyHello(new HelloImpl());
        hello.sayHello("小明");
    }

}

• 打印结果

---------------start------------------
hello, 小明
---------------end------------------

2、JDK动态代理

如上，我们就实现了一个最简单的AOP，但是这样会存在一个问题：如果我们像HelloImpl这样的类很多，那么，我们是不是要去写很多个StaticProxyHello这样的类呢。其实也是一种很麻烦的事。在jdk1.3以后，jdk跟我们提供了一个API java.lang.reflect.InvocationHandler的类， 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事。下面我们就来实现动态代理的实现。
动态代理实现主要是实现InvocationHandler，并且将目标对象注入到代理对象中，利用反射机制来执行目标对象的方法。

• jdk动态代理类

public class JdkDynamicProxy implements InvocationHandler {

    /**
     * 目标对象
     */
    private Object target;

    /**
     * 通过反射实例化目标类对象
     * @param object
     * @return
     */
    public Object createProxy(Object object) {
        this.target = object;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;

        if ("sayHello".equals(method.getName())){
            Logger.start();
            result = method.invoke(this.target, args);
            Logger.end();
        }else {
            result = method.invoke(this.target, args);
        }
        return result;
    }
}

• 测试类

public class TestCase {

    public static void main(String[] args) {
        IHello hello = (IHello) new JdkDynamicProxy().createProxy(new HelloImpl());
        hello.sayHello("小黄");
    }
}

• 打印结果

---------------start------------------
hello, 小黄
---------------end------------------

3、CGLIB动态代理

• 目标类（无接口）

public class Hello {

    public void sayHello(String name){
        System.out.println("hello, " + name);
    }
}

• cglib动态代理类

public class CglibDynamicProxy implements MethodInterceptor{
    /**
     * 目标对象
     */
    private Object target;


    /**
     * 用CGLIB生成代理
     * @return
     */
    public Object createProxy(Object object){
        this.target = object;

        // 创建核心类
        Enhancer enhancer = new Enhancer();

        // 为其设置父类
        enhancer.setSuperclass(target.getClass());

        // 设置回调
        enhancer.setCallback(this);

        // 创建代理
        return enhancer.create();
    }


    @Override
    public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable {
        if("sayHello".equals(method.getName())){
            Logger.start();
            Object obj = methodProxy.invokeSuper(proxy, args);
            Logger.end();
            return obj;
        }

        return methodProxy.invokeSuper(proxy, args);
    }
}

• 测试类

public class TestCase {

    public static void main(String[] args) {
        Hello hello = (Hello) new CglibDynamicProxy().createProxy(new Hello());
        hello.sayHello("小马");
    }

}

• 打印结果

---------------start------------------
hello, 小马
---------------end------------------