JdbcTemplate
需求
=如果程序员就希望使用 spring 框架来做项目，spring 框架如何处理对数据库的操作呢?
方案 1. 使用前面做项目开发的 JdbcUtils 类
方案 2. 其实 spring 提供了一个操作数据库(表)功能强大的类 JdbcTemplate 。我们可以同ioc 容器来配置一个 jdbcTemplate 对象，使用它来完成对数据库表的各种操作.
官方文档
JdbcTemplate APIs : /spring-framework-5.3.8/docs/javadoc-api/index.html
JdbcTemplate-基本介绍
● 基本介绍
1. 通过 Spring 可以配置数据源，从而完成对数据表的操作
2. JdbcTemplate 是 Spring 提供的访问数据库的技术。可以将 JDBC 的常用操作封装为模板方法。[JdbcTemplate 类图].
JdbcTemplate 使用实例
需求说明
我们使用 spring 的方式来完成 JdbcTemplate 配置和使用JdbcTemplate 使用-代码演示
引入使用 JdbcTemplate 需要的 jar 包
创建数据库 spring 和表 monster
1. -- 创建数据库 2. CREATE DATABASE spring 3. USE spring 4. -- 创建表 monster 5. CREATE TABLE monster( 6. id INT PRIMARY KEY, `name` VARCHAR(64) NOT NULL DEFAULT '', 7. 韩顺平 Java 工程师 8. skill VARCHAR(64) NOT NULL DEFAULT '' )CHARSET=utf8 9. INSERT INTO monster VALUES(100, '青牛怪', '吐火'); 10. INSERT INTO monster VALUES(200, '黄袍怪', '吐烟'); 11. INSERT INTO monster VALUES(300, '蜘蛛怪', '吐丝');
创建配置文件 src/jdbc.properties
1. jdbc.user=root 2. jdbc.pwd=你的数据库密码 3. jdbc.driver=com.mysql.jdbc.Driver 4. jdbc.url=jdbc:mysql://localhost:你的数据库端口/数据库名字 5. 6. 例如我的 7. jdbc.user=root 8. jdbc.pwd=xxxx 9. jdbc.driver=com.mysql.jdbc.Driver 10. jdbc.url=jdbc:mysql://localhost:3306/spring
创建配置文件 src/JdbcTemplate_ioc.xml
1. <!--引入外部的jdbc.properties文件--> 2. <context:property-placeholder location="classpath:jdbc.properties"/> 3. <!--配置数据源对象-DataSoruce--> 4. <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource"> 5. <!--给数据源对象配置属性值--> 6. <property name="user" value="${jdbc.user}"/> 7. <property name="password" value="${jdbc.pwd}"/> 8. <property name="driverClass" value="${jdbc.driver}"/> 9. <property name="jdbcUrl" value="${jdbc.url}"/> 10. </bean>
创建类JdbcTemplateTest测试是否可以正确得到数据源
1. @Test 2. public void testDatasourceByJdbcTemplate() throws SQLException { 3. //获取到容器 4. ApplicationContext ioc = 5. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 6. 7. DataSource dataSource = ioc.getBean(DataSource.class); 8. Connection connection = dataSource.getConnection(); 9. System.out.println("获取到connection= " + connection); 10. connection.close(); 11. System.out.println("ok"); 12. }
配置 JdbcTemplate_ioc.xml，将数据源分配给 JdbcTemplate bean
1. <!--引入外部的jdbc.properties文件--> 2. <context:property-placeholder location="classpath:jdbc.properties"/> 3. <!--配置数据源对象-DataSoruce--> 4. <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource"> 5. <!--给数据源对象配置属性值--> 6. <property name="user" value="${jdbc.user}"/> 7. <property name="password" value="${jdbc.pwd}"/> 8. <property name="driverClass" value="${jdbc.driver}"/> 9. <property name="jdbcUrl" value="${jdbc.url}"/> 10. </bean> 11. 12. <!--配置JdbcTemplate对象--> 13. <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate"> 14. <!--给JdbcTemplate对象配置dataSource--> 15. <property name="dataSource" ref="dataSource"/> 16. </bean>
创建和数据库对应的字段类
1. public class Monster { 2. private Integer monsterId; 3. private String name; 4. private String skill; 5. 6. //全参构造器 7. public Monster(Integer monsterId, String name, String skill) { 8. this.monsterId = monsterId; 9. this.name = name; 10. this.skill = skill; 11. } 12. 13. 14. //无参构造器一定要写，Spring反射创建对象时，需要使用 15. public Monster() { 16. } 17. 18. public Integer getMonsterId() { 19. return monsterId; 20. } 21. 22. public void setMonsterId(Integer monsterId) { 23. this.monsterId = monsterId; 24. } 25. 26. public String getName() { 27. return name; 28. } 29. 30. public void setName(String name) { 31. this.name = name; 32. } 33. 34. public String getSkill() { 35. return skill; 36. } 37. 38. public void setSkill(String skill) { 39. this.skill = skill; 40. } 41. 42. @Override 43. public String toString() { 44. return "Monster{" + 45. "monsterId=" + monsterId + 46. ", name='" + name + '\'' + 47. ", skill='" + skill + '\'' + 48. '}'; 49. } 50. }
1. 修改 JdbcTemplateTest.java，添加一个新的 monster
1. @Test 2. public void addDataByJdbcTemplate() { 3. //获取到容器 4. ApplicationContext ioc = 5. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 6. 7. //获取JdbcTemplate对象 8. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class); 9. //1. 添加方式1 10. //String sql = "INSERT INTO monster VALUES(400, '红孩儿', '枪法')"; 11. //jdbcTemplate.execute(sql); 12. //2. 添加方式2 13. String sql = "INSERT INTO monster VALUES(?, ?, ?)"; 14. //affected表示 执行后表受影响的记录数 15. int affected = jdbcTemplate.update(sql, 500, "红孩儿2", "枪法2"); 16. System.out.println("add ok affected=" + affected); 17. 18. 19. }
2. 修改 JdbcTemplateTest.java，更新一个 monster 的 skill
1. @Test 2. public void updateDataByJdbcTemplate() { 3. 4. //获取到容器 5. ApplicationContext ioc = 6. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 7. 8. //获取JdbcTemplate对象 9. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class); 10. 11. //组织SQL 12. String sql = "UPDATE monster SET skill=? WHERE id=?"; 13. int affected = jdbcTemplate.update(sql, "美女计", 300); 14. System.out.println("update ok affected= " + affected); 15. 16. }
3.修改 JdbcTemplateTest.java，批量添加二个 monster 白蛇精和青
1. 对于某个类， 有很多API, 使用的步骤
2. 使用技巧
(1) 先确定API名字
(2) 根据API提供相应的参数 [组织参数]
(3) 把自己的调用思路清晰
(4) 根据API, 可以推测类似的用法和功能
1. //批量添加二个monster 白蛇精和青蛇精 2. @Test 3. public void addBatchDataByJdbcTemplate() { 4. ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 5. //得到JdbcTemplate bean 6. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);//添加.. 7. 8. //1. 先确定,猜测API名称 batchUpdate[如果出现问题，才重新玩] 9. //public int[] batchUpdate(String sql, List<Object[]> batchArgs){} 10. //2. 准备参数 11. String sql = "INSERT INTO monster VALUES(?, ?, ?)"; 12. List<Object[]> batchArgs = new ArrayList<>(); 13. batchArgs.add(new Object[]{600, "老鼠精", "偷吃粮食"}); 14. batchArgs.add(new Object[]{700, "老猫精", "抓老鼠"}); 15. //3. 调用 16. //说明：返回结果是一个数组，每个元素对应上面的sql语句对表的影响记录数 17. int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); 18. //输出 19. for (int anInt : ints) { 20. System.out.println("anInt=" + anInt); 21. } 22. System.out.println("batch add ok.."); 23. }
4.查询 id=100 的 monster 并封装到并封装到Monster实体对象[在实际开发中，非常有用]
1. public void selectDataByJdbcTemplate() { 2. ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 3. //得到JdbcTemplate bean 4. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class); 5. //组织SQL 6. //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中. 7. 8. //1. 确定API ： queryForObject() 9. //public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) 10. //2.准备参数 11. String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERE id = 100"; 12. //使用RowMapper 接口来对返回的数据，进行一个封装-》底层使用的反射->setter 13. //这里有一个细节: 你查询的记录的表的字段需要和 Monster的对象字段名保持一致 14. RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class); 15. //jdbcTemplate 16. Monster monster = jdbcTemplate.queryForObject(sql, rowMapper); 17. System.out.println("monster= " + monster); 18. System.out.println("查询ok"); 19. 20. }
5.查询id>=200的monster并封装到Monster实体对象
注意因为配置的对应类的id是 monsterId
所以我们在使用的过程中需要用monsterId 这就是为什么要取一个别名。
通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中.
1. @Test 2. public void selectMulDataByJdbcTemplate() { 3. ApplicationContext ioc = 4. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 5. //得到JdbcTemplate bean 6. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class); 7. //组织SQL 8. //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中. 9. 10. //1. 确定API 11. //public <T> T query(String sql, RowMapper<T> rowMapper, Object... args){} 12. //2. 组织参数 13. String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERE id >= ?"; 14. RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class); 15. //3. 调用 16. List<Monster> monsterList = jdbcTemplate.query(sql, rowMapper, 100); 17. for (Monster monster : monsterList) { 18. System.out.println("monster= " + monster); 19. } 20. }
6.查询返回结果只有一行一列的值，比如查询id=100的怪物名
1. /** 2. * 查询返回结果只有一行一列的值 3. */ 4. @Test 5. public void selectScalarByJdbcTemplate() { 6. ApplicationContext ioc = 7. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 8. //得到JdbcTemplate bean 9. JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class); 10. 11. //1. 确定API 12. //public <T> T queryForObject(String sql, Class<T> requiredType) 13. //2. 提供参数 14. String sql = "SELECT NAME FROM monster WHERE id = 100"; 15. //Class<T> requiredType 表示你返回的单行单列的数据类型 16. 17. String name = 18. jdbcTemplate.queryForObject(sql, String.class); 19. System.out.println("返回name= " + name); 20. 21. }
7.使用Map传入具名参数完成操作，比如添加 螃蟹精.:name 就是具名参数形式需要使用NamedParameterJdbcTemplate 类
修改JdbcTemplate_ioc.xml, 增加配置
1. <!--引入外部的jdbc.properties文件--> 2. <context:property-placeholder location="classpath:jdbc.properties"/> 3. <!--配置数据源对象-DataSoruce--> 4. <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource"> 5. <!--给数据源对象配置属性值--> 6. <property name="user" value="${jdbc.user}"/> 7. <property name="password" value="${jdbc.pwd}"/> 8. <property name="driverClass" value="${jdbc.driver}"/> 9. <property name="jdbcUrl" value="${jdbc.url}"/> 10. </bean> 11. 12. <!--配置JdbcTemplate对象--> 13. <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate"> 14. <!--给JdbcTemplate对象配置dataSource--> 15. <property name="dataSource" ref="dataSource"/> 16. </bean> 17. 18. <!--配置NamedParameterJdbcTemplate对象--> 19. <bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate" 20. id="namedParameterJdbcTemplate"> 21. <!--通过构造器，设置数据源--> 22. <constructor-arg name="dataSource" ref="dataSource"/> 23. </bean>
开始测试
1. @Test 2. public void testDataByNamedParameterJdbcTemplate() { 3. ApplicationContext ioc = 4. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 5. //得到NamedParameterJdbcTemplate bean 6. NamedParameterJdbcTemplate namedParameterJdbcTemplate = 7. ioc.getBean(NamedParameterJdbcTemplate.class); 8. 9. //1. 确定使用API 10. //public int update(String sql, Map<String, ?> paramMap) 11. //2. 准备参数 [:my_id, :name, :skill] 要求按照规定的名字来设置参数 12. String sql = "INSERT INTO monster VALUES(:id, :name, :skill)"; 13. Map<String, Object> paramMap = new HashMap<>(); 14. //给paramMap填写数据 15. paramMap.put("id", 800); 16. paramMap.put("name", "蚂蚁精"); 17. paramMap.put("skill", "喜欢打洞"); 18. //3. 调用 19. int affected = namedParameterJdbcTemplate.update(sql, paramMap); 20. System.out.println("add ok affected=" + affected); 21. 22. 23. }
8.使用sqlparametersoruce 来封装具名参数,还是添加一个Monster 狐狸精
1. @Test 2. public void operDataBySqlparametersoruce() { 3. ApplicationContext ioc = 4. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 5. //得到NamedParameterJdbcTemplate bean 6. NamedParameterJdbcTemplate namedParameterJdbcTemplate = 7. ioc.getBean(NamedParameterJdbcTemplate.class); 8. 9. //确定API 10. //public int update(String sql, SqlParameterSource paramSource) 11. //public BeanPropertySqlParameterSource(Object object) 12. //准备参数 13. String sql = "INSERT INTO monster VALUES(:monsterId, :name, :skill)"; 14. Monster monster = new Monster(900, "大象精", "搬运木头"); 15. SqlParameterSource sqlParameterSource = 16. new BeanPropertySqlParameterSource(monster); 17. //调用 18. int affected = 19. namedParameterJdbcTemplate.update(sql, sqlParameterSource); 20. 21. System.out.println("add ok affected= " + affected); 22. }
9.Dao 对象中使用 JdbcTemplate 完成对数据操作
创建MonsterDao类
1. @Repository //将MonsterDao 注入到spring容器 2. public class MonsterDao { 3. 4. //注入一个属性 5. @Resource 6. private JdbcTemplate jdbcTemplate; 7. 8. //完成保存任务 9. public void save(Monster monster) { 10. //组织sql 11. String sql = "INSERT INTO monster VALUES(?,?,?)"; 12. int affected = jdbcTemplate.update 13. (sql, monster.getMonsterId(), monster.getName(), monster.getSkill()); 14. System.out.println("affected= " + affected); 15. } 16. }
修改JdbcTemplate_ioc.xml, 增加配置
1. <!--配置要扫描包--> 2. <context:component-scan 3. base-package="com.spring.jdbctemplate.dao"/> 4. 5. <!--引入外部的jdbc.properties文件--> 6. <context:property-placeholder location="classpath:jdbc.properties"/> 7. <!--配置数据源对象-DataSoruce--> 8. <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource"> 9. <!--给数据源对象配置属性值--> 10. <property name="user" value="${jdbc.user}"/> 11. <property name="password" value="${jdbc.pwd}"/> 12. <property name="driverClass" value="${jdbc.driver}"/> 13. <property name="jdbcUrl" value="${jdbc.url}"/> 14. </bean> 15. 16. <!--配置JdbcTemplate对象--> 17. <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate"> 18. <!--给JdbcTemplate对象配置dataSource--> 19. <property name="dataSource" ref="dataSource"/> 20. </bean> 21. 22. <!--配置NamedParameterJdbcTemplate对象--> 23. <bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate" 24. id="namedParameterJdbcTemplate"> 25. <!--通过构造器，设置数据源--> 26. <constructor-arg name="dataSource" ref="dataSource"/> 27. </bean> 28. </beans>
测试
1. //测试MonsterDAO 2. @Test 3. public void monsterDaoSave() { 4. ApplicationContext ioc = 5. new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml"); 6. 7. MonsterDao monsterDao = ioc.getBean(MonsterDao.class); 8. Monster monster = new Monster(1000, "小鸭精", "吃鱼"); 9. monsterDao.save(monster); 10. System.out.println("MonsterDAO保存 ok .."); 11. }
