spring AOP（本质是动态代理）

静态代理设计模式

以租房子为例，有哪些角色：
抽象角色——一般使用接口或者抽象类实现。
真实角色——被代理的角色
代理角色——代理真实角色，代理真实角色后一般会做一些附属的操作
客户——使用代理角色来进行一些操作
Rent.java 抽象角色

package staticproxy;

public interface Rent {
    public void rent();
}

Host.java 真实角色

package staticproxy;
/*
房东
 */
public class Host implements Rent{
    public void rent(){
        System.out.println("房屋出租");
    }

}

Proxy.java代理角色

package staticproxy;
/*
中介
 */
public class Proxy implements Rent{
    private Host host;
    public Proxy(){

    }
    public Proxy(Host host){
        super();
        this.host = host;
    }
    public void setHost(Host host){
        this.host = host;
    }
    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    private void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    private void fare(){
        System.out.println("收取中介费");

    }
}

Client.java客户角色

package staticproxy;
/*
客户
 */

public class Client {
    public static void main(String[] args){
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
        //对客户来说，房东是不透明的；这是静态代理设计模式
    }
}

使用静态代理的好处：
1、使得真实角色处理的业务更加纯粹（比如日志模块，各模块都有调用，这时候其他业务只要调公用的日志模块即可），不再去关注一些公共的事情
2、公共的业务由代理来完成，实现了业务的分工
3、公共业务进行扩展时，变得更加集中和方便
缺点也是很明显的：
1、类多了，多了代理类，工作量变大了，有一个service就要实现它的一个代理类，开发效率降低了
接口：UserService.java

package com.sbmybatis.user;

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

实现类UserServiceImpl.java

package com.sbmybatis.user;

public class UserServiceImpl implements UserService {

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

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

    }

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

    }

    @Override
    public void search() {
        System.out.println("search用户");

    }
}

代理类：UserServiceProxy.java，将打印方法名的公共方法抽取出来

package com.sbmybatis.user;

public class UserServiceProxy implements UserService {
    private UserService userService;

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

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

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

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

    public void log(String methodName){
        System.out.println("执行"+methodName+"方法");
    }
}

基于以上问题，出现了动态代理

动态代理设计模式

动态代理和静态代理的角色是一样的。
动态代理的代理类是动态生成的，可以分为两类：
一类是基于接口动态代理和基于类的动态代理
1、基于接口的动态代理——jdk动态代理
2、基于类的动态代理——cglib
现在用