Spring

如果我们可以applicationContext.xml放到classpath下，我们可以使用ClasspathXmlApplicationContext。这里传入参数的路径是相对于classpath的配置的，对于web项目就是WEB-INF/classes这个目录，或者WEB-INF/lib下任意一个jar文件下了。

ApplicationContext ctx = new ClasspathXmlApplicationContext("applicationContext.xml");
            

从ServletContext取得web.xml中初始化的ApplicationContext

首先在web.xml中配置listener。

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:spring/*.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
            

然后从ServletContext中获得ApplicationContext。

ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(application);
            

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

相比schema真是方便了很多，这样可以在必须使用特定schema的时候，再让他重装上阵。

spring-2.x中去掉了singleton属性，使用scope属性做替代。如果还想使用singleton属性，必须配置成spring-1.x格式的DTD。

懒惰加载，系统启动的时候并不加载xml中定义的bean，而是等到实际调用的时候才去加载，这样可以缩短系统初始化时间，在测试系统部分功能的情况下有极大的好处。

注意，PropertityPlaceHolderConfigurer，springmvc，xfire，quartz等的配置文件不能声明为懒惰加载，否则会出问题。

按名称自动绑定。设置了这个，只要定义bean的时候名称与需要绑定的属性名相同，在实例化对象的时候，spring就会将这些实例自动绑定，不需要再去声明绑定哪些property。减少xml代码量，使得结构更清晰。

在使用compass的时候要注意，不能使用按名称自动绑定，会自动为compass绑定dataSource导致错误。

将xml统一放在classpath下，这样更有利于进行单元测试，对于多个模块的xml使用import进行导入，层次更清晰。

<import resource="classpath:jbpm/applicationContext-jbpm4.xml"/>
            

spring提供的编码过滤器，好处一是不用自己动手写了，好处二是保证每次请求只过滤一次。配置如下：（web.xml）

<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
            

spring提供的监听器，避免Struts，Quartz的内存泄露导致ClassLoader不能加载。配置如下：（web.xml）

<listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
            

读取properties中的变量，在xml中可以通过${变量名}的方式调用。配置如下：

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath*:conf/jdbc.properties</value>
        </list>
    </property>
</bean>

<bean id="userManager" class="com.family168.manager.UserManager">
    <property name="username" value="${jdbc.username}"/>
</bean>
            

与PropertyPlaceholderConfigurer不同，PropertyOverrideConfigurer会在ApplicationContext初始化后，根据properties中的定义，修改对应属性的值。配置如下：

<bean id="testPropertyConfigurer" class="org.springframework.beans.factory.config.PropertyOverrideConfigurer">
    <property name="locations" value="classpath*:override.properties"/>
    <property name="ignoreInvalidKeys" value="true"/>
</bean>
            

用来在测试环境下覆盖已有的配置，比如在override.properties中有userManager.username=111，那么id="userManager"的bean的username属性就会被修改为111。

ResourceLoader 可以获得ClassPath, File,URL中的文件，返回类型为Resource的统一资源定义。

ApplicationContext中就拥有ResourceLoader。

实现resourceLoaderAware接口可以获得ResourceLoader。

ResourcePatternResolver 是ResourceLoader的升级版子接口，能解决ant-style的文件模糊批量定义，如applicationContext-*.xml。

ApplicationContext中的ResourceLoader其实是ResourcePatternResolver ，可以通过强制转型获得，友好一点的做法是使用ResourcePatternUtils来转换。

public class RescManager implements InitializingBean, BeanNameAware,
    ResourceLoaderAware {
    private ResourceLoader resourceLoader;

    public void demo() throws IOException {
        ResourcePatternResolver resolver = ResourcePatternUtils
            .getResourcePatternResolver(resourceLoader);
        Resource[] rescs = resolver.getResources(
                "classpath*:spring/applicationContext*.xml");
        System.out.println(rescs);
    }
            

所谓微内核，就是仅提供以上三种功能的DI容器。

Spring的AOP、ORM、事务管理、JMX、Quartz、Remoting、Freemarker、Velocity，都靠FacotryBean的扩展，FacotryBean几乎遍布地上：

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"/>
<bean id="baseDAOService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"/>
            

这原理说出来好简单，所有FactoryBean 实现FactoryBean接口的getObject()函数。Spring容器getBean(id)时见到bean的定义是普通class时，就会构造该class的实例来获得bean，而如果发现是FactoryBean接口的实例时，就通过调用它的getObject()函数来获得bean，仅此而以.......可见，很重要的思想，可以用很简单的设计来实现。

考察一个典型的FactoryBean：

一般会有两个变量，三个接口：

一个setter函数注入需要改装的pojo，一个内部变量保持装配后的对象returnOjbect。

implements三个接口 ：FactoryBean,InitializingBean和BeanFactoryAware 。

各接口的意义之前都讲过了。factoryBean会在afterPropertiesSet()里把pojo改装成returnObject，需要用到beanfactory进行天马行空的动作时就靠BeanFactoryAware注入。最后在getObject()里把returnObject返回。

如果说FactoryBean 是一种Factory、Wrapper式的扩展，Bean Post-Processor就是另一种AOP、visitor式的机制，所以也多用于spring的AOP架构。

Post-Processor的原理就是BeanFactory在前文里的调用afterPropertiesSet()/init-method前后，调用在工厂里注册了的post-processor的postProcessBeforeInitialization()和postProcessAfterInitialization()。

那怎么注册登记呢？又分请不请礼仪公司两类。如果是ApplicationContext，你把继承BeanPostProcessor 的bean往xml里一搁就行了,application context自会打理。如果是BeanFacotry，就要显式的注册，代码大概像：

XmlBeanFactory factory = new XmlBeanFactory("C:/beans.xml");
BeanPostLogger logger = new BeanPostLogger();
factory.addBeanPostProcessor(logger);