10、静态/动态代理模式

转载 于 2020-07-18 17:12:33 发布 · 181 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.bilibili.com/video/BV1WE411d7Dv?p=19
文章标签：

#java #设计模式

文章目录


为什么学习代理模式，因为AOP的底层机制就是动态代理模式！

代理模式

  • 静态代理
  • 动态代理
    在这里插入图片描述

10.1、静态代理

角色分析：

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

代码实现

Rent.java 即抽象角色

//抽象角色：出租房屋
public interface Rent {
    void rent();
}

Host.java即真实角色

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

Proxy.java即代理角色

//代理角色：中介
public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

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

    public void rent() {
        host.rent();
        seeHouse();
        fare();
        hetong();
    }

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

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

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

Client.java即客户

public class Client {

    public static void main(String[] args) {

        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东出租房子，但是呢？代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租放即可！
        proxy.rent();
    }

}

分析：在这个过程中，你直接接触的就是中介，就如同现视生活中的样子，你看不到房东，但是你依旧通过代理租到了房东的房子，这就是所谓的代理模式。

静态代理模式的好处：

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

缺点：

  • 类多了，多了代理类，工作量变大，开发效率降低

我们想要静态代理的好处，又不想要静态代理的缺点，所以，就有了动态代理。

10.2、静态代理加深理解

1、创建一个抽象角色，比如咱们平时做的用户业务，抽象起来就是增删改查！

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

2、我们需要一个真实对象来完成这些增删改查操作

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("查询了一个用户");
    }
}

3、需求来了，现在我们需要增加一个日志功能，怎么实现？

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

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

public class UserServiceProxy implements UserService {

    private 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("[D" +
                "ebug] 使用了"+msg+"方法");
    }
}

5、测试访问类：

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

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想
在这里插入图片描述

10.3、动态代理

  • 动态代理的角色和静态代理的一样
  • 动态代理的代理类是自动生成的，静态代理的代理类是我们提前写好的
  • 动态代理分为两类：一类是基于接口的动态代理，一类是基于类的动态代理
    • 基于接口的动态代理----JDK动态代理
    • 基于类的动态代理----cglib
    • 现在用的比较多的是javasist来生成动态代理，百度一下javasist
    • 我们这里使用JDK的原生代码来实现，其余的道理都是一样得！

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

核心：InvocationHandler 和 Proxy ，打开JDK帮助文档查看
【InvocationHandler：调用处理程序】
在这里插入图片描述

Object invoke(Object proxy, 方法 method, Object[] args)；
/*参数
proxy - 调用该方法的代理实例
method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，
它可以是代理类继承该方法的代理接口的超级接口。
args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始
类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
*/

参数再解析：
proxy：生成的代理类，目前没发现用处，不管它
method：是执行的方法
args：是执行某方法需要的参数
第二个第三个参数解释执行的方法意思是：代理类不是要代理某个对象么，然后增强里面的方法么，指得就是这个方法，代理类会为几乎所有方法都增强，除非你在这里做判断。
返回值，是执行这个方法所返回的值。
然后你要去执行方法，就是用第二参数的invoke(obj,args);第一个参数是你要增强的对象。第二个是参数。object是你返回的类型
Object object= method.invoke(obj,args);
｝
【Proxy：代理】
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
参数再解析：
loader：表明你要用哪个类加载器去加载生成的代理类。
interfaces：说明你要生成的代理类的接口
h：实现InvocationHandle类，这个类只有一个方法需要你实现它。

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

代码实现
Rent.java即抽象角色

//抽象角色：租房
public interface Rent {
    void rent();
}

Host.java即真实角色

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

ProxyInvocationHandler.java即代理角色

//等会我们会用这个类，自动生成代理类！
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：代理类的调用处理程序的方法对象.
    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质,就是使用反射机制
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

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

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

Client.ava

public class Client {

    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色:现在没有
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们我们要调用的接口
        pih.setRent(host); //将真实角色放置进去！
        //这里的proxy即使动态生成的，我们并没有写
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();

    }

}

核心：一个动态代理，一般代理某一类业务，一个动态代理可以代理多个类，代理的是接口！

10.4、动态代理加深理解

我们可以编写一个通用的动态代理实现的类！所有代理对象设置为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 result = method.invoke(target, args);
        return result;
    }

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

测试！

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

动态代理的好处：

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

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

10.5、基于Cglib的动态代理

  1. Num.java
public class Num {

    // 两数相加
    public int add(int x, int y){
        return x + y;
    }

    // 两数相减
    public int less(int x, int y){
        return x - y;
    }

}
  1. ProxyNum.java
public class PoxyNum {

    public static void main(String[] args) {
    	// 创建 Enhancer
        Enhancer enhancer = new Enhancer();
        final Num target = new Num();
        // 设置父类，本质是创建子类
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
	           // 拦截的方法
		       // 参数 o：目标对象
		       // method:目标方法
		       // objects：执行方法的参数
		       // MethodProxy：方法的代理对象

                System.out.println("计算前");
                Object result = method.invoke(target, objects);
                System.out.println(result);
                System.out.println("计算后");
                return result;
            }
        });
        Num proxy = (Num) enhancer.create();
        proxy.add(5,6);
        System.out.println("================================");
        proxy.less(8,5);
    }
}

学习视频链接：https://www.bilibili.com/video/BV1WE411d7Dv?p=19

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值