网站网址怎么写_雄安移动网站_网站首页排名seo搜索优化_网站结构

/*** Interface supplying the information necessary to describe an introduction.* 为描述一个introduction(引入)提供必要信息的接口。但是这个接口之定义了一个* Class<?>[] getInterfaces()方法，看来 introduction 最主要的信息就是要引入的接口* * <p>{@link IntroductionAdvisor IntroductionAdvisors} must implement this* interface. If an {@link org.aopalliance.aop.Advice} implements this,* it may be used as an introduction without an {@link IntroductionAdvisor}.* In this case, the advice is self-describing, providing not only the* necessary behavior, but describing the interfaces it introduces.* IntroductionAdvisor 必须实现这个接口，假如一个 Advice 实现了IntroductionInfo，* 它就可以被当作一个没有 IntroductionAdvisor 的introduction来使用。在这种情况下* 这个Advice是自我描述的，不仅提供了必要的行为，和描述了要引入的接口* * @author Rod Johnson* @since 1.1.1*/
public interface IntroductionInfo {/*** 返回这个Advisor 或者 Advice 引入的额外的接口* 这里的额外接口指的是，Advisor和Advice 没有实现这些接口，但是要具有这些接口的能力* Return the additional interfaces introduced by this Advisor or Advice.* @return the introduced interfaces*/Class<?>[] getInterfaces();}

/*** Superinterface for advisors that perform one or more AOP <b>introductions</b>.* * * <p>This interface cannot be implemented directly; subinterfaces must* provide the advice type implementing the introduction.** <p>Introduction is the implementation of additional interfaces* (not implemented by a target) via AOP advice.* 引入是target对象通过Aop实现的额外的接口，这些额外的接口指的是target没有* 实现的一些接口 * 比如：target 实现了接口A 和 接口B，但是还想给 target 添加接口C 和 接口D 的功能，* 接口C 和 接口D 就属于引入的接口* @author Rod Johnson* @since 04.04.2003* @see IntroductionInterceptor*/
public interface IntroductionAdvisor extends Advisor, IntroductionInfo {/*** Return the filter determining which target classes this introduction* should apply to.* 返回一个过滤器，这个过滤器用来决定这个 introduction 因该引用到哪些类上* * <p>This represents the class part of a pointcut. Note that method* matching doesn't make sense to introductions.* 这代表了切点的 class 部分。注意对于introduction来说，方法匹配不起作用* * @return the class filter*/ClassFilter getClassFilter();/*** Can the advised interfaces be implemented by the introduction advice?* Invoked before adding an IntroductionAdvisor.* 在IntroductionAdvisor被添加之前调用，用来校验 introduction 引入的接口* 能不能被introduction advice实现* @throws IllegalArgumentException if the advised interfaces can't be* implemented by the introduction advice* */void validateInterfaces() throws IllegalArgumentException;}

/*** Simple {@link org.springframework.aop.IntroductionAdvisor} implementation* that by default applies to any class.* * @author Rod Johnson* @author Juergen Hoeller* @since 11.11.2003*/
@SuppressWarnings("serial")
public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFilter, Ordered, Serializable {private final Advice advice;private final Set<Class<?>> interfaces = new LinkedHashSet<>();private int order = Ordered.LOWEST_PRECEDENCE;/*** Create a DefaultIntroductionAdvisor for the given advice.* @param advice the Advice to apply (may implement the* {@link org.springframework.aop.IntroductionInfo} interface)* @see #addInterface*/public DefaultIntroductionAdvisor(Advice advice) {// 这里的Advice同时也实现了IntroductionInfo，说明这个Advice实例既提供了要引入的接口// ，又具有根据本次请求的Method的，将请求转发到delegate的能力// 比如说:DelegatingIntroductionInterceptorthis(advice, (advice instanceof IntroductionInfo ? (IntroductionInfo) advice : null));}/*** Create a DefaultIntroductionAdvisor for the given advice.* @param advice the Advice to apply* @param introductionInfo the IntroductionInfo that describes* the interface to introduce (may be {@code null})*/public DefaultIntroductionAdvisor(Advice advice, @Nullable IntroductionInfo introductionInfo) {Assert.notNull(advice, "Advice must not be null");// 这里传进来的 Advice 不是像PointcutAdvisor中的Advice那样，对目标对象的方法进行加强// 主要的业务还是在代理的目标对象// DefaultIntroductionAdvisor的Advice最终是要完成主要业务的，Advice持有能够解决// 所引入的接口的问题的实例 Object delegate ，这个delegate本身实现了引入的接口，// 当执行到执行链中的Introduction Advice时，这个Advice会先判断这次调用的Method方法// 所属的Class是不是Introduction引入的接口，如果是就直接把这个调用准发到 delegate// ，delegate实现了Introduction引入的接口，能够解决本次调用，解决完了，直接就返回了// 不再将请求向后传递了this.advice = advice;if (introductionInfo != null) {Class<?>[] introducedInterfaces = introductionInfo.getInterfaces();if (introducedInterfaces.length == 0) {throw new IllegalArgumentException("IntroductionInfo defines no interfaces to introduce: " + introductionInfo);}for (Class<?> ifc : introducedInterfaces) {addInterface(ifc);}}}/*** Create a DefaultIntroductionAdvisor for the given advice.* @param advice the Advice to apply* @param ifc the interface to introduce*/public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> ifc) {Assert.notNull(advice, "Advice must not be null");this.advice = advice;addInterface(ifc);}/*** Add the specified interface to the list of interfaces to introduce.* 添加要引入的接口* @param ifc the interface to introduce*/public void addInterface(Class<?> ifc) {Assert.notNull(ifc, "Interface must not be null");if (!ifc.isInterface()) {throw new IllegalArgumentException("Specified class [" + ifc.getName() + "] must be an interface");}this.interfaces.add(ifc);}// 这里相当于实现了 IntroductionInfo 的public Class<?>[] getInterfaces();// 当通过AdvisedSupport#addAdvisor(int,org.springframework.aop.Advisor)// 方法添加 Advisor 的时候，判断如果添加的Advisor，是一个IntroductionAdvisor// ，就会将调用IntroductionAdvisor.getInterfaces()获取所有引入的接口，添加到// AdvisedSupport.interfaces中，AdvisedSupport.interfaces中放的都是生成的代理// 对象需要实现的接口，之后实现了这些接口，后期生成的代理才能强转为这些接口进行调用@Overridepublic Class<?>[] getInterfaces() {return ClassUtils.toClassArray(this.interfaces);}@Overridepublic void validateInterfaces() throws IllegalArgumentException {for (Class<?> ifc : this.interfaces) {if (this.advice instanceof DynamicIntroductionAdvice &&!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +"does not implement interface [" + ifc.getName() + "] specified for introduction");}}}@Overridepublic Advice getAdvice() {return this.advice;}@Overridepublic boolean isPerInstance() {return true;}@Overridepublic ClassFilter getClassFilter() {// 因为DefaultIntroductionAdvisor本来就实现了ClassFilter// 返回thisreturn this;}@Overridepublic boolean matches(Class<?> clazz) {// 因为DefaultIntroductionAdvisor实现了ClassFilter// 所以必须实现 matches 方法，这里直接返回 true// 表示所有的 Class 都能匹配成功return true;}}

上面说了创建 DefaultIntroductionAdvisor 的时候，需要一个能根据本次调用的Method的，将调用转发到 delegate 的Advice，DelegatingIntroductionInterceptor 就是这样一个Advice，DelegatingIntroductionInterceptor通过继承IntroductionInfoSupport具有了校验一个Method是否属于被引入的某一个接口的能力，当然IntroductionInfoSupport校验是所用的接口数据也是DelegatingIntroductionInterceptor 通过 implementInterfacesOnObject(delegate) 传给它的

/*** Convenient implementation of the* {@link org.springframework.aop.IntroductionInterceptor} interface.** <p>Subclasses merely need to extend this class and implement the interfaces* to be introduced themselves. In this case the delegate is the subclass* instance itself. Alternatively a separate delegate may implement the* interface, and be set via the delegate bean property.* 很少需要扩展这个类，并且子类实现要引入的所有接口，如果真是这种情况，子类自己就是delegate。* 还有可选方案就是，用一个单独的 delegate 实现要引入的所有接口，然后通过构造方法或者setter* 将单独的 delegate 设置给 delegate 属性* <p>Delegates or subclasses may implement any number of interfaces.* All interfaces except IntroductionInterceptor are picked up from* the subclass or delegate by default.** <p>The {@code suppressInterface} method can be used to suppress interfaces* implemented by the delegate but which should not be introduced to the owning* AOP proxy.** <p>An instance of this class is serializable if the delegate is.** @author Rod Johnson* @author Juergen Hoeller* @since 16.11.2003* @see #suppressInterface* @see DelegatePerTargetObjectIntroductionInterceptor*/
@SuppressWarnings("serial")
public class DelegatingIntroductionInterceptor extends IntroductionInfoSupportimplements IntroductionInterceptor {/*** Object that actually implements the interfaces.* May be "this" if a subclass implements the introduced interfaces.*/@Nullableprivate Object delegate;/*** Construct a new DelegatingIntroductionInterceptor, providing* a delegate that implements the interfaces to be introduced.* @param delegate the delegate that implements the introduced interfaces*/public DelegatingIntroductionInterceptor(Object delegate) {// 这里是通过一个独立的delegate来实现要引入的所有接口// 然后通过构造方法初始化 delegate 字段init(delegate);}/*** Construct a new DelegatingIntroductionInterceptor.* The delegate will be the subclass, which must implement* additional interfaces.* 如果不传一个独立的 delegate，说明子类自己就是 delegate* ，子类必须实现 要引入的所有接口*/protected DelegatingIntroductionInterceptor() {init(this);}/*** Both constructors use this init method, as it is impossible to pass* a "this" reference from one constructor to another.* @param delegate the delegate object*/private void init(Object delegate) {Assert.notNull(delegate, "Delegate must not be null");this.delegate = delegate;// 这里会调用 IntroductionInfoSupport.implementInterfacesOnObject()// 将 delegate 所实现的所有接口提出出来，并发布implementInterfacesOnObject(delegate);// We don't want to expose the control interfacesuppressInterface(IntroductionInterceptor.class);suppressInterface(DynamicIntroductionAdvice.class);}/*** Subclasses may need to override this if they want to perform custom* behaviour in around advice. However, subclasses should invoke this* method, which handles introduced interfaces and forwarding to the target.* 如果子类想执行以下自定义的行为，就需要重写这个方法，然而，子类需要通过调用* super.invoke(mi)调用这个方法，这个方法可以处理引入的接口，并将调用转发到* delegate*/@Override@Nullablepublic Object invoke(MethodInvocation mi) throws Throwable {// 调用IntroductionInfoSupport.isMethodOnIntroducedInterface()是不是属于// 被引入的接口之一if (isMethodOnIntroducedInterface(mi)) {// Using the following method rather than direct reflection, we// get correct handling of InvocationTargetException// if the introduced method throws an exception.// 如果判断这个Method是属于被引入的某一个接口，说明delegate能解决问题// 调用delegate的方法完成调用的任务Object retVal = AopUtils.invokeJoinpointUsingReflection(this.delegate, mi.getMethod(), mi.getArguments());// Massage return value if possible: if the delegate returned itself,// we really want to return the proxy.if (retVal == this.delegate && mi instanceof ProxyMethodInvocation) {Object proxy = ((ProxyMethodInvocation) mi).getProxy();if (mi.getMethod().getReturnType().isInstance(proxy)) {retVal = proxy;}}return retVal;}// 如果不属于被引入的任何一个接口，就掉过当前 MethodInterceptorreturn doProceed(mi);}/*** Proceed with the supplied {@link org.aopalliance.intercept.MethodInterceptor}.* Subclasses can override this method to intercept method invocations on the* target object which is useful when an introduction needs to monitor the object* that it is introduced into. This method is <strong>never</strong> called for* {@link MethodInvocation MethodInvocations} on the introduced interfaces.*/@Nullableprotected Object doProceed(MethodInvocation mi) throws Throwable {// If we get here, just pass the invocation on.return mi.proceed();}}/*** Support for implementations of {@link org.springframework.aop.IntroductionInfo}.* * <p>Allows subclasses to conveniently add all interfaces from a given object,* and to suppress interfaces that should not be added. Also allows for querying* all introduced interfaces.** @author Rod Johnson* @author Juergen Hoeller*/
@SuppressWarnings("serial")
public class IntroductionInfoSupport implements IntroductionInfo, Serializable {protected final Set<Class<?>> publishedInterfaces = new LinkedHashSet<>();private transient Map<Method, Boolean> rememberedMethods = new ConcurrentHashMap<>(32);/*** Suppress the specified interface, which may have been autodetected* due to the delegate implementing it. Call this method to exclude* internal interfaces from being visible at the proxy level.* <p>Does nothing if the interface is not implemented by the delegate.* @param ifc the interface to suppress*/public void suppressInterface(Class<?> ifc) {this.publishedInterfaces.remove(ifc);}// 返回子类中的 delegate 所实现的所有接口// 用于校验本次调用的Method是不是属于 子类的 delegate 所实现的所有接口// 之一@Overridepublic Class<?>[] getInterfaces() {return ClassUtils.toClassArray(this.publishedInterfaces);}/*** 校验传入的接口是不是 发布的被引入的接口之一* Check whether the specified interfaces is a published introduction interface.* @param ifc the interface to check* @return whether the interface is part of this introduction*/public boolean implementsInterface(Class<?> ifc) {for (Class<?> pubIfc : this.publishedInterfaces) {if (ifc.isInterface() && ifc.isAssignableFrom(pubIfc)) {return true;}}return false;}/*** 发布 delegate 所实现的所有接口，子类中调用。delegate是子类传的* Publish all interfaces that the given delegate implements at the proxy level.* @param delegate the delegate object*/protected void implementInterfacesOnObject(Object delegate) {this.publishedInterfaces.addAll(ClassUtils.getAllInterfacesAsSet(delegate));}/*** 校验MethodInvocation实例中的Method对象是不是属于被引入的某一个接口* Is this method on an introduced interface?* @param mi the method invocation* @return whether the invoked method is on an introduced interface*/protected final boolean isMethodOnIntroducedInterface(MethodInvocation mi) {Boolean rememberedResult = this.rememberedMethods.get(mi.getMethod());if (rememberedResult != null) {return rememberedResult;}else {// Work it out and cache it.boolean result = implementsInterface(mi.getMethod().getDeclaringClass());this.rememberedMethods.put(mi.getMethod(), result);return result;}}}

举两个例子：

例子一：

public interface CarService {Integer addCar(Car car);
}public interface AService {public String serviceA(String param);public String serviceAA(String param);}public interface BService {public String serviceB(String param);public String serviceBB(String param);
}

public class CarServiceImpl implements CarService, AService, BService {@Overridepublic Integer addCar(Car car) {System.out.println("add");//int i = 1 / 0;return 1000;}@Overridepublic String serviceA(String param) {System.out.println("执行 CarServiceImpl.serviceA() 参数:" + param);return "CarServiceImpl.serviceA() 处理过的 " + param;}@Overridepublic String serviceAA(String param) {System.out.println("执行 CarServiceImpl.serviceAA() 参数:" + param);return "CarServiceImpl.serviceAA() 处理过的 " + param;}@Overridepublic String serviceB(String param) {System.out.println("执行 CarServiceImpl.serviceB() 参数:" + param);return "CarServiceImpl.serviceB() 处理过的 " + param;}@Overridepublic String serviceBB(String param) {System.out.println("执行 CarServiceImpl.serviceBB() 参数:" + param);return "CarServiceImpl.serviceBB() 处理过的 " + param;}
}

public class ProxyFactoryTest1 {public static void main(String[] args) {ProxyFactory proxyFactory = new ProxyFactory();CarServiceImpl carServiceImpl = new CarServiceImpl();DelegatingIntroductionInterceptor delegatingIntroductionInterceptor = new DelegatingIntroductionInterceptor(carServiceImpl);IntroductionAdvisor introductionAdvisor = new DefaultIntroductionAdvisor(delegatingIntroductionInterceptor);proxyFactory.addAdvisor(introductionAdvisor);CarService carServiceProxy = (CarService) proxyFactory.getProxy();Integer integer = carServiceProxy.addCar(new Car());System.out.println(integer);AService aServiceProxy = (AService) proxyFactory.getProxy();String serviceA = aServiceProxy.serviceA("测试引入代理");System.out.println(serviceA);BService bServiceProxy = (BService) proxyFactory.getProxy();String serviceBB = bServiceProxy.serviceBB("测试引入代理");System.out.println(serviceBB);}}运行结果:
add
1000
执行 CarServiceImpl.serviceA() 参数:测试引入代理
CarServiceImpl.serviceA() 处理过的 测试引入代理
执行 CarServiceImpl.serviceBB() 参数:测试引入代理
CarServiceImpl.serviceBB() 处理过的 测试引入代理

例子二：

public class CustomDelegatingIntroductionInterceptor extends DelegatingIntroductionInterceptor implements CarService,AService,BService {@Overridepublic Integer addCar(Car car) {System.out.println("执行 CustomDelegatingIntroductionInterceptor.add() 参数：" + JSON.toJSONString(car));return 2000;}@Overridepublic String serviceA(String param) {System.out.println("执行 CustomDelegatingIntroductionInterceptor.serviceA() 参数:" + param);return "CustomDelegatingIntroductionInterceptor.serviceA() 处理过的 " + param;}@Overridepublic String serviceAA(String param) {System.out.println("执行 CustomDelegatingIntroductionInterceptor.serviceAA() 参数:" + param);return "CustomDelegatingIntroductionInterceptor.serviceAA() 处理过的 " + param;}@Overridepublic String serviceB(String param) {System.out.println("执行 CustomDelegatingIntroductionInterceptor.serviceB() 参数:" + param);return "CustomDelegatingIntroductionInterceptor.serviceB() 处理过的 " + param;}@Overridepublic String serviceBB(String param) {System.out.println("执行 CustomDelegatingIntroductionInterceptor.serviceBB() 参数:" + param);return "CustomDelegatingIntroductionInterceptor.serviceBB() 处理过的 " + param;}
}

public class ProxyFactoryTest2 {public static void main(String[] args) {ProxyFactory proxyFactory = new ProxyFactory();IntroductionAdvisor introductionAdvisor = new DefaultIntroductionAdvisor(new CustomDelegatingIntroductionInterceptor());proxyFactory.addAdvisor(introductionAdvisor);CarService carServiceProxy = (CarService) proxyFactory.getProxy();Integer integer = carServiceProxy.addCar(new Car());System.out.println(integer);AService aServiceProxy = (AService) proxyFactory.getProxy();String serviceA = aServiceProxy.serviceA("测试引入代理");System.out.println(serviceA);BService bServiceProxy = (BService) proxyFactory.getProxy();String serviceBB = bServiceProxy.serviceBB("测试引入代理");System.out.println(serviceBB);}}执行结果:
执行 CustomDelegatingIntroductionInterceptor.add() 参数：{}
2000
执行 CustomDelegatingIntroductionInterceptor.serviceA() 参数:测试引入代理
CustomDelegatingIntroductionInterceptor.serviceA() 处理过的 测试引入代理
执行 CustomDelegatingIntroductionInterceptor.serviceBB() 参数:测试引入代理
CustomDelegatingIntroductionInterceptor.serviceBB() 处理过的 测试引入代理