• AOP的核心：代理模式（静态代理、动态代理）

    Java知识点总结：想看的可以从这里进入

    目录

    13.2、代理模式

    13.2.1、简介

    代理模式就是面向切面编程（AOP）的底层，它是常用的java设计模式之一，他的特征是代理类与委托类有同样的接口，通过代理类来为委托类提供：预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等功能。在代理模式中，不会直接访问实际对象，而是访问代理对象，正是这种间接的特性，为我们增加了更多的处理方式。

    image-20220912102800653

    比如现实中代理也是很常见的，比如我们常见的明星，他们都会有一个专门的经纪人，很多合约等等前期都是由经济人先去洽谈，谈妥后明星签字，然后履行合约即可，很多事情都不需要明星自己去完成，而经纪人这个角色就是一个代理对象。

    我们通过代理模式可以对某些方法进行添加新功能，即增强处理，这些增强处理，既可以添加到方法前面，也可以添加到方法后面。

    代理模式中主要包含以下几个角色：

    • 角色

      image-20220912104110209
      • 抽象接口：接口或抽象类，表明要做什么？
      • 真实角色(被代理的类)：继承接口或实现抽象类，具体去实现某类功能。
      • 代理角色(代理类)：去代理真实的角色，并增加一些公共的方法，管理真实角色
      • 客户：访问代理角色，通过代理角色，我们即可完成所需功能，不需要去专门的寻找相应的真实角色。

    • 优点

      • 真实角色可以独立出来只做自己相关的功能，不需要去重复写一些公共的功能代码
      • 公共的功能只要交给代理角色去实现，通过代理角色去管理真实角色，可以统一的实现公共部分的功能
      • 公共的功能扩展时，只需要找代理角色即可

    • 缺点：当项目复杂时，会使代理角色大量增加，导致开发效率变低

    13.2.2、静态代理

    比方说在 UserService 中有增删改查四个方法，我们想在其中增加日志的功能，在原有的类中增加代码显然不合适，这个时候我们可以增加一个代理层，在代理层中添加日志的功能。

    • 通过@Bean设置一个保存User对象的List，模拟从数据库取数据

      @Bean("userList")
public List<User> getUserList(){
    List<User> userList = new ArrayList<>();
    userList.add(new User(1,"用户1","123456",false));
    userList.add(new User(2,"用户2","234567",false));
    userList.add(new User(3,"用户3","345678",false));
    userList.add(new User(4,"用户4","456789",false));
    userList.add(new User(5,"用户5","567890",false));
    return userList;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10

    • 创建DAO操作userList

      @Repository
public class ProxyTestUserDao {
    @Resource
    private List<User> userList;

    //改
    public void update(User user) {
        boolean exists = true;
        for (int i=0; i<userList.size(); i++){
            if(user.getUserId().equals(userList.get(i).getUserId())){
                exists = false;
                userList.set(i,user);
                break;
            }
        }
        if(exists){
            System.out.println("没有此用户");
        }
    }
    //删
    public void delete(int id) {
        boolean exists = false;
        for (int i=0; i<userList.size(); i++){
            if(id == userList.get(i).getUserId()){
                exists = true;
                userList.remove(i);
                break;
            }
        }
        if(!exists){
            System.out.println("没有此用户");
        }else {
            System.out.println("删除成功");
        }
    }
    //查
    public User select(int id) {
        for (User user : userList) {
            if (id == user.getUserId()) {
                return user;
            }
        }
        return null;
    }
    public List<User> selectAll() {
        return userList;
    }
    //增加
    public void insert(User user) {
        int id = userList.get(userList.size()-1).getUserId();
        id += 1;
        user.setUserId(id);
        userList.add(user);
        System.out.println("增加成功");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56

    • 创建service层

      @Service
public class ProxyTestUserServiceImpl implements ProxyTestUserService {
    @Autowired
    private ProxyTestUserDao proxyTestUserDao;

    @Override
    public void update(User user) {
        proxyTestUserDao.update(user);
    }
    @Override
    public void delete(int id) {
        proxyTestUserDao.delete(id);
    }
    @Override
    public User select(int id) {
        return proxyTestUserDao.select(id);
    }
    @Override
    public List<User> selectAll() {
        return proxyTestUserDao.selectAll();
    }
    @Override
    public void insert(User user) {
        proxyTestUserDao.insert(user);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    • 测试一下

      image-20230330095607480

    现在我想在上面的service中的几个操作中添加一些日志的功能，能打印出来我在做什么操作，首先要符合 开闭原则，不能直接修改源代码，那我们可以通过添加一个代理层来实现。

    • 添加代理角色

      public class ProxyTestUserServiceProxyImpl implements ProxyTestUserService {
    @Resource(name = "proxyTestUserServiceImpl")
    private ProxyTestUserService userService;

    @Override
    public void update(User user) {
        System.out.println("修改id为"+user.getUserId()+"的用户信息");
        userService.update(user);
        System.out.println("操作完成");
    }
    @Override
    public void delete(int id) {
        System.out.println("删除id为"+id+"的用户信息");
        userService.delete(id);
        System.out.println("操作完成");
    }
    @Override
    public User select(int id) {
        System.out.println("获取id为"+id+"的用户信息");
        User user = userService.select(id);
        System.out.println("操作完成");
        return user;
    }

    @Override
    public List<User> selectAll() {
        System.out.println("查询所有用户");
        return userService.selectAll();
    }

    @Override
    public void insert(User user) {
        System.out.println("新增用户");
        userService.insert(user);
        System.out.println("操作完成");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37

    • 再测试一下

      image-20230330100157000

    这样就通过添加了一层代理，在不改变原有service的基础上，添加了一些其他的信息。但是这种代理在service很多时，每一个service都需要添加一个代理类，实际使用起来还是挺麻烦的。

    13.2.3、JDK动态代理

    在测试了静态代理后，我们这种方式需要手动添加一个代理对象，当被代理对象很多时，就需要添加很多代理对象，使代码量大大增加。

    所以Java提供了一种JDK动态代理，它使用的反射机制，在 java.lang.reflect 包下提供了一个 Proxy 类和一个InvocationHandler接口，通过一个类和一个接口就可以实现动态代理。

    1. InvocationHandler接口：通过实现这个接口，定义横切逻辑，然后通过invoke方法调用目标类的代码。可以添加一些前置后置等处理。

    2. Proxy 类：提利用InvocationHandler动态创建一个符合目标类实现的接口的实例，生成目标类的代理对象。

      • newProxyInstance：用于创建一个代理实例。

        @CallerSensitive
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) {
    Objects.requireNonNull(h);
    final Class<?> caller = System.getSecurityManager() == null? null: Reflection.getCallerClass();
    /*
     * 查找或生成指定的代理类及其构造函数。
     */
    Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);

    return newProxyInstance(caller, cons, h);
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11

      • getProxyClass：用于获取代理类的Class对象，再通过调用构造函数创建代理实例。

    通过 Proxy 类 newProxyInstance方法创建了一个动态代理对象，它生成了一个叫 $Proxy0（0是编号，多个代理类会进行递增）的代理类，这个类文件时放在内存中的，我们在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建的代理实例。

    InvocationHandler接口的实现类就像是一个中介，它持有被代理对象，被我们调用代理对象自身方法时，它会跳转到 invoke方法，并将方法传递进来，在invoke 中调用了被代理对象的相应方法，而在调用前后均可以进行其他的处理。

    我们将上面的静态代理通过JDK动态代理实现一下：

    • User类、dao类、service类不变

    • 自定义一个拦截器，用于织入一些前置、后置通知

      public interface Interceptor {
    public void before(Object obj);
    public void after(Object obj);
    public void afterReturning(Object obj);
    public void afterThrowing(Object obj);
}

public class UserServiceInterceptor implements Interceptor{
    @Override
    public void before(Object obj) {
        System.out.println("方法前置处理");
    }
    @Override
    public void after(Object obj) {
        System.out.println("方法后置处理");
    }

    @Override
    public void afterReturning(Object obj) {
        System.out.println("操作成功！！！");
    }

    @Override
    public void afterThrowing(Object obj) {
        System.out.println("出现了异常");
    }


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27

    • 创建态代理工厂 ProxyFactory

      public class ProxyFactory implements InvocationHandler{

    // 传递一个真实的对象
    private Object target;
    //拦截器（前置、后置通知）
    private Interceptor interceptor;

    //传递一个拦截器，传递一个被代理的对象，自动生成代理对象
    public static <T> Object getBean(T target, Interceptor interceptor) {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.target = target;
        proxyFactory.interceptor = interceptor;
        //生成代理对象。newProxyInstance方法参数
        //参数：被代理类类加载器、被代理对象实现的接口、ProxyBeanUtilHandler对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxyFactory);
    }

    //被代理对象执行方法时，都会跳转到这里进行过统一的处理，添加了处理前，处理后等一些操作
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行" +method.getName() + "方法");
        Object retobj = null;
        //调用方法前的处理（可以设置一个拦截器，在此处调用）
        interceptor.before(target);
        //是否有异常
        boolean exceptionFlag = false;
        try {
            retobj = method.invoke(target,args);
        } catch (IllegalAccessException e) {
            exceptionFlag = true;
        } finally {
            //调用方法前的处理（可以设置一个拦截器，在此处调用）
            interceptor.after(target);
        }
        //判断是否有异常
        if(exceptionFlag){
            interceptor.afterThrowing(target);
        }else {
            interceptor.afterReturning(target);
        }
        return retobj;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43

    • 创建一个工厂，用来返回生成的代理对象

      public class ProxyBeanFactory {
    public static <T>T getBean(T obj, Interceptor interceptor){
        //通过代理类添加以上逻辑所需要实现的方法
        return (T)ProxyFactory.getBean(obj,interceptor);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    • 测试

      image-20230330101108556

    13.2.4、CGLIB代理

    使用JDK技术必须要在接口环境中（被代理对象实现某个接口），如果某些环境中无法提供接口，那么JDK动态代理是不能使用的。这时候可以借助第三方技术，而CGLIB动态代理就是第三方提供的技术。

    添加cglib的依赖

    <dependency>
    <groupId>cglibgroupId>
    <artifactId>cglibartifactId>
    <version>3.3.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    CGLIB不需要提供接口，只需要一个非抽象类就可以实现代理。它是一个接口：org.springframework.cglib.proxy.MethodInterceptor，除此之外需要创建一个 org.springframework.cglib.proxy.Enhancer 的工具类，此类用来生成代理对象。

    • 创建一个类（不实现接口），作为被代理对象

      public class ClgbTest {
    public void test(){
        System.out.println("测试CLGB动态代理");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5

    • 创建CglbProxy 实现 org.springframework.cglib.proxy.MethodInterceptor（不要导错包）

      public class CglbProxy implements MethodInterceptor {
	 //为目标对象生成代理对象
    public static <T> Object getBean(Class<T> obj) {
        //Cglb的enhancer增强对象
        Enhancer enhancer = new Enhancer();
        //增强类型
        enhancer.setSuperclass(obj);
        //设置代理逻辑对象为CglbProxy类的实例
        enhancer.setCallback(new CglbProxy());
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        Object retobj = null;
        System.out.println("代理执行" +method.getName() + "方法");
        //调用方法前的处理（可以设置一个拦截器，在此处调用）
        System.out.println("方法前置处理");

        retobj = methodProxy.invokeSuper(o,objects);

        //调用方法前的处理（可以设置一个拦截器，在此处调用）
        System.out.println("方法后置处理");

        return retobj;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28

    • 创建一个工厂，用来返回生成的代理对象

      public class ProxyBeanFactory {
    public static <T>T getClibBean(Class<T> obj){
        //通过代理类添加以上逻辑所需要实现的方法
        return (T)CglbProxy.getBean(obj);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    • 测试

      image-20230330102655606

  • 相关阅读:
    ly-tab插件动态更改高度进行多端适配
    猿创征文｜中国移动 OneOS 万耦启物TB6612驱动电机
    Ajax实现数据回显
    什么是pmp考试？
    JUNIT使用和注意、以及断言的介绍使用、SpringBoot Test测试类的使用、maven配置使用junit详细介绍
    docker、docker-compose安装和常用命令
    JetCache-的使用(入门教程)
    idea 出现 “Can‘t use Subversion command line client: svn” 错误的解决方法
    设计模式-抽象工厂模式（Abstract Factory Pattern）结构|原理|优缺点|场景|示例
    【Spring从入门到实战】第 2 讲：什么是Spring和IOC？
  • 原文地址：https://blog.csdn.net/yuandfeng/article/details/126822085