深入浅出Spring框架：从IOC与DI基础到掌握自动装配原理

最新推荐文章于 2024-07-12 12:44:48 发布

Java探秘者

最新推荐文章于 2024-07-12 12:44:48 发布

阅读量1.7k

点赞数 11

文章标签： spring java 前端开发语言 idea intellij-idea 后端

本文链接：https://blog.csdn.net/2301_80237574/article/details/139369800

版权

问题导入

我们为什么要学习Spring框架？

为什么要学

Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>==90%==
专业角度
==简化开发==，降低企业级开发的复杂性
==框架整合==，高效整合其他技术，提高企业级应用开发与运行效率

怎么学

学习Spring框架设计思想
学习基础操作，思考操作与思想间的联系
学习案例，熟练应用操作的同时，体会思想

一、Spring核心概念

问题导入

问题1：目前我们的代码存在什么问题以及怎么解决这些问题？

问题2：请描述什么是IOC，什么是DI？

1.1 目前我们代码存在的问题

代码书写现状
耦合度偏高
解决方案
使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

1.2 核心概念

==IOC（Inversion of Control）控制反转==使用对象时，由主动new产生对象转换为由==外部==提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“==将new对象的权利交给Spring，我们从Spring中获取对象使用即可==”

Spring技术对IoC思想进行了实现

Spring提供了一个容器，称为==IOC容器==，用来充当IoC思想中的“外部”

IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为==Bean==

DI（Dependency Injection）依赖注入==

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

目标：充分解耦
使用IoC容器管理bean（IOC)
在IoC容器内将有依赖关系的bean进行关系绑定（DI）
最终效果
使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

二、IOC和DI入门案例

1 IOC入门案例

1.1 门案例思路分析

管理什么？(Service与Dao)
如何将被管理的对象告知IOC容器？(配置文件)
被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
IOC容器得到后，如何从容器中获取bean？(接口方法)
使用Spring导入哪些坐标？(pom.xml)

1.2 实现步骤

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

1.3 实现代码

【第一步】导入Spring坐标

<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

【第二步】定义Spring管理的类（接口)

BookDao接口和BookDaoImpl实现类

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象

定义applicationContext.xml配置文件并配置BookServiceImpl

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        bean标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookService" class="com.wwc.service.impl.BookServiceImpl"></bean>

</beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复

【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}

1.4 运行结果

2 DI入门案例

2.1 DI入门案例思路分析

基于IOC管理bean
Service中使用new形式创建的Dao对象是否保留？(否)
Service中需要的Dao对象如何进入到Service中？(提供方法)
Service与Dao间的关系如何描述？(配置)

2.2 实现步骤

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系

2.3 实现代码

环境代码：
- BookService接口和BookServiceImpl实现类：

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第一步】删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

【第二步】提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

【第三步】配置service与dao之间的关系

在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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        bean标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.wwc.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
            property标签：表示配置当前bean的属性
            name属性：表示配置哪一个具体的属性
            ref属性：表示参照哪一个bean
        -->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

三、Bean的基础配置

配置说明

四、Bean的实例化

问题导入

1、Bean是如何创建

bean本质上就是对象，创建bean使用构造方法完成

2、实例化Bean的三种方式

2.1 构造方法方式

BookDaoImpl实现类

public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}

applicationContext.xml配置

<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>

AppForInstanceBook测试类

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}

运行结果

注意：无参构造方法如果不存在，将抛出异常`BeanCreationException

2.2 静态工厂方式

OrderDao接口和OrderDaoImpl实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

OrderDaoFatory工厂类

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}

applicationContext.xml配置

<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.wwc.factory.OrderDaoFactory" factory-method="getOrderDao"/>

AppForInstanceOrder测试类

public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}

运行结果

2.3 实例工厂方式

UserDao接口和UserDaoImpl实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

UserDaoFactory工厂类

//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

applicationContext.xml配置

<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.wwc.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

AppForInstanceUser测试类

public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

2.4 实现FactoryBean\<T>方式

定义UserDaoFactoryBean实现FactoryBean\<UserDao>

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

applicationContext.xml配置
```

<bean id="userDao" class="com.wwc.factory.UserDaoFactoryBean"/>
```
使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复

五、依赖注入(DI配置)

1 依赖注入方式

问题导入

依赖注入有几种方式？

1.1 依赖注入的两种方式

setter注入
简单类型
引用类型(很常用)
构造器注入
简单类型
引用类型

1.2 setter方式注入

引用类型

public class BookServiceImpl implements BookService {
    BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

<bean id="bookDao" name="dao dao2" class="com.wwc.dao.impl.BookDaoImpl" scope="prototype"></bean>
        <bean id="bookService" class="com.wwc.sevice.impl.BookServiceImpl">
                <property name="bookDao" ref="bookDao"></property>
        </bean>

简单类型

public void setConnecttionNumber(Integer number){
        this.number=number;
    }

<bean id="bookDao" name="dao dao2" class="com.wwc.dao.impl.BookDaoImpl" ></bean>
<bean id="bookService" class="com.wwc.sevice.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"></property>
    <property name="number" value="10"></property>
    </bean>

构造方法

将上面的setter方式注入中的<propertry>改为<constructor-arg>

1.4 依赖注入方式选择

强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
可选依赖使用setter注入进行，灵活性强
Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器
注入自己开发的模块推荐使用setter注入

2 依赖自动装配

2.1 自动装配概念

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
自动装配方式
- 按类型（常用）
- 按名称
- 按构造方法
- 不启用自动装配

2.2 自动装配类型

依赖自动装配
- 配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.wwc.service.impl.BookServiceImpl" autowire="byType"/>

依赖自动装配特征

自动装配用于引用类型依赖注入，不能对简单类型进行操作

使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用

使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用

自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

3 集合注入

3.1 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

3.2 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

3.3 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

3.4 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

3.5 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写\<array>、\<list>、\<set>、\<map>、\<props>标签

六、Bean的生命周期

1 生命周期相关概念介绍

生命周期：从创建到消亡的完整过程
bean生命周期：bean从创建到销毁的整体过程
bean生命周期控制：在bean创建后到销毁前做一些事情

2 代码演示

提供生命周期控制方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

applicationContext.xml配置

<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

测试类

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
    }
}

2.2 Bean生命周期控制

实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

3 Bean销毁时机

容器关闭前触发bean的销毁
关闭容器方式：
手工关闭容器`
ConfigurableApplicationContext`接口`close()`操作
注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机`
ConfigurableApplicationContext`接口`registerShutdownHook()`操作

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        ctx.registerShutdownHook();
        //关闭容器
        //ctx.close();
    }
}

感谢观看