依赖注入(Inverse of Control)
Spring 实现IoC(Inverse of Control)，就是通过 Spring容器 来创建，管理所有的Java对象(Java Bean)。
并且Spring容器使用配置文件来组织各个Java Bean之间的依赖关系，而不是以硬编码的方式让它们耦合在一起！
没有各种new真爽，配置文件管理各个Bean 之间的协作关系真的炒鸡解耦，谁用谁知道。
Bean 的作用域 singleton (默认) ,prototype ，request，session，global session 后面三个只在web应用中有效
创建Bean的三种形式
构造器，最常见的形式，如果不采用构造注入，Spring底层会调用Bean类的无参数构造器来创建实例，因此要求该Bean类提供无参数的构造器。Spring容器会默认初始化所有属性，基础类型0或false，引用类型null
-
静态工厂 ，要创建的实例的Bean，class属性要是静态工厂类(因为Spring需要的是哪个工厂类来创建Bean实例)，用factory-method指定工厂方法。
``` package com.example.factory; public class ExampleFactory{ //静态工厂方法 public static Example newInstance(String message,int index){ return new Example(message,index); } ---- xml配置文件 <beans> <bean id = "byIndex" class = "com.example.ExampleFactory" factory-method="newInstance"> <constructor-arg index="0" value="Hello World!"/> <constructor-arg index="1" value="1"/> </bean> </beans> ``` -
实例工厂，先配置实例工厂类，配置Bean无需class属性, 用factory-bean指定工厂类id，factory-method指定工厂方法
---- xml配置文件 <beans> <bean id = "exampleFactory" class = "com.example.ExampleFactory"/> <bean id = "byName" factory-bean = "exampleFactory" factory-method="newInstance"> <constructor-arg name="message" value="Hello World!"/> <constructor-arg name="index" value="1"/> </bean> </beans>
循环依赖问题
- 构造器注入的循环依赖问题是无法解决的
- setter循环依赖是可以提前暴露刚完成的构造器来解决(需要是singleton)
怎么检测循环依赖
检测循环依赖相对比较容易，Bean在创建的时候可以给该Bean打标，如果递归调用回来发现正在创建中的话， 即说明了循环依赖了。
Spring容器将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在发现已经在“当前创建Bean池”里,将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。
//DefaultSingletonBeanRegistry
protected void beforeSingletonCreation(String beanName) {
if (!this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
怎么检测循环依赖
提前暴露。
假如A，B循环依赖
- 实例Ａ，将未注入属性的A，暴露给容器(Wrap)
- 给A注入属性，发现要用B
- 实例Ｂ，注入属性，发现要用Ａ，在单例缓存中没有找到Ａ，又去Warp中找到了，注入完成
- 递归回来，A成功注入Ｂ
//初始化Bean之前提前把Factory暴露出去
addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
//通过暴露Factory的方式暴露，是因为有些Bean是需要被代理的
protected Object getEarlyBeanReference(String beanName,
RootBeanDefinition mbd,
Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {
BeanPostProcessor bp = (BeanPostProcessor) it.next();
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp
= (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
// 在Bean 的单例缓存中获取Bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
synchronized (this.singletonObjects) {
// 单例缓存中没有，找提前暴露的
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory singletonFactory = (ObjectFactory) this
.singletonFactories.get(beanName);
// 如果只是提前暴露了工厂(没有实例)，执行工厂方法
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
Spring 的几个缓存池 :
- alreadyCreated：已经创建好的Bean ，检测创建好的Bean是否依赖正在创建的Bean，如果是，说明原创建好多不可用了
- singletonObjects：单例Bean
- singletonFactories : 单例Bean 提前暴露的工厂
- earlySingletonObjects：执行了工厂方法生产出的Bean
- singletonsCurrentlyCreation：创建中的Bean ，用于检测循环依赖
所以循环依赖无法解决的有
构造器注入
代理类改变了Bean的版本(见alreadyCreated，提前暴露的别的Bean 依赖了，之后)
原型Bean (prototype)
参考乌哇哇这里
协调不同步的Bean
简单的说，一个如果一个singleton的Bean 依赖一个prototype 的Bean的时候，会产生不同步的情况(因为singleton只创建一次，当singleton调用 prototype 的时候，一般的注入没办法让 Spring 容器每次都返回一个新的 prototype的Bean)。
两种方法：
- 让singleton 的bean 实现 ApplicationContextAware 接口
public class A implements ApplicationContextAware {
//用于保存ApplicationContext的引用，set方式注入
private ApplicationContext applicationContext;
//模拟业务处理的方法
public Object process(){
B b = createB();
return b.execute();
}
private B createB() {
return (B) this.applicationContext.getBean("b"); //
}
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext=applicationContext;//获得该ApplicationContext引用
}
}
2 . lookup 方法
public abstract class A{
//模拟业务处理的方法
public Object process(){
B b= createB();
return b.execute();
}
protected abstract B createB();
}
<bean id="b" class="com.example.B" scope="prototype"/>
<bean id="a" class="com.example.A">
<lookup-method name="createB" bean="b"/>
</bean>
推荐用第二种方法，这样和Spring的代码没有耦合。
createB() 方法是个抽象方法，我们并没有实现它啊，那它是怎么拿到B类的呢。这里的奥妙就是Srping应用了CGLIB（动态代理）类库。这个方法是不是抽象都无所谓，不影响CGLIB动态代理。
在这个方法的代码签名处有个标准：
<public|protected> [abstract] <return-type> theMethodName(no-arguments);
- public|protected要求方法必须是可以被子类重写和调用的；
- abstract可选，如果是抽象方法，CGLIB的动态代理类就会实现这个方法，如果不是抽象方法，就会覆盖这个方法，所以没什么影响；
- return-type就是non-singleton-bean的类型咯，当然可以是它的父类或者接口。
- no-arguments不允许有参数。
AOP
AOP （Aspect-OrientedProgramming，面向方面编程），是对OOP（Object-Oriented Programing，面向对象编程）的补充。
传统的OOP模式编程，会在每个类调用一些共同的方法（log，安全检查，事务，性能统计，异常处理等）。
这些方法会造成代码的冗余，而且曾加的代码的耦合性(功能逻辑和业务逻辑没有分开)
实现AOP的两种方式：
- XML风格，使用<aop:config>
首先定义一个要被切的类
public interface PersonService {
public String getPersonName(Integer id);
public void save(String name);
}
public class PersonServiceBean implements PersonService {
@Override
public String getPersonName(Integer id) {
// TODO Auto-generated method stub
return null;
}
@Override
public void save(String name) {
// TODO Auto-generated method stub
System.out.println("您输入的是" + name);
}
}
然后，我们来定义切点类和切点
public class MyInterceptor {
public void anyMethod(){}
public void doBefore(String name){
System.out.println("前置通知" + name);
}
public void doAfterReturn(String result){
System.out.println("后置通知" + result);
}
public Object doAfter(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("进入方法");
Object result = pjp.proceed();
System.out.println("最终通知");
return result;
}
public void doAfterThrowing(Exception e){
System.out.println("异常通知" + e);
}
public void doAround(){
System.out.println("环绕通知");
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<aop:config>
<aop:aspect id="asp" ref="myInterceptor">
<!-- 切点-->
<aop:pointcut id="mycut"
expression="execution(* cn.qdlg.service.impl.PersonServiceBean.*(..))"/>
<aop:before pointcut-ref="mycut" method="doBefore"/>
<aop:after pointcut-ref="mycut" method="doAfter"/>
<aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>
<aop:around pointcut-ref="mycut" method="doAround"/>
<aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
</aop:aspect>
</aop:config>
<bean id="myInterceptor" class="cn.qdlg.service.MyInterceptor"></bean>
<bean id="PersonService" class="cn.qdlg.service.impl.PersonServiceBean"></bean>
</beans>
- @Aspect 风格
//启动 aspectj 代理
<aop:aspectj-autoproxy proxy-target-class="true"/>
public class MyInterceptor {
@Pointcut("execution (* cn.qdlg.service.impl.PersonServiceBean.*(..))")
public void anyMethod(){}
@Before("anyMethod()")
public void doBefore(String name){
System.out.println("前置通知" + name);
}
@AfterReturning("anyMethod() && args(name)")
public void doAfterReturn(String result){
System.out.println("后置通知" + result);
}
@After("anyMethod()")
public Object doAfter(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("进入方法");
Object result = pjp.proceed();
System.out.println("最终通知");
return result;
}
@AfterThrowing("anyMethod()")
public void doAfterThrowing(Exception e){
System.out.println("异常通知" + e);
}
@Around("anyMethod()")
public void doAround(){
System.out.println("环绕通知");
}
}
AOP 实现的方式，动态代理----- >http://www.jianshu.com/p/6411406ef7c3
