概念和准备
1、JdbcTemplate
- Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。
- 可以将 Spring 的 JdbcTemplate 看作是一个小型的轻量级持久化层框架
2、前期准备
（1）引入相关 jar 包
- 更清楚的可以参考这个
- IOC 容器所需要的 JAR 包
commons-logging-1.1.1.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar- JdbcTemplate 所需要的 JAR 包
spring-jdbc-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar- 数据库驱动和数据源
c3p0-0.9.1.2.jar
mysql-connector-java-5.1.7-bin.jar
（2）在 spring 配置文件配置数据库连接池
- 例1
<!-- 1配置数据源 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <!--数据库驱动 --> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <!--连接数据库的url --> <property name="url" value="jdbc:mysql://localhost:3306/spring" /> <!--连接数据库的用户名 --> <property name="username" value="root" /> <!--连接数据库的密码 --> <property name="password" value="root" /> </bean>
- 例2
<!-- 数据库连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"> <property name="url" value="jdbc:mysql:///user_db" /> <property name="username" value="root" /> <property name="password" value="root" /> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> </bean>
（3）配置 JdbcTemplate 对象，注入 DataSource
<!-- 2配置JDBC模板,也就是JdbcTemplate 对象 --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 默认必须使用数据源，注入 dataSource --> <property name="dataSource" ref="dataSource" /> </bean>
（4）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象
配置文件
如果不想在xml文件中配置bean，我们可以给我们的类加上spring组件注解，只需再配置下spring的扫描器就可以实现bean的自动载入。
<!-- 组件扫描 --> <context:component-scan base-package="com.it"></context:component-scan>
需要注意的是：
在base-package指明一个包：
<context:component-scan base-package=“com.it”/>
表明com.b505包及其子包中，如果某个类的头上带有特定的注解
@Component，@Repository，@Service，@Controller，就会将这个对象作为Bean注入进spring容器。
Service包
@Service public class BookService { //注入 dao @Autowired private BookDao bookDao; }
Dao包
@Repository public class BookDaoImpl implements BookDao { //注入 JdbcTemplate @Autowired private JdbcTemplate jdbcTemplate; }
[添加/更新]数据库
1、对应数据库创建实体类
这里只是举一个例子，和上下文的代码不存在关系
public class Account { private Integer id; // 账户id private String username; // 用户名 private int password; // 账户密码 public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public int getPassword() { return password; } public void setPassword(int password) { this.password = password; } public String toString() { return "Account [id=" + id + ", " + "username=" + username + ", password=" + password + "]"; } }
2、编写 service 和 dao
（1）在 dao 进行数据库添加操作
类似这样：
（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作
该方法有两个参数
- 第一个参数：sql 语句
- 第二个参数：可变参数，设置 sql 语句值
（常在之前定义一个数组做对象）
- 例1
public class AccountDaoImpl implements AccountDao { // 声明JdbcTemplate属性及其setter方法 private JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } // 添加账户 public int addAccount(Account account) { // 定义SQL String sql = "insert into account(username,password) value(?,?)"; // 定义数组来存放SQL语句中的参数 Object[] obj = new Object[] { account.getUsername(), account.getPassword() }; // 执行添加操作，返回的是受SQL语句影响的记录条数 int num = this.jdbcTemplate.update(sql, obj); return num; } // 更新账户 public int updateAccount(Account account) { // 定义SQL String sql = "update account set username=?,password=? where id = ?"; // 定义数组来存放SQL语句中的参数 Object[] params = new Object[] { account.getUsername(), account.getPassword(), account.getId() }; // 执行添加操作，返回的是受SQL语句影响的记录条数 int num = this.jdbcTemplate.update(sql, params); return num; }
- 例2（观察与例1的不同）
@Repository public class BookDaoImpl implements BookDao { //注解形式注入 JdbcTemplate @Autowired private JdbcTemplate jdbcTemplate; //添加的方法 @Override public void add(Book book) { //1 创建 sql 语句 String sql = "insert into t_book values(?,?,?)"; //2 调用方法实现 Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()}; int update = jdbcTemplate.update(sql,args); System.out.println(update); } }
3、测试类
@Test public void testJdbcTemplate() { ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); BookService bookService = context.getBean("bookService", BookService.class); Book book = new Book(); book.setUserId("1"); book.setUsername("java"); book.setUstatus("a"); bookService.addBook(book); }
[修改和删除]数据库
1、修改
@Override public void updateBook(Book book) { // 定义SQL String sql = "update t_book set username=?,ustatus=? where user_id=?"; // 定义数组来存放SQL语句中的参数 Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()}; // 执行添加操作，输出结果 int update = jdbcTemplate.update(sql, args); System.out.println(update); }
2、删除
@Override public void delete(String id) { String sql = "delete from t_book where user_id=?"; int update = jdbcTemplate.update(sql, id); System.out.println(update); }
[查询返回某个值]数据库
1、查询表里面有多少条记录，返回是某个值
2、使用 JdbcTemplate 实现查询返回某个值代码
有两个参数
- 第一个参数：sql 语句
- 第二个参数：返回类型 Class
//查询表记录数 @Override public int selectCount() { String sql = "select count(*) from t_book"; Integer count = jdbcTemplate.queryForObject(sql, Integer.class); return count; }
[查询返回对象]数据库
1、场景：查询图书详情
2、JdbcTemplate 实现查询返回对象
有三个参数
- 第一个参数：sql 语句
- 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
- 第三个参数：sql 语句值
//查询返回对象 @Override public Book findBookInfo(String id) { String sql = "select * from t_book where user_id=?"; //调用方法 Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id); return book; }
// 通过id查询账户数据信息 public Account findAccountById(int id) { //定义SQL语句 String sql = "select * from account where id = ?"; // 创建一个新的BeanPropertyRowMapper对象 RowMapper<Account> rowMapper = new BeanPropertyRowMapper<Account>(Account.class); // 将id绑定到SQL语句中，并通过RowMapper返回一个Object类型的单行记录 return this.jdbcTemplate.queryForObject(sql, rowMapper, id); }
[查询返回集合]数据库
1、场景：查询图书列表分页…
2、调用 JdbcTemplate 方法实现查询返回集合
有三个参数
- 第一个参数：sql 语句
- 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
- 第三个参数：sql 语句值
//查询返回集合 @Override public List<Book> findAllBook() { String sql = "select * from t_book"; //调用方法 List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); return bookList; }
[批量操作] 数据库
1、批量操作：操作表里面多条记录
2、JdbcTemplate 实现批量添加操作
有两个参数
- 第一个参数：sql 语句
- 第二个参数：List 集合，添加多条记录数据
//批量添加 @Override public void batchAddBook(List<Object[]> batchArgs) { String sql = "insert into t_book values(?,?,?)"; int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); System.out.println(Arrays.toString(ints)); } //批量添加测试 List<Object[]> batchArgs = new ArrayList<>(); Object[] o1 = {"3","java","a"}; Object[] o2 = {"4","c++","b"}; Object[] o3 = {"5","MySQL","c"}; batchArgs.add(o1); batchArgs.add(o2); batchArgs.add(o3); //调用批量添加 bookService.batchAdd(batchArgs);
3、JdbcTemplate 实现批量修改操作
//批量修改 @Override public void batchUpdateBook(List<Object[]> batchArgs) { String sql = "update t_book set username=?,ustatus=? where user_id=?"; int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); System.out.println(Arrays.toString(ints)); } //批量修改 List<Object[]> batchArgs = new ArrayList<>(); Object[] o1 = {"java0909","a3","3"}; Object[] o2 = {"c++1010","b4","4"}; Object[] o3 = {"MySQL1111","c5","5"}; batchArgs.add(o1); batchArgs.add(o2); batchArgs.add(o3); //调用方法实现批量修改 bookService.batchUpdate(batchArgs);
4、JdbcTemplate 实现批量删除操作
//批量删除 @Override public void batchDeleteBook(List<Object[]> batchArgs) { String sql = "delete from t_book where user_id=?"; int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); System.out.println(Arrays.toString(ints)); } //批量删除 List<Object[]> batchArgs = new ArrayList<>(); Object[] o1 = {"3"}; Object[] o2 = {"4"}; batchArgs.add(o1); batchArgs.add(o2); //调用方法实现批量删除 bookService.batchDelete(batchArgs);
