设计模式——代理模式①之静态代理

---

扩展：设计模式学习汇总

---

静态代理

• 其实像设计模式这种抽象的技术真的不大好用代码来表示，因为实际业务总是比我们举的例子复杂一百倍一千倍！
• 但我们在工作过程中，突然有一天感觉自己老是在做重复的事情，希望可以优化一下自己的代码时，这时候设计模式可能就在不知不觉中用上了。
• 总的来说，学习设计模式是一个日积月累的过程，不是一朝一夕可以学会的。
• 在这里只会提供一个思维方式给大家，主要还是要靠自己在实际开发中可以多想想，尽量带入这种思维模式写到代码里！这样我们才能融汇贯通！

1.1、案例一：租房

①在生活中，我们难免会因为工作、生活等原因而需要租房。这个对大家来说是再熟悉不过的了！

• 房东和中介有一个共性，就是租房出去！

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

②房东：

/**
 * 房东需要实现租房这个接口，因为有房子需要出租！
 */
public class Landlord implements Rent {

    @Override
    public void rent() {
        System.out.println("房东：我有房子出租！");
    }
}

③中介：

/**
 * 这是一个代理角色，相当于中介
 * 它也实现租房接口，因为中介帮房东租房子!
 */
public class ProxyUser implements Rent {
    //帮房东租房
    private Landlord landlord;

    public ProxyUser() {
    }

    //可以根据有参构造来帮助不同的房东出租房子
    public ProxyUser(Landlord landlord) {
        this.landlord = landlord;
    }

    @Override
    public void rent() {
        //房东的房子出租
        landlord.rent();

    }
    //带看
    public void seeHouse(){
        System.out.println("中介：带客看房!");
    }
    //代替房东签合同
    public void sinContract(){
        System.out.println("中介：签合同！");
    }
}

④客户：

public class Customer {
    private String name;

    public String getName() {
        System.out.println(name+"我需要租个房子");
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

⑤测试类：

public class Test {
    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.setName("大大丁大大");
        customer.getName();
        Landlord landlord = new Landlord();
        ProxyUser proxyUser = new ProxyUser(landlord);
        proxyUser.rent();
        proxyUser.seeHouse();
        proxyUser.sinContract();
    }
}

⑥执行结果：

⑦总结：

• 本来租房子是需要客户找房东。
• 现在房东不想操心，直接把房子给中介，中介每个月给房东租金即可。
• 中介负责将房子出租给客户。
• 好处就是，本来看十套房需要找是个房东，现在只需要找一个中介即可！
• 中介就是代理！

1.2、案例二：横向拓展

①业务抽象接口：

public interface UserService {
    void add();
    void delete();
    void update();
    void selete();
}

②业务实现类：

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

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

    @Override
    public void update() {
        System.out.println("更新用户");
    }

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

③代理实现类：

public class ProxyUserService implements UserService{

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    //日志类
    public void log(){
        System.out.println("日志打印！");
    }

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

    @Override
    public void delete() {
        log();
        userService.delete();
    }

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

    @Override
    public void selete() {
        log();
        userService.selete();
    }
}

④测试类：

public class TestProxy {
    public static void main(String[] args) {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        ProxyUserService proxy = new ProxyUserService();
        //实现代理增加日志功能
        proxy.setUserService(userService);

        proxy.add();
        System.out.println("=========");
        proxy.delete();
        System.out.println("=========");
        proxy.update();
        System.out.println("=========");
        proxy.selete();
    }
}

⑤执行结果：

⑥总结：

• 额，模拟的这种代码可能看起来会更加麻烦，其实本质上就是再封装一层！
• 为啥要这样呢？如果每个业务代码量都非常大呢？改造的风险太大，但是使用代理模式来切面改造！这就是优点！
• 横向开发！！！

---

路漫漫其修远兮，吾必将上下求索~
如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧_{**转载请注明出处哦**}