Spring核心技术

最新推荐文章于 2024-03-20 11:03:50 发布

Java全栈研发大联盟

最新推荐文章于 2024-03-20 11:03:50 发布

阅读量824

点赞数

分类专栏： SSM三大框架文章标签： Spring核心技术

本文链接：https://blog.csdn.net/qq_40241957/article/details/82818071

版权

SSM三大框架专栏收录该内容

23 篇文章 2 订阅

订阅专栏

Spring的概述

Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
且可以和其他框架一起使用；Spring与Struts, Spring与hibernate
(起到整合（粘合）作用的一个框架)
Spring提供了一站式解决方案：
1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web Spring对web模块的支持。
- 可以与struts整合,让struts的action创建交给spring
- spring mvc模式
3） Spring DAO Spring 对jdbc操作的支持【JdbcTemplate模板工具类】
4） Spring ORM spring对orm的支持：
既可以与hibernate整合，【session】
也可以使用spring的对hibernate操作的封装
5）Spring AOP 切面编程
6）SpringEE spring 对javaEE其他模块的支持

spring环境需要maven 坐标

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.itmayiedu</groupId>
	<artifactId>itmayiedu-spring</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<!-- 引入Spring-AOP等相关Jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>3.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.6.1</version>
		</dependency>
		<dependency>
			<groupId>aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.5.3</version>
		</dependency>
<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.1_2</version>
		</dependency>
	</dependencies>

</project>

注解版本使用

注解方式可以简化spring的IOC容器的配置!

使用注解步骤：
1）先引入context名称空间
xmlns:context=“http://www.springframework.org/schema/context”
2）开启注解扫描
<context:component-scan base-package=“com.itmayiedu02”></context:component-scan>
3）使用注解
通过注解的方式，把对象加入ioc容器。

   创建对象以及处理对象依赖关系，相关的注解：
	@Component   指定把一个对象加入IOC容器

@Repository 作用同@Component；在持久层使用
@Service 作用同@Component；在业务逻辑层使用
@Controller 作用同@Component；在控制层使用

@Resource 属性注入

总结：
1）使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
2）注解可以和XML配置一起使用。

@Resource与@Autowired区别

1、@Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。
2、@Autowired默认按类型装配（这个注解是属业spring的），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用，如下：
Java代码
1.@Autowired() @Qualifier(“baseDao”)
2.private BaseDao baseDao;
3、@Resource（这个注解属于J2EE的），默认安照名称进行装配，名称可以通过name属性进行指定，
如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。
Java代码
1.@Resource(name=“baseDao”)
2.private BaseDao baseDao;

我喜欢用 @Resource注解在字段上，且这个注解是属于J2EE的，减少了与spring的耦合。最重要的这样代码看起就比较优雅。

手动实现AOP编程
AOP 面向切面的编程，
AOP可以实现“业务代码”与“关注点代码”分离

// 保存一个用户
public void add(User user) { 
		Session session = null; 
		Transaction trans = null; 
		try { 
			session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
			trans = session.beginTransaction();    // 【关注点代码】
			 
			session.save(user);     // 核心业务代码
			 
			trans.commit();     //…【关注点代码】

		} catch (Exception e) {     
			e.printStackTrace(); 
			if(trans != null){ 
				trans.rollback();   //..【关注点代码】

			} 
		} finally{ 
			HibernateSessionFactoryUtils.closeSession(session);   ..【关注点代码】

		} 
   }

分析总结：
关注点代码，就是指重复执行的代码。
业务代码与关注点代码分离，好处？
– 关注点代码写一次即可；
-开发者只需要关注核心业务；
-运行时期，执行核心业务代码时候动态植入关注点代码；【代理】

AOP编程
概述：
AOP: Aspect Oriented Programming 面向切面编程。
　　面向切面编程(也叫面向方面)：Aspect Oriented Programming(AOP),是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
　　AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面（方面）编程。
　　主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
　　主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
假设把应用程序想成一个立体结构的话，OOP的利刃是纵向切入系统，把系统划分为很多个模块（如：用户模块，文章模块等等），而AOP的利刃是横向切入系统，提取各个模块可能都要重复操作的部分（如：权限检查，日志记录等等）。由此可见，AOP是OOP的一个有效补充。
注意：AOP不是一种技术，实际上是编程思想。凡是符合AOP思想的技术，都可以看成是AOP的实现。

Aop， aspect object programming 面向切面编程
功能：让关注点代码与业务代码分离！
关注点,
重复代码就叫做关注点；
切面，
关注点形成的类，就叫切面(类)！
面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。
切入点，
执行目标对象方法，动态植入切面代码。
可以通过切入点表达式，指定拦截哪些类的哪些方法；给指定的类在运行的时候植入切面类代码。

注解方式实现AOP编程

aop:aspectj-autoproxy</aop:aspectj-autoproxy> 开启事物注解权限

使用注解
@Aspect 指定一个类为切面类
@Pointcut("execution( com.itmayiedu.service.UserService.add(…))")* 指定切入点表达式

@Before(“pointCut_()”) 前置通知: 目标方法之前执行
@After(“pointCut_()”) 后置通知：目标方法之后执行（始终执行）
@AfterReturning(“pointCut_()”) 返回后通知：执行方法结束前执行(异常不执行)
@AfterThrowing(“pointCut_()”) 异常通知: 出现异常时候执行
@Around(“pointCut_()”) 环绕通知：环绕目标方法执行

@Component
@Aspect
public class Aop {
	@Before("execution(* com.itmayiedu.service.UserService.add(..))")
	public void begin() {
		System.out.println("前置通知");
	}

	@After("execution(* com.itmayiedu.service.UserService.add(..))")
	public void commit() {
		System.out.println("后置通知");
	}

	@AfterReturning("execution(* com.itmayiedu.service.UserService.add(..))")
	public void afterReturning() {
		System.out.println("运行通知");
	}

	@AfterThrowing("execution(* com.itmayiedu.service.UserService.add(..))")
	public void afterThrowing() {
		System.out.println("异常通知");
	}

	@Around("execution(* com.itmayiedu.service.UserService.add(..))")
	public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
       System.out.println("我是环绕通知-前");
       proceedingJoinPoint.proceed();
       System.out.println("我是环绕通知-后");
	}

}

XML方式实现AOP编程

Xml实现aop编程：
1）引入jar文件【aop 相关jar， 4个】
2）引入aop名称空间
3）aop 配置
* 配置切面类（重复执行代码形成的类）
* aop配置
拦截哪些方法 / 拦截到方法后应用通知代码

 <?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
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/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

<!-- dao 实例 -->
<bean id="userDao" class="com.itmayiedu.UserDao"></bean>
<bean id="orderDao" class="com.itmayiedu.OrderDao"></bean>

<!-- 切面类 -->
<bean id="aop" class="com.itmayiedu.Aop"></bean>

<!-- Aop配置 -->
<aop:config>
	<!-- 定义一个切入点表达式： 拦截哪些方法 -->
	<aop:pointcut expression="execution(* com.itmayiedu.*.*(..))" id="pt"/>
	<!-- 切面 -->
	<aop:aspect ref="aop">
		<!-- 环绕通知 -->
		<aop:around method="around" pointcut-ref="pt"/>
		<!-- 前置通知： 在目标方法调用前执行 -->
		<aop:before method="begin" pointcut-ref="pt"/>
		<!-- 后置通知： -->
		<aop:after method="after" pointcut-ref="pt"/>
		<!-- 返回后通知 -->
		<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
		<!-- 异常通知 -->
		<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
		
	</aop:aspect>
</aop:config>

事务的概述

⑴ 原子性（Atomicity）
　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。
⑵ 一致性（Consistency）
　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。
⑶ 隔离性（Isolation）
　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。
　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。
⑷ 持久性（Durability）
　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
　　例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

事务控制概述

编程式事务控制
自己手动控制事务，就叫做编程式事务控制。
Jdbc代码：
Conn.setAutoCommite(false); // 设置手动控制事务
Hibernate代码：
Session.beginTransaction(); // 开启一个事务
【细粒度的事务控制：可以对指定的方法、指定的方法的某几行添加事务控制】
(比较灵活，但开发起来比较繁琐：每次都要开启、提交、回滚.)

声明式事务控制
Spring提供了对事务的管理, 这个就叫声明式事务管理。
Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理，只需要在配置文件中配置即可；不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦。
Spring声明式事务管理，核心实现就是基于Aop。
【粗粒度的事务控制：只能给整个方法应用事务，不可以对方法的某几行应用事务。】
(因为aop拦截的是方法。)

**Spring声明式事务管理器类：
	Jdbc技术：DataSourceTransactionManager
	Hibernate技术：HibernateTransactionManager**

编程事物管理
手动管理事物

1. UserDao.java
@Repository
public class UserDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;
	public void add(String name, Integer age) {
		String sql = "INSERT INTO users(NAME, age) VALUES(?,?);";
		int update = jdbcTemplate.update(sql, name, age);
		System.out.println("insertResult:" + update);
	}
}
2. UserService
@Service
public class UserService {
	@Autowired
	private UserDao userDao;
	public void add() {
		userDao.add("lisi", 18);
		int i=1/0;//可能会发生异常
		userDao.add("yushengjun", 19);
	}
}
3. App 测试类
public class UserTest {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.add();
	}
}

4.手动事物管理类
@Component
public class TransactionUtils {
	// 事物管理器
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionDefinition());
		return transaction;
	}
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}
}

5. bean.xml  (Spring务管理配置)
<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 开启注解 -->
	<context:component-scan base-package="com.itmayiedu"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

   <!-- 配置事物 -->
   <bean  id="DataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
   </bean>
</beans>

声明式事务管理
XML方式实现

 @Repository
public class UserDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;
	public void add(String name, Integer age) {
		String sql = "INSERT INTO users(NAME, age) VALUES(?,?);";
		int update = jdbcTemplate.update(sql, name, age);
		System.out.println("updateResult:" + update);
	}
}
2. UserService
@Service
public class UserService {
	@Autowired
	private UserDao userDao;
	public void add() {
		userDao.add("lisi", 18);
		int i=1/0;//可能会发生异常
		userDao.add("yushengjun", 19);
	}
}
3. App 测试类
public class UserTest {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.add();
	}
}

4.手动事物管理类
@Component
public class TransactionUtils {
	// 事物管理器
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionDefinition());
		return transaction;
	}
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}
}



5. bean.xml  (Spring务管理配置)
	<!-- 开启注解 -->
	<context:component-scan base-package="com.itmayiedu"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置事物 -->
	<bean id="dataSourceTransactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
   	<!—配置事物增强-->
	<tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" />
			<tx:method name="find*" read-only="true" />
			<tx:method name="*" read-only="false" />
		</tx:attributes>
	</tx:advice>
	<!-- Aop配置： 拦截哪些方法(切入点表表达式) + 应用上面的事务增强配置 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.itmayiedu.service.*.*(..))"
			id="pt" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pt" />
	</aop:config>

使用事务注意事项
事务是程序运行如果没有错误,会自动提交事务,如果程序运行发生异常,则会自动回滚。
如果使用了try捕获异常时.一定要在catch里面手动回滚。
事务手动回滚代码

注解方式实现
使用注解实现Spring的声明式事务管理，更加简单！
步骤：
1）必须引入Aop相关的jar文件
2） bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类
3）在需要添加事务控制的地方，写上: @Transactional

@Transactional注解：
1）应用事务的注解
2）定义到方法上：当前方法应用spring的声明式事务
3）定义到类上：当前类的所有的方法都应用Spring声明式事务管理;
4）定义到父类上：当执行父类的方法时候应用事务。

Bean.xm
<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 开启注解 -->
	<context:component-scan base-package="com.itmayiedu"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- 配置事务 -->
	<bean id="dataSourceTransactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
</beans>     

UserService
@Transactional
	public void add() {
		try {
			userDao.add("lisi", 18);
			int i = 1 / 0;
			userDao.add("yushengjun", 19);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
		}
		
	}

使用事务注意事项

使用事务时，一定要将异常抛出外部，不然AOP环绕通知获取不到异常不能够回滚。

传播七种行为

（传播行为就是为了解决事务嵌套的问题的）
Spring中事务的定义：
Propagation（key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：
PROPAGATION_REQUIRED–支持当前事务(指最外层的那个事务)(用外层事务而不用里层事务)，如果当前没有事务，就新建一个事务。这是最常见的选择。
举例说明一下：（解析：@Transactional默认的传播行为是required,因为最外层的add方法已经有@Transactional了，所以logService.addLog支持最外层的事务，放弃自己的事务，相当于合并事务了，如果外层的add方法后面发生异常，那么logService.addLog也要发生回滚，所以要想让logService.addLog不回滚就要改变logService.addLog上的@Transactional的传播行为requireds_new）
在这里插入图片描述

PROPAGATION_SUPPORTS–支持当前事务（外层事务），如果当前没有事务，就以非事务方式执行。(如果当前有事务，我就用当前事务,如果当前没有事务，就以非事务进行执行)
PROPAGATION_MANDATORY–支持当前事务（外层事务），如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务（外层事务），把当前事务挂起。（如果当前运行的方法，已经存在事务：事务会挂起；会始终开启一个新的事务，执行完后；刚才挂起的事务才继续运行。）（就是说不用外层事务，用自己本身的新建的事务（requireds_new要加在里层方法上））
PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务（外层事务），就把当前事务（外层事务）挂起。
PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务（外层事务），则抛出异常。

Java全栈研发大联盟

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring核心技术

Spring的概述Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。且可以和其他框架一起使用；Spring与Struts, Spring与hibernate(起到整合（粘合）作用的一个框架)Spring提供了一站式解决方案：1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系2） Spring Web Spring对web模...
复制链接

扫一扫