public interface UserDAO {
  public abstract boolean isValidUser(String name,String password);
}
编写一个类继承该接口UserDAOImp.java
package SpringPack;

import org.springframework.orm.hibernate.support.*;
import net.sf.hibernate.SessionFactory;
import java.util.List;
import Hibernate.hibernateTest;
import net.sf.hibernate.*;

public class UserDAOImp extends HibernateDaoSupport implements UserDAO{

  public boolean isValidUser(String name,String pwd){
    hibernateTest t = null;
    try {
      t = new hibernateTest();
    }
    catch (HibernateException ex) {
      ex.printStackTrace();
    }
    if(t.checkUser(name,pwd)) return true;
    return false;
  }
}

然后编写一个Bean用来映射数据表的字段
package Hibernate;

public class user {
  private String username;
  private String password;
  public user() {
  }

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

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

  public String getUsername() {
    return username;
  }

  public String getPassword() {
    return password;
  }
}

编写hibernate.cfg.xml文件用于连接数据库的配置文件：
<?xml version='1.0' encoding='big5'?>
<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd ">

<hibernate-configuration>

    <session-factory>

        <property name="show_sql">true</property>

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="connection.url">jdbc:mysql://localhost/myDB</property>

        <property name="connection.username">root</property>

        <property name="connection.password">test</property>

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

    </session-factory>

</hibernate-configuration>


然后下面编写一个描述数据库映射表字段信息的mapping文件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>

    <class name="Hibernate.user" table="user">

        <id name="username" type="string" unsaved-value="null">
            <column name="username" sql-type="varchar(20)" />
            <generator class="uuid.hex"/>
        </id>

        <property name="password" type="string" column="password"/>

    </class>

</hibernate-mapping>
好了现在Hibernate已基本搭建出来了，下一步我们要用Spring来整合Hibernate 和Struts 操作步骤很简单编写一个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 name="/loginAction"
    class="StrutsPack.LoginAction"
    singleton="false">
  </bean>
</beans>
要整合Struts还要在Struts-config.xml文件中做一些修改如下:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd ">
<struts-config>
  <form-beans>
    <form-bean name="loginActionForm" type="StrutsPack.LoginActionForm" />
  </form-beans>
  <action-mappings>
    <action  name="loginActionForm" path="/loginAction" scope="session" type="org.springframework.web.struts.DelegatingActionProxy" validate="false">
      <forward name="Success" path="/success.jsp" />
      <forward name="Failure" path="/Failure.jsp" />
    </action>
  </action-mappings>
  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
  </plug-in>
</struts-config>
好了现在还要编写一个Hibernate的辅助文件如下:
package Hibernate;

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

public class hibernateTest {
  Session session;
  public hibernateTest()
  throws HibernateException{
    SessionFactory factory=new Configuration().configure().buildSessionFactory();
     session=factory.openSession();

  }
  public boolean checkUser(String name,String pwd){
  List count = null;
  try {
    Query q = session.createQuery(
        "select count(*) from user where username=? and password=?");
    q.setString(1, name);
    q.setString(2, pwd);
    count = q.list();
  }
  catch (HibernateException ex) {
    ex.printStackTrace();
  }
  ListIterator list=count.listIterator();
  Integer s=(Integer)list.next();
  if(s.intValue() > 0 ) return true;
  return false;
  }
}

然后就可以在LoginAction.java中调用了LoginAction.java文件如下:
package StrutsPack;

import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForm;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.Action;
import SpringPack.*;

public class LoginAction
    extends Action {
  private static final String SUCCESS="Success";
  private static final String FAILURE="Failure";

  private UserDAO userdao=new UserDAOImp();

  public ActionForward execute(ActionMapping mapping,
                               ActionForm actionForm,
                               HttpServletRequest servletRequest,
                               HttpServletResponse servletResponse) {
    LoginActionForm loginform = (LoginActionForm) actionForm;

    if(userdao.isValidUser(loginform.getUsername(),loginform.getPassword())){
    return mapping.findForward(SUCCESS);
    }
    return mapping.findForward(FAILURE);
  }

  public UserDAO getUserDAO() {
    return userdao;
}
public void setUserDAO(UserDAO userDAO) {
  this.userdao = userDAO;
}

}
至此JB开发一个简单的SSH就结束了感觉就是两个字麻烦！还是使用Eclispe开发方便!下面是具体的path:

　　Spring 框架

　　Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

　　☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
　　☆ Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
　　☆ Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
　　☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
　　☆ Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
　　☆ Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
　　☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

　　Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。