Spring核心对jdbc支持 + 程序中的事务控制学习--实训 2019/10 / 14

最新推荐文章于 2021-11-03 23:30:00 发布

欢乐大象

最新推荐文章于 2021-11-03 23:30:00 发布

阅读量408

点赞数

分类专栏： Spring 实训

本文链接：https://blog.csdn.net/qq_39088066/article/details/102541023

版权

实训同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

Spring

14 篇文章 0 订阅

订阅专栏

jdbc使用步骤：三种实现

1）引入jar文件
spring-jdbc-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar
2）优化数据库连接

Dept.java //部门类
package cn.atcast.h_jdbc;
public class Dept {
	private int deptId;
	private String deptName;
	public int getDeptId() {
		return deptId;
	}
	public void setDeptId(int deptId) {
		this.deptId = deptId;
	}
	public String getDeptName() {
		return deptName;
	}
	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}
}

UserDao1.java

package cn.atcast.h_jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class UserDao1 {
	/*
	 *  保存方法
	 *  需求优化的地方：
	 *  	1. 连接管理（UserDao01.java)
	 *  	2. jdbc操作重复代码封装（UserDao02.java)
	 */
	public static void main(String args[]){
			save();
	}
	public static void save() {
		try {
			String sql = "insert into t_dept(deptName) values('test')"; 
			Connection con = null; //链接对象
			Statement stmt = null;//声明
			Class.forName("com.mysql.jdbc.Driver");
			// 连接对象--驱动管理
			con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
			// 执行命令对象
			stmt =  con.createStatement();
			// 执行
			stmt.execute(sql);
			// 关闭
			stmt.close();
			con.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
        *****有效代码 只有一到两句****

UserDao2.java//用到了数据库连接池 + 配置文件

package cn.atcast.h_jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import javax.sql.DataSource;
public class UserDao2 {
	// IOC容器注入 +set方法
	private DataSource dataSource;
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	
	public void save() {
		try {
			String sql = "insert into t_dept(deptName) values('test');";
			Connection con = null;
			Statement stmt = null;
			// 连接对象
			con = dataSource.getConnection();
			// 执行命令对象
			stmt =  con.createStatement();
			// 执行
			stmt.execute(sql);
			// 关闭
			stmt.close();
			con.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


	bean.xml
<?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">
	
	<!-- 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:///hib_demo"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
		<property name="initialPoolSize" value="3"></property>
		<property name="maxPoolSize" value="10"></property>
		<property name="maxStatements" value="100"></property>
		<property name="acquireIncrement" value="2"></property>
	</bean>
	
	<!--UserDao2实例 -->
	<bean id="userDao2" class="cn.atcast.h_jdbc.UserDao2">
		 <property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 2. 创建JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- UserDao3实例 -->
	<bean id="userDao3" class="cn.atcast.h_jdbc.UserDao3">
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
	
</beans>        
	

UserDao3.java //jdbc 模板类jdbcTemplate

package cn.atcast.h_jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.RowMapper;

public class UserDao3 {

	
	private JdbcTemplate jdbcTemplate;
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}
	//增加操作
	public void save() {
		String sql = "insert into t_dept(deptName) values('test');";
		jdbcTemplate.update(sql);
	}
	
	public Dept findById(int id) {
		String sql = "select * from t_dept where deptId=?";
		//参数  sql ,把搜索出来的行 变 成对象 , 参数
		List<Dept> list = jdbcTemplate.query(sql,new MyResult(), id);
		return (list!=null && list.size()>0) ? list.get(0) : null;
	}
	
	public List<Dept> getAll() {
		String sql = "select * from t_dept";
		List<Dept> list = jdbcTemplate.query(sql, new MyResult());
		return list;
	}
	
	class MyResult implements RowMapper<Dept>{
		// 如何封装一行记录,变成对象
		@Override
		public Dept mapRow(ResultSet rs, int index) throws SQLException {
			Dept dept = new Dept();
			dept.setDeptId(rs.getInt("deptId"));
			dept.setDeptName(rs.getString("deptName"));
			return dept;
		}	
	}
}


App2.java

package cn.atcast.h_jdbc;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App2 {
	// 容器对象
	ApplicationContext ac = new ClassPathXmlApplicationContext("cn/atcast/h_jdbc/bean.xml");
	@Test
	public void testApp() throws Exception {
		UserDao2 ud = (UserDao2) ac.getBean("userDao2");
		ud.save();
	}
}

App3.java

package cn.atcast.h_jdbc;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App3 {
	// 容器对象
	ApplicationContext ac = new ClassPathXmlApplicationContext("cn/atcast/h_jdbc/bean.xml");
	@Test
	public void testApp() throws Exception {
		UserDao3 ud = (UserDao3) ac.getBean("userDao3");
//		ud.save();
		System.out.println(ud.findById(1));
		System.out.println(ud.getAll());
	}
}

程序中的事务控制

程序中事务控制
程序的“事务控制”可以用aop实现。即只需要写一次，运行时候动态织入到业务方法上。Spring提供了对事务的管理，开发者只需要按照Spring的方式去做就行。
一个业务的成功：调用的service是执行成功的，意味着service中调用的所有的 dao是执行成功的。 事务应该在Service层统一控制。

细粒度的事务控制：可以对指定的方法、指定的方法的某几行添加事务控制
(比较灵活，但开发起来比较繁琐：每次都要开启、提交、回滚.)

粗粒度的事务控制只：能给整个方法应用事务，不可以对方法的某几行应用事务。】(因为aop拦截的是方法。)

声明式事务控制

Spring提供了对事务的管理, 这个就叫声明式事务管理。

Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理，只需要在配置文件中配置即可；不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦。

Spring声明式事务管理，核心实现就是基于Aop。

如何管理事务，事务是只读的还是读写的，对于查询的find()是只读，对于保存的 save()是读写

如果一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持SQL 执行期间的读一致性；

如果一次执行多条查询语句，例如统计查询，报表查询，在这种场景下，多条查询 SQL必须保证整体的读一致性，否则，在前条SQL查询之后，后条SQL查询之前，数据被其他用户改变，则该次整体的统计查询将会出现读数据不一致的状态，此时应该启用事务支持

read-only="true"表示该事务为只读事务，比如上面说的多条查询的这种情况可以使用只读事务，由于只读事务不存在数据的修改，因此数据库将会为只读事务提供一些优化手段。

在Spring的Hibernate封装中，指定只读事务的办法为：

bean配置文件中，prop属性增加“read-Only”
或者用注解方式@Transactional(readOnly=true)
Spring中设置只读事务是利用上面两种方式（根据实际情况）
在将事务设置成只读后，相当于将数据库设置成只读数据库，此时若要进行写的操作会出现错误。

代码分析

1) XML实现

	步骤：
	a） 引入spring-aop相关的4个jar文件
	b） 引入aop名称空间  【XML配置方式需要引入】
	c） 引入tx名称空间    【事务方式必须引入】

Dept.java

package cn.atcast.a_tx;
public class Dept {
	private int deptId;
	private String deptName;
	public int getDeptId() {
		return deptId;
	}
	public void setDeptId(int deptId) {
		this.deptId = deptId;
	}
	public String getDeptName() {
		return deptName;
	}
	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}
}

DeptDao.java

package cn.atcast.a_tx;
import org.springframework.jdbc.core.JdbcTemplate;
/**
 * dao实现，使用Spring对jdbc支持功能
 *
 */
public class DeptDao {
	// 容器注入JdbcTemplate对象
	private JdbcTemplate jdbcTemplate;
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	public void save(Dept dept){
String sql = "insert into t_dept (deptName) values(?)";
		jdbcTemplate.update(sql,dept.getDeptName());
	}
}

DeptService.java 业务层
需要Dao层的注入

package cn.atcast.a_tx;
import org.springframework.jdbc.core.JdbcTemplate;
/**
 * Service
 *
 */
public class DeptService {
	// 容器注入dao对象
	private DeptDao deptDao;
	public void setDeptDao(DeptDao deptDao) {
		this.deptDao = deptDao;
	}
	/*
	 * 事务控制
	 */
	public void save(Dept dept){
		// 第一次调用
		deptDao.save(dept);
     //int i = 1/0; // 异常： 整个Service.save()执行成 功的要回滚
		// 第二次调用 两次都成功事务才算成功  配置文件帮助回滚5. ****
		deptDao.save(dept);
	}
}

bean.xml

<?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">
	<!-- 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:///hib_demo"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
		<property name="initialPoolSize" value="3"></property>
		<property name="maxPoolSize" value="10"></property>
		<property name="maxStatements" value="100"></property>
		<property name="acquireIncrement" value="2"></property>
	</bean>

	
	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 3. dao实例 -->
	<bean id="deptDao" class="cn.atcast.a_tx.DeptDao">
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
 
	<!-- 4. service实例 -->
	<bean id="deptService" class="cn.atcast.a_tx.DeptService">
		<property name="deptDao" ref="deptDao"></property>
	</bean>
	
	<!-- #############5. Spring声明式事务管理配置############### -->
	<!-- 5.1 配置事务管理器类 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 5.2 配置事务增强(如何管理事务，对于找到的方法进行事务控制的描述，哪些事务是只读的还是读写的，对于查询的find()是只读，对于保存的save()是读写) -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<!-- <tx:method name="save*" read-only="false"/>
				<tx:method name="find*" read-only="true"/> 
			-->
			<tx:method name="*" read-only="false"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 5.3 Aop配置：通过切入点表达式找到需要spring进行事务控制的方法-->
	<aop:config>
		<aop:pointcut expression="execution(* cn.atcast.a_tx.*.*(..))" id="pt"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
	</aop:config>
</beans>

App.java

package cn.atcast.a_tx;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
	@Test
	public void testApp() throws Exception {
		//容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("cn/atcast/a_tx/bean.xml");
		// 模拟数据
		Dept dept = new Dept();
		dept.setDeptName("测试： 开发部");
		DeptService deptService = (DeptService) ac.getBean("deptService");
		deptService.save(dept);
	}
}

2)注解方式实现

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

dao层

@Repository  //持久层注解
public class DeptDao {
	
	@Autowired
	private JdbcTemplate jdbcTemplate;

	public void save(Dept dept){
		String sql = "insert into t_dept (deptName) values(?)";
		jdbcTemplate.update(sql,dept.getDeptName());
	}
}

bean.xml

<?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">

	
	<!-- 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:///hib_demo"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
		<property name="initialPoolSize" value="3"></property>
		<property name="maxPoolSize" value="10"></property>
		<property name="maxStatements" value="100"></property>
		<property name="acquireIncrement" value="2"></property>
	</bean>
	
	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 事务管理器类 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 开启注解扫描 -->
	<context:component-scan base-package="cn.atcast.b_anno"></context:component-scan>
	
	<!-- 注解方式实现事务： 指定注解方式实现事务 -->
	<tx:annotation-driven transaction-manager="txManager"/>
	
</beans>

业务层

@Service
@Transactional //写到这 这个类所有方法 都进行了事务管理
public class DeptService {
	
	// 部门dao
	@Autowired
	private DeptDao deptDao;
	
	//事务控制
	
	public void save(Dept dept){
		deptDao.save(dept);
		int i=1/0;
		deptDao.save(dept);
	}
	
	 
	public void delete(Dept dept){
		deptDao.save(dept);
		int i=1/0;
		deptDao.save(dept);
	}
		
	 
}

测试类

public class App {

	@Test
	public void testApp() throws Exception {
		//容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("cn/atcast/b_anno/bean.xml");
		// 模拟数据
		Dept dept = new Dept();
		dept.setDeptName("测试： 开发部");
		
		DeptService deptService = (DeptService) ac.getBean("deptService");
		deptService.save(dept);
	}
}

3) 事务传播行为

我执行经过了一个事务

当我遇到第二个操作我该怎么办?
A: 纳入自己的事务(常用) ------- 同生共死
B: 你在开一个事务
c: 无事务

详细介绍:

1、PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。(常用)
2、PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。‘
3、PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。
4、PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。

代码示例

两个操作 ,往两个表插入数据 , 业务类

DeptDao

/**
 * dao实现，使用Spring对jdbc支持功能
 */
@Repository
public class DeptDao {
	@Resource
	private JdbcTemplate jdbcTemplate;
	public void save(Dept dept){
String sql = "insert into t_dept (deptName) values(?)";
		jdbcTemplate.update(sql,dept.getDeptName());
	}
}

LogDao.java

// 测试： 日志传播行为
@Repository
public class LogDao {
	@Resource
	private JdbcTemplate jdbcTemplate;
	// 始终开启事务  
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void insertLog() {
		jdbcTemplate.update("insert into log_ values('在保存Dept..')");
	}
}

DeptService.java (重点)

@Service
public class DeptService {
   @Autowired
   private DeptDao deptDao;
  @Autowired
   private LogDao logDao;

@Transactional(
readOnly = false,// 读写事务
timeout=-1,// 事务的超时时间不限制(数据库有异常或没有连接上，等待的时间，但还是要看连接的数据库是如何设置的。)
//noRollbackFor = ArithmeticException.class,  // noRollbackFor设置遇到指定的错误不用回滚。此处是遇到数学异常不回滚
isolation = Isolation.DEFAULT,     // 事务的隔离级别，数据库的默认
propagation = Propagation.REQUIRED	// 事务的传播行为,此处是指当前的方法要在事务中去执行。
)
public void save(Dept dept){
        logDao.insertLog();  // 保存日志  【自己开启一个事务】
		
		deptDao.save(dept);  // 保存部门
		//int i = 1/0;
		deptDao.save(dept);  // 保存部门
}
}
}