动态代理

复习反射

反射的定义：在运行状态时(动态的)，对于任意一个类，都能够得到这个类的所有属性和方法。对于任意一个对象，都能够调用它的任意属性和方法。这种动态获取的信息以及动态调用对象的方法的功能称之为java语言的反射机制.

反射的三种用法

public class ClassDemo02 {

     public static void main(String[] args) {
          Person p1 = new Person("小明" ,20,'男' );
          Person p2 = new Person("小红" ,23,'女' );

           //创建Class对象的方式一：(对象.getClass())，获取person类中的字节码文件
           Class class1 = p1.getClass();
          System. out.println(p1.getClass().getName());
           Class class2 = p2.getClass();
          System. out.println(class1 == class2 );

          System. out.println("==============================" );
           //创建Class对象的方式二：(类.class:需要输入一个明确的类，任意一个类型都有一个静态的class属性)
           Class class3 = Person.class;
          System. out.println(class1 == class2);

          System. out.println("==============================" );
           //创建Class对象的方式三：(forName():传入时只需要以字符串的方式传入即可)
           //通过Class类的一个forName（String className)静态方法返回一个Class对象，className必须是全路径名称；
           //Class.forName()有异常：ClassNotFoundException

           Class class4 = null;
           try {
              class4 = Class.forName("cn.itcast.Person");
          } catch (ClassNotFoundException e) {
               // TODO Auto-generated catch block
              e.printStackTrace();
          }
          System. out.println(class4 == class3);
     }
}

动态代理

对于JDK动态代理，其必须要有接口
代码案例
接口

package bjpowernode;

public interface HelloService {
     void sayhello(String name);
}

方法HelloServiceimpl

package bjpowernode.Service;

import bjpowernode.HelloService;

public class HelloServiceimpl implements HelloService {
    @Override
    public void sayhello(String name) {
        System.out.println("你好："+name);
    }
}

被代理的方法TestApp

package bjpowernode;

import bjpowernode.Service.HelloServiceimpl;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestApp {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        HelloService service = new HelloServiceimpl();

        service.sayhello("zhangsan");



        //使用反射机制执行sayhello方法
        HelloService target = new HelloServiceimpl();
        //获取hello名称对饮的Method类对象
        //关于.class.getMethod()方法：作用是获得对象所声明的公开方法,该方法的第一个参数name是要获得方法的名字，第二个参数parameterTypes是按声明顺序标识该方法形参类型。
        //在sayhello方法中,方法的类型是String，因此第二个参数为String.class
        Method method = HelloService.class.getMethod("sayhello", String.class);


        //通过method可以调用sayhello方法
		//表达的意思是method方法执行的对象是sayhello，参数是李四
        method.invoke(target,"李四");
    }
}

动态代理分析
反射包 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 h)

动态代理实现步骤

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

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

代码

package Service;

import Service.Handler.MySellHandler;

import java.lang.reflect.Proxy;

public class MainShop {
    public static void main(String[] args) {
        //创建代理对象，使用proxy
        UsbSell factory = new UsbKingFactory();

        //



        //创建InvocationHandler对象

        MySellHandler handler = new MySellHandler(factory);
        //创建目标对象
        UsbSell proxy_1 = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), handler);



        //通过代理执行方法
        float sell = proxy_1.sell(1);
        System.out.println("通过动态代理得到的结果"+sell);
    }
}