DAO设计模式的介绍与实现

系统管理员 2022-06-06 14:09 133阅读 0赞

#### 前言：哈哈，第一篇关于Java的博客了，暑假看了一些Java的设计模式，本来想着总结一下的，但是一耽误就到现在了，后面慢慢补上。今天我们来聊聊DAO ####

#### 1、DAO是个什么东西呢? ####

看一下官方的介绍，DAO（Data Access Object，数据访问对象）的主要功能是数据操作，在程序的标准开发架构中属于数据层的操作。额，好像有点糊涂啊，用人类的语言解释一下也就是DAO是一种操作数据库的设计模式，也就是我们通过DAO这种设计模式，对于数据库的操作更加的方便管理，可扩展性更加的好。说到这里，可能也不是很明白，你把下面的代码都敲一遍，自然就明白了。

#### 2、DAO的组成 ####

上面说了DAO是什么东西，现在就来说说DAO的组成。有些地方说DAO是由五部分组成，有些地方说是由六部分组成。  
五部分的说法是

数据库连接类: 连接数据库
    VO实体类: JavaBean，里面一堆的setter和getter
    DAO接口:  接口还能干啥，不就是让别人来实现吗，进行规范化管理。老板（接口）说了让你写报告，你要是不写就开除（报错）
    DAO实现类: 员工写报告的的具体过程（打开电脑，***，关闭电脑，汇报）
    DAO工厂类: 工厂不就是为了方便调用吗，要什么给什么。

六部分的说法是

数据库连接类: 连接数据库
    VO实体类: JavaBean，里面一堆的setter和getter
    DAO接口:  接口还能干啥，不就是让别人来实现吗，进行规范化管理。老板（接口）说了让你写报告，你要是不写就开除（报错）
    DAO实现真正类: 员工自己不写，嘿嘿，去找小明帮他写，所以小明成为了真正的实现类
    DAO的代理实现类: 员工这时候就是代理实现类
    DAO工厂类: 工厂不就是为了方便调用吗，要什么给什么。

其实关于上面的两种组成部分，我还是比较赞同六部分组成的，因为这样更加的清晰化，数据和逻辑得到更进一步的分离，所以我下面就采用六部分来实现一个小例子。

#### 3、通过图书的增删改查来看看这个神秘的玩意儿 ####

1、创建数据库（自己使用的是MySQL）,咱们就随便找几个字段意思一下，比较重点不在这里

create table books( bookid int auto_increment primary key, bookName varchar(50) not null, bookNumber int not null default 0, pubdate datetime not null, UNIQUE INDEX unique_id(bookid) )

2、编写数据库的连接类  
在编写数据库的连接类之前，我们可以想一想，我们这里采用的是MySQL数据库，如果其他地方使用Oracle或者SQL Server，那么我们的数据库连接类就需要进行修改，在Java中有一个设计模式的理念就是我们尽量不要进行代码的修改，通过增加代码来实现我们想要的功能（我忘记这个设计模式叫什么名字了，手动【尴尬】），因此我们通过让连接类实现一个接口的方式来连接数据库。我们建立一个DB包，在包中建立一个DatabaseConnection接口和一个MySQLConnection类  
DatabaseConnection的代码如下

package DB;
    
    import java.sql.Connection;
    public interface DatabaseConnection { 
        // 取得数据库的连接
        public Connection getConnection();
        // 关闭数据库的连接
        public void close();
    }

MySQLConnection的代码如下

package DB;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    public class MySQLConnection implements DatabaseConnection{ 
        //数据库连接驱动
        private static final String DBDRIVER = "com.mysql.jdbc.Driver";
        //数据库连接地址，我这里直接将数据库名字web放在后面了
        private static final String DBULR = "jdbc:mysql://localhost:3306/web";
        // 数据库用户名 
        private static final String USERNAME = "root";
        // 数据库密码 
        private static final String PASSWORD = "root";
        private Connection conn;
        // 取得数据库连接
        public Connection getConnection() throws Exception{
            try {
                // 加载驱动程序
                Class.forName(DBDRIVER);
                // 取得数据库连接，获得资源句柄
                this.conn = DriverManager.getConnection(DBULR,USERNAME,PASSWORD);
            }catch(Exception e) {
                throw e;
            }
            return this.conn;
        }
        // 关闭数据库连接 
        public void close() throws Exception{
            if(this.conn != null) {
                try{
                    this.conn.close();
                }catch(Exception e) {
                    throw e;
                }
            }
        }
    }

3、数据库连接类写好了，咱们来写一下VO类吧，我们建一个VO的包，在里面建立一下Book类  
book类的代码如下

package VO;
    
    import java.util.Date;
    
    public class Book { 
        private int bookid;
        private String bookName;
        private int bookNumber;
        private Date pubdate;
        public int getBookid() {
            return bookid;
        }
        public void setBookid(int bookid) {
            this.bookid = bookid;
        }
        public String getBookName() {
            return bookName;
        }
        public void setBookName(String bookName) {
            this.bookName = bookName;
        }
        public int getBookNumber() {
            return bookNumber;
        }
        public void setBookNumber(int bookNumber) {
            this.bookNumber = bookNumber;
        }
        public Date getPubdate() {
            return pubdate;
        }
        public void setPubdate(Date pubdate) {
            this.pubdate = pubdate;
        }
    }

4、接下来就是DAO接口类了，上面已经说过了，这就是老板安排的任务的汇总（进行数据库操作的所有方法）。因为我们要对图书进行增删改查，所以我们需要findById方法（查找），findAll（显示全部书籍），doUpdate（修改书籍），doDelete（删除书籍），doCreate（新增书籍）。我们建立一个DAO包，在这里面建立一个bookDAO的接口  
bookDAO的代码如下

package DAO;
    
    import java.sql.SQLException;
    import java.util.List;
    
    import VO.Book;
    
    public interface BookDAO { 
        // 查找某一本书籍
        public Book findById(int bookid) throws Exception;
        // 显示所有书籍
        public List<Book> findAll() throws Exception;
        // 修改书籍信息
        public boolean doUpdate(Book book) throws Exception;
        // 删除书籍信息
        public boolean doDelete(Book book) throws Exception;
        // 新增书籍信息
        public boolean doCreate(Book book) throws Exception;
    }

5、接下来我们就是进行方法的具体实现，如果拆分成五部分的话，在这里就直接把方法实现了，但是因为我将其拆分成了六部分，所以我就先写真正的实现类，再写代理实现类。我们在DAO下面建立一个BookDAOImpl的类  
BookDAOImpl的代码如下（代码相对比较多，但是逻辑比较简单）

package DAO;
    
    import java.sql.Connection;
    import java.sql.Date;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    import VO.Book;
    
    public class BookDAOImpl implements BookDAO { 
        private Connection conn;
        // 这里采用PreparedStatement进行预处理，主要是为了方式SQL注入
        // 关于网络安全，可以看我GitHub上面的一个文章
        // https://github.com/deng1234/webSecurity
        private PreparedStatement pstmt;
        // 在代理实现类中进行对象实例化的时候获得连接数据库的资源句柄 
        public BookDAOImpl(Connection conn) {
            this.conn = conn;
        }
        @Override
        // 根据id查找 
        public Book findById(int bookid) throws SQLException{
            Book book = new Book();
            String sql = "SELECT bookid, bookName, bookNumber, pubdate FROM books WHERE bookid = ?";
            try {
                this.pstmt = this.conn.prepareStatement(sql);
                this.pstmt.setInt(1, bookid);
                ResultSet rs = (ResultSet) this.pstmt.executeQuery();
                if(rs.next()) {
                    book.setBookid(rs.getInt(1));
                    book.setBookName(rs.getString(2));
                    book.setBookNumber(rs.getInt(3));
                    book.setPubdate(rs.getDate(4));
                }
            } catch (SQLException e) {
                throw e;
            }
            this.pstmt.close();
            return book;
        }
    
        @Override
        // 列出所有书籍
        public List<Book> findAll() throws SQLException {
            List<Book> books = new ArrayList<Book>();
            Book book;
            String sql = "SELECT bookid, bookName, bookNumber, pubdate FROM books";
            try {
                this.pstmt = this.conn.prepareStatement(sql);
                ResultSet rs = (ResultSet) this.pstmt.executeQuery();
                while(rs.next()) {
                    book = new Book();
                    book.setBookid(rs.getInt(1));
                    book.setBookName(rs.getString(2));
                    book.setBookNumber(rs.getInt(3));
                    book.setPubdate(rs.getDate(4));
                    books.add(book);
                }
            } catch (SQLException e) {
                throw e;
            }
            this.pstmt.close();
            return books;
        }
    
        @Override
        // 修改书籍信息
        public boolean doUpdate(Book book) throws SQLException {
            boolean flag = false;
            String sql = "UPDATE books SET bookName = ?, bookNumber = ?, pubdate = ? WHERE bookid = ?";
            try {
                this.pstmt = this.conn.prepareStatement(sql);
                this.pstmt.setString(1, book.getBookName());
                this.pstmt.setInt(2, book.getBookNumber());
                this.pstmt.setDate(3, new java.sql.Date(book.getPubdate().getTime()));
                this.pstmt.setInt(4, book.getBookid());
                if(this.pstmt.executeUpdate() > 0) {
                    flag = true;
                }
            } catch (SQLException e) {
                throw e;
            }
            this.pstmt.close();
            return flag;
        }
    
        @Override
        // 删除书籍信息
        public boolean doDelete(Book book) throws SQLException {
            boolean flag = false;
            String sql = "DELETE FROM books WHERE bookid = ?";
            try {
                this.pstmt = this.conn.prepareStatement(sql);
                this.pstmt.setInt(1, book.getBookid());
                if(this.pstmt.executeUpdate() > 0) {
                    flag = true;
                }
            } catch (SQLException e) {
                throw e;
            }
            this.pstmt.close();
            return flag;
        }
    
        @Override
        // 新增书籍
        public boolean doCreate(Book book) throws SQLException {
            boolean flag = false;
            String sql = "INSERT INTO books (bookName, bookNumber, pubdate) "
                    + "values(?, ?, ?)";
            try {
                this.pstmt = this.conn.prepareStatement(sql);
                this.pstmt.setString(1, book.getBookName());
                this.pstmt.setInt(2, book.getBookNumber());
                this.pstmt.setDate(3, new java.sql.Date(book.getPubdate().getTime()));
                if(this.pstmt.executeUpdate() > 0) {
                    flag = true;
                }
            } catch (SQLException e) {
                throw e;
            }
            this.pstmt.close();
            return flag;
        }
    
    }

6、咱们接下来就写DAO的代理实现类，在DAO的包下面建立一个BookDAOProxy类，因为不管是代理，还是真正去实现的，接口中（老板）的方法都是需要去做的，所以我们在这里面都需要实现BookDAO接口  
BookDAOProxy类的代码为

package DAO;
    
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import DB.MySQLConnection;
    import VO.Book;
    
    public class BookDAOProxy implements BookDAO{ 
        private MySQLConnection conn = null;
        private BookDAO dao;
        public BookDAOProxy() throws Exception {
            this.conn = new MySQLConnection();
            // 在这里对真正的DAO实现内进行实例化 
            this.dao = new BookDAOImpl(this.conn.getConnection());
        }
    
        @Override
        // 书籍查找
        public Book findById(int bookid) throws Exception {
            Book book = new Book();
            try {
                book = this.dao.findById(bookid);
            }catch(SQLException e) {
                throw e;
            }finally {
                // 关闭数据库
                this.conn.close();
            }
            return book;
        }
    
        @Override
        // 列出所有书籍
        public List<Book> findAll() throws Exception {
            List<Book> books = new ArrayList<Book>();
            try {
                books = this.dao.findAll();
            }catch(Exception e) {
                throw e;
            }finally {
                this.conn.close();
            }
            return books;
        }
    
        @Override
        public boolean doUpdate(Book book) throws Exception {
            boolean flag = false;
            try {
                if(this.dao.findById(book.getBookid()) != null) {
                    flag = this.dao.doUpdate(book);
                }
            }catch(Exception e) {
                throw e;
            }finally {
                this.conn.close();
            }
            return flag;
        }
    
        @Override
        public boolean doDelete(Book book) throws Exception {
            boolean flag = false;
            try {
                flag = this.dao.doDelete(book);
            }catch(Exception e) {
                throw e;
            }finally {
                this.conn.close();
            }
            return flag;
        }
    
        @Override
        public boolean doCreate(Book book) throws Exception {
            boolean flag = false;
            try {
                flag = this.dao.doCreate(book);
            }catch(Exception e) {
                throw e;
            }finally {
                this.conn.close();
            }
            return flag;
        }
    
    }

7、挺住，我们马上就迎来最后一部分啦，建立一个工厂类。为什么进行工厂类呢，如果不进行工厂化处理的时候，我们调用方法需要对BookDAOProxy进行对象实例化，然后再调用其中的方法，不管在哪里调用，都需要进行对象实例化。如果有一天我们需要修改代理类，哈哈，你就需要去每一个地方修改（^\_\_^），虽然修改的可能性不大哈。但是如果我们进行工厂类的封装，调用直接通过工厂类取得其实例化，并且如果要要换一个代理类，直接修改即可。我们建立一个FACTORY的包，然后在下面建立一个DAOFactoty的类  
DAOFactory的代码为

package FACTORY;
    
    import DAO.BookDAO;
    import DAO.BookDAOProxy;
    
    public class DAOFactory { 
        public static BookDAO getBookDAOInstance() throws Exception {
            return new BookDAOProxy();
        }
    }

#### 4、折腾了半天，我们总得测试一下，看看写的正确吧 ####

我们建立一个Test包，在里面建立一个doCreate的类测试数据插入，doUpdate测试数据修改，doDelete测试数据删除，findAll数据显示，finById数据查找 。  
数据插入方法测试的测试

package Test;
    
    import FACTORY.DAOFactory;
    import VO.Book;
    
    public class doCreate { 
        public static void main(String args[]) throws Exception {
            Book book = new Book();
            try {
                book.setBookName("Java特种兵");
                book.setBookNumber(1);
                book.setPubdate(new java.util.Date());
                boolean flag = DAOFactory.getBookDAOInstance().doCreate(book);
                System.out.println(flag);//true则是成功,false则是失败
            }catch(Exception e) {
                System.out.println(e);
            }
        }
    }

数据查找方法测试代码

package Test;
    
    import FACTORY.DAOFactory;
    import VO.Book;
    
    public class finById { 
        public static void main(String args[]) throws Exception {
            Book book = new Book();
            try {
                book = DAOFactory.getBookDAOInstance().findById(1);
                System.out.println(book.getBookName()+"--"+book.getBookNumber()+"--"+book.getPubdate());
            }catch(Exception e) {
                System.out.println(e);
            }
        }
    }

数据修改方法测试代码

package Test;
    
    import FACTORY.DAOFactory;
    import VO.Book;
    
    public class doUpdate { 
        public static void main(String args[]) throws Exception {
            Book book = new Book();
            try {
                book.setBookid(1);
                book.setBookName("Java特种兵");
                book.setBookNumber(3);
                book.setPubdate(new java.util.Date());
                boolean flag = DAOFactory.getBookDAOInstance().doUpdate(book);
                System.out.println(flag);
            }catch(Exception e) {
                System.out.println(e);
            }
        }
    }

数据删除方法代码测试

package Test;
    
    import FACTORY.DAOFactory;
    import VO.Book;
    
    public class doDelete { 
        public static void main(String args[]) throws Exception {
            Book book = new Book();
            try {
                book.setBookid(1);
                boolean flag = DAOFactory.getBookDAOInstance().doDelete(book);
                System.out.println(flag);
            }catch(Exception e) {
                System.out.println(e);
            }
        }
    }

显示所有数据方法代码测试

package Test;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    import FACTORY.DAOFactory;
    import VO.Book;
    
    public class findAll { 
        public static void main(String args[]) throws Exception {
            List<Book> books = new ArrayList<Book>();
            Book book = new Book();
            try {
                books = DAOFactory.getBookDAOInstance().findAll();
                Iterator<Book> iter = books.iterator();
                while(iter.hasNext()) {
                    book = iter.next();
                    System.out.println(book.getBookName()+"--"+book.getBookNumber()+"--"+book.getPubdate());
                }
            }catch(Exception e) {
                System.out.println(e);
            }
        }
    }

详细代码可以在我的[Github][]上面查看

（完）

[Github]: https://github.com/deng1234/Java-DAO