Webwork2+Spring+Hibernate体验

posted @ 2005-08-29 11:03 我的JAVA 阅读(95) | 评论 (1) | 编辑收藏

嘿嘿，偶来介绍下Webwork2结合Spring, Hibernate，Default认为对Spring,Hibernate有一定了解。
从User说起，包括创建/修改/删除User，以及对User的列表，先看Webwork2的Action代码
为简单说明问题，不考虑什么Interceptor, Duplicated Submit, Validation,等问题

创建/修改/删除User:UserAction.java相关代码

java代码:

 
UserManager userManager; 
       
       public 
       void setUserManager 
       (UserManager 
       ) 
       { 
       
    this. 
       userManager = userManager; 
       
       } 
       
       public 
       String create 
       ( 
       ) 
       { 
       
    userManager. 
       create 
       (getUser 
       ( 
       ) 
       ); 
       
       } 
       
       public 
       String modify 
       ( 
       ) 
       { 
       
    userManager. 
       modify 
       (modifyUser 
       ( 
       ) 
       ) 
       
       return "success"; 
       
       } 
       
       public 
       String remove 
       ( 
       ) 
       { 
       
    userManager. 
       remove 
       (getUser 
       ( 
       ) 
       ) 
       
       return "success"; 
       
       }

xwork.xml相关代码

java代码:

 
       
<action name="user" 
       class="com. 
       caryo. 
       user. 
       actions. 
       UserAction"> 
       
    <external-ref name="userManager">userManager</external-ref> 
       
    <result name="success" type="dispatcher">user. 
       jsp</result> 
       
</action> 
      

webwork action会自动接受页面上传过来的信息，而且还支持JavaBean的BeanInfo（BeanInfo没用过，偶
都是直接在action中完成获取属性，以及类型转换与校验的工作的）
Webwork2很方便的支持了Command模式，允许一个Action拥有多个Command，对应的url调用
user!create.action, user!modify.action, user!remove.action，会对应的调用UserAction中的方法，
然后根据方法返回值去寻找对应的View，return "sucess" 就会forward到user.jsp。
其中的userManager是Spring中applicationContext中定义的bean

java代码:

 
<bean id="userManager" 
       class="com. 
       caryo. 
       user. 
       DefaultUserManager"> 
       
    <property name="userDAO"><ref local="userDAO"/></property> 
       
</bean>

对User的列表:ListUserAction.java相关片断

java代码:

 
UserManager userManager; 
       
       public 
       void setUserManager 
       (UserManager 
       ) 
       { 
       
    this. 
       userManager = userManager; 
       
       } 
       
       // userManager的获取可放在一个User的根类声明，如AbstractUserAction，这里重复为了看得清楚些 
       
       public 
       List getAllUsers 
       ( 
       ) 
       { 
       
    userManager. 
       getAllUsers 
       ( 
       ); 
       
       } 
       
       public 
       List getOnlineUsers 
       ( 
       ) 
       { 
       
    userManager. 
       getOnlineUsers 
       ( 
       ); 
       
       }

xwork.xml相关代码

java代码:

 
       
<action name="listuser" 
       class="com. 
       caryo. 
       user. 
       actions. 
       ListUserAction"> 
       
    <external-ref name="userManager">userManager</external-ref> 
       
    <result name="success" type="dispatcher">listuser. 
       jsp</result> 
       
</action> 
      

这样对应的url就是listuser.action，无command模式下会自动执行public String execute()这一方法，
Default是一个返回"success"的空方法，当然你也可以重写此方法，例如做校验等等。

listuser.jsp中使用webwork taglib打出User列表的片断

java代码:

 
<ww:iteraor value="allUsers"> 
       
userId: <ww:property value="id" /> 
       
userName: <ww:property value="name" /> 
       
</ww:iterator> 
       
<ww:iteraor value="onlineUsers"> 
       
userId: <ww:property value="id" /> 
       
userName: <ww:property value="name" /> 
       
</ww:iterator>

webwork taglib功能比较强大，其中还可使用带参数的方法调用，而且在逻辑控制等方面都考虑的比较完善
详细参见 http://wiki.opensymphony.com/pages/viewpage.action?pageId=1876
只要设计合理，基本上使用其taglib就可以控制整个view，包括复杂的页面。尽管也支持Velocity, Freemarker等
不过考虑到性能，推荐还是使用jsp view。
大型网站的UI层应该尽可能的薄，JSP不易维护，我觉得taglib是可接受的厚度的上限了。

Spring+hibernate的部分跟dhj1版主的相近，http://forum.javaeye.com/viewtopic.php?t=7925
偶就不重复了。只说一些不同的地方
1. web.xml 可以使用listener来初始化基本信息而不是用servlet
2. 在Session in DAO中，用iterator返回数据应该是不行的，那么要获取count，不是iterator.next()
也不是获取整个list，然后list.size()，而应是一个list.get(0);
3. 可将HQL放到对应的hbm.xml中

java代码:

 
       public 
       class HibernateVehicleDAO 
       extends CaryoHibernateObjectDAO 
       implements VehicleDAO 
       { 
       
       Class vehicleClass; 
       
       public 
       Class getPersistentClass 
       ( 
       ) 
       { 
       
       return vehicleClass != 
       null ? vehicleClass : 
       (vehicleClass = Vehicle. 
       class 
       ); 
       
       } 
       
       public Vehicle getById 
       ( 
       final long id 
       ) 
       { 
       
       return 
       (Vehicle 
       ) getByClassId 
       (id 
       ); 
       
       } 
       
       public 
       List findAllGlobalVehicles 
       ( 
       ) 
       { 
       
       return findNamedQuery 
       ("caryo. 
       vehicle_findAllGlobalVehicles" 
       ); 
       
       } 
       
       }

vehicle.hbm.xml相关代码

java代码:

 
<query name="caryo. 
       vehicle_findAllGlobalVehicles"><! 
       [CDATA 
       [ 
       
    from Vehicle vehicle 
       
       ] 
       ]></query>

posted @ 2005-08-26 15:58 我的JAVA 阅读(146) | 评论 (1) | 编辑收藏

本文是开发基于spring的web应用的入门文章，前端采用Struts MVC框架，中间层采用spring，后台采用Hibernate。

　　本文包含以下内容：

　　　·配置Hibernate和事务

　　　·装载Spring的applicationContext.xml文件

　　　·建立业务层和DAO之间的依赖关系

　　　·将Spring应用到Struts中

　　简介

　　这个例子是建立一个简单的web应用，叫MyUsers,完成用户管理操作，包含简单的数据库增，删，查，该即CRUD（新建，访问，更新，删除）操作。这是一个三层的web应用，通过Action（Struts）访问业务层，业务层访问DAO。图一简要说明了该应用的总体结构。图上的数字说明了流程顺序－从web（UserAction）到中间层（UserManager），再到数据访问层（UserDAO），然后将结果返回。

　　Spring层的真正强大在于它的声明型事务处理，帮定和对持久层支持（例如Hiberate和iBATIS）

　　以下下是完成这个例子的步骤：

　　1．安装Eclipse插件

　　2．数据库建表

　　3．配置Hibernate和Spring

　　4．建立Hibernate DAO接口的实现类

　　5．运行测试类，测试DAO的CRUD操作

　　6．创建一个处理类，声明事务

　　7．创建web层的Action和model

　　8．运行Action的测试类测试CRUD操作

　　9．创建jsp文件通过浏览器进行CRUD操作

　　10．通过浏览器校验jsp

　　安装eclipse插件

　　1． Hibernate插件http://www.binamics.com/hibernatesync

　　2． Spring插件http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/

　　3． MyEclipse插件(破解版)

　　4． Tomcat插件. tanghan

　　5．其他插件包括xml，jsp，

　　数据库建表

create table app_user(id number not null primary,firstname vchar(32),lastname vchar(32));

　　新建项目

　　新建一个web project，新建后的目录结构同时包含了新建文件夹page用于放jsp文件，和源文件夹test用于放junit测试文件。同时将用到的包，包括struts，hibernate，spring都导入到lib目录下。

　　创建持久层O/R mapping

　　1．在src/com.jandar.model下用hibernate插件从数据库导出app_user的.hbm.xml文件改名为User.hbm.xml

＜?xml version="1.0"?＞
＜!DOCTYPE hibernate-mapping PUBLIC
　　 "-//Hibernate/Hibernate Mapping DTD//EN"
　　 "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" ＞
＜hibernate-mapping package="com.jandar.model"＞
＜class name="User" table="APP_USER"＞
　＜id
　　column="ID"
　　name="id"
　　type="integer"
　＞

　　＜generator class="assigned" /＞

　＜/id＞

　＜property
　　　column="LASTNAME"
　　　length="10"
　　　name="lastname"
　　　not-null="false"
　　　type="string"
　/＞

　＜property
　　　column="FIRSTNAME"
　　　length="10"
　　　name="firstname"
　　　not-null="true"
　　　type="string"
　/＞

＜/class＞
＜/hibernate-mapping＞

　　2．通过hibernate synchronizer-＞synchronizer file生成User.java文件,User对象对应于数据库中的app_user表

　　注：在eclipse下自动生成的对象文件不完全相同，相同的是每个对象文件必须实现Serializable接口，必需又toString和hashCode方法；

import java.io.Serializable;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;

public class BaseObject implements Serializable {
　public String toString() {
　　return ToStringBuilder.reflectionToString(this,
　　ToStringStyle.MULTI_LINE_STYLE);
　}

　public boolean equals(Object o) {
　　return EqualsBuilder.reflectionEquals(this, o);
　}

　public int hashCode() {
　　return HashCodeBuilder.reflectionHashCode(this);
　}
}

public class User extends BaseObject {
　private Long id;
　private String firstName;
　private String lastName;

　/**
　* @return Returns the id.
　*/

　public Long getId() {
　　return id;
　}

　/**
　　* @param id The id to set.
　*/

　public void setId(Long id) {
　　this.id = id;
　}

　/**
　* @return Returns the firstName.
　*/

　public String getFirstName() {
　　return firstName;
　}

　/**
　　* @param firstName The firstName to set.
　*/

　public void setFirstName(String firstName) {
　　this.firstName = firstName;
　}

　/**
　* @return Returns the lastName.
　*/

　public String getLastName() {
　　return lastName;
　}

　/**
　* @param lastName The lastName to set.
　*/

　public void setLastName(String lastName) {
　　this.lastName = lastName;
　}
}

创建DAO访问对象

　　1．在src/com.jandar.service.dao新建IDAO.java接口，所有的DAO都继承该接口

package com.jandar.services.dao;

public interface IDAO {

}

　　2．在src/com.jandar.service.dao下新建IUserDAO.java接口

public interface IUserDAO extends DAO {
　List getUsers();
　User getUser(Integer userid);
　void saveUser(User user);
　void removeUser(Integer id);
}

　　该接口提供了访问对象的方法，

　　3．在src/com.jandar.service.dao.hibernate下新建UserDAOHiberante.java

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
import com.jandar.model.User;
import com.jandar.service.dao.IUserDAO;

public class UserDaoHibernate extends HibernateDaoSupport implements IUserDAO {

　private Log log=LogFactory.getLog(UserDaoHibernate.class);
　/* （非 Javadoc）
　* @see com.jandar.dao.IUserDAO#getUsers()
　*/

　public List getUsers() {
　　return getHibernateTemplate().find("from User");
　}

　/* （非 Javadoc）
　* @see com.jandar.dao.IUserDAO#getUser(java.lang.Long)
　*/

　public User getUser(Integer id) {
　　// TODO 自动生成方法存根
　　return (User) getHibernateTemplate().get(User.class,id);
　}

　/* （非 Javadoc）
　* @see com.jandar.dao.IUserDAO#saveUser(com.jandar.model.User)
　*/

　public void saveUser(User user) {
　　log.debug("xxxxxxx");
　　System.out.println("yyyy");
　　getHibernateTemplate().saveOrUpdate(user);
　　if(log.isDebugEnabled())
　　{
　　　log.debug("userId set to "+user.getId());
　　}
　}

　/* （非 Javadoc）
　* @see com.jandar.dao.IUserDAO#removeUser(java.lang.Long)
　*/

　public void removeUser(Integer id) {
　　Object user=getHibernateTemplate().load(User.class,id);
　　getHibernateTemplate().delete(user);
　　if(log.isDebugEnabled()){
　　　log.debug("del user "+id);
　　}
　}
}

　　在这个类中实现了IUserDAO接口的方法，并且继承了HibernateDAOSupport类。这个类的作用是通过hibernate访问、操作对象，进而实现对数据库的操作。

posted @ 2005-08-25 01:28 我的JAVA 阅读(164) | 评论 (1) | 编辑收藏

spring+hibernate开发网站

http://www.xyzp.net 校园招聘一网打尽

spring，一个轻量级的j2ee框架，轻量级的，这几个字就深深的把我吸引住了。抱着《spring in action》啃了一个星期，小了解之后，把自己所学的东西几乎通通用在了xyzp.net这个网站上，下面介绍一下：

校园招聘一网打尽提供专业的校园招聘信息。系统自动采集全国各大高校BBS和就业中心的招聘信息，按照地区、学校进行组织分类。

http://www.xyzp.net网站分为两个部分：后台数据采集与前台展示。
1.后台数据采集，利用htmlparser分析网页，抽取我们所需的数据，以rss的结构进行存储。
2. 前台展示，利用spring＋hibernate开发。hibernate处理数据库逻辑，逻辑层使用spring，表示层应用spring本身的 mvc。应用spring开发确实很方便，速度快，效率高；），整个网站2周就搞完了。而且，我不得不说，spring太美了。

hibernate处理数据库逻辑真是没的说，整个网站一共就4张表，大量一对多和多对多的逻辑，hibernate处理的很好，主要是编程方面要处理的逻辑简单了很多，但是效率方面有一点欠缺；（

spring本身提供一套完整的mvc，应用起来很方便，功能也很强大，几乎用的到的页面逻辑它都想到了。推荐使用。

应用了xmlhttprequest技术，因为首页调用数据库的次数太多，所以每个栏目都用一个远程调用来解决的，速度很快，不过有的ie显示还有一些问题；（

虽然xmlhttprequest提升速度比较明显，但对数据库操作的次数并没有减少，引入缓存机制才能从根本上解决，oscache是opensymphony的出品，它的页面级缓存把整个网页缓存下来，速度提升自然很明显。

整个网站没有使用table，全部使用css搞定，大家可以看一下。

整个网站全部采用开源软件构建，包括spring,hibernate,oscache,tomcat,mysql,eclipse,java commons.lucene等等。

在开发中碰到不少问题，字符集、链接池，spring与hibernate集成等等，对此有兴趣可以和我联系，QQ：21231398

如果大家觉得这个网站还不错，请推荐一下，谢谢；）

posted @ 2005-08-24 01:58 我的JAVA 阅读(163) | 评论 (0) | 编辑收藏

其实Hibernate本身是个独立的框架，它不需要任何web server或application server的支持。然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。这容易让人产生Hibernate复杂难懂的误解，特别是打击了初学者的积极性。

在这篇文章将不涉及Eclipse, log4j, Struts, Tomcat, XDoclet，和JBoss。本文的目的是演示一下Hibernate的安装过程以及最基本的功能，从而给初学者一个低得不能再低的入门门槛。

下载文件

你需要Java SDK、 Hibernate包、Ant包、和JDBC Driver。

1、Hibernate包下载地址:
http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

2、Ant包下载地址:
http://apache.130th.net/ant/binaries/apache-ant-1.6.1-bin.zip

3、 JDBC Driver要根据你用的database来定，一般database官方网站上都会有。Hibernate支持常用的database，比如 MySQL, Oracle, PostgreSQL, 和MS-SQL Server。这些数据库都有JDBC Driver:

Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)
http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

MySQL JDBC Driver下载地址
http://dev.mysql.com/downloads/connector/j/3.0.html

PostgreSQL JDBC Driver下载地址
http://jdbc.postgresql.org/download.html

MS-SQL Server JDBC Driver下载地址
http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en

4、将Hibernate包和Ant包分别解压至c:/dev/下(此目录不重要，你可以换其它任何目录)。

配置环境

1、你需要添加一个新的环境变量: ANT_HOME，让它指向c:/dev/<你的ANT包所在目录>。并在PATH环境变量里添加%ANT_HOME%/bin。

2、你需要添加一个新的环境变量: JAVA_HOME，让它指向你的j2sdk根目录。并在PATH环境变量里添加%JAVA_HOME%/bin。

3、创建一个项目目录，比如c:/workspace/My1stHibernate。

在项目目录下，另外创建三个目录: src, classes, lib。

在lib目录下，创建两个目录: hibernate和db。

这样你有了如下的文件结构:

c:/workspace/My1stHibernate/
c:/workspace/My1stHibernate/src
c:/workspace/My1stHibernate/classes
c:/workspace/My1stHibernate/lib
c:/workspace/My1stHibernate/lib/hibernate
c:/workspace/My1stHibernate/lib/db

4、将c:/dev/<你的Hibernate包所在目录>/hibernate2.jar文件copy到c:/workspace/My1stHibernate/lib/hibernate下。

将c:/dev/<你的Hibernate包所在目录>/lib/下的所有文件同样copy到c:/workspace/My1stHibernate/lib/hibernate下。

将你的JDBC Driver文件(一般是一个jar文件)copy到c:/workspace/My1stHibernate/lib/db下。

创建数据库

1、用你最喜爱的database软件，创建一个hibernate_test的数据库。

2、在此数据库下，新建一个table名为CUSTOMER

CREATE TABLE CUSTOMER
(
    CID INTEGER NOT NULL PRIMARY KEY,
    USERNAME VARCHAR(12) NOT NULL,
    PASSWORD VARCHAR(12)
);

编写Java文件

public class Customer {

    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public String getPassword() {
        return password;
    }

    public String getUsername() {
        return username;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

}

将此类存为c:/workspace/My1stHibernate/src/Customer.java文件。

编写Test类

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public class Test {

    public static void main(String[] args) {

        try {
            SessionFactory sf =
                new Configuration().configure().buildSessionFactory();
            Session session = sf.openSession();
            Transaction tx = session.beginTransaction();

            for (int i = 0; i < 200; i++) {
                Customer customer = new Customer();
                customer.setUsername("customer" + i);
                customer.setPassword("customer");
                session.save(customer);
            }

            tx.commit();
            session.close();

        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
}

将此类存为c:/workspace/My1stHibernate/src/Test.java文件。

创建Hibernate映射文件

因为这里只有一个Class --- Customer 和一个Table --- CUSTOMER，你只需要建立一个映射文件--- Customer.hbm.xml，来对应Customer类和CUSTOMER表之间的关系。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class name="Customer" table="CUSTOMER">
        <id name="id" column="CID">
            <generator class="increment" />
        </id>
        <property name="username" column="USERNAME" />
        <property name="password" column="PASSWORD" />
    </class>
</hibernate-mapping>

把此文件存为c:/workspace/My1stHibernate/src/Customer.hbm.xml，和Customer.java放在同一目录下。

编写Ant build.xml文件

你不一定要知道这个build.xml的细节，其实Ant也不是Hibernate所必须的。这里用Ant是为了简化一些任务，比如: 编译、copy、运行，等。

<?xml version="1.0" ?>

<project name="My1stHibernate" default="build" basedir=".">

    <property name="base.dir" value="." />
    <property name="src.dir" value="src" />
    <property name="lib.dir" value="lib" />
    <property name="build.dir" value="classes" />

    <path id="myclasspath">
        <fileset dir="${lib.dir}">
            <include name="**/*.jar" />
        </fileset>
        <pathelement location="${build.dir}" />
    </path>

    <target name="init">
        <mkdir dir="${build.dir}" />
    </target>

    <target name="build" depends="init" description="compile the source files">
        <javac classpathref="myclasspath" srcdir="${src.dir}" destdir="${build.dir}" />
        <copy todir="${build.dir}" >
            <fileset dir="${src.dir}" >
                <exclude name="**/*.java"/>
            </fileset>
        </copy>
    </target>

    <target name="run" depends="build">
        <java classpathref="myclasspath" classname="Test" fork="true" />
    </target>

    <target name="clean">
        <delete includeEmptyDirs="true">
            <fileset dir="${build.dir}" />
        </delete>
    </target>

</project>

配置Hibernate描述文件

Hibernate描述文件可以是一个properties或xml 文件，其中最重要的是定义数据库的连接。我这里列出的是一个XML格式的hibernate.cfg.xml描述文件。

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>

    <session-factory name="java:/hibernate/HibernateFactory">

        <property name="show_sql">true</property>
        <property name="connection.driver_class">
            oracle.jdbc.driver.OracleDriver 
        </property>
        <property name="connection.url">
            jdbc:oracle:oci8:@hibernate_test 
        </property>
        <property name="connection.username">
            你的数据库用户名
        </property>
        <property name="connection.password">
            你的数据库密码
        </property>
        <property name="dialect">
            net.sf.hibernate.dialect.Oracle9Dialect 
        </property>

        <mapping resource="Customer.hbm.xml" /> 

    </session-factory>

</hibernate-configuration>

如果你用的不是Oracle 9i，可到C:/dev/<你的Hibernate包所在目录>/src/hibernate.properties文件里找到你的数据库，然后替换以上相对应的值。

开始运行

到c:/workspace/My1stHibernate下，运行ant run。如果你严格依照以上步骤，应该看到

run:
        [java] log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
        [java] log4j:WARN Please initialize the log4j system properly.
        [java] Hibernate: insert into CUSTOMER (USERNAME, PASSWORD, CID) values (?, ?, ?)
BUILD SUCCESSFUL

到你的hibernate_test数据库看一下，在CUSTMOR表里新添了200条记录，但你没有写任何JDBC code。
以后如果你要更换数据库，只需要改变hibernate.cfg.xml描述文件里相应的值即可。

结论

此文是一篇门槛极低的入门介绍。我给一个完全不懂Hibernate的朋友看，他用了不到30分钟就运行了他的第一个Hibernate程序，从此引起了他对Hibernate的兴趣。但读者必须认识到这只是一个开始，此文实乃窥Hibernate冰山一角上的一颗小冰晶。千里之行始于足下，你可以把此文当作迈向Hibernate大道的一个起点。

posted @ 2005-08-24 01:56 我的JAVA 阅读(108) | 评论 (0) | 编辑收藏

对象、关系的映射（ORM）是一种耗时的工作，在Java环境下，有几种框架来表示持久数据，如实体Bean、OJB、JDO、Hibernate等。 Hibernate是一种新的ORM映射工具，它不仅提供了从Java类到数据表的映射，也提供了数据查询和恢复等机制。本文介绍怎么在Web应用开发中配置Hibernate的环境，并且使用Hibernate来开发一个具体的实例。

　　介绍

　　面向对象的开发方法是当今的主流，但是同时我们不得不使用关系型数据库，所以在企业级应用开发的环境中，对象、关系的映射（ORM）是一种耗时的工作。围绕对象关系的映射和持久数据的访问，在Java领域中发展起来了一些API和框架，下面分别简单介绍。

　　JDBC可以说是访问持久数据层最原始、最直接的方法。在企业级应用开发中，我们可能使用DAO（Data Access Object）模式来把数据访问封装起来，然后在其它的层中同一调用。这种方式的优点是运行效率最高，缺点是把DAO对象和SQL语言紧密耦合在一起使得在大项目中难以维护。但是不管怎么说，使用JDBC来直接访问持久数据层是当今企业级应用开发中使用最广泛的。

　　实体Bean是J2EE平台中用来表示和访问持久数据的方式。虽然实体Bean是一种方便快捷的方法，但是在运行时我们需要额外购买EJB容器（当然，如今也有免费的EJB容器，如JBOSS），并且使用不同的应用服务器，需要重新书写不同的部署描述，使得在不同应用服务器下移植企业级应用会带来一些困难。

　　另外，在Java领域中，还有一些表示持久数据的框架，比如JDO和OJB，在这里就不详细介绍了。

　　Hibernate是一种新的ORM映射工具，它不仅提供了从Java类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来手工操作数据库，使用Hibernate，可以大大减少操作数据库的工作量。

　　Hibernate可以和多种Web服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器（达16种）。

　　下面我们来介绍怎么结合Hibernate2.0和Apache Tomcat5.0在Web应用中使用Hibernate。

　　配置

　　1、下载安装Tomcat，并且下载Hibernate的运行环境（主要包含一些JAR包）。
　　2、把要使用的数据库的JDBC驱动程序拷贝到%TOMCAT_HOME%/common/lib目录下。笔者使用的是MYSQL，对应的驱动程序的JAR包为mm.mysql-2.0.4-bin.jar。
　　3、在Tomcat的Webapps目录下新建一个Web应用，名字为hibernate。
　　4、把Hibernate提供的hibernate2.jar和一些第三方的运行库拷贝到hibernate/WEB/INF/lib目录下。（这些第三方的运行库包含在下载的Hibernate lib目录下）
　　5、在%TOMCAT_HOME%/conf/server.xml中Web应用和数据源。在server.xml中加入以下的配置描述。

　　例程1 配置web应用

　<Context path="/hibernate" docBase="hibernate" debug="0"   reloadable="true" crossContext="true">
　　<Resource name="jdbc/hibernate" auth="Container" type="javax.sql.DataSource"/>
     <ResourceParams name="jdbc/hibernate">
     <parameter>
          <name>factory</name>
       <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
     </parameter>
     <parameter>
         <name>driverClassName</name>
            <value>org.gjt.mm.mysql.Driver</value>
     </parameter>
        <parameter>
              <name>url</name>
              <value>jdbc:mysql:///test</value>
         </parameter>
     <parameter>
          <name>username</name>
          <value>root</value>
     </parameter>
     <parameter>
         <name>password</name>
         <value></value>
          </parameter>
     <parameter>
      <name>maxActive</name>
      <value>20</value>
    </parameter>
         <parameter>
        <name>maxIdle</name>
           <value>10</value>
    </parameter>
    <parameter>
          <name>maxWait</name>
      <value>-1</value>
    </parameter>
　　</ResourceParams>
　</Context>

　　在这里，配置了一个名为hibernate的Web应用，并且配置了一个数据源，数据源的JNDI名称为jdbc/hibernate。您需要根据情况修改数据源的链接属性。

　　6、下一步就是书写Hibernate的配置描述符。可以使用XML的配置描述，也可以使用基于属性的配置描述。在这里使用基于XML的配置描述。在hibernate/WEB-INF/classes目录下新建一个hibernate.cfg.xml文件。然后加入例程2所示的内容。

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

<hibernate-configuration>
    <session-factory>
        <property name="connection.datasource">java:comp/env/jdbc/hibernate</property>
        <property name="show_sql">false</property>
        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
        
    </session-factory>
</hibernate-configuration>

　　注意connection.datasource属性必须和server.xml中配置的数据源的属性一样。如果不是使用MYSQL，那么需要更改dialect属性。

　　到现在，配置基本完成，下面我们来开发一个最简单的应用。

　　开发持久对象、编写映射描述

　　我们使用hibernate来封装一个简单的数据表。这个表的名字为Courses，它有两个字段，一个是ID，它是Courses表的主键；另一个是name，表示Courses的名字。在数据库中使用以下的脚本来创建这个表：

　　create table Courses(CourseId varchar(32) not null, name varchar(32), constraint pk_Courses primary key (CourseId) );

　　接下来的任务就是为Courses表书写持久对象，如例程3所示。

　　例程3 Courses的持久对象（Courses.java）

package com.hellking.study.hibernate;

import java.util.Set;

/**
*在hibernate中代表了Course表的类。
*/
public class Course
{
   /**每个属性和表的一个字段对应**/
   private String id;
   private String name;

   /**students表示course中的学生，在后面才会用到，暂时不管**/
   private Set students;

    /**属性的访问方法**/
public void setId(String string) {
  id = string;
}

public String getId() {
  return id;
}

public void setName(String name)
{
  this.name=name;
}
public String getName()
{
  return this.name;
}
public void setStudents(Set stud)
{
  this.students=stud;
}
public Set getStudents()
{
  return this.students;
}
}

　　可以看出，在Course类中也包含了两个属性，id和name，它的属性和表Courses的字段是一一对应的，并且类型一致。

　　书写好了持久对象，接下来的任务就是书写对象、关系映射描述。在hibernate/WEB-INF/classes目录下新建一个Course.hbm.xml描述文件，内容如例程4所示。

　　例程4 Course.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class
        name="com.hellking.study.hibernate.Course"
        table="Courses"
        dynamic-update="false"
    >

        <id
            name="id"
            column="CourseId"
            type="string"
            unsaved-value="any"
        >
            <generator class="assigned"/>
        </id>

        <property
            name="name"
            type="string"
            update="true"
            insert="true"
            column="Name"
        />
    </class>
</hibernate-mapping>

　　在Course.hbm.xml映射文件中，指定了要映射的类和映射的表，并且指定了表的各个字段和Java对象中各个字段的映射关系，比如Course对象中的id属性对应了Courses表的courseId字段。

　　接下来的任务就是在hibernate.cfg.xml中指定这个映射关系。如下所示：

<session-factory>
…

<mapping resource="Course.hbm.xml"/>
</session-factory>

　　编写业务逻辑

　　到此，我们已经封装了一个名为Courses的表，并且配置完成。接下来的任务就是在Web应用开发中使用它们，为了演示在Hibernate中对数据库的不同类型的操作，我们开发的Web应用有以下的功能：
　　增加一个Course；
　　删除一个Course；
　　按照Course的名字进行模糊搜索；
　　查看系统中所有的Course。

　　虽然我们可以直接在JSP中使用hibernate，但是往往我们不这样，而是把这些业务逻辑封装在JavaBean中，然后在JSP中通过调用JavaBean以访问Hibernate封装的对象。

　　由于访问通过使用hibernate有一些共性的操作，在这里我们把这些共性的操作封装在一个专门的类中，这样其它的类可以继承它，如例程5所示。

　　例程5 HibernateBase.java

package com.hellking.study.hibernate;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import java.util.*;
import java.io.IOException;
import java.io.PrintWriter;

public abstract class HibernateBase
{
protected SessionFactory sessionFactory;//会话工厂，用于创建会话
    protected Session session;//hibernate会话
    protected Transaction transaction; //hiberante事务

    public HibernateBase()throws HibernateException
    {
    this.initHibernate();
    }
    // 帮助方法
    protected void initHibernate()
        throws HibernateException {

        // 装载配置，构造SessionFactory对象
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    /**
     *开始一个hibernate事务
     */
    protected void beginTransaction()
        throws HibernateException {

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    /**
     *结束一个hibernate事务。
     */
    protected void endTransaction(boolean commit)
        throws HibernateException {

        if (commit) {
            transaction.commit();
        } else {
           //如果是只读的操作，不需要commit这个事务。
            transaction.rollback();
        }
         session.close();
    }
}

　　下面编写业务逻辑类，新建一个名为CourseBean的JavaBean，并且CourseBean继承HibernateBase类，代码如例程6所示。

　　例程6 CourseBean.java

package com.hellking.study.hibernate;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import java.util.*;

/**
*和course相关的业务逻辑
*/
public class CourseBean extends HibernateBase
{
public CourseBean()throws HibernateException
{
  super();
}
/**
*增加一个Course
*/
public void addCourse(Course st)throws HibernateException
{
  beginTransaction();
         session.save(st);
         endTransaction(true);
    }

    /**
     *查询系统中所有的Course，返回的是包含有Course持久对象的Iterator。
     */
    public Iterator getAllCourses()throws HibernateException
    {
     String queryString = "select courses from Course as courses";
        beginTransaction();
        Query query = session.createQuery(queryString);
        Iterator it= query.iterate();
        return it;
    }

    /**
     *删除给定ID的course
     */
    public void deleteCourse(String id)throws HibernateException
    {
     beginTransaction();
     Course course=(Course)session.load(Course.class,id);
     session.delete(course);
     endTransaction(true);
     }

    /**
     *按course的名字进行模糊查找，返回的是包含有Course持久对象的Iterator。
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
      String queryString = "select c from Course as c where c.name like :name" ;
         beginTransaction();
         Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }
}

　　在CourseBean封装了4个业务方法，你可以根据情况增加其它的业务方法。在CourseBean中，通过Hibernate来操作潜在的数据库资源。

　　要保存Course数据到数据库，可以通过：

　　session.save(Course);

　　方法来保存，它相当于使用在JDBC中执行以下语句：

　　Connection con=…
　　Statement stmt=con.createStatement();
　　stmt.executeUpdate("insert into courses values('"+course.getId(),+"','"+course.getName()+"')");
　　con.close();

　　可以看出，通过使用Hibernate，可以大大减少数据访问的复杂度。

　　在JSP中调用业务逻辑

　　添加数据

　　CourseBean这个业务对象封装了和Hibernate的交互关系，从而使JSP和Hibernate关系的解藕。我们来看测试主页面的部分代码，如例程7所示。

　　例程7 测试Hibernate开发的应用（course.jsp）

<%@ page import="java.sql.*,java.util.*" errorPage="error.jsp"%>
<jsp:useBean id="course" class="com.hellking.study.hibernate.Course" scope="page">
<jsp:setProperty name="course" property="*"/>
</jsp:useBean>
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
<html><body><center>
<%
try
{
if(course.getId().equals(null)||course.getId().equals(""));
else courseBusiness.addCourse(course);

%>
成功添加了Course：<br>
name：<%=course.getName()%>
Id:<%=course.getId()%>
<%
}
catch(Exception e)
{
}
%>

<hr>
<br>::增加一个course::<br>
<form action="course.jsp" method="get" name="add">
id:<input type=text name="id"><br>
name:<input type=text name="name"><br>
<input type=submit value="submit"><br>
</form>
<hr>
::按名字模糊查找::<br>
<form action="queryCourse.jsp" method="get" name="queryByName">
name:<input type=text name="name"><br>
<input type=submit value="query"><br>
</form>
<hr>
::删除一个Course::<br>
<form action="deleteCourse.jsp" method="get" name="queryByName">
id:<input type=text name="id"><br>
<input type=submit value="delete"><br>
</form>
<hr>
<a href=viewAll.jsp>::查看所有Course::<a>
</body>
</html>

　　首先通过一个值对象Course（这个类正好是Hibernate使用的持久对象，这里作为值对象来传递数据）接收获得的参数，然后 CourseBean的addCourse(Course)方法把数据保存到数据库。可以看出，通过使用Hibernate，把数据从表单中添加到数据库非常简单。

　　查询

　　下面来看模糊查找的JSP代码，如例程8所示。

　　例程8 按名字模糊查找Course

<%@ page import="java.sql.*,java.util.*,com.hellking.study.hibernate.Course" errorPage="error.jsp"%>
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
<% try
{
   Iterator it=courseBusiness.getSomeCourse((String)request.getParameter("name"));
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
}
catch(Exception e)
{
    out.println(e.getMessage());
   }
%>
….

　　它实际上调用的是CourseBean的Iterator getSomeCourse(String name)方法。我们来回顾一下这个方法中的代码：

　　/**
     *按course的名字进行模糊查找
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
      String queryString = "select c from Course as c where c.name like :name" ;
        beginTransaction();
        Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }

　　在查询前，首先调用beginTransaction方法启动新的Hibernate事务，然后创建一个Query对象，在创建这个对象时，同时指定查询的语句。

　　注意，在查询语句：

　　select c from Course as c where c.name like :name"

　　中，它虽然和普通的SQL语句相似，但是不同，在数据库中，使用的表的名字是Courses，而在这个查询语句中使用的是Course，它和持久对象的名字一致，也就是说，这个查询的概念是查询持久对象，而不是数据库的记录。

　　创建了查询对象Query后，需要设置查询的参数，它和在JDBC中PreparedStatement对象中设置参数的方法相似。通过 "Iterator it= query.iterate()"语句来执行查询，并且返回一个Iterator对象。在这里使用了Hibernate提供的查询机制，一般的JDBC查询返回的是ResultSet对象，而这里返回的是包含了CourseBean对象的Iterator。

　　要查询系统中所有的Course，也同样非常简单，可以通过例程9所示的代码实现。

　　例程9 查询数据库中所有的Course

…
<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
<% try
{
   Iterator it=courseBusiness.getAllCourses();
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
}
catch(Exception e)
{
    out.println(e.getMessage());
   }
%>
…

　　实际上调用的是CourseBean的getAllCourses方法，它和getSomeCourse方法机制一样，就不再介绍了。

　　删除数据

　　在JSP中，使用以下的代码来执行删除操作。

　　例程10 删除数据库中Courses表的记录

<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
…
删除id为：<%=request.getParameter("id")%>的course：:::<br>

<% try
{
courseBusiness.deleteCourse(request.getParameter("id"));
out.println("删除成功");
}
catch(Exception e)
{
out.println("不存在这个记录");
}
%>

　　我们来看CourseBean中执行删除操作的具体代码：

　　/**
     *删除给定ID的course
     */
    public void deleteCourse(String id)throws HibernateException
    {
    beginTransaction();
    Course course=(Course)session.load(Course.class,id);
    session.delete(course);
    endTransaction(true);
     }

　　在这个方法中，首先开始一个事务，然后通过session.load(Course.class,id)方法来装载指定ID的持久对象，接下来通过"session.delete(course)"来删除已经装载的course，并且结束Hibernate事务。

　　总结

　　下面总结一下使用Hibernate的开发过程：

　　1、配置Hibernate（一次即可）；
　　2、确定数据表；
　　3、创建持久对象；
　　4、编写对象和数据表的映射描述；
　　5、编写和业务逻辑。

　　实际上，上面的过程和使用EJB没有什么区别：在使用EJB时，首先当然也是配置环境，初始化数据表；然后创建实体Bean（对象于 Hibernate的持久对象）；接下来编写部署描述符（ejb-jar.xml，厂商专有的部署描述），在这些部署描述符里，指定了EJB和数据表的映射关系，如果多个实体Bean存在关联关系，需要描述它们之间的关系，这些描述对应于Hibernate中持久对象的描述，如 Course.hbm.xml；往往我们并不在应用程序中直接操作实体Bean，而是通过业务对象（如会话Bean）来操作，这里的会话Bean可以简单的和Hibernate中执行业务逻辑的JavaBean对应。这里只是简单的类比，不是绝对的，比如我们同样可以在会话Bean中访问 Hibernate持久对象，也就是说使用Hibernate，同样可以把业务逻辑放在会话Bean中。

　　通过本文的学习，相信读者对Hibernate已经有了初步的认识，并且能够使用Hibernate开发简单的应用。在下一篇中，我们将学习怎么使用Hibernate来为复杂的数据表进行映射，并且维护它们之间的关系。

posted @ 2005-08-18 01:29 我的JAVA 阅读(208) | 评论 (2) | 编辑收藏

在配置jsp开发环境的过程中会碰到不少问题，感谢网上的许多前辈的经验总结，作者cl41的JSP连接Mysql数据库攻略和作者Saulzy的 MySQL学习笔记等文章对我来说简直是雪中送碳，为了帮助象我一样的初学者在此总结了不少作者的经验，非常感谢他们的无私奉献精神，也希望更多的人把这种精神发扬光大，呵呵，再次对所参考文章的作者表示最崇高的敬意！
以下软件下载连接地址无法显示的话，请直接到官方网站下载即可！

软件下载
Mysql
下载版本：mysql-4.1.13-win32.zip(Windows downloads)
http://dev.mysql.com/downloads/mysql/4.1.html

JDBC驱动
下载版本：mysql-connector-java-3.1.10.zip
http://dev.mysql.com/downloads/connector/j/3.1.html

下载j2sdk
下载版本：jdk-1_5_0_04-windows-i586-p.exe
http://java.sun.com/j2se/1.5.0/download.jsp

下载tomcat
下载版本: jakarta-tomcat-5.5.9.exe
http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi

安装,配置j2sdk：

执行j2sdk安装程序，按默认设置进行安装，也可自定义路径，但需修改下面的配置

配置j2sdk:

配置环境变量:

我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量：
JAVA_HOME=C:/Program Files/Java/jdk1.5.0_04
CLASSPATH=%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;
path=%JAVA_HOME%/bin;%SystemRoot%/system32;%SystemRoot%;%SystemRoot%/System32/Wbem

写一个简单的java程序来测试J2SDK是否已安装成功：
public class hello
{
public static void main(String args[])
{
System.out.println("Hello");
}
}

将程序保存为文件名为hello.java的文件。

打开命令提示符窗口，进入到hello.java所在目录，键入下面的命令
javac hello.java
java hello
此时若打印出来hello则安装成功，若没有打印出这句话，仔细检查以上配置是否正确。
注意系统文件夹选项中应确定“隐藏已知文件类型的扩展名”不勾选（我的电脑—工具—查看）

安装,配置tomcat
执行tomcat安装程序，按默认设置进行安装，也可自定义路径，但需修改下面的配置

我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量
CATALINA_HOME=C:/Program Files/Apache Software Foundation/Tomcat 5.5
CATALINA_BASE=C:/Program Files/Apache Software Foundation/Tomcat 5.5

修改环境变量中的classpath，把tomat安装目录下的common/lib下的servlet-api.jar添加到classpath中去，
修改后的classpath如下：
classpath=%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;C:/Program Files/Apache Software Foundation/Tomcat 5.5/common/lib/servlet-api.jar;

启动tomcat，在IE中访问http://localhost:8080，若看到tomcat的欢迎页面的话说明安装成功。

安装mysql
解压缩mysql-4.1.13-win32.zip，运行setup.exe
首先出现的是安装向导欢迎界面,直接点击“Next”
继续，选择安装类型,选择“自定义”custom安装，然后点“Next”下一步，出现自定义安装界面
选择安装路径：C:/MySQL Server 4.1(可自定义)
点“OK”返回到自定义安装界面，路径已改为设置的路径
点“Next”，准备开始安装
点“Install”开始安装
完成后出现创建MySQL.com帐号的界面
如果是首次使用MySQL，选“Create anew free MySQL.com accout”
点“Next”，输入你的Email地址和自己设定的用于登录MySQL.com的密码
填完后点“Next”进入第二步
填写姓名等相关信息，填完点“Next”，进入第三步
填完电话号码、公司名称等信息后，点“Next”，
然后出现预览你刚才填的信息的界面，点“Next”出现安装完成界面
注意，这里有个配置向导的选项（Configure the MySQL Server now），
建议勾选立即配置你的MySQL。许多说安装完MySQL后无法启动，原因就在于没有配置MySQL。
点击“Finish”完成安装，并开始配置MySQL
点“Next”，进入配置类型选择页面。选“Detailed configuration”(详细配置)
点“Next”，进入服务类型选择页面。选“Developer Machine”（开发者机器），这样占用系统的资源不会很多
点“Next”后，进入数据库用法选择页面。选择“Multifunctional Database”
点“Next”，进入选择InnoDB数据存放位置页面
不用更改设置，直接放在Installation Path安装目录里即可，然后点“Next”，选择MySQL的同时联接数
选择“Manual Setting”，设置为100(根据自己需要，酌情设置)
点“Next”，配置MySQL在TCP/IP通讯环境中的端口选择默认的3306端口即可。
点“Next”，选择MySQL中的字符设置
注意，这里的选择将会影响你是否能在MySQL中使用中文。选择gb2312字符集以便支持简体中文
点“Next”，设置Windows服务选项
注意，这里的选择很关键。
“Install As Windows Service”一定要勾选，这是将MySQL作为Windows的服务运行。
“Service Name”就用默认的“MySQL”
下面的“Launch the MySQL Server automatically”一定要勾选，这样Windows启动时，MySQL就会自动启动服务，要不然就要手工启动MySQL。
许多人说安装MySQL后无法启动、无法连接、出现10061错误，原因就在这里。
点“Next”，设置根帐号root的登录密码
“Modify Security Settings”是设置根帐号的密码，输入你设定的密码即可。
“Create An Anonymous Account”是创建一个匿名帐号，这样会导致未经授权的用户非法访问你的数据库，有安全隐患，建议不要勾选。
点“Next”，MySQL配置向导将依据你上面的所有设定配置MySQL，以便MySQL的运行符合你的需要
点“Execute”开始配置，当出现“Service started successfully”时，说明你的配置完成，MySQL服务启动成功
点“Finish”完成，整个MySQL的配置完成，剩下的就是用MySQL客户端连接MySQL服务器，然后使用了。

安装JDBC驱动：
解压缩mysql-connector-java-3.1.10.zip
将要使用的是mysql-connector-java-3.1.10-bin-g.jar和mysql-connector-java-3.1.10-bin.jar

配置
在C:/Program Files/Java目录下建立mysqlforjdbc子目录，进入该目录将mysql-connector-java-3.1.10-bin.jar到该目录下
进入C:/Program Files/Java/jdk1.5.0_04/lib目录将mysql-connector-java-3.1.10-bin-g.jar拷贝到该目录下
然后配置classpath，追加%JAVA_HOME%/lib/mysql-connector-java-3.1.10-bin-g.jar;C:/ Program Files/Java/mysqlforjdbc/mysql-connector-java-3.1.10-bin.jar;到该环境变量中去
追加以后环境变量如下：
CLASSPATH=%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;C:/Program Files/Apache Software Foundation/Tomcat5.5/common/lib/servlet-api.jar;%JAVA_HOME%/lib/mysql-connector-java-3.1.10-bin-g.jar;C:/Program Files/Java/mysqlforjdbc/mysql-connector-java-3.1.10-bin.jar;
配置这个的目的是让java应用程序找到连接mysql的驱动．

查看并启动MySQL服务
在Windows XP下安装完MySQL后，它就已经自动启动服务了，并且在开始菜单中有其客户端的快捷方式连接
可以通过Windows的服务管理器查看。“开始”－“运行”，输入“services.msc”，回车。
弹出Windows的服务管理器，然后就可以看见服务名为“mysql”的服务项了，其右边标明“已启动”
在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
输入安装是设置的密码即可

数据库的使用

Mysql安装完毕以后，在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
输入安装时设置的密码

使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号)
显示数据库：show databases;
使用数据库：use 数据库名；

建库
在mysql里建一个数据库first，以及在数据库里建一个表about
命令：create database first;

为数据库设置权限（用户和密码）
命令：grant all privileges on first.* to test@localhost identified by “123456”;
当你执行完这个命令以后，只要你再以用户名：test,密码：123456登录时你就只可以对first这个数据库操作，这样避开使用root
输入命令：use first;
使用first数据库；

在first库中建表
命令：create table about(id int(8) primary key,name varchar(10));

在表中假如数据：
命令：insert into about values('xyw1026','laojiang');

退出
命令：exit

JSP连接mysql
在C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps目录下建立子目录myapp
进入C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/myapp目录下
用记事本编写一个文件保存为first.jsp
代码如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//first为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from first";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>

在浏览器中输入：
http://127.0.0.1:8080/myapp/first.jsp
若出现：
id|num
0 |laojiang

数据库操作成功，恭喜你

表示配置成功

进入C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/myapp目录
在myapp目录下新建一个目录WEB-INF，注意，目录名称是区分大小写的；
在WEB-INF下用记事本新建一个文件，命名为web.xml，内容如下：

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
</web-app>

在myapp下用记事本新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：

重启Tomcat
打开浏览器，输入http://localhost:8080/myapp/index.jsp
看到当前时间的话说明成功安装。

建立自己的Servlet：
用记事本新建一个servlet程序，文件名为HelloWorld.java，文件内容如下：

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
{

response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><head><title>");
out.println("This is my first Servlet");
out.println("</title></head><body>");
out.println("<h1>Hello,World!</h1>");
out.println("</body></html>");

}
}

编译
将HelloWorld.java剪切到C:/Program Files/Apache Software Foundation/Tomcat5.5/common/classes目录下
命令行方式下输入：
cd C:/Program Files/Apache Software Foundation/Tomcat5.5/common/classes
javac HelloWorld.java
用javac HelloWorld.java来编译这个文件，如果出现无法import javax.servlet.*
则将C:/Program Files/Apache Software Foundation/Tomcat5.5/common/lib目录下的servlet-api.jar文件拷贝并添加到
C:/Program Files/Java/jre1.5.0_04/lib/ext目录中去就可以了

然后在C:/Program Files/Apache Software Foundation/Tomcat5.5/common/classes下会产生一个编译后的servlet文件：HelloWorld.class
用记事本打开C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/ROOT/WEB-INF目录下的web.xml如下所示，添加后的内容如下:
.
.
.

    <servlet>
        <servlet-name>org.apache.jsp.index_jsp</servlet-name>
        <servlet-class>org.apache.jsp.index_jsp</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>org.apache.jsp.index_jsp</servlet-name>
        <url-pattern>/index.jsp</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/servlet/HelloWorld</url-pattern>
    </servlet-mapping>

</web-app>

这段话中的servlet这一段声明了你要调用的Servlet，而servlet-mapping则是将声明的servlet“映射”到/servlet/HelloWorld地址上

启动Tomcat，启动浏览器，输入http://localhost:8080//servlet/HelloWorld 如果看到输出HelloWorld！就说明编写的servlet成功了。
注意：修改了web.xml以及新加了class，都要重启Tomcat

也可以在自己创建的目录下测试如：
将HelloWorld.class拷贝到C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/myapp/WEB-INF/classes目录下
其中classes目录若没有就创建一个
用记事本打开C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/myapp/WEB-INF目录下的web.xml如下所示，修改后的内容如下:
.
.
.


    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/servlet/HelloWorld</url-pattern>
    </servlet-mapping>

</web-app>

启动Tomcat，启动浏览器，输入http://localhost:8080/myapp/servlet/HelloWorld 如果看到输出HelloWorld！就说明编写的servlet成功了。
注意：修改了web.xml以及新加了class，都要重启Tomcat

建立自己的javaBean：

用记事本新建一个java程序，文件名为TestBean.java，文件内容如下：
package test;
public class TestBean{
private String name = null;
public TestBean(String strName_p){
this.name=strName_p;
}
public void setName(String strName_p){
this.name=strName_p;
}
public String getName(){
return this.name;
}
}

编译
将TestBean.java放在c:/test下，使用如下命令编译：
C:/test>javac TestBean.java
然后在c:/Test下会产生一个编译后的bean文件：TestBean.class
将TestBean.class文件剪切到C:/Program Files/Apache Software Foundation/Tomcat5.5/webapps/myapp/WEB-INF/classes/test目录下，
若无某些子目录则创建一个

新建一个TestBean.jsp文件，文件内容为：
<%@ page import="test.TestBean" %>
<html><body><center>
<%
TestBean testBean=new TestBean("This is a test java bean.");
%>
Java bean name is: <%=testBean.getName()%>
</center></body></html>

重启Tomcat，启动浏览器，输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean
就说明编写的javaBean成功了。

（特别注明：本文内容均来自互联网）

posted @ 2005-08-17 01:06 我的JAVA 阅读(82) | 评论 (0) | 编辑收藏

webwork是个优秀的开源框架，特别是其拦截器机制，我认为是整个系统最大的亮点，可在其上面做大量文章
我的开发环境为Eclipse3.0.1+lomoz，数据库我用的是MySQL4.0.12,当然，也用到了mysqlcc,服务器我用的是tomcat4.0.3和tomcat4.1
请先下载webwork.,spring.,hibernate，并把JAR文件放到web-inf的lib目录里面。同时，请下载http://unc.dl.sourceforge.net/sourceforge/aopalliance/aopalliance.zip ，将aopalliance.jar放到lib目录里面。
还有webwork2-spring.jar，以及mysql的驱动都要下载并放到lib里面，缺一不可
然后是配置log4j，如果没有正确配置log，TOMCAT将不能正常发布你的项目。配置log4j很简单，
在web-inf/classes下建立一个log4j.properties的文件，内容如下
    log4j.rootLogger=INFO, A1 , R
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
    log4j.appender.R=org.apache.log4j.RollingFileAppender
    log4j.appender.R.File=d:/Tomcat 4.1/webapps/demo/logs/log4j.log
    log4j.appender.R.MaxFileSize=100KB
    log4j.appender.R.MaxBackupIndex=1
    log4j.appender.R.layout=org.apache.log4j.PatternLayout
    log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
其中log4j.appender.R.File这一项请按照你TOMCAT的安装位置进行修改，关于log4j的详细内容，推荐大家看Hilton的学习笔记以及IBM网站上的相关文章.
好了，开始我们的webwork之旅了。首先是配置web.xml文件
<?xml version="1.0" ?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
       <listener>
              <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
       </listener>
       <listener>
              <listener-class>com.atlassian.xwork.ext.ResolverSetupServletContextListener</listener-class>
       </listener>
    <servlet>
        <servlet-name>webwork</servlet-name>
        <servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>webwork</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

     <taglib>
        <taglib-uri>webwork</taglib-uri>
        <taglib-location>/WEB-INF/webwork.tld</taglib-location>
    </taglib>

</web-app>

我们配置了两个监听器，还有一个servlet，这个servlet负责action的转发工作，关于action的详细工作原理，大家可以参看xwork的源代码
在接下来配置之前，我想大概说一下我想实现的功能，就是简单的往mysql的一个表中插入一些数据
首先我用Middlegen-Hibernate和hibernate-extensions（我没用eclipse的hibernate插件，我喜欢用这两样工具来生成）生成了表对应的hbm.xml文件和两个JAVA类，表的字段是"tablename,fieldname,chinesename", 表名是
"systable",其中tablename,fieldname做双主键，这样，生成出来的类应该是两个，一个PK主键类和主类本身，我把他们加入到了我的项目中.
然后我做了一个接口类
package com.cz.struct;

/**
* @author tijichen
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public interface SystableDAO {
  public abstract void insert(Systable data);
}
然后是实现类
package com.cz.struct;
import net.sf.*;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
/**
* @author tijichen
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class SysTableDAOImp extends HibernateDaoSupport implements
SystableDAO{
  public void insert(Systable data)
  {
   this.getHibernateTemplate().save(data);
  }
}
为什么要用接口类？因为spring会用到JAVA的动态代理，关于这部分，大家可以看xiaxin的spring指南
在insert 方法中，我直接调用了spring提供的hibernate模板方法，真是方便呀

然后是 spring的配置了，请在web-lib/下建立applicationContext.xml文件，内容如下
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource"
   destroy-method="close">
   <property name="driverClassName">
    <value>org.gjt.mm.mysql.Driver</value>
   </property>
   <property name="url">
    <value>jdbc:mysql://localhost/mystructs</value>
   </property>
   <property name="username">
    <value>chenzhi</value>
   </property>
   <property name="password">
    <value>1</value>
   </property>
</bean>
<bean id="sessionFactory"
   class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
   <property name="dataSource">
    <ref local="dataSource" />
   </property>
   <property name="mappingResources">
    <list>
     <value>com/cz/struct/SysTable.hbm.xml</value>
    </list>
   </property>
   <property name="hibernateProperties">
    <props>
     <prop key="hibernate.dialect">
      net.sf.hibernate.dialect.MySQLDialect
     </prop>
     <prop key="hibernate.show_sql">
      true
     </prop>
    </props>
   </property>
</bean>
<bean id="transactionManager"
   class="org.springframework.orm.hibernate.HibernateTransactionManager">
   <property name="sessionFactory">
    <ref local="sessionFactory" />
   </property>
</bean>
<bean id="systableDAO" class="com.cz.struct.SysTableDAOImp">
   <property name="sessionFactory">
    <ref local="sessionFactory" />
   </property>
</bean>
<bean id="systableDAOProxy"
   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property>
   <property name="target">
    <ref local="systableDAO" />
   </property>
   <property name="transactionAttributes">
    <props>
      <prop key="insert*">PROPAGATION_REQUIRED</prop>
      <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
      <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
</bean>
</beans>
在这个配置文件里面，我们设置了datasource/sessionfactory以及spring的动态代理，还有hibernate所需要的XML映射文件路径
然后是配置xwork.xml
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
<include file="webwork-default.xml" />
  <package name="default" extends="webwork-default"
   externalReferenceResolver="com.atlassian.xwork.ext.SpringServletContextReferenceResolver">
  <interceptors>
  <interceptor name="reference-resolver"
  class="com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor" />
  <interceptor-stack name="vxStack">
  <interceptor-ref name="params" />
  <interceptor-ref name="model-driven" />
  <interceptor-ref name="reference-resolver" />
  </interceptor-stack>
  </interceptors>
<action name="Test" class="com.cz.struct.TestAction">
<external-ref name="systableDAO">systableDAOProxy</external-ref>
<result name="success" type="dispatcher">
<param name="location">/index.jsp</param>
</result>

<interceptor-ref name="vxStack" />
</action>
</package>
</xwork>
在配置action的external-ref的时候我遇到了一个不大不小的玩笑，一般编辑XML的时候我都是在editplus里面编辑的
，最开始我写成
<external-ref name="systableDAO">
systableDAOProxy
</external-ref>
结果系统提示找不到叫systableDAOProxy这个名字的bean，结果一查，发现旁边不能加上空格和tab，哎。。肯定是返回串的时候没加trim
的后果
好了，最后是我们的TestAction.java
package com.cz.struct;
import com.opensymphony.xwork.*;
import com.opensymphony.webwork.*;
import java.util.*;
/**
* @author tijichen
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class TestAction extends ActionSupport
{
private SystableDAO systabledao;

String testname=null;
public void setSystableDAO(SystableDAO dao)
{
  this.systabledao=dao;
}
public SystableDAO getSystableDAO()
{return this.systabledao;}
    public String execute() throws Exception {
    testname="executeing";
    SystablePK pk=new SystablePK();
    Systable newdata=new Systable();
    pk.setFieldName("test");
    pk.setTableName("test3");
    newdata.setComp_id(pk);
    newdata.setChineseName("tets");

    systabledao.insert(newdata);
        return Action.SUCCESS;
    }

}
ok,编译打包，然后在浏览器地址栏中输入http://localhost:8080/你的发布目录/Test.action
看看，是不是数据库里面多出了一条数据了？
至于其他，比如从页面提交的值插入数据库等等，这里都不多说了，webwork自带的sample就是最好的参考资料

package zmsjdbc;
import java.sql.*;
public class mysql1
{

private String url="jdbc:mysql://localhost:3306/beyond";
//先下载MYSQL 驱动 mm.mysql-2.0.4-bin.jar 放在D:/JBuilder9/jdk1.4/jre/lib/ext 下

private   String user="root";
private   String pwd="";
public   Connection getcon()
{
   Connection con;
    try
    { //加载驱动程序
      Class.forName("org.gjt.mm.mysql.Driver").newInstance();
      //创建连接
      con=DriverManager.getConnection(url,user,pwd);
      return con;
     }

     catch(ClassNotFoundException e)
     {
         System.out.println("加载驱动程序出错");
     }

     catch(Exception e)
     {
       System.out.println("出现了好大的错误");
     }

     return null;
}
public ResultSet executeSql(String sqlstr)
   {
     Connection conn;
     Statement stmt;

      try
      {
        conn=getcon();
        stmt=conn.createStatement();
        ResultSet rs=stmt.executeQuery(sqlstr);

        return rs;
      }
      catch(SQLException e)
      {
        System.out.print("获取数据集时出现错误");
      }
      return null;
   }

public static void main(String[] args)
{
    mysql1 mysql11 = new mysql1();
    Connection conn;
    ResultSet rs;
   rs= mysql11.executeSql("select * from zms1");
    try
    {
      while(rs.next())
      {
        System.out.println(rs.getString("name"));
      }
    }
    catch(Exception e)
    {
       System.out.println(e.getMessage());
    }

}

Webwork2+Spring+Hibernate体验

转自:http://www.blogjava.net/lgplhk/

2005年8月26日

hibernate+spring

2005年8月25日

spring+hibernate开发网站

2005年8月24日

史上最简单的Hibernate入门简介

Hibernate快速入门

2005年8月18日

jsp+tomcat+mysql&sevlet&javabean配置全过程选择自 xyw1026 的 Blog

2005年8月17日

webwork2+spring+hibernate入门完全配置指南(1)(原创) 选择自 tijichen 的 Blog

JDBC之 MYSQL 选择自 mfc2003 的 Blog