public class proxyTest {

    public static void main(String[] args) {

        final IProducer producer = new Producer();

//        producer.saleProduce(54200f);



        /*

          今天学习动态代理

          代理对象---producer

          字节码随用随创建，什么时候用什么时候加载

          作用：增强所需的办法，而且不改变代码（不改变办法）

          分类：基于子类的动态代理

          基于接口的动态代理

          如何创建代理对象

          s使用----

          Proxy.newProxyInstance(1，2，3)

          参数1：代理对象

          ClassLoader

          想代理谁，就写谁的类加载器，写的是被代理的类加载器，

          也就是如果这个类（IProduce类，，想代理这个类，就写这个的类对象的类加载器）

          想代理谁就写谁

          固定写法：----------->类对象（IProducer producer）.getClass().getClassLoader()

          等价于-----producer.getClass().getClassLoader()

         

          参数2：被代理对象

         

          interfaces:class[]

         

          为了代理对象和被代理对象实现相同的办法时候，参数1，2的对象必须一致

         固定写法：producer.getClass().getInterfaces()

         

          参数3：

          IncocationHandler:

          作用增强办法的内容

          或者说这个办法是如何让我们实现办法增强的逻辑办法，也就是想对这个办法增强必须再这里写，

          因为invoke(Object proxy, Method method, Object[] args)会拦截代理对象和被代理对象的所有办法（也就是拦截IProduce接口内的所有办法

          利用 if ("saleProduce".equals(method.getName())){}

          来判断是使用那个办法

         

          method.invoke(producer, money0.8f);这个是执行办法--->代理对象，

          第二个就是参数这个saleProduce办法有多少个参数就写多少个）

          ）

          返回值强转为接口类型

         /



        /

          producer.getClass()类对象.getClass()得到的是这个类的字节码----》等价于--->IProducer类.class

          /



        IProducer proxyProduce = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(), new InvocationHandler() {

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

                Float money = (Float) args[0];

                Object invoke = null;

                if ("saleProduce".equals(method.getName())) {

                    //invoke = method.invoke(producer, money 0.8);//这个出错，因为吗，money是float，所以必须加f

                    invoke = method.invoke(producer, money * 0.8f);//这个是对的

                }

                return invoke;

            }

        });

        proxyProduce.saleProduce(10000);

    }

}

public class ZLProxyTest {
    public static void main(String[] args) {
        final Producer producer=new Producer();

        /**
         * 今天学习动态代理
         * 代理对象---producer
         * 字节码随用随创建，什么时候用什么时候加载
         * 作用：增强所需的办法，而且不改变代码（不改变办法）
         * 分类：基于子类的动态代理
         * 基于接口的动态代理
         * 如何创建代理对象
         * s使用----
         * Proxy.newProxyInstance(1，2，3)
         * 参数1：代理对象字节码
         * Class
         * 想代理谁，就写谁的代理对象字节码
         * 也就是如果这个类（IProduce类，，想代理这个类，就写这个的类对象的字节码）
         * 想代理谁就写谁
         * 固定写法：----------->类对象（IProducer producer）.class
         *

         *
         * 参数2：
         * MethodInterceptor:
         * 作用增强办法的内容
         * 或者说这个办法是如何让我们实现办法增强的逻辑办法，也就是想对这个办法增强必须再这里写，
         * 因为Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         *                 return null;
         *             }会拦截代理对象和被代理对象的所有办法（也就是拦截IProduce接口内的所有办法
         * 利用 if ("saleProduce".equals(method.getName())){}
         * 来判断是使用那个办法
         *
         * Object proxy:代理对象
         * Method method:代理办法
         * Object[] args:办法所需要的参数
         * MethodProxy methodProxy:当前执行办法的对象
         * method.invoke(producer, money*0.8f);这个是执行办法--->代理对象，
         * 第二个就是参数这个saleProduce办法有多少个参数就写多少个）
         * ）
         * 返回值强转为接口类型
         */

        /*
         * producer.getClass()类对象.getClass()得到的是这个类的字节码----》等价于--->IProducer类.class
         * */
        Producer proxyProduce= (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Float money = (Float) args[0];
                Object invoke = null;
                if ("saleProduce".equals(method.getName())) {
                    //invoke = method.invoke(producer, money * 0.8);//这个出错，因为吗，money是float，所以必须加f
                    invoke = method.invoke(producer, money * 0.8f);//这个是对的
                }
                return invoke;
            }
        });
        proxyProduce.saleProduce(10000);
    }
}