数据库Spring的数据库编程浅入浅出

【金融特辑】光大银行科技部DBA女神带你从0到1揭秘MGR

 前言

先入门，把核心理解后再回过头来看这些我觉得效果更好，不知道说的对不对，要是理解不当，还望指教。此篇为Spring的数据库编程，主要讲jdbcTemplate，让初学者直接上手。

数据库切入

数据库编程是互联网编程的基础，Spring框架为开发者提供了JDBC模板模式，即jdbcTemplate，它可以简化许多代码，需要提醒的是jdbcTemplate在实际应用中并不常用，但我觉得对新手来说苍蝇再小也是肉，要想往前走，就得把这些小肉先吃了。

Spring JDBC配置

使用Spring JDBC操作数据库，需要对其进行配置，配置如下

1. --配置spring-jdbcTemplate--> 
2. --配置数据源-->  
3. "dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
4. --MySQL数据库驱动-->  
5. name="driverClassName" value="com.mysql.jdbc.Driver">  
6. --连接数据库的URL-->  
7. name="url" value="jdbc:mysql://localhost:3306/bbb?useUnicode=true&characterEncoding=UTF-8"> 
8. --连接数据库的用户名--> 
9. name="username" value="root">  
10. --连接数据库的密码--> 
11. name="password" value="root">  
12.   
13. --配置JDBC模板-->  
14. "jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
15. name="dataSource" ref="dataSource">  
16.  

 

配置JDBC模板时需要将dataSource注入到jdbcTemplate,而在数据访问层(Dao类)需要使用jdbcTemplate时也需要将jdbc Template注入到对应的Bean中，我在这演示用最简单的注解注入

1. @Repository("userDao")  
2. public class UserDaoImpl implements UserDao {  
3. @Autowired  
4. //使用配置文件中的JDBC模板  
5. private JdbcTemplate jdbcTemplate;  
6. } 

Spring Jdbc Template的常用方法

在上面我们获取了JDBC模板，下面我来说如何使用它。首先需要了解JdbcTemplate常用的方法，该类的常用方法是update和query.

1、public int update(String sql,Object args[])

该方法可以对数据表进行增加、修改、删除等操作。使用args[]设置SQL语句中的参数，并返回更新的行数。

示例如下：

1. public void add() {  
2. String insertSql = "insert into user values(null,?,?)";  
3. Object parem1[] = {"成功","123456"};  
4. jdbcTemplate.update(insertSql,parem1);  
5. System.out.println("UserDao中的添加功能实现了");  
6. } 

2、public List query(String sql,RowMapper rowMapper,Object args[])

该方法可以对数据表进行查询操作，rowMapper将结果集映射到用户自定义的类中(前提是自定义类中的属性要与数据表的字段对应)。

示例如下：

 

1. public void query() {  
2. String selectSql = "select * from user";  
3. RowMapper<User> rowMapper = new BeanPropertyRowMapper<User>(User.class);  
4. List<User> list = jdbcTemplate.query(selectSql,rowMapper,null);  
5. System.out.println("UserDao中的查询功能实现了"); 
6.  
7. } 

案例辅助

Pom.XML

1.  
2.  
3. junit 
4. junit 
5. 4.11 
6. test 
7.  
8.  
9. javax.servlet 
10. javax.servlet-api 
11. 3.1.0 
12.  
13.  
14.  
15.  
16. javax.servlet 
17. jstl 
18. 1.2 
19.  
20.  
21.  
22.  
23. mysql 
24. mysql-connector-java 
25. 5.1.38 
26.  
27. --spring核心依赖--> 
28.  
29. org.springframework 
30. spring-core 
31. 5.1.5.RELEASE 
32.  
33.  
34. org.springframework 
35. spring-beans 
36. 5.1.5.RELEASE 
37.  
38.  
39. org.springframework 
40. spring-context 
41. 5.1.5.RELEASE 
42.  
43.  
44. org.springframework 
45. spring-aop 
46. 5.1.5.RELEASE 
47.  
48.  
49. org.springframework 
50. spring-jdbc 
51. 5.1.5.RELEASE 
52.  
53.  
54. org.springframework 
55. spring-web 
56. 5.1.5.RELEASE 
57.  
58.  
59. org.springframework 
60. spring-webmvc 
61. 5.1.5.RELEASE 
62.  
63.  
64. org.springframework 
65. spring-expression 
66. 5.1.5.RELEASE 
67.  
68.  
69. org.springframework 
70. spring-tx 
71. 5.1.5.RELEASE 
72.  
73. --日志相关--> 
74.  
75. commons-logging 
76. commons-logging 
77. 1.2 
78.  
79.  
80.  
81.  

spring-config.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. xmlns:context="http://www.springframework.org/schema/context" 
5. xmlns:tx="http://www.springframework.org/schema/tx" 
6. xmlns:mvc="http://www.springframework.org/schema/mvc" 
7. xsi:schemaLocation="http://www.springframework.org/schema/beans 
8. http://www.springframework.org/schema/beans/spring-beans.xsd 
9. http://www.springframework.org/schema/context 
10. http://www.springframework.org/schema/context/spring-context.xsd 
11. http://www.springframework.org/schema/tx 
12. http://www.springframework.org/schema/tx/spring-tx.xsd 
13. http://www.springframework.org/schema/mvc 
14. http://www.springframework.org/schema/mvc/spring-mvc.xsd 
15. "> 
16. --配置注解要扫描的包--> 
17. "com.my"> 
18.  
19.  
20.  
21. --将指定类TestDaoImpl配置给Spring,让Spring创建其实例--> 
22. "testDIDao" class="com.my.dao.impl.TestDaoImpl"/> 
23. --使用构造方法注入--> 
24. ----> 
25. --<!–将TestDIDao注入到TestDIServiceImpl类的属性testDao上–>--> 
26. ----> 
27. ----> 
28. --使用setter方法注入--> 
29. "testDIService" class="com.my.service.impl.TestServiceImpl"> 
30. --调用TestDIServiceImpl类的setter方法，将TestDao注入到TestServiceImpl类的属性testDao上--> 
31. name="testDao" ref="testDIDao"> 
32.  
33.  
34.  
35. --配置spring-jdbcTemplate--> 
36. --配置数据源--> 
37. "dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 
38. --MySQL数据库驱动--> 
39. name="driverClassName" value="com.mysql.jdbc.Driver"> 
40. --连接数据库的URL--> 
41. name="url" value="jdbc:mysql://localhost:3306/bbb?useUnicode=true&characterEncoding=UTF-8"> 
42. --连接数据库的用户名--> 
43. name="username" value="root"> 
44. --连接数据库的密码--> 
45. name="password" value="root"> 
46.  
47. --配置JDBC模板--> 
48. "jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
49. name="dataSource" ref="dataSource"> 
50.  
51. --配置事务--> 
52. "txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
53. name="dataSource" ref="dataSource"> 
54.  
55. --注册事务注解驱动--> 
56. transaction-manager="txManager"> 
57.  

 

User

1. package com.my.pojo; 
2.  
3.  
4. public class User { 
5. private int id; 
6. private String username; 
7. private String password; 
8.  
9.  
10. public User() { 
11. } 
12.  
13.  
14. public User(int id, String username, String password) { 
15. this.id = id; 
16. this.username = username; 
17. this.password = password; 
18. } 
19.  
20.  
21. public int getId() { 
22. return id; 
23. } 
24.  
25.  
26. public void setId(int id) { 
27. this.id = id; 
28. } 
29.  
30.  
31. public String getUsername() { 
32. return username; 
33. } 
34.  
35.  
36. public void setUsername(String username) { 
37. this.username = username; 
38. } 
39.  
40.  
41. public String getPassword() { 
42. return password; 
43. } 
44.  
45.  
46. public void setPassword(String password) { 
47. this.password = password; 
48. } 
49.  
50.  
51. @Override 
52. public String toString() { 
53. return "User{" + 
54. "id=" + id + 
55. ", username='" + username + ''' + 
56. ", password='" + password + ''' + 
57. '}'; 
58. } 
59. } 

UserDao

1. package com.my.dao;   
2. public interface UserDao {  
3. public void add();  
4. public void delete();  
5. public void update();  
6. public void query();  
7. } 

UserDaoImpl

1. @Override 
2. public void update() { 
3. String updateSql = "update user set username=? , password=? where id =?"; 
4. Object parem3[] = {"修改","654321",3}; 
5. jdbcTemplate.update(updateSql,parem3); 
6. System.out.println("UserDao中的修改功能实现了"); 
7. } 
8.  
9.  
10. @Override 
11. public void query() { 
12. String selectSql = "select * from user"; 
13. RowMapper<User> rowMapper = new BeanPropertyRowMapper<User>(User.class); 
14. List<User> list = jdbcTemplate.query(selectSql,rowMapper,null); 
15. System.out.println("UserDao中的查询功能实现了"); 
16. for (User user : list){ 
17. System.out.println(user); 
18. } 
19. } 
20. } 

测试Test3

1. package com.my.test; 
2.  
3.  
4. import com.my.dao.UserDao; 
5. import org.springframework.beans.factory.annotation.Autowired; 
6. import org.springframework.context.ApplicationContext; 
7. import org.springframework.context.support.ClassPathXmlApplicationContext; 
8.  
9.  
10. public class Test3 { 
11. @Autowired 
12. private UserDao userDao; 
13.  
14.  
15. public static void main(String[] args) { 
16.  
17.  
18. ApplicationContext appCon = new ClassPathXmlApplicationContext("spring-config.xml"); 
19. //从容器中获取目标对象 
20. UserDao userDao = (UserDao) appCon.getBean("userDao"); 
21.  
22.  
23. //userDao.add(); 
24. userDao.delete(); 
25. userDao.update(); 
26. userDao.query(); 
27. } 
28. } 

测试结果

结束

对于Spring JbdcTemplate的讲解到此结束，对于新手来说没必要太复杂，能完成增删改查做个入门即可，等了解了再详细学习才有帮助，希望能对一些需要的朋友有用吧。

 严格来说，数据库是长期储存在计算机内、有组织的、可共享的数据集合。数据库中的数据指的是以一定的数据模型组织、描述和储存在一起、具有尽可能小的冗余度、较高的数据独立性和易扩展性的特点并可在一定范围内为多个用户共享。