Spring4笔记5--基于注解的DI（依赖注入）

基于注解的DI（依赖注入）：

　　对于 DI 使用注解，将不再需要在 Spring 配置文件中声明 Bean 实例。只需要在 Spring 配置文件中配置组件扫描器，用于在指定的基本包中扫描注解。

<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">    
    <!-- 只扫描子包，不扫描当前包 -->
    <!--  <context:component-scan base-package="com.tongji.*"/>  -->
    <!-- 先扫描子包，再扫描当前包 -->
    <!--  <context:component-scan base-package="com.tongji"/>  -->
    
    <context:component-scan base-package="com.tongji.di01"/>
</beans>

　　　　注意：添加的约束http://www.springframework.org/schema/context/spring-context.xsd

　　注解基本注入：

package com.tongji.di01;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//与本注解具有相同功能的注解还有三个：
//@Repository:注解在Dao接口的实现类上，表示当前Dao类为组件
//@Service:注解在Service接口的实现类上，表示当前Service类为组件
//@Controller:注解在Controller接口的实现类上，表示当前Controller类为组件（SpringMVC）
@Component("student")  //表明当前类为组件，容器创建的这个组件对象名称为myStudent,相当于<bean/>的id属性
@Scope("prototype") //设置Bean的作用范围，默认是singleton
public class Student {
    @Value("张三")  //为name属性赋值
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        System.out.println("执行setName");
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    @Value("23")  //可以将该注解放到set上
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
}

　　　　解释：注解注入时，POJO类可以没有setXXX()方法，但还是写上去比较好。

　　

　　注解域属性的自动注入：

　　　　（1） 用Spring自带的注解实现：　　

@Component("myStudent") 
@Scope("prototype") 
public class Student {
    @Value("张三") 
    private String name;
    @Value("23")  
    private int age;
    @Autowired  //byType方式自动注入
    private School school;

@Component("myStudent") 
@Scope("prototype") 
public class Student {
    @Value("张三") 
    private String name;
    @Value("23")  
    private int age;
    @Autowired
    @Qualifier("mySchool")  //byName方式自动注入
    private School school;

　　　　补充：@Autowired 还有一个属性 required，默认值为 true，表示当匹配失败后，会终止程序运行。若将其值设置为 false，则匹配失败，将被忽略，未匹配的属性值为 null。

　　　　（2）使用JDK提供的注解实现：

@Component("myStudent") 
@Scope("prototype") 
public class Student {
    @Value("张三") 
    private String name;
    @Value("23")  
    private int age;
    @Resource  //byType方式自动注入
    private School school;

@Component("myStudent") 
@Scope("prototype") 
public class Student {
    @Value("张三") 
    private String name;
    @Value("23")  
    private int age;
    @Resource(name="mySchool")  //byName方式自动注入
    private School school;

　　注解Bean的定制声明始末：

    @PostConstruct
    public void postInit() {
        System.out.println("初始化完毕之后");
    }
    
    @PreDestroy
    public void preDestory() {
        System.out.println("销毁之前");
    }

　　　　在方法上使用@PostConstruct，与原来的 init-method 等效。在方法上使用@PreDestroy，与 destroy-method 等效。  

　　使用JavaConfig进行配置：

　　　　JavaConfig，是在 Spring 3.0 开始从一个独立的项目并入到 Spring 中的。JavaConfig 可以看成一个用于完成 Bean 装配的配置文件，只不过是程序员使用 Java 自己编写的。  

package com.tongji.di07;

import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //表明当前POJO类将会被当作配置文件来使用，即Spring容器
public class MyJavaConfig {
    
    @Bean(name="mySchool")     //表明当前方法的返回值为一个Bean对象
    public School mySchoolCreater() {
        return new School("清华大学");
    }
    
    @Bean(name="school")     //byName方式需要定义的该Bean的name值与被注入的属性名相同
    public School mySchoolCreater2() {
        return new School("北京大学");
    }
    
    //@Bean(name="myStudent", autowire=Autowire.BY_TYPE)     //byType方式自动注入
    @Bean(name="myStudent", autowire=Autowire.BY_NAME)       //byName方式自动注入
    public Student myStudentCreater() {
        return new Student("赵六",26);
    }
}

　　　　解释：此时School类和Student类就不需要注解了。

　　使用 junit4 测试 Spring：

　　　　对 Spring 程序的运行，首先需要创建容器对象，而后还要从容器中获取对象，再对其进行执行。但，JUnit4 对 Spring 程序有专门的测试方法。

package com.tongji.di08;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//使用Spring的测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:com/tongji/di08/applicationContext.xml")
public class MyTest2 extends AbstractJUnit4SpringContextTests {
    
    @Autowired              //byType
    @Qualifier("myStudent")  //byName
    private Student student;
    @Test
    public void test01() {
        System.out.println(student);
    }
    
}

　　　　注意：Student对象的注入方式可以是基于XML的，也可以是基于注解的。

　　注解与XML共同使用：

　　　　注解的好处是，配置方便，直观。但其弊端也显而易见：以硬编码的方式写入到了 Java代码中，其修改是需要重新编译代码的。  
　　　　XML 配置方式的最大好处是，对其所做修改，无需编译代码，只需重启服务器即可将新的配置加载。  
　　　　若注解与 XML 同用，XML 的优先级要高于注解。这样做的好处是，需要对某个 Bean做修改，只需修改配置文件即可。当然，此时，Bean 类要有 setXXX() 或构造器。