JavaSE-反射的应用-JDK代理

1、代理模式原理

由于某些原因，客户端不想或者不能直接访问一个对象，此时可以通过一个称为“代理”的第三者来实现间接访问，该方案对应的设计模式被称为代理模式。

代理模式是一种应用广泛的结构型设计模式，而且变化形式特别多，常见的代理形式有远程代理、保护代理、虚拟代理、缓冲代理、智能引用代理等。

代理模式是一种结构型模式。在代模式中引入了一个新的代理对象，代理对象在客户端对象和目标对象之间起到中介的作用，它去掉客户端不能看到的内容和服务或者添加客户端需要的额外新服务。

2、静态代理：代理只能代理某一类，不能代理多个类

特点：代理类和被代理类在编译期间，就被确定下来

//买票接口
interface ByTicket{
    void byTicketMethod();
}

//代理类：此黄牛代理类为静态代理  对应目标方法的增强
class TicketByHuangNiu implements ByTicket {

    //用被代理类对象实例化
    private ByTicket byTicket;

    //代理类构造器
    public TicketByHuangNiu(ByTicket byTicket) {
        this.byTicket = byTicket;
    }

    @Override
    public void byTicketMethod() {
        System.out.println("黄牛做一些买票的准备工作");
        byTicket.byTicketMethod();
        System.out.println("黄牛通过12306买到了票，收取20%服务费");
    }
}

//被代理类：12306网站
class TicketBy12306 implements ByTicket{
    @Override
    public void byTicketMethod() {
        System.out.println("通过12306买票");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        TicketBy12306 ticketBy12306 = new TicketBy12306();
        //创建代理类的对象
        TicketByHuangNiu ticketByHuangNiu = new TicketByHuangNiu(ticketBy12306);

        ticketByHuangNiu.byTicketMethod();
    }
}

3、动态代理

4、动态代理相对于静态代理的优点

5、动态代理举例

//代理类
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("我喜欢吃"+food);
    }
}

/**
 * 要想实现动态代理，需要解决的问题？
 * 问题一：如何根据加载到到内存中的被代理类，动态的创建一个代理类及其对象。
 * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
 */
//代理工厂，创建代理类对象
class ProxyFactory{
    //调用此方法，返回一个代理类对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);
        //返回创建代理类对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{

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

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

    //当我们通过代理类对象，调用a方法时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就要声明在invoke()方法中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值就作为当前类中invoke()的返回值
        return returnValue;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        Human human = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
        String belief = human.getBelief();
        System.out.println(belief);
        human.eat("重庆火锅");

        System.out.println("*********************************");

        TicketBy12306 ticketBy12306 = new TicketBy12306();
        ByTicket byTicketClass = (ByTicket) ProxyFactory.getProxyInstance(ticketBy12306);
        byTicketClass.byTicketMethod();
    }

}