classpathconfigurationprovider.java

struts 2 核心包 的源码 有错误是难免的

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   ClasspathConfigurationProvider.java

package org.apache.struts2.config;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.config.*;
import com.opensymphony.xwork2.config.entities.*;
import com.opensymphony.xwork2.inject.ContainerBuilder;
import com.opensymphony.xwork2.util.*;
import com.opensymphony.xwork2.util.location.LocatableProperties;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.util.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

// Referenced classes of package org.apache.struts2.config:
//			ParentPackage, Namespace, Results, Result, 
//			NullResult

public class ClasspathConfigurationProvider
	implements ConfigurationProvider
{
	class ResultMap extends HashMap
	{

		private Class actionClass;
		private String actionName;
		private PackageConfig pkgConfig;
		final ClasspathConfigurationProvider this$0;

		protected ResultConfig createResultConfig(Result result)
		{
			Class cls = result.type();
			if (cls == org/apache/struts2/config/NullResult)
				cls = null;
			return createResultConfig(result.name(), cls, result.value(), createParameterMap(result.params()));
		}

		protected Map createParameterMap(String parms[])
		{
			Map map = new HashMap();
			int subtract = parms.length % 2;
			if (subtract != 0)
				ClasspathConfigurationProvider.LOG.warn("Odd number of result parameters key/values specified.  The final one will be ignored.");
			for (int i = 0; i < parms.length - subtract; i++)
			{
				String key = parms[i++];
				String value = parms[i];
				map.put(key, value);
				if (ClasspathConfigurationProvider.LOG.isDebugEnabled())
					ClasspathConfigurationProvider.LOG.debug((new StringBuilder()).append("Adding parmeter[").append(key).append(":").append(value).append("] to result.").toString());
			}

			return map;
		}

		private ResultConfig createResultConfig(Object key, Class resultClass, String location, Map configParams)
		{
			if (resultClass == null)
			{
				String defaultResultType = pkgConfig.getFullDefaultResultType();
				ResultTypeConfig resultType = (ResultTypeConfig)pkgConfig.getAllResultTypeConfigs().get(defaultResultType);
				configParams = resultType.getParams();
				String className = resultType.getClazz();
				try
				{
					resultClass = ClassLoaderUtil.loadClass(className, getClass());
				}
				catch (ClassNotFoundException ex)
				{
					throw new ConfigurationException((new StringBuilder()).append("ClasspathConfigurationProvider: Unable to locate result class ").append(className).toString(), actionClass);
				}
			}
			String defaultParam;
			try
			{
				defaultParam = (String)resultClass.getField("DEFAULT_PARAM").get(null);
			}
			catch (Exception e)
			{
				defaultParam = "location";
			}
			HashMap params = new HashMap();
			if (configParams != null)
				params.putAll(configParams);
			params.put(defaultParam, location);
			return new ResultConfig((String)key, resultClass.getName(), params);
		}

		public ResultMap(Class actionClass, String actionName, PackageConfig pkgConfig)
		{
			this$0 = ClasspathConfigurationProvider.this;
			super();
			this.actionClass = actionClass;
			this.actionName = actionName;
			this.pkgConfig = pkgConfig;
			for (; !actionClass.getName().equals(java/lang/Object.getName()); actionClass = actionClass.getSuperclass())
			{
				Results results = (Results)actionClass.getAnnotation(org/apache/struts2/config/Results);
				if (results != null)
				{
					for (int i = 0; i < results.value().length; i++)
					{
						Result result = results.value()[i];
						ResultConfig config = createResultConfig(result);
						put(config.getName(), config);
					}

				}
				Result result = (Result)actionClass.getAnnotation(org/apache/struts2/config/Result);
				if (result != null)
				{
					ResultConfig config = createResultConfig(result);
					put(config.getName(), config);
				}
			}

		}
	}

	public static class ClasspathPageLocator
		implements PageLocator
	{

		public URL locate(String path)
		{
			return ClassLoaderUtil.getResource(path, getClass());
		}

		public ClasspathPageLocator()
		{
		}
	}

	public static interface PageLocator
	{

		public abstract URL locate(String s);
	}


	private static final String DEFAULT_PAGE_PREFIX = "struts.configuration.classpath.defaultPagePrefix";
	private String defaultPagePrefix;
	private static final String DEFAULT_PAGE_EXTENSION = "struts.configuration.classpath.defaultPageExtension";
	private String defaultPageExtension;
	private static final String DEFAULT_PARENT_PACKAGE = "struts.configuration.classpath.defaultParentPackage";
	private String defaultParentPackage;
	private static final String FORCE_LOWER_CASE = "struts.configuration.classpath.forceLowerCase";
	private boolean forceLowerCase;
	private static final String ACTION = "Action";
	private PageLocator pageLocator;
	private boolean initialized;
	private String packages[];
	private Map loadedPackageConfigs;
	private static final Log LOG = LogFactory.getLog(org/apache/struts2/config/ClasspathConfigurationProvider);
	private Configuration configuration;

	public ClasspathConfigurationProvider(String pkgs[])
	{
		defaultPagePrefix = "";
		defaultPageExtension = ".jsp";
		defaultParentPackage = "struts-default";
		forceLowerCase = true;
		pageLocator = new ClasspathPageLocator();
		initialized = false;
		loadedPackageConfigs = new HashMap();
		packages = pkgs;
	}

	public void setDefaultParentPackage(String defaultParentPackage)
	{
		this.defaultParentPackage = defaultParentPackage;
	}

	public void setDefaultPageExtension(String defaultPageExtension)
	{
		this.defaultPageExtension = defaultPageExtension;
	}

	public void setDefaultPagePrefix(String defaultPagePrefix)
	{
		this.defaultPagePrefix = defaultPagePrefix;
	}

	public void setForceLowerCase(String force)
	{
		forceLowerCase = "true".equals(force);
	}

	public void setPageLocator(PageLocator locator)
	{
		pageLocator = locator;
	}

	protected void loadPackages(String pkgs[])
	{
		ResolverUtil resolver = new ResolverUtil();
		resolver.find(new com.opensymphony.xwork2.util.ResolverUtil.Test() {

			final ClasspathConfigurationProvider this$0;

			public boolean matches(Class type)
			{
				return com/opensymphony/xwork2/Action.isAssignableFrom(type) || type.getSimpleName().endsWith("Action");
			}

			
			{
				this$0 = ClasspathConfigurationProvider.this;
				super();
			}
		}, pkgs);
		Set actionClasses = resolver.getClasses();
		Iterator i$ = actionClasses.iterator();
		do
		{
			if (!i$.hasNext())
				break;
			Object obj = (Class)i$.next();
			Class cls = (Class)obj;
			if (!Modifier.isAbstract(cls.getModifiers()))
				processActionClass(cls, pkgs);
		} while (true);
		String key;
		for (i$ = loadedPackageConfigs.keySet().iterator(); i$.hasNext(); configuration.addPackageConfig(key, (PackageConfig)loadedPackageConfigs.get(key)))
			key = (String)i$.next();

	}

	protected void processActionClass(Class cls, String pkgs[])
	{
		String name = cls.getName();
		String actionPackage = cls.getPackage().getName();
		String actionNamespace = null;
		String actionName = null;
		String arr$[] = pkgs;
		int len$ = arr$.length;
		int i$ = 0;
		do
		{
			if (i$ >= len$)
				break;
			String pkg = arr$[i$];
			if (name.startsWith(pkg))
			{
				if (LOG.isDebugEnabled())
					LOG.debug((new StringBuilder()).append("ClasspathConfigurationProvider: Processing class ").append(name).toString());
				name = name.substring(pkg.length() + 1);
				actionNamespace = "";
				actionName = name;
				int pos = name.lastIndexOf('.');
				if (pos > -1)
				{
					actionNamespace = (new StringBuilder()).append("/").append(name.substring(0, pos).replace('.', '/')).toString();
					actionName = name.substring(pos + 1);
				}
				break;
			}
			i$++;
		} while (true);
		PackageConfig pkgConfig = loadPackageConfig(actionNamespace, actionPackage, cls);
		if (!actionPackage.equals(pkgConfig.getName()))
			actionPackage = pkgConfig.getName();
		java.lang.annotation.Annotation annotation = cls.getAnnotation(org/apache/struts2/config/ParentPackage);
		if (annotation != null)
		{
			String parent = ((ParentPackage)annotation).value();
			PackageConfig parentPkg = configuration.getPackageConfig(parent);
			if (parentPkg == null)
				throw new ConfigurationException((new StringBuilder()).append("ClasspathConfigurationProvider: Unable to locate parent package ").append(parent).toString(), annotation);
			pkgConfig.addParent(parentPkg);
			if (!TextUtils.stringSet(pkgConfig.getNamespace()) && TextUtils.stringSet(parentPkg.getNamespace()))
				pkgConfig.setNamespace(parentPkg.getNamespace());
		}
		if (actionName.endsWith("Action"))
			actionName = actionName.substring(0, actionName.length() - "Action".length());
		if (forceLowerCase && actionName.length() > 1)
		{
			int lowerPos = actionName.lastIndexOf('/') + 1;
			StringBuilder sb = new StringBuilder();
			sb.append(actionName.substring(0, lowerPos));
			sb.append(Character.toLowerCase(actionName.charAt(lowerPos)));
			sb.append(actionName.substring(lowerPos + 1));
			actionName = sb.toString();
		}
		ActionConfig actionConfig = new ActionConfig();
		actionConfig.setClassName(cls.getName());
		actionConfig.setPackageName(actionPackage);
		actionConfig.setResults(new ResultMap(cls, actionName, pkgConfig));
		pkgConfig.addActionConfig(actionName, actionConfig);
	}

	protected PackageConfig loadPackageConfig(String actionNamespace, String actionPackage, Class actionClass)
	{
		PackageConfig parent = null;
		if (actionClass != null)
		{
			Namespace ns = (Namespace)actionClass.getAnnotation(org/apache/struts2/config/Namespace);
			if (ns != null)
			{
				parent = loadPackageConfig(actionNamespace, actionPackage, null);
				actionNamespace = ns.value();
				actionPackage = actionClass.getName();
			}
		}
		PackageConfig pkgConfig = (PackageConfig)loadedPackageConfigs.get(actionPackage);
		if (pkgConfig == null)
		{
			pkgConfig = new PackageConfig();
			pkgConfig.setName(actionPackage);
			if (parent == null)
				parent = configuration.getPackageConfig(defaultParentPackage);
			if (parent == null)
				throw new ConfigurationException((new StringBuilder()).append("ClasspathConfigurationProvider: Unable to locate default parent package: ").append(defaultParentPackage).toString());
			pkgConfig.addParent(parent);
			pkgConfig.setNamespace(actionNamespace);
			loadedPackageConfigs.put(actionPackage, pkgConfig);
		}
		return pkgConfig;
	}

	public void destroy()
	{
	}

	public void init(Configuration config)
	{
		configuration = config;
	}

	public void loadPackages()
		throws ConfigurationException
	{
		loadedPackageConfigs.clear();
		loadPackages(packages);
		initialized = true;
	}

	public boolean needsReload()
	{
		return !initialized;
	}

	public void register(ContainerBuilder containerbuilder, LocatableProperties locatableproperties)
		throws ConfigurationException
	{
	}


}