JAVA设计模式之代理模式

【 代理模式应用场景举例】

比如在玩“极品飞车”这款游戏，如果游戏者手中的金钱达到了一定的数量就可以到车店买一部性能更高的赛车，那么这个卖车的“车店”就是一个典型的“汽车厂家”的“代理”，他为汽车厂家“提供卖车的服务”给有需求的人士。从面向对象的方面考虑，“销售汽车的代理”也是一个对象，那么这个对象也具有一定的状态，在软件项目中这个对象也具有管理财务进销存的基本功能，那么在设计时就要以面向OOP编程的思想来考虑软件的类结构，这个销售汽车的代理也是一个类了。

【代理模式解释】

类型：结构模式

对一些对象提供代理，以限制那些对象去访问其它对象。

【代理模式案例-JAVA代码实现】

1，租房

场景
房东想要出租房子，房东不想去签合同，收租金，打广告等一些麻烦的事情，交给中介公司来做，中介公司也能够出租房子

出粗房子的接口

public interface Rent {
    /**
     * 租房
     */
    void rent();
}

房东也可以出粗房子，实现出租房子的接口

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

中介公司也实现出租房子，并做一些附加操作，比如，带你看房子，收租金，签合同

public class Agency implements Rent {
    private Host host;

    public Agency() {
    }

    public Agency(Host host) {
        this.host = host;
    }

    /**
     * 中介出粗代理房子
     */
    @Override
    public void rent() {
        seeHouse();
        signContract();
        fare();
        host.rent();
    }
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void signContract(){
        System.out.println("签合同");
    }
    public void fare(){
        System.out.println("收取中介费");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 房东要出租房子
        Host host = new Host();
        // 代理，中介帮房东出租房子，但是，中间呢，中介会做一些其他的操作
        Agency agency = new Agency(host);
        // 直接找中介租房子，而不用找房东了
        agency.rent();
    }
}

测试结果

由始至终由中介来操作，房东最后将房子出粗

2， 买车

代理模式扩展
汽车厂商要卖车，交给4s店来做，4s店会根据不同的人来是否将车买给他，这有点策略模式，理解代理模式即可

卖车公共接口

public interface SellCar {
    /**
     * 卖车
     */
    void sellCar();
}

汽车厂商卖车

public class CarManufacturer implements SellCar {
    @Override
    public void sellCar() {
        System.out.println("汽车生厂商卖出了一辆车");
    }
}

4s店卖车，4s店会根据卖车的人是否vip和金额来确认是否卖车
买车的人

public class People {
    /**
     * 金额
     */
    private int cash;
    /**
     * 客户类型
     */
    private String vip;
    /**
     * 客户名称
     */
    private String userName;

    public People(int cash, String vip, String userName) {
        this.cash = cash;
        this.vip = vip;
        this.userName = userName;
    }

    public People() {
    }

    public int getCash() {
        return cash;
    }

    public void setCash(int cash) {
        this.cash = cash;
    }

    public String getVip() {
        return vip;
    }

    public void setVip(String vip) {
        this.vip = vip;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

public class Car4sShop implements SellCar {
    private CarManufacturer carManufacturer;
    private People people;
    public Car4sShop() {
    }

    public void setCarManufacturer(CarManufacturer carManufacturer) {
        this.carManufacturer = carManufacturer;
    }

    public void setPeople(People people) {
        this.people = people;
    }

    /**
     * 4s 店卖车，会根据不同客户卖出不同的车
     */
    @Override
    public void sellCar() {

        if(people.getVip()=="vip"){
            System.out.println(people.getUserName()+"是vip客户买了辆新车");
            carManufacturer.sellCar();
            return;
        }
        if(people.getCash()>=50000){

            System.out.println(people.getUserName()+"花了" + people.getCash() +"元买了辆新车");
            carManufacturer.sellCar();
        }else{
            System.out.println(people.getUserName()+"只有"+people.getCash()+"元，无法购买新车");
        }

    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 创建不同的三个人
        People people_1 = new People();
        people_1.setVip("");
        people_1.setCash(60000);
        people_1.setUserName("jeck");


        People people_2 = new People();
        people_2.setVip("vip");
        people_2.setCash(40000);
        people_2.setUserName("rose");

        People people_3 = new People();
        people_3.setVip("");
        people_3.setCash(0);
        people_3.setUserName("tom");
        // people去4s店买车，代理对象4s店卖车
        Car4sShop shop = new Car4sShop();
        // 代理对象
        shop.setCarManufacturer(new CarManufacturer());
        // 汽车厂不卖车，4s店代理汽车厂卖车
        shop.setPeople(people_1);
        shop.sellCar();
        shop.setPeople(people_2);
        shop.sellCar();
        shop.setPeople(people_3);
        shop.sellCar();


    }
}

测试结果

people买了车，汽车厂商卖出一台，全由4s店操作

3，动态代理

动态代理有两个核心类
Proxy代理和InvocationHandler调用处理程序

public class ProxyInvocationHandler implements InvocationHandler {
    /**
     * 被代理的接口
     */
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    /**
     * 生成得到代理类
     * @return
     */
    public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg){
        System.out.println("执行了" + msg+"方法");
    }
}

测试类
以买房的类为例

public class Test {
    public static void main(String[] args) {
        // 真实角色
        Host host = new Host();
        // 代理角色，不存在
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        // 设置代理对象
        handler.setTarget(host);
        // 动态生成代理类
        Rent proxy = (Rent)handler.getProxy();
        proxy.rent();
    }
}

结果

总结

代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口。