`
1028826685
  • 浏览: 938729 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类

struct1.x+spring2.x+hibernate整合

    博客分类：
  • J2EE
struct1.x+spring2.x+hibernate整合 
阅读更多
  
    开发j2ee其实最复杂的就是环境搭建和框架的整合了，在这里总结一下使比较流行的三大框架struct1.x+spring2.x+hibernate整合。这个过程非常的复杂请耐心读完，在这个过程中也实际操作一下环境的搭建。现在就开始吧！

  第一步：
   * 配置structs
     <1、拷贝全部的struct的*.jar和jstl类库(在jsp中药使用EL表达式)jstl.jar和standard.jar

     <2、修改web.xml文件配置ActionServlet如下：(例子中参考)
     
<servlet>
        <servlet-name>action</servlet-name>
        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

        <!-- Default -->
        <init-param>
            <param-name>config</param-name>
            <param-value>/WEB-INF/struts-config.xml</param-value>
        </init-param>
         <init-param>
            <param-name>debug</param-name>
            <param-value>2</param-value>
        </init-param>
        <init-param>
            <param-name>detail</param-name>
            <param-value>2</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>action</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
      

     <3、在WEB-INF下提供struts-config.xml文件 (例子中参考)如下：
  
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
        "http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>


<!-- 用做国际化 -->
<message-resources parameter="MessageResources"/>


</struts-config>

    <4、提供国际化只有文件
(参考\apps\struts-blank-1.3.8\WEB-INF\src\java\)下的资源属性文件
MessageResources.properties
拷贝到src目录下(注意：这不是必须的)

   第二步：

     * 配置spring
     <1、 拷贝spring类库
       spring.jar、commons-loging.jar(覆盖低版本的)、log4j-*.jar
AOP(aspectjrt.jar、aspectjweaver.jar)

      <2、提供spring配置文件
       在src目录下提供applicationContext-bean.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

</beans>

     <3、接下来我们需要让spring容器来管理beanFactory，这样就可以使用对象注入来解决耦合 。 配置Web.xml文件如下

<!--
    <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:applicationContext-*.xml,/WEB-INF/applicationContext-*.xml</param-value>
    </context-param>
-->
  <!-- 读取spring applicationContext-*.xml配置文件得到beanFactory对象-->
    <context-param>
         <param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext-*.xml</param-value>
</context-param>
<!-- 负责得到beanFactory并放到serveltContext-->
<listener>
<listenerclass>org.springframework.web.context.ContextLoaderListener</        listener-class>
</listener>


   此时struts1.x和spring整合完成 我们写个例子测试一下：

第一步：我们先写需要的页面*.jsp
   index.jsp、login.jsp、success.jsp

index.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
   
    <title>spring和struct第二种集成方案</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
  </head>
 
  <body>
   <a href="logininput.do">登录</a><br>
   <a href="login.jsp">登录</a>
  </body>
</html>

  login.jsp:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
      <title>登陆页面</title>
   
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->

  </head>
 
  <body>
<!-- <%=request.getContextPath() %>/login.do -->
<!-- /SS1.x/login.do -->
<!-- login.do -->
   <form action="login.do" method="post">
用户名：<input type="text"  name="username"> <br>
密码：<input type="password"  name="password"><br>
<input type="submit" value="提交">
</form>
  </body>
</html>

  success.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
      <title>登陆页面</title>
   
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->

  </head>
 
  <body>
<!-- <%=request.getContextPath() %>/login.do -->
<!-- /SS1.x/login.do -->
<!-- login.do -->
   <form action="login.do" method="post">
用户名：<input type="text"  name="username"> <br>
密码：<input type="password"  name="password"><br>
<input type="submit" value="提交">
</form>
  </body>
</html>

  第二步：struts1.x需要使用到ActionFrom 来封装数据
   新建一个LogingActionForm.java

  public class LogingActionForm extends ActionForm {

private String username;
private String password;


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;
}


}
  第三步：需要一个Action 新建一个名LogingAction.java来做页面逻辑和导向
 
public class LogingAction extends Action {
//使用spring 注入bean
private UserManger userManger;

public void setUserManger(UserManger userManger) {
this.userManger = userManger;
}

@Override
      public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response)
      throws Exception {

LogingActionForm logingActionForm=(LogingActionForm)form;

userManger.Loging(logingActionForm.getUsername(), logingActionForm.getPassword());

return mapping.findForward("success");
}
}


     第四步：编写业务层一般面向借口编程所以新建一个接口

   public interface IUserManger {

public abstract void Loging(String username, String password);

}
    第五步：业务层实现
   
public class UserManger implements IUserManger {
public void Loging(String username,String password)
{
//简单的打印一句话
  System.out.println("loging..."+username+":"+password);
}
}
  
  接下来因为我们要注入一个业务bean使用spring所以我们需要把这个业务类交个spring管理配置如下：
  新建一个applicationContext-acton.xml(因为spring读取时候我们配置了通配符所以不用担心不会被加载文件)
 
<?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:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
     <bean name="/login" class="com.liyong.actions.LogingAction"
<!--scope="prototype"指定这个bean是原型不是单例这解决了action的线程安全问题-->
scope="prototype">
       <!--为userManger属性注入userManger对象因为在applicationContext-bean.xml中申明了所以直接引用-->

<property name="userManger" ref="userManager"/>
</bean>
</beans>


在接下来配置struts-config.xml文件配置Action 如下：
 
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
        "http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>

    <form-beans>
<form-bean name="loginForm" type="com.liyong.forms.LogingActionForm" />
</form-beans>
<action-mappings>
    <action path="/logininput" forward="/login.jsp">
</action>
<!--
由spring来创建这个action spring的一个代理类 这个代理类会去实例化beanFactory,然后再去实例化我们的Action
path="/login" 必须与 applicationContext-acton.xml中bean的name="/login" 相同这样才会去实例化这个Action
-->
<action path="/login"
       type="org.springframework.web.struts.DelegatingActionProxy"
name="loginForm"
scope="request"
>
<!--formbean 默认放在seesion中 改为 scope="request"  -->

<forward name="success" path="/success.jsp"/>
</action>
</action-mappings>

<!-- 用做国际化 -->
<message-resources parameter="MessageResources"/>


</struts-config>

  上面就把spring+strut1.x集成完成，那么下面我们来集成hibernate步骤如下：
 
   *配置hibernate

    <1、拷贝hibernate所以得*.jar文件

     <2、编写一个hibernate.cfg.xml配置文件(参考例子)在src目录下如下：

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.  -->
<hibernate-configuration>

    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/mysql</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="myeclipse.connection.profile">mysql</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>

</hibernate-configuration>   
   

  <3、编写一个日志属性文件log4j.properties在src目录下(参照例子)

  ### direct log messages to 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

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
#log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace


<4、编写一个事务文件在src目录下applicationContext-common.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:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 配置sessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>          

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>

<!-- 配置事务的传播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="modify*" propagation="REQUIRED"/>
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>

<!--
那些类的哪些方法参与事务   下面的expression需要修改
com.liyong.server.manager.*.*(..))
-->
<aop:config>
<aop:pointcut id="allManagerMethod" expression="execution(* com.liyong.server.manager.*.*(..))"/>
<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>
</aop:config>
</beans>

  <5、处理中文字符在web.xml文件中配置filter
 
<!--
如何提交中文字符？配置web.xml了，Spring提供了专门的针对Encoding的过滤器
-->

<filter>
    <filter-name>Spring character encoding filter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</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>

  <6、了避免Hibernate的懒加载异常而创建的解决方案
 
  这是为了避免Hibernate的懒加载异常而创建的解决方案
它是一个过滤器，能够让Session在请求解释完成之后再关闭（所以才能够避免懒加载异常）
   -->
   <filter>
    <filter-name>hibernateFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
  </filter>
<filter-mapping>
    <filter-name>hibernateFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

   <7、检查所导入的*.jar包是否有重复的去掉低版本的jar包
 
 
.....集成成功.....
  
  
分享到：
| Mysql 乱码解决
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis是两种常见的Java Web应用程序集成框架，它们分别基于ORM框架Hibernate和轻量级数据访问框架Ibatis。这两种框架结合Spring，旨在提供一个强大的、可扩展的、易于...

    struct2+spring+hibernate的整合的例子

    在这个"struct2+spring+hibernate的整合的例子"中，提供的"实验一 SSH整合.doc"文档很可能是详细的步骤指南，引导读者逐步完成整合过程。而"ssh4.zip"可能包含了示例项目的源代码和配置文件，供学习者参考和实践。 ...

    struct+spring+hibernate依赖包大全

    这个"Struct+Spring+Hibernate依赖包大全"提供了这三个框架最新版本所需的全部jar包，使得开发者能够快速搭建一个完整的SSH集成开发环境。 1. **Struts**： Struts是Apache组织开发的一个开源MVC框架，它为Web应用...

    基于struct+spring+hibernate框架整合详解

    4. **整合三者**：使用Spring插件使Struts2与Spring交互，通过SessionFactory实例化Hibernate Session，实现业务逻辑。 SSH框架的整合大大简化了Java Web应用的开发流程，提高了开发效率。然而，随着技术的发展，...

    Struct2+Hibernate3+Spring3整合的纯净Demo

    总的来说，SSH整合提供了一种成熟、稳定的企业级应用开发模式，它结合了Spring的IoC和AOP特性、Hibernate的ORM能力以及Struts2的MVC设计，使得开发者能够更专注于业务逻辑，而不是底层实现细节。在实际项目中，通过...

    struts2+spring+hibernate+easyui管理框架

    Struts2+Spring+Hibernate+EasyUI 是一个经典的Java Web开发框架组合，广泛应用于企业级应用的构建。这个管理系统利用这些技术的特性，提供了一种高效、稳定且易于维护的解决方案。 **Struts2** 是一个强大的MVC...

    struct + hibernate +spring组装例

    - **整合Hibernate和Spring**：Spring通过其Hibernate支持模块（Spring-Data-JPA或Hibernate-ORM）管理SessionFactory和Session，为DAO层提供数据访问服务。这使得在DAO中可以使用注解配置来执行数据库操作，简化了...

    struct 2 + spring + hibernate 学习实例

    通过这个实例，你可以深入了解Struts 2、Spring和Hibernate的整合使用，学习如何构建一个完整的Java Web应用，掌握MVC模式和企业级开发的最佳实践。这不仅对个人技能提升有帮助，也为将来参与大型项目开发奠定了坚实...

    图书管理系统spring+struts+hibernate

    library_ssh2可能是一个包含系统源代码的压缩文件，"ssh2"可能表示系统使用了Struts2、Spring2和Hibernate2这三个框架的早期版本。这个文件中应包含所有必要的Java源代码、配置文件、Web应用相关的资源（如JSP页面、...

    在Netbeans中使用Struts2.0+Spring2.5+Hibernate框架

    其中，Struts2、Spring与Hibernate作为经典的“SSH”组合（Struts-Spring-Hibernate），在Java Web开发领域占据着重要的地位。本文旨在通过一个简单的登录示例项目，详细介绍如何在Netbeans IDE环境下构建基于Struts...

    struts2+spring+hibernate整合步骤

    以上就是Struts2、Spring和Hibernate整合的基本步骤。在这个过程中，需要注意的是，配置文件的正确性至关重要，包括web.xml、struts.xml、applicationContext.xml和hibernate.cfg.xml。此外，理解各个框架的核心功能...

    struct+spring+Hibernate框架整合文档

    **SSH框架整合详解** SSH（Struts2、Spring、Hibernate）是Java开发中常见的三大开源框架，它们分别负责MVC...阅读提供的文档如`struts2-spring-hibernate.doc`和`SSH2整合.doc`，可以获取更详尽的步骤和注意事项。

    spring+hibernate+struct2框架整合

    1. 引入所需的jar包，包括Spring、Hibernate、Struts2及其依赖。 2. 创建并配置Spring的`applicationContext.xml`，定义数据源、SessionFactory、事务管理器等。 3. 在`web.xml`中配置Spring的上下文加载监听器`...

    网络硬盘（struct 2+hibernate+spring）实现

    **整合Struts 2、Hibernate和Spring**： 将这三个框架整合在一起，可以创建一个强大的Web应用程序。Struts 2处理HTTP请求并调用业务逻辑，Spring管理对象依赖，而Hibernate则作为数据访问层，负责与数据库的交互。...

    Spring3.1.1+Struct+hibernate3.x必须的jar包

    在"Spring3.1.1+Struct+hibernate3.x必须的jar包"中，"hibernate3.x必须的包.rar"可能包含了Hibernate框架所需的各种jar文件，如hibernate-core、hibernate-annotations、hibernate-commons-annotations等。...

    (Struts2+Spring4+Hibernate3)ssh整合全部所需jar包 - 38个

    在实际开发中，开发者还需要导入SSH整合所需的jar包，包括Struts2、Spring、Hibernate的核心库以及它们的依赖。例如，Struts2的struts2-core、Spring的spring-context、spring-beans、spring-tx，以及Hibernate的...

    spring4+struct2+hibernate4的整合

    下面我们将详细探讨Spring 4、Struts2和Hibernate4的整合以及相关的知识点。 首先，Spring 4框架是IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）的代表，它为应用提供...

    spring+struts2+hibernate整合实现分页

    在这个项目中，“spring+struts2+hibernate整合实现分页”是一个基础教程，旨在帮助初学者理解如何在SSH框架下实现数据的分页展示。下面将详细讲解这个主题中的关键知识点。 1. **Spring框架**：Spring是Java应用的...

    网上商城struts2+spring+hibernate

    5. 整合应用：将Struts2、Spring和Hibernate整合在一起，可以实现高度解耦和模块化的开发。Spring可以管理Struts2的Action实例，以及Hibernate的数据访问对象（DAO），使得整个系统更加灵活和可扩展。同时，这三者...

    Struts+Hibernate+Spring的基本流程

    Struts+Hibernate+Spring（SSH）整合是Java Web开发中常见的技术栈，它结合了三个强大的框架，分别负责MVC架构、对象关系映射（ORM）以及依赖注入和AOP（面向切面编程）。SSH整合使得开发过程更加高效且易于维护。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics