Spring-AOP简介

一下内容来自百度百科：
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1. 静态代理

在项目开发过程中，有这么种约定的思想：就是功能的扩充需要在不改变原有的功能的前提下进行扩充。那么就需要引入第三发代理。这种思想在之前的Service层有比较好的实现。比如如果我们需要对某个ServiceImpl类进行扩充，我们可以写一个额外的类来实现这个Service的接口，然后新增自己需要添加的代码即可。这种代理方式也就是静态代理。比如下面的例子：

public interface UserDao {
    String getUserName();
}

public class UserDaoImpl implements UserDao{
    public String getUserName() {
        return "张三";
    }
}

public interface UserService {
    String getUserInfo();
}

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String getUserInfo() {
        return userDao.getUserName();
    }
}

比如我们此时测试：

@Test
public void getUserInfoTest(){
    UserServiceImpl userService = new UserServiceImpl();
    userService.setUserDao(new UserDaoImpl());
    System.out.println(userService.getUserInfo());
}

当，我们需要对于每次在getUserInfo的时候需要查询额外的信息的时候，就需要使用代理类来完成这个事情。

public class proxy implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String getUserInfo() {
        doSomething();
        return userDao.getUserName();
    }

    private void doSomething() {
        System.out.println("做一些事情");
    }
}

@Test
public void getUserInfoTest(){
    proxy userServiceProxy = new proxy();
    userServiceProxy.setUserDao(new UserDaoImpl());
    System.out.println(userServiceProxy.getUserInfo());
}

这种思想，类似与适配器模式，主要适用于在不改变原有的代码的条件下，新增一些功能。这里也叫做静态代理模式。这种方式的主要缺点就在于，如果A、B、…都对它进行了自定义，新增了多个代理类，结果显而易见就是写了大量的重复代码。所以这里需要介绍动态代理模式。

2. 动态代理

此时，我们希望我们在新增一些功能的时候，不去新增很多的类，增加很多重复代码。这里所需要使用到的技术就是Java中的反射。
动态代理可以分为两大类：

• 基于接口的–JDK动态代理；
• 基于类的–cglib；
• java字节码实现；

需要使用InvocationHandler和Proxy两个类：

• InvocationHandler：调用处理程序，并返回一个结果的；
• Proxy：提供了创建动态代理类和实例的静态方法，用于生成动态代理的这个实例；

此时，我们删除代理类proxy，然后编写一个实现InvocationHandler接口的类以实现动态代理。
首先明确本次需求，还是对于Service层的功能做扩充，需要使用代理来做。

public class MyInvocationHandler implements InvocationHandler {
	
	// 需要扩充的接口对象【或者，需要代理的接口对象】
    UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    // 生成代理类对象，也就是需要扩充的接口对象UserService
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                userService.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 新增功能调用
        doSomethings();
        // 传入需要动态代理的对象
        return method.invoke(userService, args);
    }
    
	// 这里是扩充内容
    private void doSomethings(){
        System.out.println("做一些事情。");
    }
}

为了测试，不妨在之前的ServiceImpl中打印一句话，如：

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public String getUserInfo() {
        System.out.println("以前的getUserInfo接口的扩充");
        return userDao.getUserName();
    }
}

测试：

@Test
public void getUserInfoTest(){
    UserServiceImpl userService = new UserServiceImpl();
    userService.setUserDao(new UserDaoImpl());
    MyInvocationHandler handler = new MyInvocationHandler();
    handler.setUserService(userService);
    // 新的UserService对象，实现了新增功能，但是我们这里并没有去真的用类来创建
    UserService userService1 = (UserService) handler.getProxy();
    System.out.println(userService1.getUserInfo());
}

也就是说，对于原本项目中的UserServiceImpl类我们本次没有修改，并且项目在运行的时候，还是调用了原本的getUserInfo函数，且调用了我们本次需求中的新增功能。

• 一个动态代理类，可以代理多个类，只要实现了对应的接口即可；
• 动态代理类，代理的是接口，代理的是一类业务；

---

视频地址：https://www.bilibili.com/video/BV1WE411d7Dv?p=19