Spring JDBC

9. Spring JDBC

• Spring 提供了一个 Spring JDBC 模块，它对 JDBC API 进行了封装，其的主要目的降低 JDBC API 的使用难度，使用 Spring JDBC，只需要定义必要的参数、指定需要执行的 SQL 语句，即可轻松的进行 JDBC 编程，对数据库进行访问。除业务之外的其他模板式代码由Spring JDBC进行管理

JDBC 是 Java 提供的一种用于执行 SQL 语句的 API,支持多种关系型数据库

JDBC API使用麻烦，我们需要手动控制数据库连接的开启，异常处理、事务处理、最后还要手动关闭连接释放资源等等

9.1 JdbcTemplate

• Spring JDBC 提供了多个实用的数据库访问工具，以简化 JDBC 的开发，其中使用最多就是 JdbcTemplate。
• JdbcTemplate 是 Spring JDBC 核心包（core）中的核心类，它可以通过配置文件、注解、Java 配置类等形式获取数据库的相关信息，实现了对 JDBC 开发过程中的驱动加载、连接的开启和关闭、SQL 语句的创建与执行、异常处理、事务处理、数据类型转换等操作的封装。我们只要对其传入SQL 语句和必要的参数即可轻松进行 JDBC 编程。
• JdbcTemplate 的全限定命名为 org.springframework.jdbc.core.JdbcTemplate，它提供了大量的查询和更新数据库的方法

方法	说明
public int update(String sql)	用于执行新增、更新、删除等语句；sql：需要执行的 SQL 语句；args 表示需要传入到 SQL 语句中的参数。
public int update(String sql,Object… args)
public void execute(String sql)	可以执行任意 SQL，一般用于执行 DDL 语句； sql：需要执行的 SQL 语句；action 表示执行完 SQL 语句后，要调用的函数。
public T execute(String sql, PreparedStatementCallback action)
public List query(String sql, RowMapper rowMapper, @Nullable Object… args)
用于执行查询语句；sql：需要执行的 SQL 语句；rowMapper：用于确定返回的集合（List）的类型；args：表示需要传入到 SQL 语句的参数。
public T queryForObject(String sql, RowMapper rowMapper, @Nullable Object… args)
public int[] batchUpdate(String sql, List<Object[]> batchArgs, final int[] argTypes)	用于批量执行新增、更新、删除等语句； sql：需要执行的 SQL 语句；argTypes：需要注入的 SQL 参数的 JDBC 类型；batchArgs：表示需要传入到 SQL 语句的参数。

9.2 使用

• 导入依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.19</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.15</version>
 </dependency>
 <!--spring 操作数据库需要spring-jdbc，并提供事务支持-->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.3.20</version>
 </dependency>

• 例：编写db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/school?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
#导入的properties文件中不要将user定为username，否者会获取系统用户名
usernames=root
password=123456

• 实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final Long serializable = 1L;
    private int id;
    private String name;
    private String pwd;
}

• 编写applicationContext.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.zk"/>
    <!--引入 db.properties 中的配置-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--定义数据源 Bean-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
        <property name="driverClassName" value="${driver}"/>
        <property name="username" value="${usernames}"/>
        <property name="url" value="${url}"/>
        <property name="password" value="${password}"/>
    </bean>
    <!--定义JdbcTemplate Bean-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
        <property name="lazyInit" value="true"/>
    </bean>
</beans>

在以上配置中，我们共定义了两个 Bean，

• dataSource 为数据库连接池对象的 Bean。
• jdbcTemplate 则为 JdbcTemplate 的 Bean，它由一个名为 datasSource 的属性。

Spring 默认使用 DriverManagerDataSource 对数据库连接池进行管理，我们可以在 Spring 的 XML 配置文件中定义 DriverManagerDataSource 的 Bean，并注入到 JdbcTempate 的 Bean 中。

• 编写dao接口及实现类

public interface UserDao {

   List<User> getUserList();

   User getUser(Map map);

   int addUser(User user);

   int updateUser(Map map);

   int deleteUser(Map map);

   int count(Map map);

   int[] batchUser(List<Object[]> users);

}

@Repository
public class UserDaoImpl implements UserDao{
    @Resource
    JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public List<User> getUserList() {
        String sql = "select * from school.user";
        List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        return users;
    }

    @Override
    public User getUser(Map map) {
        String sql = "select * from school.user where id = ?";
        User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(User.class),map.get("id"));
        return user;
    }

    @Override
    public int addUser(User user) {
        String sql = "INSERT into school.user (id,name,pwd) VALUES(?,?,?);";
        int result = jdbcTemplate.update(sql, user.getId(), user.getName(), user.getPwd());
        return result;

    }

    @Override
    public int updateUser(Map map) {
        String sql = "update  school.user set pwd = ? where id = ?";
        int result = jdbcTemplate.update(sql, map.get("pwd"),map.get("id"));
        return result;
    }

    @Override
    public int deleteUser(Map map) {
        String sql = "delete from school.user where id = ?";
        int result = jdbcTemplate.update(sql, map.get("id"));
        return result;
    }

    @Override
    public int count(Map map) {
        String sql = "select count(1) from school.user where name = ?";
        int result = jdbcTemplate.queryForObject(sql,Integer.class, map.get("name"));
        return result;
    }

    @Override
    public int[] batchUser(List<Object[]> users) {
        String sql = "INSERT into school.user (id,name,pwd) VALUES(?,?,?);";
        int[] result = jdbcTemplate.batchUpdate(sql,users);
        return result;
    }
}

• 测试

public class testDemo {
    @Test
    public void test01(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        List<User> userList = userDao.getUserList();
        userList.forEach(var-> System.out.println(var.toString()));
    }
    @Test
    public void test02(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",2);
        User user = userDao.getUser(map);
        System.out.println(user.toString());
    }
    @Test
    public void test03(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        int result = userDao.addUser(new User(7, "Jom", "123456"));
        System.out.println("结果："+result);
    }
    @Test
    public void test04(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",7);
        map.put("pwd","987654");
        int result = userDao.updateUser(map);
        System.out.println("结果："+result);
    }

    @Test
    public void test05(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",7);
        int result = userDao.deleteUser(map);
        System.out.println("结果："+result);
    }
    @Test
    public void test06(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","tony");
        int result = userDao.count(map);
        System.out.println("结果："+result);
    }
    @Test
    public void test07(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        List<Object[]> objects = new ArrayList<>();
        Object[] o1 = {11,"Jom", "123456"};
        Object[] o2 = {12,"hom", "123456"};
        Object[] o3 = {13,"zail", "987654"};
        objects.add(o1);
        objects.add(o2);
        objects.add(o3);
        int[] result = userDao.batchUser(objects);
        System.out.println("结果："+result.length);
    }

}

本专栏下一篇：spring整合mybatis