stripes actionresolve (一)

3.5解析ActionResolver


我们已经了解stripes的生命周期，如何通过配置把可配置的组件组合在一起，又了解了如何通过interceptor把这些组件串起来。现在我们应该了解每步每个组件都做了什么，首先我们要了解是ActionResolver，也就stripes如何通过url path去映射到相对应的action。在DispatcherServlet中第一步生命阶段就是resolveActionBean(ctx)；这个方法的主体在：DispatcherHelper.java中：

public static Resolution resolveActionBean(final ExecutionContext ctx) throws Exception {
        return  ctx.wrap( new Interceptor() {
            public Resolution intercept(ExecutionContext ctx) throws Exception {
                // Look up the ActionBean and set it on the context
                ActionBeanContext context = ctx.getActionBeanContext();
                ActionBean bean = StripesFilter.getConfiguration()
.getActionResolver().getActionBean(context);
           //把找到actionbean实例保存在ExcuteContext中。
    ctx.setActionBean(bean);
       // 把找到actionbean实例保存在request中actionBean中，以供在页面或后面的// 程序直接调用actionbean实例
                HttpServletRequest request = context.getRequest();                request.setAttribute(StripesConstants.REQ_ATTR_ACTION_BEAN, bean);
                return null;           }        });    }

 

 上面最重要的一部分是       ActionBean bean = StripesFilter.getConfiguration().getActionResolver().getActionBean(context);       这是通过configuration找到配置或默认的ActionResolver。Stripes默认是NameBasedActionResolver;它继承于AnnotatedClassActionResolver。它的实质是采用annotation映射。由而我们要定制ActionResolver，最好是继承于AnnotatedClassActionResolver。由于ActionResolver是可配置组件，在stripes启动时，就会生成ActionResolver的子类的实例并运行它们的init(Configuraton)方法。我们先来看一下NameBasedActionResolver.getActionBean(context)，这个方法继承于AnnotatedClassActionResolver;

public ActionBean getActionBean(ActionBeanContext context) throws StripesServletException {       
        HttpServletRequest request = context.getRequest();
        String path = getRequestedPath(request);
     //调用本类的getActionBean(context, path)方法，但是此时实例是、、//NameBasedActionResolver，而此实例中又有重写的同名方法，只能是运行子类的方法了。
    ActionBean bean = getActionBean(context, path);
     //把找到actionbean实例放在request中的__stripes_resolved_action。
   request.setAttribute(RESOLVED_ACTION, getUrlBindingFromPath(path));
        return bean;
    }
@Override public ActionBean getActionBean(ActionBeanContext
 context, String urlBinding) throws StripesServletException {
     try {    return super.getActionBean(context, urlBinding);     }
       catch (StripesServletException sse) {
        ActionBean bean = handleActionBeanNotFound(context, urlBinding);
         if (bean != null) {      bean.setContext(context);
                             return bean;           }
            else {               throw sse;            }        }    }

 

 它Override父类的同名方法。它的功能是先执行父类的同名方法，如果出现了异常（即没有找到对应的actionbean）就找找看有没有最合适的jsp文件。比如请求user.action,就会找user.jsp或等等。

 

 protected ActionBean handleActionBeanNotFound(ActionBeanContext context, String urlBinding) {
        ActionBean bean = null;
        Resolution view = findView(urlBinding);
    if (view != null) {
      log.debug("Could not find an ActionBean bound to '", urlBinding, "', but found a view ","at '", view, "'. Forwarding the user there instead.");
          bean = new DefaultViewActionBean(view);       }
        return bean;    }
这个方法先执行findView(urlBinding)：
protected Resolution findView(String urlBinding) {
   int lastPeriod = urlBinding.lastIndexOf('.');
 String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1);
        String name = (lastPeriod >= path.length()) ? urlBinding.substring(path.length(), lastPeriod)   :    urlBinding.substring(path.length());
        ServletContext ctx = StripesFilter.getConfiguration().getBootstrapPropertyResolver().getFilterConfig().getServletContext();
        try {
            // This will try /account/ViewAccount.jsp
            String jsp = path + name + ".jsp";
            if (ctx.getResource(jsp) != null) {
                return new ForwardResolution(jsp);         }

            // This will try /account/viewAccount.jsp
      name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
            jsp = path + name + ".jsp";
            if (ctx.getResource(jsp) != null) {
                return new ForwardResolution(jsp);        }

            // And finally this will try /account/view_account.jsp
            StringBuilder builder = new StringBuilder();
            for (int i=0; i<name.length(); ++i) {
                char ch = name.charAt(i);
                if (Character.isUpperCase(ch)) {
                    builder.append("_");
                    builder.append(Character.toLowerCase(ch));
                }
                else {     builder.append(ch);     }   }
            jsp = path + builder.toString() + ".jsp";
            if (ctx.getResource(jsp) != null) {
                return new ForwardResolution(jsp);        }            return null;
                }  catch (MalformedURLException mue) {
            return null;        }    }}

 

这个方法很简单，就是找到合适的jsp页面如urlBinding 是ViewAccount.action            ViewAccount.jsp   viewAccount.jsp、view_account.jsp，之后就看存不存在三个jsp文件，存在就取最先存在jsp文件。现在回到handleActionBeanNotFound中，找到页面的Resolution，那接下为了上面的程序统一起来，就用这个Resolution生成一个 DefaultViewActionBean(view);

class DefaultViewActionBean implements ActionBean {
    private ActionBeanContext context;
    private Resolution view;
    public DefaultViewActionBean(Resolution view) { this.view = view; }
    public void setContext(ActionBeanContext context) { this.context = context; }
    public ActionBeanContext getContext() { return this.context; }
public Resolution view() { return view; }}

 

这个actionbean很很简单，就是DefaultViewActionBean(Resolution view) { this.view = view; }这个方法。用这个主要是为了和整体代码统一起来。 

现在我们要回到getActionBean(ActionBeanContext     ， String)看看：

public ActionBean getActionBean(ActionBeanContext context, String path)
            throws StripesServletException {

       String urlBinding = getUrlBindingFromPath(path);
      Class<? extends ActionBean> beanClass = this.formBeans.get(urlBinding);
        ActionBean bean;
        if (beanClass == null) {
            throw new StripesServletException(“emit”);       }
        try {      HttpServletRequest request = context.getRequest();
            if (beanClass.isAnnotationPresent(SessionScope.class)) {
            bean = (ActionBean) request.getSession().getAttribute(path);

          if (bean == null) {
             bean = makeNewActionBean(beanClass, context);
            equest.getSession().setAttribute(path, bean);      }
             bean.setContext(context);    }
            else {
                bean = (ActionBean) request.getAttribute(path);
                if (bean == null) {
                    bean = makeNewActionBean(beanClass, context);
                    bean.setContext(context);
                    request.setAttribute(path, bean); } }
                        return bean;      }
        catch (Exception e) {  。。。。。      }   }

 

这段代码首先从路径中找到urlBinding,再从urlBinding找到对应的actionbean.这两个等会儿分析，先看一下下面的代码，下面简单，从代码我们可以看出actionbean可以通过@SessionScope保存在session中。一般情况都是在request存着。通过调用程序员实现的bean.setContext(context);把上下文传到actionbean中。接下把actionbean的实例放在request（session）的path属性中。

回到上面的问题,如何找到urlBinding = getUrlBindingFromPath(path);：

String getUrlBindingFromPath(String path) {
        String binding = null;
        while (binding == null && path != null) {
            if (this.formBeans.containsKey(path)) {
                binding = path;            }         else {
                int lastSlash = path.lastIndexOf("/");
                if (lastSlash > 0) {
                    path = path.substring(0, lastSlash);    }
                else {    path = null;   }         }     }
                return binding;    }

 

在解决这个问题之前，我们得知道path是什么样的格式，怎么来的。Path是通过getActionBean(ActionBeanContext context)中的            HttpServletRequest request = context.getRequest();        String path = getRequestedPath(request);而得到： 

：  protected String getRequestedPath(HttpServletRequest request) {    String servletPath = null, pathInfo = null;
   if (request.getAttribute(StripesConstants.REQ_ATTR_INCLUDE_PATH) != null) {        servletPath = (String) request.getAttribute(StripesConstants.REQ_ATTR_INCLUDE_PATH);
       pathInfo    = (String) request.getAttribute(StripesConstants.REQ_ATTR_INCLUDE_PATH_INFO);        }
        else {       servletPath = request.getServletPath();
            pathInfo    = request.getPathInfo();
        }
	
        return (servletPath == null ? "" : servletPath) + (pathInfo == null ? "" : pathInfo);   }

 

在servlet规范中，把url路径为成三部分requestURI = contextPath + servletPath + pathInfo。

contextPath就是我们应用系统的名称，比如第二章的例子就是register。上面的程序就是取根目录之后URL地址部分，如：/user/register.action/view。我们知道是这种结构，就不难理解上面的程序就是从this.formBeans的找到有没有符合和/user/register.action/view相同的key。没有就再看看有没有/user/register.action这个相同。没有的话就再看/user相同的key.再没有的就是null啦。

在这个方法和上面的方法中都出现this.formBeans,这是什么东西，是map没有错：

 

rivate Map<String,Class<? extends ActionBean>> formBeans =
            new HashMap<String,Class<? extends ActionBean>>();
还记得AnnotatedClassActionResolver是可配置组件呸，应该想到这个formBeans应该在init(Configuration)中设了值。确定在AnnotatedClassActionResolver的init()设了值，但是细心的会问到：这个实例不是NameBasedActionResolver的，而且它也有init(Configuration)，先看NameBasedActionResolver的init()方法。
@Override
    public void init(Configuration configuration) throws Exception {
        super.init(configuration);
        addActionBean(DefaultViewActionBean.class);
}
它调用了AnnotatedClassActionResolver。之后增加了一个DefaultViewActionBean的bean。这个是为了找到与之对应的jsp页面而用的。不做分析。
public void init(Configuration configuration) throws Exception {
     is.configuration = configuration;
Set<Class<? extends ActionBean>> beans = findClasses(ActionBean.class);
    ActionClassCache.init(beans);
        for (Class<? extends ActionBean> clazz : beans) {
            addActionBean(clazz);       }
    }

 

 

这个方法先找到所有的actionbean,之后保存在缓存中。再之后分别处理每个bean.

protected <T> Set<Class<? extends T>> findClasses(Class<T> parentType) {
        ResolverUtil<T> resolver = new ResolverUtil<T>();
        resolver.setPackageFilters(getPackageFilters());
        resolver.setLocationFilters(getUrlFilters());

        if (!resolver.loadImplementationsFromContextClassloader(parentType)) {
            ServletContext context = this.configuration.getBootstrapPropertyResolver()
                    .getFilterConfig().getServletContext();

            resolver.loadImplementationsFromServletContext(parentType, context);
        }

        return resolver.getClasses();

这个功能是找到所有actionbean的子类。Stripes1.5有些变化。接下的缓存没有什么好看的，关键在于addActionBean(clazz);循环把每个actionbean及其对应的urlbinging和处理方法加入到this. formBeans中。

 

 protected void addActionBean(Class<? extends ActionBean> clazz) {
       //取得actionbean中如@ UrlBinding(“/user/register.action”)中的/user/register.action值
 String binding = getUrlBinding(clazz);
   // Only process the class if it's properly annotated
   if (binding != null) {
            this.formBeans.put(binding, clazz);
      // Construct the mapping of event->method for the class
    Map<String, Method> classMappings = new HashMap<String, Method>();
           processMethods(clazz, classMappings);
      // Put the event->method mapping for the class into the set of mappings
            this.eventMappings.put(clazz, classMappings);
            // Print out the event mappings nicely
    for (Map.Entry<String,Method> entry : classMappings.entrySet()) {
                String event   = entry.getKey();
                Method handler = entry.getValue();
                boolean isDefault = DEFAULT_HANDLER_KEY.equals(event);
                log.debug("Bound: ", clazz.getSimpleName(), ".", handler.getName(), "() ==> ",
                          binding, isDefault ? "" : "?" + event);
            }
        }
    }
在上在的代码中有两个属性： formBeans、eventMappings，formBeans保存urlbinging的路径和与之对应的actionbean关系。eventMappings保存actionbean类与它的所有的处理事件方法的关系。这样，我们就可以通过路径（urlbinging）找到类，再通过actionbean的类找到它的事件方法。Actionbean类通过分析类的@UrlBinding就可以找到，如果没有,因为actonresolver的实例是基于命名。所以String binding = getUrlBinding(clazz)中调用是子类的方法。
@Override
    public String getUrlBinding(Class<? extends ActionBean> clazz) {
        String binding = super.基于annotation的;
        // If there's no annotated binding, and the class is concrete
        if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) {    binding = getUrlBinding(clazz.getName());       }
        return binding;    }
getUrlBinding先调用父类的getUrlBinding(clazz)方法。之后把actionbean的类名按一定的规则转为urlbing路径。getUrlBinding(String name)就是实现这个功能：

protected String getUrlBinding(String name) {
        // Chop off the packages up until (and including) any base package
        for (String base : getBasePackages()) {
            int i = name.indexOf("." + base + ".");
            if (i != -1) {
                name = name.substring(i + base.length() + 1);}
            else if (name.startsWith(base + ".")) {
                name = name.substring(base.length());}   }
        // If it ends in Action or Bean (or ActionBean) take that off
        if (name.endsWith("Bean")) {
            name = name.substring(0, name.length() - 4);     }
        if (name.endsWith("Action")) {
            name = name.substring(0, name.length() - 6);        }

        // Replace periods with slashes and make sure it starts with one
        name = name.replace('.', '/');
        if (!name.startsWith("/")) {
            name = "/" + name;        }

        // Lastly add the suffix
        name += getBindingSuffix();
        return name;
    }
getUrlBinding(String name)就是一些字符转换，它把如com.morik.action.RegisterAction或者RegisterActionBean,变成Register.action.

解决了路径和actionbean的映射问题。接下来的processMethods(clazz, classMappings);就是如何把actionbean和它的所有的事件方法对应起来。
  protected void processMethods(Class clazz, Map<String,Method> classMappings) {
        // Do the super class first if there is one
        Class superclass = clazz.getSuperclass();
        if (superclass != null) {
            processMethods(superclass, classMappings);
        }

        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            if ( Modifier.isPublic(method.getModifiers()) ) {            
 String eventName = getHandledEvent(method);
                DefaultHandler defaultMapping = method.getAnnotation(DefaultHandler.class);
                if (eventName != null) {
                    classMappings.put(eventName, method);
                }
                if (defaultMapping != null) {
                    // Makes sure we catch the default handler
                    classMappings.put(DEFAULT_HANDLER_KEY, method);
                }
            }
        }
    }
这个一个递归方法，它实现了从actionbean所有父类开始找标识为@DefaultHandler和DefaultHandler的处理方法。对于基于命名的方法，
 public String getHandledEvent(Method handler) {
        String name = super.getHandledEvent(handler); 
        if ( name == null && !Modifier.isAbstract(handler.getModifiers())
          &&R esolution.class.isAssignableFrom(handler.getReturnType()) ) {            name = handler.getName();        }
        return name;    }

 

 

它是在解析事件方法时，如果在基于annotion没有找到，就找返回类型为Resolution的非抽象的方法同名方法。处理事件方法一般不会有参数的。 这样就actionResolver就找到与路径对应的actionbean类了，并初始化了类与处事事件方法的关系。 

 

分享到：

闲谈 Web 图片服务器(转) | stripes 的Intercept Execution

• 2008-02-20 09:07
• 浏览 1702
• 评论(0)
• 论坛回复 / 浏览 (0 / 2978)
• 查看更多