xwork分析1

import java.util.HashMap; import java.util.Map; import com.opensymphony.xwork2.ActionProxy; import com.opensymphony.xwork2.ActionProxyFactory; import com.opensymphony.xwork2.config.Configuration; import com.opensymphony.xwork2.config.ConfigurationManager; import com.opensymphony.xwork2.inject.Container; public class Main { public static void main(String args[]){ ConfigurationManager cm = new ConfigurationManager();//1 Configuration config = cm.getConfiguration();//2 Container c = config.getContainer();//3 ActionProxyFactory actionProxyFactory = c.getInstance(ActionProxyFactory.class);//4 Map<String,Object> m = new HashMap<String,Object>();//5 m.put("name", "bobo"); ActionProxy actionProxy = actionProxyFactory.createActionProxy( "/helloWorld", "actionTest",null, m);//6 try { actionProxy.execute();//7 } catch (Exception e) { e.printStackTrace(); } } }

 

1 . ConfigurationManager,这个是xwork配置管理的核心，它默认是读取xwork.xml的配置文件的信息，xwork.xml可以通过extends="xwork-default" 来继承xwork-default.xml的配置信息，可以使用里面定义的各种拦截器，ConfigurationManager的主要内容如下：

 public class ConfigurationManager { protected Configuration configuration;//相关的配置信息 protected Lock providerLock = new ReentrantLock();//获取/设置containerProviders时使用的锁 private List<ContainerProvider> containerProviders = new CopyOnWriteArrayList<ContainerProvider>();//为容器提供bean,constants/properties信息 private List<PackageProvider> packageProviders = new CopyOnWriteArrayList<PackageProvider>();//提供包配置信息 TODO protected String defaultFrameworkBeanName; public ConfigurationManager() { this("xwork"); } public ConfigurationManager(String name) { this.defaultFrameworkBeanName = name; } public List<ContainerProvider> getContainerProviders() { providerLock.lock(); try { //没有提供的话就默认使用一下2个provider if (containerProviders.size() == 0) { containerProviders.add(new XWorkConfigurationProvider()); containerProviders.add(new XmlConfigurationProvider("xwork.xml", false)); } return containerProviders; } finally { providerLock.unlock(); } } public synchronized Configuration getConfiguration() { if (configuration == null) { //第一次获取的时候会初始化所有相关的ContainerProvider setConfiguration(new DefaultConfiguration(defaultFrameworkBeanName)); try { configuration.reloadContainer(getContainerProviders()); } catch (ConfigurationException e) { setConfiguration(null); throw new ConfigurationException("Unable to load configuration.", e); } } else { conditionalReload(); } return configuration; } }

 

 

2.Configuration是xwork的配置信息，它是一个接口主要的实现类有2个DefaultConfiguration和MockConfiguration(单元测试用的),Configuration的主要内容如下：

public interface Configuration extends Serializable { PackageConfig getPackageConfig(String name);//取得某一个package的配置信息 Map<String, PackageConfig> getPackageConfigs();//取得所有package的配置信息 RuntimeConfiguration getRuntimeConfiguration();//取得运行时期的配置信息 void addPackageConfig(String name, PackageConfig packageConfig);//添加包配置信息 PackageConfig removePackageConfig(String packageName);//移除包配置信息 Container getContainer();//获得容器 Set<String> getLoadedFileNames();//获得加载的配置文件的信息 }

 

 

 DefaultConfiguration是Configuration的实现类，它的主要成员变量有：

public class DefaultConfiguration implements Configuration { //相关的信息都存储在以下的成员变量中--------- protected Map<String, PackageConfig> packageContexts = new LinkedHashMap<String, PackageConfig>(); protected RuntimeConfiguration runtimeConfiguration; protected Container container; protected String defaultFrameworkBeanName; protected Set<String> loadedFileNames = new TreeSet<String>(); protected List<UnknownHandlerConfig> unknownHandlerStack; //xwork提供的对象创建工厂，使用buildBean 来创建所有的类，用户可以自定义自己的ObjectFactory ObjectFactory objectFactory; }

 

 

DefaultConfiguration的主要责任就是在reloadContainer的时候根据注册的所有ConfigurationProvider的提供的信息来实例化一个Container（它的默认实现是ContainerImpl）,然后根据Container来实例化ObjectFactory，最后使用Container对各个ConfigurationProvider进行依赖注入

public synchronized List<PackageProvider> reloadContainer(List<ContainerProvider> providers) throws ConfigurationException { packageContexts.clear(); loadedFileNames.clear(); List<PackageProvider> packageProviders = new ArrayList<PackageProvider>(); //在取得xwork的配置信息的时候使用了2个类从各个Providers取得相应的信息 ContainerProperties props = new ContainerProperties(); ContainerBuilder builder = new ContainerBuilder(); for (final ContainerProvider containerProvider : providers) { containerProvider.init(this); containerProvider.register(builder, props);//各个provider在register的时候往这2个实例中放入配置参数 } props.setConstants(builder); builder.factory(Configuration.class, new Factory<Configuration>() { public Configuration create(Context context) throws Exception { return DefaultConfiguration.this; } }); ActionContext oldContext = ActionContext.getContext(); try { // Set the bootstrap container for the purposes of factory creation Container bootstrap = createBootstrapContainer(); setContext(bootstrap); container = builder.create(false); setContext(container); objectFactory = container.getInstance(ObjectFactory.class); // Process the configuration providers first for (final ContainerProvider containerProvider : providers) { if (containerProvider instanceof PackageProvider) { container.inject(containerProvider); ((PackageProvider)containerProvider).loadPackages(); packageProviders.add((PackageProvider)containerProvider); } } // Then process any package providers from the plugins Set<String> packageProviderNames = container.getInstanceNames(PackageProvider.class); if (packageProviderNames != null) { for (String name : packageProviderNames) { PackageProvider provider = container.getInstance(PackageProvider.class, name); provider.init(this); provider.loadPackages(); packageProviders.add(provider); } } rebuildRuntimeConfiguration(); } finally { if (oldContext == null) { ActionContext.setContext(null); } } return packageProviders; }  

 

 

ContainerBuilder是一个final类，它主要是存储有关类型和相关实现类的信息，它主要的成员变量和方法有：

public final class ContainerBuilder { final Map<Key<?>, InternalFactory<?>> factories = new HashMap<Key<?>, InternalFactory<?>>();//所有class和name对应的实现类 final List<InternalFactory<?>> singletonFactories = new ArrayList<InternalFactory<?>>();//所有的单例的实现类 final List<Class<?>> staticInjections = new ArrayList<Class<?>>();//配置中bean中static=true的类 boolean created;//是否已经创建，适用于单例模式 boolean allowDuplicates = false; /** * 添加映射 */ public <T> ContainerBuilder factory(final Class<T> type, final String name, final Class<? extends T> implementation, final Scope scope) { // This factory creates new instances of the given implementation. // We have to lazy load the constructor because the Container // hasn't been created yet. InternalFactory<? extends T> factory = new InternalFactory<T>() { volatile ContainerImpl.ConstructorInjector<? extends T> constructor; @SuppressWarnings("unchecked") public T create(InternalContext context) { if (constructor == null) { this.constructor = context.getContainerImpl().getConstructor(implementation); } return (T) constructor.construct(context, type); } @Override public String toString() { return new LinkedHashMap<String, Object>() {​{ put("type", type); put("name", name); put("implementation", implementation); put("scope", scope); }}.toString(); } }; return factory(Key.newInstance(type, name), factory, scope); } private <T> ContainerBuilder factory(final Key<T> key, InternalFactory<? extends T> factory, Scope scope) { ensureNotCreated(); checkKey(key); final InternalFactory<? extends T> scopedFactory = scope.scopeFactory(key.getType(), key.getName(), factory); factories.put(key, scopedFactory); if (scope == Scope.SINGLETON) { singletonFactories.add(new InternalFactory<T>() { public T create(InternalContext context) { try { context.setExternalContext(ExternalContext.newInstance( null, key, context.getContainerImpl())); return scopedFactory.create(context); } finally { context.setExternalContext(null); } } }); } return this; } /** *创建Container */ public Container create(boolean loadSingletons) { ensureNotCreated(); created = true; final ContainerImpl container = new ContainerImpl( new HashMap<Key<?>, InternalFactory<?>>(factories)); if (loadSingletons) { container.callInContext(new ContainerImpl.ContextualCallable<Void>() { public Void call(InternalContext context) { for (InternalFactory<?> factory : singletonFactories) { factory.create(context); } return null; } }); } container.injectStatics(staticInjections); return container; } }