JDBC 2：操作Dept表

[b][size=large]三、操作Dept表。[/size][/b]

[size=large][b]1.使用实体类来封装Dept表。[/b][/size]

[size=medium]实体类（pojo类）：其作用是用来封装表中的一条数据。（或：用来封装类的属性和方法）。[/size]

[size=medium]表中的一条记录：对应于一个实体。[/size]

[size=medium]写实体类：必须写三部分：属性、默认构造方法（无参构造方法）、setter和getter方法。其他方法：用到才写，不用就不写。[/size]

 package com.lxd.pojo;  

 import java.io.Serializable;  

 /** 
  * 实体类(pojo类) 
  *  
  * @author XiangdongLee 
  *  
  */  
 public class Dept implements Serializable {  
     private static final long serialVersionUID = 1L;  
     private Integer deptno;  
     private String dname;  
     private String loc;  

     public Dept() {  
         super();  
     }  

     public Integer getDeptno() {  
         return deptno;  
     }  

     public void setDeptno(Integer deptno) {  
         this.deptno = deptno;  
     }  

     public String getDname() {  
         return dname;  
     }  

     public void setDname(String dname) {  
         this.dname = dname;  
     }  

     public String getLoc() {  
        return loc;  
     }  

     public void setLoc(String loc) {  
        this.loc = loc;  
     }  

 }

[size=medium][b]代码说明：[/b][/size]

[size=medium]（1）创建该类的时候，实现Serializable接口。之后，在该行左侧标黄的部位双击，选择“Add default serial version ID”，即可出现第12行代码。[/size]


[b][size=large]2.创建数据库工具类，来获得数据库连接与关闭数据库连接。[/size][/b]

 package com.lxd.dao;  

 import java.sql.Connection;  
 import java.sql.DriverManager;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  

 /** 
  * DBUtil:数据库工具类 
  *  
  * @author XiangdongLee 
  *  
  */  
 public class DBUtil {  
     /** 
      * 获得数据库连接 
      *  
      * @return 
      */  
     public static Connection getConnection() {  
         Connection conn = null;  
         String driverName = "oracle.jdbc.OracleDriver";  
         String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";  
         String username = "scott";  
         String password = "tiger";  

         try {  
             Class.forName(driverName);  
             conn = DriverManager.getConnection(url, username, password);  
         } catch (ClassNotFoundException e) {  
             System.out.println("加载数据库驱动出错...");  
            e.printStackTrace();  
         } catch (SQLException e) {  
             System.out.println("获得数据库连接出错...");  
             e.printStackTrace();  
         }  
         return conn;  
     }  

     /** 
      * 关闭数据库连接 
      *  
      * @param conn 
      * @param ps 
      * @param rs 
      */  
     public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {  
         // 关闭原则:先开后关,后开先关  
         if (rs != null) {  
             try {  
                 rs.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
         }  

         if (ps != null) {  
             try {  
                 ps.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
         }  

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

     public static void main(String[] args) {  
         System.out.println(getConnection());  
     }  
 }

[size=medium][b]代码说明：[/b][/size]

[size=medium]（1）写getConnection()方法时，先写如下结构：[/size]

 public static Connection getConnection() {  
         Connection conn = null;  

         return conn;  
     }

[size=medium]因为方法需要返回Connection类型的参数，因此先写出此结构，然后再在内部开始填写代码。[/size]

[size=medium]（2）第23行代码：取得数据库驱动程序。[/size]

[size=medium]写驱动的时候，先在外面点出oracle.jdbc.OracleDriver，然后剪切入引号中。[/size]

[size=medium]另外，11g中的数据库驱动程序为：oracle.jdbc.OracleDriver，10g的数据库驱动程序为：oracle.jdbc.driver.OracleDriver。11g也可以通过10g的方式取得，这是为了向下兼容，但是性能不太好。[/size]

[size=medium]（3）第24行代码：url：连接数据库的路径（协议）。[/size]

[size=medium]127.0.0.1：该部位填写安装Oracle数据库的计算机的IP地址。127.0.0.1是特殊的地址，是环回地址。（服务器和客户端在同一台机器上，转一圈是客户端，再转一圈又是服务器。）该处，也可以用 localhost，但是不建议用。因为实际开发中，服务器和客户端是不在一台机器上的。[/size]

[size=medium]1521：Oracle端口号。每个应用程序都有一个唯一的端口号。通过该端口号可以找到是哪个应用程序。Oracle的端口号默认是1521，如果为了防止黑客攻击，在安装数据库的时候，应该改端口号。[/size]

[size=medium]orcl：Oracle实例名。通过实例，可以找到数据库中的表分区。[/size]

[size=medium]（4）第25、26行：连接数据库的用户名和密码。注意必须是普通用户。[/size]

[size=medium]（5）第29行：加载数据库驱动。[/size]

[size=medium]第30行：通过驱动管理器类，获得数据库连接。[/size]

[size=medium]（6）第48-73行：关闭数据库。[/size]

 public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {  
         // 关闭原则:先开后关,后开先关  
         try {  
             rs.close();  
             ps.close();  
             conn.close();  
         } catch (SQLException e) {  
             e.printStackTrace();  
         }  
     }

[size=medium]注意：不能用此写法来关闭。如果先关的，在关闭的时候出了错，后面的也会受影响。[/size]

[size=medium]（7）第75-77行：测试类。 [/size]


[b][size=large]3. 创建dao类，来封装Dept表的所有操作（增删改查CRUD）。[/size][/b]

 package com.lxd.dao;  

 import java.sql.Connection;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.util.ArrayList;  
 import java.util.List;  
 import com.newer.pojo.Dept;  

 /** 
  * 封装表 DEPT 的所有操作(增删改查 CRUD CreateReadUpdateDelete) 
  *  
  * @author XiangdongLee 
  *  
  */  
 public class DeptDao {  
    // 成员变量：下面的方法都要用到它们3个，因此提在最前面。  
     private Connection conn;  
     private PreparedStatement ps;  
     private ResultSet rs;  

     /** 
      * 查询所有数据 
      *  
      * @return 
      */  
     // 查询表：访问的是结果集（多条记录）。——因此要用集合。——用List：先放进去的先出来；允许重复值。 
     public List<Dept> find() {  
         List<Dept> depts = new ArrayList<Dept>();  

        try {  
             // 1.加载数据库驱动类  
             // 2.获得数据库连接  
             conn = DBUtil.getConnection();  
             // 查询所有记录  
             // String sql = "select * from dept ";  

             // 根据条件查询记录  
             String sql = "select * from dept ";  
             sql += " where deptno<=30";  
             // 3.通过操作句柄执行SQL语句  
             ps = conn.prepareStatement(sql);  
             // 4.获得结果集  
             rs = ps.executeQuery();  
             // 5.处理结果集  
             while (rs.next()) {  
                 Dept dept = new Dept();  
                 // 根据字段名获得字段值(列的值)  
                 dept.setDeptno(rs.getInt("deptno"));  
                 dept.setDname(rs.getString("dname"));  
                 // 根据字段索引获得字段值(列的值)。下标从 1 开始。  
                 dept.setLoc(rs.getString(3));  
                 // 把每一条数据添加到集合中  
                 depts.add(dept);  
             }  
         } catch (SQLException e) {  
             e.printStackTrace();  
         } finally {  
             // 6.关闭结果集  
             // 7.关闭操作句柄Statement  
             // 8.关闭连接  
             DBUtil.close(conn, ps, rs);  
         }  

         return depts;  
     }  

     /** 
      * 新增数据 
      *  
      * @param dept 
      * @return 
      */  
     public int add(Dept dept) {  
         int count = 0;  
         try {  
             conn = DBUtil.getConnection();  

             // ? 使用占位符传参 (下标从 1 开始)  
             String sql = "insert into dept(deptno,dname,loc) ";  
             sql += " values(?,?,?)";  

             ps = conn.prepareStatement(sql);  
             // 设置 占位符 的参数  
             ps.setInt(1, dept.getDeptno());  
             ps.setString(2, dept.getDname());  
             ps.setString(3, dept.getLoc());  

             // 执行新增语句  
             count = ps.executeUpdate();  
         } catch (SQLException e) {  
             e.printStackTrace();  
         } finally {  
             DBUtil.close(conn, ps, rs);  
         }  

         return count;  
     }  

     /** 
      * 修改数据 
      *  
      * @param dept 
      * @return 
      */  
	  public int modify(Dept dept) {  
         int count = 0;  
         try {  
             conn = DBUtil.getConnection();  

             String sql = "update dept set dname=? , loc=? ";  
             sql += " where deptno=?";  

             ps = conn.prepareStatement(sql);  
             ps.setString(1, dept.getDname());  
             ps.setString(2, dept.getLoc());  
             ps.setInt(3, dept.getDeptno());  

             // 执行更新语句  
             count = ps.executeUpdate();  
         } catch (SQLException e) {  
             e.printStackTrace();  
         } finally {  
             DBUtil.close(conn, ps, rs);  
         }  

         return count;  
     }  

     /** 
     * 删除数据 
      *  
      * @param deptno 
      * @return 
      */  
     public int remove(Integer deptno) {  
        int count = 0;  
         try {  
            conn = DBUtil.getConnection();  

             String sql = "delete dept where deptno=?";  

             ps = conn.prepareStatement(sql);  
             ps.setInt(1, deptno);  

             // 执行更新语句  
             count = ps.executeUpdate();  
         } catch (SQLException e) {  
             e.printStackTrace();  
         } finally {  
             DBUtil.close(conn, ps, rs);  
         }  

         return count;  
     }  
 }

[size=medium][b]代码说明：[/b][/size]

[size=medium]（1）dao：Data Access Object （数据访问对象）。[/size]

[size=medium]（2）JDBC 访问数据库的步骤:（八部曲、天龙八部）[/size]

[size=medium]1. 加载数据库驱动类[/size]
[size=medium]2. 获得数据库连接（打开水厂阀门）[/size]
[size=medium]3. 获得数据库操作句柄（打开小区阀门）[/size]
[size=medium]4. 获得结果集（打开家里阀门）[/size]
[size=medium]5. 处理结果集（做事）[/size]
[size=medium]6. 关闭结果集（关闭家里阀门）[/size]
[size=medium]7. 关闭操作句柄（关闭小区阀门）[/size]
[size=medium]8. 关闭数据库连接（关闭水厂阀门）[/size]

[size=medium]（3）第40行，在写完sql语句后，后面记得空一格。第41行，在开始写sql语句的时候，引号内记得先空一格再开始写。这样做是为了防止两个句子连接的时候出错。[/size]

[size=large]4.测试dao类，对Dept表进行操作。[/size]

 package com.lxd.test;  

 import java.util.List;  
 import org.junit.Before;  
 import org.junit.Test;  
 import com.newer.dao.DeptDao;  
 import com.newer.pojo.Dept;  

 /** 
  *  
  * @author XiangdongLee 
  *  
  */  
 public class DeptDaoTest {  
     private DeptDao dao;  

     // @Before注解：在所有@Test测试方法之前首先运行init()方法。作用：初始化资源  
     @Before  
     public void init() {  
         // System.out.println("init");  
         dao = new DeptDao();  
     }  

     @Test  
     public void find() {  
         for (Dept dept : dao.find()) {  
             System.out.println(dept.getDeptno() + " " + dept.getDname() + " "  
                     + dept.getLoc());  
         }  
     }  

     // 也可以拆开写成如下形式：  
     // List<Dept> depts = dao.find();  
     // for (Dept dept : depts) {  
     // System.out.println(dept.getDeptno() + " " + dept.getDname() + " "  
     // + dept.getLoc());  
     // }  
     // }  

     @Test  
     public void add() {  
         Dept dept = new Dept();  
         dept.setDeptno(52);  
         dept.setDname("IT");  
         dept.setLoc("cs");  

         int count = dao.add(dept);  
         if (count > 0) {  
             System.out.println("新增成功.");  
         } else {  
             System.err.println("新增失败.");  
         }  
     }  

     @Test  
     public void modify() {  
         Dept dept = new Dept();  
         dept.setDeptno(50); // 该部门必须已存在  
         dept.setDname("Java");  
         dept.setLoc("sh");  

         int count = dao.modify(dept);  
         if (count > 0) {  
             System.out.println("修改成功.");  
         } else {  
             System.err.println("修改失败.");  
         }  
     }  

     @Test  
     public void remove() {  
         Dept dept = new Dept();  
         dept.setDeptno(50); // 该部门必须已存在  
         int count = dao.remove(dept.getDeptno());  

         if (count > 0) {  
             System.out.println("删除成功.");  
         } else {  
             System.err.println("删除失败.");  
         }  
     }  

 }