新手写数据库mysql，DAO模式

2000阅读　0评论2016-08-10　xiaqian369
分类：LINUX

昨天写了一篇博客，新手写数据库mysql一个JDBC的小程序。今天继续数据库之旅......
先看昨天的数据库状态, 未操作数据库之前, 状态如下:
mysql> select * from student;
+-----------+-----------+------+------+-------+
| Sno       | Sname     | Ssex | sage | Sdept |
+-----------+-----------+------+------+-------+
| 200215121 | 李勇      | 男   |   18 | CS    |
| 200215122 | 刘晨      | 女   |   19 | CS    |
| 200215123 | 王敏      | 女   |   18 | MA    |
| 200215125 | 张立      | 男   |   19 | IS    |
| 200215126 | 张成民    | 男   |   18 | CS    |
| 200215128 | 陈冬      | 男   |   18 | IS    |
+-----------+-----------+------+------+-------+
6 rows in set (0.00 sec)

这是昨天写的直接操作数据库的代码:

点击(此处)折叠或打开

  1. package jdbc_test;

  3. import java.sql.*;

  5. public class jdbc_test {

  7.     public static void main(String[] args) {
  8.         System.out.println("haha");
  9.         try {
  10.             Class.forName("com.mysql.jdbc.Driver");
  11.             Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/s_t", "root", "mikemike");
  12.             Statement stmt = conn.createStatement();
  13.             //ResultSet rs = stmt.executeQuery("select * from student where ssex='男'");
  14.             int rs = stmt.executeUpdate("insert into student values('200210008','李莉','女',18,'CS');");            
  15.             stmt.close();
  16.             conn.close();
  17.         } catch (SQLException e) {
  18.             System.out.println(e.getMessage());
  19.         } catch (ClassNotFoundException e) {
  20.             System.out.println("haha2");
  21.             e.printStackTrace();
  22.         }
  23.     }

  25. }

执行完了之后, 数据库状态如下:
mysql> select * from student;
+-----------+-----------+------+------+-------+
| Sno       | Sname     | Ssex | sage | Sdept |
+-----------+-----------+------+------+-------+
| 200210008 | 李莉      | 女   |   18 | CS    |
| 200215121 | 李勇      | 男   |   18 | CS    |
| 200215122 | 刘晨      | 女   |   19 | CS    |
| 200215123 | 王敏      | 女   |   18 | MA    |
| 200215125 | 张立      | 男   |   19 | IS    |
| 200215126 | 张成民    | 男   |   18 | CS    |
| 200215128 | 陈冬      | 男   |   18 | IS    |
+-----------+-----------+------+------+-------+
7 rows in set (0.00 sec)

   
这里我们来看看代码中存在多少问题:
    1) 添加删除不便, 如果我想要继续添加数据到数据库中, 就必须不断重复写如下sql语句, 这本身就是一个很low, 而且也不太现实的问题. 因为实际上我们的应用程序, 不可能每次因为要添加一个学生, 就不断的重新编译代码. 
       stmt.executeUpdate("insert into student values('******','*****','**',**,'**');");
    2) 有可能会有脏数据, 甚至是sql语句的恶意代码, 如下, 假设应用程序中, 有人恶意传下来了这么一行sql的语句, 会导致什么情况:
        stmt.execute("select * from student where sname = '李莉' and sno = '+varsno+'";);//其中+varsno+是一个变量
        好了, 那现在, 这个坏人把+varson+这个变量赋值为中括号里面的内容[' or '1' = '1], 这句话会变成下面这样,
           stmt.execute("select * from student where sname = '李莉' and sno = '' or  '1' = '1' ";);  //这就导致sno这个选择条件根本没用了.
        更有甚者, 把+varson+这个变量赋值为[';drop table student;] //那我们的sql语句在执行完之后, 直接把表都给删了.
        针对第2个问题, 我们在代码中, 采用Preparedstatment来代替Statement的实现, 具体用Preparedstatment代替Statement的好处自行百度好了.
        对第1个问题, 我们来用DAO模式来实现我们的数据库连接.
        
        先上代码:

点击(此处)折叠或打开

  1. package jdbc_test;

  3. import java.sql.*;

  5. class student {         //这就是一个POJO, POJO实际上, 就是一个简单的只具有setter和getter方法的类.
  6.     private String sno;
  7.     private String sname;
  8.     private String ssex;
  9.     private int sage;
  10.     private String sdept;

  12.     public String getSno() {
  13.         return sno;
  14.     }

  16.     public void setSno(String sno) {
  17.         this.sno = sno;
  18.     }

  20.     public String getSname() {
  21.         return sname;
  22.     }

  24.     public void setSname(String sname) {
  25.         this.sname = sname;
  26.     }

  28.     public String getSsex() {
  29.         return ssex;
  30.     }

  32.     public void setSsex(String ssex) {
  33.         this.ssex = ssex;
  34.     }

  36.     public int getSage() {
  37.         return sage;
  38.     }

  40.     public void setSage(int sage) {
  41.         this.sage = sage;
  42.     }

  44.     public String getSdept() {
  45.         return sdept;
  46.     }

  48.     public void setSdept(String sdept) {
  49.         this.sdept = sdept;
  50.     }

  52. }

  54. interface studentDAO {
  55.     public int addStudent(student s);

  57.     public int delStudent(student s);

  59.     public int updateStudent(student s);

  61.     public int queryStudent();
  62. }

  64. class studentDAOimpl implements studentDAO {
  65.     
  66.     Connection conn = null;
  67.     studentDAOimpl(Connection conn)
  68.     {
  69.         this.conn = conn;
  70.     }
  71.     
  72.     @Override
  73.     public int addStudent(student s) {
  74.         String addsql = "insert into student values(?,?,?,?,?);";
  75.         try {
  76.             PreparedStatement stmt = conn.prepareStatement(addsql);
  77.             stmt.setString(1, s.getSno());
  78.             stmt.setString(2, s.getSname());
  79.             stmt.setString(3, s.getSsex());
  80.             stmt.setInt(4, s.getSage());
  81.             stmt.setString(5, s.getSdept());

  83.             stmt.executeUpdate();
  84.             stmt.close(); /*
  85.                              * 这里的close,我开始没加上.
  86.                              * 后来知道PreparedStatement申请的资源也是需要释放的.
  87.                              * 并且,PreparedStatement是Statement的 子接口,所以,
  88.                              * 我们直接在帮助文件里是看不到close方法的, 但事实上它继承了Statement的方法.
  89.                              * 这里也有个java的基础知识, 接口中定义的方法一般都是公共静态方法
  90.                              */

  92.         } catch (SQLException e) {
  93.             System.out.println(e.getMessage());
  94.             e.printStackTrace();
  95.         }
  96.         return 0;
  97.     }

  99.     @Override
  100.     public int delStudent(student s) {
  101.         String delsql = "delete from student where sno=?;"; //实际上这里的删除语句,只实现了通过sno来删除数据库元组的功能,没有通过其它的来删除
  102.         try {
  103.             PreparedStatement stmt = conn.prepareStatement(delsql);
  104.             stmt.setString(1, s.getSno());
  105.             stmt.executeLargeUpdate();
  106.             
  107.             stmt.close(); //同add, 一样需要释放资源
  108.         } catch (SQLException e) {
  109.             System.out.println(e.getMessage());
  110.             e.printStackTrace();
  111.         }
  112.         return 0;
  113.     }

  115.     @Override
  116.     public int updateStudent(student s) {
  117.         // TODO Auto-generated method stub
  118.         return 0;
  119.     }

  121.     @Override
  122.     public int queryStudent() {
  123.         // TODO Auto-generated method stub
  124.         return 0;
  125.     }

  127. }

  129. public class jdbc_DAO {

  131.     public static void main(String[] args) {
  132.         Connection conn = null;
  133.         try {
  134.             Class.forName("com.mysql.jdbc.Driver");
  135.         } catch (ClassNotFoundException e) {
  136.             System.out.println(e.getMessage());
  137.             e.printStackTrace();
  138.         }
  139.         try {
  140.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/s_t", "root", "12345678");
  141.         } catch (SQLException e) {
  142.             System.out.println(e.getMessage());
  143.             e.printStackTrace();
  144.         }
  145.         student s1 = new student();
  146.         s1.setSno("200210002");
  147.         s1.setSname("李莉");
  148.         s1.setSdept("CS");
  149.         s1.setSage(20);
  150.         s1.setSsex("女");
  151.         studentDAO daoimpl = new studentDAOimpl(conn);
  152.         daoimpl.addStudent(s1);
  153.         //daoimpl.delStudent(s1);    
  154.         
  155.         try {
  156.             conn.close(); //这里的资源一定也要记得, 需要释放
  157.         } catch (SQLException e) {
  158.             // TODO Auto-generated catch block
  159.             e.printStackTrace();
  160.         }
  161.         
  162.     }

  164. }
    这样看起来, 代码是多了点, 但是看起来清爽多了.
    解析:  DAO: data access object, 用于对数据库访问的一个操作集合的对象.
    1. 事实上, 对于DAO模式, 每一张表, 都可以定义一个自己的所谓domain, 实际上我理解的就是对每一个表, 都定义一个POJO, 也就是只有setter和getter函数的类, 用以作为用户对数据库表的元组赋值. 每一个属性都有一个setter和getter函数. 上一例中就是通过class student来实现的.
    2. 对于每一个表的增删改查操作, 首先定义一个对应的DAO接口, 如本例中, student表就对应一个interface studentDAO, 而这个接口有下面的具体实现, class studentDAOimpl implements studentDAO ,所以事实上真正的增删改查操作, 都是在这个实现了接口的类class studentDAOimpl 中来完成的. 
    这样有什么好处? 增删改查的这些具体的操作的方法, 如果以后一旦发生了变化, 我们只需要修改对应的操作方法就可以了. main函数中对增删改查的调用本身并不需要做任何修改. 而再看本文最开始的那个例子, 假设某一天, 某个数据库的增加或删除语句发生了点变化, 那么我们的程序代码中, 凡是写了 stmt.execute 语句的地方, 都需要修改, 那可真是太费劲了.

上述代码的验证过程略过了, 是OK的.

我感觉, 这个DAO模式, 其实跟设计模式中的策略模式很有点像, 增删改查其实就是对数据student的各种算法策略, 把数据和策略分开来的一种思想.       
 



上一篇：新手写数据库mysql一个JDBC的小程序
下一篇：java代理模式与反射机制(整理)