Spring IoC 详解(上篇)

介绍：
Spring 主要思想IoC(控制反转) 是Core的核心部分,AOP(面向切面编程),其中IoC由DI(依赖注入)的思想实现,AOP是OOP(面向对象)的一种延伸,Spring可以降低程序组建之间的耦合度。

Spring 提供了Spring MVC(spring web mvc) 的实现，可以快速开发MVC结构的Web程序

Spring核心jar包：
IoC:
commons-logging.jar
spring-beans-*.RELEASE.jar
spring-context-*.RELEASE.jar
spring-core-*.RELEASE.jar
spring-expression-*.RELEASE.jar
AOP：
aopalliance.jar
aspectjweaver.jar
spring-aop-*.RELEASE.jar
spring-aspects-*.RELEASE.jar
MVC：
jstl.jar
spring-web-*.RELEASE.jar
spring-webmvc-*.RELEASE.jar
standard.jar

spring的容器类型分为：ApplicationContext(主流)和BeanFactory(一般不用)

实例化ApplicationContext容器：

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

applicationContext.XML配置：

<?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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd">
    <!-- Bean 初始化部分 -->
    <!-- 声明组件new构造器实例化bean -->
    <bean id="exampleNew" class="action.ExampleAction"></bean>
    <!-- 通过实例工厂方法实例化bean,必须指定factory-method,指定由哪个方法创建,
         创建后得到的是该方法的结果,调用的方法必须有返回值！ -->
    <bean id="exampleFactory" factory-bean="exampleNew" factory-method="execute"></bean>
    <!-- 声明组件静态方法实例化bean，factory-method可以为静态方法 -->
    <bean id="calendar" class="java.util.Calendar" factory-method="getInstance"></bean>
    <!-- 指定默认init方法和destory方法 -->
    <!-- 延迟实例化lazy-init="true" 推迟到getBean方法调用时初始化，通常用于使用频率较低的方法 -->
    <bean id="e1" class="action.ExampleAction" lazy-init="true" scope="singleton" init-method="init" destroy-method="destory"></bean>

</beans>

获取bean
Calendar c = ac.getBean(“calendar”,Calendar.class);
新版本语法参数1为bean的id，参数2为bean的类的类型
控制对象使用范围：
scope=”[singleton(单例)|prototype(原型)]”
singleton:默认方式，bean容器中只有一个对象,以单例模式获取对象，每次拿到的都是同一个对象。
注意：如果使用默认的模式，有可能出现线程同步问题
prototype：原型模式，每次拿到的都是新的对象
模拟获取bean对象：

@org.junit.Test
    public void test() {
        //创建ApplicationContext容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println(ac);
        Calendar c = ac.getBean("calendar",Calendar.class);
        System.out.println(c.getTime());
    }

<!-- 指定默认init方法和destory方法 -->
<!-- 延迟实例化lazy-init="true" 推迟到getBean方法调用时初始化，通常用于使用频率较低的方法 -->
<bean id="e1" class="action.ExampleAction" lazy-init="true" scope="singleton" init-method="init" destroy-method="destory"></bean>

init-method=”init”:在创建对象后，执行对应名字方法
destroy-method=”destory”:容器销毁后，执行对应名字方法,销毁方法仅对单例模式有效

模拟init,destory：

@org.junit.Test
    public void test1() {
        //AbstractApplicationContext容器，可以模拟销毁的过程
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        ExampleAction e1 = ac.getBean("e1",ExampleAction.class);
        e1.execute();
        ac.close();
    }

用于演示的 JAVA 类,ExampleAction.java

    public class ExampleAction {

        public ExampleAction() {
            System.out.println("正在实例化......");
        }

        /**
         * 模拟初始化方法
         */
        public void init() {
            System.out.println("init正在初始化......");
        }
        /**
         * 模拟执行的方法
         */
        public String execute() {
            System.out.println(this.getClass().getName()+"正在执行.....");
            return "success";
        }

        /**
         * 模拟销毁时的方法
         */

        public void destory() {
            System.out.println("destory正在销毁......");
        }
    }

IoC: 控制反转/反向控制
本质：改变了对象获取方式，由原有自己创建应用，转为接收外界(第三方，比如spring)注入的对象使用。
Spring的IoC主要采用DI(依赖注入)技术实现关系注入
Spring的DI又分为set注入，构造器注入

set注入可以注入：属性，bean，对象
模拟set注入,applicationContext.XML配置：

<!-- 声明Computer -->
<bean id="computer" class="model.Computer">
    <!-- 注入属性 -->
    <property name="mainbord" value="华硕"></property>
    <property name="hdd" value="西数"></property>
    <property name="ram" value="金泰克"></property>
</bean>

测试代码：

    @org.junit.Test
    public void test3() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Computer c = ac.getBean("computer",Computer.class);
        c.show();
    }

bean的对应JAVA类，Computer.java

/**
 * 模拟使用set方法注入信息
 * @author haifeng
 *
 */
public class Computer implements Serializable{

    private String mainbord; //主板
    private String hdd; //硬盘
    private String ram; //内存



    public void setMainbord(String mainbord) {
        this.mainbord = mainbord;
    }



    public void setHdd(String hdd) {
        this.hdd = hdd;
    }



    public void setRam(String ram) {
        this.ram = ram;
    }


    /**
     * 显示电脑配置
     */
    public void show(){
        System.out.println("主板"+mainbord);
        System.out.println("硬盘"+hdd);
        System.out.println("内存"+ram);
    }
}