aop 实现机制

 Calculator 一个计算器类

有add sub mul div 增删改查四个方法

每一个方法在特定的执行阶段想输出打印日志

 

开发流程 dao-》service-》controller-》前端，可以认为这是一个纵向的开发，当程序越来越大，越来越复杂的时候，如果想要在service层增加一些日志，怎么做？修改原来的代码吗？这个在公司开发中是大忌，修改了别人的代码，原来能跑，万一修改崩了呢，万一原来的代码成千上万行，

这个时候可以考虑写一个service的代理类，现在要加一个日志，可以横切进去，直接在代理类中添加日志。

在不改变原有代码的情况下，使用代理机制，增加一个代理类来完成。这个就是aop的底层实现机制。

 

 

静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决。（比如说租房，中介和房东去实现租房的接口）

真实角色：被代理的角色。

代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作。

客户：访问代码对象的人。

代码步骤：

1，接口

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

2，真实角色

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

3，代理角色

public class Proxy implements Rent{
​
    private Host host;
​
    public Proxy(){}
    public Proxy(Host host){
        this.host = host;
    }
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        frae();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }
    //收中介费
    public void frae(){
        System.out.println("中介收中介费");
    }
}

​4，客户端访问代理角色 

public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //host.rent();
        // 代理，中介帮房东租房子，但是呢，代理角色一般都会有一些附属操作，比如带客户看房子，签合同，收房租等。
        Proxy proxy = new Proxy(host);
        // 你不用面对房东，直接找中介租房即可。
        proxy.rent();
    }
}

代理模式的好处：

• 可以使真实角色的操作更加纯碎！不用去关注一些公共的业务。

• 公共业务就交给代理角色，实现了业务的分工。

• 公共业务发生扩展的时候，方便集中管理。

缺点：

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

 

静态代理加深理解

有 UserService 这样一个接口，里面定义了增删改查的方法。

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

UserServiceImpl 实现 UserService接口的类

//真实对象
public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }
​
    public void delete() {
        System.out.println("删除了一个用户");
    }
​
    public void update() {
        System.out.println("修改了一个用户");
    }
​
    public void query() {
        System.out.println("查询一个用户");
    }
}

现在有这样一个需求，就是在每个方法执行的时候都增加日志，比如：

//真实对象
public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("使用了 add 方法");
        System.out.println("增加了一个用户");
    }
​
    public void delete() {
        System.out.println("使用了 delete 方法");
        System.out.println("删除了一个用户");
    }
​
    public void update() {
        System.out.println("使用了 update 方法");
        System.out.println("修改了一个用户");
    }
​
    public void query() {
        System.out.println("使用了 query 方法");
        System.out.println("查询一个用户");
    }
}

客户端调用

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

现在只有 UserServiceImpl 这一个实现类，如果有N个实现类，每个实现类都改吗？很明显这有点不现实。

新增一个UserService 的代理类：

public class UserServiceProx implements UserService {
    UserServiceImpl userService;
​
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
​
    public void add() {
        log("add");
        userService.add();
    }
​
    public void delete() {
        log("delete");
        userService.delete();
    }
​
    public void update() {
        log("update");
        userService.update();
    }
​
    public void query() {
        log("query");
        userService.query();
    }
​
    // 日志方法
    public void log(String msg){
        System.out.println("[debug]使用了"+msg+"方法");
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        //userService.add();
​
        UserServiceProx prox = new UserServiceProx();
        prox.setUserService(userService);
        prox.add();
    }
}

在不改变原有业务的情况下，想要扩展一些功能（就比如上面的加日志）,使用代理模式就非常的好。