JDK动态代理

1、代理：

如：代购、中介、商家等等

代理类完成的功能：

1. 目标类中方法的调用
2. 功能增强

2、使用代理模式的作用

• 功能增强： 在你原有的功能上，增加了额外的功能。 新增加的功能，叫做功能增强。
• 控制访问： 代理类不让你访问目标

3、实现代理的方式

1. 静态代理 ：
   1） 代理类是自己手工实现的，自己创建一个java类，表示代理类。
   2）同时你所要代理的目标类是确定的。
   特点： 1）实现简单 2）容易理解。
   缺点：
   1）当目标类增加了，代理类可能也需要成倍的增加，代理类数量过多。
   2） 当你的接口中功能增加了，或者修改了，会影响众多的实现类，厂家类，代理都需要修改，影响比较多。
2. 动态代理
   （1）在静态代理中目标类很多时候，可以使用动态代理，避免静态代理的缺点。
   （2）动态代理中目标类即使很多：代理类数量可以很少
   当你修改了接口中的方法时，不会影响代理类
   （3）动态代理： 在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类。
   （4）动态代理的实现：
   1. jdk动态代理（理解）： 使用java反射包中的类和接口实现动态代理的功能。（反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy.）
   2. cglib动态代理（了解）: cglib是第三方的工具库， 创建代理对象。（cglib的原理是继承， cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法， 实现功能的修改。）

注意：因为cglib是继承，重写方法，所以要求目标类不能是final的， 方 法也不能是final的。cglib的要求目标类比较宽松， 只要能继承就可 以了。cglib在很多的框架中使用，比如 mybatis ，spring框架中都有 使用。
对于无接口的类，只能用cglib
（5）jdk动态代理的实现
反射包 java.lang.reflect , 里面有三个类 ：

InvocationHandler , Method, Proxy.

		1)InvocationHandler 接口（调用处理器）：就一个方法invoke（）
		   invoke（）:表示代理对象要执行的功能代码。你的代理类要完成					的功能就写在invoke()方法中。

			代理类完成的功能：
				1. 调用目标方法，执行目标方法的功能
				2. 功能增强，在目标方法调用时，增加功能。
     	方法原型：
			public Object invoke(Object proxy, Method method, Object[] args)
			参数： 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() 
		public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)			
     	参数：
		 1. ClassLoader loader：类加载器，负责向内存中加载对象的。 使用									反射获取对象的ClassLoader
		     比如：类a , a.getCalss().getClassLoader(),  目标对象的类加载器
	     2. Class<?>[] interfaces： 接口,目标对象实现的接口，也是反射获取的。
      	 3. InvocationHandler h : 我们自己写的，代理类要完成的功能。 
			返回值：就是代理对象
				作用是： 创建代理对象，等同于静态代理中的
				TaoBao taoBao = new TaoBao();

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

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

例子：

接口UsbSell

package _02_动态代理.service;

public interface UsbSell {
    float sell(int amount);
}

目标类

package _02_动态代理.factory;

import _02_动态代理.service.UsbSell;
//目标类
public class UsbKingFactory implements UsbSell {
    @Override
    //目标方法
    public float sell(int amount) {
        System.out.println("目标类中执行了目标方法sell（）");
        return 85f;
    }
}

代理类

package _02_动态代理.handler;

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

//必须实现InvocationHandler接口，完成代理类要做的事
public class MySellHandler implements InvocationHandler {
    //目标对象
    private Object target = null;
    //动态代理是活动的，传进来谁，就给谁创建代理，使用构造方法实现传入对象
    public MySellHandler(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //实现目标方法
        Object res = null;
        res = method.invoke(target,args);
        //对方法进行增强
        if (res != null){
            Float price = (Float) res;
            price += 25;
            res = price;
        }
        System.out.println("我已经增强过了！");
        return res;
    }
}

主函数

package _02_动态代理;

import _02_动态代理.factory.UsbKingFactory;
import _02_动态代理.handler.MySellHandler;
import _02_动态代理.service.UsbSell;

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

public class MainShop {
    public static void main(String[] args) {
        //创建目标对象
        UsbSell usbKingFactory = new UsbKingFactory();
        //创建InvocationHandler对象
        InvocationHandler mySellHandler = new MySellHandler(usbKingFactory);
        //创建代理对象(该方法返回一个接口)
        UsbSell proxy = (UsbSell) Proxy.newProxyInstance(usbKingFactory.getClass().getClassLoader(),
                usbKingFactory.getClass().getInterfaces(),
                mySellHandler);
        //通过代理对象执行目标类中的方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象调用方法，价格"+price);
    }
}