spring源码学习系列1.1-ProxyFactory AopProxy与Proxy之间的关系

最新推荐文章于 2024-04-08 09:49:53 发布
最新推荐文章于 2024-04-08 09:49:53 发布
阅读量268 收藏
点赞数
分类专栏： spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_15360/article/details/82680683
版权
1.ProxyFactory持有生成代理的相关资源，如advice targetSource等属性(资源)。ProxyFactory是ProxyConfig及AdvisorSupport的子类,这些属性在AdvisorSupport中。

在ProxyFactory中委托AopProxyFactory生成AopProxy,并将自身传给AopProxy

[color=red]可以将ProxyFactory当做现实中的某个工厂。工厂中有各种各样的原材料,在这里，这些原材料就是目标类，目标类所实现的接口，拦截器等等。目标类或者接口可以想象成要加工的东西，而拦截器等就是一些辅助材料，用来加工最终成型的产品。
对于调用这来说，他只要提供材料就行或最终得到产品就行，不需要关心这些材料在一起怎么生成产品的[/color]

例如：ProxyFactoryHelloWorld.java

2.AopProxy通过AopProxyFacotory生成，AopProxy持有以上ProxyFactory的对象,也即拥有了生成代理的相关资源。引用已有的某个对象的方法，可以继承某个对象或者持有某个对象,这个用了第二种方式即引用。

[color=red]DefaultAopProxyFactory可以看做一个更大的工厂，包括了ProxyFactory这个小工厂或小作坊中的一些原材料(AdvisorSupport)。DefaultAopProxyFactory并不是ProxyFactory的子类，而是通过引用拥有了这个小工厂或者通过引用(AdvisorSupport)从而拥有了ProxyFactory相关的原材料[/color]

[color=red]DefaultAopProxyFactory中仅仅通过new JdkDynamicAopProxy(config);或者CglibProxyFactory.createCglibProxy(config);来创建AopProxy对象。依据是ProxyFactory中的某些属性或者原材料[/color]

例如：AopProxyHelloWorld.java

3.AopProxy中继续通过Proxy生成最终代理，最终代理中持有AopProxy对象。

AopProxy：Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects

[color=red]AopProxy才可以最终生成实际的代理对象,当然DefaultAopProxyFactory这个工厂制造AopProxy这个产品时，也将ProxyFactory这个小作坊(AdvisorSupport)给了AopProxy或者AopProxy可以使用ProxyFactory的原材料。[/color]

以JdkDynamicAopProxy为例,其实现了InvocationHandler接口

例如：ProxyHelloWorld.java


综上：
[color=red]原材料其实保存在ProxyFactory的父类AdvisedSupport中。ProxyFactory，AopProxyFactory,AopProxy通过不同方式共享这个AdvisedSupport中的原材料。AopProxy只是一个半成品,实际的代理对象中包括了这个半成品AopProxy。调用代理对象时，也是通过半成品aopProxy来执行代理操作[/color]

[color=red]原材料的输入是在后置处理器InfrastructureAdvisorAutoProxyCreator中产生的[/color]


ProxyFactoryHelloWorld 
package com.bill.tx;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;

public class ProxyFactoryHelloWorld {
	public static void main(String[] args) {
		ProxyFactory pf = new ProxyFactory();

		pf.setTarget(new HelloWorldImpl());// 基本材料
		pf.setInterfaces(HelloWorldImpl.class.getInterfaces());

		pf.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before1");
			}
		});

		pf.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before2");
			}
		});

		pf.addAdvice(new AfterReturningAdvice() {

			@Override
			public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
				System.out.println("afterReturning");
			}
		});

		pf.addAdvice(new MethodInterceptor() {

			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("MethodInterceptor-start");
				Object retValue = invocation.proceed();
				System.out.println("MethodInterceptor-end");
				return retValue;
			}


		});

		HelloWorld hello = (HelloWorld) pf.getProxy(pf.getClass().getClassLoader());
		String retValue = hello.sayHello("jpj");

		System.out.println("==================输出返回值");
		System.out.println(retValue);
	}
}



AopProxyHelloWorld 
package org.springframework.aop.framework;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import com.bill.tx.HelloWorld;
import com.bill.tx.HelloWorldImpl;

public class AopProxyHelloWorld {
	public static void main(String[] args) {
		AdvisedSupport config = new AdvisedSupport(); // 原材料

		config.setTarget(new HelloWorldImpl());
		config.setInterfaces(HelloWorldImpl.class.getInterfaces());

		config.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before1");
			}
		});

		config.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before2");
			}
		});

		config.addAdvice(new AfterReturningAdvice() {

			@Override
			public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
				System.out.println("afterReturning");
			}
		});

		config.addAdvice(new MethodInterceptor() {

			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("MethodInterceptor-start");
				Object retValue = invocation.proceed();
				System.out.println("MethodInterceptor-end");
				return retValue;
			}


		});

		AopProxy aopProxy = new JdkDynamicAopProxy(config);

		HelloWorld hello = (HelloWorld) aopProxy.getProxy(aopProxy.getClass().getClassLoader());
		String retValue = hello.sayHello("jpj");

		System.out.println("==================输出返回值");
		System.out.println(retValue);
	}
}



ProxyHelloWorld 
package org.springframework.aop.framework;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import com.bill.tx.HelloWorld;
import com.bill.tx.HelloWorldImpl;

public class ProxyHelloWorld {
	public static void main(String[] args) {
		AdvisedSupport config = new AdvisedSupport(); // 原材料

		config.setTarget(new HelloWorldImpl());
		config.setInterfaces(HelloWorldImpl.class.getInterfaces());

		config.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before1");
			}
		});

		config.addAdvice(new MethodBeforeAdvice() {

			@Override
			public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
				System.out.println("before2");
			}
		});

		config.addAdvice(new AfterReturningAdvice() {

			@Override
			public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
				System.out.println("afterReturning");
			}
		});

		config.addAdvice(new MethodInterceptor() {

			@Override
			public Object invoke(MethodInvocation invocation) throws Throwable {
				System.out.println("MethodInterceptor-start");
				Object retValue = invocation.proceed();
				System.out.println("MethodInterceptor-end");
				return retValue;
			}


		});

		JdkDynamicAopProxy aopProxy = new JdkDynamicAopProxy(config);

		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(config);
		//findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		HelloWorld hello = (HelloWorld) Proxy.newProxyInstance(aopProxy.getClass().getClassLoader(), proxiedInterfaces, aopProxy);
		String retValue = hello.sayHello("jpj");

		System.out.println("==================输出返回值");
		System.out.println(retValue);
	}
}


MyInvocationHandler: 
package com.bill.tx;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler {
	Object target;
	public MyInvocationHandler(Object target) {
		this.target = target;
	}

	public static void main(String[] args) {
		InvocationHandler myHandler = new MyInvocationHandler(new HelloWorldImpl());

		HelloWorld hello = (HelloWorld) Proxy.newProxyInstance(myHandler.getClass().getClassLoader(), HelloWorldImpl.class.getInterfaces(), myHandler);
		hello.sayHello("jpj");
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("MyInvocationHandler-start");
		Object retValue = method.invoke(target, args);
		System.out.println("MyInvocationHandler-end");
		return retValue;
	}


}



[img]http://dl2.iteye.com/upload/attachment/0123/9767/57552c82-82ef-3f94-9ea5-28ad455dcf60.png[/img]
iteye_15360
关注
专栏目录
SpringAop源码分析---Spring面试系列--源码解析
java技术专家全栈成长之路
05-11 370
SpringAop源码分析 AOP简介 概念 切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。连接点（Joinpoint） ：程序执行过程中的某一行为。通知（Advice） ：“切面”对于某个“连接点”所产生的动作。切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。目标对象（Target Object） ：被一个或者多个切面所通知的对象。AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态
(二)Spring AOP的实现-建立AopProxy代理对象
qq_22866497的博客
04-02 254
1.设计原理在Spring中是通过配置和调用Spring的ProxyFactoryBean来生成代理对象的，在这个过程中可以使用JDK的Proxy和CGLIB两种生成方式。ProxyFactory的继承体系如下图：由继承体系可见，对于需要使用AspectJ的AOP应用，AspectJProxyFactory起到集成Spring和AspectJ的作用；使用ProxyFactoryBean可以在IOC...
JDK-Cglib代理以及SpringAop-ProxyFactory
Liu_York的博客
01-29 259
我们知道，java中代理分为静态代理和动态代理： 静态代理： 1 用户自定义硬编码，就是将代理代码直接入侵到业务类中 2 著名的 AspectJ 代理，AspectJ很多人以为是动态代理，其实它是静态，原因是它在编译 期间利用字节码框架asm改变了被代理对象，将代码"入侵"到了目标对象，只不过我们并不知道，因为是编译期间发生的。其实这种方式调用性能是非常高的，比jdk反...
Factory和Proxy的区别理解
WHW1984的专栏
09-06 904
在读了设计模式后，对里面的Factory和Proxy这两个模式比较郁闷，感觉功能都很像。后来细细一琢磨才感觉不一样。Factory是创建模式Proxy是结构模式。对于应用中的理解，可以从字面上来看。Factory注重于生产来使用，Proxy注重于拿来使用。如果没有Factory的生产，Proxy就没有可拿来使用的东西。
SpringFramework的ProxyFactory和ProxyFactoryBean实现分析
weixin_34242509的博客
05-04 511
2019独角兽企业重金招聘Python工程师标准>>> ...
Factory模式,Proxy模式和持久层
kubete的专栏
08-17 1978
 作为最常用的创建模式，Factory模式在这里起到连接接口和实现的桥梁作用。通过Factory模式，我们可以根据具体需要加载相应的实现，并将此实现作为所对应接口的一个实例提供给业务层使用：CustomerDao custDAO=(CustomerDAO)DAOFactory.getDAO(CustomerDAO.class);Customer customer=custDAO.getCu
Spring Aop（十一）——编程式的创建Aop代理之ProxyFactory
weixin_34101229的博客
10-23 165
编程式的创建Aop代理之ProxyFactory Spring Aop是基于代理的，ProxyFactory是Spring Aop内部用来创建Proxy对象的一个工厂类。如果我们需要在程序运行时来动态的应用Spring Aop，则我们可以考虑使用ProxyFactory。使用ProxyFactory时，我们需要为它指定我们需要代理的目标对象、代...
剖析ProxyFactory
技术分享
04-11 1425
Spring 定义了org.springframework.aop.framework.AopProxy接口，并提供了两个final类型实现类
spring-aop-ProxyFactoryBean 源码分析
08-06
在Spring框架中，AOP（面向切面编程）是一个核心特性，它允许我们在不修改代码的情况下，对程序的行为进行统一的管理和控制。`ProxyFactoryBean`是Spring AOP实现中的一个重要类，它用于创建代理对象，使我们能够...
Spring源码学习十二：@Transactional是如何工作的1
08-04
Spring 框架中 @Transactional 注解的工作原理分析 在 Spring 框架中，@Transactional 注解是一个非常重要的概念，经常用于数据库操作。那么，@Transactional 注解是如何工作的呢？让我们深入源码分析。 首先，从 ...
spring 事务管理例子（TransactionProxyFactoryBean代理机制 和 tx/aop）
02-15
适用企业系统的sturts1.2+spring2.0+jdbc 的架构。 通过TransactionProxyFactoryBean 代理机制和tx/aop两种方式来管理事务的详细demo
ProxyFactory的一个问题
09-17 86
今天写了一段很简单的代码，但一直都有问题。代码如下. 接口定义 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace aoptest { interface ISay { ...
代理模式与动态代理、AOP
JOKER的博客
03-19 80
代理模式与动态代理、AOP
Spring专题--AOP--ProxyFactory
小虾米的博客
01-26 808
https://www.iteye.com/blog/elim-2397388 ProxyFactory 源码分析https://www.iteye.com/blog/wangxinchun-2079024 https://blog.csdn.net/m0_38043362/article/details/80388698 https://www.iteye.com/blog/wangxi...
Spring——通过ProxyFactory来创建代理对象分析
daliucheng的博客
12-12 1975
Spring——通过ProxyFactory来创建代理对象分析 这一篇文章旨在分析Spring中创建代理对象的环节中，最后一步创建代理代理对象的具体的操作。以及涉及到的相关的东西 在开始之前，必须要清楚Spring关于代理的几个概念：切面，通知，连接点，切入点，织入，目标类。建议直接看官网-AOP Concepts 都知道，Spring创建代理对象有两种方式， JDK-Proxy和Cglib-Proxy方式。在之前的文章中， 已经说了，如果是Jdk就要关注InvocationHandler。如果是Cglib
探索Proxy Factory：一个高效且灵活的代理管理工具
最新发布
gitblog_00022的博客
04-08 894
探索Proxy Factory：一个高效且灵活的代理管理工具 项目地址:https://gitcode.com/ShichaoMa/proxy_factory 在我们的日常编程工作中，尤其是在进行网络请求或者爬虫开发时，代理服务器经常被用于增加请求的匿名性、避免IP被封禁等问题。为此，我们很荣幸地向大家推荐一个开源项目——Proxy Factory。这是一个强大的Python库，可以帮助开发者轻...
spring 源码分析 代理工厂 (ProxyFactory)
Pazz
06-20 853
AnnotationAwareAspectJAutoProxyCreator 类关系图 通过发现，我们可以知道该类实现BeanPostProcessor接口, 是一个后置处理器.
springAOP之ProxyFactory
09-12 5706
ProxyFactory就springAOP创建代理的工厂，现在以此为入口进行aop源码的解读。 首先看ProxyFactory的结构图： TargetClassAware根据结构图，先看接口TargetClassAware，该接口是暴露代理的目标类的最小实现，该接口只有一个方法， Class<?> getTargetClass();获取实现对象的目标类，当目标类未知，返回null。 接口A
【源码】Spring AOP 11 AopProxyFactory AopProxy
小水牛的博客
08-16 422
【源码】Spring AOP 10 AopProxyFactory AopProxy前言AopProxyFactoryDefaultAopProxyFactoryAopProxyJdkDynamicAopProxyJdkDynamicAopProxy.invokeCglibAopProxyDynamicAdvisedInterceptor总结序列图get the proxyproxy invoke method参考 前言 这章节我们介绍代理创建器工厂 AopProxyFactory 和具体的代理创建器 Ao
深度解析Spring AOP框架实现与结构
本文将从源码层面分析Spring AOP的结构，通过核心组件、组件关系、示例以及后记，帮助读者深入理解其工作原理。 首先，我们来看AOP的基本概念： 1. 关注点（Concern）：关注点是应用程序中需要实现的功能，可以是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值