java反射的应用：动态代理和静态代理

代理设计模式的原理：

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

• 静态代理：

特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过以恶代理类完成全部的代理功能。

• 动态代理：

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

• 动态代理相比静态代理的优点
  抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和同意的处理众多的方法

静态代理代码实现

package com.example.leardemo.refiex;

/**
 * 静态代理
 *
 * @Auther: qiuhongyu
 * @Date: 2021/06/30/11:04
 */
interface ClothFactory {
    void produceCloth();
}

/**
 * 代理类
 */
class ProxyClothFactory implements ClothFactory {

    //用被代理对象进行实例化
    private ClothFactory factory;

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些收尾工作");
    }

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }
}

/**
 * 被代理类
 */
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("nike生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        ClothFactory nikeClothFactory = new NikeClothFactory();
        //创建代理类对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);
        proxyClothFactory.produceCloth();

    }
}

运行的结果

动态代理代码实现

package com.example.leardemo.refiex2;

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

/**
 * 动态代理
 *
 * @Auther: qiuhongyu
 * @Date: 2021/06/30/11:23
 */

interface Human {

    String getBelief();

    void eat(String food);


}

/**
 * 被代理类
 */
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("I like eat:" + food);

    }
}


/**
 * 动态创建代理类
 */
class ProxyFactory{
    //通过此静态方法返回一个代理类对象
    public static Object getProxyInstance(Object obj) {//obj被代理类对象
        MyInvocationHandler handle = new MyInvocationHandler();
        handle.bind(obj);
        Object proxy = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handle);
        return proxy;
    }
}

class MyInvocationHandler implements InvocationHandler {
    //需要使用被代理类的对象进行赋值
    private Object obj;

    public void bind(Object object) {
        this.obj = object;

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(obj, args);
        return invoke;
    }
}


public class ProxyTest {

    public static void main(String[] args) {
        //被代理类
        SuperMan superMan = new SuperMan();
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("chongqing huoguo");

    }
}

运行的结果