基于jdk的动态代理

- 日理万妓 2023-02-15 12:34 179阅读 0赞

### 文章目录 ###

*  一. 问题背景
 *  二. 基于jdk的动态代理
 *   *  2.1 获取代理对象的2个方法
     *   *  2.1.1 getProxyClass(ClassLoader loader,Class<?>... interfaces)
         *  2.1.2 newProxyInstance(ClassLoader loader,Class<?>\[\] interfaces, InvocationHandler h)
     *  2.2 原理分析
     *  2.3 例子：使用newProxyInstance()实现动态代理
     *  2.4 例子：使用getProxyClass()实现动态代理

# 一. 问题背景 #

复习spring的时候涉及到动态代理，主要是基于接口的jdk自带的动态代理。采用jdk自带的Proxy类实现。

# 二. 基于jdk的动态代理 #

**动态代理：使用代理对象去包装目标对象（即原始对象）。目标对象有的东西，代理对象也都有（即代理对象实现目标对象的所有接口或继承目标对象的所有类）。**

## 2.1 获取代理对象的2个方法 ##

jdk自带Proxy类，这是所有代理类的父类。我们就是通过它的2个方法实现动态代理

### 2.1.1 getProxyClass(ClassLoader loader,Class<?>… interfaces) ###

获取代理类，然后可以使用代理类创建代理对象（使用反射创建对象）

public static Class<?> getProxyClass(ClassLoader loader,
                                             Class<?>... interfaces)

### 2.1.2 newProxyInstance(ClassLoader loader,Class<?>\[\] interfaces, InvocationHandler h) ###

直接获取到代理类

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)

## 2.2 原理分析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]

## 2.3 例子：使用newProxyInstance()实现动态代理 ##

需求：一个计数器，加减乘除，计算前后实现日志输出

代码如下：  
Calculate.java

package com.atguigu;
    
    public interface Calculate { 
    
        public int add(int i, int j);
        public int sub(int i, int j);
        public int mul(int i, int j);
        public int div(int i, int j);
    }

CalculateImpl.java

package com.atguigu;
    
    public class CalculateImpl implements Calculate { 
        @Override
        public int add(int i, int j) { 
            return (i+j);
        }
    
        @Override
        public int sub(int i, int j) { 
            return (i-j);
        }
    
        @Override
        public int mul(int i, int j) { 
            return (i*j);
        }
    
        @Override
        public int div(int i, int j) { 
            return (i/j);
        }
    }

CalculateProxy.java

package com.atguigu;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.Type;
    import java.util.Arrays;
    
    /** * 编写代理过程 */
    public class CalculateProxy { 
        //1.目标对象 //2.代理对象
    
        Calculate target;
    
        public CalculateProxy(Calculate target) { 
            this.target = target;//将外部传入的target赋给当前类的目标对象
        }
    
        //获取代理对象
        public Object getProxy() { 
            Object proxy = null;//代理对象
    
            //获取目标对象的class对象，方便后面使用反射
            Class cls = target.getClass();
    
            //获取类加载器
            ClassLoader loader = cls.getClassLoader();
            //获取CalculateImpl实现了哪些接口
            Class[] interfaces = cls.getInterfaces();
    
    
            //使用Proxy的newProxyInstance()方法创建代理对象
            proxy = Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() { 
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
                    Object result = method.invoke(target, args);//将方法调用转回目标对象（原始对象）
                    System.out.println("The method " + method.getName() + " ends with " + result);
                    return result;
                }
            });
    
            return proxy;
        }
    }

Main.java

@Test
        public void test9() throws Exception { 
    
            Calculate target = new CalculateImpl();//先获取目标对象
    
            Object object = new CalculateProxy(target).getProxy();//获取代理对象
    
            Calculate proxy = (Calculate) object;//强转类型：必须转为接口类型，不能转为接口的实现类
    
            int result = proxy.add(2, 3);
    
            System.out.println("result:" + result);
    
        }

结果如下：  
![在这里插入图片描述][2020060511515049.png]

## 2.4 例子：使用getProxyClass()实现动态代理 ##

公用代码如上，有需要修改的代码如下：

//获取代理对象
        public Object getProxy() throws Exception { 
            Object proxy = null;//代理对象
    
            //获取目标对象的class对象，方便后面使用反射
            Class cls = target.getClass();
    
            //获取类加载器
            ClassLoader loader = cls.getClassLoader();
            //获取CalculateImpl实现了哪些接口
            Class[] interfaces = cls.getInterfaces();
    
            Class<?> proxyClass = Proxy.getProxyClass(loader, interfaces);
    
            //使用反射创建代理对象
            Constructor<?> declaredConstructor =
                    proxyClass.getDeclaredConstructor(InvocationHandler.class);
    
            proxy = declaredConstructor.newInstance(new InvocationHandler() { 
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
                    Object result = method.invoke(target, args);//将方法调用转回目标对象（原始对象）
                    System.out.println("The method " + method.getName() + " ends with " + result);
                    return result;
                }
            });
    
            return proxy;
    
        }

**注意：获取到代理类时，不能直接使用反射的newInstance()创建代理对象，因为生成出来的代理类是有一个有参构造方法必须传入一个InvocationHandler。所以我们要先使用代理类的class对象获取该有参构造器（带形参InvocationHandler），然后使用构造器newInstance（要传入一个形参InvocationHandler）。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200605114814657.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2,size_16,color_FFFFFF,t_70
[2020060511515049.png]: https://img-blog.csdnimg.cn/2020060511515049.png