深入浅出设计模式（七）：9.代理模式

最新推荐文章于 2024-01-21 20:25:25 发布

ToughMind_

最新推荐文章于 2024-01-21 20:25:25 发布

阅读量1k

点赞数

分类专栏：设计模式文章标签：代理模式设计模式 java

本文链接：https://blog.youkuaiyun.com/liuquan0071/article/details/50524094

版权

设计模式专栏收录该内容

14 篇文章

订阅专栏

9.代理模式(Proxy)

我们买房子办理贷款时可以自己到银行办理，但是手续很多，也可以找相应的代理公司，这样我们什么都不用管。代理模式就是给一个对象提供一个代理对象，由这个代理对象控制对原对象的引用

动态代理的实现

比如现有操作计算薪资、计算所得税、权限控制等，现系统要求给每个方法都使用日志记录，则每个操作就都要有一个日志记录的代理类，太多了，此时就可通过动态代理，代理类要都实现InvocationHandler接口。
这里写图片描述

SalaryInterface

// 计算薪资的接口  
public interface SalaryInterface {
    public void doSalary();
}

Salary

//计算薪资的实现类  
public class Salary implements SalaryInterface{
    public void doSalary() {
        System.out.println("进行薪资计算的逻辑处理");
    }
}

TaxInterface

//计算税率的接口  
public interface TaxInterface {
    public void doTax();
}

Tax

//计算税率的实现类  
public class Tax implements TaxInterface{
    public void doTax() {
        System.out.println("进行所得税计算的逻辑处理");
    }
}

TimeProxy

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

//计算薪资和税率，并统计时间的代理类  
public class TimeProxy implements InvocationHandler{
    private Object obj; 
    //绑定代理对象
    public Object bind(Object obj) {
        this.obj = obj; 
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }

    /**
     * @description  每一个代理实例都必须指定一个调用处理器，代理对象调用方法时，该方法会指派到调用处理器的invoke()中去
     * @date  2016年1月14日
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        try { 
            long startTime = System.nanoTime(); // 获取开始时间
            result = method.invoke(obj, args);
            long endTime = System.nanoTime(); // 获取结束时间
            System.out.println("计算程序运行时间： " + (endTime - startTime) + "ns");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }   
}

Client

public class Client {
    public static void main (String[] args) {       
        TimeProxy timeProxy = new TimeProxy();
        SalaryInterface salaryInterface = (SalaryInterface)timeProxy.bind(new Salary());
        salaryInterface.doSalary();
        TaxInterface taxInterface = (TaxInterface)timeProxy.bind(new Tax());
        taxInterface.doTax();
    }
}

面向方面的程序编程

上面代码是记录程序的执行时间，若还需要记录其他内容，比如权限控制，此时要么修改原来的代理类，要么增加新的代理类，但这不符合面向对象的设计原则，那么有没有一种简单的方法既不增加代理类，也不修改原来代理类呢？具体实现可以参考AOP的实现原理

这里写图片描述

Advice

public interface Advice {
    public void before();
    public void after();
}

TimeAdvice

public class TimeAdvice implements Advice {
    long startTime;
    long endTime;
    @Override
    public void before() {
        startTime=System.nanoTime();   //获取开始时间
    }

    @Override
    public void after() {
        endTime=System.nanoTime(); //获取结束时间
        System.out.println("计算程序运行时间： "+(endTime-startTime)+"ns");
    }

MyProxy

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

public class MyProxy implements InvocationHandler{

    private Object obj;
    private Advice advice;

    //绑定代理对象
    public Object bind(Object obj, Advice advice) {
        this.obj = obj;
        this.advice = advice;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }

    //实现代理
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        try {
            advice.before();
            result = method.invoke(obj, args);
            advice.after();
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

}

ControlAdvice

public class ControlAdvice extends TimeAdvice {

    @Override
    public void before() {
        super.before();
        System.out.println("判断系统的权限 ");
    }

    @Override
    public void after() {
        super.after();
    }
}

此时若要在此基础上又加入权限控制，则可以增加一个Advice的实现类，继承TimeAdvice即可。

ControlAdvice

public class ControlAdvice extends TimeAdvice {

    @Override
    public void before() {
        super.before();
        System.out.println("判断系统的权限 ");
    }

    @Override
    public void after() {
        super.after();
    }
}

Client

public class Client {

    public static void main (String[] args) { 
        MyProxy timeProxy = new MyProxy();
        SalaryInterface salaryInterface = (SalaryInterface)timeProxy.bind(new Salary(), new ControlAdvice());
        salaryInterface.doSalary();
        TaxInterface taxInterface = (TaxInterface)timeProxy.bind(new Tax(), new ControlAdvice());
        taxInterface.doTax();
    }
}

AOP的意思是面向方面编程，AOP就是要分离那种和业务代码不相关的代码，通过另一种方式实现对业务代码的控制，而业务代码本身并不改变，这恰恰是代理模式的好时机，因为当系统对某个对象进行额外的控制的时候，就需要使用代理模式。

代理模式在Spring的实际应用

通过java的动态代理机制，就可以很容易实现AOP的思想。实际上Spring的AOP也是建立在JAVA的代理机制之上的。在Spring中主要是通过JdkDynamicAopProxy类实现动态代理的：

JdkDynamicAopProxy

package org.springframework.aop.framework;

import java.io.Serializable;
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.AopInvocationException;
import org.springframework.aop.RawTargetAccess;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler,
        Serializable {
    private static final long serialVersionUID = 5531744639992436476L;
    //记录日志
    private static Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);
    //设定配置
    private final AdvisedSupport advised;
    private boolean equalsDefined;
    private boolean hashCodeDefined;

    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if ((config.getAdvisors().length == 0)
                && (config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE)) {
            throw new AopConfigException(
                    "No advisors and no TargetSource specified");
        }
        this.advised = config;
    }

    public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }

    //获取默认的代理类
    public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is "
                    + this.advised.getTargetSource());
        }
        Class[] proxiedInterfaces = AopProxyUtils
                .completeProxiedInterfaces(this.advised);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

    private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
        for (Class proxiedInterface : proxiedInterfaces) {
            Method[] methods = proxiedInterface.getDeclaredMethods();
            for (Method method : methods) {
                if (AopUtils.isEqualsMethod(method)) {
                    this.equalsDefined = true;
                }
                if (AopUtils.isHashCodeMethod(method)) {
                    this.hashCodeDefined = true;
                }
                if ((this.equalsDefined) && (this.hashCodeDefined)) {
                    return;
                }
            }
        }
    }

    //反射调用
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        //设定源类
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;
        try {
            Object localObject1;
            //下列代码用于定义如何实现代理模式
            //判断是否为方法本身
            if ((!this.equalsDefined) && (AopUtils.isEqualsMethod(method))) {
                return Boolean.valueOf(equals(args[0]));
            }
            if ((!this.hashCodeDefined) && (AopUtils.isHashCodeMethod(method))) {
                return Integer.valueOf(hashCode());
            }
            if ((!this.advised.opaque)
                    && (method.getDeclaringClass().isInterface())
                    && (method.getDeclaringClass()
                            .isAssignableFrom(Advised.class))) {
                return AopUtils.invokeJoinpointUsingReflection(this.advised,
                        method, args);
            }
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            //获取目标类
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
            List<Object> chain = this.advised
                    .getInterceptorsAndDynamicInterceptionAdvice(method,
                            targetClass);
            Object retVal;
            Object retVal;
            //检查是否有拦截器
            if (chain.isEmpty()) {
                retVal = AopUtils.invokeJoinpointUsingReflection(target,
                        method, args);
            } else {
                MethodInvocation invocation = new ReflectiveMethodInvocation(
                        proxy, target, method, args, targetClass, chain);

                retVal = invocation.proceed();
            }
            Class<?> returnType = method.getReturnType();
            if ((retVal != null)
                    && (retVal == target)
                    && (returnType.isInstance(proxy))
                    && (!RawTargetAccess.class.isAssignableFrom(method
                            .getDeclaringClass()))) {
                retVal = proxy;
            } else if ((retVal == null) && (returnType != Void.TYPE)
                    && (returnType.isPrimitive())) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: "
                                + method);
            }
            return retVal;
        } finally {
            if ((target != null) && (!targetSource.isStatic())) {
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

    public boolean equals(Object other) {
        if (other == this) {
            return true;
        }
        if (other == null) {
            return false;
        }
        JdkDynamicAopProxy otherProxy;
        if ((other instanceof JdkDynamicAopProxy)) {
            otherProxy = (JdkDynamicAopProxy) other;
        } else {
            JdkDynamicAopProxy otherProxy;
            if (Proxy.isProxyClass(other.getClass())) {
                InvocationHandler ih = Proxy.getInvocationHandler(other);
                if (!(ih instanceof JdkDynamicAopProxy)) {
                    return false;
                }
                otherProxy = (JdkDynamicAopProxy) ih;
            } else {
                return false;
            }
        }
        JdkDynamicAopProxy otherProxy;
        return AopProxyUtils.equalsInProxy(this.advised, otherProxy.advised);
    }

    public int hashCode() {
        return JdkDynamicAopProxy.class.hashCode() * 13
                + this.advised.getTargetSource().hashCode();
    }
}

ReflectiveMethodInvocation，主要负责调用代理类的方法

package org.springframework.aop.framework;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.ProxyMethodInvocation;
import org.springframework.aop.support.AopUtils;
import org.springframework.core.BridgeMethodResolver;

public class ReflectiveMethodInvocation
  implements ProxyMethodInvocation, Cloneable
{
  protected final Object proxy;
  protected final Object target;
  protected final Method method;
  protected Object[] arguments;
  private final Class targetClass;
  private Map<String, Object> userAttributes;
  protected final List interceptorsAndDynamicMethodMatchers;
  private int currentInterceptorIndex = -1;

  protected ReflectiveMethodInvocation(Object proxy, Object target, Method method, Object[] arguments, Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers)
  {
    this.proxy = proxy;
    this.target = target;
    this.targetClass = targetClass;
    this.method = BridgeMethodResolver.findBridgedMethod(method);
    this.arguments = arguments;
    this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
  }

  //返回代理
  public final Object getProxy()
  {
    return this.proxy;
  }

  //返回目标类
  public final Object getThis()
  {
    return this.target;
  }

  public final AccessibleObject getStaticPart()
  {
    return this.method;
  }

  //返回方法
  public final Method getMethod()
  {
    return this.method;
  }

  //返回参数
  public final Object[] getArguments()
  {
    return this.arguments != null ? this.arguments : new Object[0];
  }

  public void setArguments(Object[] arguments)
  {
    this.arguments = arguments;
  }

  //调用方法
  public Object proceed()
    throws Throwable
  {
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
      return invokeJoinpoint();
    }
    Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if ((interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher))
    {
        //检查方法名是否匹配
      InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
      if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
        return dm.interceptor.invoke(this);
      }
      return proceed();
    }
    return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
  }

  //回调插入点
  protected Object invokeJoinpoint()
    throws Throwable
  {
    return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
  }

  public MethodInvocation invocableClone()
  {
    Object[] cloneArguments = null;
    if (this.arguments != null)
    {
      cloneArguments = new Object[this.arguments.length];
      System.arraycopy(this.arguments, 0, cloneArguments, 0, this.arguments.length);
    }
    return invocableClone(cloneArguments);
  }

  public MethodInvocation invocableClone(Object[] arguments)
  {
    if (this.userAttributes == null) {
      this.userAttributes = new HashMap();
    }
    try
    {
      ReflectiveMethodInvocation clone = (ReflectiveMethodInvocation)clone();
      clone.arguments = arguments;
      return clone;
    }
    catch (CloneNotSupportedException ex)
    {
      throw new IllegalStateException("Should be able to clone object of type [" + getClass() + "]: " + ex);
    }
  }

  public void setUserAttribute(String key, Object value)
  {
    if (value != null)
    {
      if (this.userAttributes == null) {
        this.userAttributes = new HashMap();
      }
      this.userAttributes.put(key, value);
    }
    else if (this.userAttributes != null)
    {
      this.userAttributes.remove(key);
    }
  }

  //返回用户属性
  public Object getUserAttribute(String key)
  {
    return this.userAttributes != null ? this.userAttributes.get(key) : null;
  }

  public Map<String, Object> getUserAttributes()
  {
    if (this.userAttributes == null) {
      this.userAttributes = new HashMap();
    }
    return this.userAttributes;
  }

  //输出字符串流
  public String toString()
  {
    StringBuilder sb = new StringBuilder("ReflectiveMethodInvocation: ");
    sb.append(this.method).append("; ");
    if (this.target == null) {
      sb.append("target is null");
    } else {
      sb.append("target is of class [").append(this.target.getClass().getName()).append(']');
    }
    return sb.toString();
  }
}

DelegatingIntroductionInterceptor,主要负责委托拦截器

package org.springframework.aop.support;

import java.lang.reflect.Method;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.DynamicIntroductionAdvice;
import org.springframework.aop.IntroductionInterceptor;
import org.springframework.aop.ProxyMethodInvocation;
import org.springframework.util.Assert;

public class DelegatingIntroductionInterceptor
  extends IntroductionInfoSupport
  implements IntroductionInterceptor
{
  private Object delegate;

  public DelegatingIntroductionInterceptor(Object delegate)
  {
    init(delegate);
  }

  protected DelegatingIntroductionInterceptor()
  {
    init(this);
  }

  private void init(Object delegate)
  {
    Assert.notNull(delegate, "Delegate must not be null");
    this.delegate = delegate;
    implementInterfacesOnObject(delegate);

    //控制接口
    suppressInterface(IntroductionInterceptor.class);
    suppressInterface(DynamicIntroductionAdvice.class);
  }

  //调用代理的方法
  public Object invoke(MethodInvocation mi)
    throws Throwable
  {
    if (isMethodOnIntroducedInterface(mi))
    {
      //直接调用代理方法
      Object retVal = AopUtils.invokeJoinpointUsingReflection(this.delegate, mi.getMethod(), mi.getArguments());
      if ((retVal == this.delegate) && ((mi instanceof ProxyMethodInvocation)))
      {
        Object proxy = ((ProxyMethodInvocation)mi).getProxy();
        //加入要代理的方法
        if (mi.getMethod().getReturnType().isInstance(proxy)) {
          retVal = proxy;
        }
      }
      return retVal;
    }
    return doProceed(mi);
  }

  protected Object doProceed(MethodInvocation mi)
    throws Throwable
  {
    return mi.proceed();
  }
}

Spring的proxy模式主要提现在AOP中，有两种代理方式，分别为JdkDynamicAopProxy和Cglib2AopProxy。下面再看看Cglib2AopProxy：

CglibAopProxy

package org.springframework.aop.framework;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.aopalliance.aop.Advice;
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.AopInvocationException;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.aop.RawTargetAccess;
import org.springframework.aop.TargetSource;
import org.springframework.aop.support.AopUtils;
import org.springframework.cglib.core.CodeGenerationException;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.CallbackFilter;
import org.springframework.cglib.proxy.Dispatcher;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.NoOp;
import org.springframework.cglib.transform.impl.UndeclaredThrowableStrategy;
import org.springframework.core.SmartClassLoader;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ObjectUtils;

final class CglibAopProxy implements AopProxy, Serializable {
    private static final int AOP_PROXY = 0;
    private static final int INVOKE_TARGET = 1;
    private static final int NO_OVERRIDE = 2;
    private static final int DISPATCH_TARGET = 3;
    private static final int DISPATCH_ADVISED = 4;
    private static final int INVOKE_EQUALS = 5;
    private static final int INVOKE_HASHCODE = 6;
    protected static final Log logger = LogFactory.getLog(CglibAopProxy.class);
    private static final Map<Class<?>, Boolean> validatedClasses = new WeakHashMap();
    protected final AdvisedSupport advised;
    private Object[] constructorArgs;
    private Class<?>[] constructorArgTypes;
    private final transient AdvisedDispatcher advisedDispatcher;
    private transient Map<String, Integer> fixedInterceptorMap;
    private transient int fixedInterceptorOffset;

    public CglibAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if ((config.getAdvisors().length == 0)
                && (config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE)) {
            throw new AopConfigException(
                    "No advisors and no TargetSource specified");
        }
        this.advised = config;
        this.advisedDispatcher = new AdvisedDispatcher(this.advised);
    }

    public void setConstructorArguments(Object[] constructorArgs,
            Class<?>[] constructorArgTypes) {
        if ((constructorArgs == null) || (constructorArgTypes == null)) {
            throw new IllegalArgumentException(
                    "Both 'constructorArgs' and 'constructorArgTypes' need to be specified");
        }
        if (constructorArgs.length != constructorArgTypes.length) {
            throw new IllegalArgumentException("Number of 'constructorArgs' ("
                    + constructorArgs.length
                    + ") must match number of 'constructorArgTypes' ("
                    + constructorArgTypes.length + ")");
        }
        this.constructorArgs = constructorArgs;
        this.constructorArgTypes = constructorArgTypes;
    }

    public Object getProxy() {
        return getProxy(null);
    }

    //获取具体的代理类
    public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating CGLIB proxy: target source is "
                    + this.advised.getTargetSource());
        }
        //获取代理
        try {
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null,
                    "Target class must be available for creating a CGLIB proxy");

            Class<?> proxySuperClass = rootClass;
            //判断是否为cglibProxy代理
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }
            //验证类
            validateClassIfNecessary(proxySuperClass);
            //配置CGLIB
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (((classLoader instanceof SmartClassLoader))
                        && (((SmartClassLoader) classLoader)
                                .isClassReloadable(proxySuperClass))) {
                    enhancer.setUseCache(false);
                }
            }
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setStrategy(new UndeclaredThrowableStrategy(
                    UndeclaredThrowableException.class));
            enhancer.setInterfaces(AopProxyUtils
                    .completeProxiedInterfaces(this.advised));
            enhancer.setInterceptDuringConstruction(false);
            //回调参数
            Callback[] callbacks = getCallbacks(rootClass);
            enhancer.setCallbacks(callbacks);
            enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised
                    .getConfigurationOnlyCopy(), this.fixedInterceptorMap,
                    this.fixedInterceptorOffset));
            //获取回调类型
            Class<?>[] types = new Class[callbacks.length];
            for (int x = 0; x < types.length; x++) {
                types[x] = callbacks[x].getClass();
            }
            enhancer.setCallbackTypes(types);
            //生成代理实例
            Object proxy;
            if (this.constructorArgs != null) {
                proxy = enhancer.create(this.constructorArgTypes,
                        this.constructorArgs);
            }
            //返回代理
            return enhancer.create();
        } catch (CodeGenerationException ex) {
            throw new AopConfigException(
                    "Could not generate CGLIB subclass of class ["
                            + this.advised.getTargetClass()
                            + "]: "
                            + "Common causes of this problem include using a final class or a non-visible class",
                    ex);
        } catch (IllegalArgumentException ex) {
            throw new AopConfigException(
                    "Could not generate CGLIB subclass of class ["
                            + this.advised.getTargetClass()
                            + "]: "
                            + "Common causes of this problem include using a final class or a non-visible class",
                    ex);
        } catch (Exception ex) {
            throw new AopConfigException("Unexpected AOP exception", ex);
        }
    }

    //创建代理Enhancer
    protected Enhancer createEnhancer() {
        return new Enhancer();
    }

    //检查是否支持代理
    private void validateClassIfNecessary(Class<?> proxySuperClass) {
        if (logger.isWarnEnabled()) {
            synchronized (validatedClasses) {
                if (!validatedClasses.containsKey(proxySuperClass)) {
                    doValidateClass(proxySuperClass);
                    validatedClasses.put(proxySuperClass, Boolean.TRUE);
                }
            }
        }
    }   

    private void doValidateClass(Class<?> proxySuperClass) {
        Method[] methods = proxySuperClass.getMethods();
        for (Method method : methods) {
            if ((!Object.class.equals(method.getDeclaringClass()))
                    && (Modifier.isFinal(method.getModifiers()))) {
                logger.warn("Unable to proxy method ["
                        + method
                        + "] because it is final: "
                        + "All calls to this method via a proxy will be routed directly to the proxy.");
            }
        }
    }

    //获取回调参数
    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();

        Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
        Callback targetInterceptor;
        Callback targetInterceptor;
        if (exposeProxy) {
            targetInterceptor = isStatic ? new StaticUnadvisedExposedInterceptor(
                    this.advised.getTargetSource().getTarget())
                    : new DynamicUnadvisedExposedInterceptor(
                            this.advised.getTargetSource());
        } else {
            targetInterceptor = isStatic ? new StaticUnadvisedInterceptor(
                    this.advised.getTargetSource().getTarget())
                    : new DynamicUnadvisedInterceptor(
                            this.advised.getTargetSource());
        }
        Callback targetDispatcher = (Callback) (isStatic ? new StaticDispatcher(
                this.advised.getTargetSource().getTarget())
                : new SerializableNoOp());

        Callback[] mainCallbacks = { aopInterceptor, targetInterceptor,
                new SerializableNoOp(), targetDispatcher,
                this.advisedDispatcher, new EqualsInterceptor(this.advised),
                new HashCodeInterceptor(this.advised) };
        Callback[] callbacks;
        if ((isStatic) && (isFrozen)) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap(methods.length);
            for (int x = 0; x < methods.length; x++) {
                List<Object> chain = this.advised
                        .getInterceptorsAndDynamicInterceptionAdvice(
                                methods[x], rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
                        chain, this.advised.getTargetSource().getTarget(),
                        this.advised.getTargetClass());
                this.fixedInterceptorMap.put(methods[x].toString(),
                        Integer.valueOf(x));
            }
            Callback[] callbacks = new Callback[mainCallbacks.length
                    + fixedCallbacks.length];
            System.arraycopy(mainCallbacks, 0, callbacks, 0,
                    mainCallbacks.length);
            System.arraycopy(fixedCallbacks, 0, callbacks,
                    mainCallbacks.length, fixedCallbacks.length);
            this.fixedInterceptorOffset = mainCallbacks.length;
        } else {
            callbacks = mainCallbacks;
        }
        return callbacks;
    }

    //返回消息
    private static Object processReturnType(Object proxy, Object target,
            Method method, Object retVal) {
        if ((retVal != null)
                && (retVal == target)
                && (!RawTargetAccess.class.isAssignableFrom(method
                        .getDeclaringClass()))) {
            retVal = proxy;
        }
        Class<?> returnType = method.getReturnType();
        if ((retVal == null) && (returnType != Void.TYPE)
                && (returnType.isPrimitive())) {
            throw new AopInvocationException(
                    "Null return value from advice does not match primitive return type for: "
                            + method);
        }
        return retVal;
    }

    public boolean equals(Object other) {
        return (this == other)
                || (((other instanceof CglibAopProxy)) && (AopProxyUtils
                        .equalsInProxy(this.advised,
                                ((CglibAopProxy) other).advised)));
    }

    public int hashCode() {
        return CglibAopProxy.class.hashCode() * 13
                + this.advised.getTargetSource().hashCode();
    }

    public static class SerializableNoOp implements NoOp, Serializable {
    }

    private static class StaticUnadvisedInterceptor implements
            MethodInterceptor, Serializable {
        private final Object target;

        public StaticUnadvisedInterceptor(Object target) {
            this.target = target;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            Object retVal = methodProxy.invoke(this.target, args);
            return CglibAopProxy.processReturnType(proxy, this.target, method,
                    retVal);
        }
    }

    private static class StaticUnadvisedExposedInterceptor implements
            MethodInterceptor, Serializable {
        private final Object target;

        public StaticUnadvisedExposedInterceptor(Object target) {
            this.target = target;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            try {
                oldProxy = AopContext.setCurrentProxy(proxy);
                Object retVal = methodProxy.invoke(this.target, args);
                return CglibAopProxy.processReturnType(proxy, this.target,
                        method, retVal);
            } finally {
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

    //动态代理的具体事项
    private static class DynamicUnadvisedInterceptor implements
            MethodInterceptor, Serializable {
        //目标源
        private final TargetSource targetSource;

        public DynamicUnadvisedInterceptor(TargetSource targetSource) {
            this.targetSource = targetSource;
        }
        //代理方法 
        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            Object target = this.targetSource.getTarget();
            try {
                Object retVal = methodProxy.invoke(target, args);
                return CglibAopProxy.processReturnType(proxy, target, method,
                        retVal);
            } finally {
                this.targetSource.releaseTarget(target);
            }
        }
    }

    //实现AOP Alliance MethodInvocation
    private static class DynamicUnadvisedExposedInterceptor implements
            MethodInterceptor, Serializable {
        private final TargetSource targetSource;

        public DynamicUnadvisedExposedInterceptor(TargetSource targetSource) {
            this.targetSource = targetSource;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            Object target = this.targetSource.getTarget();
            try {
                oldProxy = AopContext.setCurrentProxy(proxy);
                Object retVal = methodProxy.invoke(target, args);
                return CglibAopProxy.processReturnType(proxy, target, method,
                        retVal);
            } finally {
                AopContext.setCurrentProxy(oldProxy);
                this.targetSource.releaseTarget(target);
            }
        }
    }

    private static class StaticDispatcher implements Dispatcher, Serializable {
        private Object target;

        public StaticDispatcher(Object target) {
            this.target = target;
        }

        public Object loadObject() {
            return this.target;
        }
    }

    private static class AdvisedDispatcher implements Dispatcher, Serializable {
        private final AdvisedSupport advised;

        public AdvisedDispatcher(AdvisedSupport advised) {
            this.advised = advised;
        }

        public Object loadObject() throws Exception {
            return this.advised;
        }
    }

    private static class EqualsInterceptor implements MethodInterceptor,
            Serializable {
        private final AdvisedSupport advised;

        public EqualsInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) {
            Object other = args[0];
            if (proxy == other) {
                return Boolean.valueOf(true);
            }
            if ((other instanceof Factory)) {
                Callback callback = ((Factory) other).getCallback(5);
                if (!(callback instanceof EqualsInterceptor)) {
                    return Boolean.valueOf(false);
                }
                AdvisedSupport otherAdvised = ((EqualsInterceptor) callback).advised;
                return Boolean.valueOf(AopProxyUtils.equalsInProxy(
                        this.advised, otherAdvised));
            }
            return Boolean.valueOf(false);
        }
    }

    private static class HashCodeInterceptor implements MethodInterceptor,
            Serializable {
        private final AdvisedSupport advised;

        public HashCodeInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) {
            return Integer.valueOf(CglibAopProxy.class.hashCode() * 13
                    + this.advised.getTargetSource().hashCode());
        }
    }

    private static class FixedChainStaticTargetInterceptor implements
            MethodInterceptor, Serializable {
        private final List<Object> adviceChain;
        private final Object target;
        private final Class<?> targetClass;

        public FixedChainStaticTargetInterceptor(List<Object> adviceChain,
                Object target, Class<?> targetClass) {
            this.adviceChain = adviceChain;
            this.target = target;
            this.targetClass = targetClass;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            MethodInvocation invocation = new CglibAopProxy.CglibMethodInvocation(
                    proxy, this.target, method, args, this.targetClass,
                    this.adviceChain, methodProxy);

            Object retVal = invocation.proceed();
            retVal = CglibAopProxy.processReturnType(proxy, this.target,
                    method, retVal);
            return retVal;
        }
    }

    private static class DynamicAdvisedInterceptor implements
            MethodInterceptor, Serializable {
        private AdvisedSupport advised;

        public DynamicAdvisedInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        public Object intercept(Object proxy, Method method, Object[] args,
                MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Class<?> targetClass = null;
            Object target = null;
            try {
                if (this.advised.exposeProxy) {
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }
                target = getTarget();
                if (target != null) {
                    targetClass = target.getClass();
                }
                List<Object> chain = this.advised
                        .getInterceptorsAndDynamicInterceptionAdvice(method,
                                targetClass);
                Object retVal;
                if ((chain.isEmpty())
                        && (Modifier.isPublic(method.getModifiers()))) {
                    retVal = methodProxy.invoke(target, args);
                } else {
                    retVal = new CglibAopProxy.CglibMethodInvocation(proxy,
                            target, method, args, targetClass, chain,
                            methodProxy).proceed();
                }
                Object retVal = CglibAopProxy.processReturnType(proxy, target,
                        method, retVal);
                return retVal;
            } finally {
                if (target != null) {
                    releaseTarget(target);
                }
                if (setProxyContext) {
                    AopContext.setCurrentProxy(oldProxy);
                }
            }
        }

        public boolean equals(Object other) {
            if (this != other) {
                if (!(other instanceof DynamicAdvisedInterceptor)) {
                    break label33;
                }
            }
            label33: return this.advised
                    .equals(((DynamicAdvisedInterceptor) other).advised);
        }

        public int hashCode() {
            return this.advised.hashCode();
        }

        protected Object getTarget() throws Exception {
            return this.advised.getTargetSource().getTarget();
        }

        protected void releaseTarget(Object target) throws Exception {
            this.advised.getTargetSource().releaseTarget(target);
        }
    }

    private static class CglibMethodInvocation extends
            ReflectiveMethodInvocation {
        private final MethodProxy methodProxy;
        private boolean protectedMethod;

        public CglibMethodInvocation(Object proxy, Object target,
                Method method, Object[] arguments, Class<?> targetClass,
                List<Object> interceptorsAndDynamicMethodMatchers,
                MethodProxy methodProxy) {
            super(target, method, arguments, targetClass,
                    interceptorsAndDynamicMethodMatchers);
            this.methodProxy = methodProxy;
            this.protectedMethod = Modifier.isProtected(method.getModifiers());
        }

        protected Object invokeJoinpoint() throws Throwable {
            if (this.protectedMethod) {
                return super.invokeJoinpoint();
            }
            return this.methodProxy.invoke(this.target, this.arguments);
        }
    }

    private static class ProxyCallbackFilter implements CallbackFilter {
        private final AdvisedSupport advised;
        private final Map<String, Integer> fixedInterceptorMap;
        private final int fixedInterceptorOffset;

        public ProxyCallbackFilter(AdvisedSupport advised,
                Map<String, Integer> fixedInterceptorMap,
                int fixedInterceptorOffset) {
            this.advised = advised;
            this.fixedInterceptorMap = fixedInterceptorMap;
            this.fixedInterceptorOffset = fixedInterceptorOffset;
        }

        public int accept(Method method) {
            if (AopUtils.isFinalizeMethod(method)) {
                CglibAopProxy.logger
                        .debug("Found finalize() method - using NO_OVERRIDE");
                return 2;
            }
            if ((!this.advised.isOpaque())
                    && (method.getDeclaringClass().isInterface())
                    && (method.getDeclaringClass()
                            .isAssignableFrom(Advised.class))) {
                if (CglibAopProxy.logger.isDebugEnabled()) {
                    CglibAopProxy.logger
                            .debug("Method is declared on Advised interface: "
                                    + method);
                }
                return 4;
            }
            if (AopUtils.isEqualsMethod(method)) {
                CglibAopProxy.logger.debug("Found 'equals' method: " + method);
                return 5;
            }
            if (AopUtils.isHashCodeMethod(method)) {
                CglibAopProxy.logger
                        .debug("Found 'hashCode' method: " + method);
                return 6;
            }
            Class<?> targetClass = this.advised.getTargetClass();

            List<?> chain = this.advised
                    .getInterceptorsAndDynamicInterceptionAdvice(method,
                            targetClass);
            boolean haveAdvice = !chain.isEmpty();
            boolean exposeProxy = this.advised.isExposeProxy();
            boolean isStatic = this.advised.getTargetSource().isStatic();
            boolean isFrozen = this.advised.isFrozen();
            if ((haveAdvice) || (!isFrozen)) {
                if (exposeProxy) {
                    if (CglibAopProxy.logger.isDebugEnabled()) {
                        CglibAopProxy.logger
                                .debug("Must expose proxy on advised method: "
                                        + method);
                    }
                    return 0;
                }
                String key = method.toString();
                if ((isStatic) && (isFrozen)
                        && (this.fixedInterceptorMap.containsKey(key))) {
                    if (CglibAopProxy.logger.isDebugEnabled()) {
                        CglibAopProxy.logger
                                .debug("Method has advice and optimisations are enabled: "
                                        + method);
                    }
                    int index = ((Integer) this.fixedInterceptorMap.get(key))
                            .intValue();
                    return index + this.fixedInterceptorOffset;
                }
                if (CglibAopProxy.logger.isDebugEnabled()) {
                    CglibAopProxy.logger
                            .debug("Unable to apply any optimisations to advised method: "
                                    + method);
                }
                return 0;
            }
            if ((exposeProxy) || (!isStatic)) {
                return 1;
            }
            Class<?> returnType = method.getReturnType();
            if (targetClass == returnType) {
                if (CglibAopProxy.logger.isDebugEnabled()) {
                    CglibAopProxy.logger
                            .debug("Method "
                                    + method
                                    + "has return type same as target type (may return this) - using INVOKE_TARGET");
                }
                return 1;
            }
            if ((returnType.isPrimitive())
                    || (!returnType.isAssignableFrom(targetClass))) {
                if (CglibAopProxy.logger.isDebugEnabled()) {
                    CglibAopProxy.logger
                            .debug("Method "
                                    + method
                                    + " has return type that ensures this cannot be returned- using DISPATCH_TARGET");
                }
                return 3;
            }
            if (CglibAopProxy.logger.isDebugEnabled()) {
                CglibAopProxy.logger
                        .debug("Method "
                                + method
                                + "has return type that is assignable from the target type (may return this) - "
                                + "using INVOKE_TARGET");
            }
            return 1;
        }

        public boolean equals(Object other) {
            if (other == this) {
                return true;
            }
            if (!(other instanceof ProxyCallbackFilter)) {
                return false;
            }
            ProxyCallbackFilter otherCallbackFilter = (ProxyCallbackFilter) other;
            AdvisedSupport otherAdvised = otherCallbackFilter.advised;
            if ((this.advised == null) || (otherAdvised == null)) {
                return false;
            }
            if (this.advised.isFrozen() != otherAdvised.isFrozen()) {
                return false;
            }
            if (this.advised.isExposeProxy() != otherAdvised.isExposeProxy()) {
                return false;
            }
            if (this.advised.getTargetSource().isStatic() != otherAdvised
                    .getTargetSource().isStatic()) {
                return false;
            }
            if (!AopProxyUtils.equalsProxiedInterfaces(this.advised,
                    otherAdvised)) {
                return false;
            }
            Advisor[] thisAdvisors = this.advised.getAdvisors();
            Advisor[] thatAdvisors = otherAdvised.getAdvisors();
            if (thisAdvisors.length != thatAdvisors.length) {
                return false;
            }
            for (int i = 0; i < thisAdvisors.length; i++) {
                Advisor thisAdvisor = thisAdvisors[i];
                Advisor thatAdvisor = thatAdvisors[i];
                if (!equalsAdviceClasses(thisAdvisor, thatAdvisor)) {
                    return false;
                }
                if (!equalsPointcuts(thisAdvisor, thatAdvisor)) {
                    return false;
                }
            }
            return true;
        }

        private boolean equalsAdviceClasses(Advisor a, Advisor b) {
            Advice aa = a.getAdvice();
            Advice ba = b.getAdvice();
            if ((aa == null) || (ba == null)) {
                return aa == ba;
            }
            return aa.getClass().equals(ba.getClass());
        }

        private boolean equalsPointcuts(Advisor a, Advisor b) {
            if ((a instanceof PointcutAdvisor)) {
                if (!(b instanceof PointcutAdvisor)) {
                    break label42;
                }
            }
            label42: return ObjectUtils.nullSafeEquals(
                    ((PointcutAdvisor) a).getPointcut(),
                    ((PointcutAdvisor) b).getPointcut());
        }

        public int hashCode() {
            int hashCode = 0;
            Advisor[] advisors = this.advised.getAdvisors();
            for (Advisor advisor : advisors) {
                Advice advice = advisor.getAdvice();
                if (advice != null) {
                    hashCode = 13 * hashCode + advice.getClass().hashCode();
                }
            }
            hashCode = 13 * hashCode + (this.advised.isFrozen() ? 1 : 0);
            hashCode = 13 * hashCode + (this.advised.isExposeProxy() ? 1 : 0);
            hashCode = 13 * hashCode + (this.advised.isOptimize() ? 1 : 0);
            hashCode = 13 * hashCode + (this.advised.isOpaque() ? 1 : 0);
            return hashCode;
        }
    }
}

代理模式在Struts2中的实际应用

Struts2中的拦截器，其实就是代理模式的一种实现。Struts2是一个基于Sun J2EE的MVC框架，它只有一个中心控制器，采用XML定制转向的URL，采用Action来处理逻辑。
这里写图片描述

在Struts2中，一个重要的类是org.apache.struts2.dispatcher.FilterDispatcher，用户通过浏览器提交一个HttpServletRequest请求后，请求被在web.xml中定义的过滤器FilterDispatcher拦截，在FilterDispatcher过滤器中首先询问ActionMapper是否需要调用某个Action来处理请求，如果ActionMapper决定调用某个某个Action，FilterDispatcher则把请求的处理交给ActionProxy，ActionProxy通过配置文件struts.xml找到需要调用的Action类，然后ActionProxy创建一个ActionInvocation实例并调用该Action，但在调用之前，ActionInvocation会根据加载Action相关的所有Interceptor，等Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回Result。

在Struts2中，拦截器其实是AOP的一种实现方式，通过拦截器可以在Action执行的前后处理一些相应的操作。

ActionProxy

package com.opensymphony.xwork2;

import com.opensymphony.xwork2.config.entities.ActionConfig;

public abstract interface ActionProxy {
    //插入Action实例
    public abstract Object getAction();

    //获取Action名称
    public abstract String getActionName();

    //获取Action配置
    public abstract ActionConfig getConfig();

    public abstract void setExecuteResult(boolean paramBoolean);

    public abstract boolean getExecuteResult();

    //代理方法
    public abstract ActionInvocation getInvocation();

    public abstract String getNamespace();

    public abstract String execute() throws Exception;

    public abstract String getMethod();

    public abstract boolean isMethodSpecified();
}

DefaultActionProxy

package com.opensymphony.xwork2;

import com.opensymphony.xwork2.config.Configuration;
import com.opensymphony.xwork2.config.ConfigurationException;
import com.opensymphony.xwork2.config.RuntimeConfiguration;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.util.LocalizedTextUtil;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import com.opensymphony.xwork2.util.profiling.UtilTimerStack;
import java.io.Serializable;
import java.util.Locale;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;

public class DefaultActionProxy implements ActionProxy, Serializable {
    private static final long serialVersionUID = 3293074152487468527L;
    private static final Logger LOG = LoggerFactory
            .getLogger(DefaultActionProxy.class);
    protected Configuration configuration;
    protected ActionConfig config;
    protected ActionInvocation invocation;
    protected UnknownHandlerManager unknownHandlerManager;
    protected String actionName;
    protected String namespace;
    protected String method;
    protected boolean executeResult;
    protected boolean cleanupContext;
    protected ObjectFactory objectFactory;
    protected ActionEventListener actionEventListener; // 定义监听事件
    private boolean methodSpecified = true;

    // 初始化构造函数，下列代码用于实现代理的默认构造函数
    protected DefaultActionProxy(ActionInvocation inv, String namespace,
            String actionName, String methodName, boolean executeResult,
            boolean cleanupContext) {
        this.invocation = inv;
        this.cleanupContext = cleanupContext;
        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating an DefaultActionProxy for namespace "
                    + namespace + " and action name " + actionName,
                    new String[0]);
        }
        this.actionName = StringEscapeUtils.escapeHtml4(actionName);
        this.namespace = namespace;
        this.executeResult = executeResult;
        this.method = StringEscapeUtils.escapeEcmaScript(StringEscapeUtils
                .escapeHtml4(methodName));
    }

    @Inject
    public void setObjectFactory(ObjectFactory factory) {
        this.objectFactory = factory;
    }

    @Inject
    public void setConfiguration(Configuration config) {
        this.configuration = config;
    }

    @Inject
    public void setUnknownHandler(UnknownHandlerManager unknownHandlerManager) {
        this.unknownHandlerManager = unknownHandlerManager;
    }

    @Inject(required = false)
    public void setActionEventListener(ActionEventListener listener) {
        this.actionEventListener = listener;
    }

    public Object getAction() {
        return this.invocation.getAction();
    }

    public String getActionName() {
        return this.actionName;
    }

    public ActionConfig getConfig() {
        return this.config;
    }

    public void setExecuteResult(boolean executeResult) {
        this.executeResult = executeResult;
    }

    public boolean getExecuteResult() {
        return this.executeResult;
    }

    public ActionInvocation getInvocation() {
        return this.invocation;
    }

    public String getNamespace() {
        return this.namespace;
    }

    //通过代理要执行的方法
    public String execute() throws Exception {
        ActionContext nestedContext = ActionContext.getContext();
        ActionContext.setContext(this.invocation.getInvocationContext());

        String retCode = null;

        String profileKey = "execute: ";
        try {
            UtilTimerStack.push(profileKey);

            retCode = this.invocation.invoke();
        } finally {
            if (this.cleanupContext) {
                ActionContext.setContext(nestedContext);
            }
            UtilTimerStack.pop(profileKey);
        }
        return retCode;
    }

    public String getMethod() {
        return this.method;
    }

    //指定方法
    private void resolveMethod() {
        if (StringUtils.isEmpty(this.method)) {
            this.method = this.config.getMethodName();
            if (StringUtils.isEmpty(this.method)) {
                this.method = "execute";
            }
            this.methodSpecified = false;
        }
    }

    //在方法执行前要执行的方法，在代理类执行前要执行的内容
    protected void prepare() {
        String profileKey = "create DefaultActionProxy: ";
        try {
            UtilTimerStack.push(profileKey);
            this.config = this.configuration.getRuntimeConfiguration()
                    .getActionConfig(this.namespace, this.actionName);
            if ((this.config == null)
                    && (this.unknownHandlerManager.hasUnknownHandlers())) {
                this.config = this.unknownHandlerManager.handleUnknownAction(
                        this.namespace, this.actionName);
            }
            if (this.config == null) {
                throw new ConfigurationException(getErrorMessage());
            }
            resolveMethod();
            if (!this.config.isAllowedMethod(this.method)) {
                throw new ConfigurationException("Invalid method: "
                        + this.method + " for action " + this.actionName);
            }
            this.invocation.init(this);
        } finally {
            UtilTimerStack.pop(profileKey);
        }
    }

    //获取错误信息
    protected String getErrorMessage() {
        if ((this.namespace != null) && (this.namespace.trim().length() > 0)) {
            return LocalizedTextUtil.findDefaultText(
                    "xwork.exception.missing-package-action",
                    Locale.getDefault(), new String[] { this.namespace,
                            this.actionName });
        }
        return LocalizedTextUtil.findDefaultText(
                "xwork.exception.missing-action", Locale.getDefault(),
                new String[] { this.actionName });
    }

    public boolean isMethodSpecified() {
        return this.methodSpecified;
    }
}

StrutsActionProxy

package org.apache.struts2.impl;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.DefaultActionProxy;
import com.opensymphony.xwork2.util.LocalizedTextUtil;
import java.util.Locale;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.ServletActionContext;

public class StrutsActionProxy extends DefaultActionProxy {
    private static final long serialVersionUID = -2434901249671934080L;

    public StrutsActionProxy(ActionInvocation inv, String namespace,
            String actionName, String methodName, boolean executeResult,
            boolean cleanupContext) {
        super(inv, namespace, actionName, methodName, executeResult,
                cleanupContext);
    }

    //执行要代理的方法
    public String execute() throws Exception {
        ActionContext previous = ActionContext.getContext();
        ActionContext.setContext(this.invocation.getInvocationContext());
        try {
            return this.invocation.invoke();
        } finally {
            if (this.cleanupContext) {
                ActionContext.setContext(previous);
            }
        }
    }

    protected void prepare() {
        super.prepare();
    }

    protected String getErrorMessage() {
        if ((this.namespace != null) && (this.namespace.trim().length() > 0)) {
            String contextPath = ServletActionContext.getRequest()
                    .getContextPath();
            return LocalizedTextUtil.findDefaultText(
                    "struts.exception.missing-package-action.with-context",
                    Locale.getDefault(), new String[] { this.namespace,
                            this.actionName, contextPath });
        }
        return super.getErrorMessage();
    }
}