21 工作室 - hiberate

hibernate 中出现 table is not mapped 问题

lianxiangpanjin@163.com(admin) — Tue,07 Oct 2008 16:25:39 +0800

HQL语句原来是这样写的：
      String hql="from person as p where p.id=? and p.password=?";
      后来上网查找原因，发现原来person第一个字母应大字，也就是说表名应该是ORM映射的类名。
      改成这样就可以了：
      String hql="from Person as p where p.id=? and p.password=?";

一般与类名一致

  原来的是这样写的：

"delete from table where username = :user"

       后来发现原因在于要写成这样：

"delete from User where username = :name"

只要将表明换成ORM映射的类名就可以了

' 引用自http://blog.5ego.net/article.asp?id=35

Hibernate3中的更新与删除

lianxiangpanjin@163.com(admin) — Tue,07 Oct 2008 16:24:05 +0800

    Update 和 Delete语句的语法为：
( Update | Delete ) FROM ? ClassName (Where Where_CONDITIONS) ?。有几点说明：

1.在FROM子句（from-clause）中，FROM关键字是可选的

2.在FROM子句（from-clause）中只能有一个类名，并且它不能有别名

3.不能在大批量HQL语句中使用连接（显式或隐式都不行）。不过在Where子句中可以使用子查询。

4.整个Where子句是可选的。

举个例子，使用Query.executeUpdate()方法执行一个HQL Update语句：

Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();

        String hqlUpdate = "update Customer set name = :newName where name = :oldName";
        int updatedEntities = s.createQuery( hqlUpdate )
                            .setString( "newName", newName )
                            .setString( "oldName", oldName )
                            .executeUpdate();
        tx.commit();
        session.close();
执行一个HQL Delete，同样使用 Query.executeUpdate() 方法（此方法是为那些熟悉JDBC PreparedStatement.executeUpdate() 的人们而设定的）

Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();

        String hqlDelete = "delete Customer where name = :oldName";
        int deletedEntities = s.createQuery( hqlDelete )
                            .setString( "oldName", oldName )
                            .executeUpdate();
        tx.commit();
        session.close();
由Query.executeUpdate()方法返回的整型值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条SQL语句）影响了的“行”数有关，也可能没有。一个大批量HQL操作可能导致多条实际的SQL语句被执行，举个例子，对joined-subclass映射方式的类进行的此类操作。这个返回值代表了实际被语句影响了的记录数量。在那个joined-subclass的例子中，对一个子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响与之有继承关系的joined-subclass映射方式的子类的表。

注意，上述大批量HQL操作的少数限制会在新版本中得到改进；进一步详细信息请参考JIRA里的路线图(roadmap)。

'引用自http://hi.baidu.com/webidea/blog/item/c07f60c794be4ddad000605e.html

hibernate的hibernate.cfg.xml配置（ms sqlserver）

lianxiangpanjin@163.com(admin) — Mon,17 Sep 2007 23:15:40 +0800

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

      org.hibernate.dialect.SQLServerDialect
      com.microsoft.jdbc.sqlserver.SQLServerDriver
      jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=myhibernate

      sa
      sa

关于hibernate的配置文件hibernate.cfg.xml

lianxiangpanjin@163.com(admin) — Mon,17 Sep 2007 23:08:58 +0800

org.hibernate.dialect.MySQLDialect一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL
com.mysql.jdbc.Driverjdbc驱动类
jdbc:mysql://localhost/studentjdbc URL
root数据库用户
数据库用户密码
10连接池容量上限数目
true输出所有SQL语句到控制台
50非零值，指定JDBC抓取数量的大小
20非零值，允许Hibernate使用JDBC2的批量更新
允许Hibernate使用JDBC2的可滚动结果集. 只有在使用用户提供的JDBC连接时，这个选项才是必要的, 否则Hibernate会使用连接的元数据

映射定义文件
映射定义文件
映射定义文件
映射定义文件

hibernate.properties

lianxiangpanjin@163.com(admin) — Mon,17 Sep 2007 23:07:16 +0800

##---------- this is the connection and hibernate.dialect fo mysql --------------------------------
hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=org.gjt.mm.mysql.Driver
hibernate.connection.url=jdbc:mysql://ip:3306/databasename?lastUpdateCount=true;useUnicode=true;characterEncoding=gb2312
hibernate.connection.username=root
hibernate.connection.password=

##---------- this is the connection and hibernate.dialect fo mssqlserver --------------------------------
#hibernate.dialect=net.sf.hibernate.dialect.SQLServerDialect
#hibernate.connection.driver_class=net.sourceforge.jtds.jdbc.Driver
#hibernate.connection.url=jdbc:jtds:sqlserver://IP:1433;DatabaseName=databasename;charset=cp936
#hibernate.connection.username=sa
#hibernate.connection.password=sa

##---------- this is the connection and hibernate.dialect fo ibmdb2 --------------------------------
#hibernate.dialect=net.sf.hibernate.dialect.DB2Dialect
#hibernate.connection.driver_class=COM.ibm.db2.jdbc.app.DB2Driver
#hibernate.connection.url=jdbc:db2:databasename
#hibernate.connection.username=sa
#hibernate.connection.password=sa

##---------- this is the connection and hibernate.dialect fo oracle --------------------------------
#hibernate.dialect=net.sf.hibernate.dialect.Oracle9Dialect
#hibernate.dialect=net.sf.hibernate.dialect.OracleDialect
#hibernate.connection.driver_class=oracle.jdbc.driver.OracleDriver
#hibernate.connection.url=jdbc:oracle:thin:@localhost:1521:databasename
#hibernate.connection.username=ora
#hibernate.connection.password=ora

##---------- after is hibernate config

hibernate.show_sql=true

hibernate.query.substitutions=true 1, false 0, yes 'Y', no 'N'
hibernate.jdbc.use_streams_for_binary=true
hibernate.cache.region_prefix=hibernate.test
hibernate.cache.use_query_cache=true
hibernate.cache.provider_class=net.sf.ehcache.hibernate.Provider

hibernate.connection.pool.size=20
hibernate.jdbc.batch_size=25
hibernate.statement_cache.size = 6
jdbc.fetch_size=50
jdbc.use_scrollable_resultset=false
jdbc.use_scrollable_resultset=false
hibernate.jdbc.use_streams_for_binary=true
hibernate.max_fetch_depth=1

##############################
### Proxool Connection Pool###
##############################

## Properties for external configuration of Proxool

hibernate.proxool.pool_alias netAuditing

## Only need one of the following

#hibernate.proxool.existing_pool true
#hibernate.proxool.xml cfg/proxool.xml
#hibernate.proxool.properties proxool.properties

##########################
### Second-level Cache ###
##########################

## optimize chache for minimal "puts" instead of minimal "gets" (good for clustered cache)

#hibernate.cache.use_minimal_puts true

## set a prefix for cache region names

hibernate.cache.region_prefix hibernate.test

## enable the query cache

hibernate.cache.use_query_cache true

## choose a cache implementation

hibernate.cache.provider_class net.sf.ehcache.hibernate.Provider

hibernate.cfg.xml

lianxiangpanjin@163.com(admin) — Mon,17 Sep 2007 23:06:17 +0800

PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-2.0.
dtd">

jdbc:mysql://localhost/sample

org.gjt.mm.mysql.Driver

User

Mypass

net.sf.hibernate.dialect.MySQLDialect

True

True

net.sf.hibernate.transaction.JDBCTransactionFactory

工厂模式的简单用例

lianxiangpanjin@163.com(admin) — Mon,13 Aug 2007 11:26:37 +0800

工厂模式是J2EE核心模式中较简单的一种，听说Jive论坛中对数种设计模式有着广泛的应用，工厂模式也包括其中，本人就从该模式起步，希望有一天能对各种设计模式运用自如。

现给出一简单用例，模拟一火腿（Ham）生产工厂，工厂可以生产数种类型的Ham，那么在创建了一个工厂实例后，只需要告诉它请你生产何种Ham，它就会给你生产出来：
package test;

interface Ham { //定义接口，用于辅助实现工厂模式
    void show();//由Ham工厂生产出的各种Ham将有show()的能力
}
public class FatoryModule {//工厂类，用于产品多种不同种类的Ham
    public Ham getHam(String HamType) throws Exception{//工厂类对象生产Ham的动作
        if (HamType.equals("HamA")) {
            return new HamA();
        }
        else if (HamType.equals("HamB")) {
            return new HamB();
        }
        else if (HamType.equals("HamC")) {
            return new HamC();
        }
        else
            throw new Exception();//如果该工厂收到生产某种Ham的指令但暂不支持，则抛出异常

    }

    public static void main(String[] args) {//测试代码
        FatoryModule fatorymodule = new FatoryModule();
    try {
        Ham myHam = fatorymodule.getHam("HamB");//可以方便地创建各种类型的Ham，而程序结构和代码的修改量达到最小
        myHam.show();
    } catch (Exception ex) {
        ex.printStackTrace();//应进一步处理异常
    }
    }
}

class HamA implements Ham { //工厂中生产的一种产品HamA
    public void show() {
        System.out.println("You got a HamA.");
    }
}

class HamB implements Ham { //工厂生产的另一种产品HamB
    public void show() {
        System.out.println("You got a HamB.");
    }
}

class HamC implements Ham { //工厂生产的第三种产品HamC
    public void show() {
        System.out.println("You got a HamC.");
    }
}
        通过程序的演示我得到了以下结论：

        由于应用了工厂模式，我只需要告诉工厂对象给我生产一种什么样的Ham（即getHam()方法中的参数），便可以得到此类Ham，而不用写HamX  hamX=new HamX(); 要是有数十种不同的Ham对象需要在程序的不同地方被创建，那么使用工厂模式代码将显得简单而统一，每个需要不同Ham的地方仅是getHam()的参数不同。否则程序一旦需要扩展和维护，数十处的new语句将让人头痛。而如果需要添加新的Ham类型，只需要在工厂类中添加即可。
        我还这样理解：如果说每种Ham对象的创建都是一条生产线，那么我们用一个工厂将多个生产线封装起来了，从而用户就好比只与工厂传达室的人打交道，告诉他请你们工厂生产一种什么产品，而不是与每一条生产线打交道－－这样说来当然是有好处的。

简单的数据库操作

lianxiangpanjin@163.com(admin) — Mon,13 Aug 2007 00:17:28 +0800

interface: DAOFace();
implement class: DAOFaceImpl();

DAOFace face = new DAOFaceImpl();
face.addUser();
-------------------------------------------------------------

先定义一个DAO接口如：IHelloDAO,里面定义你要进行的数据库操作的抽象方法如添加记录、查询等
再写一个DAO实现类实现上边的接口如：HelloDAO,具体实现接口中定义的抽象方法。给你个例子：

public interface IUserDAO {
public User getByName(String name,String password);
}

public class UserDAO extends HibernateDaoSupport implements IUserDAO{

public User getByName(String name,String password){
Object[] args=new Object[]{name,password};
int i=getHibernateTemplate().find("from User i where i.username=? and i.userpassword=?",args).size();
System.out.println("与该username相同的元素个数是："+i);
if (i!=0)
return (User) getHibernateTemplate().find("from User i where i.username=? and i.userpassword=?",args).get(0);
else{
User user=new User();
user=null;
return user;
}
}

}
-----------------------------------------------------
在Action中调用：User user=userDAO.getByName(username,password);

用DAO模式操作数据库(未运行)

lianxiangpanjin@163.com(admin) — Sun,12 Aug 2007 23:43:22 +0800

DAO（Data Access Object，数据访问对象），是Java编程中的一种经典模式，正被广泛应用，也是J2EE架构中持久层框架的基础知识，基于分层次式的软件架构来实现对数据库的访问操作。

　　DAO模式的主要思想就是从抽象数据源获取与操纵数据的方法。抽象数据的含义就是编写应用程序的程序员不必关心数据库的物理位置，是何种数据库，只须使用封装数据库中表示记录的数据对象即可。
图中BusinessObject业务对象，是使用DAO模式的客户端；DataTransferObject数据传输对象，在应用程序不同层次之间传输对象，在一个分布式应用程序中，通常可以提高整体的性能；DataAccessObject数据输入/输出对象封装了对数据源的一些基本的操作；DataSource指的是数据源。也可以从图中看出，DAO模式分离了业务逻辑和数据逻辑，使得编写的软件具有良好的层次式体系结构。

　　DAO模式中对于数据库的访问，可以使用任意的Java数据访问方式，如JDBC API、EJB, JDO/Hibernate以及任何其他的ORM（对象关系映射工具）。

　　【实例66】  用DAO模式操作数据库

　　下面是一个相对复杂的应用实例，一方面理解DAO模式操作数据库的分层式软件开发思想，另一方面结合第7章中用.properties作数据库连接配置文件的方法，并用JavaBean来实现对配置文件中属性值的读取。

　　本例不再使用ROOT（Tomcat默认的Web应用），而使用一个新的Web应用——dao。建立一个应用最简单的方法就是在Tomcat 5.5的安装目录下的webapps子文件夹中创建一个文件夹，命名为“dao”，文件夹结构如图8-12所示。

　从上图可以看出，类的组织层次上共有3个包，DAO.connDB包中存放与数据库连接相关的类；DAO.table包中存放封装表的类；DAO.tableOP包中存放对表操作的类；数据库连接的配置文件dbconn.properties位于classes目录中。类之间的调用关系如下：

所有代码如下：
dbconn.properties文件存放连接数据库的配置参数，内容如下：
　　dbconn.properties
　　#SQL Server
　　driverName=com.microsoft.jdbc.sqlserver.SQLServerDriver　　connString=jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=testDatabase
　　userName=sa
　　password=6599996
　　DAO.connDB.readPropertie类用来读取.properties文件中的配置，其源代码如下：
　　readProperties.java
　　package DAO.connDB;
　　import java.io.InputStream;
　　import java.util.Properties;
　　//读.properties文件属性类
　　public class readProperties {
String propertyFileName=null;//.properties文件名称
public String getPropertyFileName() {
  return propertyFileName;
}
public void setPropertyFileName(String propertyFileName) {
  this.propertyFileName = propertyFileName;
}
public String getPropertyFromFile(String refName)
{//从.properties文件中得到refName属性的值
  if(this.getPropertyFileName()==null) return null;
  else{
   try{
    InputStream fin = getClass().getResourceAsStream(this. get Property FileName());
    Properties props = new Properties();
    props.load(fin);
    return (String)props.getProperty(refName);
   }catch(Exception e){
    return null;
   　　}
  　　}
　　}
　　}　

　　DAO.connDB.conndb封装了对数据库的连接，通过DAO.connDB.readProperties类读取连接参数，其源代码如下：
　　conndb.java
　　package DAO.connDB;
　　import java.sql.Connection;
　　import java.sql.DriverManager;
　　//生成数据库连接对象类
　　public class connDB {
String driverName=null;//数据库驱动名
String connString=null;//连接字符串
String userName=null;//用户名
String password=null;//密码
public connDB() {//在构造函数中初始化数据库连接参数
  readProperties readDBProperties=new readProperties();
  readDBProperties.setPropertyFileName("/dbconn.properties");
  　　driverName=readDBProperties.getPropertyFromFile("driverName");
  　　connString=readDBProperties.getPropertyFromFile("connString");
  userName=readDBProperties.getPropertyFromFile("userName");
  password=readDBProperties.getPropertyFromFile("password");
}
public Connection getDBConn()
{//得到数据库连接对象
  if(driverName==null||connString==null||userName==null) return null;
  else{
   try{
    Connection connDBObject=null;
    Class.forName(driverName);
    return 　　DriverManager.getConnection(connString, userName, password);
   }catch(Exception e){
    return null;
   }
  }
}
public String getConnString() {
  return connString;
}
public String getDriverName() {
  return driverName;
}
public String getPassword() {
  return password;
}
public String getUserName() {
  return userName;
}
　　}
　　DAO.table.userRecord类封装了数据库中的userTable表记录，源代码如下：
　　UserRecord.java
　　package DAO.table;
　　import java.sql.Date;
　　//封闭数据库userTable表记录的类
　　public class userRecord {
long userId;//用户ID
String userName;//用户名
String userPassword;//用户密码
String userTrueName;//用户真实姓名
int userAge;//用户年龄
String userSex;//用户性别
String userAddress;//用户地址
String userTelephone;//用户电话号码
Date addTime; //增加用户的时间
public long getUserId() {
  return userId;
}
public void setUserId(long userId) {
  this.userId = userId;
}
public String getUserName() {
  return userName;
}
public void setUserName(String userName) {
  this.userName = userName;
}
public String getUserPassword() {
  return userPassword;
}
public void setUserPassword(String userPassword) {
  this.userPassword = userPassword;
}
public String getUserSex() {
  return userSex;
}
public void setUserSex(String userSex) {
  this.userSex = userSex;
}
public String getUserTelephone() {
  return userTelephone;
}
public void setUserTelephone(String userTelephone) {
  this.userTelephone = userTelephone;
}
public String getUserTrueName() {
  return userTrueName;
}
public void setUserTrueName(String userTrueName) {
  this.userTrueName = userTrueName;
}
public Date getAddTime() {
  return addTime;
}
public void setAddTime(Date addTime) {
  this.addTime = addTime;
}
public String getUserAddress() {
  return userAddress;
}
public void setUserAddress(String userAddress) {
  this.userAddress = userAddress;
}
public int getUserAge() {
  return userAge;
}
public void setUserAge(int userAge) {
  this.userAge = userAge;
}
　　}

　　从上面的代码可以看出，针对数据库中的userTable表的字段都一个userRecord类的属性相对应，并有getXxxx()和setXxxx()方法，如果使用了Eclipse或JBuilder这样的可视化开发环境，书写了类的属性后，相应的 getXxxx()和setXxxx()方法都可以用功能菜单快速自动生成。

DAO.tableOP.uerDAO类中编写对userTable表的操作，为简便起见，这里只编写了根据用户名查找用户的方法，实际应用中可以根据需要增加方法。其源代码如下：
　　UserDAO.java
　　package DAO.tableOP;
　　import java.sql.Connection;
　　import java.sql.ResultSet;
　　import java.sql.Statement;
　　import java.util.Hashtable;
　　import DAO.table.userRecord;
　　import DAO.connDB.connDB;
　　//userTable表DAO操作类
　　public class userDAO {
    　　Connection conn=null;
　　public userDAO() {//在构造函数中初始化数据库连接
　　    conn=(new connDB()).getDBConn();
　　}
　　public Hashtable getUsersByUserName(String userName)
　　{//根据用户名查找用户，支持模糊查询，输入参数为JSP页面输入的查询姓名，
　　 //返回用户记录对象集的Hashtable(哈希表)
　　　Hashtable usersHashTable=new Hashtable();
  　　String sqlString=null;
  　　//构造SQL语句
  　　if(userName==null||userName.length()==0)
  　　　　sqlString="select * from userTable";
  　　else
　　　   　　sqlString="select * from userTable where user_true_name like '%"+userName+"%'";
  if(conn!=null){
   Statement SQLQueryObject=null;
   ResultSet RecordSet=null;
   try{
       //查询出数据
　　SQLQueryObject=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
    　　RecordSet=SQLQueryObject.executeQuery(sqlString);
    //循环地把数据放入Hashtable
    int i=0;
    userRecord user=new userRecord();
    while(RecordSet.next()){
     　　user.setUserId(RecordSet.getLong("user_id"));
     　　user.setUserName(RecordSet.getString("user_name"));     user.setUserPassword(RecordSet.getString("user_password"));
     　　user.setUserSex(RecordSet.getString("user_sex"));
     　　user.setUserTelephone(RecordSet.getString("user_telephone"));
     　　user.setUserTrueName(RecordSet.getString("user_true_name"));
     　　user.setUserAge(RecordSet.getInt("user_age"));
     　　user.setUserAddress(RecordSet.getString("user_address"));
     　　user.setAddTime(RecordSet.getDate("add_time"));
     usersHashTable.put("user"+i,user);
     i++;
     user=new userRecord();
    }
   }catch(Exception e){
    e.printStackTrace();
   }
  }
  return usersHashTable;
　　}
　　}

　　在该程序中，把查询出的用户信息放入userRecord类的对象user中，然后再放入hashTable。在user对象中需要用new关键字再新生成一个，这是因为hashTable在内存中作了映射，如果不新生成一个user对象，在while循环中，设置user属性等于是更改了原user对象的属性，放入hashTable中的对象仍然指向此对象，会使得hashTable中的对象内容相同，因此每在hashTable中放入一个user对象后，需要用user=new userRecord()语句来新生成一个user对象。

　应用层通过调用userDAO类完成所需的操作。这里的应用层是一个JSP页面，其源代码如下：
　　userDAOExample.jsp
　　<%@ page contentType="text/html;charset=GB2312" %>
　　<%@ 　　pageimport="java.sql.*,DAO.tableOP.*,DAO.table.*,java.util.Hashtable" 　　%>
　　<%!
　　public String codeToString(String str)
　　{//处理中文字符串的函数
  　　String s=str;
  　　try{
    　　byte tempB[]=s.getBytes("ISO-8859-1");
    　　s=new String(tempB);
   　　 return s;
   　　}catch(Exception e)
  　　 {return s;
　　  }
　　}
　　%>
　　<%//根据条件查询出数据,放入Hashtable对象中
　　  String username= codeToString(request.getParameter("username"));
　　  userDAO userDAOObject=new userDAO();
　　  Hashtable users=userDAOObject.getUsersByUserName(username);
　　%>
　　
　　
　　
　　
　　
　　查询姓名
　　
　　
　　
　　
　　用户数据(共<%%>条记录)
　　
　　
  　　用户ID号
  　　用户名
  　　用户真实姓名
  　　年龄
  　　性别
  　　联系地址
　　联系电话
　　添加时间
　　
　　<%//输出查询出的数据
　　if(users!=null)
　　{
    　　 for(int i=0;i    　　 {
　　%>
　　
  　　  <%=((userRecord)users.get("user"+i)).getUserId()%>
　　   <%=((userRecord)users.get("user"+i)).getUserName()%>
　　    <%=((userRecord)users.get("user"+i)).getUserTrueName()%>
　　    <%=((userRecord)users.get("user"+i)).getUserAge()%>
　　    <%=((userRecord)users.get("user"+i)).getUserSex()%>
　　    <%=((userRecord)users.get("user"+i)).getUserAddress()%>
　　    <%=((userRecord)users.get("user"+i)).getUserTelephone()%>
　    <%=((userRecord)users.get("user"+i)).getAddTime()%>
　　
　　<%
　　     }
　　 }
　　%>
　　
　　
　　

　　从上述代码中可以发现，在JSP页同中的Java代码已经很少，只是接收提交要查找的用户名后，用userDAO类的方法来得到查询结果hashTable，再用for循环来输出此hashTable中的内容。该程序的运行结果（第一次打开页面查询出所有的用户的用户信息）如图8-14所示：

点击下载此文件

DAO模型(未能运行)

lianxiangpanjin@163.com(admin) — Sun,12 Aug 2007 10:58:44 +0800

DAO设计模式
1: 为什么使用DAO?
    a: 在涉及数据库操作，以前一般使用jdbc，使用这种方法我们会发现代码和html标签同时使用，维护很困难。
    b：jsp文件中不应该出现任何sql包，jsp文件侧重于显示界面的。
    c：所有的数据库操作建议使用prepareStatement。好处重在避免sql注入漏洞。

2：DAO是J2EE中的数据层操作。

3：数据库创建脚本
--删除表
Drop TABLE person;

--创建表
Create TABLE person
(
    id varchar(20) not null primary key,
    name varchar(20) not null,
    password varchar(20) not null,
    age varchar(20) not null,
    email varchar(30) not null
);
--事务提交
commit;

4：如果在数据库修改后，我们怎么样才能做到前台页面不需要太多的改变？
        我们必须规定出对PERSON中的全部操作。比如增删查改。
按照以上要求，制定出操作那张表的标准，之后只要针对不同的数据库实现这些标准就可以了。在java中我们可以通过接口来实现----》DAO规定的就是这些接口。

package com.nnu.djx.dao;
import com.nnu.djx.vo.*;
import java.util.*;

//规定了在此项目中操作person表的全部方法
public interface PersonDao ...{
    /** *//**
     * 插入对象
     * @throws Exception
     */
    public void insert(Person person)throws Exception;
    /** *//**
     * 更新对象
     * @throws Exception
     */
    public void update(Person person)throws Exception;
    /** *//**
     * 删除某一对象
     * @param id
     * @throws Exception
     *
     */
    public void delete(String id)throws Exception;

    /** *//**
     * 按照ID查询
     * @param id
     * @return
     * @throws Exception
     *
     */
    public Person queryById(String id)throws Exception;
    /** *//**
     * 查询全部结果
     * @return
     * @throws Exception
     */
    public List     queryAll()throws Exception;
    /** *//**
     * 模糊查询
     * @param code
     * @return
     * @throws Exception
     */
    public List queryByLike(String code)throws Exception;

}

5：在DAO中操作的是对象和数据库之间的关系。
    不过此时的对象是（VO,POLO,TO）(值对象，最简单对象，传输对象)
    即是只包括getter，setter方法的类。
通过VO操作DAO
Vo中的字段和表中一一对应。
package com.nnu.djx.vo;

public class Person ...{

    private String id;
    private String name;
    private String password;
    private int age;
    private String email;

    //生成getter，setter方法。
    public int getAge() ...{
        return age;
    }
    public void setAge(int age) ...{
        this.age = age;
    }
    public String getEmail() ...{
        return email;
    }
    public void setEmail(String email) ...{
        this.email = email;
    }
    public String getId() ...{
        return id;
    }
    public void setId(String id) ...{
        this.id = id;
    }
    public String getName() ...{
        return name;
    }
    public void setName(String name) ...{
        this.name = name;
    }
    public String getPassword() ...{
        return password;
    }
    public void setPassword(String password) ...{
        this.password = password;
    }
}

6：对于定义好的接口，需要给出具体实现。对数据库表的一切具体操作。
可以定义一个数据库链接类，只负责连接。

package com.nnu.djx.dao.impl;

import java.util.List;
import com.nnu.djx.dao.*;
import com.nnu.djx.vo.Person;

public class PersonDaoImpl implements PersonDao  ...{

    public void delete(String id) throws Exception ...{
        // TODO 自动生成方法存根

    }
    public void insert(Person person) throws Exception ...{
        // TODO 自动生成方法存根

    }
    public List queryAll() throws Exception ...{
        // TODO 自动生成方法存根
        return null;
    }
    public Person queryById(String id) throws Exception ...{
        // TODO 自动生成方法存根
        return null;
    }
    public List queryByLike(String code) throws Exception ...{
        // TODO 自动生成方法存根
        return null;
    }
    public void update(Person person) throws Exception ...{
        // TODO 自动生成方法存根
    }

    public PersonDaoImpl() ...{
        // TODO 自动生成构造函数存根
    }
}

具体的数据库连接类如下：
package com.nnu.djx.dbc;
import java.sql.*;
public class DataBaseConnection ...{

    private final String DBDRIVER ="oracle.jdbc.driver.OracleDriver";
    private final String DBURL ="jdbc:oracle:thin:@localhost:1521:ora9djx";
    private final String DBUSER ="system";
    private final String DBPWD ="system";

    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rst = null;

    public DataBaseConnection()...{
        try...{
            Class.forName(DBDRIVER);

            this.conn = DriverManager.getConnection(DBURL,DBUSER,DBPWD);
        }catch(Exception e)...{
            e.printStackTrace();
        }
    }
    //取得数据库链接
    public Connection getConnection()...{
        return this.conn;
    }
    public void closeConnection()...{
        try ...{
            this.conn.close();
        } catch (SQLException e) ...{
            // TODO 自动生成 catch 块
            e.printStackTrace();
        }
    }

}
然后对于上面的具体实现。用prepareStatement实现。。

5：再设计一个jsp页面用来操作数据库，检验前面的代码是否正确。
<%@page contentType="text/html;charset=GB2312"%>
<%@page import="com.nnu.djx.dao.*,com.nnu.djx.vo.*,com.nnu.djx.dao.impl.*,java.util.*,com.nnu.djx.factory.*"%>

<%
    //进行插入操作
    /**//*
    Person person = new Person();
    person.setId("001");
    person.setName("why");
    person.setPassword("123");
    person.setAge(12);
    person.setEmail("123j@163.com");

    */
        PersonDao persondao = new PersonDaoImpl();

        //PersonDaoFactory.getPersonDaoInstance().queryAll();
    //删除一个用户


    try...{

        //persondao.insert(person);

        //persondao.delete("001");

        //persondao.update(person);

        //全部查询
        /**//*
        List list = persondao.queryAll();
        Iterator iterator = list.iterator();
        while(iterator.hasNext())
            {
                Person person = (Person)iterator.next();
                out.print(person.getName());
            }

        */

        //模糊查询
        List list = persondao.queryByLike("hy");
        Iterator iterator = list.iterator();
        while(iterator.hasNext())
            ...{
                Person person = (Person)iterator.next();
                out.print(person.getName());
            }
    }catch(Exception e)...{

    }
%>

DAO使用后，我们发现前天的代码明显减少，而后台比如类都增多了。
同时可以发现这样的一个问题
PersonDao persondao = new PersonDaoImpl();
操作时必须知道子类。
如果有一天我们改变了数据库（DB2）修改就不方便了。
应该考虑如何是前台代码不关后台的变化。。
此时可以考虑工厂模式:
    新建一个类工厂类PersonDaoFactory
package com.nnu.djx.factory;

import com.nnu.djx.dao.PersonDao;
import com.nnu.djx.dao.impl.PersonDaoImpl;

public class PersonDaoFactory ...{

    public static PersonDao getPersonDaoInstance()...{
        return new PersonDaoImpl();
    }
}

以后调用的时候就可以用
PersonDaoFactory.getPersonDaoInstance().queryAll();
而不具体涉及到类。。。
后序：
程序经过验证完全正确，可以作为以后数据库学习的模板。。

点击下载此文件