代理模式

 生活中的代理：

       每个歌星都有自己的代理人， 歌星有自己的事业:唱歌。

         每次开演唱会， 前期要 宣传，广告，手续，等等。。。  完会又要  结账，收钱，给会场方交手续费，交税等等。。

         如果歌星没有代理，每次开演唱会  管这些 繁琐的手续 就会让他累死。。。

 

java 中的代理：

       有接口  ： 具体要做的事 (歌唱)

       有实现类 ： 做事的不同的实现 （要唱哪些歌）

       有代理 ： 处理 执行接口方法时 额外的流程 （宣传，广告，手续，结账，交税...）

 

 

代理模式形成条件
    1.有多个实现类实现了一个接口中的某个方法

     2.在调研实现类的方法 之前 之后 还有一些必须的事情要做
    

    代理类 亦是该接口的实现类，但代理类 不直接 实现接口中的方法，而是调用原有实现类进行实现

    代理类，作为接口的代理， 在执行接口中方法的实现时 调用具体接口的实现类

 

 

    例子:
   
  

    public interface Sing
    {
        public void singing();
    }

    public class Singer implements Sing
    {

       // 实现歌唱的方法
        public void singing()
        {
            // 具体唱什么歌 略...
        }

    }

    public class SingerAgent implements Sing    {

        private Object singerObj; // 被代理的对象

        public SingerAgent(Object obj) // 通过构造方法传入 被代理 的对象，也可以通过 set 方法
        {
            this.singerObj = obj;
        }

        public void singing()
        {
            System.out.println("开演唱会前     宣传，安排会场......");
            agentObject.sayHello();  // 执行具体实现类的方法
            System.out.println("开演唱会后     结账，交税......");
        }

    }

    public class Test()
    {

        public static void main(String []  args)
        {
            // 直接调用实现类的方法
            Sing singer1 = new Singer();
            singer1.singing();

            // 使用代理调用实现类的方法，在这种场景下我们可以在
            // 代理类的方法中 显示 的控制是否执行在执行具体实现的 前后 执行其它事情...
            Human human2 = new ManAgent ( new Man() );
            human2.sayHello();
        }

    }

 

   
    从上面我们可以看出来，代理就是在接口实现类方法执行之前让代理来做一部分操作。
    就是将这个方法的主动权交给了代理，由代理来决定什么时候执行它，执行前后有什么操作等等。
   
    上面的例子是一个静态代理的例子，我们知道了接口方法的具体定义，也知道具体的实现类。
    当我们只知道接口方法定义而不知道是哪个具体的实现类时怎么来代理呢？将具体的实现类作为
    一个参数传递给 代理，代理不管是哪个实现类，只要是接口的实现类就执行相应的方法即可。
   
    JDK 为我们提供了一个很好的类来实现动态代理的模式。
    InvocationHandler(Interface) 和 Proxy 类。
   
    Proxy 负责创建动态代理对象
    动态代理对象要实现 InvocationHandler
   
   

    public class DynamicAgent implements InvocationHandler
    {

        private Object agentObject ; // 代理对象，作为参数传入，可用构造传也可以用 set 方法

        public DynamicAgent(Object obj)
        {
            this.agentObject = obj;
        }

        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
        {
            System.out.println("执行方法之前...");

            method.invoke(agentObj, args);   // 方法中使用 代理对象 反射调用 方法
            return null;
        }

    }

    public DynamicAgentTest
    {

        public static void main(String[] args)
        {
            // 获取接口代理对象 ，根据传入对象的不同生成不同对象的代理
            Sing singger = agentObjFactory( getMan() );
            singger.singing();
        }

        /**
         * 将代理的对象传入方法，生成改接口实例对象的代理
         * 具体的实现类可以是很多个
         */
        private static Object agentObjFactory(Object obj)
        {
            // 通过 proxy 构建一个代理对象，被代理的对象 obj 作为方法的参数传入
            Sing agentObj = (Sing) Proxy.newProxyInstance(obj.getClass()
                .getClassLoader(), obj.getClass().getInterfaces(),
                new Agent1Handler(obj));
        }

        /**
         * 改方法返回一个真实的需要被代理的对象，可以是一个工厂方法。
         */
        private static Object getMan()
        {
            return new Singer(); // 可以返回不同的接口的实现类对象
            //return new Singer1 
           // return new Singer2 ...  多种唱歌的实现



        }

    }

 

   
   
    使用代理模式有什么好处？
    这样想，当我们有一个接口叫登陆，那么对于登陆有六个实现类(六种不同的登陆方法)。
    在每次登陆之前，我们要考虑是否满足登陆的条件。满足条件再做登陆操作。
   
    在传统的代码中，每个实现类都要考虑是否满足登陆条件。造成代码冗余，代码逻辑与结构不够清晰
   
  

    public interface Login
    {
        void log();
    }

    public class CheckLog
    {
        public static boolean check(){ ... }
    }   

    public class loger1 implements Login
    {

        public void log()
        {
            if ( CheckLog.check() )
            {
                // log1... 具体实现
            }
        }

    }   
  
    public class loger2 implements Login
    {

        public void log()
        {
            if ( CheckLog.check() )
            {
                // log2... 具体实现
            }
        }

    }

 

   
    这样一来每个实现类都要考虑是否满足条件。
   
    使用代理时，每个实现类不用管那么多，只管做自己如何实现登陆这个动作就行了。
   
   

    public interface Login
    {
        void log();
    }
   
    public class loger1 implements Login
    {
        public void log()
        {
                // log1... 具体实现
        }
    }   
   
    public class loger2 implements Login
    {

        public void log()
        {
                // log2... 具体实现
        }

    }

    public class logAgent implements InvacationHandler
    {

        private Object agentObj; // 代理的对象       

        public logAgent(Object obj)
        {
            this.agentObj = obj;
        }       

        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
        {
            if ( checkLog() )  // 是否满足登陆条件的判断
            {
                method.invoke(agentObj, args);   // 执行具体的登陆
            }
            return null;
        }

    }

 

   
    这样一来，实现类所要做的就是单一实现 登陆。在登陆过程中需要考虑的 流程
    交给代理来完成。