模式系列之代理模式

最新推荐文章于 2023-03-07 09:04:41 发布
最新推荐文章于 2023-03-07 09:04:41 发布
阅读量198 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m76756794/article/details/80279738
版权

  简介：代理模式是一种非常重要的设计模式，在 Java 语言中有着广泛的应用，包括Spring AOP 的核心设计思想，都和代理模式有密切关系。什么场景使用代理模式？代理模式实现原理是什么？本节课程将带你领略代理模式的奥妙。

1. 代理模式概念介绍

1.1  代理模式定义：为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到中介的作用，可以去掉功能服务或增加额外的服务。

  如：火车票代售处是火车站的代理。

1.2 几种常见的代理模式

远程代理：为不同地理的对象提供局域网代表对象。

虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建


  如一张大的图片未加载成功时先用一张小的图片代替就是虚拟代理的一种应用。

  保护代理：控制对一个对象的访问权限。

  如发帖功能中，控制用户的访问权限，登录和不登录的用户具有不同的权限。

  智能引用代理：提供对目标对象的一些额外服务。

2. 常用代理模式原理（智能引用为例）

2.1 静态代理概念及实现

静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或者继承相同的抽象类。

模拟场景：汽车行驶，通过代理实现汽车行驶的基本功能+行驶计时功能

2.1.1 初始代码：

public interface Movable {
  public void move();
}

import java.util.Random;
public class Car implements Movable {
	public void move() {
		long starttime=System.currentTimeMillis();
		System.out.println("汽车开始行驶....");
		//实现开车		
		try {
			Thread.sleep(new Random().nextInt(1000));
			System.out.println("汽车行驶中...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		long endtime=System.currentTimeMillis();
		System.out.println("汽车行驶结束...汽车行驶时间为："+(endtime-starttime)+"毫秒!");
		
	}
}

public class Client {
    //测试类
	public static void main(String[] args) {
		Car car=new Car();
		car.move();
	}

}

输出：

汽车开始行驶....

汽车行驶中...

汽车行驶结束...汽车行驶时间为：979毫秒!

2.1.2 修改一

使用继承方式实现代理

public interface Movable {
  public void move();
}

public class Car implements Movable {
	public void move() {
		//实现开车		
		try {
			Thread.sleep(new Random().nextInt(1000));
			System.out.println("汽车行驶中...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

public class Car2 extends Car {
	public void move() {
		long starttime=System.currentTimeMillis();
		System.out.println("汽车开始行驶....");
		super.move();
		long endtime=System.currentTimeMillis();
		System.out.println("汽车行驶结束...汽车行驶时间为："+(endtime-starttime)+"毫秒!");		
	}
}

public class Client {
    //测试类
	public static void main(String[] args) {
		Car car=new Car2();
		car.move();
	}
}

输出：

汽车开始行驶....

汽车行驶中...

汽车行驶结束...汽车行驶时间为：977毫秒!

2.1.3 修改二

使用聚合方式实现代理

public interface Movable {
  public void move();
}

public class Car implements Movable {
	public void move() {	
		//实现开车		
		try {
			Thread.sleep(new Random().nextInt(1000));
			System.out.println("汽车行驶中...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}	
	}
}

public class Car3 implements Movable {
    private Car car;
	public Car3(Car car) {
		super();
		this.car=car;
	}
	public void move() {
		long starttime=System.currentTimeMillis();
		System.out.println("汽车开始行驶....");
		car.move();
		long endtime=System.currentTimeMillis();
		System.out.println("汽车行驶结束...汽车行驶时间为："+(endtime-starttime)+"毫秒!");		
	}
}

public class Client {
    //测试类
	public static void main(String[] args) {
		Car car=new Car();
		Movable car3=new Car3(car);
		car3.move();
	}
}

输出：

汽车开始行驶....

汽车行驶中...

汽车行驶结束...汽车行驶时间为：414毫秒!

2.2 聚合比继承更适合代理模式



使用继承的方式实现功能的叠加会导致代理类无限地膨胀下去。


使用聚合方式实现代理组合：(时间代理和日志代理的叠加)

public interface Movable {
  public void move();
}

import java.util.Random;
public class Car implements Movable {
	public void move() {	
		//实现开车		
		try {
			Thread.sleep(new Random().nextInt(1000));
			System.out.println("汽车行驶中...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
	}
}

public class CarTimeProxy implements Movable {
    private Movable m;
	public CarTimeProxy(Movable m) {
		super();
		this.m=m;
	}
	public void move() {
		long starttime=System.currentTimeMillis();
		System.out.println("汽车开始行驶....");
		m.move();
		long endtime=System.currentTimeMillis();
		System.out.println("汽车行驶结束...汽车行驶时间为："+(endtime-starttime)+"毫秒!");		
	}
}

public class CarLogProxy implements Movable {
    private Movable m;
	public CarLogProxy(Movable m) {
		super();
		this.m=m;
	}
	public void move() {
		System.out.println("日志开始....");
		m.move();
		System.out.println("日志结束...");		
	}
}

public class Client {
    //测试类
	public static void main(String[] args) {
		Car car=new Car();
		CarTimeProxy ctp=new CarTimeProxy(car);
		CarLogProxy clp=new CarLogProxy(ctp);
		clp.move();
		System.out.println("---------------");
		CarLogProxy clp2=new CarLogProxy(car);
		CarTimeProxy ctp2=new CarTimeProxy(clp2);
		ctp2.move();
	}
}

输出:

日志开始....

汽车开始行驶....

汽车行驶中...

汽车行驶结束...汽车行驶时间为：967毫秒!

日志结束...

---------------

汽车开始行驶....

日志开始....

汽车行驶中...

日志结束...

汽车行驶结束...汽车行驶时间为：27毫秒!

 

2.3 了解JDK动态代理







public interface Movable {  //被代理接口
  public void move();
}

import java.util.Random;
public class Car implements Movable {   //被代理类
	public void move() {
		//实现开车		
		try {
			Thread.sleep(new Random().nextInt(1000));
			System.out.println("汽车行驶中...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
	private Object target;
	public TimeHandler(Object target) {
		super();
		this.target=target;
	}
	/*
	 *参数：
	 *proxy:被代理的对象
	 *method：被代理对象的方法
	 *args:方法的参数
	 *返回值：Object 方法的返回值 
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		long starttime=System.currentTimeMillis();
		System.out.println("汽车开始行驶....");
        method.invoke(target);
        long endtime=System.currentTimeMillis();
		System.out.println("汽车行驶结束...汽车行驶时间为："+(endtime-starttime)+"毫秒!");		
		return null;
	}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.sql.Time;
public class test {    //调用Proxy的静态方法，创建一个代理类
	public static void main(String[] args) {
		Car car=new Car();
		InvocationHandler h=new TimeHandler(car);
		InvocationHandler l=new LogHandler(car); 
		Class<?> cls=car.getClass();
		/*
		 * loader:类加载器
		 * interface:实现接口
		 * h InvocationHandler
		 * 
		 * 动态代理实现思路
		 * 实现功能：通过Proxy类的NewProxyInstance方法返回代理对象
		 * 1.声明一段源码（动态产生代理）
		 * 2.编译源码（JDK Compiler API），产生新的类(代理类)
		 * 3.将这个类load到内存当中，产生一个新的对象(代理对象)
		 * 4.return 代理对象
		 */
		Movable m=(Movable)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h);
	    m.move();
System.out.println("-----------------------------");
	    Movable m2=(Movable)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), l);
	    m2.move();
	}
}

输出：

汽车开始行驶....

汽车行驶中...

汽车行驶结束...汽车行驶时间为：168毫秒!



2.4 使用cglib动态产生代理



public class Train {
     public void move() {
    	 System.out.println("火车行驶中....");
     }
}

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy implements MethodInterceptor {
    private Enhancer enhance=new Enhancer();
    //得到代理类
	public Object getProxy(Class clazz) {
		//设置创建子类的类
		enhance.setSuperclass(clazz);
		enhance.setCallback(this);
		return enhance.create();
	}
	/*
	 * 拦截所有目标类方法的调用
	 * obj 目标类的实例
	 * m 目标方法的反射对象
	 * args 方法的参数
	 * proxy 代理类的实例
	 */
	public Object intercept(Object obj, Method m, Object[] args, 
			MethodProxy proxy) throws Throwable {
		//代理类调用父类的方法
		System.out.println("日志开始...");
		proxy.invokeSuper(obj, args);
		System.out.println("结束日志...");
		return null;
	}
}

输出：

日志开始...

火车行驶中....

结束日志...

 

3. 自定义类模拟JDK动态代理的实现(视频中写了底层源码，跟不上)

3.1 模拟JDK动态代理实现思路分析及简单实现

3.2 完善动态代理实现

3.3 动态代理实现添加InvocationHandler

4. 代理模式总结






张Kyle
关注
MyBatis架构设计中的经典设计模式分析
张彦峰的博客
12-28 170万+
本文通过深入分析 MyBatis 框架中的设计模式，探讨了多个关键设计模式如何在 MyBatis 中实现和应用，包括工厂模式、单例模式、代理模式和责任链模式等。通过对源码的详细解读，本文阐述了这些设计模式如何提升框架的灵活性、可维护性和扩展性。文章旨在帮助开发者理解并掌握 MyBatis 框架中的设计模式应用，从而在实际项目中优化数据访问层的架构设计。
动态代理（二）---Cglib两种代理方式初探(非JDK代理)
u010663871的专栏
08-23 812
前言 曾经尝试在网上搜索 cglib的两种代理方式，搜到的结果基本全是讲动态代理的两种方式而非Cglib动态代理的两种方式。 按我的理解Cglib动态代理有两种，JDK的有一种，一共应该是三种动态代理才对。 本文灵感来源：在学习Spring框架的AOP模块时，在被代理方法（此处假设该方法的持有类为TestBean）里执行System.out.println(this.getCla
5.CGLIB动态代理源码之Enhancer的创建
qq_30635523的博客
03-07 1344
Cglib动态代理源码 在cglib动态代理中生成代理对象核心代码是下面2句。 java //创建Enhancer Enhancer enhancer = new Enhancer(); //使用Enhancer创建代理类对象 Calculator calculator = (Calculator) enhancer.create(); 调用代理对象的代码是下面1句。 java /...
Java 动态代理，看这篇就够了
weixin_33938733的博客
09-05 307
这篇文章需要用到 Java 的反射知识，如果对反射还不清楚的小伙伴，可以先移步到这里 《Java进阶-反射》。 编程思想都是来自于生活的，“代理” 在生活中很常见。比如我们买一个东西时，一般都不会是直接从工厂里买的，而是去商店或者其他的商家买，这些商家做的事情就是代理。再比如，做微商的朋友经常在朋友圈里推广商品，它们也是代理商。Java 程序中的代理是用接口实现的，用户买某件商品的需求就可以看做是...
[java-代理]测试Proxy和Enhancer两种代理方式
u010989191的博客
02-18 4124
区别Proxy是基于接口的方式进行代理，Enhancer是基于继承的方式代理。 proxy是java.lang.reflect.* enhancer是net.sf.cglib.*测试代码:package main;import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.
Java的三种代理模式 Spring代理
PitBXu的博客
05-15 1201
Java的三种代理模式 1.代理模式 ​ 代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 ​ 这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需改修改，可以通过代理的方式来扩展该方法。 ​ 举个例子来说明代理的作用：假设我们想邀请一位明星，...
Cglib的几种Callback简介
03-28 5389
Callback是Cglib中一个比较核心的概念，看一下下面的示例代码：import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class T
设计模式系列之代理模式
01-28
组成： ...代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
js设计模式之代理模式及订阅发布模式实例详解
01-21
本文实例讲述了js设计模式之代理模式及订阅发布模式。分享给大家供大家参考，具体如下： 为啥将两种模式放在一起呢？因为这样文章比较长啊。 写博客的目的我觉得首要目的是整理自己的知识点，进而优化个人所得知识...
C# 设计模式系列教程-代理模式
12-26
　解决的问题：如果直接访问对象比较困难，或直接访问会给使用者或系统带来一系列问题。这样对于客户端（调用者）来说，就不需要直接与真实对象进行交互，解除了调用者与真实对象的耦合。 2. 模式中的角色 　2.1 ...
js策略模式和代理模式
11-22
策略模式和代理模式是设计模式中的两种常见模式，它们在软件开发中扮演着重要的角色，尤其是在JavaScript中，这两种模式提供了更加灵活和可维护的代码结构。 策略模式（Strategy Pattern）是一种行为设计模式，它...
动态代理和静态代理
xiao1491944538的博客
09-10 187
ISubject（抽象主题类）:在这个类中，主要声明真实主题类和代理类的共同方法。它既可以是一个接口也可以是一个抽象类。 　　RealSubject（真实主题类）:这是被代理类，具体的业务实现都在这个类中。 　　Proxy（代理类）:这是一个代理类，在这个代理类中它持有真实主题类的对象。通过调用真实主题类的方法来实现代理。 对静态代理模式，代理者的代码都是通过程序员或者是通过一些自动化的工具生成的固定代码然后再对他们进行编译。这样也就意味着在我们的代码运行之前代理类的Class文件就已...
drawable.setCallback（空）的后果
张文达的博客
03-28 2391
drawable.setCallback（空）的后果 yuan文地址 ：CodeGo.net/362871/  同时努力可绘制对象的小缓存，我才知道，泄漏关闭活动后，我需要解除那些可绘：设置自己的回调为null。 保持可绘制对象缓存在每个活动将需要额外的代码，我试过后，他们解除绑定setImageDrawable(drawable)我没有看到任何后果至今。 这是从MyIma
Java-代理
测试
02-28 164
Jdk动态代理(代理接口) 通过获取委托类实现的所有接口，为每个接口方法创建一个代理方法，通过ProxyGenerator.generateProxyClass动态生成代理类字节码文件并加载，反射生成代理对象，代理对象调用的时候通过自定义的InvocationHandler（super.h）调用invoke方法，在回调方法invoke...
java 内存溢出（方法区溢出）
iteye_171的博客
07-26 691
package jvm; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; /** * -XX:PermSi...
java中的代理
胖墩的IT博客
07-21 232
代理分为两种：静态代理和动态代理 1、静态代理 2、动态代理 目前我知道的动态代理分为两种： 基于JDK的动态代理：代理类和实体类要实现同一个接口 基于cglib的动态代理：代理类要继承实体类，第三方的 最后目的相同，代理实体类，做一些额外的工作 （1）基于JDK的动态代理 接口 public interface ForumService { void removeTopic(int ...
java的三种代理模式(AOP原理)
放羊的大飞
03-20 586
一、静态代理: 1个接口+2实现类，不灵活 二、JDK动态代理 1.又叫动态代理、JDK代理。目标对象一定要实现接口(否则只能用CGLib动态代理)，代理类是 java.lang.reflect.Proxy类。 a.定义接口; b.创建真实委托类，实现接口; c.创建中间类，实现InvocationHandler接口，重写invoke方法，同时可...
cglib callback几种用法
gdhgr的博客
10-19 3237
转自：：https://blog.youkuaiyun.com/difffate/article/details/70552056  尊重原创   前面介绍了代理模式，讲了动态代理常见的实现方式，包含了JDK的动态代理和CGLib的动态代理。本文将介绍下CGLib动态代理及几种用法。CGLib（Code Generation Library）是一个高效的代码生成库，底层实现是使用asm来转换字节码生成类...
js-4 代理Proxy，object原型链, prototype, 继承，
白白的博客
02-20 1394
1.什么是代理Proxy拦截？ 可以对对象，函数，数组进行拦截,将其原本的函数操作改写。 Proxy在目标对象前设一个拦截层，外界对该对象的访问都必须先通过这层拦截，因此提供了一种机制可以对外界的访问进行过滤和改写。 1.obj是原对象，property是实参，函数是要进行的操作 "use strict" const hd = {name:"fff", age :10}; con...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值