Spring静态/动态代理（六）

Spring静态/动态代理（六）

资料来源：微信公众号狂神说

学习Spring AOP之前 先需要学习代理模式，因为AOP的底层机制就是动态代理。

分类：

• 静态代理
• 动态代理

一、静态代理

1.1 角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现
• 真实角色 : 被代理的角色
• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
• 客户 : 访问代理角色

1.2 示例一

抽象角色Rent

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

真实角色Host

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

代理角色Proxy

//中介
public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    @Override
    public void rent() {
        System.out.println("代理了");
        host.rent();
        seeHouse();
        fare();
        hetong();

    }

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

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

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

客户Client

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理房东
        Proxy proxy = new Proxy(host);
        //中介租房
        proxy.rent();
    }
}

1.3 静态代理的好处

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .

要说缺点就是， 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低

1.4 示例二

1. 创建抽象角色，以增删改查为例

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

2. 真实角色

//真实对象
public class UserServieImpl 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("查询了一个用户");
    }
}

3. 需求是增加日志功能，如何实现？

• 思路1：在实现类上增加代码【麻烦】
• 思路2：代理来做，不改变原来业务的情况下，实现此功能

4. 设置一个代理类来处理日志！代理角色

public class UserServiceProxy implements UserService {
    private UserServieImpl userService;
	//代理真实对象
    public void setUserService(UserServieImpl 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("[Debug] 使用了"+msg+"方法");
    }

}

5. 测试

public class Client {
    public static void main(String[] args) 
        //真实业务
        UserServieImpl userServie = new UserServieImpl();
    	//代理
        UserServiceProxy userServiceProxy = new UserServiceProxy();
    	//使用代理实现日志
        userServiceProxy.setUserService(userServie);
        userServiceProxy.add();
        userServiceProxy.query();
    }
}

二、动态代理

• 动态代理的角色和静态代理的一样 .

• 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的

• 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

• • 基于接口—JDK动态代理
  • 基于类—cglib
  • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
  • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！、

JDK的动态代理需要了解两个类

核心： InvocationHandler 和 Proxy 两个类

InvocationHandler

• 是由代理实例的调用处理程序实现的接口 。 （不理解没关系看例子）

调用处理程序返回结果，实质就是反射触发代理类的实例去执行抽象方法的！

Proxy

• 提供了创建动态代理类和实例的静态方法

实质就是一个构造代理类，然后生成了实例的东西。其实和静态代理一样，只不过静态代理是写好代理类，而这里是靠反射机制生成代理类。

核心就是newProxyInstance这个方法

jdk示例：

Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class<?>[] { Foo.class },
                                          handler); 

2.1 示例一

就用上面租房的例子

抽象角色Rent

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

真实角色Host

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

注意这里代理角色ProxyInvocationHandler这个类

Proxy.newProxyInstance这个方法的第二个参数获取的是你要代理真实角色的接口！！

//这个类将自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类 重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }

    //处理代理实例，并返回结果
    //method : 代理类的调用处理程序的方法对象.
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是反射机制
        seeHouse();
        Object res = method.invoke(rent, args);
        fare();
        return res;
    }

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

Client

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //放入真实角色
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();//动态生成的proxy
        proxy.rent();
    }
}

2.2 示例二

深化理解 用上面的示例二实现动态代理

编写一个通用的动态代理实现的类。所有的代理对象设为Object

//这个类将自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        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 {
        log(method.getName());
        Object res = method.invoke(target, args);
        return res;
    }

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

}

测试

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServieImpl userService = new UserServieImpl();
        //代理角色(创建中)
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的角色
        pih.setTarget(userService);
        //得到代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

2.3 动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
• 公共的业务由代理来完成 . 实现了业务的分工 ,
• 公共业务发生扩展时变得更加集中和方便 .
• 一个动态代理 , 一般代理某一类业务
• 一个动态代理可以代理多个类，代理的是接口！