java反射の动态代理与静态代理-蒲公英云

java反射の动态代理与静态代理

桃扇骨 2022-08-23 03:50 282阅读 0赞

静态代理弊端：

之前博客中有讲静态代理机制的，特征是代理类和目标对象的类都是在编译期间确定下来的，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理

最好可以通过一个代理类完成全部代理功能

动态代理

定义

动态代理是指客户通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

使用场合

调试

远程方法调用

代理设计模式的原理

使用一个代理将对象包装起来（对象成为代理类属性），然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上

3.动态代理--反射的应用，体会反射的动态性

静态代理：

要求被代理类和代理类同时实现相应的一套接口；

通过被代理类的对象调用重写接口的方法时，直接上执行的是被代理类的同样的方法调用

动态代理：

反射的动态性

在程序运行时根据被代理类及其实现的接口，动态的创建一个代理类，当调用代理类实现的抽象方法时，就发起对被代理类方法的调用。

技术点

实现了InvocationHandler接口实现类，并重写invoke()方法

Proxy.newInstance(obj.getClass.getClassLoader,obj.getClass().getInterfaces(),h); obj是被代理类的对象h是实现了InvocationHandler接口实现类的对象

package myNetDemo;
//静态代理模式
//接口
interface ClothesFactory {
    void productCloth();
}
// 被代理类
class NikeClothFactory implements ClothesFactory {
    @Override
    public void productCloth() {
        System.out.println("Nike工厂生产衣服");
    }
}
// 代理类
class ProxyFactory implements ClothesFactory {
    ClothesFactory cf;// 虽然声明的是总接口，但实例化时实际传进去的是具体被代理实现类
    // 在构造器内完成初始化
    public ProxyFactory(ClothesFactory cf) {
        this.cf = cf;
    }
    @Override
    public void productCloth() {
        System.out.println("代理类开始执行，收代理费");
        cf.productCloth();// 实际调用的是实际被代理类的实现方法
    }
}
public class TestProductClothes {
    public static void main(String[] args) {
        NikeClothFactory nikeClothFactory = new NikeClothFactory();// 创建被代理类的对象
        ProxyFactory pFactory = new ProxyFactory(nikeClothFactory);// 创建爱你代理类的对象
        pFactory.productCloth();// 实际调用的是被代理类方法
        // 若再有一个接口，还要在于一个接口的实现类（被代理类，目标类），在造一个代理类实现接口
        // 于是想要动态代理
    }
}
package myNetDemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理的使用
//反射式动态语言的关键，不在编译的时候，而是在运行的时候动态的创建被代理类
interface Subject {
    void action();
}
// 被代理类
class RealSubject implements Subject {
    @Override
    public void action() {
        System.out.println("我是被代理类");
    }
}
// 凡是与动态代理相关的必须要实现这个接口，实现这个接口的抽象方法
class MyInvocationHandler implements InvocationHandler {
    Object obj;// 实现了接口的被代理类的对象的声明
    // 方法有两个作用①创建代理类时初始化被代理类对象②返回一个代理类对象
    // ①给被代理类的对象实例化②返回一个代理类的对象
    public Object blind(Object object) {
        this.obj = object;
        // ②返回一个代理类的对象()
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), this);// h第三个参数，指的是实现了InvocationHandler接口的对象
    }
    // 当通过代理类的对象发起对被重写的方法的调用时，都对转化为对如下的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 抽象方法的返回值，method方法的返回值.返回定义抽象接口的对象
        Object returnVal = method.invoke(obj, args);
        return returnVal;
    }
}
public class TestProxy {
    public static void main(String[] args) {
        //被代理类的对象
        RealSubject real=new RealSubject();
        //创建一个实现了InvacationHandler接口的对象
        MyInvocationHandler handler=new MyInvocationHandler();
        //调用blind方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
        Object obj=handler.blind(real);//返回定义接口的对象
        Subject sub=(Subject)obj;//此时的sub就是代理类的对象
        sub.action();//转到对InvacationHandler实现类的invoke方法的调用
        //在举一例
        NikeClothFactory nike=new NikeClothFactory();
        ClothesFactory proxyCloth=(ClothesFactory)handler.blind(nike);//proxyCloth即为代理类的对象
        proxyCloth.productCloth();
    }
}