动态代理

动态代理

使用代理模式的作用
  1.功能增强： 在你原有的功能上，增加了额外的功能。 新增加的功能，叫做功能增强。
  2.控制访问： 代理类不让你访问目标，例如商家不让用户访问厂家。

1.静态代理 ：

1） 代理类是自己手工实现的，自己创建一个java类，表示代理类。
2）同时你所要代理的目标类是确定的。
特点： 1）实现简单 2）容易理解。
缺点：当你的项目中，目标类和代理类很多时候，有以下的缺点：
1）当目标类增加了， 代理类可能也需要成倍的增加。 代理类数量过多。
2） 当你的接口中功能增加了， 或者修改了，会影响众多的实现类，厂家类，代理都需要修改。影响比较多。

2.动态代理
在静态代理中目标类很多时候，可以使用动态代理，避免静态代理的缺点。
动态代理中目标类即使很多， 1）代理类数量可以很少， 2）当你修改了接口中的方法时，不会影响代理类。

动态代理： 在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类。
换句话说： 动态代理是一种创建java对象的能力，让你不用创建TaoBao类，就能创建代理类对象。

在java中，要想创建对象：
1.创建类文件， java文件编译为class
2.使用构造方法，创建类的对象。

动态代理的实现： 1. jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。
反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.

2. cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。
cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中
重写父类中同名的方法， 实现功能的修改。

因为cglib是继承，重写方法，所以要求目标类不能是final的， 方法也不能是final的。cglib的要求目标类比较宽松， 只要能继承就可以了。cglib在很多的框架中使用，比如 mybatis ，spring框架中都有使用。

jdk动态代理：
1. 反射， Method类，表示方法。类中的方法。 通过Method可以执行某个方法。

2. jdk动态代理的实现
反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.
1)InvocationHandler 接口（调用处理器）：就一个方法invoke（）
invoke（）:表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。

代理类完成的功能：
1. 调用目标方法，执行目标方法的功能
2. 功能增强，在目标方法调用时，增加功能。

方法原型：
参数： Object proxy:jdk创建的代理对象，无需赋值。
Method method:目标类中的方法，jdk提供method对象的
Object[] args：目标类中方法的参数， jdk提供的。

public Object invoke(Object proxy, Method method, Object[] args)

InvocationHandler 接口：表示你的代理要干什么。
怎么用： 1.创建类实现接口InvocationHandler
2.重写invoke（）方法， 把原来静态代理中代理类要完成的功能，写在这。

2）Method类：表示方法的， 确切的说就是目标类中的方法。
作用：通过Method可以执行某个目标类的方法，Method.invoke();
method.invoke(目标对象，方法的参数)
Object ret = method.invoke(service2, "李四");

说明： method.invoke（）就是用来执行目标方法的，等同于静态代理中的
//向厂家发送订单，告诉厂家，我买了u盘，厂家发货
float price = factory.sell(amount); //厂家的价格。

3）Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()
现在我们是使用Proxy类的方法，代替new的使用。

方法： 静态方法 newProxyInstance()
作用是： 创建代理对象， 等同于静态代理中的TaoBao taoBao = new TaoBao();

参数：
1. ClassLoader loader 类加载器，负责向内存中加载对象的。 使用反射获取对象的ClassLoader类a , a.getCalss().getClassLoader(), 目标对象的类加载器
2. Class<?>[] interfaces： 接口， 目标对象实现的接口，也是反射获取的。
3. InvocationHandler h : 我们自己写的，代理类要完成的功能。

返回值：就是代理对象

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

3. 实现动态代理的步骤：
1. 创建接口，定义目标类要完成的功能
2. 创建目标类实现接口
3. 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
1.调用目标方法
2.增强功能

4.使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

 

 

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

public interface ClothFactory {
    void produceCloth();
}

//被代理类
public class AnTaClothFactory implements ClothFactory{
    @Override
    public void produceCloth() {
        System.out.println("安踏工作生产产品！");
    }
}

//代理类
public class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory;
    public ProxyClothFactory (ClothFactory factory){
        this.factory = factory;
    }
    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些收尾工作");
    }
}

public class StaticProxyTest {
    @Test
    public void proxyTest(){
        ClothFactory anTa = new AnTaClothFactory();
        ClothFactory proxyClothFactory = new ProxyClothFactory(anTaClothFactory);
        proxyClothFactory.produceCloth();
    }
}

动态代理

public class ProxyTest {
    /**
     * 要想实现动态代理，需要解决的问题？
     * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
     * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
     */
    @Test
    public void proxyTest(){
        SuperMan superMan = new SuperMan();
        //superInstance:代理类的对象
        Human superInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        superInstance.eat("小孩");//超人喜欢吃小孩
        SpiderMan spiderMan = new SpiderMan();
        Human spiderInstance = (Human) ProxyFactory.getProxyInstance(spiderMan);
        spiderInstance.eat("小丑");//蜘蛛侠喜欢吃小丑

        System.out.println("*****************************");
        AnTaClothFactory nikeClothFactory = new AnTaClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();//安踏工作生产产品！
    }
}

public interface Human {
    String getName();
    void eat(String food);
}

//被代理类
public class SpiderMan implements Human{
    @Override
    public String getName() {
        return "蜘蛛侠";
    }
    @Override
    public void eat(String food) {
        System.out.println(getName()+"喜欢吃"+food);
    }
}

//被代理类
public class SuperMan implements Human{
    @Override
    public String getName() {
        return "超人";
    }
    @Override
    public void eat(String food) {
        System.out.println(getName()+"喜欢吃"+food);
    }
}

//代理工厂
public class ProxyFactory {
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        Object o = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
        return o;
    }
}

public 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:纪委代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj, args);
        //上述方法的方绘制就作为当前类中的invoke()的返回值
        return returnValue;
    }
}