当前位置：主页 > 查看内容

Spring的数据库编程浅入浅出

发布时间：2021-05-21 00:00| 有 位朋友查看

简介：前言 先入门，把核心理解后再回过头来看这些我觉得效果更好，不知道说的对不对，要是理解不当，还望指教。此篇为Spring的数据库编程，主要讲jdbcTemplate，让初学者直接上手。 数据库切入 数据库编程是互联网编程的基础，Spring框架为开发者提供了JDBC模板模……

 前言

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

数据库切入

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

Spring JDBC配置

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

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

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

spring-config.xml

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <beans xmlns="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. <context:component-scan base-package="com.my"></context:component-scan> 
  18. <mvc:annotation-driven></mvc:annotation-driven> 
  19.  
  20.  
  21. <!--将指定类TestDaoImpl配置给Spring,让Spring创建其实例--> 
  22. <bean id="testDIDao" class="com.my.dao.impl.TestDaoImpl"/> 
  23. <!--使用构造方法注入--> 
  24. <!--<bean id="testDIService" class="com.my.service.impl.TestServiceImpl" >--> 
  25. <!--&lt;!&ndash;将TestDIDao注入到TestDIServiceImpl类的属性testDao上&ndash;&gt;--> 
  26. <!--<constructor-arg index="0" ref="testDIDao"/>--> 
  27. <!--</bean>--> 
  28. <!--使用setter方法注入--> 
  29. <bean id="testDIService" class="com.my.service.impl.TestServiceImpl"> 
  30. <!--调用TestDIServiceImpl类的setter方法，将TestDao注入到TestServiceImpl类的属性testDao上--> 
  31. <property name="testDao" ref="testDIDao"></property> 
  32. </bean> 
  33.  
  34.  
  35. <!--配置spring-jdbcTemplate--> 
  36. <!--配置数据源--> 
  37. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 
  38. <!--MySQL数据库驱动--> 
  39. <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> 
  40. <!--连接数据库的URL--> 
  41. <property name="url" value="jdbc:mysql://localhost:3306/bbb?useUnicode=true&amp;characterEncoding=UTF-8"></property> 
  42. <!--连接数据库的用户名--> 
  43. <property name="username" value="root"></property> 
  44. <!--连接数据库的密码--> 
  45. <property name="password" value="root"></property> 
  46. </bean> 
  47. <!--配置JDBC模板--> 
  48. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
  49. <property name="dataSource" ref="dataSource"></property> 
  50. </bean> 
  51. <!--配置事务--> 
  52. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
  53. <property name="dataSource" ref="dataSource"></property> 
  54. </bean> 
  55. <!--注册事务注解驱动--> 
  56. <tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven> 
  57. </beans> 

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


本文转载自网络，原文链接：https://mp.weixin.qq.com/s/cu89J4HwMsbb43xfLlQSaQ
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！
上一篇：1.3万亿条数据查询如何做到毫秒级响应？ 下一篇：为什么Zookeeper天生就是一副分布式锁的胚子？

推荐图文

  • 周排行
  • 月排行
  • 总排行

随机推荐