spring代理快速了解

静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，（一般会做一些附属操作）
• 客户：访问代理对象的人

代理模式的好处：

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

先定义一个抽象的角色（基本逻辑增删改查）

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

// 真实的对象
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 Client {
    public static void main(String[] arg) {
        UserServiceImpl UserService = new UserServiceImpl();
        // UserService.add();
        // 实现下面的日志
        // 使用代理
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(UserService);
        
        proxy.add();
        
    }
}

在上面的业务中对添加一个日志业务

public class UserServiceProxy implements UserService {
    
    private UserServiceImpl userService;
    
    public void setUserService(UserService 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("使用了" + msg + "方法")
    }
}

缺点：

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

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是直接写好的
• 动态代理分为两大类：
  • 基于接口 — JDK 动态代理
  • 基于类： cglib
  • java字节码实现： javasist

了解的两个类：Prixy， InvocationHandler

InvocationHandler

Proxy

// 用这个类，自动生成代理类
public class ProxyInvocationHandle implements InvocationHandler {
    
    // 被代理的接口
    private Object target;
    
    public void setRent(Rent rent)} {
    	this.target = target;
	}
    
    // 生成得到代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getclass().getClassLoader(),target.getClass().getInterfaces,this)
    }
    
	// 处理代理实例，并返回结果
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        
        Object result = method.invoke(target, args);
        return result;
    }
}

完成可以当作代理模板去使用，动态代理的本质，就是使用反射机制实现