啊啊毕竟是学JAVA起步的，虽然感觉它又重又麻烦，但是该会还是要会，这次总结了一下使用MyEclipse2014整合配置SSH的步骤，以供参考。
啊啊我学到的整合，整整15步才能全部搞定，当然如果熟练的话，一个小时基本就可以做出来了，而且有些步骤其实也不是必须的，只是可能用到，这是简单的过程：
1. 导入struts2.x（勾选spring支持包）——导入hibernate——导入spring（勾选hibernate支持包）
2. 创建目录结构：model、service、action-common-dao、vo
3. 创建model.POJO类与hbm.xml配置文件
4. 创建dao.iDeptDao接口，创建dao.impl.DeptDao类实现接口中的方法
5. 创建service.IDeptService接口，承接dao类接口，加注解@Transactional，创建service.impl.DeptService类实现服务类接口，用来调用dao类中的hibernate方法。
6. 创建vo.DeptVo类，复制dept.class类中的属性方法，用来支持页面模版数据传递
7. 创建action.DeptActionImpl类，继承ActionSupport类，定义业务方法：save（）、query（），
获取页面传入的vo表单数据，转换（copy）成Dept持久化对象，调用服务 类方法进行数据的添加，返回数据（request、session）
8. 创建jsp页面（放在WEB-INF目录下面提高安全性），s标签创建表单，
9. WEB-INF目录下创建spring文件夹，放入 spring配置文件applicationContext、beanContext.xml
10. src目录下放入beanContext .xml、hibernateContext.xml、log4j.properties、struts.xml配置文件
11. 配置applicationContext.xml：sessionFactory下配置hibernate.cfg.xml，配置mappingDirectoryLocation；
事务管理器下注入sessionFactory；配置hibernateTemplate，注入sessionFactory；注解配置transactionManager
12. 配置beanContext.xml：配置deptDao，注入hibernateTemplate；配置服务类deptservice，注入deptDao；配置deptAction，注入服务类
13. 配置struts.xml：package name：s1，extendsstruts-default；action标签拦截请求定向页面
14. 配置web.xml：welcome页面为目标页面；配置spring监听器（listener）， 配置全局变量中的paramvalue:/WEB-INF/SPRING/*.XML；配置日志加载器
Listener class为log4j路径，日志文件路径为classpath:log4j.properties；配置字符编码过滤器，设置字符编码和拦截路径*.jsp和*.action；
配置处理hibernate Session关闭的过滤器；最后配置struts2的控制器（filter）。
15. 替换struts包中存在版本冲突的antlr2.7.2包，页面输入数据调试代码
啊啊下面一步步详细讲：
1.导入struts2.x（勾选spring支持包）—导入hibernate—导入spring（勾选hibernate支持包）
啊啊导入的话自然是用MyEclipse的内置包导入了，右键项目各种添加，但是这个里面会有个问题就是，三大框架的包的版本有冲突，这也就是第十五步里面为什么要替换一下那个jar包了，有个getLine方法旧版本的没有，而新版本的被引用的时候还必须要，所以要手动替换一下。什么？那个包到底叫啥，我也没记住到底叫啥，啊哈哈，反正是那个样子。
2.创建目录结构：model、service、action-common-dao、vo
啊啊就是在SRC目录下面创建你自己的各种包，以此来明晰地实现MVC架构的划分，说实话我觉得简单的整合其实不用这么多层目录这么多关系，但是为了高内聚低耦合，为了标准为了以后不后悔，还是要这么个样子弄，具体哪个样子是最好的，我不知道，反正这个能用。。上图
3.创建model.POJO类（实现序列化Serializable接口、settergetter，有无参构造方法）与hbm.xml配置文件（mapping class name-table id-generater property）
啊啊MVC第一步，你先要有个模型，还是给hibernate用的持久化模型（当然数据库表早就要自己弄好啊，我自己弄了个简单的dept表），所以实现序列化接口，定义好模型的属性之后，要添加stter/getter方法，有参无参构造方法。然后给这个POJO类写hbm.xml配置文件，要加上hibernate的dtd声明，要把类和表的名字对上，主键要加一个自动生成的序列，其他的属性也要有写上：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.com.model">
<class name="Dept" table="DEPT">
<id name="deptno" column="DEPTNO">
<generator class="native">
<param name="sequence">DEPT_SEQ</param>
</generator>
</id>
<property name="dname"></property>
<property name="loc"></property>
</class>
</hibernate-mapping>4.创建dao.iDeptDao接口，创建dao.impl.DeptDao类实现接口中的方法（setter方法 注入hibernateTemplate）
啊啊传说中的面向接口编程？看起来明白一些。这里dao全称data access object，就和数据库打交道的接口方法的集合，既然是用了hibernate来代替原始的jdbc代码，那dao类就要注入hibernateTemplate对象了：
package cn.com.dao.impl;
import java.sql.SQLException;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import cn.com.dao.IDeptDao;
import cn.com.model.Dept;
public class DeptDao implements IDeptDao{
private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
System.out.println( "DeptDao setHibernateTemplate:"+hibernateTemplate );
this.hibernateTemplate = hibernateTemplate;
}
@Override
public int save(Dept dept) {
// TODO Auto-generated method stub
try{
hibernateTemplate.save( dept );
}catch( Exception e ){
System.out.println( e.getMessage() );
return 0;
}
return 1;
}}5.创建service.IDeptService接口，承接dao类接口，创建service.impl.DeptService类实现服务类接口，因为是spring管理一定要加上@transactional注解；调用dao类中的方法。
啊啊又是接口，其实它不用打酱油的，但是简单的整合它就是会打酱油，接口不写，直接看实现类：
package cn.com.service.impl;
import org.springframework.transaction.annotation.Transactional;
import cn.com.dao.IDeptDao;
import cn.com.model.Dept;
import cn.com.service.IDeptService;
@Transactional
public class DeptService implements IDeptService{
//注入 DeptDao
private IDeptDao deptDao;
public void setDeptDao(IDeptDao deptDao) {
System.out.println( "DeptService setDeptDao注入："+deptDao );
this.deptDao = deptDao;
}
@Override
public int save(Dept dept) {
// TODO Auto-generated method stub
return deptDao.save(dept);
}
@Override
public String queryLoc(String dname) {
// TODO Auto-generated method stub
return deptDao.queryLoc(dname);
}
}6.创建VO.DeptVo类，复制dept.class类中的属性方法，支持页面模版数据传递
啊啊是的，你需要一个vo类来接收转换数据，当然你也可以不用。内容就是把model类里面的属性方法复制过来。不同层之间的传递这种脏活儿还是不要麻烦model了。7.创建action.DeptActionImpl类，继承ActionSupport类，setter方法注入deptservice对象，setter、getter方法注入deptVo类（注意表单中的属性名字必须前缀dept，且与属性名相同），定义业务方法：save（）、query（），获取页面传入的vo表单数据并转换（copy）成Dept持久化对象（实例化Dept类，BeanUtils.copyProperties（1，2）），调用服务类方法进行数据的添加，返回数据（request、session）。
啊啊要用到哪里的方法，自然是要先注入对象，一环套一环，真正的控制器来了，控制就是让谁谁谁去干啥啥啥，自己其实也就是发号施令，让我们动起来~（为什么总是会有一些没用到的类呢，因为不只这一个方法……）
package cn.com.action;
import java.util.Map;
import org.springframework.beans.BeanUtils;
import cn.com.model.Dept;
import cn.com.service.IDeptService;
import cn.com.vo.DeptVo;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import org.springframework.orm.hibernate4.support.OpenSessionInViewFilter;
public class DeptActionImpl extends ActionSupport{
//注入DeptService
private IDeptService deptService;
private DeptVo deptVo;//表单的元素名字要加dept前缀 表单元素名字要与DeptVo类的名字相同
public DeptVo getDeptVo() {
return deptVo;
}
public void setDeptVo(DeptVo deptVo) {
this.deptVo = deptVo;
}
public void setDeptService(IDeptService deptService) {
System.out.println( "DeptActionImpl setDeptService注入:"+deptService );
this.deptService = deptService;
}
//业务方法 添加部门信息
public String saveDept(){
System.out.println( "======DeptActionImpl saveDept=====" );
System.out.println( "dname:"+deptVo.getDname()+" loc:"+deptVo.getLoc() );
//把deptVo类中的数据copy到Dept持久化对像中
Dept dept = new Dept();
//1：源 2：目标 通过反射把相同名字的属性值进行copy
BeanUtils.copyProperties( deptVo, dept );
//调用服务类进行数据的添加
int flag = deptService.save( dept );
//获取request
Map request = (Map)ActionContext.getContext().get( "request" );
if( flag > 0 ){//添加成功
request.put( "msg", "部门信息添加成功!" );
}else{//添加失败
request.put( "msg", "部门信息添加失败!" );
}
return this.INPUT;
}}8.创建jsp页面（放在WEB-INF目录下面），s标签创建表单
啊啊View来了，虽然我一般喜欢先弄view，这样比较踏实，想的业务逻辑也比较倾向于用户，但是这没关系。放在WEB-INF目录下会提高安全性，页面不会被随意直接访问，导入标签库，然后做一个表单提交vo数据。表单action请求写绝对路径也是因为放在了web-inf目录下，name写清楚才好配置拦截。
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'Dept.jsp' starting page</title>
</head>
<body>
<center>
msg:${msg }
<hr/>
<s:form action="/ssh/dept_saveDept">
<s:textfield name="deptVo.dname" key="dname"></s:textfield>
<s:textfield name="deptVo.loc" key="loc"></s:textfield>
<s:submit></s:submit>
</s:form>
<hr/>
<s:form action="/ssh/dept_queryLoc">
<s:textfield name="deptVo.dname" key="dname"></s:textfield>
<s:submit></s:submit>
</s:form>
<hr/>
loc:${loc }
</center>
</body>
</html>啊啊写到这里基本上MVC的架构已经出来了，但是三大框架和他们的关联还没有建立起来，所以要对它们进行配置。Struts2:主要是做web框架用来处理客户的http请求/响应的MVC模式；Hibernate则是重放ORM框架、持久化框架，对数据库操作，用来封装jdbc 代码；Spring用来做 IOC控制反转，依赖注入，面向切面编程， 建立类与类之间，模块与模块之间，框架与框架之间的关联，实现无缝联接。（其实这是老师说的）Ssh三大框架整合：把struts2,hibernate中的类的实例，类的关联交给spring去管理。Struts2获取客户端请求，创建一个对应的action类。 把action类的创建交给spring去管理。
9.WEB-INF目录下创建spring文件夹，放入 spring配置文件applicationContext.xml、beanContext.xml
10.src目录下放入beanContext .xml、hibernateContext.xml、log4j.properties、struts.xml
啊啊把配置文件创建放好之后，就要开始对它们进行配置了熟练的人觉得没什么，可以拿来复制粘贴搞定，不熟的人还是去看对应框架的教程吧，很多时候觉得做起来无比困难就是因为基础没打好，理解不到位。
11.配置applicationContext.xml：
啊啊sessionFactory下配置hibernate.cfg.xml，配置mappingDirectoryLocation；事务管理器下注入sessionFactory；配置hibernateTemplate，注入sessionFactory；注解配置transactionManager
<?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.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" xmlns:tx="http://www.springframework.org/schema/tx">
<!-- 配置数据源 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 加载classpath下hibernate.cfg.xml配置文件 -->
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
<property name="mappingDirectoryLocations">
<list>
<value>classpath:cn/com/model</value>
</list>
</property>
</bean>
<!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置HibernateTemplate -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 注解方式配置 -->
<tx:annotation-driven transaction-manager="transactionManager" /></beans>
12. 配置同目录下的beanContext/xml：配置deptDao，注入hibernateTemplate；配置服务类deptservice，注入deptDao；配置deptAction，注入服务类
啊啊这里要说一下，hibernate.cfg.xml和log4j.properties直接那以前配置过的用就可以了，就不算什么一步了~这里bean的配置就好像是控制器的注册一样的感觉……
<?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.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" xmlns:tx="http://www.springframework.org/schema/tx">
<!-- 配置deptDao -->
<bean id="deptDao" class="cn.com.dao.impl.DeptDao">
<!-- 注入hibernateTemplate -->
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
<!-- 配置deptService -->
<bean id="deptService" class="cn.com.service.impl.DeptService">
<!-- 注入deptDao -->
<property name="deptDao" ref="deptDao"></property>
</bean>
<!-- 配置deptAction -->
<bean id="deptAction" scope="prototype" lazy-init="false" class="cn.com.action.DeptActionImpl">
<!-- 注入 dpetService -->
<property name="deptService" ref="deptService"></property>
</bean>
</beans>13.配置struts.xml，package name：s1，extendsstruts-default；action标签拦截请求定向页面
啊啊前面提到了，struts框架主要负责接受网页请求等事务，配置的重点也是这个。<?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="s1" extends="struts-default">
<!-- 通过 -->
<action name="*_*" class="deptAction" method="{2}">
<result name="input">/WEB-INF/dept/Dept.jsp</result>
</action>
</package>
</struts> <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>ssh</display-name>
<welcome-file-list>
<welcome-file>/WEB-INF/dept/Dept.jsp</welcome-file>
</welcome-file-list>
<!-- spring监听器，加载spring配置文件 建立类与类的关联 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 全局变量，spring监听器会读取变量对应的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/*.xml</param-value>
</context-param>
<!-- 配置日志加载器 -->
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<!-- 设置log4j日志 文件 的路径 -->
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.properties</param-value>
</context-param>
<!-- 配置字符编码过滤器 -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!-- 设置字符编码 -->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<!-- 配置字符编码拦截的路径 -->
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<!-- 配置处理hibernate session关闭的过滤器 -->
<filter>
<filter-name>hibernateSessionClose</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
<init-param>
<param-name>singleSession</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!-- 配置拦截的路径 -->
<filter-mapping>
<filter-name>hibernateSessionClose</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<!-- 配置struts2控制器=================================== -->
<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>/*</url-pattern>
</filter-mapping>
</web-app>15.最后要把struts包里面的antlr包替换掉，可以全删掉然后拷贝一分不带这个antlr2.7.2的包放在lib里面，其实直接删掉也没啥大不了的把……不太清楚这个细节。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
