动态代理-JDK

1、什么是代理模式

  代理模式是指，为其他对象提供一种代理，以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。
                        百度百科《代理模式》

  换句话说， 使用代理对象，是为了在不修改目标对象的基础上， 增强主业务逻辑。

客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。
客户类对目标对象的访问是通过访问代理对象来实现的。当然，代理类与目标类要实现同一个接口，也就是说，他们要实现的功能是一样的。
  例如：有 A， B， C 三个类， A 原来可以调用 C 类的方法， 现在因为某种原因 C 类不允许A 类调用其方法，但 B 类可以调用 C 类的方法。 A 类通过 B 类调用 C 类的方法。这里 B 是 C的代理。 A 通过代理 B 访问 C，既可以实现访问C的功能，同时也可以在B中增加新的业务功能.

1.1 代理模式作用

A、 控制访问
B、 增强功能

1.2代理模式分类

1、静态代理
2、动态代理

2、静态代理

2.1 静态代理的理解

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

2.2 需求

  用户需要购买 u 盘， u 盘厂家不单独接待零散购买，用户可以通过淘宝的代理商，或者微商那里进行购买。
  淘宝上的商品，微商都是 u 盘工厂的代理商， 他们代理对 u 盘的销售业务。
用户购买-------代理商（淘宝，微商） ----- u 厂家（金士顿，闪迪等不同的厂家）

  设计这个业务需要的类：

1. 商家和厂家都是提供 sell 购买 u 盘的方法。定义购买 u 盘的接口 UsbSell
2. 金士顿（King）厂家，定义 UsbKingFactory 类，实现 UsbSell接口
3. 闪迪（San）厂家，定义 UsbSanFactory 类，实现 UsbSell
4. 定义淘宝的代理商 TaoBao ，实现 UsbSell
5. 定义微商的代理商 WeiShang, 实现 UsbSell
6. 定义测试类，测试通过淘宝， 微商购买 u 盘

  以上，厂家是目标类，商家是代理，用户是客户端类，模拟一个用户购买u盘的行为。三者的关系： 用户（客户端）—商家（代理）—厂家（目标）。
    代理类完成的功能：
        1. 目标类中方法的调用
        2. 功能增强

2.3代码实现

1、UsbSell接口是厂家和代理商需要实现的功能：卖U盘
2、factory包中是厂家，也就是我们的目标类
3、shangjia包中是代理类：TaoBao和WeiShang，也就是代理类
4、ShopMan：测试类

/**
 * 接口：表示功能的，厂家商家都要实现的功能
 */
public interface UsbSell {
    //定义方法，参数 amount：表示一次购买的数量，暂时不用
    //返回值表示一个u盘的价格
    public  float sell(int amount);
    //还可以多个其它的方法
    //void print();
}

//目标类1：金士顿厂家， 不接受用户的单独购买
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        System.out.println("目标类中的方法调用，useKingFactory中的sell()");
        //一个128G的U盘，85元
        //后期根据amount。可以实现不同的价格
        return 85.0f;
    }
}

//淘宝是一个商家，代理金士顿U盘的销售
public class TaoBao implements UsbSell {
    //声明商家代理的厂家（目标类）具体是谁
    private UsbSell usbSell=new UsbKingFactory();
   //实现销售U盘的功能，
    @Override
    public float sell(int amount) {

        //向厂家发送订单，告诉厂家，我买了U盘，厂家发货
        float price = usbSell.sell(amount);     //厂家的价格
        //代理加价      增加功能 price=prce+25;代理类在完成目标方法调用后，增强了功能
        //在目标类的方法调用之后，你做的其他功能，都是增强的意思
        System.out.println("淘宝商家，给你返回一个优惠券或者红包");
        return price+25;
    }
}

//测试类
public class ShopMan {
    public static void main(String[] args) {
        //创建代理的商家TaoBao对象
      TaoBao taoBao = new TaoBao();
        float price = taoBao.sell(1);       //商家卖了一个u盘【给man】
        System.out.println("通过淘宝的商家，购买U盘单价为： " + price);

       /* WeiShang weiShang = new WeiShang();
        //通过代理类实现购买u盘，增加了其他功能
        float price = weiShang.sell(1);
        System.out.println("通过微商购买的价格是：" + price);*/
    }
}

再简述一下 实现步骤：
   1. 创建一个接口，定义卖u盘的方法， 表示你的厂家和商家做的事情。
   2. 创建厂家类，实现1步骤的接口
   3. 创建商家类，就是代理类，也需要实现1步骤中的接口。
   4. 创建客户端类，调用商家的方法买一个u盘。

2.4 再次阐述特点

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

3、动态代理

1. 什么是动态代理 ？

  使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件。

  动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象。

  jdk动态代理，必须有接口，目标类必须实现接口， 没有接口时，需要使用cglib动态代理

2. 动态代理能做什么

  在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码。

程序开发中的意思。
   比如：你所在的项目中，有一个功能是其他人（公司的其它部门，其它小组的人）写好的，你可以使用：

GongNeng.class ,  
GongNeng gn = new GongNeng (), 		
 gn.print();

  你发现这个功能，现在还缺点， 不能完全满足我项目的需要。 我需要在gn.print()执行后，需要自己在增加代码。我们没有源代码，也不能改变人家的代码用代理实现 gn.print（）调用时， 增加自己代码， 而不用去改原来的 GongNeng 文件。

3、动态代理特点

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

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

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

4、JDK动态代理的实现

jdk动态代理：必须有接口

   jdk动态代理的实现
	   反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.
		**

1)InvocationHandler 接口（调用处理器）：就一个方法invoke（）

	invoke（）:表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。

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

     方法原型：
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
		参数： 	Object proxy:	jdk创建的代理对象，无需赋值。
		        Method method:	目标类中的方法，jdk提供method对象的
             	Object[] args：	目标类中方法的参数， jdk提供的。
             	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： 接口，目标对象实现的接口，也是反射获取的。
				Factory.getClass().getInterFaces()
         3. InvocationHandler h : 我们自己写的，代理类要完成的功能。 

		返回值：就是代理对象
		方法原型
		public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

具体实现步骤

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

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

5、代码实现动态代理

 * //表示功能的，厂家商家都要实现的功能
public interface UsbSell {
    //定义方法，参数 amount：表示一次购买的数量，暂时不用
    //返回值表示一个u盘的价格
    public  float sell(int amount);
    //可以多个其它的方法
    //void print();
}

//目标类：金士顿厂家， 不接受用户的单独购买
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        //目标方法
        System.out.println("目标类中执行了sell()目标方法，useKingFactory中的sell()");
        //一个128G的U盘，85元
        //后期根据amount。可以实现不同的价格
        return 85.0f;
    }
}

//必须实现InvocationHandler接口，完成代理类要实现的功能(调用目标方法、增强功能)
public class MySellHandler implements InvocationHandler {
    //定义动态目标类的对象，用构造方法传进来
    private Object target=null;
    //动态代理，目标对象是活动的，不是固定的，需要传入进来，
    // 传入的是谁，就给谁创建代理
    public MySellHandler(Object target) {
        //给目标对象赋值
        this.target = target;
    }

    /**
     *     invoke（）:表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke()方法中。
     *     代理类完成的功能：
 *              1. 调用目标方法，执行目标方法的功能
 * 			    2. 功能增强，在目标方法调用时，增加功能。
     *
     * @param proxy     jdk创建的代理对象，无需赋值。
     * @param method    目标类中的方法，jdk提供method对象的
     * @param args      目标类中方法的参数， jdk提供的。
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //接收目标方法执行后的返回值
        Object res =null;
        //向厂家发送订单，告诉厂家，我买了U盘，厂家发货
        //float price = factory.sell(amount);     //厂家的价格
        System.out.println("before");
        res = method.invoke(target, args);   //method代替调用目标方法，目标类是动态创建的
        System.out.println("after");    //证明已经上一句代码调用了目标类里面的方法

        //代理加价      增加功能 price=prce+25;代理类在完成目标方法调用后，增强了功能
        //在目标类的方法调用之后，你做的其他功能，都是增强的意思
        System.out.println("淘宝商家，给你返回一个优惠券或者红包");
//        return price+25;
        if (res!=null) {
            float price= (float) res+25;
            res=price;
        }

       //增加新的功能//
        return res;
    }
}

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

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

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

 返回值：就是代理对象

 */
public class MainShop {
    public static void main(String[] args) {
//        使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

        //1、创建目标类的对象
        UsbSell factory = new UsbKingFactory();
        //2、创建InvacationHandler对象       调用方法，功能增强
//        InvacationHandler handler = new MySellHandler(factory);

        //3、给factory动态创建代理对象，并把它返回值转为接口类型（便于调用目标类里面的方法）
        UsbSell proxy=      //返回值是代理对象TaoBao
                (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                        factory.getClass().getInterfaces(),
                        new MySellHandler(factory));

        System.out.println("proxy = " + proxy.getClass().getName());
        //proxy = com.sun.proxy.$Proxy0 一定是JDK的动态代理创建的对象类型

        //通过代理对象，一层一层调用方法
        float price = proxy.sell(1);
        System.out.println(" 通过动态代理对象，调用方法：price=  " + price);
    }
}

4、cgLib 代理

  CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。它广泛的被许多 AOP 的框架使用，例如 Spring AOP。
  使用 JDK 的 Proxy 实现代理，要求目标类与代理类实现相同的接口。若目标类不存在接口， 则无法使用该方式实现。
  但对于无接口的类，要为其创建动态代理，就要使用 CGLIB 来实现。 CGLIB 代理的生成原理是生成目标类的子类，而子类是增强过的，这个子类对象就是代理对象。 所以， 使用CGLIB 生成动态代理，要求目标类必须能够被继承，即不能是 final 的类。cglib 经常被应用在框架中，例如 Spring ， Hibernate 等。 Cglib 的代理效率高于 Jdk。对
于 cglib 一般的开发中并不使用。做了一个了解就可以。