Deployment期间验证
实现一：
1 <bean id="theTargetBean" class="..."/> 2 3 <bean id="theClientBean" class="..."> 4 <property name="targetName"> 5 <idref bean="theTargetBean" /> 6 </property> 7 </bean>
实现二：
1 <bean id="theTargetBean" class="..." /> 2 3 <bean id="client" class="..."> 4 <property name="targetName" value="theTargetBean" /> 5 </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代码
1 public abstract class CommandManager {
2 protected abstract Command createCommand();
3 }
Xml代码
1 <bean id="command" class="fiona.apple.AsyncCommand" scope="prototype"> 2 <!-- inject dependencies here as required --> 3 </bean> 4 5 <bean id="commandManager" class="fiona.apple.CommandManager"> 6 <lookup-method name="createCommand" bean="command"/> 7 </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的类并在改类中调用目标类的方法；
1 public class PerformanceMonitorProxy implements InvocationHandler {
2
3 private Object target;
4
5 public ServiceWithPerformanceMonitorProxy(Object target) {
6 this.target = target;
7 }
8
9 public static Object newProxyInstance(Object target) {
10 Class clazz = target.getClass();
11 return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(),
12 new ServiceWithPerformanceMonitorProxy(target));
13 }
14
15 @Override
16 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
17 //do something before target function invocation
18 PerformanceMonitor.begin(method.getName());
19 Object result = method.invoke(target, args);
20 //do something after target function invocation
21 PerformanceMonitor.end(method.getName());
22 return result;
23 }
24 }
#2 CGLIB使用字节码技术，动态生成一个目标类的子类，通过over-write去覆盖目标方法；
1 public class CGlibProxy implements MethodInterceptor {
2 private Enhancer enhancer = new Enhancer();
3 public Object getProxy(Class clazz) {
4 enhancer.setSuperclass(clazz);
5 enhancer.setCallback(this); // 代理执行时会回调此this持有的intercept方法，以实现代码织入
6 return enhancer.create();
7 }
8
9 @Override
10 public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
11 PerformanceMonitor.begin(method.getName());
12 Object result = methodProxy.invokeSuper(target, args);
13 // 下面这样是无法执行原有方法的，因为这里的target并不是原有类的实例，而是代理类的实例
14 // target :
15 // [email protected]d5a9d
16 // Object result = method.invoke(target, args);
17 PerformanceMonitor.end(method.getName());
18 return result;
19 }
20 }
Spring一般首选JDK Dynamic Proxy进行代理，如果遇到没有实现Interface的情况则使用CGLIB，当然可以通过下属设置强制使用CGLIB；
1 <aop:config proxy-target-class="true"> 2 <!-- other beans defined here... --> 3 </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
1 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"> 2 <aop:scoped-proxy/> 3 </bean> 4 5 <!-- a singleton-scoped bean injected with a proxy to the above bean --> 6 <bean id="userService" class="com.foo.SimpleUserService"> 7 <property name="userPreferences" ref="userPreferences"/> 8 </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进行处理。
1 @PostConstruct
2 public void init(){
3 System.out.println("init method”);
4 }
5 @PreDestroy
6 public void dostory(){
7 System.out.println("destory method");
8 }
方法二：使用xml配置属性init-method和destroy-method，或者在<beans/>中添加批量设置的属性default-init-method或者default-destroy-method；
1 <bean id="initAndDestroySeqBean" 2 class="com.chj.spring.InitAndDestroySeqBean" 3 init-method="initMethod" 4 destroy-method="destroyMethod"/>
方法三：使用接口InitializingBean和DisposableBean （不推荐）
1 public class PersonService implements InitializingBean,DisposableBean{
2 @Override
3 public void destroy() throws Exception {
4 // TODO Auto-generated method stub
5 System.out.println("init method");
6 }
7 @Override
8 public void afterPropertiesSet() throws Exception {
9 // TODO Auto-generated method stub
10 System.out.println("init method");
11 }
12 }
执行顺序为@PostConstruct -> InitializingBean -> init-method
如果POJO需要获取容器的某些消息，可以实现下述接口；但是一旦实现这些接口之后就与Spring框架强耦合；
1 public interface ApplicationContextAware {
2 void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
3 }
4 public interface BeanNameAware {
5 void setBeanName(string name) throws BeansException;
6 }
Bean继承
当需要创建同一个class或者同一个parent class的多个不同状态的instance时，使用parent属性可以有效减少配置文件中需要填写的属性值；
1 <bean id="inheritedTestBean" abstract="true" 2 class="org.springframework.beans.TestBean"> 3 <property name="name" value="parent"/> 4 <property name="age" value="1"/> 5 </bean> 6 7 <bean id="inheritsWithDifferentClass" 8 class="org.springframework.beans.DerivedTestBean" 9 parent="inheritedTestBean" init-method="initialize"> 10 <property name="name" value="override"/> 11 <!-- the age property value of 1 will be inherited from parent --> 12 </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；并且容易造成匹配歧义从而抛出异常；
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 6 http://www.springframework.org/schema/beans/spring-beans.xsd 7 http://www.springframework.org/schema/context 8 http://www.springframework.org/schema/context/spring-context.xsd"> 9 10 <context:annotation-config/> 11 12 </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。
原文地址：https://www.cnblogs.com/leo-chen-2014/p/8111771.html