Struts2.0.11+ Hibernate3.6.0+Spring2.5.6的简单使用与配置
2011-03-23 21:28
483 查看
转载本人163博客，因工作时间只能访问技术站
http://chaoji-liangbin.blog.163.com/blog/static/2523921220101019114149974/
参考：http://ajava.org/course/open/12486.html
一 开发环境
MyEclipse6.5
JDK 1.6.10
Tomcat6.0
Struts2.0.11
Spring2.5.6
Hibernate3.6.0
用户可以在对应的官网下载对应的包。
Struts:
http://apache.freelamp.com/struts/binaries/struts-2.0.11.2-all.zip
Hibernate: http://nchc.dl.sourceforge.net/project/hibernate/hibernate3/3.6.0.Final/hibernate-distribution-3.6.0.Final-dist.zip
Spring: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.6-with-dependencies.zip
二 Struts的简单配置与使用
以一个普通的用户登录例子为例，
2.1 导入struts2包
新建web项目,命名为SSHProject,引入struts2必须的包：
2.2 修改web.xml文件
修改WEB-INF下的web.xml文件，增加struts2的过滤器
完整的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"> <welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<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>
</web-app>
2.3新建页面index.jsp
在webroot下新建一个index.jsp页面，内容如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用户登录</title>
</head>
<body>
<s:form action="login" name="form1">
<s:textfield name="username" label="username"></s:textfield>
<s:password name="password" label="password"></s:password>
<s:submit value="提交" label="submit"></s:submit>
<s:label name="feedback"></s:label>
</s:form>
</body>
</html>
其中，跳转动作名是login，，即点击提交按钮，根据struts的配置表（struts.xml，这个是需要自己配置的文件，会在下节介绍）动作名进行跳转并操作。
登陆成功页面success.jsp
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>登录成功</title>
</head>
<body>
登录成功。
</body>
</html>
失败的话跳转回index.jsp，并反馈信息。
2.4 添加struts.xml文件
在项目的src下，新建struts.xml文件，这是struts2的基本配置文件，struts2的跳转，异常等配置均在此，struts2的跳转亦是根据这个文件来跳转的。完整的内容如下：
<?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="example" extends="struts-default">
<action name="login" class="com.wenbin.example.Login">
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
注解：<struts>是基本的标签
<package name="example" extends="struts-default">标签是包名，需要继承struts-default.xml文件，写成extends="struts-default"
<action>是跳转动作，命名为login（这个名字是根据index.jsp的页面定义的表单form的action对应的），对应的class属性是指操作的类com.wenbin.example.Login，
<result>是结果，根据验证的结果，选择进行跳转。type=”redirect”表示重定向。
2.5 定义动作Login.java
根据struts配置，其是跳转到com.wenbin.example.Login，这个类处理的，所以新建com.wenbin.example包，再新建Login.java类，处理内容如下：
package com.wenbin.example;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.opensymphony.xwork2.ActionSupport;
import com.wenbin.entry.Sysuser;
public class Login extends ActionSupport {
private static final long serialVersionUID = 1L;
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() {
System.out.println("登录成功...");
System.out.println("用户名：" + username);
System.out.println("密码:" + password);
if (username.equals("liangbinny") && password.equals("123")) {
return SUCCESS;
} else {
super.addFieldError("feedback", "用户名或密码错误");
return ERROR;
}
}
@Override
public void validate() {
if (username == null || username.equals("")) { // 这种验证，对应返回input这个名的页面,必须在struts.xml中定义<result
// name="input">/index.jsp</result>这个属性
super.addActionError("用户名不能为空");
super.addFieldError("feedback", "用户名不能为空");
}
if (password == null || password.equals("")) {// 这种验证，对应返回input这个名的页面
super.addActionError("密码不能为空");
super.addFieldError("feedback", "密码不能为空");
}
}
}
2.6 定义sturts.properties
这个文件是用来定义struts的属性的，在src下，新建sturts.properties，内容如下：
struts.locale=en_GB
至此，struts基本配置完毕。启动tomcat并访问index.jsp，即可。完整项目图如下：
三 Hibernate的简单配置与使用
3.1 导入Hibernate包
在刚才那个项目下，继续添加Hibernate所需要的包，如下：
具体介绍如下：
hibernate3.jar-----------------------------核心类库
antlr-2.7.6.jar-----------------------------代码扫描器,用来翻译HQL语句
commons-collections-3.1.jar----------- Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大
dom4j-1.6.1.jar----------------------------是一个Java的XML API，类似于jdom，用来读写XML文件的
javassist-3.4.GA.jar----------------------- Javassist 字节码解释器
jta-1.1.jar------------------------------------标准的JTA API。
slf4j-api-1.6.1.jar
slf4j-nop-1.6.1.jar --------------这个包要自己去独立下载
class12是数据库驱动包
3.2 Hibernate配置文件配置
创建Hibernate配置文件。在src下新建hibernate.cfg.xml。这是hibernate连接数据库的配置文件。这里以连接Oracle为例，(假设数据库SID是Test,用户名和密码都是Test)，具体配置如下：
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
oracle.jdbc.driver.OracleDriver
</property>
<property name="connection.url">
jdbc:oracle:thin:@192.168.5.24:1521:Test
</property>
<property name="myeclipse.connection.profile">test</property><!-- 这个是你myeclipse的数据库连接视图里建立的连接名，可有可无 -->
<property name="connection.username">test</property>
<property name="connection.password">test</property>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property> <!-- 这个表示数据库连接的方言 -->
<property name="show_sql">true</property> <!-- 是否显示sql语句 -->
<mapping resource="com/wenbin/model/Sysuser.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>
最后一句：
<mapping resource="com/wenbin/model/Sysuser.hbm.xml"></mapping>
是指对应映射数据库中的哪些表，这里仅举例一张表，多张表对应多个mapping，该表的配置对应的是com.wenbin.model下的Sysuser.hbm.xml配置文件，在数据库中，一张数据表对应一个类似于xxx.hbm.xml配置文件，该表对应数据库该用户中的表结构如下：
主键是id。
所以，需要新建com.wenbin.model包，再在该包下建立一个Sysuser.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="com.wenbin.entry.Sysuser" table="sysuser">
<!-- id是指主键的意思，property是指列的意思 -->
<id name="id" column="id" type="java.lang.Long">
<generator class="native"></generator>
</id>
<property name="account" column="account" type="java.lang.String" />
<property name="password" column="password" type="java.lang.String" />
<property name="popedom" column="popedom" type="java.lang.String" />
<property name="district_id" column="district_id" type="java.lang.String" />
<property name="email" column="email" type="java.lang.String" />
<property name="org_id" column="org_id" type="java.lang.Long" />
<property name="name" column="name" type="java.lang.String" />
<property name="oid" column="oid" type="java.lang.Long" />
</class>
</hibernate-mapping>
第一句，<class name="com.wenbin.entry.Sysuser" table="sysuser">表明对应的实体类是com.wenbin.entry包下的Sysuser.java类，table对应的是表名。
其实关于这些配置文件，完全可以由myeclipse自动生成。
3.3 建立持久化对象
再建好各配置表以后，还需要新建实体对象Sysuser,该对象对应表结构，新建com.wenbin.entry包，再在该包下建立Sysuser.java，具体代码如下：
package com.wenbin.entry;
public class Sysuser {
private String account;
private String password;
private String popedom;
private String district_id;
private Long id;
private String email;
private Long org_id;
private String name;
private Long oid;
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPopedom() {
return popedom;
}
public void setPopedom(String popedom) {
this.popedom = popedom;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Long getOrg_id() {
return org_id;
}
public void setOrg_id(Long org_id) {
this.org_id = org_id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getOid() {
return oid;
}
public void setOid(Long oid) {
this.oid = oid;
}
public String getDistrict_id() {
return district_id;
}
public void setDistrict_id(String district_id) {
this.district_id = district_id;
}
}
3.4 测试
创建Session工厂类HibernateSessionFactory。
让我们先了解一下Session, Hibernate 对数据库的操作是通过Session来实现的，这里的session不同于页面间传递参数的session,而是类似于JDBC中的 Connection。Session是Hibernate运作的中心，对象的生命周期、事务的管理、数据库的存取都与session息息相关。
而Session是由HibernateSessionFactory创建的，是线程安全的，可以让多个执行线程同时存取HibernateSessionFactory而不会有数据共享的问题，但不能让多个线程共享一个Session。
可以先随便找个类，这里以之前建立的Login.java来测试，为Login.java添加main方法，具体和注释如下：
public static void main(String[] args) {
// Configuration 负责管理 Hibernate 配置讯息
Configuration config = new Configuration().configure();
// 根据 config 建立 SessionFactory
// SessionFactory 将用于建立 Session
SessionFactory factory = config.buildSessionFactory();
// 开启Session，相当于开启JDBC 的Connection
Session session = factory.openSession();
Query query = session.createQuery("from Sysuser where password=?"); //Sysuser是持久化对象，
query.setParameter(0, "111111");
List<Sysuser> list = query.list();
for (Sysuser sysuser : list) {
System.out.println(sysuser.getAccount());
}
session.close();
}
注意Query query = session.createQuery("from Sysuser where password=?"); //Sysuser是持久化对象，
此句，from Sysuser where password=?是HQL语句，跟普通的查询语句不同，该Sysuser不是表名，而是你之前建立的类名，对应的持久化对象，所以必须写成Sysuser类名，写成SYSUSER或sysuser都不允许的，因为没有建立这样的类，只有Sysuser这个类名。
测试，直接执行此mian方法，执行结果正确。
至此，Hibernate测试完成。
具体完整的项目如下：
四 Spring2.5的简单配置与使用
4.1导入spring包。
下载spring-framework-2.5.6并解压后，在spring-framework-2.5.6"dist目录下找到spring.jar，引入到工程中
说明：spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。这里，为了使用方便，我们引入整个spring.jar。
4.2配置web.xml文件。
首先修改web.xml文件，增加如下代码：
<!--
* 从类路径下加载spring的配置文件, 多个配置文件可以用逗号和空格区分
* classpath: 关键字特指类路径下加载-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*: applicationContext*.xml
</param-value>
</context-param>
在这里，我们指定了spring配置文件的路径，即WEB-INF/classes/目录下的所有以applicationContext开头命名的xml文件。
4.3配置applicationContext.xml
在src下面新建applicationContext.xml文件。首先给这个文件加上spring的标头：
代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> </beans>
4.4 测试举例
Spring基本配置完毕，让我们建个示例来测试一下吧，修改实体类Sysuser.java，另其实现一个接口，implements Serializable，即可，再在com.wenbin.example创建SpringTest.java用来测试。
SpringTest.java:
package com.wenbin.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wenbin.entry.Sysuser;
public class SprintTest {
public static void main(String[] args) {
//加载spring配置文件，初始化IoC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器 接管Bean
Sysuser user = (Sysuser) ac.getBean("Sysuser");
System.out.println(user.getAccount()+"..."+user.getName()+"");
}
}
创建完毕后，就剩最后一步了，在applicationContext.xml中配置一个bean，在applicationContext.xml中代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
运行SpringTest.java，结果输出“小张...liangbinny”
至此，spring的简单配置完毕。
五 Spring2.5整合Struts2.0.11
Spring与Struts的整合其实就是把Struts的Action类交给Spring来管理。
导入struts包下的struts2-spring-plugin-2.0.11.jar包
配置web.xml文件。在web.xml中加入以下代码：
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
现在就来看如何把struts的action交给spring。以struts示例中的以login这个action为例，首先创建一个Login类的Bean。在applicationContext.xml中增加如下代码：
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
</bean>
这里，我们把这个bean的id设为loginAction。Scope设为prototype，含义是每一次请求创建一个Login类的实例，Scope还有另一个值“singleton”意为“单例模式”。
接下来修改struts.xml文件，把原来login的配置做如下修改：
将
<struts>
<package name="example" extends="struts-default">
<action name="login" class="com.wenbin.example.Login">
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
修改为：
<struts>
<!-- 下面这句表明对象是由spring负责产生的.加上这句后,struts会产生让spring负责
产生bean,如果spring不能产生bean,则由struts自己产生.也可以在struts.properties
文件内定义这个属性.-->
<constant name="objectFactory" value="spring"></constant>
<!-- namespace非常重要，作为action访问的域 -->
<package name="example" extends="struts-default" namespace="">
<!-- 注意,现在action的class属性不再是类的名字了,而是在spring中的bean的id
详细信息请看下面的spring的bean配置文件applicationContext.xml -->
<action name="login" class="loginAction" >
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
就可以了。class值设为了loginAction，即LoginAction类的bean的ID。这样我们就把LoginAction类交给了spring管理。启动tomcat并访问登录页面登录一切正常，配置成功。
至此，完整的项目路径图如下：
包图如下：
完整的applicationContext.xml内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="loginAction" class="com.wenbin.example.Login" scope="prototype"></bean>
<bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
完整的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"> <welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<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的配置文件, 多个配置文件可以用逗号和空格区分
* classpath: 关键字特指类路径下加载-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*:applicationContext*.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>
六 Spring2.5整合Hibernate3.6
Spring整合Hibernate主要是对hibernate的Session进行管理，包含Session的创建、提交、关闭的整个生命周期。Spring对事务的管理应用了AOP的技术，配置前请先了解一下AOP的知识。
6.1 导入jar包
aspectjweaver.jar --在spring-framework-2.5.6/lib/aspectj文件夹下
hibernate-jpa-2.0-api-1.0.0.Final.jar ---在hibernate-distribution-3.6.0.Final/lib/jpa文件夹下
6.2配置sessionFactory，让spring来创建Session
在applicationContext.xml中增加如下代码：
<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath: hibernate.cfg.xml</value>
</property>
</bean>
之前我们测试是自己新建SessionFactory.来创建Session的，现在，交给Spring创建。这里，创建了一个Session工厂类的Bean，其ID为“sessionFactory”。
6.3 配置事务管理器
增加如下代码：
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
这里创建了一个id为transactionManager的事务管理器，它匹配一个session工厂，<ref bean="sessionFactory"/>这个sessionFactory是指session工厂的ID
6.4 对事务管理器进行事务设置
<tx:advice id="smAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
这里创建了一个advice(通知)，对事务管理器进行事务设置，这里意思是指，对于以save、del、update开头的方法应用事务。
6.5 具体应用到类。
看如下代码：
<aop:config>
<aop:pointcut id="smMethod" expression="execution(* com.wenbin.example.*.*(..))" />
<aop:advisor pointcut-ref="smMethod" advice-ref="smAdvice" />
</aop:config>
这里配置的作用是把我们上面创建的advice应用到具体的类中。以上代码的意思指，给com.wenbin下的所有类的所有方法应用smAdvice。
注意：expression="execution(* com.wenbin. *.*(..))"，这个定义里面的包域com.wenbin范围不应过小，至少要包含实体entry在内。否则会造成Struts取不到提交表单Form的值。
至此，spring已经整合好了Hibernate。
七 具体应用
7.1 DAO层建立
建立com.wenbin.dao包，然后在该包下建立接口IDAO，具体内容如下：
package com.wenbin.dao;
public interface IDAO {
}
这是最基本的接口，建立该最基本的接口的目的是为了多个DAO可以使用同一个基类IDAO管理，减少后期的Spring的Bean配置。
再在该包下建立接口ISysuserDAO，实现IDAO，内容如下：
package com.wenbin.dao;
import java.util.List;
import com.wenbin.entry.Sysuser;
public interface ISysuserDAO extends IDAO {
List getSysusers();
Sysuser getSysuser(Integer userid);
void saveSysuser(Sysuser user);
void removeSysuser(Sysuser user);
List getSysuser(String account,String password);
}
在接口定义了几个基本的方法。
然后再建立具体的DAO类SysuserDAOHiberante.java（先在dao包下建一个hibernate包），具体代码如下：
package com.wenbin.dao.hibernate;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.wenbin.entry.Sysuser;
import com.wenbin.dao.ISysuserDAO;
public class SysuserDAOHiberante extends HibernateDaoSupport implements
ISysuserDAO {
public SysuserDAOHiberante() {
}
public Sysuser getSysuser(Integer userid) {
List users = getHibernateTemplate().find("from Sysuser where id=?",
userid);
if (users.size() > 0) {
return (Sysuser) users.get(1);
}
return null;
}
public List getSysusers() {
List users = getHibernateTemplate().find("from Sysuser");
return users;
}
public void removeSysuser(Sysuser user) {
getHibernateTemplate().delete(user);
}
public void saveSysuser(Sysuser user) {
getHibernateTemplate().update(user);
}
public List getSysuser(String account, String password) {
return getHibernateTemplate().find(
"from Sysuser where account=? and password = ?",
new String[] { account, password });
}
}
至此，DAO层配置完毕.
7.2 service层建立
在com.wenbin下建立service包，再在service包下建立一个spring包，先在service包下建立一个接口IService，内容如下：
package com.wenbin.service;
public interface IService {
}
再建立一个接口ISysuserService，继承IService，
package com.wenbin.service;
import java.util.List;
import com.wenbin.entry.Sysuser;
public interface ISysuserService extends IService {
List getSysusers();
Sysuser getSysuser(Integer userid);
void saveSysuser(Sysuser user);
void removeSysuser(Sysuser user);
List getSysuser(String account, String password);
}
再在spring包下建立一个具体实现的类SysuserService.java，具体代码如下：
package com.wenbin.service.spring;
import java.util.List;
import com.wenbin.entry.Sysuser;
import com.wenbin.service.ISysuserService;
import com.wenbin.dao.ISysuserDAO;
public class SysuserService implements ISysuserService {
private ISysuserDAO sysuserDao;
public Sysuser getSysuser(Integer userid) {
return sysuserDao.getSysuser(userid);
}
public List getSysusers() {
return sysuserDao.getSysusers();
}
public void removeSysuser(Sysuser user) {
sysuserDao.removeSysuser(user);
}
public void saveSysuser(Sysuser user) {
sysuserDao.saveSysuser(user);
}
public ISysuserDAO getSysuserDao() {
return sysuserDao;
}
public void setSysuserDao(ISysuserDAO sysuserDao) {
this.sysuserDao = sysuserDao;
}
public List getSysuser(String account, String password) {
return sysuserDao.getSysuser(account, password);
}
}
至此，service层定义完毕。
7.3 视图层view的引用
之前我们已经实现了由spring绑定的登录页面的action， login这个action，指向的是Login.java这个类，现在，将在这个类里面引用service，并使用该service里的方法。具体代码如下：
package com.wenbin.example;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.opensymphony.xwork2.ActionSupport;
import com.wenbin.entry.Sysuser;
import com.wenbin.service.ISysuserService;
public class Login extends ActionSupport {
private static final long serialVersionUID = 1L;
private ISysuserService sysuserService;
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() {
System.out.println("登录成功...");
System.out.println("用户名：" + username);
System.out.println("密码:" + password);
List sysusers = sysuserService.getSysuser(username, password);
if (sysusers != null && sysusers.size() > 0) {
return SUCCESS;
} else {
super.addFieldError("feedback", "用户名或密码错误");
return ERROR;
}
// if (username.equals("liangbinny") && password.equals("123")) {
// return SUCCESS;
// } else {
// super.addFieldError("feedback", "用户名或密码错误");
// return ERROR;
// }
}
@Override
public void validate() {
if (username == null || username.equals("")) { // 这种验证，对应返回input这个名的页面,必须在struts.xml中定义<result name="input">/index.jsp</result>这个属性
super.addActionError("用户名不能为空");
super.addFieldError("feedback", "用户名不能为空");
}
if (password == null || password.equals("")) {// 这种验证，对应返回input这个名的页面
super.addActionError("密码不能为空");
super.addFieldError("feedback", "密码不能为空");
}
}
public static void main(String[] args) {
// Configuration 负责管理 Hibernate 配置讯息
Configuration config = new Configuration().configure();
// 根据 config 建立 SessionFactory
// SessionFactory 将用于建立 Session
SessionFactory factory = config.buildSessionFactory();
// 开启Session，相当于开启JDBC 的Connection
Session session = factory.openSession();
Query query = session.createQuery("from Sysuser where password=?"); // Sysuser是持久化对象，
query.setParameter(0, "111111");
List<Sysuser> list = query.list();
for (Sysuser sysuser : list) {
System.out.println(sysuser.getAccount());
}
session.close();
}
public void setSysuserService(ISysuserService sysuserService) {
this.sysuserService = sysuserService;
}
public ISysuserService getSysuserService() {
return sysuserService;
}
}
7.4服务的绑定
在上节定义的Login.java中，里面的sysuserService目前是空的，因为还没有实现由spring绑定的service，需要进行绑定。在applicationContext.xml中进行定义。在applicationContext.xml中定义的bean,都会在服务启动时初始化对象的。
绑定一个service的代码如下：
<!-- 模型DAO -->
<bean id="ISysuserDAO"
class="com.wenbin.dao.hibernate.SysuserDAOHiberante">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 服务Services -->
<bean id="sysuserService"
class="com.wenbin.service.spring.SysuserService">
<property name="sysuserDao"><!-- 这个name名就是对应你定义的service名sysuserDao，在Sysuserservice.java中定义的名，这个要额外小心注意，不然会报初始化BEAN错误 -->
<ref bean="ISysuserDAO" />
</property>
</bean>
<!-- 视图view -->
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
<property name="sysuserService"> <!-- 这里的属性名就是对应Login.java中的成员sysuserService，这样进行绑定的。 -->
<ref bean="sysuserService"/>
</property>
</bean>
由此可见，三层都是由spring的bean统一进行管理。通过这样绑定以后，在Login.java中定义的sysuserService在服务启动时会初始化对象，而无需再初始化对象。
具体applicationContext.xml完整代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 对事务管理器进行事务设置 -->
<tx:advice id="smAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="smMethod"
expression="execution(* com.wenbin.*.*(..))" />
<aop:advisor pointcut-ref="smMethod" advice-ref="smAdvice" />
</aop:config>
<!-- 模型DAO -->
<bean id="ISysuserDAO"
class="com.wenbin.dao.hibernate.SysuserDAOHiberante">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 服务Services -->
<bean id="sysuserService"
class="com.wenbin.service.spring.SysuserService">
<property name="sysuserDao"><!-- 这个name名就是对应你定义的service名sysuserDao，在Sysuserservice.java中定义的名 -->
<ref bean="ISysuserDAO" />
</property>
</bean>
<!-- 视图view -->
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
<property name="sysuserService"> <!-- 这里的属性名就是对应Login.java中的成员sysuserService，这样进行绑定的。 -->
<ref bean="sysuserService"/>
</property>
</bean>
<bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
启动tomcat，访问index.jsp页面。输入数据库中的正确用户名和密码，登录成功。配置成功。
完整的项目图如下：
包图：
http://chaoji-liangbin.blog.163.com/blog/static/2523921220101019114149974/
参考：http://ajava.org/course/open/12486.html
一 开发环境
MyEclipse6.5
JDK 1.6.10
Tomcat6.0
Struts2.0.11
Spring2.5.6
Hibernate3.6.0
用户可以在对应的官网下载对应的包。
Struts:
http://apache.freelamp.com/struts/binaries/struts-2.0.11.2-all.zip
Hibernate: http://nchc.dl.sourceforge.net/project/hibernate/hibernate3/3.6.0.Final/hibernate-distribution-3.6.0.Final-dist.zip
Spring: http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-2.5.6-with-dependencies.zip
二 Struts的简单配置与使用
以一个普通的用户登录例子为例，
2.1 导入struts2包
新建web项目,命名为SSHProject,引入struts2必须的包：
2.2 修改web.xml文件
修改WEB-INF下的web.xml文件，增加struts2的过滤器
完整的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"> <welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<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>
</web-app>
2.3新建页面index.jsp
在webroot下新建一个index.jsp页面，内容如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用户登录</title>
</head>
<body>
<s:form action="login" name="form1">
<s:textfield name="username" label="username"></s:textfield>
<s:password name="password" label="password"></s:password>
<s:submit value="提交" label="submit"></s:submit>
<s:label name="feedback"></s:label>
</s:form>
</body>
</html>
其中，跳转动作名是login，，即点击提交按钮，根据struts的配置表（struts.xml，这个是需要自己配置的文件，会在下节介绍）动作名进行跳转并操作。
登陆成功页面success.jsp
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>登录成功</title>
</head>
<body>
登录成功。
</body>
</html>
失败的话跳转回index.jsp，并反馈信息。
2.4 添加struts.xml文件
在项目的src下，新建struts.xml文件，这是struts2的基本配置文件，struts2的跳转，异常等配置均在此，struts2的跳转亦是根据这个文件来跳转的。完整的内容如下：
<?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="example" extends="struts-default">
<action name="login" class="com.wenbin.example.Login">
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
注解：<struts>是基本的标签
<package name="example" extends="struts-default">标签是包名，需要继承struts-default.xml文件，写成extends="struts-default"
<action>是跳转动作，命名为login（这个名字是根据index.jsp的页面定义的表单form的action对应的），对应的class属性是指操作的类com.wenbin.example.Login，
<result>是结果，根据验证的结果，选择进行跳转。type=”redirect”表示重定向。
2.5 定义动作Login.java
根据struts配置，其是跳转到com.wenbin.example.Login，这个类处理的，所以新建com.wenbin.example包，再新建Login.java类，处理内容如下：
package com.wenbin.example;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.opensymphony.xwork2.ActionSupport;
import com.wenbin.entry.Sysuser;
public class Login extends ActionSupport {
private static final long serialVersionUID = 1L;
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() {
System.out.println("登录成功...");
System.out.println("用户名：" + username);
System.out.println("密码:" + password);
if (username.equals("liangbinny") && password.equals("123")) {
return SUCCESS;
} else {
super.addFieldError("feedback", "用户名或密码错误");
return ERROR;
}
}
@Override
public void validate() {
if (username == null || username.equals("")) { // 这种验证，对应返回input这个名的页面,必须在struts.xml中定义<result
// name="input">/index.jsp</result>这个属性
super.addActionError("用户名不能为空");
super.addFieldError("feedback", "用户名不能为空");
}
if (password == null || password.equals("")) {// 这种验证，对应返回input这个名的页面
super.addActionError("密码不能为空");
super.addFieldError("feedback", "密码不能为空");
}
}
}
2.6 定义sturts.properties
这个文件是用来定义struts的属性的，在src下，新建sturts.properties，内容如下：
struts.locale=en_GB
至此，struts基本配置完毕。启动tomcat并访问index.jsp，即可。完整项目图如下：
三 Hibernate的简单配置与使用
3.1 导入Hibernate包
在刚才那个项目下，继续添加Hibernate所需要的包，如下：
具体介绍如下：
hibernate3.jar-----------------------------核心类库
antlr-2.7.6.jar-----------------------------代码扫描器,用来翻译HQL语句
commons-collections-3.1.jar----------- Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大
dom4j-1.6.1.jar----------------------------是一个Java的XML API，类似于jdom，用来读写XML文件的
javassist-3.4.GA.jar----------------------- Javassist 字节码解释器
jta-1.1.jar------------------------------------标准的JTA API。
slf4j-api-1.6.1.jar
slf4j-nop-1.6.1.jar --------------这个包要自己去独立下载
class12是数据库驱动包
3.2 Hibernate配置文件配置
创建Hibernate配置文件。在src下新建hibernate.cfg.xml。这是hibernate连接数据库的配置文件。这里以连接Oracle为例，(假设数据库SID是Test,用户名和密码都是Test)，具体配置如下：
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
oracle.jdbc.driver.OracleDriver
</property>
<property name="connection.url">
jdbc:oracle:thin:@192.168.5.24:1521:Test
</property>
<property name="myeclipse.connection.profile">test</property><!-- 这个是你myeclipse的数据库连接视图里建立的连接名，可有可无 -->
<property name="connection.username">test</property>
<property name="connection.password">test</property>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property> <!-- 这个表示数据库连接的方言 -->
<property name="show_sql">true</property> <!-- 是否显示sql语句 -->
<mapping resource="com/wenbin/model/Sysuser.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>
最后一句：
<mapping resource="com/wenbin/model/Sysuser.hbm.xml"></mapping>
是指对应映射数据库中的哪些表，这里仅举例一张表，多张表对应多个mapping，该表的配置对应的是com.wenbin.model下的Sysuser.hbm.xml配置文件，在数据库中，一张数据表对应一个类似于xxx.hbm.xml配置文件，该表对应数据库该用户中的表结构如下：
主键是id。
所以，需要新建com.wenbin.model包，再在该包下建立一个Sysuser.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="com.wenbin.entry.Sysuser" table="sysuser">
<!-- id是指主键的意思，property是指列的意思 -->
<id name="id" column="id" type="java.lang.Long">
<generator class="native"></generator>
</id>
<property name="account" column="account" type="java.lang.String" />
<property name="password" column="password" type="java.lang.String" />
<property name="popedom" column="popedom" type="java.lang.String" />
<property name="district_id" column="district_id" type="java.lang.String" />
<property name="email" column="email" type="java.lang.String" />
<property name="org_id" column="org_id" type="java.lang.Long" />
<property name="name" column="name" type="java.lang.String" />
<property name="oid" column="oid" type="java.lang.Long" />
</class>
</hibernate-mapping>
第一句，<class name="com.wenbin.entry.Sysuser" table="sysuser">表明对应的实体类是com.wenbin.entry包下的Sysuser.java类，table对应的是表名。
其实关于这些配置文件，完全可以由myeclipse自动生成。
3.3 建立持久化对象
再建好各配置表以后，还需要新建实体对象Sysuser,该对象对应表结构，新建com.wenbin.entry包，再在该包下建立Sysuser.java，具体代码如下：
package com.wenbin.entry;
public class Sysuser {
private String account;
private String password;
private String popedom;
private String district_id;
private Long id;
private String email;
private Long org_id;
private String name;
private Long oid;
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPopedom() {
return popedom;
}
public void setPopedom(String popedom) {
this.popedom = popedom;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Long getOrg_id() {
return org_id;
}
public void setOrg_id(Long org_id) {
this.org_id = org_id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getOid() {
return oid;
}
public void setOid(Long oid) {
this.oid = oid;
}
public String getDistrict_id() {
return district_id;
}
public void setDistrict_id(String district_id) {
this.district_id = district_id;
}
}
3.4 测试
创建Session工厂类HibernateSessionFactory。
让我们先了解一下Session, Hibernate 对数据库的操作是通过Session来实现的，这里的session不同于页面间传递参数的session,而是类似于JDBC中的 Connection。Session是Hibernate运作的中心，对象的生命周期、事务的管理、数据库的存取都与session息息相关。
而Session是由HibernateSessionFactory创建的，是线程安全的，可以让多个执行线程同时存取HibernateSessionFactory而不会有数据共享的问题，但不能让多个线程共享一个Session。
可以先随便找个类，这里以之前建立的Login.java来测试，为Login.java添加main方法，具体和注释如下：
public static void main(String[] args) {
// Configuration 负责管理 Hibernate 配置讯息
Configuration config = new Configuration().configure();
// 根据 config 建立 SessionFactory
// SessionFactory 将用于建立 Session
SessionFactory factory = config.buildSessionFactory();
// 开启Session，相当于开启JDBC 的Connection
Session session = factory.openSession();
Query query = session.createQuery("from Sysuser where password=?"); //Sysuser是持久化对象，
query.setParameter(0, "111111");
List<Sysuser> list = query.list();
for (Sysuser sysuser : list) {
System.out.println(sysuser.getAccount());
}
session.close();
}
注意Query query = session.createQuery("from Sysuser where password=?"); //Sysuser是持久化对象，
此句，from Sysuser where password=?是HQL语句，跟普通的查询语句不同，该Sysuser不是表名，而是你之前建立的类名，对应的持久化对象，所以必须写成Sysuser类名，写成SYSUSER或sysuser都不允许的，因为没有建立这样的类，只有Sysuser这个类名。
测试，直接执行此mian方法，执行结果正确。
至此，Hibernate测试完成。
具体完整的项目如下：
四 Spring2.5的简单配置与使用
4.1导入spring包。
下载spring-framework-2.5.6并解压后，在spring-framework-2.5.6"dist目录下找到spring.jar，引入到工程中
说明：spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。这里，为了使用方便，我们引入整个spring.jar。
4.2配置web.xml文件。
首先修改web.xml文件，增加如下代码：
<!--
* 从类路径下加载spring的配置文件, 多个配置文件可以用逗号和空格区分
* classpath: 关键字特指类路径下加载-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*: applicationContext*.xml
</param-value>
</context-param>
在这里，我们指定了spring配置文件的路径，即WEB-INF/classes/目录下的所有以applicationContext开头命名的xml文件。
4.3配置applicationContext.xml
在src下面新建applicationContext.xml文件。首先给这个文件加上spring的标头：
代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> </beans>
4.4 测试举例
Spring基本配置完毕，让我们建个示例来测试一下吧，修改实体类Sysuser.java，另其实现一个接口，implements Serializable，即可，再在com.wenbin.example创建SpringTest.java用来测试。
SpringTest.java:
package com.wenbin.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wenbin.entry.Sysuser;
public class SprintTest {
public static void main(String[] args) {
//加载spring配置文件，初始化IoC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器 接管Bean
Sysuser user = (Sysuser) ac.getBean("Sysuser");
System.out.println(user.getAccount()+"..."+user.getName()+"");
}
}
创建完毕后，就剩最后一步了，在applicationContext.xml中配置一个bean，在applicationContext.xml中代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
运行SpringTest.java，结果输出“小张...liangbinny”
至此，spring的简单配置完毕。
五 Spring2.5整合Struts2.0.11
Spring与Struts的整合其实就是把Struts的Action类交给Spring来管理。
导入struts包下的struts2-spring-plugin-2.0.11.jar包
配置web.xml文件。在web.xml中加入以下代码：
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
现在就来看如何把struts的action交给spring。以struts示例中的以login这个action为例，首先创建一个Login类的Bean。在applicationContext.xml中增加如下代码：
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
</bean>
这里，我们把这个bean的id设为loginAction。Scope设为prototype，含义是每一次请求创建一个Login类的实例，Scope还有另一个值“singleton”意为“单例模式”。
接下来修改struts.xml文件，把原来login的配置做如下修改：
将
<struts>
<package name="example" extends="struts-default">
<action name="login" class="com.wenbin.example.Login">
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
修改为：
<struts>
<!-- 下面这句表明对象是由spring负责产生的.加上这句后,struts会产生让spring负责
产生bean,如果spring不能产生bean,则由struts自己产生.也可以在struts.properties
文件内定义这个属性.-->
<constant name="objectFactory" value="spring"></constant>
<!-- namespace非常重要，作为action访问的域 -->
<package name="example" extends="struts-default" namespace="">
<!-- 注意,现在action的class属性不再是类的名字了,而是在spring中的bean的id
详细信息请看下面的spring的bean配置文件applicationContext.xml -->
<action name="login" class="loginAction" >
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/index.jsp</result>
<result name="input">/index.jsp</result>
</action>
</package>
</struts>
就可以了。class值设为了loginAction，即LoginAction类的bean的ID。这样我们就把LoginAction类交给了spring管理。启动tomcat并访问登录页面登录一切正常，配置成功。
至此，完整的项目路径图如下：
包图如下：
完整的applicationContext.xml内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="loginAction" class="com.wenbin.example.Login" scope="prototype"></bean>
<bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
完整的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"> <welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<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的配置文件, 多个配置文件可以用逗号和空格区分
* classpath: 关键字特指类路径下加载-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*:applicationContext*.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>
六 Spring2.5整合Hibernate3.6
Spring整合Hibernate主要是对hibernate的Session进行管理，包含Session的创建、提交、关闭的整个生命周期。Spring对事务的管理应用了AOP的技术，配置前请先了解一下AOP的知识。
6.1 导入jar包
aspectjweaver.jar --在spring-framework-2.5.6/lib/aspectj文件夹下
hibernate-jpa-2.0-api-1.0.0.Final.jar ---在hibernate-distribution-3.6.0.Final/lib/jpa文件夹下
6.2配置sessionFactory，让spring来创建Session
在applicationContext.xml中增加如下代码：
<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath: hibernate.cfg.xml</value>
</property>
</bean>
之前我们测试是自己新建SessionFactory.来创建Session的，现在，交给Spring创建。这里，创建了一个Session工厂类的Bean，其ID为“sessionFactory”。
6.3 配置事务管理器
增加如下代码：
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
这里创建了一个id为transactionManager的事务管理器，它匹配一个session工厂，<ref bean="sessionFactory"/>这个sessionFactory是指session工厂的ID
6.4 对事务管理器进行事务设置
<tx:advice id="smAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
这里创建了一个advice(通知)，对事务管理器进行事务设置，这里意思是指，对于以save、del、update开头的方法应用事务。
6.5 具体应用到类。
看如下代码：
<aop:config>
<aop:pointcut id="smMethod" expression="execution(* com.wenbin.example.*.*(..))" />
<aop:advisor pointcut-ref="smMethod" advice-ref="smAdvice" />
</aop:config>
这里配置的作用是把我们上面创建的advice应用到具体的类中。以上代码的意思指，给com.wenbin下的所有类的所有方法应用smAdvice。
注意：expression="execution(* com.wenbin. *.*(..))"，这个定义里面的包域com.wenbin范围不应过小，至少要包含实体entry在内。否则会造成Struts取不到提交表单Form的值。
至此，spring已经整合好了Hibernate。
七 具体应用
7.1 DAO层建立
建立com.wenbin.dao包，然后在该包下建立接口IDAO，具体内容如下：
package com.wenbin.dao;
public interface IDAO {
}
这是最基本的接口，建立该最基本的接口的目的是为了多个DAO可以使用同一个基类IDAO管理，减少后期的Spring的Bean配置。
再在该包下建立接口ISysuserDAO，实现IDAO，内容如下：
package com.wenbin.dao;
import java.util.List;
import com.wenbin.entry.Sysuser;
public interface ISysuserDAO extends IDAO {
List getSysusers();
Sysuser getSysuser(Integer userid);
void saveSysuser(Sysuser user);
void removeSysuser(Sysuser user);
List getSysuser(String account,String password);
}
在接口定义了几个基本的方法。
然后再建立具体的DAO类SysuserDAOHiberante.java（先在dao包下建一个hibernate包），具体代码如下：
package com.wenbin.dao.hibernate;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.wenbin.entry.Sysuser;
import com.wenbin.dao.ISysuserDAO;
public class SysuserDAOHiberante extends HibernateDaoSupport implements
ISysuserDAO {
public SysuserDAOHiberante() {
}
public Sysuser getSysuser(Integer userid) {
List users = getHibernateTemplate().find("from Sysuser where id=?",
userid);
if (users.size() > 0) {
return (Sysuser) users.get(1);
}
return null;
}
public List getSysusers() {
List users = getHibernateTemplate().find("from Sysuser");
return users;
}
public void removeSysuser(Sysuser user) {
getHibernateTemplate().delete(user);
}
public void saveSysuser(Sysuser user) {
getHibernateTemplate().update(user);
}
public List getSysuser(String account, String password) {
return getHibernateTemplate().find(
"from Sysuser where account=? and password = ?",
new String[] { account, password });
}
}
至此，DAO层配置完毕.
7.2 service层建立
在com.wenbin下建立service包，再在service包下建立一个spring包，先在service包下建立一个接口IService，内容如下：
package com.wenbin.service;
public interface IService {
}
再建立一个接口ISysuserService，继承IService，
package com.wenbin.service;
import java.util.List;
import com.wenbin.entry.Sysuser;
public interface ISysuserService extends IService {
List getSysusers();
Sysuser getSysuser(Integer userid);
void saveSysuser(Sysuser user);
void removeSysuser(Sysuser user);
List getSysuser(String account, String password);
}
再在spring包下建立一个具体实现的类SysuserService.java，具体代码如下：
package com.wenbin.service.spring;
import java.util.List;
import com.wenbin.entry.Sysuser;
import com.wenbin.service.ISysuserService;
import com.wenbin.dao.ISysuserDAO;
public class SysuserService implements ISysuserService {
private ISysuserDAO sysuserDao;
public Sysuser getSysuser(Integer userid) {
return sysuserDao.getSysuser(userid);
}
public List getSysusers() {
return sysuserDao.getSysusers();
}
public void removeSysuser(Sysuser user) {
sysuserDao.removeSysuser(user);
}
public void saveSysuser(Sysuser user) {
sysuserDao.saveSysuser(user);
}
public ISysuserDAO getSysuserDao() {
return sysuserDao;
}
public void setSysuserDao(ISysuserDAO sysuserDao) {
this.sysuserDao = sysuserDao;
}
public List getSysuser(String account, String password) {
return sysuserDao.getSysuser(account, password);
}
}
至此，service层定义完毕。
7.3 视图层view的引用
之前我们已经实现了由spring绑定的登录页面的action， login这个action，指向的是Login.java这个类，现在，将在这个类里面引用service，并使用该service里的方法。具体代码如下：
package com.wenbin.example;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.opensymphony.xwork2.ActionSupport;
import com.wenbin.entry.Sysuser;
import com.wenbin.service.ISysuserService;
public class Login extends ActionSupport {
private static final long serialVersionUID = 1L;
private ISysuserService sysuserService;
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() {
System.out.println("登录成功...");
System.out.println("用户名：" + username);
System.out.println("密码:" + password);
List sysusers = sysuserService.getSysuser(username, password);
if (sysusers != null && sysusers.size() > 0) {
return SUCCESS;
} else {
super.addFieldError("feedback", "用户名或密码错误");
return ERROR;
}
// if (username.equals("liangbinny") && password.equals("123")) {
// return SUCCESS;
// } else {
// super.addFieldError("feedback", "用户名或密码错误");
// return ERROR;
// }
}
@Override
public void validate() {
if (username == null || username.equals("")) { // 这种验证，对应返回input这个名的页面,必须在struts.xml中定义<result name="input">/index.jsp</result>这个属性
super.addActionError("用户名不能为空");
super.addFieldError("feedback", "用户名不能为空");
}
if (password == null || password.equals("")) {// 这种验证，对应返回input这个名的页面
super.addActionError("密码不能为空");
super.addFieldError("feedback", "密码不能为空");
}
}
public static void main(String[] args) {
// Configuration 负责管理 Hibernate 配置讯息
Configuration config = new Configuration().configure();
// 根据 config 建立 SessionFactory
// SessionFactory 将用于建立 Session
SessionFactory factory = config.buildSessionFactory();
// 开启Session，相当于开启JDBC 的Connection
Session session = factory.openSession();
Query query = session.createQuery("from Sysuser where password=?"); // Sysuser是持久化对象，
query.setParameter(0, "111111");
List<Sysuser> list = query.list();
for (Sysuser sysuser : list) {
System.out.println(sysuser.getAccount());
}
session.close();
}
public void setSysuserService(ISysuserService sysuserService) {
this.sysuserService = sysuserService;
}
public ISysuserService getSysuserService() {
return sysuserService;
}
}
7.4服务的绑定
在上节定义的Login.java中，里面的sysuserService目前是空的，因为还没有实现由spring绑定的service，需要进行绑定。在applicationContext.xml中进行定义。在applicationContext.xml中定义的bean,都会在服务启动时初始化对象的。
绑定一个service的代码如下：
<!-- 模型DAO -->
<bean id="ISysuserDAO"
class="com.wenbin.dao.hibernate.SysuserDAOHiberante">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 服务Services -->
<bean id="sysuserService"
class="com.wenbin.service.spring.SysuserService">
<property name="sysuserDao"><!-- 这个name名就是对应你定义的service名sysuserDao，在Sysuserservice.java中定义的名，这个要额外小心注意，不然会报初始化BEAN错误 -->
<ref bean="ISysuserDAO" />
</property>
</bean>
<!-- 视图view -->
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
<property name="sysuserService"> <!-- 这里的属性名就是对应Login.java中的成员sysuserService，这样进行绑定的。 -->
<ref bean="sysuserService"/>
</property>
</bean>
由此可见，三层都是由spring的bean统一进行管理。通过这样绑定以后，在Login.java中定义的sysuserService在服务启动时会初始化对象，而无需再初始化对象。
具体applicationContext.xml完整代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 对事务管理器进行事务设置 -->
<tx:advice id="smAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="smMethod"
expression="execution(* com.wenbin.*.*(..))" />
<aop:advisor pointcut-ref="smMethod" advice-ref="smAdvice" />
</aop:config>
<!-- 模型DAO -->
<bean id="ISysuserDAO"
class="com.wenbin.dao.hibernate.SysuserDAOHiberante">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 服务Services -->
<bean id="sysuserService"
class="com.wenbin.service.spring.SysuserService">
<property name="sysuserDao"><!-- 这个name名就是对应你定义的service名sysuserDao，在Sysuserservice.java中定义的名 -->
<ref bean="ISysuserDAO" />
</property>
</bean>
<!-- 视图view -->
<bean id="loginAction" class="com.wenbin.example.Login"
scope="prototype">
<property name="sysuserService"> <!-- 这里的属性名就是对应Login.java中的成员sysuserService，这样进行绑定的。 -->
<ref bean="sysuserService"/>
</property>
</bean>
<bean id="Sysuser" class="com.wenbin.entry.Sysuser">
<property name="account" value="小张"></property>
<property name="password" value="123"></property>
<property name="name" value="liangbinny"></property>
</bean>
</beans>
启动tomcat，访问index.jsp页面。输入数据库中的正确用户名和密码，登录成功。配置成功。
完整的项目图如下：
包图：
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 简单的struts+spring+hibernate配置实例
- 史上最简单的struts+spring+hibernate配置实例[修订版](2005-5-11 周三)_作者:heweiya
- (转）Myeclipse+struts2.0.11+hibernate+spring配置
- 史上最简单的struts+spring+hibernate配置实例
- 最简单的SSH（Struts+Spring+Hibernate）[二]配置文件
- 最简单的SSH（Struts+Spring+Hibernate）[三]配置文件和测试页面
- Myeclipse+struts2.0.11+hibernate+spring配置
- 史上最简单的struts+spring+hibernate配置实例
- 关于使用Spring和hibernate开发web程序的配置说明和简单实例的详细说明
- 史上最简单的struts+spring+hibernate配置实例
- Spring中TransactionTemplate 简单灵活的事务配置及使用
- 在Netbeans中使用Struts2.0+Spring2.5+Hibernate框架(二)
- struts2.1.8 + spring2.5.6 + hibernate3.3.2整合的登陆
- 使用struts+spring+hibernate 组装web应用
- spring+hibernate+struts文件基本配置
- Spring-简单bean的配置（使用bean.xml手动完成）
- 使用struts+spring+hibernate 组装web应用
- 图解MyEclipse配置struts+hibernate+spring+FreeMarker
- Spring中TransactionTemplate 简单灵活的事务配置及使用
- 使用open source产品组装你的web应用架构(struts+spring+hibernate)