使用JDBC连接和操作数据库

青旅半醒 2023-06-06 03:43 23阅读 0赞

## 写在前面 ##

笔者之前写过一篇[通过JDBC操作MySQL数据库][JDBC_MySQL]，文章内容对使用 JDBC 操作数据库过程的各个步骤进行了说明，并在最后给出了一个小的样例。

此次，将尝试使用一种新的方式进行公共操作的封装。在样例程序中也将使用数据访问层和业务层的模式进行模块划分。

## 工具类 ##

连接到数据库并在使用完成之后释放资源的方法封装。

public class BaseDao {
        /*
         * 不同的数据库甚至同一数据库的不同版本，在不同的驱动包下配置信息都有所不同
         */
        private static final String CLASS_NAME = "com.mysql.cj.jdbc.Driver";
        private static final String URL = "jdbc:mysql://127.0.0.1:3306/databasename?useSSL=FALSE&serverTimezone=UTC&characterEncoding=utf8";
        private static final String USER_NAME = "username";
        private static final String PASSWORD = "password";
        
        public Connection getConnection() {
            Connection connection = null;
            try {
                // 加载驱动
                Class.forName(CLASS_NAME);
                // 获取数据库连接对象
                connection = DriverManager.getConnection(URL, USER_NAME, PASSWORD);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return connection;
        }
        
        public void closeAll(Connection connection, PreparedStatement statement, ResultSet resultSet) {
            /*
            * 当且仅当资源对象不为 null 的时候进行资源的关闭与释放
            * 释放资源的时候, 先释放结果集, 再释放操作对象, 最后释放连接对象
            */
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } // end if
        } // end method
    }

## 在 DAO 层进行增删改查操作 ##

增删改查 实际上是增删改和查操作。即更新和查询两种分类。  
如果是更新操作，返回的是数据库中受影响的行数，使用 int 接收即可；如果是查询操作，返回的是结果集ResultSet，一般情况下，还要继续对结果集中的信息进行读取并封装成想要的数据格式。

### 在数据操作之前，先封装一个实体类 ###

以图书查询为例，创建一个属性较为简单的实体类 Book。

public class Book {
        
        private Long bookId;
        private String bookName;
        private double price;
        
        // constructor
        // getters and setters
        // toString
    }

### BookDao ###

如果按照面向接口编程，应该首先使用接口定义方法，然后在实现类中实现这些方法。

public interface BookDao {
        // 添加书籍到数据库
        int insertBook(Book book);
        // 根据编号删除图书
        int deleteBookById(Long bookId);
        // 修改图书信息
        int updateBook(Book book);
        // 查询所有图书
        List<Book> selectAllBooks();
        // 根据书名进行模糊查询
        List<Book> selectBooksByName(String bookName);
        // 根据编号查询具体的一本书
        Book selectBookById(Long bookId);
        // 其他查询, 根据要求进行补充
    }

在 DAO 的具体实现类中，实现 BookDao 接口，对其中的方法进行实现。可以通过继承 BaseDao 然后调用其中方法，也可以将 BaseDao 作为成员变量然后创建实例对象调用方法。本例使用继承实现重用。

public class BookDaoImpl extends BaseDao implements BookDao {
    
        // 添加书籍到数据库
        public int insertBook(Book book) {
            // 记录数据库受影响行数
            int count = 0;
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 添加图书的 SQL 语句, id 自增, 不需要设置
            String sqlString = "insert into t_book(bname,bprice) values(?,?)";
            try {
                // 获取数据库连接对象
                connection  = this.getConnection();
                // 使用数据库连接对象和 SQl 语句创建预编译的数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 给占位符赋值
                statement.setString(1, book.getBookName());
                statement.setDouble(2, book.getPrice());
                // 执行添加图书的操作, 更新操作统一使用 executeUpdate() 
                count = statement.executeUpdate();
            } catch(Exception e) {
                e.printStackTrace();
                return 0;
            } finally {
                // 因为更新操作没有结果集对象, 所有传入 null
                this.closeAll(connection, statement, null);
            }
            return count;
        }
        
        // 根据编号删除图书
        public int deleteBookById(Long bookId) {
            // 记录数据库受影响行数
            int count = 0;
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 删除图书的 SQL 语句
            String sqlString = "delete from t_book where bid = ?";
            try {
                // 获取数据库连接对象
                connection  = this.getConnection();
                // 使用数据库连接对象和 SQl 语句创建预编译的数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 给占位符赋值
                statement.setLong(1, bookId);
                // 执行删除图书的操作
                count = statement.executeUpdate();
            } catch(Exception e) {
                e.printStackTrace();
                return 0;
            } finally {
                this.closeAll(connection, statement, null);
            }
            return count;        
        }
        
        // 修改图书信息
        public int updateBook(Book book) {
            // 记录数据库受影响行数
            int count = 0;
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 更新图书的 SQL 语句
            String sqlString = "update t_book set bname = ?, bprice = ? where bid = ?";
            try {
                // 获取数据库连接对象
                connection  = this.getConnection();
                // 使用数据库连接对象和 SQl 语句创建预编译的数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 给占位符赋值
                statement.setString(1, book.getBookName());
                statement.setDouble(2, book.getPrice());
                statement.setLong(3, book.getBookId());
                // 执行更新图书的操作
                count = statement.executeUpdate();
            } catch(Exception e) {
                e.printStackTrace();
                return 0;
            } finally {
                this.closeAll(connection, statement, null);
            }
            return count;        
        }
        
        // 查询所有图书
        public List<Book> selectAllBooks() {
            // 用于封装查询结果的 List
            List<Book> booksList = new ArrayList<>();
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 接收查询的结果集
            ResultSet resultSet = null;
            // 查询语句
            String sqlString = "select bid,bname,bprice from t_book";
            try {
                // 获取数据库连接
                connection = this.getConnection();
                // 构造数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 执行查询操作, executeQuerty()
                resultSet = statement.executeQuery();
                // 将结果集中的查询结果封装到 List
                while (resultSet.next()) {
                    Book book = new Book();
                    book.setBookId(resultSet.getLong("bid"));
                    book.setBookName(resultSet.getString("bname"));
                    book.setPrice(resultSet.getDouble("bprice"));
                    booksList.add(book);
                }
            } catch(Exception e) {
                e.printStackTrace();
                return null;
            } finally {
                this.closeAll(connection, statement, resultSet);
            }
            return booksList;
        }
        
        // 根据书名进行模糊查询, 与上面的方法仅仅时 SQL 语句的区别（注意为占位符赋值）
        public List<Book> selectBooksByName(String bookName) {
            // 用于封装查询结果的 List
            List<Book> booksList = new ArrayList<>();
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 接收查询的结果集
            ResultSet resultSet = null;
            // 查询语句
            String sqlString = "select bid,bname,bprice from t_book where bname like ?";
            try {
                // 获取数据库连接
                connection = this.getConnection();
                // 构造数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 为占位符赋值, 模糊查询的通配符在这里设置
                statement.setString(1, "%" + bookName + "%");
                // 执行查询操作, executeQuerty()
                resultSet = statement.executeQuery();
                // 将结果集中的查询结果封装到 List
                while (resultSet.next()) {
                    Book book = new Book();
                    book.setBookId(resultSet.getLong("bid"));
                    book.setBookName(resultSet.getString("bname"));
                    book.setPrice(resultSet.getDouble("bprice"));
                    booksList.add(book);
                }
            } catch(Exception e) {
                e.printStackTrace();
                return null;
            } finally {
                this.closeAll(connection, statement, resultSet);
            }
            return booksList;
        }
        
        // 根据编号查询具体的一本书
        public Book selectBookById(Long bookId) {
            // 用于封装查询结果的 Book 对象, 设置为 null 而不是直接创建对象, 当查询出错时返回 null 有助于业务层的判断
            Book book = null;
            // 数据库连接对象
            Connection connection = null;
            // 数据库操作对象
            PreparedStatement statement = null;
            // 接收查询的结果集
            ResultSet resultSet = null;
            // 查询语句
            String sqlString = "select bid,bname,bprice from t_book where bid = ?";
            try {
                // 获取数据库连接
                connection = this.getConnection();
                // 构造数据库操作对象
                statement = connection.prepareStatement(sqlString);
                // 为占位符赋值, 模糊查询的通配符在这里设置
                statement.setLong(1, bookId);
                // 执行查询操作, executeQuerty()
                resultSet = statement.executeQuery();
                // 将结果集中的查询结果封装到 List
                while (resultSet.next()) {
                    book = new Book();
                    book.setBookId(resultSet.getLong("bid"));
                    book.setBookName(resultSet.getString("bname"));
                    book.setPrice(resultSet.getDouble("bprice"));
                }
            } catch(Exception e) {
                e.printStackTrace();
                return null;
            } finally {
                this.closeAll(connection, statement, resultSet);
            }
            return book;
        }
    }

## 业务层 ##

实际上，在 DAO 层就已经完成了所有的数据库操作。但是这仍然给出业务层的实现并通过业务层进行单元测试。

### 业务层实现类 ###

// 略过接口
    public class BookServiceImpl {
        private BookDao bookDao = null;
        
        public BookServiceImpl() {
            // 创建对象的时候给 bookDao 赋值
            bookDao = new BookDaoImpl();
        }
        
        // 添加书籍到数据库
        public Boolean addBook(Book book) {
            int count = bookDao.insertBook(book);
            if (count == 1) {
                return true;
            } else {
                return false;
            }
        }
        // 根据编号删除图书
        public Boolean removeBookById(Long bookId) {
            int count = bookDao.deleteBookById(bookId);
            if (count > 0) {
                return true;
            } else {
                return false;
            }
        }
        // 修改图书信息
        public Boolean updateBook(Book book) {
            int count = bookDao.updateBook(book);
            if (count > 0) {
                return true;
            } else {
                return false;
            }
        }
        // 查询所有图书
        public List<Book> getAllBooks() {
            return bookDao.selectAllBooks();
        }
        // 根据书名进行模糊查询
        public List<Book> getBooksByName(String bookName) {
            return bookDao.selectBooksByName(bookName);
        }
        // 根据编号查询具体的一本书
        public Book getBookById(Long bookId) {
            return bookDao.selectBookById(bookId);
        }
    }

### 单元测试 ###

public class BookServiceImplTest {
        @Test
        public void testAddBook() throws Exception {
            Book book = new Book("三国演义", 89);
            BookServiceImpl service = new BookServiceImpl();
            if (service.addBook(book)) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        }
        @Test
        public void testRemoveBookById() throws Exception {
            BookServiceImpl service = new BookServiceImpl();
            if (service.removeBookById(1L)) {
                System.out.println("删除成功");
            } else {
                System.out.println("删除失败");
            }
        }
        @Test
        public void testUpdateBook() throws Exception {
            Book book = new Book(1L, "三国演义", 89.92);
            BookServiceImpl service = new BookServiceImpl();
            if (service.updateBook(book)) {
                System.out.println("更新成功");
            } else {
                System.out.println("更新失败");
            }
        }
        @Test
        public void testGetAllBooks() throws Exception {
            BookServiceImpl service = new BookServiceImpl();
            List<Book> list = service.getAllBooks();
            for (Book book : list) {
                System.out.println(book);
            }
        }
        @Test
        public void testGetBooksByName() throws Exception {
            BookServiceImpl service = new BookServiceImpl();
            List<Book> list = service.getBooksByName("演义");
            for (Book book : list) {
                System.out.println(book);
            }
        }
        @Test
        public void testGetBookById() throws Exception {
            BookServiceImpl service = new BookServiceImpl();
            Book book = service.getBookById(1L);
            System.out.println(book);
        }
    }

## 说明： ##

本篇博客所有代码均使用记事本书写，没有借助工具检测，可能存在拼写错误，欢迎读者朋友们指正。

[JDBC_MySQL]: https://blog.csdn.net/qq_38234015/article/details/84145154