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了。

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