Spring-依赖注入

一、安装Spring IDE

在Eclipse Marketplace 查询安装Spring IDE。

二、导入Spring必须的jar包

使用maven管理spring的jar包。

<properties>
    <spring.version>版本号</spring.version>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependencies>  
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
<dependencies>  

三、Spring配置bean

配置bean的形式：基于xml文件的方式；基于注解的方式。

1. 基于xml配置bean

1.1 全类名配置bean

Person.java

package com.cd.spring.bean;

public class Person {

    private String user;
    // 必须有无参构造器
    public Person() {
        System.out.println("Person's constructor...");
    }

    public Person(String user) {
        this.user = user;
    }

    public void setUser(String user) {
        System.out.println("setUser:" + user);
        this.user = user;
    }

    public void hello(){
        System.out.println("Hello: " + user);
    }
}

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:util="http://www.springframework.org/schema/util"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!-- 
    全类名配置一个 bean
    在 IOC 容器中id必须是唯一的。
     -->
    <bean id="helloWorld" class="com.cd.spring.bean.Person">
        <!-- 为属性赋值 -->
        <property name="user" value="zhangsan"></property>
    </bean>
</beans>

Main.java

package com.cd.spring.bean;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {

        // 创建 Spring 的 IOC 容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 从 IOC 容器中获取 bean 的实例
        HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");

        // 根据类型来获取 bean 的实例: 要求在  IOC 容器中只有一个与之类型匹配的 bean, 若有多个则会抛出异常. 
        // 一般情况下, 该方法可用, 因为一般情况下, 在一个 IOC 容器中一个类型对应的 bean 也只有一个. 
        // HelloWorld helloWorld = ctx.getBean(HelloWorld.class);

        // 使用 bean
        helloWorld.hello();
    }
}

ps：
ApplicationContext 在初始化上下文时就实例化所有单例的 bean

1.2 工厂方法配置bean

1.2.1 静态工厂方法

静态工厂类示例：

StaticFactoryMethod.java

package com.cd.spring.factorybean;

import java.util.HashMap;
import java.util.Map;

public class StaticFactoryMethod {
    public static Map<String,Person> map = new HashMap<String,Person>();

    static {
        map.put("first", new Person(1,"jayjay1"));
        map.put("second", new Person(2,"jayjay2"));
    }

    public static Person getPerson(String key){
        return map.get(key);
    }
}

xml配置：

<!-- static factory method -->  
<!-- factory-method: 指向静态工厂方法的名字-->  
<bean id="person" factory-method="getPerson" class="com.cd.spring.factorybean.StaticFactoryMethod">
    <constructor-arg value="first" type="java.lang.String"></constructor-arg>
</bean>

1.2.2 实例工厂方法

工厂类示例：

InstanceFactoryMethod.java

package com.cd.spring.factorybean;

import java.util.HashMap;
import java.util.Map;

// 实例工厂的方法
public class InstanceFactoryMethod {
    public static Map<String, Person> map = null;

    public InstanceFactoryMethod(){
        map = new HashMap<String, Person>();
        map.put("first", new Person(1,"jayjay1"));
        map.put("second", new Person(2,"jayjay2"));
    }

    public Person getPerson(String key){
        return map.get(key);
    }
}

xml配置：

<!-- instance factory method -->
<bean id="InstanceFactoryMethod" class="com.cd.spring.factorybean.InstanceFactoryMethod"></bean>

<!--
factory-bean: 指向实例工厂方法的bean
factory-method: 指向静态工厂方法的名字
-->
<bean id="person1" factory-bean="InstanceFactoryMethod" factory-method="getPerson">
    <constructor-arg value="second"></constructor-arg>
</bean>

1.3 FactoryBean配置bean

需要对FactoryBean接口的3个方法进行适当重写

PersonFactoryBean.java

package com.cd.spring.factorybean;

import org.springframework.beans.factory.FactoryBean;

public class PersonFactoryBean implements FactoryBean<Person>{

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private int id;
    private String name;

    @Override
    public Person getObject() throws Exception {
        return new Person(id,name);
    }

    @Override
    public Class<?> getObjectType() {
        return Person.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

xml配置

<!-- use factory bean to get a instance -->
<bean id="person2" class="com.cd.spring.factorybean.PersonFactoryBean">
    <property name="id" value="3"></property>
    <property name="name" value="FactoryBean"></property>
</bean>

1.4 依赖注入的方式

1.4.1 属性注入

• 属性注入即通过 setter 方法注入bean 的属性值或依赖的对象
• 属性注入使用 <property> 元素, 使用 name 属性指定 bean 的属性名称，value 属性或 <value>子节点指定属性值
• 属性注入是实际应用中最常用的注入方式:

<bean id="helloWorld" class="com.cd.spring.bean.HelloWorld">
    <!-- 为属性赋值 -->
    <property name="user" value="zhangsan"></property>
</bean>

1.4.2 构造器注入

通过构造方法注入bean 的属性值或依赖的对象，它保证了 bean 实例在实例化后就可以使用。
构造器注入在 <constructor-arg> 元素里声明属性, <constructor-arg> 中没有 name 属性

<!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
<!-- 可以根据 index 和 type 进行更加精确的定位. -->
<bean id="cal" class="com.cd.spring.bean.Calculator">
    <constructor-arg value="200" index="1"></constructor-arg>
    <constructor-arg value="100" index="0"></constructor-arg>
    <constructor-arg value="300" type="float"></constructor-arg>
</bean>

1.5 字面值

• 字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。
• 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式。
• 若字面值中包含特殊字符，可以使用 <![CDATA[]]>把字面值包裹起来。

1.6 引用其它bean

组成应用程序的 bean 经常需要相互协作以完成应用程序的功能. 要使 bean 能够相互访问, 就必须在 bean 配置文件中指定对 bean 的引用
在 bean 的配置文件中, 可以通过 <ref>元素或 ref 属性为 bean 的属性或构造器参数指定对 bean 的引用。
也可以在属性或构造器里包含 bean 的声明, 这样的 bean 称为内部 bean。

<!-- 配置 bean -->
<bean id="dao" class="com.cd.spring.Dao"></bean>

<bean id="service" class="com.cd.spring.Service">
    <!-- 通过 ref 属性值指定当前属性指向哪一个 bean! -->
    <property name="dao" ref="dao"></property>
</bean>

1.7 内部bean

当 bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 bean. 内部 bean 声明直接包含在 <property> 或 <constructor-arg> 元素里, 不需要设置任何 id 或 name 属性
内部 bean 不能使用在任何其他地方。

<!-- 声明使用内部 bean -->
<bean id="service" class="com.cd.spring.Service">
    <property name="dao">
        <bean class="com.cd.spring.Dao">
            <property name="dataSource" value="c3p0"></property>
        </bean>
    </property>
</bean>

1.8 集合属性

在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.

1.8.1 List

• 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过 <ref> 指定对其他 bean 的引用. 通过

<!-- 装配List集合属性 -->
<bean id="user" class="com.cd.spring.bean.User">
    <property name="userName" value="zhangsan"></property>
    <property name="list">
        <list>
            <value>list1</value>
            <value>list2</value>
            <value>list3</value>
        </list>
    </property>
</bean>

1.8.2 Map

java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值.
必须在 <key> 标签里定义键
因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素.
可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; bean 引用通过 key-ref 和 value-ref 属性定义

<!-- configure the map -->
<bean id="testMap" class="com.cd.spring.bean.User">
    <property name="map">
        <map>
            <entry key="first" value="1"></entry>
            <entry key="second" value="2"></entry>
            <entry key="third" value="3"></entry>
        </map>
    </property>
</bean>

1.8.3 Properties

使用 <props> 定义 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性.

DataSource.java

package com.cd.spring.bean;

import java.util.Properties;

public class DataSource {
    @Override
    public String toString() {
        return "Properties [properties=" + properties + "]";
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    private Properties properties;
}

application.xml配置

<!-- configure the properties -->
<bean id="dataSource" class="com.cd.spring.bean.DataSource">
    <property name="properties">
        <props>
            <prop key="user">root</prop>
            <prop key="password">root</prop>
            <prop key="jdbcUrl">jdbc:mysql:///test</prop>
            <prop key="driverClass">com.mysql.jdbc.Driver</prop>
        </props>
    </property>
</bean>

1.9 util命名空间

通过xml的Namespaces导入util命名空间。

<!-- 声明集合类型的 bean，共享该集合 -->
<util:list id="users">
    <ref bean="user0"/>
    <ref bean="user1"/>
    <ref bean="user2"/>
</util:list>
<bean id="Users" class="test.Spring.helloworld.Users">
    <property name="list">
        <ref bean="users"/>
    </property>
</bean>

1.10 p命名空间

为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。
Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 <bean> 元素属性的方式配置 bean 的属性。

通过xml的Namespaces导入p命名空间。

<bean id="user" class="com.cd.spring.bean.User" p:userName="zhangsan"></bean>

1.11 abstract模板bean

设置abstract=true表明此bean是模板bean，为其他bean提供属性值模板

<!-- template bean -->
<bean abstract="true"  id="template" p:id="50" p:name="fromTemplate"></bean>
<bean id="user1" parent="template" class="com.cd.spring.bean.User"></bean>

1.12 单例bean和原型bean

<!-- use scope to build singleton/prototype bean -->
<bean id="user0" parent="template" scope="singleton" class="test.Spring.helloworld.User"></bean>
<bean id="user1" parent="template" scope="prototype" class="test.Spring.helloworld.User"></bean>

singleton:此bean为单例，在context创建时已经创建，并且只有一个实例。

prototype:当需要时创建实例。

1.13 导入资源文件

db.properties

jdbc.user=root
jdbc.password=root
jdbc.jdbcUrl=jdbc:mysql:///test
jdbc.driverClass=com.mysql.jdbc.Driver

xml配置

<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.cd.spring.bean.DataSource">
    <property name="properties">
        <props>
            <prop key="user">${jdbc.user}</prop>
            <prop key="password">${jdbc.password}</prop>
            <prop key="jdbcUrl">${jdbc.jdbcUrl}</prop>
            <prop key="driverClass">${jdbc.driverClass}</prop>
        </props>
    </property>
</bean>

2. 基于注解配置bean

加上注解的类会被Spring容器管理。
组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.

2.1 常用注解

特定组件包括:
* @Component: 基本注解, 标识了一个受 Spring 管理的组件
* @Respository: 标识持久层组件
* @Service: 标识服务层(业务层)组件
* @Controller: 标识表现层组件
* @Autowired: 依据类型自动装配
* @Qualifier: 指定自动装载的bean的name
对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称。

xml配置:
在Spring配置文件中导入context命名空间，并加入。

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

ps:
base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类.
当需要扫描多个包时, 可以使用逗号分隔.
如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类。如：resource-pattern=”autowire/*.class”

<context:include-filter>
子节点表示要包含的目标类,该子节点需要use-default-filters配合使用。
<context:exclude-filter>
子节点表示要排除在外的目标类。

2.2 示例

TestObject:

package com.nf.test.bean.annotation;

import org.springframework.stereotype.Component;

@Component
public class TestObject {

}

UserController.java

package com.cd.spring.annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import com.cd.spring.annotation.service;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public void execute() {
        System.out.println("UserController execute...");
        userService.add();
    }
}

UserRepository.java

package com.cd.spring.annotation.repository;

public interface UserRepository {

    void save();
}

UserRepositoryImpl.java

package com.cd.spring.annotation.repository;

import org.springframework.stereotype.Service;
import com.nf.test.bean.annotation.TestObject;

@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository{

    @Autowired(required=false)// 类型可以是非注解，不会异常
    private TestObject testObject;

    public void save(){
        System.out.println("UserRepository save...");
        System.out.println(testObject);
    }
}

UserService.java

package com.cd.spring.annotation.service;

import org.springframework.stereotype.Service;
import com.cd.spring.annotation.repository.UserRepository;

@Service
public class UserService {

    // @Autowired默认按类的名字（首字母小写）去匹配。
    // 可以指定@Qualifier("userRepositoryImpl")设置匹配的类名。
    @Autowired   
    private UserRepository userRepository;

    public void add(){
        System.out.println("add...");
        userRepository.save();
    }
}

xml配置：

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

调用

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean_annotation.xml");

UserController controller = (UserController)ctx.getBean("userController");
System.out.println(controller);
controller.execute();

2.3 泛型注入

示例：
BaseRepository.java

package com.cd.test.bean.generic.di;

public class BaseRepository<T> {

}

BaseService.java

package com.cd.test.bean.generic.di;

import org.springframework.beans.factory.annotation.Autowired;

public class BaseService<T> {

    @Autowired
    protected BaseRepository<T> repository;

    public void add() {
        System.out.println("add...");
        System.out.println(repository);
    }
}

package com.cd.test.bean.generic.di;

public class User {

}

package com.cd.test.bean.generic.di;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository extends BaseRepository<User>{

}

package com.cd.test.bean.generic.di;

import org.springframework.stereotype.Service;

@Service
public class UserService extends BaseService<User>{

}

xml配置：

<context:component-scan base-package="com.cd.test.bean.generic.di"></context:component-scan>

调用

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

UserService userService = (UserService)context.getBean("userService");
userService.add();

3. bean的生命周期

通过init-method 和 destory-method为bean指定初始化和销毁方法。

Person.java

package com.cd.spring.bean;
public class Person {

    private String user;
    public Person() {
        System.out.println("Person's constructor...");
    }

    public Person(String user) {
        this.user = user;
    }

    public void setUser(String user) {
        System.out.println("setUser:" + user);
        this.user = user;
    }

    public void init(){
        System.out.println("init...");
    }

    public void destory(){
        System.out.println("destory...");
    }
}

xml配置

<bean id="person" class="com.cd.spring.bean.Person" init-method="init" destory-method="destory">
    <property name="user" value="zhangsan"></property>
</bean>

bean的后置处理器。允许在调用初始化方法前后对 Bean 进行额外的处理。

MyBeanPostProcessor.java

package com.cd.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        super();
        System.out.println("BeanPostProcessor实现类构造器！！");
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out
        .println("postProcessAfterInitialization对属性进行更改！");
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out
        .println("postProcessBeforeInitialization对属性进行更改！");
        return bean;
    }
}

xml配置

<bean id="beanPostProcessor" class="com.cd.spring.bean.MyBeanPostProcessor">
</bean>