资讯专栏INFORMATION COLUMN

Spring【DAO模块】就是这么简单

NSFish / 1199人阅读

摘要:连接对象执行命令对象执行关闭值得注意的是,对数据库连接池是有很好的支持的。给我们提供了事务的管理器类,事务管理器类又分为两种,因为的事务和的事务是不一样的。

前言

上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程,本博文主要讲解Spring的DAO模块对JDBC的支持,以及Spring对事务的控制...

对于JDBC而言,我们肯定不会陌生,我们在初学的时候肯定写过非常非常多的JDBC模板代码

回顾对模版代码优化过程

我们来回忆一下我们怎么对模板代码进行优化的!

首先来看一下我们原生的JDBC:需要手动去数据库的驱动从而拿到对应的连接..

</>复制代码

  1. try {
  2. String sql = "insert into t_dept(deptName) values("test");";
  3. Connection con = null;
  4. Statement stmt = null;
  5. Class.forName("com.mysql.jdbc.Driver");
  6. // 连接对象
  7. con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
  8. // 执行命令对象
  9. stmt = con.createStatement();
  10. // 执行
  11. stmt.execute(sql);
  12. // 关闭
  13. stmt.close();
  14. con.close();
  15. } catch (Exception e) {
  16. e.printStackTrace();
  17. }

因为JDBC是面向接口编程的,因此数据库的驱动都是由数据库的厂商给做到好了,我们只要加载对应的数据库驱动,便可以获取对应的数据库连接....因此,我们写了一个工具类,专门来获取与数据库的连接(Connection),当然啦,为了更加灵活,我们的工具类是读取配置文件的方式来做的

</>复制代码

  1. /*
  2. * 连接数据库的driver,url,username,password通过配置文件来配置,可以增加灵活性
  3. * 当我们需要切换数据库的时候,只需要在配置文件中改以上的信息即可
  4. *
  5. * */
  6. private static String driver = null;
  7. private static String url = null;
  8. private static String username = null;
  9. private static String password = null;
  10. static {
  11. try {
  12. //获取配置文件的读入流
  13. InputStream inputStream = UtilsDemo.class.getClassLoader().getResourceAsStream("db.properties");
  14. Properties properties = new Properties();
  15. properties.load(inputStream);
  16. //获取配置文件的信息
  17. driver = properties.getProperty("driver");
  18. url = properties.getProperty("url");
  19. username = properties.getProperty("username");
  20. password = properties.getProperty("password");
  21. //加载驱动类
  22. Class.forName(driver);
  23. } catch (IOException e) {
  24. e.printStackTrace();
  25. } catch (ClassNotFoundException e) {
  26. e.printStackTrace();
  27. }
  28. }
  29. public static Connection getConnection() throws SQLException {
  30. return DriverManager.getConnection(url,username,password);
  31. }
  32. public static void release(Connection connection, Statement statement, ResultSet resultSet) {
  33. if (resultSet != null) {
  34. try {
  35. resultSet.close();
  36. } catch (SQLException e) {
  37. e.printStackTrace();
  38. }
  39. }
  40. if (statement != null) {
  41. try {
  42. statement.close();
  43. } catch (SQLException e) {
  44. e.printStackTrace();
  45. }
  46. }
  47. if (connection != null) {
  48. try {
  49. connection.close();
  50. } catch (SQLException e) {
  51. e.printStackTrace();
  52. }
  53. }
  54. }

经过上面一层的封装,我们可以在使用的地方直接使用工具类来得到与数据库的连接...那么比原来就方便很多了!但是呢,每次还是需要使用Connection去创建一个Statement对象。并且无论是什么方法,其实就是SQL语句和传递进来的参数不同!

于是,我们就自定义了一个JDBC的工具类,详情可以看http://blog.csdn.net/hon_3y/article/details/53760782#t6

我们自定义的工具类其实就是以DbUtils组件为模板来写的,因此我们在开发的时候就一直使用DbUtils组件了

使用Spring的JDBC

上面已经回顾了一下以前我们的JDBC开发了,那么看看Spring对JDBC又是怎么优化的

首先,想要使用Spring的JDBC模块,就必须引入两个jar文件:

引入jar文件

spring-jdbc-3.2.5.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

首先还是看一下我们原生的JDBC代码:获取Connection是可以抽取出来的,直接使用dataSource来得到Connection就行了

</>复制代码

  1. public void save() {
  2. try {
  3. String sql = "insert into t_dept(deptName) values("test");";
  4. Connection con = null;
  5. Statement stmt = null;
  6. Class.forName("com.mysql.jdbc.Driver");
  7. // 连接对象
  8. con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
  9. // 执行命令对象
  10. stmt = con.createStatement();
  11. // 执行
  12. stmt.execute(sql);
  13. // 关闭
  14. stmt.close();
  15. con.close();
  16. } catch (Exception e) {
  17. e.printStackTrace();
  18. }
  19. }

值得注意的是,JDBC对C3P0数据库连接池是有很好的支持的。因此我们直接可以使用Spring的依赖注入,在配置文件中配置dataSource就行了

</>复制代码

</>复制代码

  1. // IOC容器注入
  2. private DataSource dataSource;
  3. public void setDataSource(DataSource dataSource) {
  4. this.dataSource = dataSource;
  5. }
  6. public void save() {
  7. try {
  8. String sql = "insert into t_dept(deptName) values("test");";
  9. Connection con = null;
  10. Statement stmt = null;
  11. // 连接对象
  12. con = dataSource.getConnection();
  13. // 执行命令对象
  14. stmt = con.createStatement();
  15. // 执行
  16. stmt.execute(sql);
  17. // 关闭
  18. stmt.close();
  19. con.close();
  20. } catch (Exception e) {
  21. e.printStackTrace();
  22. }
  23. }

Spring来提供了JdbcTemplate这么一个类给我们使用!它封装了DataSource,也就是说我们可以在Dao中使用JdbcTemplate就行了。

创建dataSource,创建jdbcTemplate对象

</>复制代码

userDao

</>复制代码

  1. package bb;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import org.springframework.stereotype.Component;
  5. /**
  6. * Created by ozc on 2017/5/10.
  7. */
  8. @Component
  9. public class UserDao implements IUser {
  10. //使用Spring的自动装配
  11. @Autowired
  12. private JdbcTemplate template;
  13. @Override
  14. public void save() {
  15. String sql = "insert into user(name,password) values("zhoggucheng","123")";
  16. template.update(sql);
  17. }
  18. }

测试:

</>复制代码

  1. @Test
  2. public void test33() {
  3. ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
  4. UserDao userDao = (UserDao) ac.getBean("userDao");
  5. userDao.save();
  6. }

JdbcTemplate查询

我们要是使用JdbcTemplate查询会发现有很多重载了query()方法

一般地,如果我们使用queryForMap(),那么只能封装一行的数据,如果封装多行的数据、那么就会报错!并且,Spring是不知道我们想把一行数据封装成是什么样的,因此返回值是Map集合...我们得到Map集合的话还需要我们自己去转换成自己需要的类型。

我们一般使用下面这个方法:

我们可以实现RowMapper,告诉Spriing我们将每行记录封装成怎么样的

</>复制代码

  1. public void query(String id) {
  2. String sql = "select * from USER where password=?";
  3. List query = template.query(sql, new RowMapper() {
  4. //将每行记录封装成User对象
  5. @Override
  6. public User mapRow(ResultSet resultSet, int i) throws SQLException {
  7. User user = new User();
  8. user.setName(resultSet.getString("name"));
  9. user.setPassword(resultSet.getString("password"));
  10. return user;
  11. }
  12. },id);
  13. System.out.println(query);
  14. }

当然了,一般我们都是将每行记录封装成一个JavaBean对象的,因此直接实现RowMapper,在使用的时候创建就好了

</>复制代码

  1. class MyResult implements RowMapper{
  2. // 如何封装一行记录
  3. @Override
  4. public Dept mapRow(ResultSet rs, int index) throws SQLException {
  5. Dept dept = new Dept();
  6. dept.setDeptId(rs.getInt("deptId"));
  7. dept.setDeptName(rs.getString("deptName"));
  8. return dept;
  9. }
  10. }
事务控制概述

下面主要讲解Spring的事务控制,如何使用Spring来对程序进行事务控制....

Spring的事务控制是属于Spring Dao模块的

一般地,我们事务控制都是在service层做的。。为什么是在service层而不是在dao层呢??有没有这样的疑问...

service层是业务逻辑层,service的方法一旦执行成功,那么说明该功能没有出错

一个service方法可能要调用dao层的多个方法...如果在dao层做事务控制的话,一个dao方法出错了,仅仅把事务回滚到当前dao的功能,这样是不合适的[因为我们的业务由多个dao方法组成]。如果没有出错,调用完dao方法就commit了事务,这也是不合适的[导致太多的commit操作]。

事务控制分为两种:

编程式事务控制

声明式事务控制

编程式事务控制

自己手动控制事务,就叫做编程式事务控制。

Jdbc代码:

Conn.setAutoCommite(false); // 设置手动控制事务

Hibernate代码:

Session.beginTransaction(); // 开启一个事务

【细粒度的事务控制: 可以对指定的方法、指定的方法的某几行添加事务控制】

(比较灵活,但开发起来比较繁琐: 每次都要开启、提交、回滚.)

声明式事务控制

Spring提供对事务的控制管理就叫做声明式事务控制

Spring提供了对事务控制的实现。

如果用户想要使用Spring的事务控制,只需要配置就行了

当不用Spring事务的时候,直接移除就行了。

Spring的事务控制是基于AOP实现的。因此它的耦合度是非常低的。

【粗粒度的事务控制: 只能给整个方法应用事务,不可以对方法的某几行应用事务。

(因为aop拦截的是方法。)

Spring给我们提供了事务的管理器类,事务管理器类又分为两种,因为JDBC的事务和Hibernate的事务是不一样的

Spring声明式事务管理器类:

Jdbc技术:DataSourceTransactionManager

Hibernate技术:HibernateTransactionManager

声明式事务控制

我们基于Spring的JDBC来做例子吧

引入相关jar包

AOP相关的jar包【因为Spring的声明式事务控制是基于AOP的,那么就需要引入AOP的jar包。】

引入tx名称空间

引入AOP名称空间

引入jdbcjar包【jdbc.jar包和tx.jar包】

搭建配置环境

编写一个接口

</>复制代码

  1. public interface IUser {
  2. void save();
  3. }

UserDao实现类,使用JdbcTemplate对数据库进行操作!

</>复制代码

  1. @Repository
  2. public class UserDao implements IUser {
  3. //使用Spring的自动装配
  4. @Autowired
  5. private JdbcTemplate template;
  6. @Override
  7. public void save() {
  8. String sql = "insert into user(name,password) values("zhong","222")";
  9. template.update(sql);
  10. }
  11. }

userService

</>复制代码

  1. @Service
  2. public class UserService {
  3. @Autowired
  4. private UserDao userDao;
  5. public void save() {
  6. userDao.save();
  7. }
  8. }

bean.xml配置:配置数据库连接池、jdbcTemplate对象、扫描注解

</>复制代码

前面搭建环境的的时候,是没有任何的事务控制的。

也就是说,当我在service中调用两次userDao.save(),即时在中途中有异常抛出,还是可以在数据库插入一条记录的

Service代码:

</>复制代码

  1. @Service
  2. public class UserService {
  3. @Autowired
  4. private UserDao userDao;
  5. public void save() {
  6. userDao.save();
  7. int i = 1 / 0;
  8. userDao.save();
  9. }
  10. }

测试代码:

</>复制代码

  1. public class Test2 {
  2. @Test
  3. public void test33() {
  4. ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
  5. UserService userService = (UserService) ac.getBean("userService");
  6. userService.save();
  7. }
  8. }

XML方式实现声明式事务控制

首先,我们要配置事务的管理器类:因为JDBC和Hibernate的事务控制是不同的。

</>复制代码

再而,配置事务管理器类如何管理事务

</>复制代码

最后,配置拦截哪些方法,

</>复制代码

配置完成之后,service中的方法都应该被Spring的声明式事务控制了。因此我们再次测试一下:

</>复制代码

  1. @Test
  2. public void test33() {
  3. ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
  4. UserService userService = (UserService) ac.getBean("userService");
  5. userService.save();
  6. }

使用注解的方法实现事务控制

当然了,有的人可能觉得到XML文件上配置太多东西了。Spring也提供了使用注解的方式来实现对事务控制

第一步和XML的是一样的,必须配置事务管理器类:

</>复制代码

第二步:开启以注解的方式来实现事务控制

</>复制代码

最后,想要控制哪个方法事务,在其前面添加@Transactional这个注解就行了!如果想要控制整个类的事务,那么在类上面添加就行了。

</>复制代码

  1. @Transactional
  2. public void save() {
  3. userDao.save();
  4. int i = 1 / 0;
  5. userDao.save();
  6. }

事务属性

其实我们在XML配置管理器类如何管理事务,就是在指定事务的属性!我们来看一下事务的属性有什么:

对于事务的隔离级别,不清楚的朋友可参考我之前的博文:http://blog.csdn.net/hon_3y/article/details/53760782

事务传播行为:

看了上面的事务属性,没有接触过的其实就这么一个:propagation = Propagation.REQUIRED事务的传播行为。

事务传播行为的属性有以下这么多个,常用的就只有两个:

Propagation.REQUIRED【如果当前方法已经有事务了,加入当前方法事务

Propagation.REQUIRED_NEW【如果当前方法有事务了,当前方法事务会挂起。始终开启一个新的事务,直到新的事务执行完、当前方法的事务才开始】

当事务传播行为是Propagation.REQUIRED

现在有一个日志类,它的事务传播行为是Propagation.REQUIRED

</>复制代码

  1. Class Log{
  2. Propagation.REQUIRED
  3. insertLog();
  4. }

现在,我要在保存之前记录日志

</>复制代码

  1. Propagation.REQUIRED
  2. Void saveDept(){
  3. insertLog();
  4. saveDept();
  5. }

saveDept()本身就存在着一个事务,当调用insertLog()的时候,insertLog()的事务会加入到saveDept()事务中

也就是说,saveDept()方法内始终是一个事务,如果在途中出现了异常,那么insertLog()的数据是会被回滚的【因为在同一事务内】

</>复制代码

  1. Void saveDept(){
  2. insertLog(); // 加入当前事务
  3. .. 异常, 会回滚
  4. saveDept();
  5. }
当事务传播行为是Propagation.REQUIRED_NEW

现在有一个日志类,它的事务传播行为是Propagation.REQUIRED_NEW

</>复制代码

  1. Class Log{
  2. Propagation.REQUIRED
  3. insertLog();
  4. }

现在,我要在保存之前记录日志

</>复制代码

  1. Propagation.REQUIRED
  2. Void saveDept(){
  3. insertLog();
  4. saveDept();
  5. }

当执行到saveDept()中的insertLog()方法时,insertLog()方法发现 saveDept()已经存在事务了,insertLog()会独自新开一个事务,直到事务关闭之后,再执行下面的方法

如果在中途中抛出了异常,insertLog()是不会回滚的,因为它的事务是自己的,已经提交了

</>复制代码

  1. Void saveDept(){
  2. insertLog(); // 始终开启事务
  3. .. 异常, 日志不会回滚
  4. saveDept();
  5. }

</>复制代码

  1. 如果文章有错的地方欢迎指正,大家互相交流。习惯在微信看技术文章,想要获取更多的Java资源的同学,可以关注微信公众号:Java3y

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/68806.html

相关文章

  • Spring【依赖注入】就是这么简单

    摘要:前言在的第二篇中主要讲解了模块的使用容器创建对象的问题,模块主要是解决对象的创建和对象之间的依赖关系,因此本博文主要讲解如何使用容器来解决对象之间的依赖关系回顾以前对象依赖我们来看一下我们以前关于对象依赖,是怎么的历程直接对象在最开始,我们 前言 在Spring的第二篇中主要讲解了Spring Core模块的使用IOC容器创建对象的问题,Spring Core模块主要是解决对象的创建和...

    Lyux 评论0 收藏0
  • 纳税服务系统【总结】

    摘要:要是使用到日历的话,我们想到使用这个日历类上面仅仅是我个人总结的要点,如果有错误的地方还请大家给我指正。 纳税服务系统总结 纳税服务系统是我第一个做得比较大的项目(不同于javaWeb小项目),该项目系统来源于传智Java32期,十天的视频课程(想要视频的同学关注我的公众号就可以直接获取了) 我跟着练习一步一步完成需求,才发觉原来Java是这样用来做网站的,Java有那么多的类库,页面...

    ispring 评论0 收藏0
  • Spring入门看这一篇就够了

    摘要:甲乙交易活动不需要双方见面,避免了双方的互不信任造成交易失败的问题。这就是的核心思想。统一配置,便于修改。带参数的构造函数创建对象首先,就要提供带参数的构造函数接下来,关键是怎么配置文件了。 前言 前面已经学习了Struts2和Hibernate框架了。接下来学习的是Spring框架...本博文主要是引入Spring框架... Spring介绍 Spring诞生: 创建Spring的...

    superw 评论0 收藏0
  • Spring【AOP模块就是这么简单

    摘要:可以通过切入点表达式,指定拦截哪些类的哪些方法给指定的类在运行的时候植入切面类代码。 前言 到目前为止,已经简单学习了Spring的Core模块、....于是我们就开启了Spring的AOP模块了...在讲解AOP模块之前,首先我们来讲解一下cglib代理、以及怎么手动实现AOP编程 cglib代理 在讲解cglib之前,首先我们来回顾一下静态代理和动态代理....我之前就写过了静态代...

    whjin 评论0 收藏0
  • Springboot简单应用

    摘要:第一步首先创建一个简单的工程,这里也可以用上的模版。第二步建立需要用到的数据库表,及数据。第三步建立项目的各个模块,实现相应的逻辑。模块就是一个简单的调用方法,代码如下模块代码如下参数为必填项至此,整个项目创建完成,然后就是启动测试了。 一直用SpringMVC+Spring开发,虽然用了这么久,但对里面繁琐的配置还是很头疼,这种情况改用Springboot,无疑是个很好的选择。废话不...

    zhunjiee 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<