用一个小故事模拟Spring-Aop(一)--动态代理和责任链

最新推荐文章于 2022-06-21 20:54:01 发布
最新推荐文章于 2022-06-21 20:54:01 发布
阅读量388 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40984185/article/details/123167954
版权

代理模式

假如现在有个厂家生产了一台生成冰淇淋的机器，支持蛋筒和杯装冰淇淋，点击不同口味的按键，不同的大小，投放硬币，就可以根据选择的口味生成大/中/小的草莓冰淇淋，原味冰淇淋，巧克力冰淇淋(这台机器就相当于一个类，蛋筒和杯装是两个不同的方法，点击的口味的按钮和规格按钮相当于参数，冰淇淋是方法的返回值)。
代码模拟

接口:

public interface IceCreamMachine {
	/**
	 * 模拟生产杯装冰淇淋
	 * @param taste 草莓/原味/巧克力
	 * @param size 大/中/小
	 * @return 冰淇淋
	 */
	String cup(String taste, String size);
	/**
	 * 模拟生产蛋筒冰淇淋
	 * @param taste 草莓/原味/巧克力
	 * @param size 大/中/小
	 * @return 冰淇淋
	 */
	String eggCone(String taste, String size);
}

实现

/**
 * @Author wmf
 * @Date 2022/1/18 15:37
 * @Description 模拟一个冰淇淋机
 */
public class IceCreamMachine1 implements IceCreamMachine {
	/**
	 * 模拟生产杯装冰淇淋
	 * @param taste 草莓/原味/巧克力
	 * @param size 大/中/小
	 * @return 冰淇淋
	 */
	@Override
	public String cup(String taste, String size) {
		System.out.println("开始生产杯装冰淇淋");
		return taste + " 杯装冰淇淋("+size+")";
	}

	/**
	 * 模拟生产蛋筒冰淇淋
	 * @param taste 草莓/原味/巧克力
	 * @param size 大/中/小
	 * @return 冰淇淋
	 */
	@Override
	public String eggCone(String taste, String size) {
		System.out.println("开始生产蛋筒冰淇淋");
		return taste + " 蛋筒冰淇淋("+size+")";
	}
}

写个测试类来跟进整个过程

/**
 * @Author wmf
 * @Date 2022/1/18 15:45
 * @Description
 */
public class ChainApplication {
	public static void main(String[] args) {
		IceCreamMachine machine = new IceCreamMachine1();
		String iceCream = machine.cup("草莓", "大");
		System.out.println(iceCream); // 正常输出： 草莓 杯装冰淇淋(大)
	}
}

输出： 1.开始生产杯装冰淇淋 2.草莓 杯装冰淇淋(大)

过了一段时间厂家领导要做市场调研，想收集每天大家都选择了什么口味，选择了什么规格，然后做市场分析(相当于一个Before 拦截器)。
为了应付这个工作，没办法厂家雇了一个售货员看着机器，以后大家有啥需求不再直接去操作机器，而是告诉这个售货员，这个售货员先把需求记录下来写在记录本上，然后再去按需操作机器，再把冰淇淋递给用户(这个售货员就是这台机器的代理)。

这种实现起来也很简单，最简单的方式就是代理模式

/**
 * @Author wmf
 * @Date 2022/1/18 15:58
 * @Description 机器的代理
 */
public class IceCreamMachineProxy implements IceCreamMachine {
	public IceCreamMachineProxy(IceCreamMachine iceCreamMachine) {
		this.iceCreamMachine = iceCreamMachine;
	}
	private IceCreamMachine iceCreamMachine;
	@Override
	public String cup(String taste, String size) {
		System.out.println("模拟记录需求"+taste+size);
		return iceCreamMachine.cup(taste, size);
	}
	@Override
	public String eggCone(String taste, String size) {
		System.out.println("模拟记录需求"+taste+size);
		return iceCreamMachine.eggCone(taste, size);
	}
}

测试一下

public class ChainApplication {
	public static void main(String[] args) {
		IceCreamMachine machine = new IceCreamMachine1();
		IceCreamMachine machineProxy = new IceCreamMachineProxy(machine);
		String iceCream = machineProxy.cup("草莓", "大");
		System.out.println(iceCream); 
	}
}

输出：1.模拟记录需求(草莓 大) 2.开始生产杯装冰淇淋 3.草莓 杯装冰淇淋(大)

动态代理

通过找个售货员方式(代理模式)，很轻松实现每次客户下完需求，把需求记录下来，然后再进行正常交易。 后来厂家越做越大，冰淇淋机越来越多，而且又引进了很多新机器，领导对新的机器质量不放心，于是规定说新机器不光要采集用户需求，又要查看机器产出的冰淇淋是否达标(相当于一个Around 拦截器)。这样就导致每个机器不光要配一个售货员(代理)，每个售货员干的活还不一样，导致人力成本和培训成本急速提高。
这时候来了个代理公司说我们可以帮你解决这个问题，只要你们每次约定好哪个冰淇淋机，计划好额外的工作(拦截器)，我们就培养出一个售货员来负责冰淇淋机 ，你们只要专心生产机器并做好计划就好(代理公司根据约定培养出销售员的过程就是动态代理)。
那么重点问题就来了，厂家和代理公司怎么做约定， 代理公司就说了我们约定好，每次来了客户的需求，我们售货员会把需求的信息打包出来，打包的信息包含用户的需求，机器的信息，开始的按钮(点击之后可以返回冰淇淋)，由于现在只是计划阶段并没有实际的需求，我们只是打包信心的格式规定好，你们只要计划好针对这个打包的信息如何处理，并制定好拦截工作计划(以下统称拦截计划)即可(定义拦截器)。

image.png

打包的信息格式于这样

机器：机器的信息
产品：蛋筒或草莓
需求：客户的需求
按钮：点击开始按钮(点击之后返回冰淇淋)

代码模拟就是

/**
 * @Author wmf
 * @Date 2022/1/19 10:05
 * @Description 打包信息的格式
 */
public interface MethodInvocation {
	/**
	 * 机器的信息
	 * @return
	 */
	Object getThis();
	/**
	 * 方法的信息(杯装还是蛋筒)
	 * @return
	 */
	Method getMethod();
	/**
	 * 客户需求的信息(草莓/原味/巧克力 大/中/小)
	 * @return
	 */
	Object[] getArguments();
	/**
	 * 开始按钮，点击返回冰淇淋
	 * @return
	 * @throws Throwable
	 */
	Object proceed() throws Throwable;

}

MethodInvocation 这个名字是按照spring起的，因为spring的MethodInvocation 都是各种继承的，不方便看。所以重写一个，接下来还是使用spring的MethodInvocation(因为一样)

厂家和代理公司商量好了这个约定的返回信息格式，厂家发给代理公司的拦截计划当然肯定不能瞎鸡写，必须也有一个格式，这要格式就是只要能处理这个打包信息并且执行打包信息的开始按钮返回冰淇淋即可
拦截计划的格式模拟代码

@FunctionalInterface
public interface MethodInterceptor {
	Object invoke(MethodInvocation invocation) throws Throwable;
}

两方规定好了这些规范，接下来就是厂家定制计划的时候，如果是食品监督他们定制的计划可能是这样的

Object invoke(MethodInvocation invocation) {
    //1.从打包信息invocation获取需求(invocation.getArguments())记在小本上
    //2.开始生产冰淇淋(invocation.proceed())
    //3.把生产出的冰淇淋拍个照发给厂家微信
}

对应的代码模拟

MethodInterceptor interceptor = new MethodInterceptor() {
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("记录需求："+invocation.getArguments());
		Object proceed = invocation.proceed();
		System.out.println("对生产出的冰淇淋拍照"+proceed);
		return proceed;
	}
};

厂家的冰淇淋机和拦截计划都准备好了，剩下的活就是代理公司的了，代理公司需要根据你的机器和拦截计划给你定制一个售货员(生成动态代理)

我们以jdk动态代理的方式模拟代理公司的这个过程(不懂jdk动态代理自己补吧)

/**
 * @Author wmf
 * @Date 2022/1/12 18:23
 * @Description 代理公司
 */
public class ProxyCompany implements AopProxy, InvocationHandler { // AopProxy相当于国家给所有代理公司下发的一个标准

	public ProxyCompany() {
	}
	/**
	 * 设置拦截计划
	 * @param interceptor
	 */
	public void setInterceptor(MethodInterceptor interceptor) {
		this.interceptor = interceptor;
	}
	/**
	 * 绑定冰淇淋机
	 * @param target
	 */
	public void setTarget(Object target) {
		this.target = target;
	}
	/**
	 * 附加工作
	 */
	MethodInterceptor interceptor;
	/**
	 * 冰淇淋机
	 */
	Object target;

	/**
	 * 生成售货员(代理)
	 * @return
	 */
	@Override
	public Object getProxy() {
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

	@Override
	public Object getProxy(ClassLoader classLoader) {
		return null;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 打包的信息 上面提到过
		MethodInvocation invocation = new MethodInvocation() {
			@Override
			public Method getMethod() {
				return method;
			}
			@Override
			public Object[] getArguments() {
				return args;
			}
			@Override
			public Object proceed() throws Throwable {
				return method.invoke(target, args);
			}
			@Override
			public Object getThis() {
				return target;
			}
			@Override
			public AccessibleObject getStaticPart() {
				return null;
			}
		};
		// 需求来了之后按拦截计划去执行
		return interceptor.invoke(invocation);
	}
}

测试整个过程：

public class ChainApplication {
	public static void main(String[] args) {
		// 厂家的冰淇淋机
		IceCreamMachine machine = new IceCreamMachine1();
		// 厂家定制拦截计划
		MethodInterceptor interceptor = new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("记录需求："+invocation.getArguments()[0]);
				Object proceed = invocation.proceed();
				System.out.println("对生产出的冰淇淋拍照"+proceed);
				return proceed;
			}
		};
		// 代理公司
		ProxyCompany proxyCompany = new ProxyCompany();
		// 绑定冰淇淋机到代理公司
		proxyCompany.setTarget(machine);
		// 绑定拦截计划到代理公司
		proxyCompany.setInterceptor(interceptor);
		// 生成售货员(机器的代理)
		IceCreamMachine saler = (IceCreamMachine) proxyCompany.getProxy();
		String iceCream = saler.eggCone("原味", "中");
	}
}

输出： 1. 记录需求：原味 2.开始生产蛋筒冰淇淋 3.对生产出的冰淇淋拍照 原味 蛋筒冰淇淋(中)

就这样过了一段时间，厂家和代理公司配合很好，厂家专注维护机器制定拦截计划，代理公司专注培养代理售货员。

责任链模式

又过了一段时间，出现问题了，厂家领导提出新的需求，我们新出一台机器要加多个拦截计划：既要市场调研又要食品监督，而且还说了我们之前做了那么多计划了，改肯定是不行，只能新加，这样一来代理公司愁了，没办法，改方案吧

首先第一步，一个机器对应多个拦截计划

/** * 附加工作列表 */ 
List<MethodInterceptor> interceptors;

现在有多个计划，每个计划都包含了开始的按钮，那怎么执行呐，循环?循环就废了，人家客户要一个冰淇淋你可能给人家生成多个(点了多次开始按钮)。
代理公司有个人提出了解决方案，让每个售货员学会通灵术!!!，没错就是火影忍者里的通灵术，但不是召唤大蛤蟆，而是召唤一个调度员，这个调度员一个个执行拦截计划，当某个拦截计划写着点击开始按钮时，不是实际的点击开始，而是交给调度进行下一个拦截计划(相当于把开始按钮调包了)，最后再没有拦截计划时再实际点击开始按钮，这里有点绕，看下面的例子

比厂家一台机器有两个计划

食品监督计划：

Object invoke(MethodInvocation invocation) {
    //1.口味/规格记在食品监督小本上
    //2.开始生产冰淇淋(invocation.proceed())
    //3.生产出的冰淇淋拍个照发给厂家微信
}

市场调研计划：

Object invoke(MethodInvocation invocation) {
    //1.口味/规格记在市场调研小本上
    //2.开始生产冰淇淋(invocation.proceed())
}

实际来客户购买冰淇淋时，售货员拿到两个计划交给召唤出的调度员，调度员是这么调度的

按第一个计划(食品监督计划)先走
1.1 口味/规格记在食品监督小本上
1.2 开始生产冰淇淋(拿到这个指令时，调度员实际开始进行下一个计划)
├── 2.1 口味/规格记在市场调研小本上
├── 2.2 开始生产冰淇淋 ***此时没有下一个拦截计划，真正点击开始按钮***
1.3 生产出的冰淇淋拍个照发给厂家微信

所以调度员的任务就是调包开始按钮，记录好拦截计划列表执行到第几个，一个个执行，形成一条链

示意图如下：

image.png

代码模拟：

/**
 * @Author wmf
 * @Date 2022/1/19 13:59
 * @Description 调度员
 */
public class Dispatcher {
	/**
	 * 原打包信息
	 */
	private MethodInvocation methodInvocation;
	/**
	 * 调包后的打包的信息
 	 */
	private MethodInvocation changelingMethodInvocation;
	/**
	 * 拦截计划列表
	 */
	private List<MethodInterceptor> chain;

	/**
	 * 执行拦截计划的游标
	 */
	private Integer index = -1;

	public Dispatcher(MethodInvocation methodInvocation, List<MethodInterceptor> chain) throws Throwable {
		this.chain = chain;
		Dispatcher that = this;
		// 存储调度员原打包的信息
		this.methodInvocation = methodInvocation;
		// 调包打包信息里面的开始按钮
		this.changelingMethodInvocation = new MethodInvocation() {
			@Override
			public Object getThis() {
				return methodInvocation.getThis();
			}
			// 不管
			@Override
			public AccessibleObject getStaticPart() {
				return null;
			}
			@Override
			public Method getMethod() {
				return methodInvocation.getMethod();
			}
			@Override
			public Object[] getArguments() {
				return methodInvocation.getArguments();
			}
			/** 调包开始按钮，工作执行计划的开始按钮实际上指向调度员的proceed**/
			@Override
			public Object proceed() throws Throwable {
				return that.proceed();
			}
		};
	}

	/**
	 * 调度员的工作
	 * @return
	 * @throws Throwable
	 */
	public Object proceed() throws Throwable {
		Object re;
		// 最后一次，没有拦截计划了，开始生产冰淇淋
		if (index == chain.size()-1) {
			re =  methodInvocation.proceed();
		}else{ // 还有下一个拦截计划，继续按照下一个拦截计划执行
			re = chain.get(++index).invoke(changelingMethodInvocation);
		}
		return re;
	}
}

修改代理公司培养售货员逻辑，改动的地方标注了(改)

/**
 * @Author wmf
 * @Date 2022/1/12 18:23
 * @Description 代理公司
 */
public class ProxyCompany implements AopProxy, InvocationHandler { // AopProxy相当于国家给所有代理公司下发的一个标准

	public ProxyCompany() {
	}
	/**
	 * (改)添加拦截计划
	 * @param interceptor
	 */
	public void addInterceptor(MethodInterceptor interceptor) {
		this.interceptors.add(interceptor);
	}
	/**
	 * 绑定冰淇淋机
	 * @param target
	 */
	public void setTarget(Object target) {
		this.target = target;
	}
	/**
	 * (改)附加工作列表
	 */
	List<MethodInterceptor> interceptors = new ArrayList<>();
	/**
	 * 冰淇淋机
	 */
	Object target;

	/**
	 * 生成售货员(代理)
	 * @return
	 */
	@Override
	public Object getProxy() {
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

	@Override
	public Object getProxy(ClassLoader classLoader) {
		return null;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 打包的信息 上面提到过
		MethodInvocation invocation = new MethodInvocation() {
			@Override
			public Method getMethod() {
				return method;
			}
			@Override
			public Object[] getArguments() {
				return args;
			}
			@Override
			public Object proceed() throws Throwable {
				return method.invoke(target, args);
			}
			@Override
			public Object getThis() {
				return target;
			}
			@Override
			public AccessibleObject getStaticPart() {
				return null;
			}
		};
		// (改)使用通灵术召唤一个调度员
		Dispatcher dispatcher = new Dispatcher(invocation, interceptors);
		// (改)需求来了之后让调度员去执行
		return dispatcher.proceed();
	}
}

测试一下

public class ChainApplication {
	public static void main(String[] args) {
		// 厂家的冰淇淋机
		IceCreamMachine machine = new IceCreamMachine1();
		// 厂家定制食品监督计划
		MethodInterceptor interceptor1 = new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("记录需求至食品监督本："+invocation.getArguments()[0]);
				Object proceed = invocation.proceed();
				System.out.println("拍照传给厂家微信："+proceed);
				return proceed;
			}
		};
		// 厂家定制市场调研计划
		MethodInterceptor interceptor2 = new MethodInterceptor() {
			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("记录需求至市场调研本："+invocation.getArguments()[0]);
				return invocation.proceed();
			}
		};
		// 代理公司
		ProxyCompany proxyCompany = new ProxyCompany();
		// 绑定冰淇淋机
		proxyCompany.setTarget(machine);
		// 绑定两个拦截计划
		proxyCompany.addInterceptor(interceptor1);
		proxyCompany.addInterceptor(interceptor2);
		// 生成售货员(机器的代理)
		IceCreamMachine saler = (IceCreamMachine) proxyCompany.getProxy();
		String iceCream = saler.eggCone("原味", "中");
	}
}

输出：

记录需求至食品监督本：原味
记录需求至市场调研本：原味
开始生产蛋筒冰淇淋
拍照传给厂家微信：原味 蛋筒冰淇淋(中)

完全满足了厂家需求，调度员使用这种方式完成了拦截计划一个接一个的执行，就是一条责任链

如上Dispatcher调包的方式还是使用的类似代理模式，写法有点丑，售货员完全可以把打包信息的工作也交给调度员，而调度员实现调包的方式也可以同过继承覆盖来实现，于是优化下代码，(按spring的命名 Dispatcher以下修改为ReflectiveMethodInvocation)，优化后的代码如下

ProxyCompany:

/**
 * @Author wmf
 * @Date 2022/1/12 18:23
 * @Description 代理公司
 */
public class ProxyCompany implements AopProxy, InvocationHandler { // AopProxy相当于国家给所有代理公司下发的一个标准

	public ProxyCompany() {
	}
	/**
	 * 设置拦截计划
	 * @param interceptor
	 */
	public void addInterceptor(MethodInterceptor interceptor) {
		this.interceptors.add(interceptor);
	}
	/**
	 * 绑定冰淇淋机
	 * @param target
	 */
	public void setTarget(Object target) {
		this.target = target;
	}
	/**
	 * 附加工作列表
	 */
	List<MethodInterceptor> interceptors = new ArrayList<>();
	/**
	 * 冰淇淋机
	 */
	Object target;

	/**
	 * 生成售货员(代理)
	 * @return
	 */
	@Override
	public Object getProxy() {
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

	@Override
	public Object getProxy(ClassLoader classLoader) {
		return null;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 使用通灵术召唤一个调度员，并把打包的工作也交给调度员
		ReflectiveMethodInvocation dispatcher = new ReflectiveMethodInvocation(target, method, args, interceptors);
		// 需求来了之后按拦截计划去执行
		return dispatcher.proceed();
	}
}

ReflectiveMethodInvocation(原Dispatcher):

/**
 * @Author wmf
 * @Date 2022/1/17 18:05
 * @Description 调度员本身就是一个打包信息，所以继承了MethodInvocation，自己重新实现了proceed
 */
public class ReflectiveMethodInvocation implements MethodInvocation {

	private Object target;

	private Method method;

	private Object[] args;

	/**
	 * 拦截计划列表
	 */
	List<MethodInterceptor> chain;

	private int index = -1;

	public ReflectiveMethodInvocation(Object target, Method method, Object[] args, List<MethodInterceptor> chain) {
		this.target = target;
		this.method = method;
		this.args = args;
		this.chain = chain;
	}

	@Override
	public Method getMethod() {
		return this.method;
	}

	@Override
	public Object[] getArguments() {
		return args;
	}

	@Override
	public Object proceed() throws Throwable {
		Object re;
		if (index == chain.size()-1) {
			re =  method.invoke(target, args);
		}else{
			re = chain.get(++index).invoke(this);
		}
		return re;
	}

	@Override
	public Object getThis() {
		return target;
	}

	@Override
	public AccessibleObject getStaticPart() {
		return null;
	}
}

测试方法还是不变，输出结果页一样(写法干净了很多)

以上就是整个spring aop动态代理+方法拦截+责任链模式的整个思路，下面对比下源码

对比spring

ReflectiveMethodInvocation对比spring ReflectiveMethodInvocation:

image.png

ProxyCompany(使用的是jdk动态代理)对比spring的JdkDynamicAopProxy:

image.png

MethodInterceptor和MethodInvocation就是直接用的spring的，所以不用对比了。

over~

后期会再扩展一下，把整个aop都加上

pq先生217
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手动模拟实现Spring-AOP
yangsnow_rain_wind的专栏
05-07 1188
Spring中AOP设计思路是这样的. 在BeaFactory.getBean()时,调用方法initBean(); 在该方法中判断当前Bean是否含有满足SpEL表达式的Method, 没有的话, 返回原始的Bean, 有的话, 会对当前Bean做动态代理, 当代理对象的方法被调用时,会发送通知到Aop拦截器,进而实现Aop的功能. 本篇文章思路接着上篇文章, (手动模拟实现Spr...
简单理解JDK动态代理使用拦截器和责任链模式
m0_56058975的博客
12-08 741
目录 1.拦截器 1.1在JDK代理中使用拦截器： 2.责任链模式 2.1定义责任链拦截器接口 由于动态代理一般都比较难理解，程序设计者会设计一个拦截器接口供开发者使用，开发者只要知道拦截器接口的方法、含义和作用即可，无须知道动态代理是怎么实现的。用JDK动态代理来实现一个拦截器的逻辑，为此先定义拦截器接口Interceptor 1.拦截器 package service; import java.lang.reflect.Method; public interface...
aop学习笔记之Aop责任链（四）
zyb2017的博客
03-15 2297
一 Aop责任链 如何理解责任链呢？当一个切面有多个织入时，这些需要织入的方法就形成了一个责任链，就像Filter链一样 二 原理 看了上图我们理解一下，责任链中包含每一个Handler，那每个Hanlder在执行之后，程序是怎么知道下次要执行哪个Handler呢？我们先做出假设，每个Handler中存储着NextHandler，这样程序就知道下次执行哪个了 三 责任链实现 ...
mybatis 插件的原理-责任链和动态代理的体现
Homejim的博客
09-28 487
如果没有自定义过拦截器， 可以看我前面的文章。如果不知道 JDK 动态代理怎么使用的， 可以看我这文章。 责任链设计模式理解起来很简单， 网上找个例子看看即可。 mybatis 插件的原理使用的是动态代理和责任链来实现的。 1 拦截哪些方法 在前面说过， 可以通过注解 Intecepts 和 Signature 来进行指定拦截哪些方法。 然而， 并不是说所有的方法都可以拦截的。 mybatis 拦...
动态代理模式和责任链模式
罐头里的沙丁鱼
10-21 1351
代理：即中介的意思，比如客户，公司产品经理，软件工程师之间的管理。产品经理为代理者，软件工程师为被代理者。回到代码中，客户就是主程序，软件工程师就是切面程序
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-4.3.20.RELEASE-API文档-中英对照版.zip
04-07
赠送jar包：spring-aop-4.3.20.RELEASE.jar 赠送原API文档：spring-aop-4.3.20.RELEASE-javadoc.jar 赠送源代码：spring-aop-4.3.20.RELEASE-sources.jar 包含翻译后的API文档：spring-aop-4.3.20.RELEASE-...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
spring-aop-5.0.8.RELEASE-API文档-中英对照版.zip
06-12
赠送jar包：spring-aop-5.0.8.RELEASE.jar； 赠送原API文档：spring-aop-5.0.8.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.8.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.8.RELEASE.pom；...
Spring AOP简单模拟
05-25
模拟AOP源码 博文链接：https://senny.iteye.com/blog/466622
代理模式(含动态代理讲解)【Spring AOP实质】
04-21
NULL 博文链接：https://fangguanhong.iteye.com/blog/1911895
spring之AOP（动态代理）
09-06
spring之AOP（动态代理），包括jdk动态代理和CGLib动态代理
（Spring笔记）AOP切面编程——模拟实现AOP
张松的博客
06-15 554
AOP全称为Aspect Oriented Programming——面向切面编程，可通过运行期动态代理实现程序功能统一维护的一种技术。AOP是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。......
基于代理机制-正则表达式模拟实现SpringAOP
wexin_mylove的博客
06-21 204
Spring的AOP面向切面编程的核心在于对于一个切点的执行过程可以进行干预，加入前置拦截、后者拦截以及异常处理等，其中的底层原理是使用代理机制得到一个代理对象，实现方法的代理调用，以及通过给切面的切点添加拦截器链，在参考了SpringAOP的一系列源码后，简单模拟实现了面向切面编程的几个重要部分，如下基本上分为三个部分： 1、代理对象的获取 2、切点的匹配以及拦截器链的实现 3、对代理对象执行方法的参数以及结果的获取与处理 下面对这三个方面的实现进行具体阐述
Spring3.0 AOP 详解
iteye_2022的博客
04-26 194
一、什么是 AOP。 AOP（Aspect Orient Programming），也就是面向切面编程。可以这样理解，面向对象编程（OOP）是从静态角度考虑程序结构，面向切面编程（AOP）是从动态角度考虑程序运行过程。 二、AOP 的作用。 常常通过 AOP 来处理一些具有横切性质的系统性服务，如事物管理、安全检查、缓存、对象池管理等，AOP 已经成为一种非常常用的解决方案。 三、...
spring aop学习9:Aop的链式调用(责任链模式)
Tiglle的博客
10-30 4616
一.责任链模式 1.基本的责任链模式 ◆主体父类:abstract class Subject.javapackage com.tiglle.responsibility.chain.model; //主体 public abstract class Subject { private Subject successor; protected abstract void handle
spring-boot-starter-aop和spring-boot-starter-parent的区别
最新发布
03-17
- spring-boot-starter-aop是一个用于支持面向切面编程（AOP）的Spring Boot启动器。 - 它提供了AOP所需的依赖项和配置，使得在Spring Boot应用中使用AOP变得更加简单。 - AOP可以帮助我们将横切关注点（如日志...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值