黑马程序员_java 代理模式

------- android培训、java培训、期待与您交流！ ----------

基本概念：
    在Java程序中，代理就是在不修改源码的情况下，使得原本不具有某种行为的类对象具有该行为能力
特点：
    代理过程必须有两个实体参与，并且代理者要按照被代理者的意愿进行代理业务。
作用：
    为其他对象提供一种代理以控制对这个对象的访问。在某种情况下，一个客户不想或者不能直接引用另
    一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。
代理模式涉及到角色：
    |--抽象角色：
        声明真实对象和代理对象的公共接口
    |--代理角色
        代理角色内部含有对真实对象的引用，从而可以操作真实对象
    |--真实角色
        代理角色所代表的真实对象，使我们最终要引用的对象

静态代理：
    演示说明：
        package com.itheima.proxy;
        /*
         * 面向接口编程
         * */
        public interface MyInter {
            public abstract void info();
        }
        package com.itheima.proxy;
        /*
         * 被代理类
         * */
        public class IsArgent implements MyInter {
            public void info()
            {
                System.out.println("制造商。。。");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        package com.itheima.proxy;
        /*
         * 这是一个代理类
         * */
        public class ProxyDemo {
            private MyInter mi;
            public ProxyDemo(MyInter mi)
            {
                this.mi = mi;
            }
            public long RunTime()
            {
                long start = System.currentTimeMillis();
                //执行需要被代理的方法
                mi.info();
                long end = System.currentTimeMillis();
                return end - start;
            }
        }
        package com.itheima.proxy;
        /*
         * 测试类
         * */
        public class Test {
            public static void main(String[] args) {
                ProxyDemo pd = new ProxyDemo(new IsArgent());
                long runTime = pd.RunTime();
                System.out.println(runTime);
            }
        }   
动态代理：
    所谓动态代理类，就是通过newProxyInstance()方法，在运行时自动生成的，在生成它时，
    必须为它提供一组要实现的接口，然后该类就宣称它实现了哪些接口。
    Java动态代理类位于java.lang.reflect包下，一般主要涉及到两个类。
    |--InvocationHandler：该接口仅定义了一个方法：
        |--Object invoke(Object proxy, Method method, Object[] args)
                    在代理实例上处理方法调用并返回结果。
            proxy：指代理类
            method：被代理的方法
            args：该方法的参数
    |--Proxy：该类即为动态代理类
        |--protected  Proxy(InvocationHandler h)
            使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 Proxy 实例。
        |--static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
            返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
        |--static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
            返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
        |--
        演示说明：
            package com.itheima.dynamic.proxy;
            public interface Subject {
                public void request();
            }

            package com.itheima.dynamic.proxy;
            public class RealSubject implements Subject {
                @Override
                public void request()
                {
                    System.out.println("需要被代理的任务。。。");
                }
            }

            package com.itheima.dynamic.proxy;
            import java.lang.reflect.InvocationHandler;
            import java.lang.reflect.Method;
            public class DynamicSubject implements InvocationHandler {
                private Subject sub;
                public DynamicSubject(Subject sub)
                {
                    this.sub = sub;
                }
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable
                {
                    System.out.println("被代理执行之前：" + method);
                    method.invoke(sub, args);
                    System.out.println("被代理执行之后：" + method);
                    return null;
                }
            }

            package com.itheima.dynamic.proxy;
            import java.lang.reflect.InvocationHandler;
            import java.lang.reflect.Proxy;
            public class Test {
                public static void main(String[] args) {
                    //创建被代理类的对象
                    Subject sub = new RealSubject();
                    //创建代理类对象，并将被代理类传递进去
                    InvocationHandler handler = new DynamicSubject(sub);
                    //获取代理类的Class对象
                    Class c = handler.getClass();
                    //通过Proxy.newProxyInstance()方法，自动生成一个动态代理类实例
                    sub = (Subject)Proxy.newProxyInstance(c.getClassLoader(), sub.getClass().getInterfaces(), handler);
                    //调用方法
                    sub.request();
                    System.out.println("------------------------------------------------");
                    System.out.println("自动生成动态代理类的名字：" + sub.getClass().getName());
                    Class[] interfaces = sub.getClass().getInterfaces();
                    for(Class item : interfaces)
                        System.out.println("自动生成动态代理类所实现的接口" + item);
                   
                }
            }
            运行结果：
                被代理执行之前：public abstract void com.itheima.dynamic.proxy.Subject.request()
                需要被代理的任务。。。
                被代理执行之后：public abstract void com.itheima.dynamic.proxy.Subject.request()
                ------------------------------------------------
                自动生成动态代理类的名字：$Proxy0
                自动生成动态代理类所实现的接口interface com.itheima.dynamic.proxy.Subject

------- android培训、java培训、期待与您交流！ ----------