设计模式_05_静态代理模式

静态代理

为什么会有代理模式

有时候我们希望程序中的某些对象不会被直接访问，于是使用代理模式来控制对真实对象的访问，假如真实对象为白脸，但是白脸不希望每个人都叫他做事，因此他必须找个黑脸（代理对象）来控制对他的访问，代理对象的任务就是控制和管理访问真实对象，代理通过Internet搬运被代理对象的整个方法调用。

类图

角色分析

1. 抽象角色：使用抽象数据类型接口或抽象类来定义
2. 真实角色：被代理的角色
3. 代理角色：代理真实角色，可以有自己的独特属性与行为
4. 客户：访问代理对象的人

代码步骤

1、定义抽象角色

//房东租房行为
public interface HostRent {
    public abstract void rent();
}

2、定义真实角色

//房东
public class Host implements HostRent {

    //房东名字
    private String name;

    public Host(String name){
        this.name = name;
    }

    @Override
    public void rent() {
        System.out.println(name+"要出租房子");
    }
}

3、定义代理角色

public class LettingAgency_Proxy implements HostRent {
    //组合房东
    HostRent host;

    //房屋中介的其它属性

    //接口回调、面向接口编程
    public LettingAgency_Proxy(HostRent host){
        this.host = host;
    }

    //房屋中介出租房子
    public void rent() {
		//其他行为
        host.rent();
        seeHouse();
        signContract();
        fare();
    }

    //房屋中介的其他行为

    public void seeHouse(){
        System.out.println("房屋中介与客户去看房");
    }

    public void fare(){
        System.out.println("房屋中介收中介费");
    }

    public void signContract(){
        System.out.println("签订房屋合同");
    }
}

4、定义客户、测试

public class ProxyTest {

    public static void main(String[] args) {
        HostRent A = new Host("A");
        HostRent B = new Host("B");
        LettingAgency_Proxy proxy1 = new LettingAgency_Proxy(A);
        LettingAgency_Proxy proxy2 = new LettingAgency_Proxy(B);
        proxy1.rent();
        proxy2.rent();
    }
}

静态代理模式的优缺点

优点：

• 抽离公共业务与特殊业务，实现业务分工，使真实角色操作更加纯粹
• 扩展公共业务更方便

缺点：

• 一个真实角色产生一个代理角色；代码量会翻倍、开发效率会变低

aop与代理模式

接口

public interface UserService {

    void add();
    void del();
    void update();
    void query();

}

真实对象

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("添加");
    }

    @Override
    public void del() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("修改");
    }

    @Override
    public void query() {
        System.out.println("查询");
    }
}

代理对象

public class UserServiceProxy implements UserService {

    UserService userServiceImpl;

    public void setUserServiceImpl(UserService userServiceImpl){
        this.userServiceImpl = userServiceImpl;
    }


    @Override
    public void add() {
        log();
        userServiceImpl.add();
    }

    @Override
    public void del() {
        log();
        userServiceImpl.del();
    }

    @Override
    public void update() {
        log();
        userServiceImpl.update();
    }

    @Override
    public void query() {
        log();
        userServiceImpl.query();
    }

    public void log(){
        System.out.println("代理类添加行为");
    }
}

客户

public class Client {

    public static void main(String[] args) {
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserServiceImpl(new UserServiceImpl());
        userServiceProxy.add();
        userServiceProxy.del();
        userServiceProxy.update();
        userServiceProxy.query();
    }
}