深入理解Spring IoC容器和动态代理机制

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。