使用MyEclipse整合ssh(Struts、Spring、Hibernate)三大框架(环境搭载+实例源码下载)

目录(?)[+]

前言

SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。

集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层（实体层）。

Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持。Spring一方面作为一个轻量级的IoC容器，负责查找、定位、创建和管理对象及对象之间的依赖关系，另一方面能使Struts和Hibernate更好地工作。

使用MyEclipse整合SSH三大框架，并实现一个模拟用户注册的Demo，对应版本：

Struts版本：2.1；

Spring版本：3.1；

Hibernate版本：3.3；

一、整合前准备工作

1.建立一个Web项目，如下：

注意：支持action的包名必须是“action”，且action类必须是以Action结尾，即形如XxxAction这种形式，如上图中所示

2.创建数据库以及表：

[sql]  view plain  copy

 

1. CREATE DATABASE sshdemo;  
2. CREATE table t_user(  
3. id INT PRIMARY KEY,  
4. username VARCHAR(10),  
5. password VARCHAR(20)  
6. )  

3.导入数据库连接池c3p0jar包，点击可下载：c3p0-0.9.2-pre1.jar、mysql-connector-java-5.1.13-bin.jar

二、Struts框架的配置：

1.选中项目,右键选择:MyEclipse -> Project Facets[Capabilities] -> Install Apache Struts (2.x) Facet，如下：

2.选择版本，在这里我选择的是2.1，点击"Finish"，如下：

3.完成上述步骤以后，会发现在src目录下多出一个struts.xml 文件，内容如下：

[html]  view plain  copy

 

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">  
3. <struts>  
4.   
5. </struts>    

4.在WEB-INF目录下的web.xml文件中多一段关于struts过滤器的配置代码,如下：

5.参考上图，将*.action修改为"/*",至此struts框架配置完毕;

三、Spring框架的配置：

1.参考struts的配置，选中项目,右键选择:MyEclipse -> Project Facets[Capabilities] -> Install Spring Facet，选择版本，在此选择3.1如下：

2.点击"Finish"，会发现src目录下多了一个applicationContext.xml文件，WEB-INF目录下多了一个spring-form.tld与spring.tld文件，并且在web.xml文件中多了一段与spring配置有关的代码，spring框架搭建基本完毕(引入命名空间会在后面讲到)，如下所示：

四、Hibernate框架的配置：

1.参考struts的配置，选中项目,右键选择:MyEclipse -> Project Facets[Capabilities] -> Install HibernateFacet，选择版本，在此选择3.3如下：

2.点击"Finish"，会发现src目录下多了一个缺省包(可以删除)，并且在web.xml文件中多了一段代码（后面会重新配置），如下所示：

3.支持“@Entity”注解的jar包导入：选中项目,右键选择:MyEclipse -> Project Facets[Capabilities] ->Manage...，然后照下图中的步骤操作：

完成上述步骤，三大框架基本就搭建起来了，接下来整合它们。

五、整合

1.为了不让applicationContext.xml看起来太臃肿，以及便于管理，我们将Hibernate有关的配置保存在另外一个.xml文件中，然后再在applicationContext.xml导入，其具体步骤：

 （1）在src目录下（与applicationContext.xml同级）创建一个名为hibernateContext.xml的文件，复制applicationContext.xml里面的内容，然后再做修改；

 （2）hibernateContext.xml文件里面的内容：

[html]  view plain  copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xmlns:p="http://www.springframework.org/schema/p"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">  
6.   
7.   
8.     <!-- sessionFactory 配置 -->  
9.     <bean id="sessionFactory"  
10.         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
11.         <!-- dataSource的属性会在applicationContext.xml文件中配置，在这里先引用 -->  
12.         <property name="dataSource" ref="dataSource"></property>  
13.         <!-- 设置hibernate相关的配置项 -->  
14.         <property name="hibernateProperties">  
15.             <!-- props标签是为了注入Properties这个类型的属性 -->  
16.             <!-- key必须加上hibernate.前缀 -->  
17.             <props>  
18.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
19.                 <!-- show_sql目的是打印sql语句 -->  
20.                 <prop key="hibernate.show_sql">true</prop>  
21.                 <!-- 美化SQL的打印格式 -->  
22.                 <prop key="hibernate.format_sql">true</prop>  
23.                 <!-- a) create-drop：在执行程序的时候创建数据表，在执行完了之后删除表,实际开发中，常用于测试   
24.                      b) create：在每次执行程序的时候重新创建数据表   
25.                     c) update：在执行程序的时候会判断，如果存在，不创建表，否则创建数据表，并且会根据实体类中的属性的增加，而自动增加数据表中的字段（开发环境）   
26.                     d) validate：在执行程序的时候会判断，如果实体类中的属性与表中的字段不一致，那么就报错（生产环境） -->  
27.                 <prop key="hibernate.hbm2ddl.auto">validate</prop>  
28.             </props>  
29.         </property>  
30.   
31.         <!-- 配置hibernate的实体类 -->  
32.         <property name="packagesToScan">  
33.             <!--list标签是用来注入String[]类型的属性 ,其值一般是对应的bean包的全限名，而bean包中的类一般又是与数据库中的表对应-->  
34.             <list>  
35.                 <value>com.beauxie.bean</value>  
36.             </list>  
37.         </property>  
38.     </bean>  
39.   
40.     <!-- 配置 hibernateTemplate模板 -->  
41.     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">  
42.         <property name="sessionFactory" ref="sessionFactory"></property>  
43.     </bean>  
44.   
45. </beans>  

（3）在applicationContext.xm删除“sessionFactory”的配置（因为在hibernateContext.xml中已经配置好了），然后导入已经修改好的hibernateContext.xml内容，导入完以后，此时applicationContext.xml内容如下：

[html]  view plain  copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:p="http://www.springframework.org/schema/p"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">  
7.   
8.   
9.     <bean id="dataSource"  
10.         class="org.apache.commons.dbcp.BasicDataSource">  
11.     </bean>  
12.       
13.     <!-- 导入其他的spring配置文件 ,如果都放在一个文件里，会看起来比较臃肿-->  
14.     <import resource="hibernateContext.xml"/>  
15.     </beans>  

2.在applicationContext.xm文件中原先dataSource的基础上，修改其配置（数据库名、用户名、密码等），（注意：value标签中一定不能含有空格、回车！！），如下所示：

[html]  view plain  copy

 

1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
2.             <property name="jdbcUrl">  
3.             <!--如果直接用value属性，而不用value标签，则需要将“&”转义(&) ,用value标签，<span style="color:#FF0000;">标签中一定不能含有空格、回车，因为它会将空格转换成"&nbsp;"</span>，导致数据库会连接不上，除非重写数据源 -->  
4.             <value><![CDATA[jdbc:mysql://localhost:3306/sshdemo?useUnicode=true&characterEncoding=UTF8&useServerPrepStmts=true&prepStmtCacheSqlLimit=256&cachePrepStmts=true&prepStmtCacheSize=256&rewriteBatchedStatements=true]]></value>  
5.         </property>  
6.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>  
7.         <property name="user" value="root"></property>  
8.         <property name="password"  value="root"></property>  
9.           
10.         <property name="acquireIncrement" value="3"></property>  
11.         <property name="initialPoolSize" value="10"></property>  
12.         <property name="minPoolSize" value="2"></property>  
13.         <property name="maxPoolSize" value="10"></property>  
14.     </bean>  

3.在applicationContext.xm中，配置spring的扫描器，这样给我们的类加上spring组件注解，就可以实现bean的自动载入，具体步骤如下：

（1）引入context命名空间，支持context标签，点击底部的"Namespaces"，然后勾选context那一项即可：

（2）配置spring扫描器：

[html]  view plain  copy

 

1. <!-- 配置spring的扫描器，然后给我们的类加上spring组件注解，就可以实现bean的自动载入-->  
2. <context:component-scan base-package="com.beauxie.action,com.beauxie.service,com.beauxie.dao">  
3. </context:component-scan>  

至此ssh三大框架环境搭建完毕，接下来是在ssh框架基础上实现用户注册

六、案例：简单的模仿用户注册

1.前台注册页面代码，index.jsp：

[html]  view plain  copy

 

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%  
3.     String path = request.getContextPath();  
4.     String basePath = request.getScheme() + "://"  
5.             + request.getServerName() + ":" + request.getServerPort()  
6.             + path + "/";  
7. %>  
8.   
9. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
10. <html>  
11. <head>  
12. <base href="<%=basePath%>">  
13.   
14. <title>欢迎注册</title>  
15. <meta http-equiv="pragma" content="no-cache">  
16. <meta http-equiv="cache-control" content="no-cache">  
17. <meta http-equiv="expires" content="0">  
18. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">  
19. <meta http-equiv="description" content="This is my page">  
20. <!-- 
21.     <link rel="stylesheet" type="text/css" href="styles.css"> 
22.     -->  
23. </head>  
24.   
25. <body>  
26.     <form action="${pageContext.request.contextPath }/user/regist" method="POST">  
27.     <!--  也可以使用user.username自动装入user属性，但在这里不是重点，所以就在后台手动获取其值-->  
28.         用户名：<input type="text" name="username"><br> 密  
29.           码：<input type="password" name="password"><br>  
30.         <input type="submit" value="注册">  
31.     </form>  
32. </body>  
33. </html>  

2.User类代码：

[java]  view plain  copy

 

1. package com.beauxie.bean;  
2.   
3. import javax.persistence.Entity;  
4. import javax.persistence.Id;  
5. import javax.persistence.Table;  
6.   
7. /** 
8.  * @author Beauxie 
9.  * 在这里User的属性应当与t_user表中的字段相同， 
10.  * 否则就需要手动为不相同的属性指定对应表中的字段 
11.  */  
12. @Entity//映射数据库表  
13. @Table(name="t_user")//不加这个注解，默认对应的是user表  
14. public class User {  
15.       
16.     @Id//对应t_user表中的主键  
17.     private int id;//用户ID  
18.       
19.     private String username;//用户名  
20.       
21.     private String password;//密码  
22.       
23.   
24.     public int getId() {  
25.         return id;  
26.     }  
27.   
28.     public void setId(int id) {  
29.         this.id = id;  
30.     }  
31.   
32.     public String getUsername() {  
33.         return username;  
34.     }  
35.   
36.     public void setUsername(String username) {  
37.         this.username = username;  
38.     }  
39.   
40.     public String getPassword() {  
41.         return password;  
42.     }  
43.   
44.     public void setPassword(String password) {  
45.         this.password = password;  
46.     }  
47.   
48. }  

3.UserDao类代码：

[java]  view plain  copy

 

1. package com.beauxie.dao;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.orm.hibernate3.HibernateTemplate;  
5. import org.springframework.stereotype.Repository;  
6.   
7. import com.beauxie.bean.User;  
8.   
9. /** 
10.  * @author Beauxie 
11.  * Dao层，对数据库进行操作 
12.  */  
13. @Repository//这个属性对应的是持久层(一般为Dao层)，说明交给spring管理，而对应的包下的类名也会有一个"S"  
14. public class UserDao {  
15.       
16.     @Autowired//自动注入，不需要设值，因为在spring配置文件中已经配置过  
17.     private HibernateTemplate template;  
18.       
19.       
20.     /** 
21.      * 用户注册，即向表中添加一条新的记录 
22.      * @param user 
23.      */  
24.     public void addUser(User user){  
25.         //往数据库中添加一条数据，一句话就可以搞定  
26.         template.save(user);  
27.     }  
28.   
29. }  

4.UserService类代码：

[java]  view plain  copy

 

1. package com.beauxie.service;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.stereotype.Service;  
5.   
6. import com.beauxie.bean.User;  
7. import com.beauxie.dao.UserDao;  
8.   
9. /** 
10.  * @author Beauxie 
11.  * Service层 
12.  */  
13.   
14. @Service//这个属性对应的是业务层一般为Service层)，说明交给spring管理，而对应的包下的类名也会有一个"S"  
15. public class UserService {  
16.   
17.     @Autowired//同样是自动注入  
18.     private UserDao userDao;  
19.       
20.     public void addUser(User user){  
21.         //调用Dao层的addUser方法  
22.         userDao.addUser(user);  
23.     }  
24. }  

5.UserAction类代码：

[java]  view plain  copy

 

1. package com.beauxie.action;  
2.   
3. import javax.servlet.http.HttpServletRequest;  
4.   
5. import org.apache.struts2.ServletActionContext;  
6. import org.apache.struts2.convention.annotation.Action;  
7. import org.apache.struts2.convention.annotation.Namespace;  
8. import org.apache.struts2.convention.annotation.Result;  
9. import org.apache.struts2.convention.annotation.Results;  
10. import org.springframework.beans.factory.annotation.Autowired;  
11. import org.springframework.context.annotation.Scope;  
12. import org.springframework.stereotype.Controller;  
13.   
14. import com.beauxie.bean.User;  
15. import com.beauxie.service.UserService;  
16.   
17. /** 
18.  * @author Beauxie 
19.  * 
20.  */  
21. @Controller//用于标注控制层组件  
22. @Namespace("/user")//url前缀  
23. @Scope("prototype")//Action默认是单例，但实际开发中，一般是多例，因为一般一个Action可能会对应多个不同的请求  
24. //@ParentPackage("struts-default")//继承特定的package，默认是“struts-default”，因此可以省略不写  
25. @Results({  
26.     @Result(name="registSuccess",location="/msg.jsp")  
27. })  
28. public class UserAction {  
29.       
30.     @Autowired//自动注入  
31.     private UserService service ;  
32.       
33.     //struts默认拦截“.action以及不加任何后缀”  
34.     @Action(value="regist")//访问：/user/regist.action 或  /user/regist  
35.     public String regist(){  
36.           
37.       //获取request  
38.       HttpServletRequest request = ServletActionContext.getRequest();  
39.          
40.       //获取表单提交的数据  
41.       String username =  request.getParameter("username");  
42.       String password = request.getParameter("password");  
43.       //封装userBean  
44.       User user = new User();  
45.       user.setId(1000);  
46.       user.setUsername(username);  
47.       user.setPassword(password);  
48.         
49.       //调用service层的方法，向数据库中增加一条记录  
50.       service.addUser(user);  
51.         
52.       //将提示信息存入request域中，用以前台显示  
53.       request.setAttribute("msg", "恭喜您，注册成功！<br>注册名："+username);  
54.         
55.         return "registSuccess";  
56.     }  
57.   
58. }  

6.消息提示界面：msg.jsp代码，如下：

[html]  view plain  copy

 

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%  
3.     String path = request.getContextPath();  
4.     String basePath = request.getScheme() + "://"  
5.             + request.getServerName() + ":" + request.getServerPort()  
6.             + path + "/";  
7. %>  
8.   
9. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
10. <html>  
11. <head>  
12. <base href="<%=basePath%>">  
13.   
14. <title>消息提示</title>  
15. <meta http-equiv="pragma" content="no-cache">  
16. <meta http-equiv="cache-control" content="no-cache">  
17. <meta http-equiv="expires" content="0">  
18. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">  
19. <meta http-equiv="description" content="This is my page">  
20. <!-- 
21.     <link rel="stylesheet" type="text/css" href="styles.css"> 
22.     -->  
23. </head>  
24.   
25. <body>  
26.     ${msg }  
27. </body>  
28. </html>  

7.将项目添加到服务器中，启动服务，打开浏览器，访问：http://localhost/SSHDemo/user/regist

8.输入用户名与密码，点击“注册”，显示结果：

9.控制台输出sql语句(在hibernateContext.xml文件中已经配置过输出并美化SQL语句)：

10.查看数据库结果：

到此这个简单的案例就已经结束了，关于表单提交数据校验、以及乱码问题并未涉及，后续应该会更新吧、、、

七、总结：

1.三大框架的整合，应该先引入每个框架以后，再整合；

2.一定要记得导入数据库jar包；

3.Action类应该要放在包名为"action"的包下，并且类名应当要以Action结尾，形如“XxxAction”;

4.在配置Hibernate时，一定要导入支持“@Entity”注解的jar包；

5.可以再struts.xml文件中定义struts拦截的请求类型，默认为.action与不加后缀

6.可以再web.xml文件中定义struts过滤器的过滤类型，默认为*.action,应当改为/*;

7.在applicationContext.xm文件中需要配置：sessionFactory、hibernate的实体类、hibernateTemplate模板 、数据源dataSource、spring扫描器五部分(包含hibernateContext.xml)；

8.各个类中一定要加上对应的注解，以及Action中的方法上也要加注解。

实例源码下载：http://download.csdn.net/detail/beauxie/9665583