SSH学习之——Spring、Struts和Hibernate整合开发

一、环境

1、测试平台：MyEclipse8.5/JDK1.7（1.5以上都OK）

2、开源框架：Spring3.0/Struts2.1/Hibernate3.3

3、UI界面：HTML/JSP/struts2标签

二、具体步骤

1、新建Web项目，此处命名为“ssh”

2、添加Spring的支持。

1）利用平台自身带有的Spring支持（如果熟悉各个库的作用以及配置文件的作用，最好是采用手动添加库来完成，这样的好处就是避免将过多的没必要的jar文件引入到项目中，造成项目的臃肿），此处我们添加Spring3.0

2）勾选五个Spring的库。Spring的核心支持库Core、面向方面编程支持库AOP、持久化核心支持库Persistence Core、JDBC持久化支持库Persistence JDBC、支持Web应用的的库Web（当然这次的开发内容中不包含AOP的东西，所以不选这个也行）

3）此时平台会提示用户自动创建Spring的配置文件“applicationContext.xml”，该文件在src目录下，也就是classpath下

4）配置Web.xml来使Web项目启动时自动启用Spring，在Web.xml中添加如下配置

<!-- 配置Spring配置文件的位置，多个可以以逗号分隔 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<!-- 不指定classpath时，默认为加载/WEB_INF/目录下的文件 -->
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!-- 项目启动时自动启用Spring -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

5）Spring的支持基本配置好了

3、添加Struts的支持

1）这里我们也采用MyEclipse8.5自身的Struts来添加Struts，此处我们添加Struts2.1

2）勾选Struts的核心支持库Core

3）整合Spring和Struts。由于Spring是管理业务对象的，Struts的Action对象可以交由Spring来管理，所以这里我们添加一个插件“struts2-spring-plugin-2.1.6.jar”来达到整合Spring和Struts的目的，把该文件拷贝到/WEB-INF/lib目录下即可（这里我们也可以采用勾选MyEclipse8.5平台提供的Struts支持中的Struts-Spring库，但是这里面的很多jar添加Spring时已经有了，一面造成重复和臃肿，我们采用手动添加该文件的方式）。关于Struts是如何于Spring进行整合的，Struts的对象又是如何交由Spring管理的，可以参照该jar文件中的“struts-plugin.xml”以及代码来研究

4）此时平台在src目录下自动创建了struts的配置文件“struts.xml”

5）Struts的支持已经和Spring的整合这里就完成了

4、添加Hibernate的支持

1）采用平台自带的Hibernate，我们这里添加Hibernate3.3

2）勾选Hibernate的核心支持库Core就行了

3）整合Spring和Hibernate。Hibernate是用于数据库映射的，映射完后的具体的CURD对象可以交由Spring来管理。此时平台会让我们选择将Hibernate的配置放在“hibernat.cfg.xml”中，还是放在spring的“applicationContext.xml”中，这里我们选择放在Spring的配置文件中。在已经存在的“applicationContext.xml”中配置sessionFactory对象

4）配置Hibernate所用的数据源。

a、这里我们采用mysql数据库，所以首先添加mysql的数据库驱动“mysql-connector-java-5.0.7-bin.jar”，将该文件放在/WEB-INF/lib目录下

b、配置数据源。采用jdbc驱动。URL为“jdbc:mysql://localhost:3306/ssh”，Driver Class为“com.mysql.jdbc.Driver”，Dialect为“MySql”

5）因为我们将sessionFactory对象已经配置在Spring中，所用我们就不创建SessionFactory类了

6）Hibernate的支持和与Spring的整合都完成了，此时我们可以看到applicationContext.xml文件中自动创建了如下配置

<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url" value="jdbc:mysql://localhost:3306/ssh"></property>
<property name="username" value="root"></property>
<property name="password" value="111111"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
</bean>

三、开发测试

1、创建数据表user，脚本如下

CREATE TABLE `user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(255) default NULL,
`password` varchar(255) default NULL,
`age` varchar(255) default NULL,
`sex` enum('男','女') default '男',
`description` varchar(255) default NULL,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2、创建实体类User，代码如下

package org.cyxl.ssh.entity;

/**
* 实体类User
* @author cyxl
*
*/
public class User {
private long id;
private String username;
private String password;
private int age;
private String sex;
private String description;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}

3、配置User表的Hibernate映射User.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="org.cyxl.ssh.entity.User" table="user">
<id name="id" column="id">
<generator class="identity" />
</id>

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

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

<property name="age" column="age" type="int"/>

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

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

</class>

</hibernate-mapping>

4、修改sessionFactory的配置，将上述映射文件添加到hibernate中

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>org/cyxl/ssh/entity/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
</bean>

5、编写数据访问对象的接口和实现类，如下

package org.cyxl.ssh.dao;

import org.cyxl.ssh.entity.User;
/**
* 用户数据访问接口
* @author cyxl
*
*/
public interface UserDao {
boolean login(String username,String password);
boolean add(User user);
}

package org.cyxl.ssh.dao.hibernate.impl;

import java.util.List;

import org.cyxl.ssh.dao.UserDao;
import org.cyxl.ssh.entity.User;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
/**
* 用户数据访问Hibernate实现
* @author cyxl
*
*/
public class UserDaoImpl implements UserDao {
private SessionFactory factory;
private Session session;

public SessionFactory getFactory() {
return factory;
}

public void setFactory(SessionFactory factory) {
this.factory = factory;
//设置SessionFactory对象后，创建Session对象
this.session=factory.openSession();
}

public boolean add(User user) {
session.save(user);
return true;
}

public boolean login(String username, String password) {
String hql="from User user where username='"+username+"' and password='"+password+"'";
Query query=session.createQuery(hql);
List<User> list=query.list();

if(list!=null && list.size()>0)
{
return true;
}
return false;
}

}

6、编写用户服务接口和实现类，代码如下

package org.cyxl.ssh.service;

import org.cyxl.ssh.entity.User;
/**
* 用户服务接口
* @author cyxl
*
*/
public interface UserService {
boolean add(User user);
boolean login(String username,String password);
}

package org.cyxl.ssh.service.impl;

import org.cyxl.ssh.dao.UserDao;
import org.cyxl.ssh.entity.User;
import org.cyxl.ssh.service.UserService;
/**
* 用户服务实现
* @author cyxl
*
*/
public class UserServiceImpl implements UserService{
private UserDao userDao;

public UserDao getUserDao() {
return userDao;
}

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public boolean add(User user) {
return userDao.add(user);
}

public boolean login(String username, String password) {
return userDao.login(username, password);
}

}

7、编写用户动作Action，代码如下

package org.cyxl.ssh.action;

import org.cyxl.ssh.entity.User;
import org.cyxl.ssh.service.UserService;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 用户动作实现
* @author cyxl
*
*/
public class UserAction extends ActionSupport implements ModelDriven {
private User user=new User();
private UserService userService;

public UserService getUserService() {
return userService;
}

public void setUserService(UserService userService) {
this.userService = userService;
}

public String login()
{
if(user!=null)
{
if(userService.login(user.getUsername(), user.getPassword()))
{
return this.SUCCESS;
}
}
return this.INPUT;
}

public Object getModel() {
return user;
}
}

这里有两点需要注意

a、该类实现了ModelDriven接口，该接口只有一个方法getModel。这个接口的作用是使请求的参数（如表单）中的name与实体中的字段自动相匹配。如在请求username时，如果采用模型驱动（ModelDriven）设置name时只要指定username，如果为字段驱动，那就需要指明user.username（这里可以参照login.jsp文件中的表单中的name属性来研究）

b、private User user=new User();这行代码中的user必须实例化，也就是必须new出一个对象来



8、发挥Spring的作用，配置各种对象的创建方式，在applicationContext.xml中添加如下配置

<bean id="userDao" class="org.cyxl.ssh.dao.hibernate.impl.UserDaoImpl">
<property name="factory" ref="sessionFactory" />
</bean>

<bean id="userService" class="org.cyxl.ssh.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao" />
</bean>

<bean id="userAction" class="org.cyxl.ssh.action.UserAction">
<property name="userService" ref="userService" />
</bean>

自下而上一次配置了userDao、userService、userAction的实现方式和所以来的对象，这里特别注意userDao的factory属性，我们将前面配置sessionFactory对象赋予了它

9、UI界面

1）index.jsp中写一行代码，作用是转向登陆界面，如下

<% response.sendRedirect("UserLogin.action"); %>

2）编写login.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>login page</title>
</head>
<body>
<s:form action="UserLogin.action">
<s:textfield label="username" name="username"></s:textfield>
<s:password label="password" name="password"></s:password>
<s:submit value="提交"></s:submit>
</s:form>
</body>
</html>

从上面的用户名输入框我们来回忆前面的UserAction中实现了ModelDriven接口。实现的情况下name=“username”，不实现的情况下应该为name=“user.username”

3）编写登陆成功结果页面success.jsp，该页面就一句话提示登陆成功“success”

10、配置struts.xml。代码如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
<package name="cyxl" extends="struts-default">
<action name="UserLogin" class="userAction" method="login">
<result name="success">/success.jsp</result>
<result name="input">/login.jsp</result>
</action>
</package>
</struts>

action为UserLogin的请求使用的类是userAction，该userAction的创建采用Spring管理，具体在applicationContext.xml文件中配置.method指定该请求使用userAction中的哪个方法。登陆成功转向success.jsp页面，失败则继续让用户输入，停留login.jsp页面



四、总结

以上开发内容主要注意一下几点（当然知识点需要查阅其它的相关资料才可能弄明白，这里只是大致引出了该知识点）

1、了解各个依赖的库文件的含义，各个配置文件的含义

2、了解Spring的自动启动方式（Web.xml）的配置

3、Spring整合Struts所依赖的库和struts-plugin.xml的作用

4、Spring整合Hibernate的方式和sessionFactory对象的配置及作用

5、Action实现ModelDriven的作用

6、Spring是如何配置各对象的创建的和创建的时间

7、注意Spring是强制开发者采用接口开发的，如接口UserDao，UserService等等

8、Struts的标签库已经包含在Core库中了，所以用的时候只需要在页面的引入该标签库即可

五、附录

1、Spring的日志记录可以整合log4j来实现，这里需要在web.xml文件中配置。在src目录创建log4j的配置文件log4j.properties

### set log levels ###
log4j.rootLogger = debug,stdout

### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} %5p %c{1}:%L - %m%n

2、完整的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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url" value="jdbc:mysql://localhost:3306/ssh"></property>
<property name="username" value="root"></property>
<property name="password" value="111111"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>org/cyxl/ssh/entity/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
</bean>

<bean id="userDao" class="org.cyxl.ssh.dao.hibernate.impl.UserDaoImpl">
<property name="factory" ref="sessionFactory" />
</bean>

<bean id="userService" class="org.cyxl.ssh.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao" />
</bean>

<bean id="userAction" class="org.cyxl.ssh.action.UserAction">
<property name="userService" ref="userService" />
</bean>
</beans>

3、完整的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>

<!-- 配置Spring配置文件的位置，多个可以以逗号分隔 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<!-- 不指定classpath时，默认为加载/WEB_INF/目录下的文件 -->
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!--由Spring载入的Log4j配置文件位置-->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.properties</param-value>
</context-param>

<!-- 项目启动时自动启用Spring -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!--Spring log4j Config loader-->
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping></web-app>