Spring初步学习——数据库编程

最新推荐文章于 2024-05-03 12:27:54 发布

jing1008-wang

最新推荐文章于 2024-05-03 12:27:54 发布

阅读量190

点赞数

分类专栏：历史文章

本文链接：https://blog.csdn.net/sinat_36722750/article/details/84292428

版权

历史文章专栏收录该内容

40 篇文章 0 订阅

订阅专栏

传统JDBC回顾

首先我们来回顾一下传统的JDBC，怎么连接数据库的，往往我们要写很多的重复模板代码：

public Student getOne(int id) {

    String sql = "SELECT id,name FROM student WHERE id = ?";
    Student student = null;
    // 声明 JDBC 变量
    Connection con = null;
    PreparedStatement ps = null;
    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类，将重复的模板代码提出来，创建一个数据库工具类

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);
    }
}

然后就可以把之前的代码变成这样：

public Student getOne(int id) {

    String sql = "SELECT id,name FROM student WHERE id = ?";
    Student student = null;
    // 声明 JDBC 变量
    Connection con = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        // 获取连接
        con = DBUtil.getConnection();
        // 预编译SQL
        ps = con.prepareStatement(sql);
        // 设置参数
        ps.setInt(1, id);
        // 执行SQL
        rs = ps.executeQuery();
        // 组装结果集返回 POJO
        ....
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接资源
        ....
    }
    return student;
}

第二步：使用try-catch语句自动关闭资源（自动关闭资源JDK7中引入的特性）

于是代码就可以优化成这样了：

public Student getOne(int id) {

    String sql = "SELECT id,name FROM student WHERE id = ?";
    Student student = null;
    // 将 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中新增一个方法，用来直接返回结果集：

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++) {
            ps.setObject(i + 1, objects[i]);
        }
        // 执行 SQL 语句并接受结果集
        rs = ps.executeQuery();
    }
    // 返回结果集
    return rs;
}

这样最初的代码就可以优化成这样了：

public Student getOne(int id) {

    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));
    } catch (SQLException e) {
        // 处理异常
        e.printStackTrace();
    }
    return student;
}

Spring中的JDBC

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

spring-jdbc-4.3.16.RELEASE.jar
spring-tx-4.3.16.RELEASE.jar

配置数据库资源的两种方式：

使用简单数据库配置
使用第三方数据库连接池

1》【使用简单数据库配置】

使用Spring的内置类：org.springframework.jdbc,datasource.SimpleDriverDataSource;

<bean id="dateSource" 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://locolhost:3306/student"/>
</bean>

我们来测试一下，JDBC操作类如下：

package jdbc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import pojo.Student;
import javax.sql.DataSource;
import java.sql.*;

@Component("jdbc")
public class JDBCtest {

    @Autowired
    private DataSource dataSource;

    public Student getOne(int stuID) throws SQLException {

        String sql = "SELECT id, name FROM student WHERE id = " + stuID;
        Student student = new Student();
        Connection con = dataSource.getConnection();
        Statement st = con.createStatement();
        ResultSet rs = st.executeQuery(sql);
        if (rs.next()) {
            student.setId(rs.getInt("id"));
            student.setName(rs.getString("name"));
        }
        return student;
    }
}

然后编写测试类：

ApplicationContext context =
        new ClassPathXmlApplicationContext("applicationContext.xml");
JDBCtest jdbc = (JDBCtest) context.getBean("jdbc");
Student student = jdbc.getOne(1);
System.out.println(student.getId());
System.out.println(student.getName());

2》【使用第三方数据库连接池】

我们举例使用C3P0数据库连接池：

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
    <property name="initialPoolSize" value="3"></property>
    <property name="maxPoolSize" value="10"></property>
    <property name="maxStatements" value="100"></property>
    <property name="acquireIncrement" value="2"></property>
</bean>

3》【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"
       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">

    <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" />

    <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.*;

@Component("jdbc")
public class JDBCtest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    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;
    }
}

再来看看其他CRUD的例子：

/**
 * 增加一条数据
 *
 * @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);
}

转载链接：我没有三个心脏

jing1008-wang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring初步学习——数据库编程

传统JDBC回顾首先我们来回顾一下传统的JDBC，怎么连接数据库的，往往我们要写很多的重复模板代码：public Student getOne(int id) { String sql = "SELECT id,name FROM student WHERE id = ?"; Student student = null; // 声明 JDBC 变量 C...
复制链接

扫一扫