Spring学习笔记（五）：Spring JDBC 框架及应用示例

JDBC 框架概述

在使用普通的 JDBC 数据库时，就会很麻烦的写不必要的代码来处理异常，打开和关闭数据库连接等。但 Spring JDBC 框架负责所有的低层细节，从开始打开连接，准备和执行 SQL 语句，处理异常，处理事务，到最后关闭连接。

所以当从数据库中获取数据时，你所做的是定义连接参数，指定要执行的 SQL 语句，每次迭代完成所需的工作。

Spring JDBC 提供几种方法和数据库中相应的不同的类与接口。我将给出使用 JdbcTemplate 类框架的经典和最受欢迎的方法。这是管理所有数据库通信和异常处理的中央框架类。

JdbcTemplate 类

JdbcTemplate 类执行 SQL 查询、更新语句和存储过程调用，执行迭代结果集和提取返回参数值。它也捕获 JDBC 异常并转换它们到 org.springframework.dao 包中定义的通用类、更多的信息、异常层次结构。

JdbcTemplate 类的实例是线程安全配置的。所以你可以配置 JdbcTemplate 的单个实例，然后将这个共享的引用安全地注入到多个 DAOs 中。

使用 JdbcTemplate 类时常见的做法是在你的 Spring 配置文件中配置数据源，然后共享数据源 bean 依赖注入到 DAO 类中，并在数据源的设值函数中创建了 JdbcTemplate。

Spring JDBC 示例

准备工作1：启动mysql，创建一张表 t_user，以便执行CRUD（增、删、改、查）操作。

create table t_user(
    id int primary key auto_increment,
    username varchar(20),
    password varchar(20),
    account decimal(10,2)
    );

准备工作2：创建一个maven工程，导入必要依赖，pom文件配置如下：

<profiles>
        <profile>
            <id>JDK1.8</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
                <encoding>UTF-8</encoding>
            </properties>
        </profile>
  </profiles>
  <dependencies>
    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>4.3.0.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.aspectj</groupId>
       <artifactId>aspectjweaver</artifactId>
       <version>1.8.9</version>
     </dependency>
     <dependency>
       <groupId>cglib</groupId>
       <artifactId>cglib</artifactId>
       <version>3.2.4</version>
     </dependency>
     <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-jdbc</artifactId>
    	<version>5.0.8.RELEASE</version>
	</dependency>
	<dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<version>6.0.6</version>
	</dependency>
  </dependencies>

准备工作3：创建数据访问对象接口文件 UserDAO.java 的内容：

package com.yingshulan.spring_learning.api;

import java.util.List;

public interface UserDAO
{
    /**
     * 新增用戶
     * @param user
     * @return
     * @throws Exception
     */
    public int insertUser(User user) throws Exception;

    /**
     * 修改用戶
     * @param user
     * @param id
     * @return
     * @throws Exception
     */
    public int updateUser(User user, int id) throws Exception;

    /**
     * 刪除用戶
     * @param id
     * @return
     * @throws Exception
     */
    public int deleteUser(int id) throws Exception;

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     * @throws Exception
     */
    public User selectUserById(int id) throws Exception;

    /**
     * 查询所有的用户信息
     * @return
     * @throws Exception
     */
    public List<User> selectAllUser() throws Exception;
}

准备工作4：创建与数据库中数据表 t_user 对应的实体类 User.java ，这是数据核心，它是真正被操作的实体。

package com.yingshulan.spring_learning.api;

import java.io.Serializable;


public class User implements Serializable
{

    private static final long serialVersionUID = 1L;
    private Integer id;
    private String username;
    private String password;
    private Double account;

    public User()
    {
        super();
    }

    public User(String username, String password, Double account)
    {
        super();
        this.username = username;
        this.password = password;
        this.account = account;
    }

    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 String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

    public Double getAccount()
    {
        return account;
    }

    public void setAccount(Double account)
    {
        this.account = account;
    }

    @Override
    public String toString()
    {
        return "UserBean [id=" + id + ", username=" + username + ", password=" + password
                + ", account=" + account + "]";
    }

}

准备工作5：创建 UserMapper.java 文件的内容，从数据库中查询得到的数据是以记录的形式存在的，并不是一个对象，因此，我们需要创建一个 “映射” 类，将从数据库中查询到的记录 转化为对象。

package com.yingshulan.spring_learning.api;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;


public class UserMapper implements RowMapper<User> 
{
    public User mapRow(ResultSet rs, int rowNum) throws SQLException 
    {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setUsername(rs.getString("username"));
        user.setAccount(rs.getDouble("account"));
        user.setPassword(rs.getString("password"));
       return user;
    }
 }

准备工作6：下面是为定义接口 StudentDAO 的实现类文件 UserJDBCTemplate.java：

package com.yingshulan.spring_learning.api;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

public class UserJDBCTemplate implements UserDAO
{
    private DataSource dataSource;
    private JdbcTemplate jdbcTemplateObject;

    public void setDataSource(DataSource dataSource)
    {
        this.dataSource = dataSource;
        this.jdbcTemplateObject = new JdbcTemplate(dataSource);
    }

    @Override
    public int insertUser(User user) throws Exception
    {
        String sql = "insert into t_user (username,password,account) values (?,?,?)";
        jdbcTemplateObject.update(sql, user.getUsername(), user.getPassword(), user.getAccount());
        System.out.println("Created Record: " + user);
        return 0;
    }

    @Override
    public int updateUser(User user, int id) throws Exception
    {
        String sql = "update t_user set username=?,password=?,account=? where id=?";
        jdbcTemplateObject.update(sql, user.getUsername(), user.getPassword(), user.getAccount(),
                user.getId());
        System.out.println("Updated Record: with id = " + id);
        return 0;
    }

    @Override
    public int deleteUser(int id) throws Exception
    {
        String sql = "delete from t_user where id=?";
        jdbcTemplateObject.update(sql, id);
        System.out.println("Deleted Record with id = " + id);
        return 0;
    }

    @Override
    public User selectUserById(int id) throws Exception
    {
        String sql = "select * from t_user where id=?";
        User user = jdbcTemplateObject.queryForObject(sql, new Object[] {id}, new UserMapper());
        ;
        System.out.println("Selected Record with id = " + id);
        return user;
    }

    @Override
    public List<User> selectAllUser() throws Exception
    {
        String sql = "select * from t_user";
        List<User> users = jdbcTemplateObject.query(sql, new UserMapper());
        return users;
    }

}

准备工作7：创建Bean的配置文件Beansjdbc.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/mysql?useUnicode=true&amp;serverTimezone=UTC"/>
      <property name="username" value="root"/>
      <property name="password" value="123456"/>
   </bean>

   <!-- Definition for UserJDBCTemplate bean -->
   <bean id="UserJDBCTemplate" 
      class="com.yingshulan.spring_learning.api.UserJDBCTemplate">
      <property name="dataSource"  ref="dataSource" />    
   </bean>

</beans>

测试代码：

package com.yingshulan.spring_learning.api;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JDBCTest
{

    public static void main(String[] args) throws Exception
    {
        // TODO Auto-generated method stub
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("Beansjdbc.xml");
         UserJDBCTemplate userJDBCTemplate = 
         (UserJDBCTemplate)context.getBean("UserJDBCTemplate");  
         
         // 1.创建一条记录
         System.out.println("------Records Creation--------" );
         userJDBCTemplate.insertUser(new User("wangchongyang","1223dfcfdv12",18.5));
         
         //2. 查询所有记录
         System.out.println("------Listing Multiple Records--------" );
         List<User> userList = userJDBCTemplate.selectAllUser();
         for (User user : userList)
         {
             System.out.println(user);
         }
         
         //3. 删除一条记录
         System.out.println("------Delete Record By ID--------" );
         userJDBCTemplate.deleteUser(3);   
    }
}

运行结果：

------Records Creation--------

Created Record: UserBean [id=null, username=wangchongyang, password=1223dfcfdv12, account=18.5]

------Listing Multiple Records--------
verification.
UserBean [id=1, username=zhangsan, password=abcd1234, account=1234.0]
UserBean [id=2, username=lisi, password=123456789, account=13456.0]
UserBean [id=3, username=wangwu, password=123adfg9, account=34567.0]
UserBean [id=4, username=zhuliu, password=123adfg9, account=34567.0]
UserBean [id=5, username=zhangsan, password=fbdjfvjdf, account=12.5]
UserBean [id=6, username=wangchongyang, password=1223dfcfdv12, account=18.5]

------Delete Record By ID--------
Deleted Record with id = 3

参考博客：

1. https://www.w3cschool.cn/wkspring/iuck1mma.html