Spring之AOP代理模式

代理模式分类：

1. 静态代理
2. 动态代理

你要租房，不找房东，找中介，中介是房东的代理。

1.1静态代理

角色分析

1. 抽象角色：一般会使用接口或者抽象类来解决

/**
 * @author LongXi
 * @create 2021-05-30 10:00
 */
public interface Rent {
    public void rent();
}

2. 真实角色：被代理的角色

 /**
 * @author LongXi
 * @create 2021-05-30 10:01
 */
public class Host implements Rent{

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

3. 代理角色：代理真是角色，代理真是角色后，我们一般会做一些附属操作

package demo1;

/**
 * @author LongXi
 * @create 2021-05-30 10:03
 */
public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        deal();
        fare();
    }

    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void fare(){
        System.out.println("收中介费");
    }
    public void deal(){
        System.out.println("签租赁合同");
    }
}

4. 客户：访问代理对象的人

/**
 * @author LongXi
 * @create 2021-05-30 10:02
 */
public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
//        host.rent();
        //代理 中介帮房东租房子，但是呢？代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

代理角色好处：

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

缺点：
一个真实角色会产生一个代理角色；代码量会翻倍，开发效率会变低！

加深理解

实体类

/**
 * @author LongXi
 * @create 2021-05-30 12:16
 */
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

/**
 * @author LongXi
 * @create 2021-05-30 12:18
 */
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("查询了一个用户");
    }

}

代理类

/**
 * @author LongXi
 * @create 2021-05-30 12:23
 */
public class UserServiceProxy implements UserService{

    private  UserServiceImpl userService;

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

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

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

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

    @Override
    public void query() {
        this.log("query");
        userService.query();
    }
    public void  log(String msg){
        System.out.println("[Debug]使用了"+msg+"方法");
    }

客户类

/**
 * @author LongXi
 * @create 2021-05-30 12:19
 */
public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        //userService.add();

        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
        userServiceProxy.delete();
        userServiceProxy.update();
        userServiceProxy.query();
    }
}

测试

[Debug]使用了add方法
增加了一个用户
[Debug]使用了delete方法
删除了一个用户
[Debug]使用了update方法
修改了一个用户
[Debug]使用了query方法
查询了一个用户

为什么不能在原来代码上加？
改动原代码是大忌。