Spring学习（九）Spring 和数据库编程

本文借鉴：Spring学习

一、传统 JDBC 回顾

用一个大佬的demo来简单看一下

/**
 * 使用jdbc，根据id查询单个Student的信息
 */
public class JdbcManage {
    public Student getOneStudent(int id) {

        String sql = "SELECT id,name FROM student WHERE id = ?";
        Student student = null;
        // 声明 JDBC 变量
        Connection con = null;
        PreparedStatement ps = null;//作用：预编译sql命令
        ResultSet rs = null;//查询数据库返回的结果集
        try {
            // 注册驱动程序
            Class.forName("com.myql.jdbc.Driver");
            // 获取连接
            con = DriverManager.getConnection("jdbc://mysql://localhost:" + "3306/student", "root", "root");
            // 预编译SQL
            ps = con.prepareStatement(sql);
            // 设置参数
            ps.setInt(1, id);
            // 执行SQL
            rs = ps.executeQuery();
            // 组装结果集返回 POJO
            if (rs.next()) {
                student = new Student();
                student.setId(rs.getInt(1));
                student.setName(rs.getString(1));
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接资源
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null && !ps.isClosed()) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (con != null && con.isClosed()) {
                    con.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return student;
    }
}

二、优化传统的 JDBC

第一步：创建 DBUtil 类

第一步我们可以把重复的模板代码提出来创建一个【DBUtil】数据库工具类

package util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    static String ip = "127.0.0.1";
    static int port = 3306;
    static String database = "student";
    static String encoding = "UTF-8";
    static String loginName = "root";
    static String password = "root";

    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        String url = String.format("jdbc:mysql://%s:%d/%s?characterEncoding=%s", ip, port, database, encoding);
        return DriverManager.getConnection(url, loginName, password);
    }
}

第二步：使用 try-catch 语句自动关闭资源

　　PS：自动资源关闭是 JDK 7 中新引入的特性（try-with-resources）

　　PS：使用方式：try关键字后跟一对圆括号，圆括号可以声明，初始化一个或多个资源，此处的资源指得是那些必须在程序结束时必须关闭的资源，try语句会在该语句结束时自动关闭这些资源。

public Student getOne(int id) {

    String sql = "SELECT id,name FROM student WHERE id = ?";
    Student student = null;
    // PS:将 JDBC 声明变量包含在 try(..) 里将自动关闭资源
    try (Connection con = DBUtil.getConnection(); PreparedStatement ps = con.prepareStatement(sql)) {

        // 设置参数
        ps.setInt(1, id);
        // 执行SQL
        ResultSet rs = ps.executeQuery();
        // 组装结果集返回 POJO
        if (rs.next()) {
            student = new Student();
            student.setId(rs.getInt(1));
            student.setName(rs.getString(1));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return student;
}

第三步：进一步改进 DBUtil 类

　　在 DBUtil 类中新增一个方法，用来直接返回结果集：

 /**
     * 通用db查询
     * @param sql sql语句
     * @param objects sql语句的参数
     * @return
     * @throws SQLException
     */
    public static ResultSet getResultSet(String sql, Object[] objects) throws SQLException {

        ResultSet rs = null;
        try (Connection con = getConnection(); PreparedStatement ps = con.prepareStatement(sql)) {

            // 根据传递进来的参数，设置 SQL 占位符的值
            for (int i = 0; i < objects.length; i++) {
                //这里的循环可以看做是一个结果集，每个ID对应存的东西就是一个sql查询出来的结果集
                ps.setObject(i + 1, objects[i]);
            }
            // 执行 SQL 语句并接受结果集
            rs = ps.executeQuery();
        }
        // 返回结果集
        return rs;
    }

　　最后的代码：

public Student getOne(int id) throws SQLException {

    String sql = "SELECT id,name FROM student WHERE id = ?";
    Object[] objects = {id};
    Student student = null;
    try (ResultSet rs = DBUtil.getResultSet(sql, objects);) {
        student.setId(rs.getInt(1));
        student.setName(rs.getString(1));
    }
    return student;
}

三、Spring 中的 JDBC

　　要想使用 Spring 中的 JDBC 模块，就必须引入相应的 jar 文件：

需要引入的 jar 包：
spring-jdbc-4.3.16.RELEASE.jar
spring-tx-4.3.16.RELEASE.jar

　　好在 IDEA 在创建 Spring 项目的时候已经为我们自动部署好了，接下来我们来实际在 Spring 中使用一下 JDBC

配置数据库资源

　　就像我们创建 DBUtil 类，将其中连接的信息封装在里面一样，这里只简单介绍一下Jdbc Template的方式。

Jdbc Template

　　Spring 中提供了一个 Jdbc Template 类，它自己已经封装了一个 DataSource 类型的变量，我们可以直接使用：

<?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"
       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">
    <!--配置数据源-->
    <bean id="dataSrouce" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/student"/>
    </bean>
    <!--配置扫描的包-->
    <context:component-scan base-package="jdbc"/>
    <!--用Spring带的jdbcTemplate来配置刚才的数据源，让程序进行调用-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSrouce"/>
    </bean>
</beans>

　　改写一下 JDBC 操作的类：

package jdbc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;
import pojo.Student;

import java.sql.ResultSet;
import java.sql.SQLException;

@Component("jdbc")
public class JDBCtest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 查询单条数据
     *
     * @param stuID
     * @return
     * @throws SQLException
     */
    public Student getOne(int stuID) throws SQLException {

        String sql = "SELECT id, name FROM student WHERE id = ?";
        Student student = jdbcTemplate.queryForObject(sql, new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet resultSet, int i) throws SQLException {
                Student stu = new Student();
                stu.setId(resultSet.getInt("id"));
                stu.setName(resultSet.getString("name"));
                return stu;
            }
        }, 123456789);
        return student;
    }

    /**
     * 增加一条数据
     *
     * @param student
     */
    public void add(Student student) {
        this.jdbcTemplate.update("INSERT INTO student(id,name) VALUES(?,?)",
                student.getId(), student.getName());
    }

    /**
     * 更新一条数据
     *
     * @param student
     */
    public void update(Student student) {
        this.jdbcTemplate.update("UPDATE student SET name = ? WHERE id = ?",
                student.getName(), student.getId());
    }

    /**
     * 删除一条数据
     *
     * @param id
     */
    public void delete(int id) {
        this.jdbcTemplate.update("DELETE FROM student WHERE id = ?",
                id);
    }
}

原文地址：https://www.cnblogs.com/riches/p/11572396.html