JDBC+DAO分层设计练习

一、数据库系统的三层架构

1、界面层（UI）

我们要做一个项目，想要什么样的外观，这是界面层要解决的问题

2、业务逻辑层（BLL）

为用户的每个功能模块，设计一个业务逻辑类。此时，需要利用相关的数据访问层类中，记录操作方法的特定集合，来实现每个逻辑功能。

3、数据访问层（DAO：Data Access Object)

业务层在实现相应功能的时候，需要访问数据库，而访问数据库就是对其进行增删查改的操作，因此DAO层实际上是面向数据库的增删查改而设计的，业务层通过调用数据访问层的服务实现业务处理。数据访问层实际上就是用Java语句来执行SQL语句。对于数据的存储，数据库中使用数据表，在程序中要使用对象，对象是对数据库中数据表的一种建模，对象名一定要与数据库中数据表的名称一致，这些对象就是简单Java类，通过这些简单Java类来存储和运输数据。

• 开发数据访问层的标准：命名方式严格使用xxxDao
• 数据更新：doXxx(),doCreate(),doUpdate(),doRemove()
• 数据查询：查询数据表中的数据：findXxx()。findByID(),findByName()
• 查询数据表中的统计信息：getXxx(),getAllCount()
• 在设计接口的时候，要写清楚属性和方法的注释

4、三层之间的调用关系

数据访问层的类：直接访问数据库，实现基本记录操作
业务逻辑层的类：调用相关的数据访问层的类，实现用户所需功能
界面层：部署控件后，调用业务逻辑层的类，实现功能

5、实体类（Entity）

存放实体类，实现数据对象实体和方法分离，以便在多个层中传递数据

6、业务测试

在test包中进行测试，明确这里的测试对象，这里主要是对业务进行测试，因此使用的主要就是业务层工厂类。

7、使用DAO进行分层设计

注意程序的结构搭建，实体层，DAO接口，DAO实现类：

• 数据库访问辅助类：DBUtil.java
• 实体类:User.java
• 数据访问接口：UserDao.java
• 数据访问接口的实现类：UserDaoImpl.java
• 并运行业务处理类：TestDao

二、JDBC

JDBC的全称是Java数据库连接==(Java Database connect)==，它是一套用于执行SQL语句的Java API。应用程序可通过这套API连接到关系数据库，并使用SQL语句来完成对数据库中数据的查询、更新和删除等操作。应用程序使用JDBC访问数据库的方式如下图所示：

1、搭建实验环境

启动 mysql 数据库，打开“myschool.sql”文件并执行，创建数据库 myschool

2、导入数据库驱动

在项目中新建文件夹lib，将jar包mysql-connector-java-8.0.13.jar复制到lib下，右击lib，选择“add as library”。

3、编写JDBC程序

加载驱动mysql8.0版本

Class.forName("com.mysql.cj.jdbc.Driver");

建立连接

conn = DriverManager.getConnection("jdbc:mysql:///myschool?serverTimezone=Hongkong", "root", "数据库密码");

编写SQL语句

String sql = "insert into users(username,password) values('Rose','123')";

三、使用DAO分层设计练习

1、实验要求

• 配置好maven；
• 创建一个maven项目，将mysql-connector-java-8.0.13.jar配置到pom.xml文件中；
• 参考TestDao.java程序，自行设计一个程序，访问myschool数据库的course表；
• 将运行结果截图，和程序一起提交

2、配置maven

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>week5_20201000000</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <properties>
      <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.13</version>
            </dependency>
        </dependencies>
</project>

配置成功后，点开此路径，可以查看自动下载的文件

D:\Maven_Repository\Repository\mysql\mysql-connector-java\8.0.13

3、访问myschool数据库的course表（代码）

User.java

package com.entity;

// User实体类，针对数据表User,实现数据表到类结构的转换，供 DAO层使用
//一个user对象对应 mysql表中一行
public class User {
    private int id;// 主键

    private String username;// 用户名

    private String password;// 密码


    public User(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }


    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

Course.java

package com.entity;
public class Course {
    private int id;

    private String cname;

    private int credit;

    private String department;

    private String content;

    public Course() {

    }

    public Course(String cname, int credit, String department, String content) {
        this.cname = cname;
        this.credit = credit;
        this.department = department;
        this.content = content;
    }

    public Course(int id, String cname, int credit, String department, String content) {
        this.id = id;
        this.cname = cname;
        this.credit = credit;
        this.department = department;
        this.content = content;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public int getCredit() {
        return credit;
    }

    public void setCredit(int credit) {
        this.credit = credit;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", cname='" + cname + '\'' +
                ", credit=" + credit +
                ", department='" + department + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

UserDao.java

package com.dao;

import com.entity.User;

import java.util.List;

//专门处理user表的接口
public interface UserDao {

    public boolean doAdd(User item);

    public boolean doDeleteById(int id);

    public boolean doUpdate(User item);

    public List<User> findAll();

    public List<User> findById(int id);
}

CourseDao.java

package com.dao;
import com.entity.Course;

import java.util.List;

public interface CourseDao {
    public boolean doAdd(Course item);

    public boolean doDeleteById(int id);

    public boolean doUpdate(Course item);

    public List<Course> findAll();

    public List<Course> findById(int id);

}

UserDaoImpl.java

package com.dao.impl;
import com.dao.UserDao;
import com.db.DBUtilConfig;
import com.entity.User;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

//UserDao的实现类，通过DBUtil访问数据库
public class UserDaoImpl implements UserDao {
    private DBUtilConfig db;

    public UserDaoImpl() {
        db=new DBUtilConfig();
    }

    @Override
    public boolean doAdd(User item) {
        String sql="insert into users(id,username,password) values(null,?,?)";
        Object[] params = { item.getUsername(),item.getPassword() };
        return db.execUpdate(sql,params);
    }

    @Override
    public boolean doDeleteById(int id) {
        String sql="delete from users where id = ?";
        Object[] params = { id };
        return db.execUpdate(sql,params);

    }


    @Override
    public boolean doUpdate(User item) {
        String sql="update users set username= ?,password = ? where id = ?";
        Object[] params = { item.getUsername(),item.getPassword(),item.getId() };
        return db.execUpdate(sql,params);
    }

    @Override
    public List<User> findById(int id) {
        List<User> usersList = new ArrayList<User>();
        String selectUsers="select * from users where id = ?";
        Object[] selparams = {id};
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryById(selectUsers,selparams);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String username=rest.getString("username");
                String password=rest.getString("password");
                usersList.add(new User(iid,username,password));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return usersList;
    }

    @Override
    public List<User> findAll() {
        List<User> usersList = new ArrayList<User>();
        String selectUsers="select * from users";
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryAll(selectUsers);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String username=rest.getString("username");
                String password=rest.getString("password");
                usersList.add(new User(iid,username,password));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return usersList;
    }
}

CourseDaoImpl.java

package com.dao.impl;
import com.db.DBUtilConfig;
import com.dao.CourseDao;
import com.entity.Course;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class CourseDaoImpl implements CourseDao {
    private DBUtilConfig db;

    public CourseDaoImpl() {
        db=new DBUtilConfig();
    }

    @Override
    public boolean doAdd(Course item) {
//        String sql="insert into course(cname,credit,department,content) values('"+item.getCname()+"','"+item.getCredit()+"','"+item.getDepartment()+"','"+item.getContent()+"')";
        String sql="insert into course(id,cname,credit,department,content) values(null,?,?,?,?)";
        Object[] params = { item.getCname(),item.getCredit(),item.getDepartment(),item.getContent() };
        return db.execUpdate(sql,params);
    }

    @Override
    public boolean doDeleteById(int id) {
        String sql="delete from course where id = ?";
        Object[] params = { id };
        return db.execUpdate(sql,params);

    }

    @Override
    public boolean doUpdate(Course item) {
        String sql="update course set cname= ?,credit = ?,department = ?,content = ? where id = ?";
        Object[] params = { item.getCname(),item.getCredit(),item.getDepartment(),item.getContent(),item.getId() };
        return db.execUpdate(sql,params);
    }

    @Override
    public List<Course> findById(int id) {
        List<Course> courseList = new ArrayList<Course>();
        String selectCourse="select * from course where id = ?";
//        封装参数
        Object[] selparams = { id };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryById(selectCourse,selparams);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String cname=rest.getString("cname");
                int credit=rest.getInt("credit");
                String department=rest.getString("department");
                String content=rest.getString("content");
                courseList.add(new Course(iid,cname,credit,department,content));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return courseList;
    }

    @Override
    public List<Course> findAll() {
        List<Course> courseList = new ArrayList<Course>();
        String selectCourse="select * from course";
//        封装参数
//        Object[] selparams = { 1 };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryAll(selectCourse);
        try {
            while(rest.next())
            {
                int id=rest.getInt("id");
                String cname=rest.getString("cname");
                int credit=rest.getInt("credit");
                String department=rest.getString("department");
                String content=rest.getString("content");
                courseList.add(new Course(id,cname,credit,department,content));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return courseList;
    }
}

DBUtilConfig.java

package com.db;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
//DBUtilConfig读取配置文件
public class DBUtilConfig {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;
    protected Connection conn;

    //静态代码块,在类初次被加载的时候执行且仅会被执行一次
    static {
        try {
            // 在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。
            // 用Properties类来读取.properties文件数据

            // 步骤说明：1.调用类加载器的方法加载资源，返回的字节流
            // DBUtilConfig.class是获得当前对象所属的class对象
            // getClassLoader()是取得该Class对象的类装载器
            // getResourceAsStream(“database.properties”)
            InputStream ins = DBUtilConfig.class.getClassLoader().getResourceAsStream("database.properties");

            // 2.使用Properties类，从.properties属性文件对应的文件输入流中，加载属性列表到Properties类对象，
            Properties props = new Properties();
            props.load(ins);

            // 3.通过getProperty方法用指定的键在此属性列表中搜索属性， 动态获取.properties配置文件中的数据
            driver = props.getProperty("driver");
            url = props.getProperty("url");
            username = props.getProperty("username");
            password = props.getProperty("password");

            // 4、加载驱动
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    // 3.执行更新数据库的预编译SQL命令
    public boolean execUpdate(String sql, Object[] params) {
        try {
            conn = getConnection();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
        try {

            // 1.创建预编译命令对象
            PreparedStatement stmt = conn.prepareStatement(sql);
            // 2.设置为字段匹配参数
            for (int i = 0; params != null && i < params.length; i++) {

                Object param = params[i];
                if (param instanceof Integer) {
                    stmt.setInt(i + 1, Integer.parseInt(param.toString()));
                }
                if (param instanceof Float) {
                    stmt.setFloat(i + 1, Float.parseFloat(param.toString()));
                }
                if (param instanceof Double) {
                    stmt.setDouble(i + 1, Double.parseDouble(param.toString()));
                }
                if (param instanceof String) {
                    stmt.setString(i + 1, param.toString());
                }
            }

            // 3.执行预编译命令
            if (stmt.executeUpdate() > 0) {
                return true;
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 4.执行预编译查询
    public ResultSet execQueryById(String sql, Object[] params) {
        try {
            conn = getConnection();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }

        try {
            // 1.创建预编译命令对象
            PreparedStatement stmt = conn.prepareStatement(sql);
            // 2.设置为字段匹配参数
            for (int i = 0; params != null && i < params.length; i++) {

                Object param = params[i];
                if (param instanceof Integer) {
                    stmt.setInt(i + 1, Integer.parseInt(param.toString()));
                }
                if (param instanceof Float) {
                    stmt.setFloat(i + 1, Float.parseFloat(param.toString()));
                }
                if (param instanceof Double) {
                    stmt.setDouble(i + 1, Double.parseDouble(param.toString()));
                }
                if (param instanceof String) {
                    stmt.setString(i + 1, param.toString());
                }
            }

            // 3.执行预编译命令
            return stmt.executeQuery();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 4.执行查询全部
    public ResultSet execQueryAll(String sql) {
        try {
            conn = getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            Statement stmt = conn.createStatement();
            return stmt.executeQuery(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 5.关闭数据库
    public void DBclose() {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

TestMavenCourseDao.java

import com.dao.CourseDao;
import com.dao.impl.CourseDaoImpl;
import com.entity.Course;
import java.util.List;
public class TestMavenCourseDao {

    public static void main(String[] args) {
        CourseDao courseDao = new CourseDaoImpl();
        System.out.println("———————————————add插入———————————————————");
        courseDao.doAdd(new Course("数据挖掘",3,"软件工程","content"));
        courseDao.doAdd(new Course("自然语言处理",3,"软件工程","content"));

        System.out.println("———————————————findById查找ID———————————————————");
        List<Course> courseListById = courseDao.findById(5);
        for (Course item:courseListById){
            System.out.println(item.toString());
        }
        System.out.println("———————————————当前表格———————————————");
        List<Course> courseListAll1 = courseDao.findAll();
        for (Course item:courseListAll1){
            System.out.println(item.toString());
        }

        courseDao.doDeleteById(5);
        System.out.println("———————————————delete删除———————————————————");
        System.out.println("———————————————当前表格———————————————");
        List<Course> courseListAll2 = courseDao.findAll();
        for (Course item:courseListAll2){
            System.out.println(item.toString());
        }

        courseDao.doUpdate(new Course(9,"更新name",10,"更新depart","更新content"));
        System.out.println("———————————————当前表格———————————————");
        List<Course> courseListAll3 = courseDao.findAll();
        for (Course item:courseListAll3){
            System.out.println(item.toString());
        }
    }
}

4、实验结果