Java Spring AOP 代理模式解析

红太狼 2022-10-15 13:59 185阅读 0赞

# 代理 #

1.  静态代理
2.  动态代理

## 1. 静态代理 ##

![在这里插入图片描述][20210525111147991.jpg]

public class TestProxy {
        
        public static void main(String[] args) {
        
            // 顾客与中介联系
            Agent agent = new Agent();
            // 中介联系商店
            agent.setAppleStore(new AppleStore());
            // 顾客买到商品
            agent.sell();
        }
    }
    
    interface Store {
        
        public void sell();
    }
    
    class AppleStore implements Store {
        
        public void sell() {
        
            System.out.println("Sell a apple");
        }
    }
    
    class Agent implements Store {
        
    
        private AppleStore appleStore;
    
        public void setAppleStore(AppleStore appleStore) {
        
            this.appleStore = appleStore;
        }
    
        public void sell() {
        
            System.out.println("I'm an agent who provides services for a fee.");
            appleStore.sell();
        }
    }
    
    ------ 输出 ------
    I'm an agent who provides services for a fee.
    Sell a apple

1.  java实现逻辑
    
    1.  创建一个接口
    2.  中介与商店都实现该接口(或是继承关系)
    3.  中介的通过实现接口(重载覆盖)的方式，添加中介的执行过程
    4.  顾客调用中介的方法，完成任务

## 动态代理方式 ##

1.  动态代理也是通过类似于静态代理的方式，只不过实现逻辑是通过反射的原理，自动创建一个中介类
2.  动态代理的实现方式
    
     *  基于接口 — JDK动态代理 (主要解释该过程)
     *  基于类：cglib
     *  java字节码实现：javassist
3.  裸代码如下

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class client {
        
        public static void main(String[] args) {
        
            Host host = new Host();
            proxy proxy1 = new proxy();
            proxy1.setRent(host);
            Rent proxy = (Rent) proxy1.getProxy();
            proxy.rent();
        }
    }
    
    interface Rent {
        
        public void rent();
    }
    
    class Host implements Rent{
        
        public void rent(){
        
            System.out.println("Host is going to rent his house.");
        }
    }
    class proxy implements InvocationHandler {
        
        private Rent rent;
        public void setRent(Rent rent) {
        
            this.rent = rent;
        }
        public Object getProxy() {
        
            return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("get_proxy() run");
            // 此语句执行房东的语句
            Object result = method.invoke(rent, args);
            seeHouse();
            takeFee();
            return result;
        }
        private void takeFee() {
        
            System.out.println("proxy take fee");
        }
        private void seeHouse() {
        
            System.out.println("The agent showed the tenant the house.");
        }
    }
    
    ---- 输出 ----
    get_proxy() run
    Host is going to rent his house.
    The agent showed the tenant the house.
    proxy take fee.

### 源代码解析 ###

1.  首先通过getProxy生成一个动态Proxy对象
2.  该对象通过 `newProxyInstance` 方法创建
3.  源码中 `java.lang.reflect.Proxy`
    
        729      final Constructor<?> cons = cl.getConstructor(constructorParams);
        730      final InvocationHandler ih = h;
        731      if (!Modifier.isPublic(cl.getModifiers())) {
              
        732         AccessController.doPrivileged(new PrivilegedAction<Void>() {
              
        733             public Void run() {
              
        734                 cons.setAccessible(true);
        735                 return null;
        736             }
        737         });
        748      }
        739      return cons.newInstance(new Object[]{
              h});
4.  getContonstuctor 和 newInstance 创建对象
5.  cl 是来自java.lang.reflect.WeakCache 这个库中，使用BiFunction通过classLoader 和 interfaces参数，生成一个类存入内存中
    
        // create subKey and retrieve the possible Supplier<V> stored by that
            // subKey from valuesMap
            Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
            Supplier<V> supplier = valuesMap.get(subKey);
            Factory factory = null;
        
            while (true) {
                if (supplier != null) {
                    // supplier might be a Factory or a CacheValue<V> instance
                    V value = supplier.get();
                    if (value != null) {
                        return value;
                    }
                }
6.  生成类的过程包含生成类的字节码（java.lang.reflect.Proxy），和通过字节码构建类的过程
    
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                        proxyName, interfaces, accessFlags);
                    try {
                        return defineClass0(loader, proxyName,
                                            proxyClassFile, 0, proxyClassFile.length);
7.  其中 defineClass0 是一个native Method，本质是C 语言的代码，可在 Openjdk中  
    `src\share\native\java\lang\reflect\Proxy.c`中找到
8.  通过(getMethod, invoke方法)反射调用方法rent，在其中就能加入中介自己的方法了

*  参考 `https://www.cnblogs.com/chinajava/p/5880870.html`
 *  参考 `https://blog.csdn.net/weixin_43973404/article/details/113094312`

[20210525111147991.jpg]: /images/20221014/f3747ac7e01c41abb2d0902ccd283ee0.png