【Java Spring整体学习】整理Spring知识点

已于 2024-03-20 19:02:06 修改
阅读量2k 收藏 17
点赞数 2
分类专栏： Spring Java Java面试题 文章标签： spring java 后端
于 2023-02-27 16:55:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46638350/article/details/129238970
版权
Java 同时被 3 个专栏收录
59 篇文章 4 订阅
订阅专栏
Java面试题
18 篇文章 0 订阅
订阅专栏
Spring
9 篇文章 3 订阅
订阅专栏

文章目录

1. 定义Spring Bean篇

1.1 定义Spring Bean的几种方式

1.1.1 XML文件定义Spring Bean

基本类型注册

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student{
	private String name;
	private Address address;
	private String[] books;
	private List<String> hobbys;
	private Map<String String> card;
	private Set<String> games;
	private String wife;
	private Properties info;
}

setter方法注入：property的name属性，填写的不是属性的名称，而是set方法去除set，然后将第一个字符小写后的结果

<bean id="student" class="com.kuang.pojo.Student">
	<!--1. 普通注入-->
	<property name="name" value="狂神说"/>

	<!--2. 数组注入-->
	<property name="books">
		<array>
			<value>红楼梦</value>
			<value>西游记</value>
			<value>水浒传</value>
		</array>
	</property>

	<!--3. List注入-->
	<property name="hobbys">
		<list>
			<value>看书</value>
			<value>听歌</value>
			<value>打球</value>
		</list>
	</property>

	<!--4. Map注入-->
	<property name="card">
		<map>
			<entry key=“身份证” value=“12315454512312”/>
			<entry key=“银行卡” value=“15465415123156”/>
		</map>
	</property>

	<!--5. 数组注入-->
	<property name="games">
		<set>
			<value>红楼梦</value>
			<value>西游记</value>
			<value>水浒传</value>
		</set>
	</property>

	<!--6. 空值注入-->
	<property name="wife">
		<null/>
	</property>

	<!--7. Properties注入-->
	<property name="info">
		<props>
			<prop key="driver">20190525</prop>
			<prop key="url">男/prop>
			<prop key="username">root</prop>
			<prop key="password">123456</prop>
		</props>
	</property>
</bean>

类装配

	<!--csBean类有两个属性：title和author-->
    <bean name="cdBean" class="com.my.spring.bean.CDBean">
        <property name="title" value="The World!!"/>
        <property name="author" value="Mr.D"/>
    </bean>    
     <!--csPlayer类有一个属性：cdBean-->
     <!--对csPlayer的属性csBean进行依赖注入，称为Bean装配，或者依赖关系注入-->
    <bean name="cdPlayer" class="com.my.spring.service.impl.CDPlayerImpl">
        <property name="cdBean" ref="cdBean"/>
    </bean>

有参构造方法注入

<!--有参构造方法1-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg index="0" value="方法1"/>
    </bean>
<!--有参构造方法2-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg type="java.lang.String" value="方法2"/>
    </bean>
<!--有参构造方法3-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg name="name" value="方法3"/>
    </bean>

扩展注入

<!--p命名空间注入-->
<!--先在beans框架中加入支持：xmlns:p="http://www/springframework.org/schema/p"-->
<!--p命名空间注入，可以直接注入属性的值，property-->
<bean id="user" class="com.kuang.pojo.User" p:name="小李" p:age="10"/>

<!--c命名空间注入-->
<!--先在beans框架中加入支持：xmlns:c="http://www/springframework.org/schema/c"-->
<!--其次使用c注入的Bean必须存在有参构造器-->
<!--c命名空间注入，通过构造器注入，construct-args-->
<bean id="user" class="com.kuang.pojo.User" c:name="小李" c:age="10"/>

Bean的作用域

  1. 单例模式（Spring默认机制）：从Spring容器中get的每个对象都是同一个对象。
// <bean id="user" class="com.kuang.pojo.User" scope="singleton"/>

ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user1 = context.getBean("user");
User user2 = context.getBean("user");
System.out.println(user1==user2);	//true
  1. 原型模式：每次从容器中get的时候，都会产生一个新对象
// <bean id="user" class="com.kuang.pojo.User" scope="prototype"/>

ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user1 = context.getBean("user");
User user2 = context.getBean("user");
System.out.println(user1==user2);	//false

别名

<!--别名，如果添加了别名，我们可以使用别名获取这个对象-->
<alias name="user" alias="userNew">

<!--
	id：bean的唯一标识符，也就是相当于我们学的对象名
	class：bean对象所对应的全限定名：包名+类型
	name：也是别名，而且那么可以同时取多个别名
-->
	<bean id="user" class="com.kuang.pojo.user" name="user1,user2,user3">
	<property name="name" value="狂神说"/>
	</bean>

Import
如果导入的文件中，bean重名了，那么就会把重名的bean合并成一个，所以不会因为不同的bean.xml存在重名而发生冲突

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

1.1.2 JavaConfig定义Spring Bean

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
	@Value("测试名字")
    public String name;
} 

@Configuration 
public class JavaConfig {
    @Bean
    public User getUser() {
        return new User();
    } }

1.1.3 @Component注解定义SpringBean

通过@Component、@Repository、@Service、@Controller等注解定义bean，在启动类上加上@ComponentScan注解，在项目启动时@ComponentScan扫描指定路径下的包，包内含有@Component、@Repository、@Service、@Controller等注解的类会被注册成Bean，放到BeanDefinitionMap中，并创建实例到单例池。

@Data
@NoArgsConstructor
@AllArgsConstructor
@Component
public class User {
    public String name;
}

这里使用了xml配置了componentScan，到了SpringBoot就完全使用注解@ComponentScan

	<?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
		        https://www.springframework.org/schema/beans/spring-beans.xsd
		        http://www.springframework.org/schema/context
		        https://www.springframework.org/schema/context/spring-context.xsd">
			<!--指定要扫描的包，这个包下的注解就会生效-->
    		<context:component-scan base-package="com.kuang.pojo"/>
			<!--开启注解的支持    -->
	        <context:annotation-config/>
	</beans>

1.2 装配Spring Bean的四种常用方式

1.2.1 手动装配 + XML文件

package com.javastudyway.pojo;
public class Cat {
    public void shout(){
        System.out.println("我是猫");
    }
}

package com.javastudyway.pojo;
publicclass Dog {
    public void shout(){
        System.out.println("我是狗");
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    /* 人有猫和狗 */
    private Cat cat;
    private Dog dog;
    private String name;
}

    <bean id="cat" class="com.javastudyway.pojo.Cat"/>
    <bean id="dog" class="com.javastudyway.pojo.Dog"/>
    <bean id="person" class="com.javastudyway.pojo.Person">
        <property name="name" value="Java学习之道"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

1.2.2 自动装配 + XML文件

    <bean id="cat" class="com.javastudyway.pojo.Cat"/>
    <bean id="dog" class="com.javastudyway.pojo.Dog"/>
    
    <!--byType-->
    <bean id="person" class="com.javastudyway.pojo.Person" autowire="byType">
        <property name="name" value="Java学习之道"/>
    </bean>

	<!--byName-->
	<bean id="person" class="com.javastudyway.pojo.Person" autowire="byName">
        <property name="name" value="Java学习之道"/>
    </bean>

1.2.3 手动装配 + JavaConfig文件

@Configuration//标明配置
public class PeopleConfig {
 
    @Bean
    public Cat catBean(){
        return new Cat();
    }
 
    @Bean
    public CDPlayer dogBean(){
        return new Dog();
    }

	@Bean
	public People peopleBean(){
		return new People(catBean(),dogBean(),"Java学习之道");
	}
}

1.2.4 自动装配 + 注解

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 开启注解支持 -->
    <context:annotation-config/>

    <bean id="cat" class="com.javastudyway.pojo.Cat"/>
    <bean id="dog" class="com.javastudyway.pojo.Dog"/>
    <bean id="person" class="com.javastudyway.pojo.Person"/>

</beans>

Field注入

public class Pepole {
	@Autowired
	private Cat cat;
	@Autowired
	private Dog dog;
	private String name;

Setter方法注入

@Controller
public class HelloController {
    private AlphaService alphaService;
    private BetaService betaService;
    
    @Autowired
    public void setAlphaService(AlphaService alphaService) {
        this.alphaService = alphaService;
    }
    @Autowired
    public void setBetaService(BetaService betaService) {
        this.betaService = betaService;
    }
}

Constructor 注入

@Controller
public class HelloController {
    private final AlphaService alphaService;
    private final BetaService betaService;
    
    @Autowired
    public HelloController(AlphaService alphaService, BetaService betaService) {
        this.alphaService = alphaService;
        this.betaService = betaService;
    }
}

2. Spring Bean注册到容器中

以UserService讲解Bean注册到容器中的过程。

@mapper
public class UserService{
	@Autowired
	private OrderService orderService;
	public void test(){
		System.out.println(orderService);
	}
}

2.1 实例化，生成普通对象

2.1.1 通过反射机制获取构造器，通过构造器创建普通对象

创建Bean过程中，推断所使用的构造器方法

  • 如果没有重写构造方法，那么创建Bean对象就会用无参构造方法；
  • 如果重写了一个有参构造方法，那么创建Bean对象就会用该有参构造方法；
  • 如果重写了两个有参构造方法，那么创建Bean对象不知道用哪个有参构造方法，就会去寻找无参构造方法，如果没有无参构造方法就报错。如果存在无参构造方法就执行无参构造方法。
  • 可以通过@Autowired，指定使用该构造方法，即使存在无参构造器，也要使用这个有参构造器

谁向有参构造器public UserService(OrderService orderService)中传入参数？

  • 当我们创建Bean对象userService时，需要用到有参构造方法，Spring就会在单例池中找到OrderService对象，并注入到构造方法的参数orderService

如何在单例池中找到自己想要的实例呢？

  • 如果通过类型OrderService找出beanName唯一，那就直接将Bean对象注入orderService。
  • 如果通过参数的类OrderService找出beanName不唯一，那就通过参数名orderService找出唯一的beanName，然后将Bean对象注入orderService参数
  • 如果这样都找不到，那就报错！

2.1.2 属性注入

2.1.3 初始化

这里通过执行invoke（）方法，将普通对象初始化

2.1.4 初始化后，生成代理对象

这里就是我们常说的AOP，如果这里进行了AOP切面编程，那么就会生成代理对象

  1. 创建普通对象UserService
@Component
public class UserService{
	@Autowired
	private OrderService orderService;
	public void test(){
		System.out.println(orderService);
	}

}
  1. 创建代理对象UserServiceProxy，对test（）方法进行切面编程
@Aspect
@Component
public class UserServiceProxy{
	@Before("execution(public void com.zhouyu.service.UserService.test())")
	public void zhouyuBefore(JoinPoint joinPoint){
		System.out.println("zhouyuBefore");
	}
}

现在来思考一个问题，在普通对象userService的属性orderService，有@Autowired进行依赖注入，那么orderService是有值的。但是在初始化后，进行了AOP生成了代理对象userServiceProxy，userServiceProxy的属性orderService并没有注入依赖，是null，这就来问题了。

  • 其实第3点的伪代码应该改成如下，这样就解决了null值得问题了，下面说说为什么。
  • 试想一下，生成普通对象userService，并为普通对象userService的属性orderService依赖注入，那么为什么生成代理对象userServiceProxy，不为代理对象userServiceProxy的属性orderService进行依赖注入呢？Spring认为是没必要的，就像下面的伪代码一样，除了执行AOP切面编程的代码之外，还是用回普通对象userService属性和方法
  • 所以一句话说完：UserServiceProxy代理对象做Bean对象，除了切面编程@Before会执行代理对象，其他的方法和属性可以认为是在执行普通对象
@Aspect
@Component
public class UserServiceProxy{
	@Autowired
	private UserService target;
	
	@Before("execution(public void com.zhouyu.service.UserService.test())")
	public void zhouyuBefore(JoinPoint joinPoint){
		System.out.println("zhouyuBefore");
	}
}

在这里插入图片描述

2.1.5 注册销毁

实现了销毁接口DisposableBean，在registerDisposableBean方法注册指定的Bean在销毁时可以直接执行destroy方法销毁Bean

2.1.6 将普通对象或者代理对象加入单例池中

3. Spring注解开发

3.1 使用注解开发前，需要做的配置

3.1.1 使用注解开发，必须要保证导入aop包

在这里插入图片描述

3.1.2 使用注解需要导入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
		        https://www.springframework.org/schema/beans/spring-beans.xsd
		        http://www.springframework.org/schema/context
		        https://www.springframework.org/schema/context/spring-context.xsd">
			<!--开启注解的支持    -->
	        <context:annotation-config/>
	</beans>

3.2 了解常用的@注解

3.2.1 @ Component、@Mapper、@Service、@Controller

3.2.2 @Bean

用于JavaConfig配置类，充当xml的<bean>标签

3.2.3 @ComponentScan

  • 通过属性basePackages或basePackageClasses，来指定要进行扫描的package
  • 如果未指定package，则默认扫描当前@ComponentScan所修饰的类所在的package

3.2.4 @Import

提供了一种显式地从其他地方加载配置类的方式，这里的其他地方一般是指第三方jar

//1. 创建普通Java类
	public class ConfigA{
		@Bean
		public A a(){
			public new A();
		}
	}
	public class A{
	}

//2. 创建一个配置类，直接将刚才创建的ConfigA导入
	@Configuration
	@Import(ConfigA.class)
	public class ConfigB{
	}

//3. 测试并运行
	public static void main(String[] args){
		ApplicationContext ctx = new AnnotationCconfigApplicationContext(ConfigB.class);
		//现在Bean ConfigA和A都在IOC容器中，是可用的
		ConfigA ca = ctx.getBean(ConfigA.class);
		A a = ctx.getBean(A.class);
		System.out.println(ca.getClass.getSimpleName());
		System.out,println(a.getClass.getSimpleName());
	}
结果：ConfigA、A

3.2.5 @Autowired和@Qualifier

public class Pepole {
    private String name;
//1. 通过名字装配
    @Autowired
    @Qualifier("books1")
    private Books books;
//2. 通过类型装配
    @Autowired
    private Hobbies hobbies;
}

在这里插入图片描述

3.2.6 @Resource

// @Resource指定按type自动装配
    @Resource(type = Books.class)
    private Books books;

// @Resource指定按name自动装配
    @Resource(name = books)
    private Books books;

在这里插入图片描述

3.2.7 @Value

  1. 基于配置文件application.yml
<!--application.yml-->
server:
	port: 9090
	tools: car,train,airplane

    @Value("${server.port}")
    private String port;

	@Value("${server.tools}")
	private String[] tools
  1. 基于非配置文件
    // 直接将字符串赋值给 str 属性
    @Value("hello world")
    private String str;

	// 注入系统变量
	@Value("#{systemProperties['os.name']}")
    private String osName; // 结果：Windows 10

	// 使用在setter方法上
	@Value("Windows")
	public void setName(String name){
		this.name = name;
	}

4. Spring事务

4.1 本质与原理讲解：Spring事务是基于AOP实现的，AOP是基于继承原理的。

1. Spring事务是基于AOP实现的

  • 现在对UserService的test方法开启MySQL事务
public class UserService{
	@Autowired
	OrderService ordserService;

	@Transactional				//回滚——Spring事务
	public void test(){
		jdbcTemplate.execute("insert into t1 values(1,1,1,1,'1')");
		throw new NullPointerException();
	}
}
  • @Transaction修饰test（）方法对应的伪代码
public class UserServiceProxy extends UserService{
	UserService target;
	
	//不难看出来1.2.3.4.6都是对test做一个切面，由UserServiceProxy代理对象执行；
	//test方法由普通对象执行
	public void test(){
		1. 事务逻辑
		2. 开启事务
		3. 事务管理器去创建数据库连接conn并放入了ThreadLocal
		4. conn.autocommit = false
		5. target.test();		//UserService普通对象.test() jdbcTemplate conn sql语句
		6. SQL没问题就conn.commit()，否则就conn.rollback();
	}
}
  • autocommit = true对应的功能
  • 如果数据库由jdbcTemplate连接，autocommit默认为true，则执行完SQL语句之后就会自动提交
  • 如果数据库由Spring连接，那么Spring就会把autocommit改成false，则执行完SQL语句之后还不会自动提交
  • 所以数据库创建必须由Spring来进行，但是如果由Spring创建数据库，那么Spring一启动就要连接数据库，万一我们不用数据库呢？不用就不用呗，哈哈哈哈！

2. AOP是基于继承原理的

public class UserService{
	@Transaction
	private void test(){
		System.out.println("测试数据库回滚事务");
	}
}

执行结果：报错

分析

  • 事务的实质是AOP，AOP的实质是继承，所以事务的实质是继承
  • 父类private修饰的方法，子类无法访问重写
  • 所以父类private修饰的方法，无法进行AOP，也无法进行事务
  • 那么@Transaction就会报错

4.2 事务失效场景

什么是事务失效呢？其实就是事务不会正常工作，可以发生如下情况

  • 事务没有启动
  • 事务启动了，但是无法回滚，或者回滚了很多
  • …

4.2.1 访问权限问题private

把某些方法或者变量定义为private，对其开启事务时，会导致事务失效。因为事务基于继承，private修饰的父类方法和变量，子类无法继承。

4.2.2 final修饰

如果某个方法用 final 修饰了，那么在它的代理类中，就无法重写该方法，所以无法添加事务功能

4.2.3 未被Spring管理

如果有一天，你匆匆忙忙地开发了一个 Service 类，但忘了加 @Service 注解，比如：

//@Service
public class UserService {
 
    @Transactional
    public void add(UserModel userModel) {
         saveData(userModel);
         updateData(userModel);
    }    
}

从上面的例子，我们可以看到 UserService 类没有加@Service注解，那么该类不会交给 spring 管理，所以它的 add 方法也不会生成事务。

4.2.4 表不支持事务

众所周知，在 mysql5 之前，默认的数据库引擎是myisam。myisam 好用，但有个很致命的问题是：不支持事务。如果只是单表操作还好，不会出现太大的问题。但如果需要跨多张表操作，由于其不支持事务，数据极有可能会出现不完整的情况。此外，myisam 还不支持行锁和外键。所以在实际业务场景中，myisam 使用的并不多。在 mysql5 以后，myisam 已经逐渐退出了历史的舞台，取而代之的是 innodb。

4.2.5 未开启事务

如果你使用的是 springboot 项目，那么你很幸运。因为 springboot 通过DataSourceTransactionManagerAutoConfiguration类，已经默默地帮你开启了事务。

你所要做的事情很简单，只需要配置spring.datasource相关参数即可。

但如果你使用的还是传统的 spring 项目，则需要在 applicationContext.xml 文件中，手动配置事务相关参数。如果忘了配置，事务肯定是不会生效的。

具体配置信息如下：

<!-- 配置事务管理器 --> 
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager"> 
    <property name="dataSource" ref="dataSource"></property> 
</bean> 
<tx:advice id="advice" transaction-manager="transactionManager"> 
    <tx:attributes> 
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes> 
</tx:advice> 
<!-- 用切点把事务切进去 --> 
<aop:config> 
    <aop:pointcut expression="execution(* com.susan.*.*(..))" id="pointcut"/> 
    <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/> 
</aop:config>

4.2.6 方法内部调用

来看两个示例

@Service
public class OrderServiceImpl implements OrderService {

    public void update(Order order) {
        updateOrder(order);
    }
    
    @Transactional
    public void updateOrder(Order order) {
        // update order
    }
    
}

@Service
public class OrderServiceImpl implements OrderService {

    @Transactional
    public void update(Order order) {
        updateOrder(order);
    }  
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateOrder(Order order) {
        // update order
    }   
}

上面两个例子的updateOrder(Order order) 都不会生成事务：因为它们发生了自身调用，就调该类自己的方法，而没有经过 Spring 的代理类，默认只有在外部调用事务才会生效，这也是老生常谈的经典问题了。

解决办法

@Service
public class ServiceA {

  @Autowired
  private ServiceB serviceB;
  
    @Transactional
    public void update(Order order) {
        serviceB.updateOrder(order);
    }
}
@Service
public class ServiceB {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateOrder(Order order) {
        // update order
    }
}

4.2.7 错误的传播特性

我们在使用@Transactional注解时，是可以指定propagation参数的：该参数的作用是指定事务的传播特性，spring 目前支持 7 种传播特性：

  • REQUIRED 如果当前上下文中存在事务，则加入该事务，如果不存在事务，则创建一个事务，这是默认的传播属性值。
  • SUPPORTS 如果当前上下文中存在事务，则支持事务加入事务，如果不存在事务，则使用非事务的方式执行。
  • MANDATORY 当前上下文中必须存在事务，否则抛出异常。
  • REQUIRES_NEW 每次都会新建一个事务，并且同时将上下文中的事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。
  • NOT_SUPPORTED 如果当前上下文中存在事务，则挂起当前事务，然后新的方法在没有事务的环境中执行。
  • NEVER 如果当前上下文中存在事务，则抛出异常，否则在无事务环境上执行代码。
  • NESTED 如果当前上下文中存在事务，则嵌套事务执行，如果不存在事务，则新建事务。

目前只有这三种传播特性才会创建新事务：REQUIRED，REQUIRES_NEW，NESTED。

如果我们在手动设置 propagation 参数的时候，把传播特性设置错了，比如：

@Service
public class UserService {
 
    @Transactional(propagation = Propagation.NEVER)
    public void add(UserModel userModel) {
        saveData(userModel);
        updateData(userModel);
    }
}

我们可以看到 add 方法的事务传播特性定义成了 Propagation.NEVER，这种类型的传播特性不支持事务，如果有事务则会抛异常。

4.2.8 自己吞了异常

@Slf4j
@Service
public class UserService {
    
    @Transactional
    public void add(UserModel userModel) {
        try {
            saveData(userModel);
            updateData(userModel);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

这种情况下 spring 事务当然不会回滚，因为开发者自己捕获catch了异常，又没有手动抛出throw，换句话说就是把异常吞掉了。

如果想要 spring 事务能够正常回滚，必须抛出它能够处理的异常。如果没有抛异常，则 spring 认为程序是正常的。

4.2.9 手动抛了别的异常

因为 spring 事务，默认情况下只会回滚RuntimeException（运行时异常）和Error（错误），对于普通的 Exception（非运行时异常），它不会回滚。

@Slf4j
@Service
public class UserService {
    
    @Transactional
    public void add(UserModel userModel) throws Exception {
        try {
             saveData(userModel);
             updateData(userModel);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new Exception(e);
        }
    }
}

解决：遇到所有异常都发生回滚

@Slf4j
@Service
public class UserService {
    
    @Transactional(rollbackFor=Exception.class) //回滚所有异常
    public void add(UserModel userModel) throws Exception {
        try {
             saveData(userModel);
             updateData(userModel);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new Exception(e);
        }
    }
}

4.2.10 事务嵌套回滚多了

public class UserService {
 
    @Autowired
    private UserMapper userMapper;
 
    @Autowired
    private RoleService roleService;
 
    @Transactional
    public void add(UserModel userModel) throws Exception {
        userMapper.insertUser(userModel);
        roleService.doOtherThing();
    }
}
 
@Service
public class RoleService {
 
    @Transactional(propagation = Propagation.NESTED)
    public void doOtherThing() {
        System.out.println("保存role表数据");
    }
}

这种情况使用了嵌套的内部事务，原本是希望调用 roleService.doOtherThing 方法时，如果出现了异常，只回滚 doOtherThing 方法里的内容，不回滚 userMapper.insertUser 里的内容，即回滚保存点。但事实是，insertUser 也回滚了。

why?

因为 doOtherThing 方法出现了异常，没有手动捕获，会继续往上抛，到外层 add 方法的代理方法中捕获了异常。所以，这种情况是直接回滚了整个事务，不只回滚单个保存点。

怎么样才能只回滚保存点呢？可以将内部嵌套事务放在 try/catch 中，并且不继续往上抛异常。这样就能保证，如果内部嵌套事务中出现异常，只回滚内部事务，而不影响外部事务。

@Slf4j
@Service
public class UserService {
 
    @Autowired
    private UserMapper userMapper;
 
    @Autowired
    private RoleService roleService;
 
    @Transactional
    public void add(UserModel userModel) throws Exception {
 
        userMapper.insertUser(userModel);
        try {
            roleService.doOtherThing();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

4.2.11 大事务

在使用 spring 事务时，有个让人非常头疼的问题，就是大事务问题。

通常情况下，我们会在方法上加@Transactional注解，添加事务功能，比如：

@Service
public class UserService {
    
    @Autowired 
    private RoleService roleService;
    
    @Transactional
    public void add(UserModel userModel) throws Exception {
       query1();
       query2();
       query3();
       roleService.save(userModel);
       update(userModel);
    }
}

但@Transactional注解，如果被加到方法上，有个缺点就是整个方法都包含在事务当中了。
上面的这个例子中，在 UserService 类中，其实只有这两行才需要事务：

roleService.save(userModel);
update(userModel);

现在的这种写法，会导致所有的 query 方法也被包含在同一个事务当中。

如果 query 方法非常多，调用层级很深，而且有部分查询方法比较耗时的话，会造成整个事务非常耗时，而从造成大事务问题。

4.3 编程式事务

上面聊的这些内容都是基于@Transactional注解的，主要说的是它的事务问题，我们把这种事务叫做：声明式事务。

其实，spring 还提供了另外一种创建事务的方式，即通过手动编写代码实现的事务，我们把这种事务叫做：编程式事务。例如：

 @Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         queryData1();
         queryData2();
         transactionTemplate.execute((status) => {
            addData1();
            updateData2();
            return Boolean.TRUE;
         })
   }

在 spring 中为了支持编程式事务，专门提供了一个类：TransactionTemplate，在它的 execute 方法中，就实现了事务的功能。

相较于@Transactional注解声明式事务，我更建议大家使用基于TransactionTemplate的编程式事务。主要原因如下：

  • 避免由于 spring aop 问题导致事务失效的问题。
  • 能够更小粒度地控制事务的范围，更直观。

建议在项目中少使用 @Transactional 注解开启事务。但并不是说一定不能用它，如果项目中有些业务逻辑比较简单，而且不经常变动，使用 @Transactional 注解开启事务也无妨，因为它更简单，开发效率更高，但是千万要小心事务失效的问题。

4.4 Spring对事务隔离级别提供了支持

在这里插入图片描述

后端漫漫
关注
专栏目录
Spring(Java框架学习超详细)
blotemj.blog.csdn.net
04-26 258
Spring 简介 轻量级开源Java开发框架 解决企业级应用开发业务逻辑层和其他各层的耦合问题 体系结构： 核心容器 Spring-core模块：控制反转、依赖注入功能 Spring-beans模块：工厂模式，管理对象：Bean Spring-context模块：访问定义和配置的任何对象的媒介，对象访问方式 Spring-context-support模块：支持高速缓存和任务调度 Spring-expression模块：运行时查询和操作对象 AOP和Instrumentation Spr
Java、springBoot、springCloud知识点整理；大厂面试题总结
10-03
本知识点整理旨在深入解析这些技术，并结合大厂面试常见问题进行讲解。 首先，Java作为全球最广泛使用的编程语言之一，其稳定性和强大的类库支持使得它在后端开发领域占据了主导地位。理解Java的核心概念，如面向...
Spring知识点总结大全
wangminshe89
02-15 252
chapter01 Spring简介 一、Spring是什么？ 在了解Spring之前，我们来了解在Java EE框架下企业级开发采用EJB框架的一些不足： (1) EJB太笨重，而且Entity EJB不能脱离容器 (2) 企业级服务使用困难 (3) 开发的复杂度太高 (4) 侵入式方案，EJB要使用特定的接口 因此，Spring应运而生。 Spring是一个开源的用...
Java Spring详解 -- 看完超越99%的同行
最新发布
ZhTiY的博客
08-30 2365
eureka主要是通过心跳检测去判断的，有一个发送者和客户端，发送者会每隔30秒发送一个心跳到eureka上去，服务端会把eureka上的客户端发送的数据进行一个接受并调用的过程，如果说生产者没有发送心跳到注册中心上，那么就直接剔除掉，将所有的接口都剔除掉，如果说中途eureka发生了宕机，那么也是可以进行一个调用的，因为将原来的数据放到了一个缓存中 去，并且eureka还有自我保护机制，如果说在15分钟内检测到有85%的服务都宕机了那么这个时候就会认为是一个网络的问题导致的。
Java 必看的 Spring 知识汇总
CRMEB小程序商城的博客
12-29 6058
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言，绝大部分Java应用都可以从Spring中受益。 Spring优点： 低侵入式设计，代码的污染极低； 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once，Run Anywhere的承诺； Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦 S
JAVA Spring学习
chenggong9527的博客
02-28 85
Java Spring框架是什么？它有哪些好处？Spring是另一个主流的JavaWeb 开发框架，该框架是一个轻量级的应用框架，具有很高的凝聚力和吸引力。Spring 框架因其强大的功能以及卓越的性能而受到众多开发人员的喜爱。 课程内容介绍 1，spring概念 2， IOC 容器 3，aop 4 jdbc template 5,事务管理 6，springt5 新特性 ...
Java Spring学习
xiabenshu的博客
05-29 393
文章目录Spring简介开始我们的程序IOCIOC简介程序入门（对象注入）对象包含其他对象使用注解来注入对象AOPAOP简介AOP程序通过注解的方式注释方式测试junit 测试框架简介简单例子参考 Spring简介 开始我们的程序 按照网上相关的教程，我们找到了一份可以立即运行的Spring，这样减少了前期繁琐的配置，可以更快地进入我们的学习之中去。 这里推荐一个网站： 可以在本文参考处找到网址，...
Java、springBoot、springCloud知识点整理；大厂面试题总结。.zip
02-25
本文将深入探讨这三个领域的关键知识点，以及在大厂面试中常见的问题。 首先，我们来了解Java的基础知识。Java的核心特性包括面向对象、自动内存管理（垃圾回收）、平台无关性、多线程和丰富的类库。在面试中，面试...
《学习资料》--一个 Java 程序员必备 Spring 学习资源库。包含 Spring 全家桶技术知识点.zip
04-19
包含 Web应用快速开发、源码实战、Spring Cloud、响应式编程、事件驱动、批处理等 Spring 全家桶技术知识点 个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论做毕业设计还是用于学习技能，或工作中...
Java面试 spring知识点 线程池 面试题
04-20
在Java面试中，Spring框架是不可或缺的知识点，尤其在涉及到线程池的面试题时，对Spring的理解深度往往成为衡量候选人技术能力的重要标准。本文将深入探讨Spring框架的核心原理、重要概念以及与线程池相关的知识。 ...
Java中spring的学习
有问题请发邮箱dengyifanlittle@163.com进行讨论
07-28 1319
spring中的IOC（控制反转），控制反转，控制和反转，在传统面向对象编程中，如果要在一个类中调用另外一个类中的方法属性等，就需要这个类new一个另外那个类的对象，以达到控制的目的。而在IOC容器中，不需要这样做，因为其将控制权交了出去，交给了IOC容器，由IOC容器来实现控制。其中的反转，其实可以理解为交控制权交出去了，不再由自己去控制另外一个对象的建立，这就是反转。而IOC还可以理解为“依赖...
Java学习-Spring
weixin_44603382的博客
11-20 929
文章目录1、Spring1.1 、简介1.2优点1.3、组成1.4、拓展2、IOC2.1、IOC理论推导2.2、IOC本质3、HelloSpring4、IoC创建对象的方式5、Spring配置5.1别名（alias）5.2、Bean的配置5.3、import6、依赖注入（DI）6.1、构造器注入6.2、Set方式注入【重点】6.3、拓展方式注入6.4Bean的作用域7、Bean的自动装配7.1、测试7.2、byName自动装配7.3、byType自动装配7.4、实现自动装配8、使用注解开发9、使用Java方
Java学习 - Spring 讲解
paofuluolijiang的博客
07-15 913
为了解决我们开发者在 J2EE 开发时所遇到的众多问题，Rob Johnson 等人发起了 Spring 框架项目。Spring 是一个开源的 J2EE 应用程序框架，是针对 Bean 的生命周期进行管理的轻量级容器。它既可以单独用于构建程序，也能和当前众多的 Web 框架进行组合使用，能够十分方便的降低当前企业应用开发的复杂性。既然 Spring 如此强大，那我们今天就来探究一下 Spring 的内容。
java spring怎么学_Java之Spring学习
weixin_35749786的博客
02-13 288
1. 首先知道Spring是个什么.Spring是分层的一个轻量级开源框架. 以反转控制IOC, 和面向切面变成AOP为内核. 提供了展现层spring MVC, 持久层Spring JDBC以及业务层事务管理等众多企业级应用技术.Spring一直贯彻并遵守:好的设计优于具体实现, 代码应该易于测试. 所以Spring提供了IOC容器, 将对象之间的依赖关系交给spring来控制,避免硬编码造成了...
Spring面试知识点
Calo_missile的博客
03-13 690
Spring中用到的设计模式 工厂模式:IOC容器 代理模式:AOP 策略模式:在spring采取动态代理时，根据代理的类有无实现接口有JDK和CGLIB两种代理方式，就是采用策略模式实现的 单例模式:默认情况下spring中的bean只存在一个实例 肯定还有其他的，希望大家留言补上，希望大家顺便看看这几种设计模式 讲讲Spring中的IOC与AOP IoC的核心
【Java学习之Spring】Spring 学习笔记（一）
Qregi的博客
01-23 303
IOC思想 Inversion of Control， 控制反转， 简称IOC，核心思想是：资源不由使用资源的双方进行管理，而由不适用资源的第三方进行管理 好处是：1. 资源集中管理m，实现资源的可配置和易管理               2. 降低了使用资源双方的依赖程度即耦合度 DI思想 Dependency Injection, 依赖注入， 简称DI， 是组件之间依赖关系由容器在运...
Java中的spring
2301_78145669的博客
05-20 1246
它是一个全面的、企业应用开发一站式的解决方案，贯穿表现层、业务层、持久层。静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让。：让容器拥有发布应用上下文事件的功能，包括容器启动事件、关闭事。求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的。实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先。， 但是要提供给构造器参数，如果没有确定的带参数的构造。容器的接口，子容器可以通过接口方法访问父容器；用它，始终指向同一对象。即可启动应用上下文，在已经启动的状态下，调用。
Java框架-Spring-知识点概括
热爱技术，热爱生活
06-21 440
IOC 传统的资源查找方式要求组件向容器发起请求来查找资源，作为回应，容器适时的返回资源；而IOC容器会主动地将资源推送给它所管理的组件，组件要做的仅是选择一种合适的方式来接受资源即可。 DI DI是IOC的另一种表述方式，即组件以一些预先定义好的方式(如setter方法)接受来自容器的资源注入。 BeanFactory与ApplicationContext 1. S...
Java之Spring学习笔记
MRS_jianai的博客
11-30 380
Java spring学习笔记
javaspring基础知识点整理
06-25
以下是一些Spring基础知识点的整理： 1. **IoC（Inversion of Control）和DI（Dependency Injection）**：Spring的核心思想就是IoC，它反转了传统的控制流动，使对象之间通过容器管理彼此的依赖关系，而不是硬编码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值