AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

万字详解Spring框架

2022-08-25 258
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 学习SpringIOC,AOP两大特性以及衍生的相关知识点, 千万不要错过!!!

一、简介

Spring简介

Spring是为了 解决企业应用开发的复杂性 而创建的一个开源框架；是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
IoC : Inversion of Control 控制反转
AOP : Aspect Oriented Programming 依赖注入

常用jar包

1.spring-core.jar
core是spring框架基本的核心工具类。spring其他组件都要使用到这个jar的类。是其他组件的基本核心。外部依赖Commons Logging， (Log4J)。

2.spring-beans.jar
beans是基本的jar。他包含访问配置文件，创建和管理bean，以及控制反转，注入操作的所有相关类。如果只用到Ioc/DI，则只需引入core与beans就足够了。平常用的Autowired就是用的这个包的

3.spring-aop.jar
这个jar 文件包含在应用中使用Spring 的AOP 特性时所需的类和源码级元数据支持。使用基于AOP 的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。

4.spring-context.jar
这个 jar 文件为 Spring 核心提供了大量扩展。可以找到使用 Spring ApplicationContext 特性时所需的全部类， JDNI 所需的全部类， UI 方面的用来与模板 （Templating） 引擎如 Velocity、 FreeMarker、JasperReports 集成的类，以及校验 Validation 方面的相关类。

5.spring-webmvc.jar
这个 jar 文件包含 Spring MVC 框架相关的所有类。包含国际化、标签、Theme、视图展现的 FreeMarker、JasperReports、Tiles、Velocity、XSLT 相关类。当然，如果你的应用使用了 独立的 MVC 框架，则无需这个 JAR 文件里的任何类。

6.spring-jdbc.jar
这个jar 文件包含对Spring 对JDBC 数据访问进行封装的所有类。

7.spring-web.jar
这个jar 文件包含Web 应用开发时，用到Spring 框架时所需的核心类，包括自动载入Web Application Context 特性的类、Struts 与JSF 集成类、文件上传的支持类、Filter 类和大量工具辅助类。平时用到RequestMapping就是来自这个包的.

其他jar包
在这里插入图片描述

二、Spring-IOC（控制反转）

IOC简介

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。 控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。把对象的创建、初始化、 销毁等工作交给spring容器来做。由spring容器控制对象的生命周期。

Spring-IOC程序搭建步骤

1、导入jar包
2、创建spring配置文件（src目录下）
3、Bean的定义与注册
4、从spring容器中获取Bean

相关jar包
在这里插入图片描述

注：

 <!-- bean的定义:以下配置相当于创建一个类的对象。即：
 SomeServiceImpl someServiceImpl= new SomeServiceImpl(); -->
  <bean id="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean>

解决Spring配置文件没有提示

如果在没有网络的情况下，spring中基于联网的 .xsd配置文件的约束文件会无法使用，这样就需要我们其提前下载并手动添加到本地，步骤如下：
  • 找到XML Catalog，添加下载好的约束文件

在这里插入图片描述

  • 注意如下选项并保存

在这里插入图片描述

BeanFactory和ApplicationContext

关系

ApplicationContext 是 Spring 应用程序中的中央接口，用于向应用程序提供配置信息 它继承了 BeanFactory 接口，所以 ApplicationContext 包含 BeanFactory 的所有功能以及更多功能！它的主要功能是支持大型的业务应用的创建特性。

区别

BeanFactory当调用getBean获取相应对象时，才创建对象
ApplicationContext容器初始化时，所有的容器中的bean创建完毕

Bean的创建

在applicationContext.xml的< beans>标签中创建< bean>标签， 一个< bean>标签表示一个java对象 ，该对象由Spring容器创建和管理，

Bean标签的属性

标签 属性
id 唯一标示该bean
name 和id相同的作用
class 该类的权限定名，指向对于的类
autowire 表示bean的自动装配

Bean的装配方式

Bean的装配，即Bean对象的创建
Bean的装配方式有三种
第一种：spring从两个角度实现自动化装配：组件扫描和自动装配。
第二种：通过java代码装配bean
第三种：在XML中装配bean

动态装配方式

1、创建Bean对象
2、注册工厂，创建工厂对象
3、从工厂中获取someServiceImpl的bean对象 


public class ServiceFactory {
    
    //动态工厂方式，创建bean对象
    public SomeService getSomeFactory(){
        SomeService someServiceImpl=new SomeServiceImpl();
        
        return someServiceImpl;
    }
    
}

<!-- 注册工厂 -->
    <bean id="serviceFactory" class="com.bjsxt.factory.ServiceFactory"></bean>
    <!-- 从工厂中获取someServiceImpl的bean对象 -->
    <bean id="someServiceImpl" factory-bean="serviceFactory" factory-method="getSomeFactory"></bean>

public class SomeTest {
    
    //该方式的优点：实现了测试类与service实现类的解耦合
    @Test
    public void someTest01(){
        //创建容器对象,ApplicationContext容器初始化时，所有的容器中的bean创建完毕
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = ac.getBean("someServiceImpl", SomeService.class);
        service.doSome();
    }
    
}

静态装配方式

1、创建bean对象
2、从工厂中获取someServiceImpl的bean对象 
<!-- 静态工厂配置，类名对象，类名，方法 -->
    <bean id="someServiceImpl" class="com.bjsxt.factory.ServiceFactory" factory-method="getSomeFactory"></bean>

Bean的作用域

作用域名 作用
singleton 默认使用, 在整个Spring IoC 容器中，使用 singleton 定义的Bean将只有一个实例
prototype 原型模式,每次通过容器的getBean 方法获取prototype定义的Bean 时,都将产生一个新的Bean实例
request 对于每次HTTP请求，使用request定义的Bean都将产生一个新的实例，每次HTTP请求都将产生不同的Bean实例,该作用域仅在给予web的Spring ApplicationContext情形下有效
Session 对于每次HTTP Session ,使用session定义的Bean都将产生一个新实例，该作用域仅在给予web的Spring ApplicationContext情形下有效
global session 每个全局得HTTP Session对应一个Bean实例，该作用域仅在给予web的Spring ApplicationContext情形下有效

三、DI依赖注入

依赖注入(Dependency Injection)：这就是DI，字面上理解，依赖注入就是将服务注入到使用它的地方。对象只提供普通的方法让容器去决定依赖关系，相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。

所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

环境

演示所用的两个实体类

在这里插入图片描述
在这里插入图片描述

测试类的测试方法

    @Test
    public void someTest01(){
        //创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Star star =ac.getBean("star", Star.class);//getBean(id, class)
        System.out.println(star);
    }

简单类型注入

简单类型数据注入包括普通数据注入、引用数据类型注入 
<bean id="star" class="com.bjsxt.pojo.Star" >
        <!-- 简单数据类型  -->
        <property name="name" value="旭旭宝宝"></property>
        <property name="age"  value="39" ></property>
        <!-- 引用数据类型注入参考的是下面的id -->
        <property name="partener"  ref="partener" ></property>
    </bean>
    <bean id="partener" class="com.bjsxt.pojo.Partener" >
        <property name="name" value="韩茜茜"></property>
    </bean>

集合类型注入

每种集合类型使用的标签
在这里插入图片描述
简单案例

<bean id="someService" class="com.bjsxt.pojo.SomeService" >
        <property name="myArray">
            <array>
                <value>北京</value>
                <value>上海</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>男</value>
                <value>女</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <ref bean="partener1" />
                <ref bean="partener2" />
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="qq" value="1315690999"></entry>
                <entry key="moblie" value="18326989999"></entry>
            </map>
        </property>
        <property name="myProps">
            <props >
                <prop key="兴趣">看动漫</prop>
                <prop key="爱好">敲代码</prop>
            </props>
        </property>
    </bean>

域属性自动注入

域属性自动注入的方式
全局自动注入（根标签下） ：default-autowire
局部自动注入（注册bean时使用）： autowire="byType"

自动注入的类别

byName 方式域属性自动注入，根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配
byType 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配；如果存在多个该类型bean，那么抛出异常，并指出不能使用byType方式进行自动装配

空值注入

空字符串注入：通过value标签        <property name="name" ><value/></property>
空值注入：通过null标签            <property name="name" ><null/></property>

构造注入

    1、通过name属性的构造
    <constructor-arg name="name" value="郭靖"></constructor-arg>
    
    2、通过index属性的构造，但value的类型顺序必须与构造器中的类型一致
    <constructor-arg index="0" value="郭靖"></constructor-arg>
    
    3、自动构造，但value的类型顺序必须与构造器中的类型一致
    <constructor-arg  value="郭靖"></constructor-arg>

DI之注解

在使注解注入用前需要扫描使用注解的包

<context:component-scan base-package="com.bjsxt.pojo"></context:component-scan>

常用注解


@Service 该注解添加在 Service的实现类中

@Controller 该注解添加在 Controller类的前面，表明当前controller交给spring管理

@Autowired 引用数据类型注入，默认byType。常用于controller与service的实现类中

@Qualifier(“id”) 与@Autowired 联合使用 byName 方式注入

@Value 简单数据类型注入。常用于自定义配置文件中的值的引用。

@Resource 引用数据类型默认使用 byName 方式，若找不到名称匹配的bean ，才会采用 byType 方式

@Scope() 表明采取什么作用域。单态模式singleton：默认使用原型模式prototype：每次调用都会传建一个新的bean

四、Spring-AOP（面向切面）

介绍

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

代理模式

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
二十三种设计模式之一 ,详情见本连接第三部分

作用

可以隐藏目标类的具体实现
在不修改目标类代码的情况下能够对其功能进行增强。

分类

静态代理

测试静态代理，写一个接口，一个目标实现类，再写一个代理类也实现该接口，并将目标类对象传入代理类中，代理类调用目标类对象的方法。最后测试。
注意： 代理类与目标类实现相同的接口 
public class SomeTest {
    public static void main(String[] args) {
        //定义目标对象
        SomeService target = new SomeServiceImpl();
        //定义目标对象的代理对象
        SomeService proxy = new ServiceProxy(target);
        String result = proxy.doSome();
        System.out.println(result);
    }
}

jdk动态代理

动态代理不在程序中声明代理类代码，而是在运行中使用 Proxy 类 动态执行代理类的方法。
应用场景：目标类 
public class SomeTest {
    public static void main(String[] args) {
        //定义目标对象
        final SomeService target = new SomeServiceImpl();
        //定义目标对象的代理对象
        SomeService proxy = (SomeService) Proxy.newProxyInstance(target.getClass().getClassLoader(),//目标类的类加载器
            target.getClass().getInterfaces(),//目标类实现的所有接口
            new InvocationHandler() {//调用处理器
                //proxy:代理对象
                //method:目标方法
                //args:目标方法参数
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    String result = (String) method.invoke(target, args);
                    return result.toUpperCase();
                }
            });
        String result1 = proxy.doSome();
        System.out.println(result1);
    }
}

cglib动态代理

应用场景： 实现目标类没有实现目标接口
注意： CGLIB 代理需要引入 cglib 架包 
public class SomeTest {
    public static void main(String[] args) {
        //定义目标对象
        SomeServiceImpl target = new SomeServiceImpl();
        //定义目标对象的代理对象
        SomeServiceImpl proxy = new CglibProxyFactory(target).proxyCreator();
        String result1 = proxy.doSome();
        System.out.println(result1);
    }
}

基于Schema-based方式的通知声明

搭建编程环境

  1. 导入jar包(SpringIOC包+AOP包)
  2. 在src下创建applicationcontext.xml配置文件
  3. 编写通知类.相关的接口 ,实现类以及方法
  4. 由Spring容器对象获取切点所在bean对象调用切点方法完成功能操作。(注册通知类 注册切面 指定目标对象 指定目标接口 指定切面)
  5. 运行测试

接口类

public interface SomeService {
    void doSome();
    String doOther();
}

实现类

public class SomeServiceImpl implements SomeService {
    
    
    public SomeServiceImpl() {
        System.out.println("无参构造器执行！");
    }

    @Override
    public void doSome() {
        System.out.println("doSome()方法执行！");
    }

    @Override
    public String doOther() {
        System.out.println("doOther()方法执行！");
        return "return doOther";
    }

}

测试方法类


public class SomeTest {
    
    
    //该方式的优点：实现了测试类与service实现类的解耦合
    @Test
    public void someTest01(){
        //创建容器对象,ApplicationContext容器初始化时，所有的容器中的bean创建完毕
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = ac.getBean("proxyFactoryBean", SomeService.class);
        service.doSome();
        String result = service.doOther();
        System.out.println(result);
        
    
    }
    

}

配置文件

<?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="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean>
<!-- 注册切面，前置通知 -->
<bean id="myMethodBeforeAdvice" class="com.bjsxt.aspects.MyMethodBeforeAdvice"></bean>
<!-- 注册切面，后置通知 -->
<bean id="afterReturning" class="com.bjsxt.aspects.AfterReturning"></bean>
<!-- 注册切面，环绕通知 -->
<bean id="myMethodInterceptor" class="com.bjsxt.aspects.MyMethodInterceptor"></bean>
<!-- 注册切面，异常通知 -->
<bean id="myThrowsAdvice" class="com.bjsxt.aspects.MyThrowsAdvice"></bean>
<!-- 注册代理 -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 指定目标对象 -->
    <property name="target" ref="someServiceImpl"></property>
    <!-- 指定目标类实现所有接口,接口,接口所在类 -->
    <property name="interfaces" value="com.bjsxt.service.SomeService"></property>
    <!-- 指定切面 -->
    <!-- <property name="interceptorNames" value="myMethodBeforeAdvice"></property> -->
    <!-- <property name="interceptorNames" value="afterReturning"></property> -->
     <property name="interceptorNames" value="myMethodInterceptor"></property> 
    <!-- <property name="interceptorNames" value="myThrowsAdvice"></property> -->
</bean>

</beans>

前置通知

/**
     * 前置通知
     * method：目标方法
     * args：目标方法参数列表
     * target：目标对象
     */
public class MyMethodBeforeAdvice  implements MethodBeforeAdvice{
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("MyMethodBeforeAdvice.before(前置通知执行)");
        
    }

    

}

后置通知

/**
 * 后置通知
 * returnValue：目标方法的返回值
 *
 */
public class AfterReturning  implements AfterReturningAdvice{
    
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("AfterReturning.afterReturning(后置通知方法的执行)"+returnValue);
        
        if (returnValue!=null) {
            System.out.println("AfterReturning.afterReturning()"+((String)returnValue).toUpperCase());
        }
    }

}

环绕通知

/**
 * 切面：环绕通知
 * invocation：方法调用器
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation ) throws Throwable {
        
        System.out.println("环绕通知:目标方法执行之前");
        //调用执行目标方法
        Object result = invocation.proceed();
        if (result!=null) {
            result=((String)result).toUpperCase();
        }
        System.out.println("环绕通知:目标方法执行之后");
        return result;
    }

}

异常通知

/**
 * 切面：异常通知
 * 需要自己创建
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing(Exception ex) {
        System.out.println("异常通知执行！！！");
    }
}

基于AspectJ方式之注解的方式通知声明

搭建编程环境

  1. 创建目标类(接口以及实现类测试类)
  2. 定义通知类,在前置通知方法上添加相应的注解，表示是什么通知
  3. 创建配置文件(注册目标类，注册切面，注册自动代理)
  4. 运行测试类

接口类

public interface SomeService {
    void doSome();
    String doOther();
}

实现类

public class SomeServiceImpl implements SomeService {
    
    
    public SomeServiceImpl() {
        System.out.println("无参构造器执行！");
    }

    @Override
    public void doSome() {
        System.out.println("doSome()方法执行！"+1/0);
        //System.out.println("doSome()方法执行！");
    }

    @Override
    public String doOther() {
        System.out.println("doOther()方法执行！");
        return "love";
    }

}

测试类

public class SomeTest {
    
    @Test
    public void someTest01(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        SomeService service = ac.getBean("someServiceImpl", SomeService.class);
        service.doSome();
        String result = service.doOther();
        System.out.println(result);
    }
}

配置文件

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

    <!-- 注册目标类 -->
    <bean id="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean>
    <!-- 注册切面 -->
    <bean id="myAspect" class="com.bjsxt.aspects.MyAspect"></bean>
    <!-- 注册自动代理 -->
    <aop:aspectj-autoproxy/>
    
</beans>

前置通知

@Before("execution(* *..service.*.doSome(..))")
    public void before(){
        System.out.println("前置通知方法执行！");
    }

后置通知

@AfterReturning(value="execution(* *..service.*.doOther(..))",returning="result")
    public void afterReturning(Object result){
        System.out.println("后置通知方法执行！ 目标方法的返回值是"+result);
    }

环绕通知

@Around("execution(* *..service.*.doOther(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知：目标方法执行之前！");
        String result = (String) pjp.proceed();
        if(result!=null){
            result = result.toUpperCase();
            
        }

异常通知

@AfterThrowing(valujavae="execution(* *..service.*.doSome(..))",throwing="ex")
    public void throwing(Exception ex){
        System.out.println("异常通知方法执行！ 异常信息为："+ex);
    }

最终通知

@After("execution(* *..service.*.doSome(..))")
    public void after(){
        System.out.println("最终通知方法执行！");
        System.out.println("最终方法的作用是，无论是否出现异常，都会执行该通知。类似try...catch中的finally代码块");
    }

基于AspectJ方式之配置文件的方式通知声明

通知类的声明


public class MyAspect {
    //该注解表明当前方法是前置通知方法
    /*
    public void before(){
        System.out.println("前置通知方法执行！");
    }
    public void before(JoinPoint jp){
        System.out.println("前置通知方法执行！jp="+jp);
    }
    */
    //该注解表明当前方法是后置通知方法
    /*
    public void afterReturning(Object result){
        System.out.println("后置通知方法执行！ 目标方法的返回值是"+result);
    }
    */
    //该注解表明当前方法是环绕通知方法
    /*
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕通知：目标方法执行之前！");
        String result = (String) pjp.proceed();
        if(result!=null){
            result = result.toUpperCase();
            
        }
        System.out.println("环绕通知：目标方法执行之后！");
        return result;
    }
    */
    //该注解表明当前方法是异常通知方法
    /*
    public void throwing(Exception ex){
        System.out.println("异常通知方法执行！ 异常信息为："+ex);
    }
    */
    //该注解表明当前方法是最终通知方法
    
    public void after(){
        System.out.println("最终通知方法执行！");
    }
    
}

配置文件的声明

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

    <!-- 注册目标类 -->
    <bean id="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean>
    <!-- 注册切面 -->
    <bean id="myAspect" class="com.bjsxt.aspects.MyAspect"></bean>
    <!-- AOP配置 -->
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut expression="execution(* *..service.*.doSome(..))" id="doSomePC"/>
        <aop:pointcut expression="execution(* *..service.*.doOther(..))" id="doOtherPC"/>
        <aop:aspect ref="myAspect">
            <!-- <aop:before method="before" pointcut-ref="doSomePC"/> -->
            <!-- <aop:before method="before(org.aspectj.lang.JoinPoint)" pointcut-ref="doSomePC"/> -->
            <!-- <aop:after-returning method="afterReturning(java.lang.Object)" pointcut-ref="doOtherPC" returning="result"/> -->
            <!-- <aop:around method="around" pointcut-ref="doOtherPC"/> -->
            <!-- <aop:after-throwing method="throwing(java.lang.Exception)" pointcut-ref="doSomePC" throwing="ex"/> -->
            <aop:after method="after" pointcut-ref="doSomePC"/>
        </aop:aspect>
    </aop:config>
    
</beans>

五、Spring的事物管理

事物的ACID特性

特性 介绍
原子性(Atomicity) 一个事务里面所有包含的SQL语句是一个执行整体，不可分割，要么都做，要么都不做。
一致性(Consistency) 事务开始时，数据库中的数据是一致的，事务结束时，数据库的数据也应该是一致的。
隔离性(Isolation) 是指数据库允许多个并发事务同时对其中的数据进行读写和修改的能力，隔离性可以防止事务的并发执行时，由于他们的操作命令交叉执行而导致的数据不一致状态。
持久性 (Durability) : 是指当事务结束后，它对数据库中的影响是永久的，即便系统遇到故障的情况下，数据也不会丢失。

DataSourceTransactionManager与HibernateTransactionManager

名称 区别
DataSourceTransactionManager 此事务管理器是针对传统的JDBC进行事务管理，在spring中是对JdbcTemplate进行事务管理
HibernateTransactionManager 是对Hibernate进行事务管理，当在spring中使用HibernateTemplate时，要使用此管理器。

注:当在service的一个方法中同时使用了JdbcTemplate和HibernateTemplate时，就要使用HibernateTransactionManager了，因为当使用DataSourceTransactionManager时，JdbcTemplate和HibernateTemplate获得的connection并不是同一个，也就没办法对service的方法进行事务管理了。

TransactionDefinition接口

Spring的TransactionDefinition接口中定义了如下事务相关常量

常量名 | 作用

int getPropagationBehavior(); 返回事务的传播行为
int getIsolationLevel(); 返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
String getName()； 返回事务的名字
int getTimeout(); 返回事务必须在多少秒内完成
boolean isReadOnly(); 返回是否优化为只读事务。

事物的传播行为

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。
例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

TransactionDefinition定义中包括了如下几个表示传播行为的常量：

常量 作用
TransactionDefinition.PROPAGATION_REQUIRED： 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
TransactionDefinition.PROPAGATION_SUPPORTS： 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_MANDATORY： 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

不支持当前事务的情况：

常量 作用
TransactionDefinition.PROPAGATION_REQUIRES_NEW： 创建一个新的事务，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED： 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER： 以非事务方式运行， 如果当前存在事务，则抛出异常。

其他情况

常量 作用
TransactionDefinition.PROPAGATION_NESTED： 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED（创建一个新的事务）。
文章标签：
DDoS防护
Java
前端开发
容器
SQL
Spring
数据格式
数据库
XML
数据库连接
设计模式
关键词：
Spring框架
时间静止不是简史
目录
相关文章
喜欢猪猪
|
21天前
|
XML 安全 Java
深度探索Spring Context：框架式的Bean访问与企业级功能
【12月更文挑战第1天】
喜欢猪猪
35 1
wljslmz
|
24天前
|
缓存 NoSQL Java
什么是缓存？如何在 Spring Boot 中使用缓存框架
什么是缓存？如何在 Spring Boot 中使用缓存框架
wljslmz
33 0
高端源码库
|
1月前
|
数据采集 监控 前端开发
二级公立医院绩效考核系统源码，B/S架构，前后端分别基于Spring Boot和Avue框架
医院绩效管理系统通过与HIS系统的无缝对接，实现数据网络化采集、评价结果透明化管理及奖金分配自动化生成。系统涵盖科室和个人绩效考核、医疗质量考核、数据采集、绩效工资核算、收支核算、工作量统计、单项奖惩等功能，提升绩效评估的全面性、准确性和公正性。技术栈采用B/S架构，前后端分别基于Spring Boot和Avue框架。
高端源码库
78 5
龙大吉
|
2月前
|
Java API 数据库
构建RESTful API已经成为现代Web开发的标准做法之一。Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐。
【10月更文挑战第11天】本文介绍如何使用Spring Boot构建在线图书管理系统的RESTful API。通过创建Spring Boot项目，定义`Book`实体类、`BookRepository`接口和`BookService`服务类，最后实现`BookController`控制器来处理HTTP请求，展示了从基础环境搭建到API测试的完整过程。
龙大吉
59 4
众所周知
|
2月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，包括版本兼容性、安全性、性能调优等方面。
众所周知
178 1
龙大吉
|
2月前
|
Java API 数据库
Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐
本文通过在线图书管理系统案例，详细介绍如何使用Spring Boot构建RESTful API。从项目基础环境搭建、实体类与数据访问层定义，到业务逻辑实现和控制器编写，逐步展示了Spring Boot的简洁配置和强大功能。最后，通过Postman测试API，并介绍了如何添加安全性和异常处理，确保API的稳定性和安全性。
龙大吉
45 0
蓝易云
|
6天前
|
IDE Java 测试技术
互联网应用主流框架整合之Spring Boot开发
通过本文的介绍，我们详细探讨了Spring Boot开发的核心概念和实践方法，包括项目结构、数据访问层、服务层、控制层、配置管理、单元测试以及部署与运行。Spring Boot通过简化配置和强大的生态系统，使得互联网应用的开发更加高效和可靠。希望本文能够帮助开发者快速掌握Spring Boot，并在实际项目中灵活应用。
蓝易云
24 5
喜欢猪猪
|
17天前
|
缓存 Java 数据库连接
Spring框架中的事件机制：深入理解与实践
Spring框架是一个广泛使用的Java企业级应用框架，提供了依赖注入、面向切面编程（AOP）、事务管理、Web应用程序开发等一系列功能。在Spring框架中，事件机制是一种重要的通信方式，它允许不同组件之间进行松耦合的通信，提高了应用程序的可维护性和可扩展性。本文将深入探讨Spring框架中的事件机制，包括不同类型的事件、底层原理、应用实践以及优缺点。
喜欢猪猪
47 8
dufadayang
|
26天前
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架，实现分布式事务的管理和处理。在实际应用中，还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时，要注意处理各种可能出现的问题，以保障分布式事务的顺利执行。
dufadayang
46 6
路卿老师
|
1月前
|
Java 数据库连接 数据库
不可不知道的Spring 框架七大模块
Spring框架是一个全面的Java企业级应用开发框架，其核心容器模块为其他模块提供基础支持，包括Beans、Core、Context和SpEL四大子模块；数据访问及集成模块支持数据库操作，涵盖JDBC、ORM、OXM、JMS和Transactions；Web模块则专注于Web应用，提供Servlet、WebSocket等功能；此外，还包括AOP、Aspects、Instrumentation、Messaging和Test等辅助模块，共同构建强大的企业级应用解决方案。
路卿老师
59 2

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    spring入门
  • 4
    Spring Cloud 统一配置
  • 5
    [Spring]支持注解的Spring调度器
  • 6
    定义全局异常处理器 | 带你读《SpringBoot实战教程》之十三
  • 7
    Spring基础笔记
  • 8
    springboot高级功能（三）自定义注解实现方式全解析
  • 9
    Spring Aware容器感知技术
  • 10
    Current O2 support for analyzing Spring MVC
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    97
  • 2
    Spring Boot中一般如何使用线程池？
    757
  • 3
    Spring Boot 源码面试知识点
    101
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    254
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot全局自定义异常
    44
  • 8
    RabbitMQ的springboot项目集成使用-01
    147
  • 9
    什么是Spring Boot 自动配置？
    60
  • 10
    Spring cloud原理详解
    79

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks售前咨询