聊聊 Spring 数据库开发

• 1. Spring JDBC
• Spring JDBC的配置
• 2. Spring JdbcTemplate的常用方法
  • execute()
• 总结

GitHub：https://github.com/nateshao/ssm/tree/master/104-spring-jdbc

1. Spring JDBC

Spring JDBC模块有什么作用?

Spring的JDBC模块负责数据库资源管理和错误处理，大大简化了开发人员对数据库的操作，使得开发人员可以从繁琐的数据库操作中解脱出来，从而将更多的精力投入到编写业务逻辑当中。

Spring JdbcTemplate的解析

针对数据库的操作，Spring框架提供了JdbcTemplate类，该类是Spring框架数据抽象层的基础。可以说，JdbcTemplate类是Spring JDBC的核心类。

JdbcTemplate类的继承结构具体如下图所示：

从JdbcTemplate的继承关系图可以看出，JdbcTemplate类的直接父类是JdbcAccessor，该类为子类提供了一些访问数据库时使用的公共属性。

DataSource：其主要功能是获取数据库连接，还可以引入对数据库连接的缓冲池和分布式事务的支持，它可以作为访问数据库资源的标准接口。

SQLExceptionTranslator：该接口负责对SQLException进行转译工作。通过必要的设置获取SQLExceptionTranslator中的方法，可以使JdbcTemplate在需要处理SQLException时，委托SQLExceptionTranslator的实现类来完成相关的转译工作。

而JdbcOperations接口定义了在JdbcTemplate类中可以使用的操作集合，包括添加、修改、查询和删除等操作。

Spring JDBC的配置

Spring JDBC模块主要由4个包组成，分别是core(核心包)、dataSource(数据源包)、object(对象包)和support(支持包)。

从上表可以看出，Spring对数据库的操作都封装在了这几个包中，而想要使用Spring JDBC，就需要对其进行配置。

1. "1.0"encoding="UTF-8"?>
2. "http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
6. --1配置数据源-->
7. "dataSource"class=
8. "org.springframework.jdbc.datasource.DriverManagerDataSource">
9. --数据库驱动-->
10. name="driverClassName"value="com.mysql.jdbc.Driver"/>
11. --连接数据库的url-->
12. name="url"value="jdbc:mysql://localhost:3306/spring"/>
13. --连接数据库的用户名-->
14. name="username"value="root"/>
15. --连接数据库的密码-->
16. name="password"value="123456"/>
18. --2配置JDBC模板-->
19. "jdbcTemplate"
20. class="org.springframework.jdbc.core.JdbcTemplate">
21. --默认必须使用数据源-->
22. name="dataSource"ref="dataSource"/>
25. --定义id为accountDao的Bean-->
26. "accountDao"class="com.nateshao.jdbc.AccountDaoImpl">
27. --将jdbcTemplate注入到accountDao实例中-->
28. name="jdbcTemplate"ref="jdbcTemplate"/>

关于上述示例dataSource配置中的4个属性说明，如下表所示：

注意：上表中的属性值在实际配置时，需要根据数据库类型和设置进行相应配置。

2. Spring JdbcTemplate的常用方法

“在JdbcTemplate核心类中，提供了大量的更新和查询数据库的方法，我们就是使用的这些方法来操作数据库的。

execute( )：execute(String sql)方法可用于执行sql语句update()：update())用于执行插入、更新和删除操作query()：query()用于执行数据查询操作

execute()

使用execute(String sql)方法执行建表的案例实现步骤如下：

• 在MySQL中创建一个名为spring的数据库;
• 创建Web项目，导入相关maven包;
• 创建Spring配置文件，配置数据源和JDBC模板;
• 创建测试类，
• 测试程序。

Spring.sql

1. CREATEDATABASEIFNOTEXISTS`spring`;
3. USE`spring`;
5. /*Tablestructurefortable`account`*/
7. DROPTABLEIFEXISTS`account`;
9. CREATETABLE`account`(
10. `id`int(11)NOTNULLAUTO_INCREMENT,
11. `username`varchar(50)DEFAULTNULL,
12. `balance`doubleDEFAULTNULL,
13. PRIMARYKEY(`id`)
14. )ENGINE=InnoDBAUTO_INCREMENT=6DEFAULTCHARSET=utf8;
16. /*Dataforthetable`account`*/
18. insertinto`account`(`id`,`username`,`balance`)values(2,'shaotongjie',2222),(3,'1',2222),(4,'a',2022),(5,'b',2322);

Account.java

1. packagecom.nateshao.jdbc;
3. /**
4. *@dateCreatedby邵桐杰on2021/10/1515:50
5. *@微信公众号程序员千羽
6. *@个人网站www.nateshao.cn
7. *@博客https://nateshao.gitee.io
8. *@GitHubhttps://github.com/nateshao
9. *@Giteehttps://gitee.com/nateshao
10. *Description:
11. */
12. @Data
13. publicclassAccount{
14. privateIntegerid;//账户id
15. privateStringusername;//用户名
16. privateDoublebalance;//账户余额
17. }

applicationContext.xml

1. "1.0"encoding="UTF-8"?>
2. "http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
6. --1配置数据源-->
7. "dataSource"class=
8. "org.springframework.jdbc.datasource.DriverManagerDataSource">
9. --数据库驱动-->
10. name="driverClassName"value="com.mysql.jdbc.Driver"/>
11. --连接数据库的url-->
12. name="url"value="jdbc:mysql://localhost:3306/spring?useSSL=false"/>
13. --连接数据库的用户名-->
14. name="username"value="root"/>
15. --连接数据库的密码-->
16. name="password"value="123456"/>
18. --2配置JDBC模板-->
19. "jdbcTemplate"
20. class="org.springframework.jdbc.core.JdbcTemplate">
21. --默认必须使用数据源-->
22. name="dataSource"ref="dataSource"/>
25. --定义id为accountDao的Bean-->
26. "accountDao"class="com.nateshao.jdbc.AccountDaoImpl">
27. --将jdbcTemplate注入到accountDao实例中-->
28. name="jdbcTemplate"ref="jdbcTemplate"/>

AccountDao.java

1. packagecom.nateshao.jdbc;
3. importjava.util.List;
5. /**
6. *@dateCreatedby邵桐杰on2021/10/1515:50
7. *@微信公众号程序员千羽
8. *@个人网站www.nateshao.cn
9. *@博客https://nateshao.gitee.io
10. *@GitHubhttps://github.com/nateshao
11. *@Giteehttps://gitee.com/nateshao
12. *Description:
13. */
14. publicinterfaceAccountDao{
15. //添加
16. publicintaddAccount(Accountaccount);
18. //更新
19. publicintupdateAccount(Accountaccount);
21. //删除
22. publicintdeleteAccount(intid);
24. //通过id查询
25. publicintqueryAccountById(intid);
26. //查询所有账户
27. publicListfindAllAccount();
29. AccountfindAccountById(inti);
30. }

AccountDaoImpl.java

1. packagecom.nateshao.jdbc;
3. importorg.springframework.jdbc.core.BeanPropertyRowMapper;
4. importorg.springframework.jdbc.core.JdbcTemplate;
5. importorg.springframework.jdbc.core.RowMapper;
6. importjava.util.List;
8. /**
9. *@dateCreatedby邵桐杰on2021/10/1515:55
10. *@微信公众号程序员千羽
11. *@个人网站www.nateshao.cn
12. *@博客https://nateshao.gitee.io
13. *@GitHubhttps://github.com/nateshao
14. *@Giteehttps://gitee.com/nateshao
15. *Description:
16. */
17. publicclassAccountDaoImplimplementsAccountDao{
18. //声明JdbcTemplate属性及其setter方法
19. privateJdbcTemplatejdbcTemplate;
21. publicvoidsetJdbcTemplate(JdbcTemplatejdbcTemplate){
22. this.jdbcTemplate=jdbcTemplate;
23. }
25. /**
26. *添加账户
27. *@paramaccount
28. *@return
29. */
30. publicintaddAccount(Accountaccount){
31. //定义SQL
32. Stringsql="insertintoaccount(username,balance)value(?,?)";
33. //定义数组来存放SQL语句中的参数
34. Object[]obj=newObject[]{
35. account.getUsername(),
36. account.getBalance()
37. };
38. //执行添加操作，返回的是受SQL语句影响的记录条数
39. intnum=this.jdbcTemplate.update(sql,obj);
40. returnnum;
41. }
43. /**
44. *更新账户
45. *@paramaccount
46. *@return
47. */
48. publicintupdateAccount(Accountaccount){
49. //定义SQL
50. Stringsql="updateaccountsetusername=?,balance=?whereid=?";
51. //定义数组来存放SQL语句中的参数
52. Object[]params=newObject[]{
53. account.getUsername(),
54. account.getBalance(),
55. account.getId()
56. };
57. //执行添加操作，返回的是受SQL语句影响的记录条数
58. intnum=this.jdbcTemplate.update(sql,params);
59. returnnum;
60. }
62. /**
63. *删除账户
64. *@paramid
65. *@return
66. */
67. publicintdeleteAccount(intid){
68. //定义SQL
69. Stringsql="deletefromaccountwhereid=?";
70. //执行添加操作，返回的是受SQL语句影响的记录条数
71. intnum=this.jdbcTemplate.update(sql,id);
72. returnnum;
73. }
75. @Override
76. publicintqueryAccountById(intid){
77. return0;
78. }
80. /**
81. *通过id查询账户数据信息
82. *@paramid
83. *@return
84. */
85. publicAccountfindAccountById(intid){
86. //定义SQL语句
87. Stringsql="select*fromaccountwhereid=?";
88. //创建一个新的BeanPropertyRowMapper对象
89. RowMapperrowMapper=
90. newBeanPropertyRowMapper(Account.class);
91. //将id绑定到SQL语句中，并通过RowMapper返回一个Object类型的单行记录
92. returnthis.jdbcTemplate.queryForObject(sql,rowMapper,id);
93. }
95. /**
96. *查询所有账户信息
97. *@return
98. */
99. publicListfindAllAccount(){
100. //定义SQL语句
101. Stringsql="select*fromaccount";
102. //创建一个新的BeanPropertyRowMapper对象
103. RowMapperrowMapper=
104. newBeanPropertyRowMapper(Account.class);
105. //执行静态的SQL查询，并通过RowMapper返回结果
106. returnthis.jdbcTemplate.query(sql,rowMapper);
107. }
109. }

测试类JdbcTemplateTest.java

1. packagecom.nateshao.jdbc;
3. importorg.junit.jupiter.api.Test;
4. importorg.springframework.context.ApplicationContext;
5. importorg.springframework.context.support.ClassPathXmlApplicationContext;
6. importorg.springframework.jdbc.core.JdbcTemplate;
7. importjava.util.List;
9. /**
10. *@dateCreatedby邵桐杰on2021/10/1515:57
11. *@微信公众号程序员千羽
12. *@个人网站www.nateshao.cn
13. *@博客https://nateshao.gitee.io
14. *@GitHubhttps://github.com/nateshao
15. *@Giteehttps://gitee.com/nateshao
16. *Description:
17. */
18. publicclassJdbcTemplateTest{
19. /**
20. *使用execute()方法建表
21. */
22. //publicstaticvoidmain(String[]args){
23. ////加载配置文件
24. //ApplicationContextapplicationContext=
25. //newClassPathXmlApplicationContext("applicationContext.xml");
26. ////获取JdbcTemplate实例
27. //JdbcTemplatejdTemplate=
28. //(JdbcTemplate)applicationContext.getBean("jdbcTemplate");
29. ////使用execute()方法执行SQL语句，创建用户账户管理表account
30. //jdTemplate.execute("createtableaccount("+
31. //"idintprimarykeyauto_increment,"+
32. //"usernamevarchar(50),"+
33. //"balancedouble)");
34. //System.out.println("账户表account创建成功！");
35. //}
36. @Test
37. publicvoidmainTest(){
38. //加载配置文件
39. ApplicationContextapplicationContext=
40. newClassPathXmlApplicationContext("applicationContext.xml");
41. //获取JdbcTemplate实例
42. JdbcTemplatejdTemplate=
43. (JdbcTemplate)applicationContext.getBean("jdbcTemplate");
44. //使用execute()方法执行SQL语句，创建用户账户管理表account
45. jdTemplate.execute("createtableaccount("+
46. "idintprimarykeyauto_increment,"+
47. "usernamevarchar(50),"+
48. "balancedouble)");
49. System.out.println("账户表account创建成功！");
50. }
52. @Test
53. publicvoidaddAccountTest(){
54. //加载配置文件
55. ApplicationContextapplicationContext=
56. newClassPathXmlApplicationContext("applicationContext.xml");
57. //获取AccountDao实例
58. AccountDaoaccountDao=
59. (AccountDao)applicationContext.getBean("accountDao");
60. //创建Account对象，并向Account对象中添加数据
61. Accountaccount=newAccount();
62. account.setUsername("千羽");
63. account.setBalance(1000.00);
64. //执行addAccount()方法，并获取返回结果
65. intnum=accountDao.addAccount(account);
66. if(num>0){
67. System.out.println("成功插入了"+num+"条数据！");
68. }else{
69. System.out.println("插入操作执行失败！");
70. }
71. }
73. @Test
74. publicvoidupdateAccountTest(){
75. //加载配置文件
76. ApplicationContextapplicationContext=
77. newClassPathXmlApplicationContext("applicationContext.xml");
78. //获取AccountDao实例
79. AccountDaoaccountDao=
80. (AccountDao)applicationContext.getBean("accountDao");
81. //创建Account对象，并向Account对象中添加数据
82. Accountaccount=newAccount();
83. account.setId(1);
84. account.setUsername("tom");
85. account.setBalance(2000.00);
86. //执行updateAccount()方法，并获取返回结果
87. intnum=accountDao.updateAccount(account);
88. if(num>0){
89. System.out.println("成功修改了"+num+"条数据！");
90. }else{
91. System.out.println("修改操作执行失败！");
92. }
93. }
95. @Test
96. publicvoiddeleteAccountTest(){
97. //加载配置文件
98. ApplicationContextapplicationContext=
99. newClassPathXmlApplicationContext("applicationContext.xml");
100. //获取AccountDao实例
101. AccountDaoaccountDao=
102. (AccountDao)applicationContext.getBean("accountDao");
103. //执行deleteAccount()方法，并获取返回结果
104. intnum=accountDao.deleteAccount(1);
105. if(num>0){
106. System.out.println("成功删除了"+num+"条数据！");
107. }else{
108. System.out.println("删除操作执行失败！");
109. }
110. }
112. @Test
113. publicvoidfindAccountByIdTest(){
114. //加载配置文件
115. ApplicationContextapplicationContext=
116. newClassPathXmlApplicationContext("applicationContext.xml");
117. //获取AccountDao实例
118. AccountDaoaccountDao=
119. (AccountDao)applicationContext.getBean("accountDao");
120. //执行findAccountById()方法
121. Accountaccount=accountDao.findAccountById(1);
122. System.out.println(account);
123. }
125. @Test
126. publicvoidfindAllAccountTest(){
127. //加载配置文件
128. ApplicationContextapplicationContext=
129. newClassPathXmlApplicationContext("applicationContext.xml");
130. //获取AccountDao实例
131. AccountDaoaccountDao=
132. (AccountDao)applicationContext.getBean("accountDao");
133. //执行findAllAccount()方法,获取Account对象的集合
134. Listaccount=accountDao.findAllAccount();
135. //循环输出集合中的对象
136. for(Accountact:account){
137. System.out.println(act);
138. }
139. }
140. }

多学一招：使用JUnit单元测试

在进行接口开发完成后，一般是写个单元测试or采用PostMan去测试，或者前端项目对接，一起调试。

在开发过程中，需要有相应的测试工作。依据测试目的不同，可以将软件测试分为单元测试、集成测试、确认测试和系统测试等。其中单元测试在软件开发阶段是最底层的测试，它易于及时发现并解决问题。JUnit就是一个进行单元测试的开源框架，下面以上个示例，来学习单元测试框架JUnit4的使用。

update()

update()方法可以完成插入、更新和删除数据的操作。在JdbcTemplate类中，提供了一系列的update()方法，其常用方法下表所示：

query()

“JdbcTemplate类中还提供了大量的query()方法来处理各种对数据库表的查询操作。其中，常用的几个query()方法如下表所示：

总结

这篇文章主要是对Spring框架中，使用JDBC进行数据操作的知识进行了详细讲解。

首先讲解了Spring JDBC中的核心类以及如何在Spring中配置JDBC，

然后通过案例讲解了Spring JDBC核心类JdbcTemplate中常用方法的使用。

通过这篇文章的学习，能够学会如何使用Spring框架进行数据库开发，并能深切的体会到Spring框架的强大。

原文链接：https://mp.weixin.qq.com/s/BvOzzcc2L9PUb4oXl4mxkw