java之 代理设计模式

1. 设计一个案例来实现租房功能。分析：在租房的过程中涉及到了3个对象，房东，中介，房客。

中介和房客具有相同的功能--租房。

可以设计如下：

2.上图的设计实际上就是一个代理设计模式---静态代理设计模式。

代理设计模式有4个角色

抽象角色 : 是一个接口，使得真实角色和代理角色具有相同的功能。

真实角色： 实际存在某个功能或权限的角色。

代理角色：代理真实角色实现某种功能。代理角色可以附加另外一些功能。

客户端：使用代理角色。

3.使用代码实现

Rent.java

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

Host.java

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

Proxy.java

public class Proxy implements Rent{
    private Host host;
    
    public Proxy(Host host) {
        super();
        this.host = host;
    }
    @Override
    public void rent() {
        fare();
        host.rent();
        maintance();
    }
    private void fare(){
        System.out.println("-----收取中介费---");
    }
    private void maintance(){
        System.out.println("-----房屋维护---");
    }
    public void setHost(Host host) {
        this.host = host;
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

4.作用

真实角色代码在不增加的情况下，增加了新的功能。

5.应用案例

UserService.java

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

UserServiceImpl.java

/**
 * 在service的方法中，经常会有一些公共的功能，
 * 如：事务，日志，权限，缓存等
 *
 */
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("add");
    }
    @Override
    public void delete() {
        System.out.println("delete");
    }
    @Override
    public void update() {
        System.out.println("update");
    }
}

UserServiceImplProxy.java

public class UserServiceImplProxy implements UserService{
    private UserService userService;
    @Override
    public void add() {
        LogUtil.log();
        userService.add();
    }

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

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

LogUtil.java

public class LogUtil {
    public static void log(){
        System.out.println("进入了方法");
    }
}

 

6.总结

通过以上代码可知，

优点：静态代理实现了公共业务和真实的业务逻辑的分离，降低了耦合，结构更清晰，维护更方便，扩展更容易，分工更明确。

缺点：代码的复杂程度增加，每个业务类都需要有一个相关的代理类，代码量增加-------解决办法：使用动态代理。

 

转载于:https://www.cnblogs.com/Vincent-yuan/p/11260911.html