Struts2框架及其设计模式

Struts2容器

         容器是框架的核心，可以利用容器生成bean，也可以完成依赖注入等，这些都是容器的基本功能，Struts2容器与之前介绍的Spring容器、Springmvc容器是大不一样的。Spring典型容器是ClassPathXmlApplicationContext，Springmvc延续Spring的风格，其典型容器是XmlWebApplicationContext，它们都是AbstractRefreshableApplicationContext的子类，以下为AbstractRefreshableApplicationContext、DefaultListableBeanFactory部分源码：

// AbstractRefreshableApplicationContext.java部分源码public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {private Boolean allowBeanDefinitionOverriding;private Boolean allowCircularReferences;// 包含DefaultListableBeanFactoryprivate DefaultListableBeanFactory beanFactory;/** Synchronization monitor for the internal BeanFactory */private final Object beanFactoryMonitor = new Object();// DefaultListableBeanFactory部分源码public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {/** Map from serialized id to factory instance */private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);/** Optional id for this factory, for serialization purposes */private String serializationId;/** Whether to allow re-registration of a different definition with the same name */private boolean allowBeanDefinitionOverriding = true;/** Whether to allow eager class loading even for lazy-init beans */private boolean allowEagerClassLoading = true;/** Resolver to use for checking if a bean definition is an autowire candidate */private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();/** Map from dependency type to corresponding autowired value */private final Map<Class<?>, Object> resolvableDependencies = new HashMap<Class<?>, Object>(16);/** Map of bean definition objects, keyed by bean name */// BeanDefinition键值对private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);/** Map of singleton and non-singleton bean names keyed by dependency type */private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);/** Map of singleton-only bean names keyed by dependency type */private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);/** List of bean definition names, in registration order */private final List<String> beanDefinitionNames = new ArrayList<String>();/** Whether bean definition metadata may be cached for all beans */private boolean configurationFrozen = false;/** Cached array of bean definition names in case of frozen configuration */private String[] frozenBeanDefinitionNames;

在Spring中，以Map<String, BeanDefinition> beanDefinitionMap形式缓存xml等配置解析后的BeanDefinition，且DefaultListableBeanFactory（AbstractBeanFactory）提供多种形式的getBean，以获取bean。

        在Struts2中，其容器为ContainerImpl：

// ContainerImpl.java部分源码class ContainerImpl implements Container {// 其体现在InternalFactory的键值对，缓存的都是InternalFactory// 直接利用InternalFactory创建beanfinal Map<Key<?>, InternalFactory<?>> factories;final Map<Class<?>, Set<String>> factoryNamesByType;// InternalFactory.javainterface InternalFactory<T> extends Serializable {/*** Creates an object to be injected.** @param context of this injection* @return instance to be injected*/T create(InternalContext context);}

Struts2框架中的设计模式

ThreadLocal设计模式

       ContainerHolder的ThreadLocal设计模式实现：

/** ContainerHolder.java */// ContainerHolder为典型的ThreadLocal设计模式实现class ContainerHolder {    private static ThreadLocal<Container> instance = new ThreadLocal<Container>();    public static void store(Container instance) {        ContainerHolder.instance.set(instance);    }    public static Container get() {        return ContainerHolder.instance.get();    }    public static void clear() {        ContainerHolder.instance.remove();    }}

         ThreadLocal设计模式本质：

/** ThreadLocal.java */public void set(T value) {// 获取当前线程Thread t = Thread.currentThread();// 获取当前线程的threadLocals属性ThreadLocalMap map = getMap(t);if (map != null)// 设置ThreadLocal—instance键值对map.set(this, value);else// 创建ThreadLocalMap，且设置ThreadLocal对应的初始值createMap(t, value);}ThreadLocalMap getMap(Thread t) {return t.threadLocals;}/** Thread.java */// Thread部分源码public class Thread implements Runnable {/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null;...}/** ThreadLocalMap.java */private void set(ThreadLocal key, Object value) {// We don't use a fast path as with get() because it is at// least as common to use set() to create new entries as// it is to replace existing ones, in which case, a fast// path would fail more often than not.Entry[] tab = table;int len = tab.length;int i = key.threadLocalHashCode & (len-1);for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {ThreadLocal k = e.get();if (k == key) {e.value = value;return;}if (k == null) {replaceStaleEntry(key, value, i);return;}}tab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)rehash();}/** ThreadLocal.java */void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);}

         ThreadLocal设计模式针对thread是线程安全的，在Thread中有ThreadLocal.ThreadLocalMap threadLocals属性，其key-value对应为ThreadLocal—实际存储对象，所以在多线程并发情况下，每一个线程存储的是对象的副本，线程之间隔离，这样当前线程对副本的操作不存在竞争关系，从这个层面体现为线程安全的。ThreadLocal设计模式在Struts2体现的淋漓尽致。

内部类工厂设计模式

        以ContainerBuilder中添加InternalFactory为例说明：

/** ContainerBuilder.java */public <T> ContainerBuilder factory(Class<T> type,  Class<? extends T> implementation, Scope scope) {return factory(type, Container.DEFAULT_NAME, implementation, scope);}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;}