静态代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层！

代理模式的分类：

• 静态代理
• 动态代理
  

静态代理

角色分析：

• 抽象角色：一般会使用接口或抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些
• 客户：访问代理对象的人

代码步骤：

1. 接口

//租房
public interface Rent {

     void rent();
}

3. 真实角色

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

5. 代理角色

public class Proxy {

    private  Host host;

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

    public Proxy() {
    }

    public void  rent(){
        seeHouse();
        host.rent();
        hetone();
        fare();
    }

    //看房
    public  void seeHouse(){
        System.out.println("中介带你看房");
    }

    public  void hetone(){
        System.out.println("签合同");
    }

    //收费
    public  void fare(){
        System.out.println("收费");
    }
}

7. 客户端访问代理角色

public class Client {

    public static void main(String[] args) {
        Host host = new Host();

        //代理，中介帮房东租房子，但是呢？代理一般会做一些附加操作
        Proxy proxy = new Proxy(host);

        //你不用找房子，直接找中介
        proxy.rent();
    }
}

代理模式的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共业务就交给了代理角色，实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理

缺点：

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

加深理解

再写一个代码案例：

先写一个用户接口：

public interface UserService {

    void add();
    void delete();
    void update();
    void query();
}

实现一个用户接口

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 query() {
        System.out.println("查询了一个用户");
    }

    //1.改动原有的业务代码，在公司中是大忌
}

测试一下

public class Client  {

    public static void main(String[] args) {
        UserServiceImpl userService=new UserServiceImpl();
		userService.add();
    
}

打印出新增一个方法。

但是现在有一个需求，增加一个日志怎么办，我们要在不改变代码的情况下去实现。

1.改动原有的业务代码，在公司中是大忌

我们写一个代理类

public class UserProxy implements UserService {
    private UserServiceImpl userService;

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

    @Override
    public void add() {

        log("add");
        userService.add();
    }

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

    }

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

    }

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

    //日志

    public void  log(String msg){

        System.out.println("使用了"+msg+"方法");
    }
}

我们在测试代理类即可。

public class Client  {

    public static void main(String[] args) {
        UserServiceImpl userService=new UserServiceImpl();
        
        UserProxy userProxy = new UserProxy();

        userProxy.setUserService(userService);

        userProxy.add();
    }
}

聊一聊AOP