Spring6 框架学习

最新推荐文章于 2024-04-27 17:33:21 发布

oizys7

最新推荐文章于 2024-04-27 17:33:21 发布

阅读量427

点赞数

分类专栏： Spring 文章标签：学习 spring java

本文链接：https://blog.csdn.net/qq_43670559/article/details/130332444

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Spring6 框架学习

1 Spring介绍

1.1 简介

2002年，Rod Jahnson 首次推出了 Spring 框架雏形interface21 框架。

2004年3月24日，Spring 框架以 interface21 框架为基础，经过重新设计，发布了1.0正式版。

Spring 是一个开源框架，它由 [Rod Johnson](https://baike.baidu.com/item/Rod Johnson) 创建。它是为了解决企业应用开发的复杂性而创建的。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。

1.2 优点

Spring 是一个开源的免费的框架（容器)！
Spring 是一个轻量级的、非入侵式的框架！
控制反转（IoC），面向切面编程 (AOP)！
支持事务的处理，对框架整合的支持！
总结一句话: Spring 就是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的框架!

1.3 Maven 导入

<!--https://mvnrepository.com/artifact/org.springframework/spring-webmvc-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.17</version>
</dependency>

1.4 Spring模块组成

Spring Core（核心容器）：提供了 IOC, DI, Bean 配置装载创建的核心实现。核心概念： Beans、BeanFactory、BeanDefinitions、ApplicationContext
- Spring-core ：IOC 和 DI 的基本实现
- Spring-Beans：BeanFactory 和 Bean 的装配管理(BeanFactory)
- Spring-context：Spring context 上下文，即 IoC 容器 (AppliactionContext)
- Spring-expression：Spring 表达式语言
Spring AOP
- Spring-aop：面向切面编程的应用模块，整合 ASM，CGLib，JDK Proxy
- Spring-aspects：集成 AspectJ，AOP 应用框架
- Spring-instrument：动态 Class Loading 模块
Spring Data Access
- Spring-jdbc：Spring 对 JDBC 的封装，用于简化 jdbc 操作
- Spring-orm：Java 对象与数据库数据的映射框架
- Spring-oxm：对象与 xml 文件的映射框架
- Spring-jms： Spring 对 Java Message Service (java 消息服务)的封装，用于服务之间相互通信
- Spring-tx：Spring 的事务管理
Spring Web
- Spring-web：最基础的 web 支持，建立于 Spring-context 之上，通过 servlet 或 listener 来初始化 IoC 容器
- Spring-webmvc：实现 web mvc
- Spring-websocket：与前端的全双工通信协议
- Spring-webflux：Spring 5.0 提供的，用于取代传统 java servlet，非阻塞式 Reactive Web 框架，异步，非阻塞，事件驱动的服务
Spring Message
- Spring-messaging：Spring4.0 提供的，为 Spring 集成一些基础的报文传送服务
Spring test
- Spring-test：集成测试支持，主要是对 junit 的封装

2 IoC思想 ▲

以前的程序：DAO—>DaoImpl—>Service—>ServiceImpl

当业务需求改变时,需要在 ServiceImpl 中手动改变 DaoImpl 对象。当代码体量十分庞大时,修改一次的代价十分昂贵,此时我们用一个 set 接口:

private UserDao userDao;
public viod setUserDao(UserDao userDao){
    this.userDao = userDao;
}

以前的程序,控制权在程序员手里,现在程序不再具有主动性,而是变成了被动的接受者.系统耦合性大大降低
这就是IOC的原型

2.1 IoC本质

控制反转 IoC(Inversion of Control)，是一种设计思想，DI(依赖注入) 是实现 IoC 的一种方法，也有人认为 DI 只是 IoC 的另一种说法。没有 IoC 的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC 是 Spring 框架的核心内容，使用多种方式完美的实现了 IoC，我们可以使用 XML 配置，也可以使用注解，新版本的 Spring 也可以零配置实现 IoC。

Spring 容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从 Ioc 容器中取出需要的对象。

下图显示了 Spring 的工作原理的高级视图。在创建和初始化 ApplicationContext 之后，我们将具有完全配置且可执行的系统或应用程序。

采用 XML 方式配置 Bean 的时候，Bean 的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean 的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在 Spring 中实现控制反转的是 IoC 容器，其实现方法是依赖注入（Dependency Injection,DI）。

2.2 IoC 在 Spring 中的实现

Spring 的 IoC 容器就是 IoC 思想的一个落地的产品实现。IoC容器中管理的组件也叫做 Bean。在创建 Bean 之前，首先需要创建IoC 容器。Spring 提供了 IoC 容器的两种实现方式：

BeanFactory

这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。

ApplicationContext的主要实现类

iamges

类型名	简介
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IoC 容器对象
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IoC 容器对象
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力
WebApplicationContext	专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中

2.3 使用 xml 管理 Bean

2.3.1 测试准备

编写 Bean 的配置文件

<?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="user" class="***.User">  (1.) (2.)
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
        <property name="..." value="..."/>   (3.)
        <property name="..." ref="..."/>   (4.)
    </bean>

    <!-- more bean definitions go here -->

</beans>

id 属性是标识单个 Bean 定义的字符串。
class 属性定义 Bean 的类型并使用完全限定的类名。
value 属性定义基本数据类型
ref 属性引用 Spring 容器中创建好的的对象

获取配置文件

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

获取对象

根据id获取bena

User user = (User)context.getBean("user");

根据类型获取Bean（要求同类型只有一个）
```
User user = (User)context.getBean(User.class);
```

根据id和类型获取

User user = (User)context.getBean("user", User.class);

2.3.2 基于 Setter 方法注入

<bean id="..." class="...">
    <!-- collaborators and configuration for this bean go here -->
    <property name="..." value="..."/>   
    <property name="..." ref="..."/> 
</bean>

property 标签使用 Setter 方法进行注入

2.3.3 基于构造器方法注入

默认使用无参构造来创建对象

使用有参构造创建对象时有三种方法

<!-- 第一种根据参数名字设置 -->
<bean id="userT" class="com.pojo.User">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="test1"/>
</bean>

<!-- 第二种根据 index 参数下标设置 -->
<bean id="userT" class="com.pojo.User">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="test2"/>
</bean>

<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.pojo.User">
   <constructor-arg type="java.lang.String" value="test3"/>
</bean>

在xml配置文件加载时容器中的对象就已经初始化完成了

2.3.4 特殊值处理

字面量赋值

什么是字面量？

int a = 10;

声明一个变量 a，初始化为10，此时 a 就不代表字母 a 了，而是作为一个变量的名字。当我们引用 a 的时候，我们实际上拿到的值是 10。

而如果 a 是带引号的：‘a’，那么它现在不是一个变量，它就是代表 a 这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!-- 使用 value 属性给 Bean 的属性赋值时，Spring 会把 value 属性的值看做字面量 -->
<property name="name" value="张三"/>

null值

<property name="name">
    <null />
</property>

注意：
<property name="name" value="null"></property>
以上写法，为name所赋的值是字符串null

特殊符号

xml 实体

<!-- 小于号在 XML 文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>

CDATA 节

<property name="expression">
    <!-- 解决方案二：使用CDATA节 -->
    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
    <!-- 所以CDATA节中写什么符号都随意 -->
    <value><![CDATA[a < b]]></value>
</property>

2.3.5 对象类型注入

引用外部 Bean

<property name="..." ref="外部 Bean 的 id"/>

内部 Bean

<property name="...">
    <!-- 在一个 Bean 中再声明一个 Bean 就是内部 Bean -->
    <!-- 内部 Bean 只能用于给属性赋值，不能在外部通过 IoC 容器获取，因此可以省略 id 属性 -->
    <bean class="...">
        <property name="..." value="..."></property>
        <property name="..." value="..."></property>
    </bean>
</property>

级联属性赋值

<bean id="..." class="...">
    <property name="..." value="..."></property>
    
    <property name="clazz" ref="..."></property>
    <!-- 级联（通过du）属性赋值--> 
    <property name="clazz.clazzId" value="..."></property>
</bean>

2.3.6 Array、List、Map 类型注入

Array

<bean id="..." class="...">
    <property name="..." value="..."></property>
    <property name="array">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
</bean>

List

<bean id="listOne" class="..."></bean>
<bean id="listTwo" class="..."></bean>

<bean id="..." class="...">
    <property name="..." value="..."></property>
    <property name="List">
        <list>
            <ref bean="listOne"></ref>
            <ref bean="listTwo"></ref>
        </list>
    </property>
</bean>

Map

<bean id="mapOne" class="..."></bean>
<bean id="mapTwo" class="..."></bean>

<bean id="..." class="...">
    <property name="..." value="..."></property>
    <property name="Map">
        <map>
            <entry>
                <key>
                    <value>10010</value>
                </key>
                <ref bean="mapOne"></ref>
            </entry>
            <entry>
                <key>
                    <value>10086</value>
                </key>
                <ref bean="mapTwo"></ref>
            </entry>
        </map>
    </property>
</bean>

命名空间引入

引入相应的命名空间

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

配置

<bean id="listOne" class="..."></bean>
<bean id="listTwo" class="..."></bean>
<bean id="mapOne" class="..."></bean>
<bean id="mapTwo" class="..."></bean>

<!--list 集合类型的 Bean-->
<util:list id="List">
    <ref bean="listOne"></ref>
    <ref bean="listTwo"></ref>
</util:list>
<!--map 集合类型的 Bean-->
<util:map id="Map">
    <entry>
        <key>
            <value>10010</value>
        </key>
        <ref bean="mapOne"></ref>
    </entry>
    <entry>
        <key>
            <value>10086</value>
        </key>
        <ref bean="mapTwo"></ref>
    </entry>
</util:map>
<bean id="..." class="...">
    <property name="..." value="..."></property>
    <!-- ref 属性：引用 IoC 容器中某个 Bean 的 id，将所对应的 Bean 为属性赋值 -->
    <property name="list" ref="List"></property>
    <property name="map" ref="Map">
</bean>

2.3.7 p命名空间

引入p命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:p="http://www.springframework.org/schema/p">

引入p命名空间后，可以通过以下方式为Bean的各个属性赋值

<bean id="..." class="..."
    p:id="..." p:name="..." p:clazz-ref="clazzOne" p:teacherMap-ref="teacherMap"></bean>

2.3.8 引入外部属性文件

以数据库配置为例

创建 jdbc.properties 文件

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

在 xml 中引入属性文件

引入 context 名称空间

<?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">

</beans>

<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

在使用 context:property-placeholder 元素加载外包配置文件功能前，首先需要在 XML 配置的一级标签中添加 context 相关的约束。

配置Bean

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="username" value="${jdbc.user}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

2.3.9 Bean 的作用域

在 Spring 中可以通过配置 bean 标签的 scope 属性来指定 Bean 的作用域范围，各取值含义参加下表：

取值	含义	创建对象的时机
singleton（默认）	在 IoC 容器中，这个 Bean 的对象始终为单实例	IoC 容器初始化时
prototype	这个 Bean 在 IoC 容器中为多实例	获取 Bean 时

如果是在 WebApplicationContext 环境下还会有另外几个作用域（但不常用）：

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

2.3.10 Bean 生命周期

具体的生命周期过程

Bean 对象创建（调用无参构造器）
给 Bean 对象设置属性
Bean 的后置处理器（初始化之前）
Bean 对象初始化（需在配置 Bean 时指定初始化方法）
Bean 的后置处理器（初始化之后）
Bean 对象就绪可以使用
Bean 对象销毁（需在配置 Bean 时指定销毁方法）

测试类 User

public class User {

    private Integer id;

    public User() {
        System.out.println("生命周期：1、创建对象");
    }

    public void setId(Integer id) {
        System.out.println("生命周期：2、依赖注入");
        this.id = id;
    }

    public void initMethod(){
        System.out.println("生命周期：4、初始化");
    }

    public void destroyMethod(){
        System.out.println("生命周期：7、销毁");
    }
}

配置 Bean

<!-- 使用 init-method 属性指定初始化方法 -->
<!-- 使用 destroy-method 属性指定销毁方法 -->
<bean class="User" scope="prototype" init-method="initMethod" destroy-method="destroyMethod">
    <property name="id" value="1001"></property>
</bean>

测试

@Test
public void testLife(){
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    User bean = ac.getBean(User.class);
    System.out.println("生命周期：6、通过 IoC 容器获取 Bean 并使用");
    ac.close();//生命周期：7、销毁
}

Bean 的后置处理器

Bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，Bean后置处理器不是单独针对某一个Bean生效，而是针对IOC容器中所有Bean都会执行

创建 Bean 的后置处理器

public class MyBeanProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("生命周期：3、后置处理器，初始化之前");
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("生命周期：5、后置处理器，初始化之后");
        return bean;
    }
}

在 IoC 容器中配置后置处理器

<!-- Bean 的后置处理器要放入 IoC 容器才能生效 -->
<bean id="myBeanProcessor" class="com.oizys.spring6.process.MyBeanProcessor"/>

2.3.11 FactoryBean

FactoryBean 是 Spring 提供的一种整合第三方框架的常用机制。和普通的 Bean 不同，配置一个 FactoryBean 类型的 Bean，在获取 Bean 的时候得到的并不是 class 属性中配置的这个类的对象，而是 getObject() 方法的返回值。通过这种机制，Spring 可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

2.3.12 基于 xml 自动装配

根据指定的策略，在 IoC 容器中匹配某一个 Bean，自动为指定的 Bean中所依赖的类类型或接口类型属性赋值

2.4 使用注解管理 Bean

2.4.1 开启组件扫描

情况一：最基本的扫描方式

<context:component-scan base-package="要扫描的路径">
</context:component-scan>

情况二：指定要排除的组件

<context:component-scan base-package="要扫描的路径">
    <!-- context:exclude-filter标签：指定排除规则 -->
    <!-- 
 		type：设置排除或包含的依据
		type="annotation"，根据注解排除，expression 中设置要排除的注解的全类名
		type="assignable"，根据类型排除，expression 中设置要排除的类型的全类名
	-->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <!--<context:exclude-filter type="assignable" expression="***.UserController"/>-->
</context:component-scan>

情况三：仅扫描指定组件

<context:component-scan base-package="要扫描的路径" use-default-filters="false">
    <!-- context:include-filter 标签：指定在原有扫描规则的基础上追加的规则 -->
    <!-- use-default-filters 属性：取值  false 表示关闭默认扫描规则 -->
    <!-- 此时必须设置 use-default-filters="false"，因为默认规则即扫描指定包下所有类 -->
    <!-- 
 		type：设置排除或包含的依据
		type="annotation"，根据注解排除，expression 中设置要排除的注解的全类名
		type="assignable"，根据类型排除，expression 中设置要排除的类型的全类名
	-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	<!--<context:include-filter type="assignable" expression="***.UserController"/>-->
</context:component-scan>

2.4.2 使用注解定义 Bean

Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean

注解	说明
@Component	该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。使用时只需将该注解标注在相应类上即可。
@Repository	该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service	该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller	该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

2.4.3 依赖注入

@Autowired 注入

单独使用 @Autowired 注解，默认根据类型装配

查看源码：

package org.springframework.beans.factory.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

源码中有两处需要注意：

第一处：该注解可以标注在哪里？
- 构造方法上
- 方法上
- 形参上
- 属性上
- 注解上
第二处：该注解有一个 required 属性，默认值是 true，表示在注入的时候要求被注入的 Bean 必须是存在的，如果不存在则报错。如果 required 属性设置为 false ，表示注入的 Bean 存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

注入方式

场景一：属性注入