走近科学(划掉)走近Spring

最新推荐文章于 2024-06-18 14:54:47 发布

简繁集

最新推荐文章于 2024-06-18 14:54:47 发布

阅读量136

点赞数

分类专栏： JavaWeb 文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_60808029/article/details/124695912

版权

JavaWeb 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

文章目录

一、Spring 概述和体系结构

Spring 是一个开源框架，Spring 是于2003年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。

简单来说，Spring是一个分层的 JavaSE/EE full-stack(一站式) 轻量级开源框架。Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。

Spring 的体系结构：

二、Spring IoC 和 Spring DI

IoC：Inverse of Control，翻译过来是控制反转，将对象的创建权由 Spring 管理，如 HelloService 等对象不需要自己去创建，Spring 可以帮你创建。Ioc部分对应上图的 Core Container 部分，如果再细分，对应的是里面的Beans和Core模块，Context模块是依赖于Beans和Core构建的上下文模块，是直接提供对外使用的，严格意义上来说Ioc的模块就是Beans和Core模块。

DI：Dependency Injection，依赖注入，在我们创建对象的过程中，把对象依赖的属性注入到我们的类中。

2.1 Spring IoC 控制反转

IoC 容器具有依赖注入功能的容器，它可以创建对象，IoC 容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制，而“控制反转”是指new实例工作不由程序员来做而是交给Spring容器来做。

Spring 提供了以下两种不同类型的容器：

Spring BeanFactory 容器：这是一个最简单的容器，它主要的功能是为依赖注入（DI）提供支持，这个容器接口在 org.springframework.beans.factory.BeanFactory 中被定义。
Spring ApplicationContext 容器：该容器是 BeanFactory 的子接口，包括 BeanFactory 容器的所有功能，也被称为 Spring 上下文，所以通常不建议使用 BeanFactory 。Application Context 可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。

Spring ApplicationContext 最常被使用的接口实现类：

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件，推荐使用这种。
FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext：在使用注解配置时该类用来加载核心配置类。

由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。

Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。这里主要讲 XML 文件格式，文件名无特殊要求，可以是 applicationContext.xml 或 Beans.xml 等，在 XML 文件配置的 <bean> 元素中可以包含多个属性或子元素，常用的属性或子元素如下表所示：

属性/子元素	描述
id	Bean实例在Spring容器中的唯一标识属性。值必须以字母开始，可以使用字母、数字、下划线等符号。
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，即类的全限定名。
scope	表示 Bean 的作用域，该属性的值可以为 singleton（单例）、prototype（原型）、request、session 和 global Session。默认值是 singleton。常用默认值singleton和prototype。
init-method	属性，容器加载 Bean 时调用该方法，类似于 Servlet 中的 init() 方法
destroy-method	属性，容器删除 Bean 时调用该方法，类似于 Servlet 中的 destroy() 方法。该方法只在 scope=singleton 时有效

根据配置文件中的信息用 Spring IoC 容器中的 getBean() 方法创建 Bean 对象并进行管理。

getBean() 有两种传参方式：

Object getBean(String name)：当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回的是Object对象，需要强转。
<T> T getBean(Class<T> requiredType)：当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。

Spring IoC 控制反转的案例：https://blog.csdn.net/weixin_60808029/article/details/124835656#Spring_IoC__2

2.2 Spring DI 依赖注入

依赖注入，总的来说就是把对象依赖的属性注入到 Bean 中，而这属性既可以普通属性 int、String 等，也可以是一个对象（Bean）如 Student ，还可以是集合，如 List<String>、Map<String, Student>、Properties 等。

Spring 主要通过以下 2 种方式实现属性注入：

setter 注入（设值注入）
有参构造函数注入

Tips：如果 Spring 配置文件中的bean中没有<constructor-arg>元素，则调用默认的无参构造函数。如果有<constructor-arg>元素，则由该元素确定调用的唯一带参构造函数。

涉及到的配置文件的 <bean> 标签的属性/子元素如下：

属性/子元素	描述
constructor-arg	`<bean>` 元素的子元素，我们可以通过该元素，将构造参数传入，以实现 Bean 的实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型。
property	`<bean>` 元素的子元素，用于调用 Bean 实例中的 setter 方法对属性进行赋值，从而完成属性的注入。该元素的 name 属性用于指定 Bean 实例中相应的属性名。
name	属性名称。
value	`<property>` 和 `<constractor-arg>` 等元素的子元素，用于直接指定一个常量值。
ref	`<property>` 和 `<constructor-arg>` 等元素的子元素，用于指定对某个 Bean 实例的引用，即 `<bean>` 元素中的 id 或 name 属性。
list	用于注入 list 类型的值，允许重复。
map	用于注入 key-value 的集合，其中 key 和 value 都可以是任意类型。
props	用于注入 key-value 的集合，其中 key 和 value 都是字符串类型。

Spring 依赖注入方式（两种）的源码示例：https://blog.csdn.net/weixin_60808029/article/details/124835656#Spring__59

三、简化XML配置就用注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

目前在Spring中注解有两个部分：原始注解（出现时间早）、新注解（出现时间晚）。

3.1 Spring 的原始注解

Spring 原始注解主要是替代 <Bean> 的配置。

Spring 原始注解	说明
@Component	使用在类上用于实例化Bean。
@Controller	使用在web层类上用于实例化Bean。
@Service	使用在service层类上用于实例化Bean。
@Repository	使用在dao层类上用于实例化Bean。
@Autowired	使用在字段上用于根据类型依赖注入。
@Qualifier	结合@Autowired一起使用，根据名称进行依赖注入。
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入。
@Value	注入普通属性。
@Scope	标注Bean的作用范围。
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法。
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法。

Tips：

使用注解进行开发时，需要在XML配置文件中配置组件扫描（如 <context:component-scan base-package="com.example"/>），作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。
若使用 @Compont 或 @Repository 标识dao层的实现类，则需要Spring进行实例化。
若使用 @Compont 或 @Service 标识service层的实现类，则需要Spring进行实例化。
使用 @Autowired 或者 @Autowired+@Qulifier 或者 @Resource 进行依赖注入。
使用 @Value 进行字符串的注入。
使用 @Scope 标注Bean的范围。
使用 @PostConstruct 标注初始化方法，使用 @PreDestroy 标注销毁方法。

3.2 Spring 的新注解

在XML配置文件中，还有非自定义的Bean<bean>、引入properties配置文件<context:property-placeholder> 、组件扫描<context:component-scan> 、引入xml配置文件<import> 四个标签不能用 Spring 原始注解替代。而Spring 新注解提出了解决方案。

Spring 新注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解。
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的 `<context:component-scan>` 一样。
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中。
@PropertySource	用于加载 `.properties` 文件中的配置。
@Import	用于导入其他配置类。

新注解使用的关键源码如下：

创建一个类如 SpringConfiguration.java 替代xml配置文件。

//@Configuration标志该类是Spring的核心配置类
@Configuration
//@ComponentScan替代xml中的<context:component-scan>
@ComponentScan("com.itheima")
//@Import替代xml中的<import>
@Import({DataSourceConfiguration.class})
public class SpringConfiguration {
}

创建一个类 DataSourceConfiguration.java 放置获取数据源的配置，该类中引入的 jdbc.properties 源码在前文已有描述。

//@PropertySource替代xml中的<context:property-placeholder>
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Bean("dataSource")  //Spring会将当前方法的返回值以指定名称存储到Spring容器中
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

使用 AnnotationConfigApplicationContext() 实现类加载Spring的核心配置类 SpringConfiguration.java 。

ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
app.getBean();
//……

四、Spring AOP

4.1 概念

AOP，Aspect Oriented Programming，译为“面向切面编程”，和 OOP（面向对象编程）类似，它也是一种编程思想。

AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标对象的方法，从而完成功能的增强。

Spring AOP 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。

Spring AOP 优势：减少重复代码，提高开发效率，并且便于维护。

4.2 AOP 术语

AOP 术语	说明
Joinpoint（连接点）	AOP 的核心概念，指的是程序执行期间明确定义的一个点，例如方法的调用、类初始化、对象实例化等。在 Spring 中，连接点则指可以被动态代理拦截目标类的方法。
Pointcut（切入点）	又称切点，指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。（切入点是连接点的一部分）
Advice（通知/增强）	指拦截到 Joinpoint 之后要执行的代码，即对切入点增强的内容。
Target（目标）	指代理的目标对象，通常也被称为被通知（advised）对象。
Weaving（织入）	指把增强代码应用到目标对象上，生成代理对象的过程。 Spring采用动态代理织入。
Proxy（代理）	指生成的代理对象。
Aspect（切面）	切面是切入点（Pointcut）和通知（Advice）的结合。

Advice 通知，亦称为“增强处理”，共有 5 种类型，如下表所示。

通知	说明
before（前置通知）	通知方法在目标方法调用之前执行
after（后置通知）	通知方法在目标方法返回或异常后调用
after-returning（返回后通知）	通知方法会在目标方法返回后调用
after-throwing（抛出异常通知）	通知方法会在目标方法抛出异常后调用
around（环绕通知）	通知方法会将目标方法封装起来

4.3 AOP 开发需明确的事项

需要编写的内容：1、编写核心业务代码（目标类的目标方法、切点表达式配置）。2、编写切面类，切面类中有通知（切面类中的增强方法）。3、在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合。

AOP 技术实现的内容：Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

AOP 底层使用的代理方式：在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式（有接口则使用JDK的动态代理进行开发，没有接口则使用Cglib的动态代理）。

Spring 基于XML的AOP开发的源码示例：https://blog.csdn.net/weixin_60808029/article/details/124835656#Spring_XMLAOP_342

五、Spring JdbcTemplate

JdbcTemplate 是 Spring 框架中提供的一个对象，是对原始繁琐的 Jdbc API 对象的简单封装。Spring 框架为我们提供了很多的操作模板类。例如：操作关系型数据的 JdbcTemplate 和 HibernateTemplate ，操作 nosql 数据库的 RedisTemplate ，操作消息队列的 JmsTemplate 等等。

用Spring配置连接池（即数据源）。DataSource 有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的，需要通过 setter 方法设置数据库连接信息，所以可以用Spring通过 setter 方法进行字符串注入。

以创建C3P0连接池为例，通过XML配置文件创建连接池，源码如下：

导入spring-jdbc和spring-tx坐标。
在resource目录下创建数据库连接信息文件：jdbc.properties 。

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名
jdbc.username=数据库的用户名
jdbc.password=数据库的密码

在resource目录下创建Spring配置文件：applicationContext.xml ，并引入context命名空间（xmlns:context="http://www.springframework.org/schema/context"）和约束路径（http://www.springframework.org/schema/context 和 http://www.springframework.org/schema/context/spring-context.xsd）：

<?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">
    <!--引入 jdbc.properties 中的配置-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--定义数据源 Bean-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
        <property name="driverClass" value="${jdbc.driver}"/> 
        <property name="jdbcUrl" value="${jdbc.url}"/> 
        <property name="user" value="${jdbc.username}"/> 
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

编写测试代码，从容器当中获取数据源。

ApplicationContext app = new 
    				ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = (DataSource) app.getBean("dataSource");
Connection connection = dataSource.getConnection();
//打印连接池地址
System.out.println(connection);
connection.close();

六、Spring Transaction（事务）

6.1 复习一下事务

SQL 中的 Transaction Control Language 事务控制语言：https://blog.csdn.net/weixin_60808029/article/details/122243661

事务由单独单元的一个或多个 SQL 语句组成，在这个单元中，每个 MySQL 语句是相互依赖的。而整个单独单元作为一个不可分割的整体，如果单元中某条 SQL 语句执行失败或者产生错误，整个单元将会回滚，所有受到影响的数据将会返回事务开始前的状态；如果单元中的所有 SQL 语句均执行成功，则事务被顺利执行。

回滚：即把执行错误的事务撤销，数据回到执行前的状态，同软件安装时的“下一步”、“上一步”一样。

应用场景比如：张三非有1000元，要给同样有1000元的郭襄转500元。

隔离，对于同时运行的多个事务，当这些事务访问数据库中相同的数据时，如果没有采取必要的隔离机制，就会导致各种并发问题：脏读、不可重复读、幻读，为避免数据发生以上问题，我们可以给数据库系统设置隔离级别，使各个事务隔离了再并发运行，这样它们不会相互影响，也避免各种并发问题。

详说并发问题：

脏读：对于两个事务T1、T2，T1读取了已经被T2更新但还没有被提交的字段，之后若T2回滚，T1读取的内容就是临时且无效的。
不可重复读：对于两个事务T1、T2，T1读取了一个字段，然后T2更新了该字段，之后T1再次读取同一个字段，值不相同。
幻读：对于两个事务T1、T2，T1从一个表中读取了一个字段，然后T2在该表中插入了一些新的行，之后如果T1再次读取同一个表，就会多处几行。（幻读针对已经插入数据的情况，注意跟脏读的情况不同。）

6.2 事务管理器

Spring 并不会直接管理事务，而是通过事务管理器对事务进行管理的。

PlatformTransactionManager 接口

PlatformTransactionManager 接口是 Spring 的事务管理器。Spring 为不同的持久化框架或平台（例如 JDBC、Hibernate、JPA 以及 JTA 等）提供了不同的 PlatformTransactionManager 接口实现。该接口的实现类被称为事务管理器实现，不同的 Dao 层技术则有不同的实现类：Dao 层技术是 Spring JDBC 或 MyBatis 时实现类是 org.springframework.jdbc.datasource.DataSourceTransactionManager ；Dao 层技术是 Hibernate 时实现类是 org.springframework.orm.hibernate5.HibernateTransactionManager 。

该接口有方法如下：

方法	说明
TransactionStatus getTransaction(TransactionDefinition definition)	获取事务的状态信息
void commit(TransactionStatus status)	提交事务
void rollback(TransactionStatus status)	回滚事务

TransactionDefinition 接口

TransactionDefinition 接口提供了获取事务相关信息的方法。

该接口有方法如下：

方法	说明
String getName()	获取事务的名称。
int getIsolationLevel()	获取事务的隔离级别。
int getPropagationBehavior()	获取事务的传播行为。
int getTimeout()	获取超时时间。默认值是-1，没有超时限制。如果有，以秒为单位进行设置。
boolean isReadOnly()	获取事务是否只读。建议查询时设置为只读。

事务隔离级别的取值有：

ISOLATION_DEFAULT，默认的隔离级别。
ISOLATION_READ_UNCOMMITTED，读未提交数据。允许事务读取未被其他事务提交的变更。脏读、不可重复读、幻读的问题都会出现。
ISOLATION_READ_COMMITTED，读已提交数据。只允许事务读取已经被其他事务提交的变更。可以避免脏读，但不可重复读和幻读问题仍然可能出现。
ISOLATION_REPEATABLE_READ，可重复读。确保事务可以多次从一个字段中读取相同的值，在这个事务维持期间，禁止其他事务对这个字段进行更新。可以避免脏读和不可重复读，但幻读问题仍然存在。
ISOLATION_SERIALIZABLE，串行化。确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入、更新、删除操作。所有并发问题都可以避免，但性能十分低下。

事务传播行为：就是多个事务方法相互调用时,事务如何在这些方法间传播。取值有：

REQUIRED，如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。默认值。
SUPPORTS，支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）。
MANDATORY，使用当前的事务，如果当前没有事务，就抛出异常。
REQUERS_NEW，新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED，以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER，以非事务方式运行，如果当前存在事务，抛出异常。
NESTED，如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。

TransactionStatus 接口

TransactionStatus 接口提供了一些简单的方法，来控制事务的执行、查询事务的状态。该接口是被动地封装事务状态信息，随着程序的进行内部信息也进行改变。

该接口有方法如下：

方法	说明
boolean hasSavePoint()	是否存储回滚点
boolean isCompleted()	事务是否完成
boolean isNewTransaction()	是否是新事务
boolean isRollbackOnly()	事务是否回滚
void setRollbackOnly()	设置事务回滚

6.3 Spring 支持2种事务管理方式

Spring 支持2种事务管理方式：

编程式事务管理：编程式事务管理是通过编写代码实现的事务管理。这种方式能够在代码中精确地定义事务的边界，我们可以根据需求规定事务从哪里开始，到哪里结束。
声明式事务管理：Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明相关规则，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。声明可以通过XML或者注解进行。Spring 声明式事务管理底层就是AOP。

声明式事务管理的作用：

事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可。
在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便。

Spring 声明式事务管理底层就是AOP，使用声明式事务管理需明确的三个事项：