springcloud项目增删改查 spring实现增删改查

1、 spring 框架一站式框架

（1）针对 javaee 三层，每一层都有解决技术

（2）在 dao 层，使用 jdbcTemplate

 

2、 spring 对不同的持久化层技术都进行封装

（1）jdbcTemplate对jdbc进行封装

 

3 、jdbcTemplate 使用和 dbutils 使用很相似，都数据库进行 crud 操作

 

实现准备

1、导入 jar 包

（1）Spirng 基础包（不一定都需要）

（2）jdbcTemplate 包

（3）jdbc-mysql 驱动包

2、新建数据库

（1）本地服务器 localhost，用户名 root，密码为空

（2）新建数据库 spring

（3）新建数据表 user，三个字段，分别是 id，username，password

 

 

增加，删除，修改

JdbcTemplateDemo1

1. package
2. 
3. import
4. import
5. import
6. import
7. 
8. import
9. import
10. 
11. public class
12. //1 添加操作
13. @Test
14. public void
15. //1、创建对象，设置数据库信息
16. new
17. "com.mysql.jdbc.Driver");
18. "jdbc:mysql://127.0.0.1:3306/spring");
19. "root");
20. "");
21. 
22. //2、创建jdbcTemplate对象，设置数据源
23. new
24. 
25. //3、调用jdbcTemplate对象里的方法实现操作
26. "insert into user values(?,?,?)";
27. int rows = jdbcTemplate.update(sql,1,"刘曌","123456");
28.         System.out.println(rows);
29.     }
30. 
31. //2 更新操作
32. @Test
33. public void
34. //1、创建对象，设置数据库信息
35. new
36. "com.mysql.jdbc.Driver");
37. "jdbc:mysql://127.0.0.1:3306/spring"
38. "?useUnicode=true&characterEncoding=utf8");
39. "root");
40. "");
41. 
42. //2、创建jdbcTemplate对象，设置数据源
43. new
44. 
45. //3、调用jdbcTemplate对象里的方法实现操作
46. "update user set username=?,password=? where id=?";
47. int rows = jdbcTemplate.update(sql,"刘言曌","666666",1);
48.         System.out.println(rows);
49.     }
50. 
51. //3 删除操作
52. @Test
53. public void
54. //1、创建对象，设置数据库信息
55. new
56. "com.mysql.jdbc.Driver");
57. "jdbc:mysql://127.0.0.1:3306/spring"
58. "?useUnicode=true&characterEncoding=utf8");
59. "root");
60. "");
61. 
62. //2、创建jdbcTemplate对象，设置数据源
63. new
64. 
65. //3、调用jdbcTemplate对象里的方法实现操作
66. "delete from user where id=?";
67. int rows = jdbcTemplate.update(sql,1);
68.         System.out.println(rows);
69.     }
70. 
71. }

查询

查询分为 “查询记录总数”，“查询单个记录”，“查询多个记录”

1、查询记录总数，返回一个整数

1. // 4 查询表中有多少数据
2. @Test
3. public void
4. //1、创建对象，设置数据库信息
5. new
6. "com.mysql.jdbc.Driver");
7. "jdbc:mysql://127.0.0.1:3306/spring"
8. "?useUnicode=true&characterEncoding=utf8");
9. "root");
10. "");
11. 
12. //2、创建jdbcTemplate对象，设置数据源
13. new
14. 
15. //3、调用方法得到记录数
16. "select count(*) from user";
17. int count = jdbcTemplate.queryForObject(sql,Integer.class);
18.     System.out.println(count);
19. }

2、查询单个对象，返回一个对象

（1）新建 user 实体类

1. package
2. 
3. public class
4. private int
5. private
6. private
7. 
8. public int
9. return
10.     }
11. 
12. public
13. return
14.     }
15. 
16. public
17. return
18.     }
19. 
20. public void setId(int
21. this.id = id;
22.     }
23. 
24. public void
25. this.username = username;
26.     }
27. 
28. public void
29. this.password = password;
30.     }
31. 
32. @Override
33. public
34. return "User{"
35. "id="
36. ", username='" + username + '\''
37. ", password='" + password + '\''
38.             '}';
39.     }
40. }

（2）新建 MyRowMapper 类，我们可以把它放到 JdbcTemplateDemo1 类中

1. class MyRowMapper implements
2. 
3. @Override
4. public User mapRow(ResultSet rs, int num) throws
5. //从结果集中得到数据
6. int id = rs.getInt("id");
7. "username");
8. "password");
9. 
10. //把得到的数据封装到对象里面
11. new
12.         user.setId(id);
13.         user.setUsername(username);
14.         user.setPassword(password);
15. 
16. return
17.     }
18. }

（3）查询单条记录信息

1. //5、查询返回对象
2. @Test
3. public void
4. //1、创建对象，设置数据库信息
5. new
6. "com.mysql.jdbc.Driver");
7. "jdbc:mysql://127.0.0.1:3306/spring"
8. "?useUnicode=true&characterEncoding=utf8");
9. "root");
10. "");
11. 
12. //2、创建jdbcTemplate对象，设置数据源
13. new
14. 
15. //调用方法得到对象
16. "select * from user where username=?";
17. new MyRowMapper(),"刘言曌");
18.         System.out.println(user);
19.     }

3、查询多条记录，返回一个 list 集合

（1）同上

（2）同上

（3）查询多条记录信息

1. //7、查询返回集合
2. @Test
3. public void
4. //1、创建对象，设置数据库信息
5. new
6. "com.mysql.jdbc.Driver");
7. "jdbc:mysql://127.0.0.1:3306/spring"
8. "?useUnicode=true&characterEncoding=utf8");
9. "root");
10. "");
11. 
12. //2、创建jdbcTemplate对象，设置数据源
13. new
14. 
15. //3、调用方法得到集合
16. "select * from user";
17. new
18.         System.out.println(list);
19.     }

 

补充

我们这里补充一下 原生的 JDBC 查询单条记录的代码，复习一下 JDBC,同时比较一下 Spring 的 jdbcTemplate 和 原生 JDBC 代码的区别

1. //5、查询返回对象，原生JDBC代码
2. @Test
3. public void getUserByJDBC() throws
4. final String URL = "jdbc:mysql://127.0.0.1:3306/spring?useUnicode=true&characterEncoding=utf8";
5. final String USERNAME = "root";
6. final String PASSWORD = "";
7. 
8. null;
9. null;
10. null;
11. //加载驱动
12. try
13. "com.mysql.jdbc.Driver");
14.             conn = DriverManager.getConnection(URL,USERNAME,PASSWORD);
15. "select * from user where username=?";
16. //预编译sql
17.             ptmt = conn.prepareStatement(sql);
18. //设置参数值
19. 1,"刘言曌");
20. //执行sql
21.             rs = ptmt.executeQuery();
22. //遍历结果集
23. while
24. //得到返回值
25. int id = rs.getInt("id");
26. "username");
27. "password");
28. //放到user对象中
29. new
30.                 user.setId(id);
31.                 user.setUsername(username);
32.                 user.setPassword(password);
33. 
34.                 System.out.println(user);
35.             }
36. catch
37.             e.printStackTrace();
38. finally
39. //关闭连接
40.             rs.close();
41.             ptmt.close();
42.             conn.close();
43.         }
44.     }