jdk静态代理和动态代理

恰子李

已于 2022-08-12 18:25:11 修改

阅读量447

点赞数

分类专栏： java基础文章标签： java

于 2022-08-11 20:59:47 首次发布

本文链接：https://blog.csdn.net/qiaziliping/article/details/126291981

版权

java基础专栏收录该内容

17 篇文章 1 订阅

订阅专栏

文章目录

jdk静态代理
- 说明
- demo 代码示例
jdk 动态代理
cglib代理
- 一篇很好的文章

jdk静态代理

说明

核心思想：目标类代码原封不动，让代理类帮帮助来完成某一个功能点；
特点：代理类和目标类必须实现同一个接口；
缺点：需要为每一个被代理的对象都创建一个代理类。

demo 代码示例

/**
 * 接口
 */
public interface IMy {
    void eat();
}
/**
 * 目标类
 */
public class My implements IMy {
    @Override
    public void eat() {
        System.out.println("--- 我要吃水果 ---");
    }
}

/**
 * 我的代理类
 */
public class MyProxy implements IMy {

    private My my;
    public MyProxy() {
        my = new My();
    }

    @Override
    public void eat() {
        System.out.println("代理---买苹果");
        my.eat();
        System.out.println("代理---垃圾丢了");
    }


    public static void main(String[] args) {
        MyProxy model = new MyProxy();
        model.eat();
    }
}

结果打印

代理---买苹果
--- 我要吃水果 ---
代理---垃圾丢了

jdk 动态代理

动态代理参考文章： https://blog.csdn.net/danchu/article/details/70146985

说明

动态代理是运行时，通过反射机制实现动态代理，能够代理实现接口的各种实现类
动态代理只能能对实现了接口的类生成代理，而不能针对普通类
JDK中生成代理对象的API，代理类所在的包：java.lang.reflect.Proxy
Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

代理机制及其特点

首先让我们来了解一下如何使用 Java 动态代理。具体有如下四步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
1. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
1. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
1. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

美中不足

Proxy只能对interface进行代理，无法实现对class的动态代理。观察动态生成的代理继承关系图可知原因，他们已经有一个固定的父类叫做Proxy，Java语法限定其不能再继承其他的父类

demo 代码示例

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class QiaProxy {
    // 接口
    interface IHello {
        void sayHello();
    }

    // 目标类
    static class Hello implements IHello {
        @Override
        public void sayHello() {
            System.out.println("hello world");
        }
    }

    // 委托类
    static class dynClass implements InvocationHandler {
        // 目标类
        Object originalObj;

        Object bind(Object originalObj) {

            this.originalObj = originalObj;
            return Proxy.newProxyInstance(originalObj.getClass().getClassLoader(), originalObj.getClass().getInterfaces(),this);
        }


        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("welcome");
            return method.invoke(originalObj,args);
        }
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //设置这个值，在程序运行完成后，可以生成代理类
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        IHello hello = (IHello)new dynClass().bind(new Hello());
        hello.sayHello();
    }

}

动态生成的代理类如下

import cc.nrbc.bschain.common.core.entity.constant.QiaProxy.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

final class $Proxy0 extends Proxy implements IHello {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("cc.nrbc.bschain.common.core.entity.constant.QiaProxy$IHello").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}