Deployment期间验证
实现一：
<bean id="theTargetBean" class="..."/>
<bean id="theClientBean" class="...">
<property name="targetName">
<idref bean="theTargetBean" />
</property>
</bean>
实现二：
<bean id="theTargetBean" class="..." />
<bean id="client" class="...">
<property name="targetName" value="theTargetBean" />
</bean>
方式1跟方式2得到的依赖关系完全一致，不同的是方式1在deployment的时候就会去判断名字为theTargetBean的bean是否有定义，方式2要推迟到client被实例化的时候才去判断名字为theTargetBean的bean是否有定义。
XML简写
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
命名空间p表示可以将<property>变成属性p:[name|name-ref]=”id”的方式出现于<bean>定义中；
命名空间c表示可以将<constructor-arg>变成属性c:[name|name-ref]=”id”的方式出现<bean>定义中；
提前初始化
<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/>
<bean name="not.lazy" class="com.foo.AnotherBean"/>
缺省情况下ApplicationContext在Initialization Process的时候就会创建并配置所有Singleton Bean (没有依赖项的bean)，如果lazy-init显示设置为true则表示取消提前初始化的功能，从而加快初始化速度并减少内存占用；对于<beans/>使用default-lazy-init=”true”属性进行批量设置。
方法注入（Lookup Method Injection）
Java代码
public abstract class CommandManager {
protected abstract Command createCommand();
}
Xml代码
<bean id="command" class="fiona.apple.AsyncCommand" scope="prototype">
<!-- inject dependencies here as required -->
</bean> <bean id="commandManager" class="fiona.apple.CommandManager">
<lookup-method name="createCommand" bean="command"/>
</bean>
CommandManager中的createCommand方法根据不同要求需要不同的实现，通过配置文件的<lookup-method>可以指定不同bean定义的方法实现；如果一个bean是stateful的则需要将scope设置为prototype，在每次调用的时候都生成一个新的instance。
<lookup-method/>标签用于解决当一个singleton的Bean A需要引用另外一个非singleton的Bean B(也就是每一次引用Bean B都需要引用最新创建的实例)；实现方式是动态创建一个CommandManager的子类，并复写指定的方法；
AOP综合使用JDK Dynamic Proxy和CGLIB对目标类进行代理，两者区别如下：
#1 JDK Dynamic Proxy方式使用Java Reflection技术，因此要求目标类有一个Interface，并且目标方法需要此Interface中申明，动态创建一个实现了Interface的类并在改类中调用目标类的方法；
public class PerformanceMonitorProxy implements InvocationHandler {
private Object target;
public ServiceWithPerformanceMonitorProxy(Object target) {
this.target = target;
}
public static Object newProxyInstance(Object target) {
Class clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(),
new ServiceWithPerformanceMonitorProxy(target));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//do something before target function invocation
PerformanceMonitor.begin(method.getName());
Object result = method.invoke(target, args);
//do something after target function invocation
PerformanceMonitor.end(method.getName());
return result;
}
}
#2 CGLIB使用字节码技术，动态生成一个目标类的子类，通过over-write去覆盖目标方法；
public class CGlibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz) {
enhancer.setSuperclass(clazz);
enhancer.setCallback(this); // 代理执行时会回调此this持有的intercept方法，以实现代码织入
return enhancer.create();
}
@Override
public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
PerformanceMonitor.begin(method.getName());
Object result = methodProxy.invokeSuper(target, args);
// 下面这样是无法执行原有方法的，因为这里的target并不是原有类的实例，而是代理类的实例
// target :
// com.dianping.aop.AdminServiceImpl$$EnhancerByCGLIB$$225da297@16dd5a9d
// Object result = method.invoke(target, args);
PerformanceMonitor.end(method.getName());
return result;
}
}
Spring一般首选JDK Dynamic Proxy进行代理，如果遇到没有实现Interface的情况则使用CGLIB，当然可以通过下属设置强制使用CGLIB；
<aop:config proxy-target-class="true">
<!-- other beans defined here... -->
</aop:config>
Bean作用范围 （<bean ………. Scope=”…….” />）
Singleton：缺省值，一个Spring IoC容器中至多仅生成一个instance，被依赖者共享，stateless
Prototype：每次调用都会生成一个新的instance，不同依赖者使用不同的实例，stateful
Request：WebApplicationContext中一次HTTP请求中至多仅生成一个instance
Session：WebApplicationContext中一个HTTP Session中至多仅生成一个instance
Global Session：WebApplicationContext中一个Global HTTP Session中至多仅生成一个instance
Application：WebApplicationContext中一个ServletContext中至多仅生成一个instance
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">
<aop:scoped-proxy/>
</bean> <!-- a singleton-scoped bean injected with a proxy to the above bean -->
<bean id="userService" class="com.foo.SimpleUserService">
<property name="userPreferences" ref="userPreferences"/>
</bean>
<aop:scoped-proxy/>用于解决将一个shorter-lived scoped bean注入到一个longer-lived scoped bean时shorter-lived scoped bean提前失效的场景；由于singleton类仅有一次注入bean的机会，因此解决思路是在一开始就在longer-lived scoped bean（singleton）中注入一个proxy class作为代理类，如果shorter-lived scoped bean（session）已经失效，代理类会使用当前session scope的shorter-lived bean。
定制Bean的初始化和销毁动作
方法一：使用标注@PostConstruct和@PreDestroy；在bean的java类文件中添加。
这两个标注由CommonAnnotationBeanPostProcessor进行处理。
@PostConstruct
public void init(){
System.out.println("init method”);
}
@PreDestroy
public void dostory(){
System.out.println("destory method");
}
方法二：使用xml配置属性init-method和destroy-method，或者在<beans/>中添加批量设置的属性default-init-method或者default-destroy-method；
<bean id="initAndDestroySeqBean"
class="com.chj.spring.InitAndDestroySeqBean"
init-method="initMethod"
destroy-method="destroyMethod"/>
方法三：使用接口InitializingBean和DisposableBean （不推荐）
public class PersonService implements InitializingBean,DisposableBean{
@Override
public void destroy() throws Exception {
// TODO Auto-generated method stub
System.out.println("init method");
}
@Override
public void afterPropertiesSet() throws Exception {
// TODO Auto-generated method stub
System.out.println("init method");
}
}
执行顺序为@PostConstruct -> InitializingBean -> init-method
如果POJO需要获取容器的某些消息，可以实现下述接口；但是一旦实现这些接口之后就与Spring框架强耦合；
public interface ApplicationContextAware {
void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}
public interface BeanNameAware {
void setBeanName(string name) throws BeansException;
}
Bean继承
当需要创建同一个class或者同一个parent class的多个不同状态的instance时，使用parent属性可以有效减少配置文件中需要填写的属性值；
<bean id="inheritedTestBean" abstract="true"
class="org.springframework.beans.TestBean">
<property name="name" value="parent"/>
<property name="age" value="1"/>
</bean> <bean id="inheritsWithDifferentClass"
class="org.springframework.beans.DerivedTestBean"
parent="inheritedTestBean" init-method="initialize">
<property name="name" value="override"/>
<!-- the age property value of 1 will be inherited from parent -->
</bean>
#1 inheritsTestBean中的abstract=true表示当前bean不能实例化；如果一个singleton bean不打算进行实例化，则需要加上abstract=true属性。
#2 inheritsWithDifferentClass中的class属性不需要extends自parent class，但必须与parent class bean定义的属性匹配；并且可省略，表示使用parent指定bean的class属性；
Spring容器扩展点接口
BeanPostProcessor可以进行customized的实例化、初始化、依赖装配、依赖验证等流程（处理annotation标签，比如@Autowired，@Resource等）。
BeanFactoryPostProcessor可以修改xml文件的bean metadata；Ordered接口控制先后执行顺序。
自动装配（Autowiring）
XML Injection在Annotation Injection之后执行，所以前者会覆盖后者的相同设置，比如如果<property/>或者<constructor-arg/>也针对同一属性进行装配，则@Autowire装配的内容被覆盖；自动装配不能指定简单类型，如String；并且容易造成匹配歧义从而抛出异常；
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
‘<context:annotation-config>’表示使用annotation对属性进行自动装配，同时还注册了一系列post processors（比如AutowiredAnnotationBeanPostProcessor）；加入上述tag之后就可以在java class中使用如下annotation了。
@Required：应用于属性的setter方法，表示相关的property必须设置值，否则抛出异常，但不检查是否为空。
@Autowired：应用于属性或者属性的setter方法， 表示相关的property必须有且仅有一个匹配项；如果应用于Spring自定义的Interface（如ApplicationContext）则容器会自动赋值匹配，无需额外进行设置；@Autowired是基于类型匹配的，所以如果一个bean是collection或者map则不能用@Autowired而需要使用@Resource。