JDBCTemplate使用步骤

Spring JDBC

• Spring 框架对 JDBC 进行了简单的封装，提供了一个 JDBCTemplate 对象简化 JDBC 的开发

使用步骤

1. 使用 maven 创建一个Java项目，导入所需要的依赖。

      <dependencies>
           <!-- JDBCTemplate所需依赖-->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-jdbc</artifactId>
               <version>5.3.14</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- MySQL数据库连接驱动 -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>8.0.27</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- Druid 数据库连接池 -->
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid</artifactId>
               <version>1.2.6</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- 测试依赖-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.13.2</version> <!-- 替换为你需要的版本号 -->
               <scope>compile</scope>
           </dependency>
       </dependencies>
   

2. 创建工具类，使用 Druid 连接池。

   import com.alibaba.druid.pool.DruidDataSourceFactory;
   
   import javax.sql.DataSource;
   import java.io.InputStream;
   import java.sql.Connection;
   import java.sql.SQLException;
   import java.util.Properties;
   // 工具类
   public class JdbcUtils {
       private static DataSource dataSource;
   
       static {
           try {
               // 加载配置文件
               Properties properties = new Properties();
               InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties");
               properties.load(inputStream);
               // 创建数据源
               dataSource = DruidDataSourceFactory.createDataSource(properties);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       // 获取数据库连接
       public static Connection getConnection() throws SQLException {
           System.out.println(dataSource);
           return dataSource.getConnection();
       }
   
       // 释放资源
       public static void close(Connection conn) {
           if (conn != null) {
               try {
                   conn.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
       }
   
       // 获取数据库连接池对象
       public static DataSource getDataSource(){
           return dataSource;
       }
   }
   

3. 在【src-main-resources】下边创建文件 【druid.properties】（更换自己的数据库用户名和密码）

   url = jdbc:mysql://localhost:3306/test
   username = root
   password = root
   

4. 创建实体类，封装由数据库查询到的数据

   public class Account {
       private int id;
       private String name;
       private double balance;
   
       public Account() {
       }
   
       public Account(int id, String name, double balance) {
           this.id = id;
           this.name = name;
           this.balance = balance;
       }
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public double getBalance() {
           return balance;
       }
   
       public void setBalance(double balance) {
           this.balance = balance;
       }
   
       @Override
       public String toString() {
           return "Account{" +
                   "id=" + id +
                   ", name='" + name + '\'' +
                   ", balance=" + balance +
                   '}';
       }
   }
   

5. 在【src-main-java】下边创建类 Test，几种使用方法（可以看的时候参考下下边的方法介绍）

   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   import org.springframework.jdbc.core.JdbcTemplate;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
   
   
   public class Test {
   
       private JdbcTemplate template;
   
       {
           // 创建 JdbcTemplate 对象，依赖于数据源
           template = new JdbcTemplate(JdbcUtils.getDataSource());
       }
   
       @org.junit.Test
       public void test1(){
           // 调用 JdbcTemplate 完成 增删改操作
           String sql = "UPDATE account SET balance = 1000 WHERE id = ?";
           int i = template.update(sql,2);
           System.out.println(i);
       }
   
       /*查询的结果集只能有一行，多行报错，可删除条件试试*/
       @org.junit.Test
       public void test2(){
           // 定义查询语句
           String sql = "SELECT * FROM account WHERE id = ?";
           // 将结果封装为 Map 集合
           Map<String, Object> map = template.queryForMap(sql , 2);
           // 遍历集合
           Set<String> keySet = map.keySet();
           for (String key : keySet) {
               Object obj = map.get(key);
               System.out.println(key + "--" + obj);
           }
       }
   
       /*查询的结果可以多行，将每一行封装成一个 map 集合，再将多行 map 封装成一个 list 集合*/
       @org.junit.Test
       public void test3(){
           // 定义查询语句
           String sql = "SELECT * FROM account";
           // 将结果封装成 List 集合
           List<Map<String, Object>> maps = template.queryForList(sql);
           // 遍历集合
           for (Map<String, Object> map : maps) {
               System.out.println(map);
           }
       }
   
       /*查询的结果，由数据库封装到实体类中，然后 从实体类中遍历得到所有结果*/
       @org.junit.Test
       public void test4(){
           // 定义查询语句
           String sql = "SELECT * FROM account";
           // 完成数据到 JavaBean 的自动封装
           BeanPropertyRowMapper<Account> bean = new BeanPropertyRowMapper<>(Account.class);
           List<Account> list = template.query(sql, bean);
           for (Account l : list) {
               System.out.println(l);
           }
       }
   }
   

JDBCTemplate方法介绍

注意：类型指的是，Java中的实体类，依照表格字段我们创建的类