Java tutorial
/* * Copyright 2002-2007 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.aop.framework; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.List; import org.aopalliance.intercept.MethodInvocation; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.aop.Advisor; import org.springframework.aop.support.AopUtils; /** * InvocationHandler implementation for the Spring AOP framework, * based on J2SE 1.3+ dynamic proxies. * * <p>Creates a J2SE proxy, implementing the interfaces exposed by the * proxy. Dynamic proxies cannot be used to proxy methods defined in * classes, rather than interface. * * <p>Objects of this type should be obtained through proxy factories, * configured by an AdvisedSupport class. This class is internal * to the Spring framework and need not be used directly by client code. * * <p>Proxies created using this class will be threadsafe if the * underlying (target) class is threadsafe. * * @author Rod Johnson * @author Juergen Hoeller * @see java.lang.reflect.Proxy * @see org.springframework.aop.framework.AdvisedSupport * @see org.springframework.aop.framework.ProxyFactory */ final class OptimizedJdkDynamicAopProxy implements AopProxy, InvocationHandler { /* * NOTE: We could avoid the code duplication between this class and the CGLIB * proxies by refactoring invoke() into a template method. However, this approach * adds at least 10% performance overhead versus a copy-paste solution, so we sacrifice * elegance for performance. (We have a good test suite to ensure that the different * proxies behave the same :-) * This way, we can also more easily take advantage of minor optimizations in each class. */ private final Log logger = LogFactory.getLog(getClass()); /** Config used to configure this proxy */ private final AdvisedSupport advised; /** * Target: usually null, non-null only if we have a static target source and frozen * configuration. */ private Object target; private Advisor[] advisors; private Class targetClass; /** * Construct a new JDK proxy. * @throws AopConfigException if the config is invalid. We try * to throw an informative exception in this case, rather than let * a mysterious failure happen later. */ protected OptimizedJdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException { if (config == null) throw new AopConfigException("Cannot create AopProxy with null ProxyConfig"); if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) throw new AopConfigException("Cannot create AopProxy with no advisors and no target source"); this.advised = config; this.advisors = config.getAdvisors(); if (!config.targetSource.isStatic()) { throw new AopConfigException("Can't use Optimized JDK proxy with non-static target source"); } if (config.exposeProxy) { throw new AopConfigException("Can't use Optimized JDK proxy if proxy needs to be exposed"); } try { // TODO must be frozen System.err.println("Caching lockable target"); this.target = config.targetSource.getTarget(); this.targetClass = target.getClass(); } catch (Exception ex) { throw new AopConfigException("Can't obtain target from static TargetSource", ex); } } /** * Implementation of InvocationHandler.invoke. * Callers will see exactly the exception thrown by the target, unless a hook * method throws an exception. */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Class declaringClass = method.getDeclaringClass(); // Try special rules for equals() method and implementation of the // Advised AOP configuration interface if (declaringClass == Object.class && "equals".equals(method.getName())) { // What if equals throws exception!? // This class implements the equals() method itself return new Boolean(equals(args[0])); } else if (Advised.class == declaringClass) { // Service invocations on ProxyConfig with the proxy config return method.invoke(this.advised, args); } Object retVal = null; // Get the interception chain for this method List chain = this.advised.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this.advised, method, this.targetClass); // Check whether we have any advice. If we don't, we can fallback on // direct reflective invocation of the target, and avoid creating a MethodInvocation if (chain.isEmpty()) { // We can skip creating a MethodInvocation: just invoke the target directly // Note that the final invoker must be an InvokerInterceptor so we know it does // nothing but a reflective operation on the target, and no hot swapping or fancy proxying retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args); } else { // We need to create a method invocation... //invocation = advised.getMethodInvocationFactory().getMethodInvocation(proxy, method, targetClass, target, args, chain, advised); MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); // Proceed to the joinpoint through the interceptor chain retVal = invocation.proceed(); } // Massage return value if necessary if (retVal != null && retVal == target) { // Special case: it returned "this" // Note that we can't help if the target sets // a reference to itself in another returned object retVal = proxy; } return retVal; } /** * Creates a new Proxy object for the given object, proxying * the given interface. Uses the thread context class loader. */ public Object getProxy() { return getProxy(Thread.currentThread().getContextClassLoader()); } /** * Creates a new Proxy object for the given object, proxying * the given interface. Uses the given class loader. */ public Object getProxy(ClassLoader cl) { logger.debug("Creating JDK dynamic proxy"); Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised); return Proxy.newProxyInstance(cl, proxiedInterfaces, this); } /** * Equality means interceptors and interfaces and * TargetSource are equal. * @see java.lang.Object#equals(java.lang.Object) * @param other may be a dynamic proxy wrapping an instance * of this class */ public boolean equals(Object other) { if (other == null) return false; if (other == this) return true; OptimizedJdkDynamicAopProxy aopr2 = null; if (other instanceof OptimizedJdkDynamicAopProxy) { aopr2 = (OptimizedJdkDynamicAopProxy) other; } else if (Proxy.isProxyClass(other.getClass())) { InvocationHandler ih = Proxy.getInvocationHandler(other); if (!(ih instanceof OptimizedJdkDynamicAopProxy)) return false; aopr2 = (OptimizedJdkDynamicAopProxy) ih; } else { // Not a valid comparison return false; } // If we get here, aopr2 is the other AopProxy return AopProxyUtils.equalsInProxy(this.advised, aopr2.advised); } }