myEclipse整合SSH步骤(基于操作和配置文件

一、准备工作：

　　1. JDK -> jdk1.6.0_17 安装(环境变量配置):

　　JAVA_HOME = C:\ jdk1.6.0_17;

　　PATH = %JAVA_HOME%\bin; %JAVA_HOME%\jre\bin;

　　CLASSPATH = .;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\lib\dt.jar ;

　　在Cmd -> java –version 查看JDK的版本是否与刚配好的版本一致。

　　2. apache-tomcat-6.0.24：解压即可；

　　3. myEclipse 8.5：安装(略)：

　　最高可提供：

　　框架：Java EE 5

　　Spring 3.0

　　Hibernate 3.3

　　Struts 2.1

　　4. DB：以MySQL 5.1为例。

　　二、打开myEclipse先配置好Tomcat服务器和JDK 操作好下图所示：

　　1. Window -> Preferences -> Java: Installed JREs

　　在这里可以不使用myEclipse自带的JDK，得Add…自己安装好的JDK：

　　001jdk.JPG

　　2. Window -> Preferences -> MyEclipse -> Servers: Tomcat 6.x

　　在这里配置Tomcat服务器，我们这里是选择6.x。Browse…自己将Tomcat解压放的目

　　录，再选择Enable，将它启用，然后Apply应用一下就Ok了。

　　00102.JPG

　　3. Window -> Preferences: Tomcat 6.x -> JDK 选择前面我们配好的JDK版本。

　　00103.JPG

　　4. 现在我们来启动Tomcat服务器，打开内部的浏览器测试Tomcat有没有配置成功，

　　如下图所示：则表示Tomcat服务器配置成功。

　　s.JPG

　　5. Window -> Preferences -> Java -> Build Path: User Libraries 在这里配置用户自己

　　要用jar包的Libraries。<说明> 这一步可以到后面需要添加自己的jar包时，再做也可以的。

　　00104.JPG

　　6. Window -> Preferences -> Java Build Path：在这里将自己上面配置好的Libraries添加到

　　编译请求的路径里。<说明> 这一步可以到后面需要添加自己的jar包时，再做也可以的。

　　00105.JPG

　　三、创建好Web项目，最先Add Spring如下图所示：

　　1. 选择项目名，右击 ->MyEclipse ->Add Spring Capabilities…

　　000.JPG

　　2. 勾选好Spring3.0 的五个核心Libraries，注意将它们Copy到/WebRoot/WEB-INF/lib目

　　录下，再点击Next > ：

　　002.JPG

　　003.JPG

　　3. 完成后，项目中将会出现Spring添加的东西，有时候可能会出现不名的错误，现在

　　暂时不需管它(推荐刷新项目)，有些原因是因为Spring的Xml配置文件里引入的东西有冲突。

　　004.JPG

　　四、创建数据源，切换到MyEclipse Database Explorer 窗口，如下图所示：

　　005.JPG

　　1. 在左边DB Browser的窗口里，右击选择New…新建一个数据源，出如下图所示的窗口：

　　根据自己项目所建的数据库来选择配置，引入连接驱动JARs包。

　　006.JPG

　　2. 配好后，点击Test Driver来测试配置连接是否成功。下图所示则表示成功了，再进行下一

　　步操作。

　　007.JPG

　　3. Schema Details选择连接映射的数据库，没必要将全部的数据库连接进来。

　　008.JPG

　　4. 配置好以后，然后选择它将它Open connection…打开看一看，能否将数据连接过来：

　　009.JPG

　　五、再将窗口切换回来，现在添加Hibernate 3.3

　　1. 选择项目名，右击 ->MyEclipse ->Add Hibernate Capabilities…，这里可以选择支持

　　Annotations注解方式来进行SSH的集成。注意将Library Copy到/WebRoot/WEB-INF/lib目录下：

　　010.JPG

　　2. 在对话框中选择Spring configuration file，表示我们希望将Hibernate托管给Spring

　　进行管理，这是将Hibernate与Spring进行整合的基础。然后点击Next：

　　011.JPG

　　3. 在出现的对话框中选择Existing Spring configuration file。因为我们已经添加了Spring

　　的配置文件，所以这里选择的是已存在的配置文件。MyEclipse会自动找到存在的那个文件。

　　然后在SessionFactory ID中输入Hibernate的SessionFactory在Spring配置文件中的Bean ID

　　的名字，这里我们输入sessionFactory即可。然后点击Next：

　　012.JPG 4. 在出现的对话框中的Bean Id里面输入数据源在Spring中的Bean ID的名字，这里我

　　们输入dataSource。然后在DB Driver里面选择我们刚刚配置好的ssh，MyEclipse会将其余

　　的信息自动填写到表格里面。然后点击Next

　　013.JPG

　　5. 在出现的对话框中取消Create SessionFactory class。点击Finish即可。

　　014.JPG

　　六、最后再Add Struts Capabilities: Struts2.1

　　1. 选择Struts 2.x之后配置窗口会变成下图所示，导入Struts2.1的Jars不可选入到

　　/WebRoot/WEB-INF/lib目录下。（以后我们再讲怎自己手动Add Struts整合）

　　2. 下一步再根据自己的情况另勾选Struts集成的应用包，Finish 一下就好了。

　　002.JPG

　　第二种： 自己手动添加Struts整合：找到自己收录的Struts 2.x架包，手动将Jars Ctrl+C

　　再Ctrl+V到/WebRoot/WEB-INF/lib目录下， 再将主要的xml配置文件struts.xml拷

　　贝到~/src/目录下即可。

　　到这里，我们整个项目的框架就算初步成形了，下面我们可以到MyEclipse Java Enterprise

　　视图下查看一下整个项目的结构，再进行后续操作。如下图所示：

　　七、Hibernate Reverse Engineering反向生成Pojo类，自动生成映射关系：

　　1. 再进入到MyEclipse Database Explorer视图，全选中所有的表，右击选择Hibernate

　　Reverse Engineering…操作，如下图所示：

　　003.JPG

　　2. Java src folder: 选项Browse…到自己新建好的包下面，我这里是放到Model(或者

　　DTO)层，如下图所示：

　　004.JPG

　　3. 再选择*.hbm.xml和POJO映射，注意我们不需选择：□Create abstract class，再Next:

　　005.JPG

　　4. 下一步再选择Id Generator的生成策略，我们选native，再点Next>，如下图所示:

　　006.JPG

　　5. 接下来，默认选项，直接点击Finish完成这项操作，如下图所示：

　　007.JPG

　　6. 最后回到MyEclipse Java Enterprise视图，查看是否已成功生成映射文件，如下图所示：

　　008.JPG

　　到这里我们就将SSH整合的所有操作都做好了，接下来就是进行编码工作，修改相应的

　　XML配置文件，最后到完成项目，发布web项目， 启动web服务器，运行测试项目。祝君

　　马到成功！~

　　************************************************** *****************************

　　八、添加在Web.xml文件里的配置：

　　1. Spring和Struts集成的配置，加载Spring容器：(Struts.x的方式: servlet、plug-in)：

　　<!-- 配置FilterDispatcher过滤器,以便加Spring容器 -->

　　<filter>

　　<filter-name>FilterDispatcher</filter-name>

　　<filter-class>

　　org.apache.struts2.dispatcher.FilterDispatcher

　　</filter-class>

　　</filter>

　　<filter-mapping>

　　<filter-name>FilterDispatcher</filter-name>

　　<url-pattern>/*</url-pattern>

　　</filter-mapping>

　　<!-- 配置Spring容器：指定Spring文件的路径，让spring知道事务管理的bean所在-->

　　<context-param>

　　<param-name>contextConfigLocation</param-name>

　　<!-- /WEB-INF/applicationContext-*.xml,classpath*:appli cationContext-*.xml

　　-->

　　<param-value>/WEB-INF/applicationContext.xml</param-v alue>

　　</context-param>

　　<!-- 在Struts2感知下，Spring容器的加载 -->

　　<listener>

　　<listener-class>

　　org.springframework.web.context.ContextLoaderListe ner

　　</listener-class>

　　</listener>

　　2. 添加连接池的配置，这里以Proxool为例：

　　<!-- 添加读连接池配置文件的servlet节点 -->

　　<servlet>

　　<servlet-name>proxoolServletConfigurator</servlet-nam e>

　　<servlet-class>

　　org.logicalcobwebs.proxool.configuration.ServletCo nfigurator

　　</servlet-class> <init-param> <param-name>xmlFile</param-name> <param-value>/WEB-INF/ProxoolConf.xml</param-value> </init-param> <!-- 由于proxool要先加载,所以启动优先级要比spring高,否则在spring加载

　　时会报错 -->

　　<load-on-startup>0</load-on-startup>

　　</servlet>

　　3. 添加事务配置Hibernate使用Session的关闭与开启由spring 来管理，针对Hivernate

　　懒加载；把一个Hibernate Session和一次完整的请求过程对应的线程相绑定：

　　<!--配置 OpenSessionInViewFilter或OpenSessionInViewInterceptor -->

　　<filter>

　　<filter-name>hibernateFilter</filter-name>

　　<filter-class>

　　org.springframework.orm.hibernate3.support.OpenSes sionInViewFilter

　　</filter-class>

　　<!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->

　　<init-param>

　　<param-name>singleSession</param-name>

　　<param-value>true</param-value>

　　<init-param>

　　</filter>

　　<filter-mapping>

　　<filter-name>hibernateFilter</filter-name>

　　<url-pattern>*.do(/*)</url-pattern>

　　</filter-mapping>

　　4. 添加字符编码过滤器：

　　<!-- Character Encoding 配置 -->

　　<filter>

　　<filter-name>Spring character encoding filter</filter-name>

　　<filter-class>

　　org.springframework.web.filter.CharacterEncodingFi lter

　　</filter-class>

　　<init-param>

　　<param-name>encoding</param-name>

　　<param-value>GBK</param-value>

　　</init-param>

　　</filter>

　　<filter-mapping>

　　<filter-name>Spring character encoding filter</filter-name>

　　<url-pattern>/*</url-pattern>

　　</filter-mapping>

　　5. 引入DWR框架，做Ajax应用：

　　<!-- 引入DWR框架 -->

　　<servlet>

　　<servlet-name>DWRServlet</servlet-name>

　　<servlet-class>org.directwebremoting.servlet.DwrServ let

　　</servlet-class>

　　<init-param>

　　<param-name>debug</param-name>

　　<param-value>true</param-value>

　　</init-param>

　　<load-on-startup>2</load-on-startup>

　　</servlet>

　　<servlet-mapping>

　　<servlet-name>DWRServlet</servlet-name>

　　<url-pattern>/dwr/*</url-pattern>

　　</servlet-mapping>

　　另外附加2.连接池配置 ：DBCP、月付美国空间Proxool、C3P0、JNDI方式

　　1. 导入连接池Jar包：Copy到~/WEB-INF/lib目录下；

　　修改好连接池的配置文件并将它Copy到~/WEB-INF/目录下。

　　2. 在applicationContext.xml中改dataSource节点(后续会讲)。

　　九、添加在Spring的 applicationContext.xml文件里的配置：

　　1. 连接池dataSource的配置：

　　<!-- 连接池 dataSource的配置 -->

　　<bean id="dataSource"

　　class="org.springframework.jdbc.datasource.DriverM anagerDataSource">

　　<property name="driverClassName" value="org.logicalcobwebs.proxool.ProxoolDriver"> </property> <property name="url" value="proxool.DBPool"></property> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSes sionFactoryBean"> <property name="dataSource"> <ref bean="dataSource" /> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect"> org.hibernate.dialect.SQLServerDialect </prop> <!-- Show SQL语句设置 -->

　　<prop key="hibernate.show_sql">true</prop>

　　<prop key="hibernate.format_sql">true</prop>

　　</props>

　　</property>

　　<property name="mappingResources">

　　<list>

　　<value>com/.../DTO/SysUser.hbm.xml</value>

　　<value>com/.../DTO/SysRole.hbm.xml</value>

　　<value>com/.../DTO/SysRight.hbm.xml</value>

　　... ...

　　</list>

　　</property>

　　</bean>

　　2. 添加处理业务逻辑的Beans，可以是DAOImpl、_Interceptor、导入xml文件等：

　　<!—- 处理整个用户业务操作的DAO一个Bean -->

　　<bean id="userDAO" class="com.Java7Group4CRM.DAOImp.SysUserDAOImp">

　　<property name="sessionFactory" ref="sessionFactory"></property>

　　</bean>

　　<!-- 处理用户登录的Action -->

　　<bean id="loginAction"

　　class="com.***.Actions.LoginAction" scope="prototype">

　　<property name="userDAo" ref="userDAO"></property>

　　</bean>

　　<!-- 验证用户权限的全局拦截器 -->

　　<bean id="action2ActionInterceptor"

　　class="com.***.interceptor.Action2ActionIntercepto r">

　　</bean>

　　3. 配置事务管理.相当于Spring AOP面向切面的配置：

　　A. 配置spring提供的事务管理的bean: HibernateTransactionManager对象.

　　<!-- spring提供的事务管理的bean -->

　　<bean id="transactionManager"

　　class="org.springframework.orm.hibernate3.Hibernat eTransactionManager">

　　<property name="sessionFactory" ref="sessionFactory"></property>

　　</bean>

　　B. 配置spring提供的将事务管理作为切面的作用于目标对象的代理bean:

　　TransactionProxyFactoryBean对象.

　　<!-- spring提供的 将事务管理 作为切面 作用于目标对象的代理 bean -->

　　<bean id="proxyObj"

　　class="org.springframework.transaction.interceptor .TransactionProxyFactoryBean" abstract="true"> <!—这是一个抽象类,只供类(target对象)继承 -->

　　<property name="transactionManager" ref="transactionManager" />

　　<property name="transactionAttributes">

　　<!--下面是配置出管理事务对应的(Dao的)方法 -->

　　<props>

　　<prop key="up*">PROPAGATION_REQUIRED</prop>

　　</props>

　　</property>

　　</bean>

　　C.现在可以配置target目标对象(Dao).[这里与普通的Dao配置不同]

　　<bean id="accountDao" parent="proxyObj"><!—这里指明其父类为以上代理bean -->

　　<property name="target">

　　<!--下面用匿名bean用作它本身的属性作为目标对象 -->

　　<bean class="com.***.daoimp.AccountDaoImp">

　　<property name="sessionFactory" ref="sessionFactory"></property>

　　</bean>

　　</property>

　　</bean>

　　<!-- 导入其他模块的配置文件 -->

　　<import resource="applicationContext_basd.xml"/>

　　十、添加在Struts2.x中struts.xml文件的配置：

　　1. 在主struts.xml配置文件里，可以引入其他模块的struts_*.xml文件和处理乱码的配置：

　　<!-- 导入其他模块的Actions配置文件 -->

　　<include file="struts_right.xml"/> <!-- 处理编码乱码的问题 -->

　　<constant name="struts.i18n.encoding" value="gbk"/>

　　2. 模块化的struts_*.xml配置文件：添加Spring代理：

　　<!-- 作国际化用的全局的资源文件的配置 -->

　　<!--<constant name="struts.custom.i18n.resources" value="resourceFile"

　　/>-->

　　<!--通过url来匹配action是由spring来生成action，

　　须在struts.xml中这里配置一个相当于Spring的代理

　　添加StrutsSpringObjectFactory所在的架包struts2-spring-plugin.jar

　　到”~/WEB-INF/lib”下-->

　　<constant name="struts.objectFactory"

　　value="org.apache.struts2.spring.StrutsSpringObjec tFactory" />

　　<!-- CRM~数据字典模块：分模块以<package>标签分开 -->

　　<package name="CRM_Basd" extends="struts-default">

　　<interceptors>

　　<!-- 功能模块的拦截器的声明 -->

　　<interceptor name="isAction2Action"

　　class="action2ActionInterceptor"/>

　　<interceptor name="rightInterceptor" class="rightInterceptor"/>

　　<!-- 声明一个作局部的权限拦截器椎栈 -->

　　<interceptor-stack name="rightStack">

　　<interceptor-ref name="rightInterceptor" />

　　<interceptor-ref name="defaultStack" />

　　</interceptor-stack>

　　<!-- 作全局拦截器椎栈区分Action跳转到Action -->

　　<interceptor-stack name="globalStack">

　　<interceptor-ref name="isAction2Action" />

　　<interceptor-ref name="defaultStack" />

　　</interceptor-stack>

　　</interceptors>

　　<!-- 应用全局的拦截器椎栈 -->

　　<default-interceptor-ref name="globalStack" />

　　<global-results>

　　<result name="none">/html/rightError.jsp</result>

　　</global-results>

　　<!-- ========\\\\ 数据字典业务处理的Action ////======== -->

　　<!-- 加载数据字典条目BasDict并分页使用的Action -->

　　<action name="loadBasDictAction" class="basDictAction"

　　method="loadBasDict">

　　<!-- 加入局部权限拦截 -->

　　<interceptor-ref name="rightStack"></interceptor-ref>

　　<result name="success">/html/~basd/dict.jsp</result>

　　<result name="input">/html/~basd/dict.jsp</result>

　　</action>

　　<action name="basDictLinkAction1" class="basDictAction"

　　method="link1Pages">

　　<!-- 未加入局部拦截器，全局拦截器将起效 -->

　　<result name="success">/html/~basd/dict.jsp</result>

　　<result name="input">/html/~basd/dict.jsp</result>

　　</action>

　　</package>

　　<!-- CRM~数据字典模块结束，下面可接其他模快的<package> -->

　　十一、组织编写代码：

　　1. DAO接口实现层对象的核心代码：

　　//成员化HibernateTemplate对象:

　　private HibernateTemplate hibernateTemplate;

　　//提供注入HibernateTemplate对象的setSessionFactory()方法

　　public void setSessionFactory(SessionFactory sessionFactory) {

　　this.hibernateTemplate = new HibernateTemplate(sessionFactory);

　　} //用户登录方法

　　public List loginUser(final SysUser user) throws Exception{

　　List loginUser = (List) hibernateTemplate.execute(new

　　HibernateCallback(){

　　public Object doInHibernate(Session session)

　　throws HibernateException, SQLException {

　　Query q = session.createQuery("from SysUser u where u.usrName=www.03723.com?

　　and u.usrPassword=?");

　　q.setParameter(0, user.getUsrName());

　　q.setParameter(1, user.getUsrPassword());

　　return q.list();

　　}});

　　return loginUser;

　　}

　　/**@用户登录后:获取TA的角色*/

　　public SysRole getUserRole(SysUser loginUser) throws Exception{

　　SysRole role = null;

　　String hql = "from SysRole sr where

　　sr.roleId="+loginUser.getSysRole().getRoleId().toS tring().trim();

　　role = (SysRole)hibernateTemplate.find(hql).get(0);

　　return role;

　　}

　　2. Action的核心代码：

　　public class LoginAction extends ActionSupport implements ServletRequestAware {

　　//IoC注入一个Request和DAO

　　private HttpServletRequest request;

　　private SysUserDAOImp userDAo;

　　public void setServletRequest(HttpServletRequest request) {

　　this.request = request;

　　}

　　public void setUserDAo(SysUserDAOImp userDAo) {

　　this.userDAo = userDAo;

　　}

　　private String usrName; //表单字段

　　private String usrPassword;

　　... ...

　　public String login() throws Exception {

　　System.out.println("usrName: "+usrName);

　　Map session = null;

　　SysUser user = new SysUser();

　　user.setUsrName(usrName);

　　user.setUsrPassword(usrPassword);

　　List list = userDAo.loginUser(user);

　　//排除验证完成后未查到符合的数据行时,调用get(0)索引溢出异常

　　if(list.size()!=0){

　　// 使用作用域对象容器ActionContext

　　SysUser loginUser = (SysUser)list.get(0);

　　session = ActionContext.getContext().getSession();

　　session.put("logId", loginUser.getUsrId());

　　session.put("logName", loginUser.getUsrName());

　　/**登录成功以后，再获取用户的角色*/

　　SysRole loginRole = userDAo.getUserRole(loginUser);

　　String roleName = loginRole.getRoleName();

　　session.put("roleName", roleName);

　　/**得到用户登录的角色以后，再获取用户所拥有的权限集合(操作节点集合) * 并将它保存到Session作用域中,以做权限校验*/

　　List rights = userDAo.getUserRight(loginRole);

　　session.put("rightList", rights);

　　System.out.println("logId:" + loginUser.getUsrId());

　　return SUCCESS;

　　}else{

　　return INPUT;

　　}

　　}

　　public void validateLogin() { //表单验证

　　if(this.usrName==null||"".equals(this.usrName)){

　　addFieldError("usrName", "用户名不能为空");

　　}

　　if(usrPassword==null||"".equals(usrPassword)){

　　addFieldError("usrPassword", "登录密码不能为空");

　　}

　　}

　　//作用域对象传值：

　　request.setAttribute("productPageDB", pageDB);

　　request.getSession(false).getAttribute("logId")

　　Map session = ActionContext.getContext().getSession();

　　session.put("logId", loginUser.getUsrId());

　　3. JSP页面代码：

　　A. 引入CSS和JS：

　　<link href="/***/html/css/style.css" rel="stylesheet" type="text/css">

　　<script src="/***/html/script/common.js"></script>

　　B. Form标签: <form action="loginAction.action" method="post" name="loginForm">

　　C. Struts2标签：

　　引入标签库：<%@ taglib uri="/struts-tags" prefix="s" %>

　　代码变化： <s:actionerror/> <s:form action="loginAction"></s:form>

　　D. JSTL标签：

　　引入JSTL库： <%@ taglib uri="java.sun/jsp/jstl/core" prefix="c" %>

　　引入Bean： <%@ page import="com.***.Pagination.PaginationSupport" %>

　　遍历标签：<table class="data_list_table">

　　<tr><th>编号</th><th>名称</th>...<th>备注</th></tr>

　　<% PaginationSupport pageDB = null;

　　List productList = null;

　　if(request.getAttribute("productPageDB")!=null){

　　pageDB =

　　(PaginationSupport)request.getAttribute("productPa geDB");

　　pageContext.setAttribute("pageDB",pageDB);

　　productList = pageDB.getItems();

　　System.out.println("productList.size():"+productLi st.size());

　　pageContext.setAttribute("productsList",productLis t);

　　}

　　if(productList.size()!=0){%>

　　<c:forEach var="product" items="${productsList}">

　　<tr><td class="list_data_number">${product.prodId}</td>

　　<td class="list_data_ltext">${product.prodName}</td>...

　　<td class="list_data_ltext">${product.prodMemo}</td> </tr>

　　</c:forEach>

　　<%}%>

　　<tr><th colspan="100" class="pager">分页操作按钮</th>

　　</tr>

　　</table>

转自http://hi.baidu.com/edoseqc032/blog/item/83563531fd8b084035a80ff3.html