Struts2+Spring+hibernate整合

Struts 2,Spring 2,Hibernate 整合 

整合完毕的项目下载地址http://download.csdn.net/detail/woaiwoaini121/4599429 

下载以后导入到myeclipse9.0中可直接使用

开发工具Eclipse
1.首先建立一个web工程，咱们暂且启明为s2sh 
这里咱们选择的是Java EE 5.0 

 

finish 
2.向工程加入hibernate支持，这里咱们使用的是hibernate 3.2 

 

默认就能够，不要忘记将jar包加入到/WebRoot/WEB-INF/lib 

 

接着next 

 

实际上这里的hibernate.cfg.xml不起做用，由于该配置文件的内容由后面的spring配置文件进行管理，咱们能够在建立以后将其删除 
默认next 

 

咱们根本不用hibernate.cfg.xml,因此这里根本不须要进行数据库配置，固然默认也无所谓。 
继续next 

 

sessionFactory咱们在以后也会直接使用spring为咱们提供的，因此这里不须要建立。 
finish 
3.向工程加入spring支持，这里咱们使用的是spring2 

 

这里咱们选择的是spring2， 

 

不要忘记选中这5个库包： 
Spring 2.0 AOP Libraries 
Spring 2.0 Core Libraries 
Spring 2.0 Persistence Core Libraries 
Spring 2.0 Persistence JDBC Libraries 
Spring 2.0 Web Libraries 
也不要忘记将jar包加入到/WebRoot/WEB-INF/lib。 
next 

 

这里咱们不须要Enable AOP 因此不须要选中 
不要忘记将配置文件applicationContext.xml指定在/WEB-INF目录下，否则服务器启动时没法加载 
next 

 

这里的sessionFactory咱们也不须要，以后会手动配置。 
finish 
4.加入struts2支持，因为MyEclipse并无加入Struts2的支持，因此咱们须要手动导入相关jar包。 
这里咱们使用的是struts 2.0.11版本 
须要的相关jar包以下： 
freemarker-2.3.8.jar 
ognl-2.6.11.jar 
struts2-core-2.0.11.jar 
xwork-2.0.4.jar 
struts2-spring-plugin-2.0.11.jar 

4.进行相关文件的配置 
首先咱们须要在src下加入struts的配置文件struts.xml 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <package name="s2sh" extends="struts-default">
    </package>
</struts>

接下来咱们配置web.xml 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- 配置struts2的过滤器 -->
<filter>
    <filter-name>struts2</filter-name>
    <filter-class>
        org.apache.struts2.dispatcher.FilterDispatcher
    </filter-class>
</filter>

<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!-- 配置spring的监听器 -->
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

到目前为止咱们的整合工做已经完成。咱们能够将该工程打包，以备下次直接使用。 
这里由一个问题就是若是采用myeclipse加载hibernate和spring的lib包形式发布项目的时候会出现异常，咱们能够手动去掉一个asm-2.2.3jar便可。 

5.下面咱们作一个简单的应用来验证。 
(1)首先咱们使用的是mysql，不要忘记将mysql-jdbc的jar包导入到咱们的工程中 
咱们建立s2sh数据库，并建立表person 

-- Table "person" DDL
CREATE TABLE `person` (
  `id` int(11) NOT NULL,
  `name` varchar(20) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

(2)首先咱们建立test.s2sh.bean包,在下面建立咱们person表对应的Entity Bean及其映射文件 
Person.java 

package test.s2sh.bean;

public class Person {
    private Integer id;
    private String name;
    private int age;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Person.hbm.xml 

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

<hibernate-mapping>
    <class name="test.s2sh.bean.Person" table="person">
        <id name="id" type="java.lang.Integer" column="id">
            <generator class="increment"></generator>
        </id>
        <property name="name" type="string" column="name"
         length="20"></property>
         <property name="age" type="java.lang.Integer" column="age"></property>
    </class>
</hibernate-mapping>

(3)在spring配置文件applicationContext.xml配置hibernate的链接数据库信息及sessionFactory建立方式 

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<!-- apache.dbcp链接池的配置 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/s2sh?useUnicode=true&amp;characterEncoding=UTF-8"></property>
    <property name="username" value="root"></property>
    <property name="password" value=""></property>
    <!-- 最大活动链接数 -->
    <property name="maxActive" value="100"></property>
    <!-- 最大可空闲链接数 -->
    <property name="maxIdle" value="30"></property>
    <!-- 最大可等待链接数 -->
    <property name="maxWait" value="500"></property>
    <!-- 默认的提交方式（若是不须要事务能够设置成true，在实际应用中通常设置为false,默认为false） -->
    <property name="defaultAutoCommit" value="true"></property>
</bean>
<!-- 这里直接使用spring对hibernate3支持的sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <!-- hibernate方言等相关配置 -->
    <property name="hibernateProperties">
        <props>
            <prop key="connection.useUnicode">true</prop>
            <prop key="connection.characterEncoding">utf-8</prop>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
            <prop key="hibernate.show_sql">true</prop>
        </props>
    </property>
    <!-- hbm.xml的映射文件 -->
    <property name="mappingResources">
        <list>
            <value>test/s2sh/bean/Person.hbm.xml</value>
        </list>
    </property>
</bean>

</beans>

若是出现乱码问题，能够考虑以下解决方案 

<property name="hibernateProperties">
    <props>
        <prop key="connection.useUnicode">true</prop>
        <prop key="connection.characterEncoding">utf-8</prop>
        <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
        <prop key="hibernate.show_sql">true</prop>
    </props>
</property>

或者将url后面加入编码串,以下 

<property name="url" value="jdbc:mysql://localhost:3306/s2sh?useUnicode=true&amp;characterEncoding=UTF-8"></property>

注意 ： 这里个人数据库编码是utf-8 
具体那种方案好用你们能够尝试一下，我基本上直接将两种方式都加上了。 

(4)下面咱们开始写DAO层，首先建立test.s2sh.dao包放置Dao类的接口，建立test.s2sh.dao.impl包放置Dao类的实现。 
PersonDAO.java 

package test.s2sh.dao;

import java.util.List;

import test.s2sh.bean.Person;

public interface PersonDAO {
    void savePerson(Person p);
    void removePerson(Person p);
    Person findPersonById(Integer id);
    List<Person> findAllPersons();
    void updatePerson(Person p);
}

因为使用了spring，因此DAO的实现类咱们能够继承HibernateDaoSupport进行实现 
PersonDAOImpl.java 

package test.s2sh.dao.impl;

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import test.s2sh.bean.Person;
import test.s2sh.dao.PersonDAO;

public class PersonDAOImpl extends HibernateDaoSupport implements PersonDAO {

    public List<Person> findAllPersons() {
        String hql = "from Person p order by p.id desc";
        return (List<Person>)this.getHibernateTemplate().find(hql);
    }

    public Person findPersonById(Integer id) {
        Person p = (Person) this.getHibernateTemplate().get(Person.class, id);
        return p;
    }

    public void removePerson(Person p) {
        this.getHibernateTemplate().delete(p);
    }

    public void savePerson(Person p) {
        this.getHibernateTemplate().save(p);
    }

    public void updatePerson(Person p) {
        this.getHibernateTemplate().update(p);
    }

}

(5)下面咱们开始进行service层的设计，这里的service层仅是简单调用DAO层的的方法。 
一样是建立接口包(test.s2sh.service)，实现包和接口类(test.s2sh.service.impl)，实现类 
PersonService.java 

package test.s2sh.service;

import java.util.List;

import test.s2sh.bean.Person;

public interface PersonService {
    List<Person> findAll();
    void save(Person p);
    void delete(Person p);
    Person findById(Integer id);
    void update(Person p);
}

这里咱们须要使用spring的ioc将DAO诸如到service中，因此不要忘记在service实现类中加入DAO做为属性。 
PersonServiceImpl.java 

package test.s2sh.service.impl;

import java.util.List;

import test.s2sh.bean.Person;
import test.s2sh.dao.PersonDAO;
import test.s2sh.service.PersonService;

public class PersonServiceImpl implements PersonService {
    private PersonDAO personDAO;
    public void delete(Person p) {
        this.personDAO.removePerson(p);
    }

    public List<Person> findAll() {
        return this.personDAO.findAllPersons();
    }

    public Person findById(Integer id) {
        return this.personDAO.findPersonById(id);
    }

    public void save(Person p) {
        this.personDAO.savePerson(p);
    }

    public void update(Person p) {
        this.personDAO.updatePerson(p);
    }

    public PersonDAO getPersonDAO() {
        return personDAO;
    }

    public void setPersonDAO(PersonDAO personDAO) {
        this.personDAO = personDAO;
    }

}

(6)接下来咱们开始对action层进行设置，实际项目中的action可能会有不少，因此咱们这里须要对action进行分包，由于咱们这里针对Person进行操做，因此咱们建立test.s2sh.action.person. 
这里先作保存操做 
SavePersonAction.java 

package test.s2sh.action.person;

import test.s2sh.bean.Person;
import test.s2sh.service.PersonService;

import com.opensymphony.xwork2.ActionSupport;

public class SavePersonAction extends ActionSupport {
    private Person p;
    private PersonService service;
    public Person getP() {
        return p;
    }
    public void setP(Person p) {
        this.p = p;
    }
    public PersonService getService() {
        return service;
    }
    public void setService(PersonService service) {
        this.service = service;
    }

    public String execute() throws Exception {
        this.service.save(p);
        return this.SUCCESS;
    }

    public void validate() {
        if(p.getName()==null||"".equals(p.getName())){
            this.addFieldError("p.name", "name is not null");
        }
    }

}

下面建立一个保存人员的提交页面 
save.jsp 

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>

    <title>Save Person</title>

  </head>

  <body>
    <s:form action="savePerson">
        <s:textfield name="p.name" label="name"></s:textfield>
        <s:textfield name="p.age" label="age"></s:textfield>
        <s:submit></s:submit>
    </s:form>
  </body>
</html>

操做成功页面 
save-success.jsp 

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>Save OK</title>
  </head>

  <body>
    保存成功 <br>
  </body>
</html>

接下来咱们须要配置struts.xml,建立action 

<action name="savePerson" class="savePersonAction">
    <result name="success" type="redirect">/save-success.jsp</result>
    <result name="input">/save.jsp</result>
</action>

因为如今的action的建立已经由spring所接管，因此这里class里面使用的是别名，该别名与applicationContext.xml中的id对应. 

接下来咱们须要配置applicationContext的ioc。 

<bean id="personDAO" class="test.s2sh.dao.impl.PersonDAOImpl" scope="singleton">
    <!-- 因为该类是继承于HibernateDaoSupport，因此须要将sessionFactory注入 -->
    <property name="sessionFactory" >
        <ref bean="sessionFactory"/>
    </property>
</bean>
<bean id="personService" class="test.s2sh.service.impl.PersonServiceImpl">
    <property name="personDAO" ref="personDAO"></property>
</bean>
<bean id="savePersonAction" class="test.s2sh.action.person.SavePersonAction" scope="prototype">
    <property name="service" ref="personService"></property>
</bean>

这里说明一下spring中的单例与设计模式中的单例不一样，设计模式的单例是在jvm中只产生一个实例，而spring中的单例 
是针对每一个ioc容器来言，若是存在两个ioc容器，那么每一个ioc容器都会生成惟一的类实例 
将sessionFactory注入Dao中,这里的Dao来讲是无状态的，能够设置为单例singleton。这里的action是使用spring建立的。 
struts2与struts1的action有所不一样，由于struts2中的action中可能存在属性,这里是Person，因此struts2的action多是有状态的。 
若是是有状态的咱们就须要将scope设置成原型模式，即每次请求都新建一个action。 
否则可能会出现若是表单提交的第一次出错，以后就再也提交不过去了，值就是应为使用默认的singleton， 

当第一次的时候就将FieldError中加入了错误，每次都是这个action，始终带着这个错误，因此就提交不过去了。

S2SH整个项目的下载地址：http://download.csdn.net/detail/woaiwoaini121/4599429

下载以后能够直接使用。