Spring学习笔记（二）

六、初始化和销毁

之前说过的IoC代表着对象的创建、初始化和销毁都由Spring框架来完成，那么初始化和销毁是怎么回事呢？
想要做到这两件事，需要在类中自己写一个初始化和销毁的方法，然后在配置文件中进行注册。仍然以HelloWorld为例，代码书写如下：

package com.tt.helloworld;import java.io.Serializable;public class HelloWorld implements Serializable {    private Long id;    private String name;    public Long getId() {        return id;    }    public void setId(Long id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public HelloWorld(){        System.out.println("create object by constructor");    }    public void hello(){        System.out.println("hello world");    }    public void init(){        System.out.println("init");    }    public void destroy(){        System.out.println("destroy");    }}

可以看到，这里我用init()方法来完成初始化任务，用destroy()方法来完成销毁任务。接着在配置文件中进行配置：

<bean id="helloWorld" class="com.tt.helloworld.HelloWorld" init-method="init" destroy-method="destroy" ></bean>

这样，我们就可以自定义对象初始化和销毁的过程了。另外，Spring容器默认在容器关闭的时候执行对象的销毁。
还有一个小的知识点是，若scope=”prototype”的话，则Spring容器关闭时也不执行销毁的过程。

七、DI

依赖注入，通俗的解释其实就是实现给类中的属性赋值。
在Spring容器中有两种方式可以实现依赖注入，分别是set方法注入和构造方法注入。
（1）set方法注入
想使用set方法注入的话当然首先要有set方法，因此首先要在类中写好属性的set方法，然后在配置文件中配置。仍然以HelloWorld为例，配置文件书写如下：

<bean id="helloWorld" class="com.tt.helloworld.HelloWorld" init-method="init" destroy-method="destroy" scope="prototype">            <property name="id" value="123"></property>            <property name="name" value="shuai ge"></property></bean>

这样的话，程序员再编写测试类时就可以直接调用该类的属性了，并且它们的值是id=123,name=shuai ge（帅哥是我室友的外号，因为他的名字就是帅，哈哈）。
（2）构造方法注入
首先要重写构造方法，针对之前的HelloWorld构造方法书写如下：

public HelloWorld(Long id,String name){        this.id=id;        this.name=name;    }

配置文件书写如下：

<constructor-arg index="0" value="123"></constructor-arg><constructor-arg index="1" value="shuai ge"></constructor-arg>

要记得构造方法的index都是从0开始计数的。然后测试类的书写同上。

之前一直觉得IoC和DI没什么意义，创建对象这件事程序员自己也可以做，并且也不是很费事，今天才明白，IoC和DI真正的作用是实现完全的面向接口编程，下面就用一个例子来体会一下吧。
例子：想象一个业务场景，我们在书写文档的时候可能会有多种类型的文档：word、excel和PDF，但它们都属于文档，可以定义一个接口叫Document,然后让这三种类型的文档都去实现它，然后在客户端调用document，利用Spring的IoC和DI即可实现完全的面向接口编程。
代码如下：

//Doucemnt接口package com.tt.inter;public interface Document {    public void reader();    public void writer();}

//DocumentManager类，用它来操作文档。package com.tt.inter;public class DocumentManager {    private Document document ;    public DocumentManager(Document document){        this.document = document;    }    public Document getDocument() {        return document;    }    public void setDocument(Document document) {        this.document = document;    }}

//ExcelDocument类package com.tt.inter;public class ExcelDocument implements Document{    public void reader(){        System.out.println("excel reader");    }    public void writer(){        System.out.println("excel writer");    }}

//PDFDocument类package com.tt.inter;public class PDFDocument implements Document{    public void reader(){        System.out.println("PDF reader");    }    public void writer(){        System.out.println("PDF writer");    }}

//WordDocument类package com.tt.inter;public class WordDocument implements Document{    public void reader(){        System.out.println("word reader");    }    public void writer(){        System.out.println("word writer");    }}

配置文件：

 <bean id="documentmanager" class="com.tt.inter.DocumentManager">            <constructor-arg index="0" ref="pdfdocument"></constructor-arg>          </bean>           <bean id="exceldocument" class="com.tt.inter.ExcelDocument"></bean>          <bean id="pdfdocument" class="com.tt.inter.PDFDocument"></bean>          <bean id="worddocument" class="com.tt.inter.WordDocument"></bean>

//测试类package com.tt.test;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import com.tt.inter.Document;import com.tt.inter.DocumentManager;public class TestInter {    @Test    public void TestDocument(){        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        DocumentManager document = (DocumentManager)context.getBean("documentmanager");        document.getDocument().reader();        document.getDocument().writer();    }}

当运行测试类的时候我们就可以看到运行结果了，若<constructor-arg index="0" ref="pdfdocument"></constructor-arg> 中的ref配置为pdfdocument，则执行pdfdocument的方法，若改为其他的document则运行其他的方法，改变文档格式只需要修改配置文件的内容，而测试类从始至终都只是一个接口，完全看不到是如何实现的，因此是完全的面向接口编程。还真的很有意思呢。

八、注解方式实现IoC和DI

用注解实现IoC和DI的话则不需要写太多配置文件的内容，但是效率会有相应的影响。
在这里，有两个注解：@Resourse和@Component，@Resourse用在引用类的属性上，用于属性注入，而@Component用在类上，实现类的控制反转。举个例子来看一下吧：
创建两个类：Student和Course，并且Student中有一个属性是Course类型

//Student类package com.tt.annotation;import javax.annotation.Resource;import org.springframework.stereotype.Component;@Component("ss")public class Student {    private long id;    private String name;    @Resource(name="cc")    private Course course;    public void show(){        this.course.show();    }}

// Course类package com.tt.annotation;import org.springframework.stereotype.Component;@Component("cc")public class Course {    private long id;    private String name;    private String description;    public void show(){        System.out.println("course");    }}

配置文件要加上如下的一句话：

<context:component-scan base-package="com.tt.annotation"></context:component-scan>

另外namespace也要改，改为：

<?xml version="1.0" encoding="UTF-8"?><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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd           http://www.springframework.org/schema/context           http://www.springframework.org/schema/context/spring-context-2.5.xsd">

这么几步改完之后，就可以用注解的形式实现IoC和DI了。

今天就总结到这里，以后接着总结，加油。