既然已经学习了javaBean了,就应该了解DAO模式了。也就步入了MVC高级开发的轨道了。关于DAO我们一起来看一下它是个什么东西。看一下面向企业开发的模式的意义。


DAO设计模式简介

   DAO全称是Data Access Object,数据库访问对象,主要的功能就是用于进行数据操作的,在程序的标准开发架构中属于数据层的操作


企业分层架构

  客户层:因为现在都采用了B/S开发架构,所以一般都使用浏览器进行访问。

        显示层:使用JSP/Servlet进行页面效果的显示

        业务层:(Business Object,业务对象):会将多个原子性的DAO操作进行组合,组合成一个完整的业务逻辑。

        数据层(DAO):提供多个原子性的DAO操作,例如:增加、修改、删除等,都属于原子性的操作。

      资源层主要是数据库的操作层,里面可以进行各种的数据存储,但是这些数据存储操作的时候肯定依靠SQL语句,之前也发现了,如果在一个程序中出现了过多的SQL语句直接操作,则jsp页面变得相当复杂,而且也不便于程序的可重用性。

      可以通过一个专门的数据库的操作组件完成,那么这个就是数据层的功能

     业务层是整个项目的核心。现在我们要学的是DAO数据层。


DAO组成

  在整个DAO中实际上都是以接口为操作标准的,即:客户端依靠DAO实现的接口进行操作,而服务端要将接口进行具体的实现。DAO由以下几个部分组成。

   1.  DatabaseConnection:专门负责数据库的打开与关闭操作的类

   2.VO:主要由属性、setter、getter方法组成,VO类中的属性与表中的字段相对应,每一个VO类的对象都表示表中的每一条记录;

   3.DAO:主要定义操作的接口,定义一系列数据库的原子性操作,例如:增加、修改、删除、按ID查询等;

   4.Impl : DAO接口的真实实现类,完成具体的数据库操作,但是不负责数据库的打开和关闭;

  5  Proxy :代理实现类,主要完成数据库的打开和关闭,并且调用真实实现类对象的操作

  6  Factory :工厂类,通过工厂类取得一个DAO的实例化对象


DAO的组成是一个重点,我们以下做的程序就是根据DAO的几种组成来编写的程序。

实例说明DAO设计模式的应用(本程序来自网络,经本人测试确实可用)

一: 数据库(工具:MySQL)

     数据库名字:  51ctotest

    建立一张用户表如下: 表的名字为 emp

Id为编号  ename为用户名字 job为工作 date为工作日期 sal为工资

二 :编写程序(工具:MyEclipse 8.5)

      在做项目之前为了大家能更好的把握全局,要做的javaBean和jsp页面就以如下图片展示:

  1. Emp.java   //定义对应的VO类  
  2. package javaBean01;  
  3. import java.util.Date;  
  4. public class Emp{  
  5.     private int id;   //id编号  
  6.     private String ename;  //名字  
  7.     private String job;  //工作  
  8.     private Date date;   //时间  
  9.     private float sal; //工资  
  10.     public int getId(){  
  11.         return id;  
  12.     }  
  13.     public void setId(int id){  
  14.         this.id=id;  
  15.     }  
  16.     public String getEname(){  
  17.         return ename;  
  18.     }  
  19.     public void setEname(String ename){  
  20.         this.ename=ename;  
  21.     }  
  22.     public String getJob(){  
  23.         return job;  
  24.     }  
  25.     public void setJob(String job){  
  26.         this.job=job;  
  27.     }  
  28.     public Date getDate(){  
  29.         return date;  
  30.     }  
  31.     public void setDate(Date date){  
  32.         this.date=date;  
  33.     }  
  34.     public float getSal(){  
  35.         return sal;  
  36.     }  
  37.     public void setSal(float sal){  
  38.         this.sal=sal;  
  39.     }     
  1. DatebaseConnection.java  //数据库连接类  
  2. package javaBean01;  
  3. import java.sql.*;  
  4. public class DatebaseConnection {  
  5.    private static final String Driver="com.mysql.jdbc.Driver";  
  6.    private static final String URL="jdbc:mysql://localhost:3306/51ctotest";  
  7.    private static final String USER="root";  
  8.    private static final String PWD="425680992";  
  9.    private Connection conn=null;  
  10.    public DatebaseConnection()throws Exception{  //在构造方法中进行数据库连接  
  11.        try{  
  12.            Class.forName(Driver);   //加载驱动类  
  13.            this.conn=DriverManager.getConnection(URL,USER,PWD);  
  14.        }catch(Exception e){  
  15.            throw e;          //直接抛出异常  
  16.        }  
  17.    }  
  18.    public Connection getConnection(){    
  19.        return this.conn;  //取得数据库的连接  
  20.    }  
  21.    public void close()throws Exception{  //数据库关闭  
  22.        if(this.conn!=null){     //避免NullPointerException  
  23.            try{  
  24.                this.conn.close();  //数据库关闭  
  25.            }catch(Exception e){  
  26.                throw e;  
  27.            }  
  28.        }  
  29.    }  
  30. }  
  1. IEmpDAO.java   //定义DAO操作标准  
  2. package javaBean01;  
  3. import java.util.List;  
  4. import javaBean01.Emp;  
  5. public interface IEmpDAO {  
  6.     /**  
  7.      * 数据库增加操作,一般以doXXX的方式命名;  
  8.      *@param emp 要增加的数据对象;  
  9.      *@return 是否增加成功的标记  
  10.      *@throws Exception 有异常交给被调用处处理  
  11.      */  
  12.     public boolean doCreate(Emp emp)throws Exception ;  
  13.      /**  
  14.      * 查询全部的数据,一般以findXX的方式命名;  
  15.      *@param keyWord 查询关键字  
  16.      *@return 返回全部的查询结果,每一个Emp对象表示表的一行记录  
  17.      *@throws Exception 有异常交给被调用处处理  
  18.      */  
  19.     public List<Emp>findAll(String keyWord)throws Exception;  
  20.      /**  
  21.      * 根据用户编号查询用户信心  
  22.      *@param  id 用户编号  
  23.      *@return  用户的vo对象  
  24.      *@throws Exception 有异常交给被调用处处理  
  25.      */  
  26.     public Emp findById(int id)throws Exception;  
  27. }  

     在DAO的操作中定义了doCreate()、findAll()、findById()3个功能。doCreate()方法主要执行数据库的插入操作,在执行插入操作时要传入一个Emp对象,Emp对象中保存了所有增加的用户信息;findAll()方法主要完成数据的查询操作,由于返回的是多条查询结果,所以使用List返回;findById()方法将根据用户的编号返回看一个Emp对象,此Emp对象中将包含一条完整数据信息。
     DAO接口定义完成后需要做具体的实现类,但是在这里DAO的实现类有两种,一种是真实主题实现类,另一种是代理操作类
    真题主题类主要是负责具体的数据库操作,在操作时为了性能及安全将使用PreparedStatement接口完成。

  1. EmpDAOImpl.java    //真实主题实现类  
  2. package javaBean01;  
  3. import java.sql.*;  
  4. import java.util.*;  
  5. import javaBean01.IEmpDAO;  
  6. import javaBean01.Emp;  
  7. public  class EmpDAOImpl implements IEmpDAO {  
  8.      private Connection conn=null;    //数据库连接对象  
  9.      private PreparedStatement pStmt=null; //数据库操作对象  
  10.      public EmpDAOImpl(Connection conn){   //通过构造方法取得数据库连接  
  11.          this.conn=conn;       //取得数据库连接  
  12.      }  
  13.      public boolean doCreate(Emp emp)throws Exception{  
  14.         boolean flag=false;    //定义标志位  
  15.         String sql="insert into emp(id,ename,job,date,sal) values(?,?,?,?,?)";  
  16.         thisthis.pStmt=this.conn.prepareStatement(sql);//实例化PrepareStatement对象  
  17.         this.pStmt.setInt(1, emp.getId()); //设置id  
  18.         this.pStmt.setString(2, emp.getEname());//设置ename  
  19.         this.pStmt.setString(3, emp.getJob());  //设置工作  
  20.         this.pStmt.setDate(4,new java.sql.Date(emp.getDate().getTime()));  
  21.         this.pStmt.setFloat(5, emp.getSal());  
  22.         if(this.pStmt.executeUpdate()>0){  //更新记录的行数大于0  
  23.             flag=true;    //修改标志位  
  24.         }  
  25.         this.pStmt.close();   //关闭PreparedStatement操作  
  26.         return flag;  
  27.      }    
  28.      public List<Emp>findAll(String keyWord)throws Exception{  
  29.          List<Emp> all=new ArrayList<Emp>();//定义集合,接受全部数据  
  30.          String sql="select id,ename,job,date,sal from emp where ename like? or job like?";  
  31.          thisthis.pStmt=this.conn.prepareStatement(sql);//实例化PreparedStatement  
  32.          this.pStmt.setString(1,"%"+keyWord+"%");//设这查询关键字  
  33.          this.pStmt.setString(2,"%"+keyWord+"%");  
  34.          ResultSet rs=this.pStmt.executeQuery();//执行查询操作  
  35.          Emp emp=null;  
  36.          while(rs.next()){  
  37.              emp=new Emp();//实例化新的Emp对象  
  38.              emp.setId(rs.getInt(1));  //设置id属性  
  39.              emp.setEname(rs.getString(2));  
  40.              emp.setJob(rs.getString(3));  
  41.              emp.setDate(rs.getDate(4));  
  42.              emp.setSal(rs.getFloat(5));  
  43.              all.add(emp);  // 向集合中增加对象  
  44.          }  
  45.          this.pStmt.close();  
  46.          return all;   //返回全部结果  
  47.      }  
  48.      public Emp findById(int id)throws Exception{  
  49.          Emp emp=null;  
  50.          String sql="select id,ename,job,date,sal from emp where id=?";  
  51.          thisthis.pStmt=this.conn.prepareStatement(sql);  
  52.          this.pStmt.setInt(1,id);  //设置用户编号  
  53.          ResultSet rs=this.pStmt.executeQuery();  
  54.          if(rs.next()){  
  55.              emp=new Emp();  
  56.              emp.setId(rs.getInt(1));  
  57.              emp.setEname(rs.getString(2));  
  58.              emp.setJob(rs.getString(3));  
  59.              emp.setDate(rs.getDate(4));  
  60.              emp.setSal(rs.getFloat(5));           
  61.          }  
  62.          this.pStmt.close();  
  63.          return emp;  //如果查询不到结果则返回null,默认值为null  
  64.      }  
  65. }  

 在DAO的实现类中定义了Connection和PreparedStatement两个接口对象,并在构造方法中接收外部传递过来的Connection的实例化对象
    在进行数据增加操作时,首先要实例化PreparedStatement接口,然后将Emp对象中的内容依次设置到PreparedStatement操作中,如果最后更新的记录大于0,则表示插入成功,将标志位修改为true.
    在执行查询全部数据时,首先实力哈U了List接口的对象;在定义SQL语句时,将用户姓名和职位定义成了模糊查询的字段,然后分别将查询关键字设置到了PreparedStatement对象中,由于查询出来的是多条记录,所以每一条记录都重新实例化了一个Emp对象,同时会将内容设置到每个Emp对象中,并将这些对象全部加到List集合中
     按编号查询时,如果此编号的用户存在,则实例化Emp对象,并将内容取出赋予Emp对象中的属性,如果没有查询到相应的用户,则返回null
    可以发现,在真实主题的实现类中,根本就没有处理数据库的打开和连接操作,只是通过构造方法取得了数据库的连接,而真正负责打开和关闭的操作将由代理列完成

  1. IEmpDAOProxy.java   //代理主题实现类  
  2. package javaBean01;  
  3. import java.util.*;  
  4. import javaBean01.IEmpDAO;  
  5. import javaBean01.DatebaseConnection;  
  6. import javaBean01.EmpDAOImpl;  
  7. import javaBean01.Emp;  
  8. public class IEmpDAOProxy implements IEmpDAO {  
  9.     private DatebaseConnection dbc=null; //定义数据库连接类  
  10.     private IEmpDAO  dao=null;  //声明DAO对象  
  11.     public IEmpDAOProxy()throws Exception{ //在构造方法中实例化连接,同时实例化dao对象  
  12.         this.dbc=new DatebaseConnection();  
  13.         this.dao=new EmpDAOImpl(this.dbc.getConnection());//实例化真实主题类  
  14.     }  
  15.     public boolean doCreate(Emp emp)throws Exception{  
  16.         boolean flag=false; //定义标志位  
  17.         try{  
  18.             if(this.dao.findById(emp.getId())==null){//如果要插入的用户编号不存在  
  19.                 flag=this.dao.doCreate(emp);//调用真实主题操作  
  20.             }  
  21.         }catch(Exception e){  
  22.             throw e;  
  23.         }finally{  
  24.             this.dbc.close();  
  25.         }  
  26.         return flag;  
  27.     }  
  28.     public List<Emp>findAll(String keyWord)throws Exception{  
  29.         List<Emp>all=null;  //定义返回的集合  
  30.         try{  
  31.             all=this.dao.findAll(keyWord);//调用真实主题  
  32.         }catch(Exception e){  
  33.             throw e;  
  34.         }finally{  
  35.             this.dbc.close();  
  36.         }  
  37.         return all;       
  38.     }  
  39.     public Emp findById(int id)throws Exception{  
  40.         Emp emp=null;  
  41.         try{  
  42.             emp=this.dao.findById(id);  
  43.         }catch(Exception e){  
  44.             throw e;  
  45.         }finally{  
  46.             this.dbc.close();  
  47.         }  
  48.         return emp;  
  49.     }  
  50. }  

 
    可以发现,在代理类的构造方法中实例化了数据库连接类的对象以及真实主题实现类,而在代理中的各个方法也只是调用了真实主题实现类中的相应的方法。
   DAO的真实实现类和代理实现类编写完成后就需要编写工厂类,以降低代码间的耦合度

  1. DAOFactory.java  //工厂类  
  2. package javaBean01;  
  3. import javaBean01.IEmpDAOProxy;  
  4. import javaBean01.IEmpDAO;  
  5. public class DAOFactory {  
  6.     public static IEmpDAO getIEmpDAOInstance()throws Exception {//取得DAO接口实例  
  7.         return new IEmpDAOProxy();//取得代理类的实现类  
  8.     }  
  9. }  

 编写后javaBean后就开始编写jsp,用来调用DAO

  1. Emp_insert.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <body> 
  8. <form action="emp_insert_do.jsp" method="post"> 
  9.     编号:<input type="text" name="id"><br> 
  10.   姓名:<input type="text" name="ename"><br> 
  11.  职位:<input type="text" name="job"><br> 
  12.  日期:<input type="text" name="date"><br> 
  13.  工资:   <input type="text" name="sal"><br> 
  14.  <input type="submit"  value="注册"> 
  15.  <input type="reset" value="重置"> 
  16.  </form> 
  17. </body> 
  18. </html> 
  1. Emp_insert_do.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <%@ page import="javaBean01.*" %> 
  4. <%@ page import="java.text.*" %> 
  5. <html> 
  6. <head> 
  7. <title>WEB开发项目</title> 
  8. </head> 
  9. <%  
  10.     request.setCharacterEncoding("utf-8");  
  11. %> 
  12. <body> 
  13. <%   
  14.     Emp emp=new Emp();  
  15.     emp.setId(Integer.parseInt(request.getParameter("id")));  
  16.     emp.setEname(request.getParameter("ename"));  
  17.     emp.setJob(request.getParameter("job"));  
  18.     emp.setDate(new SimpleDateFormat("yyyy-MM-dd").parse(request.getParameter("date")));  
  19.     emp.setSal(Float.parseFloat(request.getParameter("sal")));  
  20.     try{  
  21.         if(DAOFactory.getIEmpDAOInstance().doCreate(emp)){  
  22.  %> 
  23.      <h3>用户信息添加成功!</h3> 
  24.  <%           
  25.         }else{  
  26.  %> 
  27.      <h3>用户信息添加失败!</h3> 
  28.  <%           
  29.         }     
  30.     }catch(Exception e){  
  31.         e.printStackTrace();  
  32.     }   
  33. %> 
  34. </body> 
  35. </html> 
  1. Emp_list.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <%@ page import="javaBean01.*" %> 
  4. <%@ page import="java.util.*" %> 
  5. <html> 
  6. <head> 
  7. <title>WEB开发项目</title> 
  8. </head> 
  9. <%  
  10.    request.setCharacterEncoding("utf-8");  
  11. %> 
  12. <body> 
  13. <%   
  14.   try{  
  15.       //String keyWord=new String(request.getParameter("kw").getBytes("ISO-8859-1"));  
  16.         String keyWord=request.getParameter("kw");  
  17.       if(keyWord==null){ //判断是否有传递的参数  
  18.           keyWord ="";  
  19.       }  
  20.       List<Emp>all=DAOFactory.getIEmpDAOInstance().findAll(keyWord);//取得全部记录  
  21.       Iterator<Emp>iter=all.iterator();//实例化iterator对象  
  22. %> 
  23. <center> 
  24. <form action="emp_list.jsp" method="post"> 
  25.     请输入查询的关键字<input type="text" name="kw"> 
  26.         <input type="submit" value="查询"> 
  27. </form> 
  28. <table border="1" width="80%"> 
  29.     <tr> 
  30.          <td>编号</td> 
  31.          <td>姓名</td> 
  32.          <td>工作</td> 
  33.          <td>工资</td> 
  34.          <td>日期</td> 
  35.     </tr> 
  36. <%  
  37.    while(iter.hasNext()){  
  38.        Emp emp=iter.next();//取得每一个Emp对象  
  39. %> 
  40.    <tr> 
  41.     <td><%=emp.getId() %></td> 
  42.      <td><%=emp.getEname() %></td> 
  43.      <td><%=emp.getJob() %></td> 
  44.      <td><%=emp.getSal() %></td> 
  45.      <td><%=emp.getDate() %></td> 
  46.     </tr> 
  47. <%       
  48.    }  
  49. %>      
  50. </table> 
  51. </center> 
  52. <%      
  53.   }catch(Exception e){  
  54.       e.printStackTrace();  
  55.   }  
  56. %> 
  57. </body> 
  58. </html> 

 运行结果:

注意: 到此为止学完javaBean后,以上代码应该也必须得看懂了,如果以上代码研究起来很吃力的话,那必须好好学习了,不然之后的servlet、MVC以及SSH等等的模式将会很困难,当然java基础也是很重要的,对于java学了个半吊子的同学,也必须学完java,因为WEB开发是在java语言的基础上。