Cynicism
cynicism
2023-04-16
目录

Spring简介

# 1. Spring系统架构

sring 4版本 (1)核心层

  • Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

(2)AOP层

  • AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
  • Aspects:AOP是思想,Aspects是对AOP思想的具体实现

(3)数据层

  • Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
  • Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
  • Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容

(4)Web层

  • 这一层的内容将在SpringMVC框架具体学习

(5)Test层

  • Spring主要整合了Junit来完成单元测试和集成测试

# 2. Bean

# 2.1 基础配置

  • 为什么Spring中的 bean 默认为单例?
    • bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
    • bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
  • bean在容器中是单例的，会不会产生线程安全问题?
    • 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，
    • 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
    • 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
  • 哪些bean对象适合交给容器进行管理?
    • 表现层对象
    • 业务层对象
    • 数据层对象
    • 工具对象
  • 哪些bean对象不适合交给容器进行管理?
    • 封装实例的域对象，因为会引发线程安全问题，所以不适合。

bean的基础配置信息:

在spring的配置文件applicationContext.xml中进行bean的配置

# 2.2 bean实例化

bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的

① 构造方法实例化 (常用)

Spring底层使用的是类的无参构造方法（默认提供）来实例化bean (底层使用的是反射)

② 静态工厂实例化 （了解）
③ 实例工厂实例化 （了解）

创建一个工厂类OrderDaoFactory并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
1
2
3
4
5
6
7
8
9
10

在spring的配置文件中添加以下内容:

<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
1
2

实例化工厂运行的顺序是:

  • 创建实例化工厂对象,对应的是第一行配置

  • 调用对象中的方法来创建bean，对应的是第二行配置

    • factory-bean:工厂的实例对象

    • factory-method:工厂对象中的具体创建对象的方法名,对应关系如下:

④ 简化版实例工厂实例化 —— FactoryBean （实用）

  • 创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    //返回所创建类的Class对象
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}
1
2
3
4
5
6
7
8
9
10
  • 在Spring的配置文件中进行配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
1

# 2.3 生命周期

bean对象从创建到销毁的整体过程,生命周期控制是指bean从创建到销毁中间需要实现的操作

具体的生命周期控制有两个阶段:

  • bean创建之后，想要添加内容，比如用来初始化需要用到资源
  • bean销毁之前，想要添加内容，比如用来释放用到的资源
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...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在配置文件添加配置，如下:

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
1

问题： Spring的IOC容器是运行在JVM中，运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象，然后调方法执行main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了,所以没有调用对应的destroy方法

解决方案：
① close关闭容器

  • 需要将ApplicationContext更换成ClassPathXmlApplicationContext
  ClassPathXmlApplicationContext ctx = new 
      ClassPathXmlApplicationContext("applicationContext.xml");
      ctx.close()
1
2
3

② 注册钩子关闭容器 在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器

  • 调用ctx的registerShutdownHook()方法

    //ClassPathXmlApplicationContext中的方法
ctx.registerShutdownHook();
    1
    2

不同点:close()是在调用的时候关闭，registerShutdownHook()是在JVM退出前调用关闭

简化配置生命周期的方法： Spring提供了两个接口来完成生命周期的控制，好处是可以不用再进行配置init-method和destroy-method

修改BookServiceImpl类，添加两个接口InitializingBean， DisposableBean并实现接口中的两个方法afterPropertiesSet和destroy

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

afterPropertiesSet初始化方法会在类中属性设置完（setBookDao方法）之后执行

# 3. 依赖注入（DI）

通过 普通方法(setter方法) 和 构造方法向一个类中传递引用数据类型和简单数据类型

# 3.1 setter注入

  • 在bean中定义基本数据和引用类型的属性，并提供可访问的set方法
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
1
2
3
4
5
6
  • 配置中使用property标签ref属性注入基本数据和引用类型对象
<?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 id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="databaseName"  value="mysql"/>
     	  <property name="connectionNum" value="10"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  • 对于引用数据类型使用的是<property name="" ref=""/>
  • 对于简单数据类型使用的是<property name="" value=""/>

# 3.2 构造器注入

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;
    private String databaseName;
    private int connectionNum;
    //删除setter方法, 采用有参构造函数
    public BookServiceImpl(BookDao bookDao,UserDao userDao,String databaseName, int connectionNum) {
        this.bookDao = bookDao;
        this.userDao = userDao;
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?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 id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="databaseName" value="mysql"/>
        <constructor-arg name="connectionNum" value="666"/>
    </bean>
   
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

说明:

constructor-arg标签中

  • name属性对应的值为构造函数中方法形参的参数名，必须要保持一致。
  • ref属性指向的是spring的IOC容器中其他bean对象

# 3.3 手动依赖注入小结

介绍完两种参数的注入方式，具体我们该如何选择呢?

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

# 3.4 自动配置

定义

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

配置方式：

  • 按类型（常用）
  • 按名称
  • 按构造方法
  • 不启用自动装配

自动装配只需要修改applicationContext.xml配置文件即可: (1)将<property>标签删除 (2)在<bean>标签中添加autowire属性

首先来实现按照类型注入的配置

<?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 class="com.itheima.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

</beans>
1
2
3
4
5
6
7
8
9
10

注意事项:

  • 需要注入属性的类中对应属性的setter方法不能省略
  • 被注入的对象必须要被Spring的IOC容器管理
  • 按照类型在Spring的IOC容器中如果找到多个对象，会报NoUniqueBeanDefinitionException
  • 一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入，配置方式为:autowire="byName"

注意事项:

  • 按照名称注入中的名称指的是什么?
public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
1
2
3
4
5
6
7

  • bookDao是private修饰的，外部类无法直接访问

  • 外部类只能通过属性的set方法进行访问

  • 对外部类来说，setBookDao方法名，去掉set后首字母小写是其属性名

    • 为什么是去掉set首字母小写?
    • 这个规则是set方法生成的默认规则，set方法的生成是把属性名首字母大写前面加set形成的方法名

  • 所以按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的

  • 如果按照名称去找对应的bean对象，找不到则注入Null

  • 当某一个类型在IOC容器中有多个对象，按照名称注入只找其指定名称对应的bean对象，会报错

两种方式介绍完后，以后用的更多的是按照类型注入。

最后对于依赖注入，需要注意一些其他的配置特征:

  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

# 3.5 集合注入

public class BookDaoImpl implements BookDao {

    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;
	//setter....方法省略，自己使用工具生成
}
1
2
3
4
5
6
7
8
9
<?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 id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        < 添加下列的property标签 >
    </bean>
</beans>
1
2
3
4
5
6
7
8
9

tips：在bookDao的bean标签中使用进行注入

# 3.5.1 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>
1
2
3
4
5
6
7

# 3.5.2 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>
1
2
3
4
5
6
7
8

# 3.5.3 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>
1
2
3
4
5
6
7
8

# 3.5.4 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>
1
2
3
4
5
6
7

# 3.5.5 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>
1
2
3
4
5
6
7

说明：

  • property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签
  • List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用
  • 集合中要添加引用类型，只需要把<value>标签改成<ref>标签，这种方式用的比较少
编辑 (opens new window)
#spring
上次更新: 2024/12/28, 07:52:50
Bean的管理开发

Bean的管理开发→

最近更新
01
JVM调优
06-03
02
Linux篇
03-30
03
Kafka篇
03-30
更多文章>
Theme by Vdoing | Copyright © 2023-2024 Cynicism | MIT License