用MyEclipse整合SSH框架-讲给菜鸟同学

时间：2023-01-22 15:15:05

啊啊毕竟是学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架构的划分，说实话我觉得简单的整合其实不用这么多层目录这么多关系，但是为了高内聚低耦合，为了标准为了以后不后悔，还是要这么个样子弄，具体哪个样子是最好的，我不知道，反正这个能用。。上图

用MyEclipse整合SSH框架-讲给菜鸟同学

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>
14.然后是web.xml的配置，这就相当于临门一脚：welcome页面设为目标页面；配置spring监听器（listener）， 配置全局变量中的paramvalue:/WEB-INF/spring/*.xml；配置日志加载器，Listener class为log4j路径，日志文件路径为classpath:log4j.properties；配置字符编码过滤器，设置字符编码和拦截路径*.jsp和*.action；配置处理hibernate Session关闭的过滤器；最后配置struts2的控制器（filter）。 

<?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里面，其实直接删掉也没啥大不了的把……不太清楚这个细节。

用MyEclipse整合SSH框架-讲给菜鸟同学这个版本高，有getline方法。

用MyEclipse整合SSH框架-讲给菜鸟同学这个自带的版本偏低了，没有哪个方法，所以不改会报错。



标签：

相关文章