JDBCTemplate的好处：

1.可以实现将查询到的数据自动分装为实体类对象
2.可以不用在执行增删改以后释放prepareStatement 对象和connection对象了

项目的框架：

项目的框架.png
可以看到项目里面使用到了7个jar包这七个jar包缺一不可的，
1.和前面两个案例01,02一样我们使先试用druid这个jar包创建一了一个工具类，提供了得到Connection和Datasource对象的方法。
2.创建了一个user的实体类，后期可以使用JDBCTemplate直接将查询到的数据封装成为User对象。

用到的方法

/*
 使用JDBCTemplate来实现对mysql数据库的操作
前提：结合前面的Druid来得到DateSource

使用JDBCtemplate的好处就是我们不用再自己去关闭数据库的连接了

1。将查询到的结果封装成为对象并且放到list集合里面
 List userlist = jdbcTemplate.query(sql, new BeanPropertyRowMapper(User.class));
2.将查询到的每一条记录封装成为Map集合，并且将map集合放到一个list集合里面
 List> maps = jdbcTemplate.queryForList(sql);
3.将查询到的结果放到Map集合里面去，！！！！ 只支持查询结果是一条记录的时候，亮条记录的时候就会报错
 Map stringObjectMap = jdbcTemplate.queryForMap(sql2,133);

 这三种方法都可以先将sql语句里面的参数用占位符？？ 代替，在执行的时候进行补全

/

实体类代码

注意：实体类的变量名 ， 属性名 要和你的数据库里面的字段的名字一模一样，不然无法自动封装为User对象

  1. package bean;
  3. public class User {
  5.     private int id;
  6.     private String name ;
  7.     private int money;
  9.     public User() {
  10.     }
  12.     public User(int id, String name, int money) {
  13.         this.id = id;
  14.         this.name = name;
  15.         this.money = money;
  16.     }
  18.     public int getId() {
  19.         return id;
  20.     }
  22.     public void setId(int id) {
  23.         this.id = id;
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public int getMoney() {
  35.         return money;
  36.     }
  38.     public void setMoney(int money) {
  39.         this.money = money;
  40.     }
  42.     @Override
  43.     public String toString() {
  44.         return "User{" +
  45.                 "id=" + id +
  46.                 ", name='" + name + '\'' +
  47.                 ", money=" + money +
  48.                 '}';
  49.     }
  50. }

image.png

测试类代码

  1. package SpringTemplate;
  3. import bean.User;
  4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import utils.JDBCUtils;
  8. import javax.sql.DataSource;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  13. public class JDBCTemplate {
  15.     /**
  16.      * 使用JDBCTemplate来实现对mysql数据库的操作
  17.      * 前提：结合前面的Druid来得到DateSource
  18.      *
  19.      * 使用JDBCtemplate的好处就是我们不用再自己去关闭数据库的连接了
  20.      *
  21.      *  1。将查询到的结果封装成为对象并且放到list集合里面
  22.      *       List<User> userlist = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
  23.      *  2.将查询到的每一条记录封装成为Map集合，并且将map集合放到一个list集合里面
  24.      *       List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
  25.      *  3.将查询到的结果放到Map集合里面去，！！！！  只支持查询结果是一条记录的时候，亮条记录的时候就会报错
  26.      *        Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql2,133);
  27.      *
  28.      *        这三种方法都可以先将sql语句里面的参数用占位符？？ 代替，在执行的时候进行补全
  29.      *
  30.      */
  31.     public static void main(String[] args) {
  33.        //得到JDBCtemplate的对象 注意导包的时候导的是org.springframework.jdbc.core.JdbcTemplate;
  34.         JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
  36.         String sql = "select * from luo ;";
  37.         List<User> userlist = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
  38.         for (User user : userlist) {
  39.             System.out.println(user);
  40.         }
  42.         System.out.println("----------防止sql注入------------");
  43.         String sql3 = "select * from luo where id = ?;";
  44.         List<User> userlist2 = jdbcTemplate.query(sql3,new BeanPropertyRowMapper<User>(User.class), "133" );
  45.         for (User user : userlist2) {
  46.             System.out.println(user);
  47.         }
  50.         System.out.println("---------------------------");
  51.         //将查询到的结果封装成为一个list集合，集合里面是Map集合 一个map集合就是一条记录 键是字段名，值是值
  52.         List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
  53.         for (Map<String, Object> map : maps) {
  54.             System.out.println(map);
  55.         }
  57.         System.out.println("--------------------------");
  58.         //将查询到的结果放到一个map集合里面
  59.         // 注意 这种方法只是用于查询的结果集里面只有一条记录的查询，结果集里面如果有两条记录就会报错
  60.         String sql2 = "select * from luo where id = ? ;";  //使用占位符可以防止sql注入
  61.         Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql2,133); //填补空缺值，并执行sql
  62.         //遍历map集合
  63.         //1.得到键的集合
  64.         Set<String> set = stringObjectMap.keySet();
  65.         for (String s : set) {
  66.             System.out.println(s+"-----"+stringObjectMap.get(s));
  67.         }
  69.     }
  71. }

扩展知识

Spring JDBC 提供了一个 JDBCTemplate对象
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
 步骤：
1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource 这个DataSource对象我们可以使用刚才创建的DruidTools来得到
* JdbcTemplate template = new JdbcTemplate(ds);

  1.     3. 调用JdbcTemplate的方法来完成CRUD的操作<br />           ** * update():执行DML语句。增、删、改语句**<br />**            * queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合**<br />**                * 注意：这个方法查询的结果集长度只能是1**<br />**            * queryForList():查询结果将结果集封装为list集合**<br />**                * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中**<br />**            * query():查询结果，将结果封装为JavaBean对象**<br />**                * query的参数：RowMapper**<br />**                    * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装**<br />**                    * new BeanProp ertyRowMapper<类型>(类型.class)**<br />**                        **_*重点！！！！ 为什么这个方法可以实现 自动封装为Person对象 是因为_<br />_ *他会把我们在Person里面定义的属性值id name money和数据库里面的字段进行匹配_<br />_*所以如果你想使用系统的BeanPropertyRowMapper方法 就要保证Person类的属性值和 数据库的字段一一对应_<br />**            * queryForObject：查询结果，将结果封装为对象**<br />**                * 一般用于聚合函数的查询**

使用JDBCtemplate的好处：
使用JDBCTemplate的有点就在于我们不需要再 创建数据库的连接 得到数据库连接池 归还连接 大大方便了

扩展案例

案例：

下面是使用Spring JDBC的 JDBCTemplate对象来实现7个案例，使用到了7个jar包 实现数据库操作更加的方便了
七个练习是：

练习一 修改id值为133的人的钱为333
* 练习二 我们添加一条记录 insert into luo values(166,”阿里巴”,777);
练习三 删除刚才添加的数据 delete from luo where id = ? ;
练习四 查询id为133的记录 并且将数据放到map集合里面 map 集合是一个双列集合里面是键值对
练习五 ; 查询所有的记录 将记录存放到list集合 list集合里面的每一个元素是一个map集合
练习六 ；查询所有的记录 将每一条记录封装为person对象 再把对象放到list集合里面
使用SpringJDBC 给的 JDBCTamplate的.query方法就可以实现 将查询到的结果封装为javabean对象
练习6plus 我们会发现自己实现一下 RowMap方法是可以的，但是比较麻烦 所以 我们来使用一下系统已经实现好的接口
系统重写好RowMaper接口的类是 BeanPropertyRowMaper();参数是一个字节码文件 就是你想封装成类的字节码文件
练习7 得到记录的总数 使用聚合函数

代码

  1. import DruidUtils.DruidTools;
  2. import org.junit.Test;
  3. import org.omg.PortableInterceptor.ClientRequestInfo;
  4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.core.RowMapper;
  8. import javax.lang.model.type.ArrayType;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.Set;
  16. public class JDBCTemplatePractice1 {
  18. /**
  19. * 我们在这里实现几个JDBCTemplate的练习
  20. * 使用单元测试的方式 不需要主方法 让定义的方法可以独立运行
  21. * 单元测试的方法返回值一般都是 void ，修饰符都是public
  22. * 我们只需要添加一个注解@Test 然后点击注解左边的小灯泡 吧Junit4添加进去就可以实现单元测试了
  23. */
  25. /**
  26. * 练习一 修改id值为133的人的钱为333
  27. */
  28. @Test
  29. public void test1 (){
  31. //获取JDBCTemplate对象 参数是dataSource我们可以使用自己创建的工具类得到
  32. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  34. //创建sql语句
  35. String sql = "update luo set money = ? where id = 133";
  36. //为sql设置参数 并执行sql
  37. int res = jdbcTemplate.update(sql, 363);
  39. if (res > 0){
  40. System.out.println("修改成功");
  41. }else {
  42. System.out.println("修改失败");
  43. }
  45. }
  48. /**
  49. * 练习一 我们添加一条记录 insert into luo values(166,"阿里巴",777);
  50. * 使用JDBCTemplate的update方法可以执行DML（增删改）语句 返回int 数据
  51. */
  52. @Test
  53. public void test2 (){
  54. //获得JDBCTemplate对象 参数是DataSource
  55. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  57. String sql = "insert into luo values(?,?,?);";
  58. //使用JDBCTemplate为sql赋值并执行sql语句
  59. int res = jdbcTemplate.update(sql,155,"阿里巴",666);
  61. if (res>0){
  62. System.out.println("添加成功");
  63. }else {
  64. System.out.println("添加失败");
  65. }
  67. }
  70. /**
  71. * 练习三 删除刚才添加的数据 delete from luo where id = ? ;
  72. * 使用JDBCTemplate的update方法执行sql语句 参数是 DataSource 我们使用自己的DruidTools工具类得到
  73. */
  74. @Test
  75. public void test3(){
  77. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  79. String sql = "delete from luo where id = ? ;";
  80. int res = jdbcTemplate.update(sql,155);
  81. if (res > 0){
  82. System.out.println("删除成功");
  83. }else {
  84. System.out.println("删除失败");
  85. }
  87. }
  90. /**
  91. * 练习四 查询id为133的记录 并且将数据放到map集合里面 map 集合是一个双列集合里面是键值对
  92. * 使用JDBCTemp的queryformap方法返回的是一个map集合
  93. * select * from luo where id = ? ;
  94. * 使用JDBCTemplate的update方法执行sql语句 参数是 DataSource 我们使用自己的DruidTools工具类得到
  95. *
  96. * 注意：！！ ！这种方法只是用于查询的结果集里面只有一条记录的查询，结果集里面如果有两条记录就会报错
  97. */
  98. @Test
  99. public void test4(){
  101. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  103. String sql = "select * from luo where id = ? ;";
  104. //map集合里面的数据就是 将字段名封装为键 字段的值 封装为值
  105. Map<String,Object> map = jdbcTemplate.queryForMap(sql,133);
  106. //我们再回忆一下遍历map集合的方法
  107. //方法一 将键和值当做一个整体进行遍历
  108. Set<Map.Entry<String,Object>> set= map.entrySet();
  109. //set集合只能使用增强for遍历
  110. for (Map.Entry<String,Object> entry : set){
  111. System.out.println(entry.getKey()+"---"+entry.getValue());
  112. }
  115. }
  117. /**
  118. * 练习五 ; 查询所有的记录 将记录存放到list集合 list集合里面的每一个元素是一个map集合
  119. * 事实上就是把查到的每一条记录封装为一个 map集合再把所有的集合放到 一个list集合里面
  120. */
  122. @Test
  123. public void test5(){
  125. //得到JDBCTemplate对象
  126. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  127. String sql = "select * from luo ;";
  128. List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
  129. for (Map<String, Object> stringObjectMap : list) {
  130. System.out.println(stringObjectMap);
  131. }
  133. }
  135. /**
  136. * 练习六 ；查询所有的记录 将每一条记录封装为person对象 再把对象放到list集合里面
  137. * 使用SpringJDBC 给的 JDBCTamplate的.query方法就可以实现 将查询到的结果封装为javabean对象
  138. */
  140. @Test
  141. public void test6(){
  143. //得到Tamplate的对象 参数是DataSource
  144. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  145. String sql = "select * from luo ;";
  146. //第二个参数是一个 接口我们可以自己实现接口 也可以使用系统已经实现好的类 这里我们自己实现一下接口
  147. List<Person> list = jdbcTemplate.query(sql, new RowMapper<Person>() {
  149. @Override
  150. public Person mapRow(ResultSet resultSet, int i) throws SQLException {
  152. //这里的resuleSet就是查询到的结果集 i 就是查询到的记录数
  153. //我们可以使用ResultSet的getxxx方法得到指定的字段对应的值
  155. int id = resultSet.getInt("id");
  156. String name = resultSet.getString("name");
  157. int money = resultSet.getInt("money");
  159. //封装为对象
  160. Person person = new Person(id , name , money);
  161. return person;
  162. }
  166. });
  168. //遍历一下list集合
  169. for (Person person : list) {
  170. System.out.println(person);
  171. }
  174. }
  177. /**
  178. * 我们会发现自己实现一下 RowMap方法是可以的，但是比较麻烦 所以 我们来使用一下系统已经实现好的接口
  179. * 系统重写好RowMaper接口的类是 BeanPropertyRowMaper();参数是一个字节码文件 就是你想封装成类的字节码文件
  180. */
  181. @Test
  182. public void test6plus(){
  184. //得到JDBCTemplate 对象
  185. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  187. String sql = "select * from luo ;";
  188. //使用系统已经实心好RowMaper接口的类 BeanPropertyRowMaper();
  189. List<Person> list =jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(Person.class));
  190. //注意这里在封装成为对象的时候 数据库里面记录有时候可能为空 这样你在给对象赋值的时候可能会出错
  191. //比如 有一条记录的id为null 我们在给 Person对象的id赋值的时候 因为id值是int int不能为空 所以就会报错
  192. //因为基本类型不可以为null 解决方法就是 在Person类里面使用基本数据类型的封装类 Integer double-- Double
  193. /**
  194. * 重点！！！！ 为什么这个方法可以实现 自动封装为Person对象 是因为
  195. * 他会把我们在Person里面定义的属性值 id name money 和数据库里面的字段进行匹配
  196. * 所以如果你想使用系统的BeanPropertyRowMapper方法 就要保证Person类的属性值和 数据库的字段一一对应
  197. */
  198. for (Person person : list) {
  199. System.out.println(list);
  200. }
  202. }
  205. /**
  206. * 得到记录的总数 使用聚合函数
  207. * select count(id) from luo ; () 里面一般放的是主键
  208. * 使用的方法是 queryForObject()
  209. */
  210. @Test
  211. public void test7(){
  212. JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidTools.getDataSource());
  214. String sql = "select count(id) from luo ;";
  215. //queryForObject()方法执行sql 前面用int接收后面第二个参数就要使用int的字节码文件 ，class
  216. int i = jdbcTemplate.queryForObject(sql,Integer.class);
  217. System.out.println(i);
  218. }
  220. }