设计模式学习（六） 代理模式

核心作用：

　　-- 通过代理，控制对对象的访问

　　　　可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理（即：AOP的微观实现！）

　　-- AOP（Aspect Oriented Programming面向切面编程）的核心实现机制！

核心角色：

• 抽象角色：

　　　　-- 定义代理角色和真实角色的公共对外方法

• 真实角色

　　　　-- 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用

　　　　-- 关注真正的业务逻辑

• 代理角色

　　　　-- 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的　　　　　　操作

　　　　-- 将统一的流程控制放到代理角色中处理

应用场景：

分类及实现：

-- 静态代理（静态定义代理类）

package com.lp.staticProxy;

public interface Star {
    /*面谈*/
    void confer();
    
    /*签合同*/
    void singContract();
    
    /*订单*/
    void bookTicket();
    
    /*唱歌*/
    void sing();
    
    /*收钱*/
    void collectMoney();
    

}

package com.lp.staticProxy;

public class RealStar implements  Star {

    @Override
    public void confer() {
        System.out.println("RealStar  confer");
        
    }

    @Override
    public void singContract() {
        System.out.println("RealStar  singContract");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar  bookTicket");
        
    }

    @Override
    public void sing() {
        System.out.println("RealStar(周杰伦)  sing");
        
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar  collectMoney");
        
    }

}

package com.lp.staticProxy;

public class ProxyStar implements  Star {
    private Star star;
    
    public ProxyStar(Star star) {
        super();
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("ProxyStar confer");
        
    }

    @Override
    public void singContract() {
        System.out.println("ProxyStar singContract");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar bookTicket");
        
    }

    @Override
    public void sing() {
        this.star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar collectMoney");
        
    }

}

package com.lp.staticProxy;

public class Clinet {
    public static void main(String[] arg){
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);
        
        proxy.confer();
        proxy.singContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

 结果：

 

--动态代理（动态生成代理类）

 

优点：

　　-- 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们就可以更加灵活和统一的处理众多的方法

JDK自带的动态代理

　　-- java.lang.reflect.Proxy

　　　　作用：动态生成代理类和对象

　　-- java.lang.reflect.InvocationHandler(处理器接口)

　　　　作用：1：可以通过invoke方法实现对真实角色的代理访问

　　　　　　　2: 每次通过Proxy生成代理类对象时都要指定对应的处理器对象

代码：

package com.lp.dynamicProxy;

public interface Star {
    /*面谈*/
    void confer();
    
    /*签合同*/
    void singContract();
    
    /*订单*/
    void bookTicket();
    
    /*唱歌*/
    void sing();
    
    /*收钱*/
    void collectMoney();
    

}

package com.lp.dynamicProxy;

public class RealStar implements  Star {

    @Override
    public void confer() {
        System.out.println("RealStar  confer");
        
    }

    @Override
    public void singContract() {
        System.out.println("RealStar  singContract");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar  bookTicket");
        
    }

    @Override
    public void sing() {
        System.out.println("RealStar(周杰伦)  sing");
        
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar  collectMoney");
        
    }

}

package com.lp.dynamicProxy;

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

public class StarHandler implements InvocationHandler {

    Star realStar;
    
    public StarHandler(Star realStar) {
        super();
        this.realStar = realStar;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        
        Object object = null;
        if(method.getName().equals("sing"))
        {
            System.out.println("预约");
            System.out.println("付款");
            method.invoke(realStar, args);
            System.out.println("听歌");
        }
        
        return null;
    }

}

package com.lp.dynamicProxy;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args){
        Star realStar = new RealStar();
        
        StarHandler handler = new StarHandler(realStar);
        
        Star proxy = (Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class},handler);
        
        proxy.confer();//这些都是不会调用真实角色的
        proxy.singContract();//这些都是不会调用真实角色的
        proxy.bookTicket();//这些都是不会调用真实角色的
        proxy.sing();
        proxy.collectMoney();//这些都是不会调用真实角色的
    }
}

结果：