【必知必会的Spring框架知识体系】

已于 2022-10-06 19:00:44 修改
阅读量658 收藏 4
点赞数 2
分类专栏： Spring必须掌握的知识体系 文章标签： spring java 后端
于 2022-10-02 19:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Coder_ljw/article/details/127140458
版权

Spring框架的发展历程？

Spring框架的发展历程

Spring的组成？

Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置.

主要由以下几个模块组成：

  • Spring Core：核心类库，提供IOC服务；
  • Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；
  • Spring AOP：AOP服务；
  • Spring DAO：对JDBC的抽象，简化了数据访问异常的处理；
  • Spring ORM：对现有的ORM框架的支持；
  • Spring Web：提供了基本的面向Web的综合特性，例如多方文件上传；
  • Spring MVC：提供面向Web应用的Model-View-Controller实现。
    Spring的组成

Spring有什么优势？

序号好处说明
1轻量Spring 是轻量的，基本的版本大约2MB。
2控制反转Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
3面向切面编程(AOP)Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
4容器Spring 包含并管理应用中对象的生命周期和配置。
5MVC框架Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
6事务管理Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
7异常处理Spring 提供方便的API把具体技术相关的异常 (比如由JDBC，Hibernate or JDO抛出的)转化为一致的unchecked 异常。
8最重要的用的人多！！！

什么是Spring的IOC？DI又是什么？Spring中IOC的底层原理？

控制反转：理论思想，原来的对象是由使用者来进行控制，有了spring之后，可以把整个对象交给spring来帮我们进行管理

​ DI：依赖注入，把对应的属性的值注入到具体的对象中，@Autowired，populateBean完成属性值的注入

容器：存储对象，使用map结构来存储，在spring中一般存在三级缓存，singletonObjects存放完整的bean对象,

​ 整个bean的生命周期，从创建到使用到销毁的过程全部都是由容器来管理（bean的生命周期）
IOC的底层实现？
createBeanFactory，getBean,doGetBean,createBean,doCreateBean,createBeanInstance(getDeclaredConstructor,newinstance),populateBean,initializingBean

1、先通过createBeanFactory创建出一个Bean工厂（DefaultListableBeanFactory）

2、开始循环创建对象，因为容器中的bean默认都是单例的，所以优先通过getBean,doGetBean从容器中查找，找不到的话，

3、通过createBean,doCreateBean方法，以反射的方式创建对象，一般情况下使用的是无参的构造方法（getDeclaredConstructor，newInstance）

4、进行对象的属性填充populateBean

5、进行其他的初始化操作（initializingBean）

什么是Spring的AOP?

先：aop概念，应用场景，动态代理
概念:面向切面的编程思想，aop是ioc的一个扩展功能，先有的ioc，再有的aop，只是在ioc的整个流程中新增的一个扩展点而已：BeanPostProcessor
应用场景:权限认证 日志 事务 监测
动态代理：通过jdk或者cglib的方式来生成代理对象

后：
补充扩展实现的过程：
​ bean的创建过程中有一个步骤可以对bean进行扩展实现，aop本身就是一个扩展功能，所以在BeanPostProcessor的后置处理方法中来进行实现:

​ 1、代理对象的创建过程（advice—通知，切面，切点,连接点）

  • 通知是指一个切面在特定的连接点要做的事情。通知分为方法执行前通知，方法执行后通知，环绕通知等。许多 AOP 框架(包括 Spring)都将通知建模为拦截器，在连接点周围维护一系列拦截器(形成拦截器链)，对连接点的方法进行增强。
  • 切点：一个匹配连接点(Join point)的谓词表达式。通知(Advice)与切点表达式关联，并在切点匹配的任何连接点(Join point)(例如，执行具有特定名称的方法)上运行。切点是匹配连接点(Join point)的表达式的概念，是AOP的核心，并且 Spring 默认使用 AspectJ 作为切入点表达式语言。
  • 切面:它是一个跨越多个类的模块化的关注点，它是通知(Advice)和切点(Pointcut)合起来的抽象，它定义了一个切点(Pointcut)用来匹配连接点(Join point)，也就是需要对需要拦截的那些方法进行定义；它定义了一系列的通知(Advice)用来对拦截到的方法进行增强。
  • Join point(连接点): 程序执行期间的某一个点，例如执行方法或处理异常时候的点。在 Spring AOP 中，连接点总是表示方法的执行。

​ 2、通过jdk或者cglib的方式来生成代理对象

​ 3、在执行方法调用的时候，会调用到生成的字节码文件中，直接回找到DynamicAdvisoredInterceptor类中的intercept方法，从此方法开始执行—真正执行的过程

​ 4、根据之前定义好的通知来生成拦截器链

​ 5、从拦截器链中依次获取每一个通知开始进行执行，在执行过程中，为了方便找到下一个通知是哪个，会有一个CglibMethodInvocation的对象，找的时候是从-1的位置一次开始查找并且执行的。

Spring中的Bean对象的生命周期？

Bean对象的生命周期

介绍下Spring的初始化过程？

spring初始化的过程

谈谈你对Bean Factory和Factory Bean的理解

相同点：都是用来创建bean对象的

不同点：使用BeanFactory创建对象的时候，必须要遵循严格的生命周期流程，太复杂了
如果想要简单的自定义某个对象的创建，同时创建完成的对象想交给spring来管理，那么就需要实现FactroyBean接口了，简化版

​ isSingleton:是否是单例对象

​ getObjectType:获取返回对象的类型

​ getObject:自定义创建对象的过程(new，反射，动态代理)

Spring中用到了哪些设计模式？

  1. 单例模式
    单例模式应该是大家印象最深的一种设计模式了。在Spring中最明显的使用场景是在配置文件中配置注册bean对象的时候设置scope的值为singleton 。
<?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.demo.ljw.User" id="user" scope="singleton">
		<property name="name" value="apple"></property>
	</bean>
</beans>
  1. 原型模式
    原型模式也叫克隆模式，Spring中该模式使用的很明显，和单例一样在bean标签中设置scope的属性prototype即表示该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 class="com.demo.ljw.User" id="user" scope="prototype">
		<property name="name" value="banana"></property>
	</bean>
</beans>
  1. 模板模式的核心是父类定义好流程，然后将流程中需要子类实现的方法就抽象话留给子类实现，Spring中的JdbcTemplate就是这样的实现。我们知道jdbc的步骤是固定
  • 加载驱动,
  • 获取连接通道,
  • 构建sql语句.
  • 执行sql语句,
  • 关闭资源

在这些步骤中第3步和第四步是不确定的,所以就留给客户实现，而我们实际使用JdbcTemplate的时候也确实是只需要构建SQL就可以了.这就是典型的模板模式。我们以query方法为例来看下JdbcTemplate中的代码.

image.png

  1. 观察者模式

  观察者模式定义的是对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。使用比较场景是在监听器中而spring中Observer模式常用的地方也是listener的实现。如ApplicationListener.

image.png

  1. 工厂模式

简单工厂模式：

  简单工厂模式就是通过工厂根据传递进来的参数决定产生哪个对象。Spring中我们通过getBean方法获取对象的时候根据id或者name获取就是简单工厂模式了。

<?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-4.3.xsd">

	<context:annotation-config/>
	<bean class="com.demo.ljw.User" id="user"  >
		<property name="name" value="apple"></property>
	</bean>
</beans>

工厂方法模式：

  在Spring中我们一般是将Bean的实例化直接交给容器去管理的，实现了使用和创建的分离，这时容器直接管理对象，还有种情况是，bean的创建过程我们交给一个工厂去实现，而Spring容器管理这个工厂。这个就是我们讲的工厂模式，在Spring中有两种实现一种是静态工厂方法模式，一种是动态工厂方法模式。以静态工厂来演示

/**
 * User 工厂类
 */
public class UserFactory {

	/**
	 * 必须是static方法
	 * @return
	 */
	public static UserBean getInstance(){
		return new UserBean();
	}
}

application.xml文件中注册

<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.demo.factory.UserFactory" factory-method="getInstance" id="user2"/>
</beans>
  1. 适配器模式

  将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。这就是适配器模式。在Spring中在AOP实现中的Advice和interceptor之间的转换就是通过适配器模式实现的。

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		// 通知类型匹配对应的拦截器
		return new MethodBeforeAdviceInterceptor(advice);
	}
}
  1. 装饰者模式

  装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。
  spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。
  具体的使用在Spring session框架中的SessionRepositoryRequestWrapper使用包装模式对原生的request的功能进行增强，可以将session中的数据和分布式数据库进行同步，这样即使当前tomcat崩溃，session中的数据也不会丢失。

<dependency>
	<groupId>org.springframework.session</groupId>
	<artifactId>spring-session</artifactId>
	<version>1.3.1.RELEASE</version>
</dependency>
  1. 代理模式

  代理模式应该是大家非常熟悉的设计模式了，在Spring中AOP的实现中代理模式使用的很彻底.

  1. 策略模式

  策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法，spring中在实例化对象的时候用到Strategy模式。XmlBeanDefinitionReader,PropertiesBeanDefinitionReader

  1. 责任链默认

AOP中的拦截器链

  1. 委托者模式

DelegatingFilterProxy，整合Shiro，SpringSecurity的时候都有用到。

循环依赖的基本概念？最基本的循环依赖的例子？循环依赖的例子

上图是循环依赖的三种情况，虽然方式有点不一样，但是循环依赖的本质是一样的，就你的完整创建要依赖与我，我的完整创建也依赖于你。相互依赖从而没法完整创建造成失败。

我们再通过代码的方式来演示下循环依赖的效果

public class CircularTest {

    public static void main(String[] args) {
        new CircularTest1();
    }
}
class CircularTest1{
    private CircularTest2 circularTest2 = new CircularTest2();
}

class CircularTest2{
    private CircularTest1 circularTest1 = new CircularTest1();
}

执行后然后不出意外出现了 StackOverflowError 错误;
上面的就是最基本的循环依赖的场景，你需要我，我需要你，然后就报错了。而且上面的这种设计情况我们是没有办法解决的。那么针对这种场景我们应该要怎么设计呢？这个是关键！

分析问题:
 首先我们要明确一点就是如果这个对象A还没创建成功，在创建的过程中要依赖另一个对象B，而另一个对象B也是在创建中要依赖对象A，这种肯定是无解的，这时我们就要转换思路，我们先把A创建出来，但是还没有完成初始化操作，也就是这是一个半成品的对象，然后在赋值的时候先把A暴露出来，然后创建B，让B创建完成后找到暴露的A完成整体的实例化，这时再把B交给A完成A的后续操作，从而揭开了循环依赖的密码。也就是如下图：

解决问题的思路过程

自己解决
  明白了上面的本质后，我们可以自己来尝试解决下：
先来把上面的案例改为set/get来依赖关联

public class Test{

    public static void main(String[] args) throws Exception{
        System.out.println(getBean(Test1.class).getTest2());
        System.out.println(getBean(Test2.class).getTest1());
    }

    private static <T> T getBean(Class<T> beanClass) throws Exception{
        // 1.获取 实例对象
        Object obj = beanClass.newInstance();
        // 2.完成属性填充
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        // 遍历处理
        for (Field field : declaredFields) {
            field.setAccessible(true); // 针对private修饰
            // 获取成员变量 对应的类对象
            Class<?> fieldClass = field.getType();
            // 获取对应的 beanName
            String fieldBeanName = fieldClass.getSimpleName().toLowerCase();
            // 给成员变量赋值 如果 singletonObjects 中有半成品就获取，否则创建对象
            field.set(obj,getBean(fieldClass));
        }
        return (T) obj;
    }
}

class Test1{
    private Test2 test2;

    public Test2 getTest2() {
        return test2;
    }

    public void setTest2(Test2 test2) {
        this.test2= test2;
    }
}

class Test2{
    private Test1 test1;

    public Test1 gettest1() {
        return test1;
    }

    public void setTest1(Test1 test1) {
        this.test1 = test1;
    }
}

然后我们再通过把对象实例化和成员变量赋值拆解开来处理。从而解决循环依赖的问题

public class Test {
    // 保存提前暴露的对象，也就是半成品的对象
    private final static Map<String,Object> singletonObjects = new ConcurrentHashMap<>();

    public static void main(String[] args) throws Exception{
        System.out.println(getBean(Test1.class).getTest2());
        System.out.println(getBean(Test2.class).getTest1());
    }

    private static <T> T getBean(Class<T> beanClass) throws Exception{
        //1.获取类对象对应的名称
        String beanName = beanClass.getSimpleName().toLowerCase();
        // 2.根据名称去 singletonObjects 中查看是否有半成品的对象
        if(singletonObjects.containsKey(beanName)){
            return (T) singletonObjects.get(beanName);
        }
        // 3. singletonObjects 没有半成品的对象，那么就反射实例化对象
        Object obj = beanClass.newInstance();
        // 还没有完整的创建完这个对象就把这个对象存储在了 singletonObjects中
        singletonObjects.put(beanName,obj);
        // 属性填充来补全对象
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        // 遍历处理
        for (Field field : declaredFields) {
            field.setAccessible(true); // 针对private修饰
            // 获取成员变量 对应的类对象
            Class<?> fieldClass = field.getType();
            // 获取对应的 beanName
            String fieldBeanName = fieldClass.getSimpleName().toLowerCase();
            // 给成员变量赋值 如果 singletonObjects 中有半成品就获取，否则创建对象
            field.set(obj,singletonObjects.containsKey(fieldBeanName)?
                    singletonObjects.get(fieldBeanName):getBean(fieldClass));
        }
        return (T) obj;
    }
}

class Test1{
    private Test2 test2;

    public Test2 getTest2() {
        return test2;
    }

    public void setTest2(Test2 test2) {
        this.test2= test2;
    }
}

class Test2{
    private Test1 test1;

    public Test1 gettest1() {
        return test1;
    }

    public void setTest1(Test1 test1) {
        this.test1 = test1;
    }
}

运行程序问题完美的解决了：上面的方法中的核心是getBean方法，Test1 创建后填充属性时依赖Test2，那么就去创建 Test2，在创建 Test2 开始填充时发现依赖于 Test1，但此时 Test1 这个半成品对象已经存放在缓存到 singletonObjects 中了，所以Test2可以正常创建，在通过递归把 Test1 也创建完整了。

最后总结下该案例解决的本质：

解决问题的实质

什么是Spring的循环依赖？(大厂必问的一个知识)

基于前面案例的了解，我们知道肯定需要在调用构造方法方法创建完成后再暴露对象，在Spring中提供了三级缓存来处理这个事情，对应的处理节点如下图：
Bean对象生命周期中使用三级缓存解决循环依赖的问题

Spring中的三级缓存依赖？

疑问点?这些疑问点也是面试官喜欢问的问题点?

为什么需要三级缓存？
三级缓存主要处理的是AOP的代理对象，存储的是一个ObjectFactory

三级缓存考虑的是代理对象，而二级缓存考虑的是性能-从三级缓存的工厂里创建出对象，再扔到二级缓存（这样就不用每次都要从工厂里拿）

没有三级环境能解决吗？
有代理对象需要三级缓存，没有代理对象二级缓存就可以解决相关的问题
没有三级缓存是可以解决循环依赖问题的，二级缓存也是可以解决循环依赖的
Spring 需要三级缓存的目的是为了在没有循环依赖的情况下，延迟代理对象的创建；
第三级缓存的目的是为了延迟代理对象的创建，因为如果没有依赖循环的话，那么就不需要为其提前创建代理，可以将它延迟到初始化完成之后再创建。
既然目的只是延迟的话，那么我们是不是可以不延迟创建，而是在实例化完成之后，就为其创建代理对象，这样我们就不需要第三级缓存了。

既然二级缓存可以解决问题？为什么还要使用三级缓存呢？
如果要使用二级缓存解决循环依赖，意味着所有Bean在实例化后就要完成AOP代理，这样违背了Spring设计的原则，Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理，而不是在实例化后就立马进行AOP代理。

三级缓存分别什么作用？
一级缓存：正式对象

二级缓存：半成品对象

三级缓存：工厂

Spring中常用的注解？

@Controller @Service @RestController @RequestBody,@Index @Import等

@Indexed提升 @ComponentScan的效率

@Import注解本身的由来是在Spring3.0的时候由xml文件的方式向注解编程的发展，替换以前在配置文件中的/<import>标签 ，也就是可以导入其他的配置类，然后@Import注解还扩展了对应的功能

静态注入：可以直接把对应的类型注入到容器中:@Import(User.class)

动态注入：可以实现ImportSelector接口和ImportBeanDefinitionRegistrar接口，然后通过重写对应的方法来实现动态的注入

当然在ImportSelector接口的实现还可以触发延迟加载的逻辑。DeferredImportSelector，这块在SpringBoot的自动装配中就应用到了

@Indexed注解是spring5.0演化而来的，是通过索引提高我们的检索效率的
首先下pom.xml文件中导入indexer的依赖，然后编译过后会在target目录下，生成一个META-INF/spring.components的文件，文件目录下是全类路径对应的被indexed修饰的注解对应的类，原来项目可能在启动的时候需要加载n次，现在直接生成在文件中，只需要加载一次，大大提升了我们项目启动的效率

Autowired和Resource关键字的区别？

这是一个相对比较简单的问题，@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。

3.1 共同点
  两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法.

3.2 不同点
@Autowired

@Autowired为Spring提供的注解，需要导入org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

public class TestServiceImpl {
 // 下面两种@Autowired只要使用一种即可
 @Autowired
 private UserDao userDao; // 用于字段上
 
 @Autowired
 public void setUserDao(UserDao userDao) { // 用于属性的方法上
 this.userDao = userDao;
 }
}

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualififier注解一起使用。如下：

public class TestServiceImpl {
 @Autowired
 @Qualifier("userDao")
 private UserDao userDao; 
}

@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略.

public class TestServiceImpl {
 // 下面两种@Resource只要使用一种即可
 @Resource(name="userDao")
 private UserDao userDao; // 用于字段上
 
 @Resource(name="userDao")
 public void setUserDao(UserDao userDao) { // 用于属性的setter方法上
 this.userDao = userDao;
 }
}

@Resource装配顺序：

如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。
@Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

Spring中支持几种作用域

Spring容器中的bean可以分为5个范围：

prototype：为每一个bean请求提供一个实例。
singleton：默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护。
request：为每一个网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。
session：与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。
global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

说说事务的隔离级别

事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：

问题描述
脏读一个事务读到另一个事务未提交的更新数据，所谓脏读，就是指事务A读到了事务B还没有提交的数据，比如银行取钱，事务A开启事务，此时切换到事务B，事务B开启事务–>取走100元，此时切换回事务A，事务A读取的肯定是数据库里面的原始数据，因为事务B取走了100块钱，并没有提交，数据库里面的账务余额肯定还是原始余额，这就是脏读
幻读是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。 同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象 发生了幻觉一样。
不可重复读在一个事务里面的操作中发现了未被操作的数据 比方说在同一个事务中先后执行两条一模一样的select语句，期间在此次事务中没有执行过任何DDL语句，但先后得到的结果不一致，这就是不可重复读

Spring支持的隔离级别

隔离级别描述
DEFAULT使用数据库本身使用的隔离级别 &#x3c;br> ORACLE（读已提交） MySQL（可重复读）
READ_UNCOMITTED读未提交（脏读）最低的隔离级别，一切皆有可能。
READ_COMMITED读已提交，ORACLE默认隔离级别，有幻读以及不可重复读风险。
REPEATABLE_READ可重复读，解决不可重复读的隔离级别，但还是有幻读风险。
SERLALIZABLE串行化，最高的事务隔离级别，不管多少事务，挨个运行完一个事务的所有子事务之后才可以执行另外一个事务里面的所有子事务，这样就解决了脏读、不可重复读和幻读的问题了

再必须强调一遍，不是事务隔离级别设置得越高越好，事务隔离级别设置得越高，意味着势必要花手段去加锁用以保证事务的正确性，那么效率就要降低，因此实际开发中往往要在效率和并发正确性之间做一个取舍，一般情况下会设置为READ_COMMITED，此时避免了脏读，并发性也还不错，之后再通过一些别的手段去解决不可重复读和幻读的问题就好了。

事务的传播行为

Spring中的7个事务传播行为:

事务行为说明
PROPAGATION_REQUIRED支持当前事务，假设当前没有事务。就新建一个事务
PROPAGATION_SUPPORTS支持当前事务，假设当前没有事务，就以非事务方式运行
PROPAGATION_MANDATORY支持当前事务，假设当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW新建事务，假设当前存在事务。把当前事务挂起
PROPAGATION_NOT_SUPPORTED以非事务方式运行操作。假设当前存在事务，就把当前事务挂起
PROPAGATION_NEVER以非事务方式运行，假设当前存在事务，则抛出异常
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

举例说明

案例代码

ServiceA

ServiceA {   
     void methodA() {
         ServiceB.methodB();
     }
}

ServiceB

ServiceB { 
     void methodB() {
     }  
}

1.PROPAGATION_REQUIRED
  假如当前正要运行的事务不在另外一个事务里，那么就起一个新的事务 比方说，ServiceB.methodB的事务级别定义PROPAGATION_REQUIRED, 那么因为执行ServiceA.methodA的时候，ServiceA.methodA已经起了事务。这时调用ServiceB.methodB，ServiceB.methodB看到自己已经执行在ServiceA.methodA的事务内部。就不再起新的事务。而假如ServiceA.methodA执行的时候发现自己没有在事务中，他就会为自己分配一个事务。这样，在ServiceA.methodA或者在ServiceB.methodB内的不论什么地方出现异常。事务都会被回滚。即使ServiceB.methodB的事务已经被提交，可是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚

2.PROPAGATION_SUPPORTS
  假设当前在事务中。即以事务的形式执行。假设当前不在一个事务中，那么就以非事务的形式执行

3PROPAGATION_MANDATORY
  必须在一个事务中执行。也就是说，他仅仅能被一个父事务调用。否则，他就要抛出异常

4.PROPAGATION_REQUIRES_NEW
  这个就比较绕口了。 比方我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW。那么当运行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起。ServiceB.methodB会起一个新的事务。等待ServiceB.methodB的事务完毕以后，他才继续运行。
他与PROPAGATION_REQUIRED 的事务差别在于事务的回滚程度了。由于ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。假设ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚。ServiceB.methodB是不会回滚的。假设ServiceB.methodB失败回滚，假设他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。

5.PROPAGATION_NOT_SUPPORTED
  当前不支持事务。比方ServiceA.methodA的事务级别是PROPAGATION_REQUIRED 。而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ，那么当执行到ServiceB.methodB时。ServiceA.methodA的事务挂起。而他以非事务的状态执行完，再继续ServiceA.methodA的事务。

6.PROPAGATION_NEVER
  不能在事务中执行。
如果ServiceA.methodA的事务级别是PROPAGATION_REQUIRED。 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ，那么ServiceB.methodB就要抛出异常了。

7.PROPAGATION_NESTED
  如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

Spring事务实现的方式

编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，但很难维护。

声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或者XML配置管理事务。

事务注解的本质是什么

@Transactional 这个注解仅仅是一些（和事务相关的）元数据，在运行时被事务基础设施读取消费，并使用这些元数据来配置bean的事务行为。 大致来说具有两方面功能，一是表明该方法要参与事务，二是配置相关属性来定制事务的参与方式和运行行为

声明式事务主要是得益于Spring AOP。使用一个事务拦截器，在方法调用的前后/周围进行事务性增强（advice），来驱动事务完成。

@Transactional注解既可以标注在类上，也可以标注在方法上。当在类上时，默认应用到类里的所有方法。如果此时方法上也标注了，则方法上的优先级高。 另外注意方法一定要是public的。

2025最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 9万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
Spring Cloud知识体系概述
weixin_47498250的博客
08-20 385
Spring Cloud是Spring旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/ Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。 Spring Cloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路 由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括： Netflix - Eureka：注册中心 - Zuul：服务网关 - Ribbon：负载均衡
Spring概述及框架体系
qq_15233495的博客
09-18 445
什么是Spring ​ Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构，因此Java开发者可以专注于应用程序的开发。 Spring框架的优点 非侵入式设计 方便解耦，简化开发 支持AOP 支持声明式任务处理 方便程序的测试 方便集成各种优秀框架 降低Java
权限框架SpringSecurity介绍
最新发布
llg3189609554的博客
04-01 1275
目前市面上比较流行的权限框架主要实Shiro和Spring Security，这两个框架各自侧重点不同，各有各的优劣。Spring Security是为基于Spring的应用程序提供声明式安全保护的安全性框架，它提供了完整的安全性解决方案，能够在web请求级别和方法调用级别处理身份证验证和授权。因为基于Spring框架，所以Spring Security充分利用了依赖注入和面向切面的技术。web请求级别：使用Servlet规范中的过滤器（Filter）保护Web请求并限制URL级别的访问。方法调用级别。
spring 知识体系
林的博客
06-09 939
个人知识体系 spring知识体系一、IOC（DI）（一）、理解（二）、原理（三）、注入方式（四）、spring如何解决循环依赖（五）、bean的作用域（六）、Spring中的单例bean的线程安全问题（七）、Spring中的bean生命周期二、AOP(一）、理解(二）、原理(三）、概念 一、IOC（DI） （一）、理解 对 IOC 的理解 首先，IOC 控制反转 谁控制谁，控制什么，什么是反转（有反转就应该有正转了） 谁控制谁，控制什么： 在之前，没有 IOC 时，我们直接在对象内部通过 new 进行创建
Spring知识体系大全（IOC,AOP,JDBC,事务）
自律
07-05 256
准备工作 1.创建Maven的java项目。 2.导入java项目的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.3.10.RELEASE</version> &
spring常用知识体系
朱培(知浅_ZLH)
10-24 979
BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。BeanFactroy采用的是延迟加载形式来注入Bean的。
Spring高频面试基础问题与知识点整理
热门推荐
张彦峰的博客
04-07 173万+
高频Spring相关基本面试题和知识点整理
《Pro Spring 2.5》：Java开发者必备的Spring框架指南
这一描述揭示了软件开发过程中，框架升级往往会对依赖于框架的书籍和项目产生影响，需要开发者和作者不断适应和更新知识体系。 3. 《Pro Spring 2.5》的出版背景：Jan为了赶上Spring Framework 2.5版本的发布，明智...
必备Spring框架jar包资源快速下载指南
在当今的Java开发领域中，Spring框架无疑是最流行和广泛使用的框架之一。...此外，随着Spring技术的持续演进，新的jar包也会不断出现，开发者需要保持对最新技术动态的关注和学习，以便充分运用Spring框架的能力。
初学者必备Spring框架核心原理与应用教程
Spring框架是Java平台上一个开源的应用程序框架，它以轻量级控制反转（Inversion of Control，简称IoC）和面向切面编程（Aspect-Oriented Programming，简称AOP）为内核，提供了构建企业级应用的一整套解决方案。...
Spring知识框架
CyberXavier的博客
05-26 233
Spring知识框架 Spring总体架构 IOC知识体系图
spring整体知识结构
become a programmer
07-22 361
下方链接是spring的整体知识结构的文章 http://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
Spring知识结构
weixin_34075551的博客
04-28 135
课程目标：          1. 回顾                    * 传统的开发模式                    * Struts与Hibernate可以做什么事？          2. Spring框架                    * 概念(术语了解)                    * Spring框架                  ...
Spring框架知识框架
weixin_43862280的博客
10-17 353
SpringIOC IOC容器概念 IOC其实就是一个对象的容器。全称Inversion Of Control 控制反转，核心的作用就是将原来由开发人员来控制的对象管理操作交由Spring来管理。 SpringIOC不仅帮我们管理了对象的创建，还包括给对象增加了生命周期行为、作用域(单例、非单例)、懒加载。 配合Spring的DI， 更能方便的解决对象属性值注入、对象之间的依赖注入问题。 IOC容...
【Spring知识】Spring知识体系
wendao76的专栏
12-19 1009
定义SpringMVC（Model-View-Controller）是一个基于MVC设计模式的框架，它将应用程序分为模型（Model）、视图（View）和控制器（Controller）三部分。MVC设计模式Model：表示应用程序的数据和业务逻辑。包括实体类Bean（专门存储业务数据，如Student、User等）和业务处理Bean（指Service或Dao对象，专门用于处理业务逻辑和数据访问）。View：负责呈现数据的用户界面。通常指工程中的HTML或JSP等页面。Controller。
Spring Framework
程序员的博客
09-05 1143
介绍: Spring Framework核心支持依赖注入，事务管理，Web应用程序，数据访问，消息传递，测试和更多功能。 Spring 官网：https://spring.io/ Spring 文档：https://spring.io/guides Spring Project:https://spring.io/projects 项目快速生成器：https://start.spring.io/ Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型 - 在任何类...
spring 知识体系积累
weixin_30881367的博客
03-23 132
sping 作为程序开发必不可少的一部分，现将所学记录，望再接再励。 1.要弄清spring和springMVC的关系。首先要弄清spring有哪及大块。 　模块一：Spring IOC核心容器实现了控制反转，将程序创建对象及创建对象依赖之间的关系转为由spring容器依赖注入，实现了控制反转。 模块二：spring Aop 面向切面编程，在日志记录，事务等方面应用。毕竟日志和事务都是...
Spring5框架知识体系最新版(建议收藏)
weixin_42279465的博客
09-09 391
Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

硕风和炜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值