SSM框架之Spring（2）IOC及依赖注入

Spring（2）IOC及依赖注入

基于xml配置文件的实现

1、IOC （控制反转-Inversion Of Control）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

明确 ioc 的作用：

削减计算机程序的耦合(降低我们代码中的依赖关系)。

2、使用 spring 的IOC解决程序耦合问题

以下使用maven建立

2.1、配置pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>wf</groupId>
    <artifactId>ssm02_spring_02IoC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
    </dependencies>
</project>

2.2、有关持久化层的编写

实现类路径：E:\java\idea\SSM\ssm02_spring_02IoC\src\main\java\domain\dao\impl\AccountDaoImpl.java

实现类全限定类名：domain.dao.impl.AccountDaoImpl

/**
 * 账户持久层接口
 */
public interface IAccountDao {
    void saveAccount();
}
/*
*持久层实现类
*/
import domain.dao.IAccountDao;
public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("保存账户成功！！！");
    }
}

2.3、服务层编写

实现类路径：E:\java\idea\SSM\ssm02_spring_02IoC\src\main\java\domain\service\impl\AccountServiceImpl.java

实现类全限定类名：domain.service.impl.AccountServiceImpl

public interface IAccountService {
    /**
     * 模拟保存账号
     */
    void saveAccount();
}
/*
*服务层实现类
*/
import domain.service.IAccountService;
import domain.dao.IAccountDao;
import domain.dao.impl.AccountDaoImpl;
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

2.4、bean.xml文件的配置

通过配置使spring可以通过该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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把对象创建交给spring管理-->
    <bean id="accountService" class="domain.service.impl.AccountServiceImpl"/>
    <bean id="accountDao" class="domain.dao.impl.AccountDaoImpl"/>
</beans>

2.5、测试类的编写

获取spring的Ioc的核心容器，并根据id获取对象

ApplicationContext的三个常用实现类：

​ ClassPathXmlApplicationContext:加载任意类类路径下的配置文件，要求配置文件必须在类路径下。否则无法加载

new ClassPathXmlApplicationContext("bean.xml");

​ FileSystemXmlApplicationContext：加载任意磁盘路径下的配置文件（）必须拥有访问权限

new FileSystemXmlApplicationContext("E:\\java\\idea\\SSM\\ssm02_spring_02IoC\\src\\main\\resources\\bean.xml");

​ AnnotationConfigApplicationContext：用于读取注解创建的容器

核心容器的两个接口引发的问题：

​ ApplicationContext： 单例模式使用

​ 在构建核心容器时，采用立即加载的方式创建对象。即只要一读取配置文件就立即创建配置文件中配置的对象

​ BeanFactory： 多例对象适用

​ 在构建核心容器时，采用延迟加载的方式创建对象。即当使用对象时才创建对象

public class Client {
    /**
     * 获取spring的Ioc的核心容器，并根据id获取对象
     *
     * ApplicationContext的三个常用实现类：
     *      ClassPathXmlApplicationContext:加载任意类类路径下的配置文件，要求配置文件必须在类路径下。否则无法加载
     *      FileSystemXmlApplicationContext：加载任意磁盘路径下的配置文件（）必须拥有访问权限
     *      AnnotationConfigApplicationContext：用于读取注解创建的容器
     *
     * 核心容器的两个接口引发的问题：
     * ApplicationContext：  单例模式使用
     *      在构建核心容器时，采用立即加载的方式创建对象。即只要一读取配置文件就立即创建配置文件中配置的对象
     * BeanFactory：  多例对象适用
     *      在构建核心容器时，采用延迟加载的方式创建对象。即当使用对象时才创建对象
     * @param args
     */
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("E:\\java\\idea\\SSM\\ssm02_spring_02IoC\\src\\main\\resources\\bean.xml");
        //通过强制类型转换创建我们需要的对象
        IAccountService service = (AccountServiceImpl)ac.getBean("accountService");
        //采用向spring容器传入要创建对象的class文件的方式创建对象
        AccountDaoImpl dao = ac.getBean("accountDao", AccountDaoImpl.class);
        /*IAccountService as = new AccountServiceImpl();
        as.saveAccount();*/
        System.out.println(service);
        System.out.println(dao);
    }
}

3、对配置文件bean.xml的详解

对应使用的工厂类

import domain.service.IAccountService;
import domain.service.impl.AccountServiceImpl;
public class BeanFactory {
    public IAccountService getAccountService(){
        return new AccountServiceImpl();
    }
    public static IAccountService getAccountService1(){
        return new AccountServiceImpl();
    }
}

3.1、spring创建bean的管理细节

1.创建bean的三种方式。

2.bean对象的作用范围

3.bean对象的生命周期

1.创建bean的三种方式。

id：给对象在容器中提供一个唯一标识。用于获取对象。

class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

方法一：使用默认的构造函数创建
        在spring配置文件中使用bean标签，配以id和class属性，
        而无其他属性与标签时，采用默认构造函数的方式创建bean对象，
        如果类中无默认构造函数则无法创建对象

<bean id="accountService" class="domain.service.impl.AccountServiceImpl"/>

方法二：使用普通工厂模式的成员方法创建对象（使用每个类中的方法创建对象，存入spring容器中）

先创建beanFactory对象然后在accountService中调用beanFactory对象通过对象调用方法getAccountService

<bean id="beanFactory" class="domain.factory.BeanFactory"/>
<bean id="accountService" factory-bean="beanFactory" factory-method="getAccountService"/>

方法三：使用工厂模式的静态方法创建对象

<bean id="accountService" class="domain.factory.BeanFactory" factory-method="getAccountService1"/>

2.bean对象的作用范围

bean标签的scope属性：
   作用：用于指定bean的作用范围
   取值：
       singleton：单例
       prototype：多例的
       request：作用于web应用的请求范围
       session：作用于web应用的会话范围
       global-session：作用于集群环境的会话范围
       （全局会话范围），不是集群环境时，就是session

<bean id="accountService" class="domain.service.impl.AccountServiceImpl" scope="prototype"/>

3.bean对象的生命周期

通过init方法和destory方法观察对象的创建和销毁

import domain.service.IAccountService;
public class AccountServiceImpl implements IAccountService {
    public AccountServiceImpl() {
        System.out.println("对象创建。。。");
    }
    public void saveAccount() {
        System.out.println("Service的saveAccount方法");
    }
    public void init() {
        System.out.println("对象初始化。。。");
    }
    public void destiry() {
        System.out.println("对象销毁了。。。。");
    }
}

init-method：指定类中的初始化方法名称。

destroy-method：指定类中销毁方法名称。

单例对象：
    出生；当容器创建时对象出生
    活着：只要容器存在，对象就一直存在
    死亡：容器销毁，对象消亡
多例对象：
    出生；当使用对象时，spring才会创建
    活着：只要对象使用就一直活着
    死亡：当对象长时间不使用，且没有被别的对象引用。通过垃圾回收机制回收

<bean id="accountService" class="domain.service.impl.AccountServiceImpl" scope="prototype"
init-method="init" destroy-method="destiry"/>

4、spring的依赖注入

4.1、依赖注入的概念

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。

我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

依赖注入：
    Dependency Injection
IOC的作用：
    解耦（降低程序间的耦合，依赖关系）
依赖关系的管理：
    以后交由spring维护
在当前类需要调用其他类的方法时，该类的对象由spring提供，只需要在配置文件中说明
依赖关系的维护：就是依赖注入
依赖注入：
    能注入的数据：三类
        基本类型和String
        其他bean类型（在配置文件中或注解中配置的bean
        复杂类型/集合类型
    注入的方式：三种
        1.通过构造函数注入
        2.通过set方法提供
        3.使用注解提供

1.通过构造函数注入

使用标签：constructor-arg

标签出现位置：bean标签内部

标签的属性：

type：指定要注入数据的数据类型，该数据类型也是构造函数的每个参数的类型

index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引位置从0开始

name：用于指定给构造函数中指定名称的参数赋值 常用

========以上三个参数用于指定给构造函数的哪个参数赋值

value：用于给基本类型和String的数据赋值

ref：用于指定其他的bean类型数据。即在spring的IOC核心容器中出现的bean对象

特点：

在获取bean对象时，注入数据是必须操作否则对象无法创建。

缺点：

改变了bean对象的数理化方式，使我们在创建对象时，即使不需要参数也要提供参数

import java.util.Date;
public class AccountServiceImpl implements IAccountService{
    //如果经常变化的数据，并不适合注入的方式
    private String name;
    private Integer age;
    private Date birthday;
   /* public AccountServiceImpl() {
    }*/
    public AccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
}

<bean id="accountService" class="domain.service.impl.AccountServiceImpl">
    <constructor-arg name="name" value="哈哈"/>
    <constructor-arg name="age" value="19"/>
    <constructor-arg name="birthday" ref="now" />
</bean>
<!--配置日期对象-->
<bean id="now" class="java.util.Date"/>

2.通过set方法提供

​ 涉及标签：properties

​ 出现位置：bean标签内部

​ 标签属性：

​ name：用于指定注入时所调用的set名称

​ value：用于给基本类型和String的数据赋值

​ ref：用于指定其他的bean类型数据。即在spring的IOC核心容器中出现的bean对象

​ 特点：

​ 创建对象时没有明确的限制，可以使用默认构造函数

​ 缺点：

​ 如果某个参数必须有值，则获取对象时可能set方法没有执行

import java.util.Date;
public class AccountServiceImpl2 implements IAccountService{
    //如果经常变化的数据，并不适合注入的方式
    private String name;
    private Integer age;
    private Date birthday;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

<bean id="accountService2" class="domain.service.impl.AccountServiceImpl2">
    <property name="name" value="test"/>
    <property name="age" value="18"/>
    <property name="birthday" ref="now"/>
</bean>

3.使用 p 名称空间注入数据（本质还是调用 set 方法）

此种方式是通过在 xml中导入 p名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用类中的

set 方法实现注入功能。

/**
* 使用 p 名称空间注入，本质还是调用类中的 set 方法
*/
public class AccountServiceImpl4 implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println(name+","+age+","+birthday);
}
}

<bean id="accountService"
	class="com.itheima.service.impl.AccountServiceImpl4"
	p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

4.复杂类型的注入/集合类型注入

用于给List结构集合注入的标签：

list,set,array

用于给Map集合注入的标签：

map，props

即结构相同，标签可以互换

import java.util.*;
public class AccountServiceImpl3 implements IAccountService {
    private String[] myStr;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProp;
    public void setMyStr(String[] myStr) {
        this.myStr = myStr;
    }
    public void setMyList(List<String> myList) {
        this.myList = myList;
    }
    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }
    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }
    public void setMyProp(Properties myProp) {
        this.myProp = myProp;
    }
    public void saveAccount() {
        System.out.println(Arrays.toString(myStr));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProp);
    }
}

<bean id="accountService3" class="domain.service.impl.AccountServiceImpl3">
        <property name="myStr">
            <array>
                <value>hhhh</value>
                <value>bbbb</value>
                <value>xxxx</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>hhhh</value>
                <value>bbbb</value>
                <value>xxxx</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>hhhh</value>
                <value>bbbb</value>
                <value>xxxx</value>
            </set>
        </property>
    <property name="myMap">
        <props>
            <prop key="a">1111</prop>
            <prop key="b">2222</prop>
        </props>
    </property>
    <property name="myProp">
        <map>
            <entry key="1" value="aaaa"/>
            <entry key="2">
                <value>bbbb</value>
            </entry>
        </map>
    </property>
</bean>