Spring--IOC

经典讲述IOC的博客：http://blog.csdn.net/qq_22654611/article/details/52606960
1 控制反转(Inversion of Control)简称IOC，IOC的思想是：Spring容器来实现这些相互依赖对象的创建、协调工作。对象只需要关系业务逻辑本身就可以了。由spring来负责控制对象的生命周期和对象间的关系。从这方面来说，对象如何得到他的协作对象的责任被反转了（IOC、DI）。IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。org.springframework.beans及org.springframework.context包 是Spring IoC容器的基础，ApplicationContext 是BeanFactory的扩展，功能得到了进一步增强，比如更易 与Spring AOP集成、资源处理(国际化处理)、事件传递及各种不同应用层的context实现 BeanFactory 是Spring IoC容器的实际代表者，IoC容器负责容纳此前所描述的bean，并对bean进行管理。BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。Spring为我们提供了许多易用的BeanFactory实现， XmlBeanFactory就是最常用的一个。
2 XML的配置元数据的基本结构：

<bean name="hello" class="cn.sxt.bean.Hello">        <property name="name" value="张三"></property>    </bean>

Spring IoC容器的实例化：

public class Hello {    private String name;    public void setName(String name) {        this.name = name;    }    public void show(){        System.out.println("hello,"+name);    }}//解析beans.xml文件 生成管理相应的bean对象        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");         Hello hello=(Hello)context.getBean("hello");        hello.show();

3.2 实例化bean
3.2.1 构造器实例化Bean：

beans.xml：<bean id="u" class="cn.sxt.vo.User"/>ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");        User user=(User)ac.getBean("u");        System.out.println(user);

需要注意的是一定要存在一个默认的构造器。

3.2.2 使用静态工厂方法实例化

<!-- factory-method指定创建对象的静态方法 -->    <bean id="u" class="cn.sxt.vo.User" factory-method="newinstance"/>测试：ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");        User user=(User)ac.getBean("u");        System.out.println(user);

3.2.3 使用实例化方法实例

<bean id="userFactory" class="cn.sxt.factory.UserDynamicFactory"/>    <!-- factory-bean设置创建对象的工厂 factory-method指定创建对象的方法-->    <bean id="user" factory-bean="userFactory" factory-method="newinstance"/>

3.2.4 使用容器:

Resource res=new FileSystemResource("src/beans.xml");BeanFactory bean=new XmlBeanFactory(res);User user=(User)bean.getBean("user");System.out.println(user.getName());<bean id="u" class="cn.sxt.vo.User" factory-method="newinstance"/>

4 注入依赖
依赖注入（DI）背后的基本原理是对象之间的依赖关系（即一起工作的其它对象）只会通过以下几种方式来实现：构造器的参数、工厂方法的参数，或给由构造函数或者工厂方法创建的对象设置属性。因此，容器的工作就是创建bean时注入那些依赖关系。
4.1 构造器注入
基于构造器的DI通过调用带参数的构造器来实现，每个参数代表着一个依赖。
4.1.1 构造器参数解析
构造器参数解析根据参数类型进行匹配，如果bean的构造器参数类型定义非常明确，那么在bean被实例化的时候，bean定义中构造器参数的定义顺序就是这些参数的顺序，依次进行匹配。

public class Foo {    public Foo(Bar bar, Baz baz) {        // ...    }}<bean name="foo" class="x.y.Foo">        <constructor-arg>            <bean class="x.y.Bar"/>        </constructor-arg>        <constructor-arg>            <bean class="x.y.Baz"/>        </constructor-arg>    </bean>

4.1.2 构造器参数类型匹配

<bean id="user" class="cn.sxt.vo.User">        <!-- 通过参数类型进行匹配 -->        <constructor-arg type="java.lang.String" value="tang"/>    </bean>

4.1.3 构造参数索引

<bean id="user" class="cn.sxt.vo.User">        <!-- 根据参数的位置设置为索引来对指定位置的数进行注入 从0开始-->        <constructor-arg index="0" value="tang"/>    </bean>

4.2 Setter注入
4.2.1 通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即可实现基于setter的DI。

<bean id="mysqlDao" class="cn.sxt.dao.impl.UserDaoMySqlImpl"/>    <bean id="oralceDao" class="cn.sxt.dao.impl.UserDaoOracleImpl"/>    <bean id="service" class="cn.sxt.service.impl.UserServiceImpl">        <!--        ref引用对象，通过Id引用对象注入 -->        <!-- 随着此处位置的引用的不同ID，而UserDaoMySqlImpl和UserDaoO        racleImpl均实现UserDao接口，将注入不同的对象 -->        <property name="userDao" ref="oralceDao"></property>    </bean>public class UserDaoMySqlImpl implements UserDao{    @Override    public void getUser() {        System.out.println("mysql获取用户数据");      }}public class UserDaoOracleImpl implements UserDao{    @Override    public void getUser() {        // TODO Auto-generated method stub        System.out.println("orac获取用户数据");    }}public interface UserService {    public void getUser();}public class UserServiceImpl implements UserService{    private UserDao userDao=null;    public void setUserDao(UserDao userDao) {        this.userDao = userDao;    }    @Override    public void getUser() {        userDao.getUser();    }}

4.2.2 注入到构造器

<bean id="service" class="cn.sxt.service.impl.UserServiceImpl">        <constructor-arg>            <ref bean="oralceDao"/>        </constructor-arg>    </bean>

4.2.3 采用static工厂方法返回对象实例：

<!-- 在BeanFactoryCustom中定义一个bean静态方法， -->    <bean id="service" class="cn.sxt.service.impl.BeanFactoryCustom" factory-method="createInstance">        <!-- 注入到bean静态方法中 -->        <constructor-arg ref="oralceDao"/>    </bean>public class UserServiceImpl implements UserService{    private UserDao userDao=null;    public UserServiceImpl(UserDao userDao) {        this.userDao = userDao;    }    public void setUserDao(UserDao userDao) {        this.userDao = userDao;    }    @Override    public void getUser() {        userDao.getUser();    }}public static UserServiceImpl createInstance(UserDao userDao){        //根据参数创建对象        return new UserServiceImpl(userDao);    }

5 集合：
需要注意的是，数据注入时，Spring的底层会强制发生强制转换。没有value值时，将设置为“ ”值，即空字符串。

<bean id="addr" class="cn.sxt.vo.Address">        <property name="address" value="北京西三旗"></property>    </bean>    <bean id="student" class="cn.sxt.vo.Student"><!--        注入属性 -->        <property name="name" value="张三丰"></property><!--        注入对象 -->        <property name="addr" ref="addr"/><!--        注入数组 -->        <property name="books">            <array>                <value>傲慢与偏见</value>                <value>仲夏之梦</value>                <value>雾都孤儿</value>            </array>        </property>        <!-- 注入List集合 -->        <property name="hobbies">            <list>                <value>羽毛球</value>                <value>乒乓球</value>                <value>玻璃球</value>            </list>        </property>        <!-- 注入Map集合 -->        <property name="cards">            <map>                <entry key="中国银行" value="1212121"></entry>                <entry key="建设银行" value="1223232"></entry>                <entry key="交通银行" value="1323232"></entry>            </map>        </property>        <!-- 注入Set集合 -->        <property name="games">            <set>                <value>lol</value>                <value>dota</value>                <value>cs</value>                <value>dnf</value>            </set>        </property>        <!-- 注入字符 -->        <property name="wife">            <null/>        </property>        <!-- 注入配置信息 -->        <property name="info">            <props>                <prop key="学号">20150512601</prop>                <prop key="sex">男</prop>                <prop key="name">小乔</prop>            </props>        </property>    </bean>

还可以使用p名称空间配置属性如下：

    <bean name="john-classic" class="com.example.Person">        <property name="name" value="John Doe"/>        <property name="spouse" ref="jane"/>    </bean>    <bean name="john-modern"         class="com.example.Person"        p:name="John Doe"        p:spouse-ref="jane"/>    <bean name="jane" class="com.example.Person">        <property name="name" value="Jane Doe"/>    </bean></beans>

需要说明的是集合支持合并，子集合将会覆盖父集合中的数据。List集合由于是有序存在的。父集合中的数据将在子集合元素之前。不同集合类型之间是不能合并的。
如：

<beans><bean id="parent" abstract="true" class="example.ComplexObject">    <property name="adminEmails">        <props>            <prop key="administrator">[e-mail]</prop>            <prop key="support">[e-mail]</prop>        </props>    </property></bean><bean id="child" parent="parent">    <property name="adminEmails">        <!-- the merge is specified on the *child* collection definition -->        <props merge="true">            <prop key="sales">[e-mail]</prop>            <prop key="support">[e-mail]</prop>        </props>    </property></bean><beans>

6 depends-on属性
depends-on属性可以用于当前bean初始化之前显式地强制一个或多个bean被初始化。防止出现依赖的对象没有生成。

7 方法注入：
7.1 在大部分情况下，容器中的bean都是singleton类型的。如果一个singleton bean要引用另外一个singleton bean，或者一个非singleton bean要引用另外一个非singleton bean时，通常情况下将一个bean定义为另一个bean的property值就可以了。对于不同周期的Bean，当一个singleton类型的Bean A中的方法需要使用另一个全新的非singleton类型的Bean B时，那么只能通过实现BeanFactoryAware接口，在需要的地方使用getBean(” “)请求一个Bean实例。
如下：

public class CommandManager implements BeanFactoryAware {    private BeanFactory beanFactory;    public Object process() {        System.out.println("process");        //获取一个实例        Command command = createCommand();        //执行Command中的方法        return command.execute();    }    /**     * 获取一个command实例     * @return Command对象     */    protected Command createCommand() {        return (Command) this.beanFactory.getBean("command");    }    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {        System.out.println("setBeanFactory");        this.beanFactory = beanFactory;    }}

其中setBeanFactory方法，在Bean的属性初始化后调用。
执行结果：

参考：http://blog.csdn.net/heyutao007/article/details/5981555
7.2 通过lookup方式：
定义一个抽象类，包含一个抽象方法，访问级别必须是public或protected，保证能被子类重载，可以是抽象方法，必须有返回值，必须是无参数方法，用于创建需要注入的方法的Bean。

public abstract class HelloImpl5 implements HelloApi {      private Printer printer;      //放回一个全新的对象。    public abstract Printer createPrototypePrinter();  }  <bean id="prototypePrinter"  class="cn.javass.spring.chapter3.bean.Printer" scope="prototype"/>  <bean id="singletonPrinter"  class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>  <bean id="helloApi1" class="cn.javass.spring.chapter3.HelloImpl5" scope="singleton">  <property name="printer" ref="prototypePrinter"/>  //生成一个bean对应的对象作为createPrototypePrinter的返回值。<lookup-method name="createPrototypePrinter" bean="prototypePrinter"/>  </bean>       

7.3 方法替换
1 定义一个类实现MethodReplacer接口，实现reimplement方法，参数obj为被替换方法的对象，method为被替换方法，args为方法参数；
2 配置
，使用< replaced-method >标签来指定要进行替换方法，属性name指定替换的方法名字，replacer指定该方法的重新实现者，子标签< arg-type >用来指定原来方法参数的类型，必须指定否则找不到原方法，如下将print替换：

<bean id="replacer" class="cn.javass.spring.chapter3.bean.PrinterReplacer"/>  <bean id="printer" class="cn.javass.spring.chapter3.bean.Printer">  <replaced-method name="print" replacer="replacer">          <arg-type>java.lang.String</arg-type>      </replaced-method>  </bean>  

参考博客：http://jinnianshilongnian.iteye.com/blog/1415461，感谢大神的分享。

8 Bean的作用域
创建一个bean定义，其实质是用该bean定义对应的类来创建真正实例的“配方(recipe)”。把bean定义看成一个配方很有意义，它与class很类似，只根据一张“处方”就可以创建多个实例。你不仅可以控制注入到对象中的各种依赖和配置值。

可自定义bean的作用域，步骤如下：
8.1 继承org.springframework.beans.factory.config.Scope接口，接口中的方法说明：
第一个方法可以从作用域中获取对象。
Object get(String name, ObjectFactory objectFactory)

第二个方法可以从作用域中移除对象。例如，session作用域的实现可以从session中移除并返回session-scoped bean(如果没有找到相应名称的对象昂，则可以返回null)。
Object remove(String name)

第三个方法是注册作用域析构的回调方法，当作用域销毁或作用域中的某个对象销毁时候会执行。。
void registerDestructionCallback(String name, Runnable destructionCallback)

最后一个方法处理作用域的会话标识。对每一个作用域来说标识是不一样的。例如，对于session，将获得session标识。
String getConversationId()
8.2 使用自定义作用域
让Spring容器装配你的作用域，把一个新的Scope 注册到Spring 容器中的核心方法定义在ConfigurableBeanFactory接口中
void registerScope(String scopeName, Scope scope);
registerScope(..) 方法的第一个参数是一个作用域的唯一名称，例如，Spring 容器中的’singleton’和’prototype’。registerScope(..) 方法的第二个参数是你要注册和使用的自定义Scope的实例。
例如：

Scope customScope = new ThreadScope();beanFactory.registerScope("thread", scope);

使用作用域：

    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">        <property name="scopes">            <map>                <entry key="thread">                    <bean class="com.foo.ThreadScope"/>                </entry>            </map>        </property>    </bean>    <bean id="bar" class="x.y.Bar" scope="thread">        <property name="name" value="Rick"/>        <aop:scoped-proxy/>    </bean>    <bean id="foo" class="x.y.Foo">        <property name="bar" ref="bar"/>    </bean>

部分摘自官方文档。

未完待续。。。