java oop第09章_JDBC02(CRUD操作)

第09章_JDBC02(CRUD操作)

CRUD（CREATE 、 RETIVE 、 UPDATE 、 DELETE）增删改查。

DAO中会提供一些CRUD操作方法，调用者可以通过调用这些方法完成相应操作，本章讨论DAO中需要提供一些什么方法？

一、     Dao常用的方法

1、     增加的方法：

　　通常需要传入实体对象携带所有属性值，作为插入的数据；返回的是受影响的行数（int类型）。

　　如：insertDept(Dept dept)

 

2、     删除的方法：通常需要传入id(指的是数据表中的主键对应的属性)返回的是受影响的行数（int类型）。

　　如：deleteDeptById（int deptNo）

 

3、     修改的方法：

　　通常需要传入实体对象携带所有属性值，id作为修改的条件，id以外的属性作为修改的数据；返回的是受影响的行数（int类型）。

　　如：updateDeptById(Dept dept)

 

4、     查询的方法：

　　1)   查询所有对象的方法：

　　　　不需要传参数，返回的是对象集合

　　　　如selectDeptAll（）

 

　　2)   通过Id查询对象的方法：

　　　　传入id作为查询的条件；返回的是查询到的实体对象，最多只可能查询到一个对象

　　　　如selectDeptBYId（Integer deptNo）

 

　　3)   模糊查询的方法：

　　　　传入查询的关键字，返回对象集合

　　　　如selectDeptLike(String keywords)

 

　　4)   通过外键查询对象集合的方法：

　　　　传入外键值作为查询的条件，返回的是对象集合。

　　　　如：selectDeptByForeignKey(T foreignName)

package com.oop.dao.impl;


import java.sql.*;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;

import com.oop.entity.Dept;

/**
 * 针对Dept实体操作的Dao实现类： 其中会提供一些针对Dept实体对应的数据表tb_dept的CRUD方法。
 */
public class DeptDaoImpl {
    Connection ct = null;
    PreparedStatement pst = null;
    ResultSet rs = null;
    Dept dept = null;
    List<Dept> deptList = new ArrayList<Dept>();
    // 定义一个变量，接收返回的受影响的行数
    Integer var = 0;

    /**
     * 通过Id(deptNo)查询Dept对象的Dao层方法。
     * 
     * @param deptNo：部门编号，作为查询的条件，返回查询到的Dept对象
     * @return
     */

    public Dept selectDeptById(Integer deptNo) {
        try {
            // 1---加载（注册）驱动：指定需要链接的是哪种数据库管理系统
            /*
             * 用Class类直接调用forName(String className)方法
             * 获取Driver类在Class中注册的对象，通过该对象可以利用“反射机制”获取到Driver类中的所有信息。
             */
            Class.forName("com.mysql.jdbc.Driver");

            // 2---获取与数据库链接：需要指定URL（jdbc:mysql://127.0.0.1:3306/数据库名）、user、password。
            // 返回值需要用一个connection接口实现类的对象ct接收
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");

            // 3---通过获取到的与数据库的链接connection向数据库发送带参数（占位符‘？’）的SQL语句，返回PreparedStatement接口实现类的对象pst。
            String sql = "SELECT * FROM tb_dept WHERE deptno = ?";
            pst = ct.prepareStatement(sql);

            // 4、通过PreparedStatement接口实现类的对象pst调用与数据类型相关的各种setter方法对“占位符”赋值，
            // setxxx(int 参数的索引（占位符）所在的位置， T ？占位符的值)。从1开始
            pst.setInt(1, deptNo);

            // 5、再通过PreparedStatement接口实现类的对象调用executeQuery()、executeUpdate()方法执行查询、增删改等操作，
            // 并返回ResultSet接口类型 、int的结果
            rs = pst.executeQuery();

            // 6、对结果进行处理。
            /*
             * next()：将指针向下移动一个单位；判断是否还有下一个记录（对象） rs.getxxx()：与数据类型相关的方法，获取相应类型的值
             * rs.getxxx(int columnIndex)：以字段的索引来获取对应字段的值（从1开始） rs.getxxx(int
             * columnLabel)：以字段的标签（指定列的值）来获取对应字段的值
             */

            while (rs.next()) {
                dept = new Dept();
                // 调用dept的各种setter方法，并将从数据库中得到相应的值作为参数传给dept的setter方法
                dept.setDeptNo(rs.getInt("deptno"));
                dept.setDName(rs.getString("dname"));
                dept.setDName(rs.getString("loc"));
            }
        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        } catch (SQLException e) {

            e.printStackTrace();

        } finally {
            // 7、关闭打开的资源：connection、PreparedStatement、ResultSet。
            // 关闭资源的顺序应采用倒叙的方式来关闭：先开的后关，后开的先关
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 返回值，返回Dept的对象dept
        return dept;
    }

    /**
     * 查询所有Dept对象的Dao层方法。
     *
     * @return：返回查询到的Dept对象集合
     */
    public List<Dept> selectDeptAll() {
        // 创建一个List对象deptlist，因为查询整个数据表中的数据，所以需要一个容器来装
        //List<Dept> deptList = new ArrayList<Dept>();

        try {
            Class.forName("com.mysql.jdbc.Driver");
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");
            String sql = "SELECT * FROM tb_dept";
            pst = ct.prepareStatement(sql);
            rs = pst.executeQuery();

            Dept dept = null;
            while (rs.next()) {
                dept = new Dept();
                dept.setDeptNo(rs.getInt("deptno"));
                dept.setDName(rs.getString("dname"));
                dept.setLoc(rs.getString("loc"));
                // 将dept对象放入deptList集合中，每次循环就放入一个对象。否则就只会出现最后一个对象（记录）
                deptList.add(dept);

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return deptList;
    }

    /**
     * 通过Id(deptNo)增加Dept对象的Dao层方法。
     * 
     * @param dept：Dept对象
     * @return：返回int类型受影响的行数
     */

    public int insertDept(Dept dept) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");
            String sql = "INSERT INTO tb_dept VALUES ('50', 'ACCOUNTING', 'KUN MING')";
            pst = ct.prepareStatement(sql);
            // var接收受影响的行数
            var = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return var;
    }

    /**
     * 通过Id(deptNo)删除Dept对象的Dao层方法。
     * 
     * @param deptNo：通过部门编号删除记录
     * @return
     */
    public int deleteDeptById(int deptNo) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");
            String sql = "DELETE FROM tb_dept WHERE deptno = ?";
            pst = ct.prepareStatement(sql);
            pst.setInt(1, deptNo);
            var = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        return var;

    }
    /**
     * 通过Id(deptNo)修改Dept对象的Dao层方法。
     * @param deptNo
     * @return
     */
    public int updateDeptById(int deptNo) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");
            String sql = "UPDATE tb_dept SET loc = '成都'  where deptno = ?";
            pst = ct.prepareStatement(sql);
            pst.setInt(1, deptNo);
            var = pst.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return var;
    }
    
    /**
     * 通过Id(deptNo)模糊查询Dept对象的Dao层方法。
     * @param deptNo
     * @return
     */
    public List<Dept> selectDeptLike(String keywords) {
        try {
            /*Class.forName("com.mysql.jdbc.Driver");
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");*/
　　　　　　　ct = getConnection();
            String sql = "SELECT * FROM tb_dept WHERE dname LIKE ?";
            pst = ct.prepareStatement(sql);
            pst.setString(1, keywords);
            rs = pst.executeQuery();
            Dept dept = null;
            while (rs.next()) {
                dept = new Dept();
                dept.setDeptNo(rs.getInt("deptno"));
                dept.setDName(rs.getString("dname"));
                dept.setLoc(rs.getString("loc"));
                deptList.add(dept);
                
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
　　　　　　　　closeAll();
            /*try {
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (ct != null) {
                    ct.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }*/
        }
        return deptList;
        
    }
}

二、     封装一个Dao的基础类BaseDao

1. 1.    设计思想：

　　　　BaseDao类定义三个属性（Connection、PreparedStatement、ResultSet类型）和两个方法：获取连接的方法getConnection()、关闭资源的方法closeAll。

1. 2.    如何使用BaseDao帮助我们提高效率：

　　　　1）     常规方式：创建BaseDao的对象，通过对象调用属性和方法。

　　　　2）     静态处理：将属性和方法都定义为静态（static），调用时直接通过“类名.属性名”、“类名.方法名()”，会有线程安全的问题。

　　　　3）     继承方式：在BaseDao中将属性和方法定义为protected访问范围，以后的Dao实现类中只要继承BaseDao就能自动拥有三个属性和两个方法。

 

package com.oop.util;

/*
 * BaseDao类定义三个属性（Connection、PreparedStatement、ResultSet类型）和
 * 两个方法：获取连接的方法getConnection()、关闭资源的方法closeAll。
 */
import java.sql.*;

public class BaseDao {
    // 三个属性
    protected Connection ct = null;
    protected PreparedStatement pst = null;
    protected ResultSet rs = null;

    // 获取连接
    protected Connection getConnection() {
        try {
            // 1---加载（注册）驱动：指定需要链接的是哪种数据库管理系统
            /*
             * 用Class类直接调用forName(String className)方法
             * 获取Driver类在Class中注册的对象，通过该对象可以利用“反射机制”获取到Driver类中的所有信息。
             */
            Class.forName("com.mysql.jdbc.Driver");

            // 2---获取与数据库链接：需要指定URL（jdbc:mysql://127.0.0.1:3306/数据库名）、user、password。
            // 返回值需要用一个connection接口实现类的对象ct接收
            ct = DriverManager.getConnection("jdbc:mysql://127.0.0.1/myschool39", "root", "root");
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return ct;

    }
    
    //关闭资源
    protected void closeAll() {
        try {
            if (rs != null) {
                rs.close();
            }
            if (pst != null) {
                pst.close();
            }
            if (ct != null) {
                ct.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

之前代码中的相关内容就可以通过以上方法进行替换，使代码更加简洁