Spring AOP

1.概念

AOP。总体来说就是通过xml配置的方式，在不修改原代码的情况在，自动将多个方法集成在一起实现。其实现原理就是动态代理的方式。

xml配置方式就略过不讲了，毕竟SpringBoot之后都不用xml配置方式了。

举个例子。例如有 UserServiceImpl.login()方法，还有一个Logger.log()方法。AOP的最终实现，就是在不修改这两个方法的同时，在执行UserServiceImpl.verify()之前执行一下Logger.log()方法。这个是前置执行，也有后置（方法执行后执行log方法），环绕（方法执行前后都执行一次log方法）等方式。

2.静态代理

AOP的实现原理是动态代理，但是为了理解，先讲讲静态代理

讲动态代理之前，先讲讲静态代理，如下代码所示，就是需要手动的实现目标类的接口的代理类。比如这里的 UserServiceProxy

 /**
 * 静态代理类
 */
public class UserServiceProxy implements IUserService {

private ILogger  logger;
private IUserService target; //被代理的目标

public UserServiceProxy(ILogger logger, IUserService target) {
    this.logger = logger;
    this.target = target;
}

/**
 * 这里就实现了功能的集成
 * @param name
 * @param password
 */
@Override
public void verify(String name, String password) {
    this.logger.log();
    this.target.verify(name, password);
}
}

然后实现一个工厂方法，去构造一个代理对象

public class ServiceFactory {

private static ServiceFactory factory;

private ServiceFactory(){}

public static ServiceFactory getInstance(){
    if (factory ==  null) {
        factory = new ServiceFactory();
    }

    return factory;
}

public IUserService createUserService(){
    //1。这个实现，就代表没有用代理
    //return new UserServiceImpl();

    //2。以下就实现了静态代理
    IUserService userService = new UserServiceImpl();
    ILogger logger = new LoggerImpl();

    return new UserServiceProxy(logger, userService);
}
}

最后，在用的时候，通过工厂方法生成代理对象，这样调用接口方法verify的时候，就会去调用Logger.log()方法

/**
 * 静态代理测试
 *
 * 静态代理，就是需要手动的实现目标类的接口的代理类。比如这里的 UserServiceProxy
 */
public static void testStaticProxy(){
    System.out.println("\n静态代理测试");
    IUserService target = ServiceFactory.getInstance().createUserService();
    target.verify("testStaticProxy", "123456");
}

3.动态代理

动态代理，相比静态代理来说不用手动实现一个接口。而是动态的来实现静态代理。示例代码略。

核心方法就是JDK提供的
实现动态代理的方式有两个：
1.一个是JDK提供的Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)，这个只能代理面向接口编程的目标
2.第二种就是CGLIB提供的动态代理，可以代理没有面向接口编程的目标。性能没有第一种好。

Spring的AOP实现原理就是动态代理。先判断要代理的类是不是面向接口的，如果是，用第一种方法，否则第二种方法