`
ivorytower
  • 浏览: 74161 次
  • 性别: Icon_minigender_1
  • 来自: 成都-->@深圳
社区版块
存档分类
最新评论

Spring+Hibernate+Struts 整和

StrutsSpringHibernateBeanXML 
阅读更多
spring加载log4j
   web.xml 
  
   < context - param > 
     < param - name > log4jConfigLocation </ param - name > 
     < param - value >/ WEB - INF / classes / log4j.properties </ param - value > 
   </ context - param > 
   < listener > 
     < listener - class > org.springframework.web.util.Log4jConfigListener </ listener - class > 
   </ listener >

一.spring+struts
1.加载springContext
      通过struts-config.xml中增加plug-in插件来加载springContext 
   <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
     <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
   </plug-in>
   
applicationContext.xml为spring的配置文件

2.将strutsAction交给Spring容器进行管理
      修改struts-config.xml中的action属性,action的type值不指定具体的实现类,统一修改成代理类 
    <action input="/login.jsp" 
         name="loginActionForm"
         path="/loginAction" 
         scope="request"   
         type="org.springframework.web.struts.DelegatingActionProxy" 
         validate="false">
      <forward name="success" path="/success.jsp" />
      <forward name="failure" path="/failure.jsp" />
    </action>

3.在applicationContext.xml中的bean name值设定与struts-config.xml中action path值相对应,以使代理类DelegatingActionProxy能够根据传入的path在springContext中找到相应的bean,并将实例返回给struts. 
 
<bean name="/loginAction" class="com.derek.action.LoginAction" singleton="false">
  <property name="login">
    <ref bean="loginBOProxy" />
  </property>
</bean>

二.spring+hibernate
   1.dateSource
      在springContext中设置dateSource Bean 
 
     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="net.sourceforge.jtds.jdbc.Driver"></property>
        <property name="url" value="jdbc:jtds:sqlserver://192.168.56.32:1433/testDB"></property>
        <property name="username" value="it"></property>
        <property name="password" value="it"></property>
     </bean>
   
     2.sessionFactory
       在springContext中设置sessionFactory Bean 
  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="mappingResources">
        <list>
          <value>hbm\OvertimeRecord.hbm.xml</value><!--hbm映射文件-->
          <value>hbm\OvertimePermit.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <props>
           <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
           <prop key="hibernate.show_sql">true</prop>
           <prop key="hibernate.jdbc.fetch_size">50</prop>
           <prop key="hibernate.jdbc.batch_size">20</prop>
        </props>
    </property>
  </bean>
 
  3.transactionManager
   在springContext中设置transactionManager Bean 
 
   <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory">
       <ref local="sessionFactory" />
     </property>
   </bean>

   4.DAO bean 
 
      <bean id="Ilogin" class="com.derek.business.Login">
          <property name="sessionFactory">
              <ref local="sessionFactory"/>
          </property>
      </bean>
     
       public class Login extends HibernateDaoSupport implements LoginInterface
      DAO 继承HibernateDaoSupport
      HibernateSupport实现了HibernateTemplate和SessionFactory实例的关联, HibernateTemplate对Hibernate Session操作进行了封装，HibernateTemplate.execute方法则是一封装机制的核心. 借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作.
        Spring中的事务管理实际上是基于动态AOP机制实现，为了实现动态AOP，Spring在默认情况下会使用Java DynamicProxy，但是，Dynamic Proxy要求其代理的对象必须实现一个接口，该接口定义了准备进行代理的方法。而对于没有实现任何接口的Java Class，需要采用其他方式，Spring通过CGLib实现这一功能。

   5.DAOProxy 代理bean
        通过代理,将上面的DAO bean 纳入到spring容器的事务管理中,并在其中设置对哪些方法进行事务管理 
 
     <bean id="loginBOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
           <property name="transactionManager">
                <ref bean="transactionManager" />
           </property>
           <property name="target">
                <ref local="Ilogin" /> <!--所代理的bean-->
           </property>
           <property name="transactionAttributes">
                <props>
                     <prop key="insert*">PROPAGATION_REQUIRED</prop> <!--以insert开头的方法加入事务管理-->
                     <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> <!--以get开头的方法只读-->
                </props>
           </property>
      </bean>
   
    6.action bean 
 
      <bean name="/loginAction" class="com.derek.action.LoginAction" singleton="false">
         <property name="login">
            <ref bean="loginBOProxy" /> <!--要将其使用的DAO bean加入事务管理,就必须ref他的代理bean,且在LoginAction中该属性须由其接口强制类型转换-->
         </property>
      </bean>

示例代码:
  struts-conifg.xml 
 
<? xml version = " 1.0 "  encoding = " UTF-8 " ?> 
<! DOCTYPE struts - config PUBLIC  " -//Apache Software Foundation//DTD Struts Configuration 1.1//EN "   " http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd " > 
< struts - config > 

   < form - beans > 
     < form - bean name = " loginActionForm "  type = " com.derek.form.LoginActionForm "   /> 
   </ form - beans > 
   < action - mappings > 
     < action input = " /login.jsp "  name = " loginActionForm "  path = " /loginAction "  scope = " request "  type = " org.springframework.web.struts.DelegatingActionProxy "  validate = " false " > 
       < forward name = " success "  path = " /success.jsp "   /> 
       < forward name = " failure "  path = " /failure.jsp "   /> 
     </ action > 
   </ action - mappings > 
   < plug - in className = " org.springframework.web.struts.ContextLoaderPlugIn " > 
     < set - property property = " contextConfigLocation "  value = " /WEB-INF/applicationContext.xml "   /> 
   </ plug - in > 
</ struts - config >

  applicationContext.xml 
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans SYSTEM "D:\JAVA\MyWork\SpringDemo\SpringWeb\WEB-INF\spring-beans.dtd">
<!--DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"-->

<!--
  - Root application context for the Countries application.
  - Web-specific beans are defined in "countries-servlet.xml".
  -->
<beans>

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName" value="net.sourceforge.jtds.jdbc.Driver"></property>
 <property name="url" value="jdbc:jtds:sqlserver://192.168.56.32:1433/testDB"></property>
 <property name="username" value="it"></property>
 <property name="password" value="itservice"></property>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
 <property name="dataSource" ref="dataSource"></property>
 <property name="mappingResources">
  <list>
    <value>hbm\OvertimeRecord.hbm.xml</value>
    <value>hbm\OvertimePermit.hbm.xml</value>
  </list>
 </property>
 <property name="hibernateProperties">
  <props>
     <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
     <prop key="hibernate.show_sql">true</prop>
     <prop key="hibernate.jdbc.fetch_size">50</prop>
     <prop key="hibernate.jdbc.batch_size">20</prop>
  </props>
 </property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
   <property name="sessionFactory">
       <ref local="sessionFactory" />
   </property>
</bean>


<!---------------使用JNDI数据源----------------
bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
  <value>jdbc/cqccms</value>
</property>
<property name="jndiEnvironment"> 
     <props> 
        <prop key="java.naming.factory.initial"> 
          weblogic.jndi.WLInitialContextFactory 
        </prop> 
        <prop key="java.naming.provider.url">t3://172.16.101.42:7001</prop> 
        <prop key="java.naming.security.principal">weblogic</prop> 
        <prop key="java.naming.security.credentials">weblogic</prop> 
     </props>    
   </property> 
</bean>

<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate" singleton="true"
  lazy-init="default" autowire="default" dependency-check="default">
  <property name="environment"> 
     <props> 
        <prop key="java.naming.factory.initial"> 
          weblogic.jndi.WLInitialContextFactory 
        </prop> 
        <prop key="java.naming.provider.url">t3://172.16.101.42:7001</prop> 
        <prop key="java.naming.security.principal">weblogic</prop> 
        <prop key="java.naming.security.credentials">weblogic</prop> 
     </props>    
   </property> 
</bean>

<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" singleton="true"
  lazy-init="default" autowire="default" dependency-check="default">
  <property name="jndiTemplate">
   <ref local="jndiTemplate" />
  </property>
  <property name="userTransactionName">
   <value>weblogic/transaction/UserTransaction</value>
  </property>
</bean>

--------------------------------->


<bean id="RecordDao" class="com.derek.business.RecordDao">
  <property name="sessionFactory">
    <ref local="sessionFactory"/>
  </property>
</bean>

<bean id="RecordDaoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
    <ref bean="transactionManager" />
  </property>
  <property name="target">
    <ref local="RecordDao" />
  </property>
  <property name="transactionAttributes">
    <props>
      <prop key="insert*">PROPAGATION_REQUIRED</prop>
      <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
  </property>
</bean>

<bean id="Ilogin" class="com.derek.business.Login">
  <property name="sessionFactory">
    <ref local="sessionFactory"/>
  </property>
</bean>

<bean id="loginBOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
    <ref bean="transactionManager" />
  </property>
  <property name="target">
    <ref local="Ilogin" />
  </property>
  <property name="transactionAttributes">
    <props>
      <prop key="insert*">PROPAGATION_REQUIRED</prop>
      <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
  </property>
</bean>

<bean name="/loginAction" class="com.derek.action.LoginAction" singleton="false">
  <property name="login">
    <ref bean="loginBOProxy" />
  </property>
</bean>
</beans>

LoginInterface 
   
package com.derek.myinterface;

public interface LoginInterface {
    public boolean check(String name,String pwd);
}

Login 
  
package com.derek.business;

import com.derek.myinterface.LoginInterface;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import java.util.List;

public class Login extends HibernateDaoSupport implements LoginInterface{
    private SessionFactory sessionFactory;
    private String hsql = "from OvertimePermit where account=? and password=?";
    public Login() {}
    public boolean check(String name,String pwd){
        String condition[] = {name, pwd};//查询条件
        /**
         * 借助HibernateTemplate我们可以脱离每次数据操作必须首先
         * 获得Session实例 、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作
         */       
        List l = this.getHibernateTemplate().find(hsql, condition);
        
        if (l.size() > 0) return true;
          else return false;
    }
}

RecordDaoInterface 
 
package com.derek.myinterface;

import java.util.List;
import hbm.OvertimeRecord;

public interface IRecordDao {
    public List findAll(String hsql);
    public void insert(OvertimeRecord or);
}

RecordDao 
  
package com.derek.business;

import com.derek.myinterface.IRecordDao;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.hibernate.SessionFactory;
import hbm.OvertimeRecord;

public class RecordDao extends HibernateDaoSupport implements IRecordDao{
    private SessionFactory sessionFactory;
    public RecordDao() {
    }

    public List findAll(String hsql) {
       return this.getHibernateTemplate().find(hsql);
    }

    public void insert(OvertimeRecord or) {
        this.getHibernateTemplate().saveOrUpdate(or);
    }
}

LoginAction通过容器注入的Login实例完成业务操作(必须由接口强制类型转化) 
   
package com.derek.action;

import javax.servlet.http.*;
import com.derek.form.*;
import org.apache.struts.action.*;
import org.apache.log4j.Logger;
import com.derek.myinterface.LoginInterface;

public class LoginAction extends Action {
    private LoginInterface login;
    public ActionForward execute(ActionMapping actionMapping,
                                 ActionForm actionForm,
                                 HttpServletRequest servletRequest,
                                 HttpServletResponse servletResponse) {
        Logger log = Logger.getLogger(this.getClass().getName());
        LoginActionForm loginActionForm = (LoginActionForm) actionForm;
        String name = loginActionForm.getName();
        String pwd = loginActionForm.getPwd();
        boolean TF = login.check(name,pwd);
        if(TF){ log.warn("LoginSuccess------------");;return actionMapping.findForward("success");}
          else{ log.warn("LoginFailure------------");;return actionMapping.findForward("failure");}
    }
    public void setLogin(LoginInterface Ilogin) {this.login = Ilogin;}
    public LoginInterface getLogin() {return login;}
}

类中直接通过Context获得bean实例(必须通过代理类获得实例且由其接口强制类型转化) 
   
package com.derek.pub;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import com.derek.myinterface.IRecordDao;
import java.util.List;
import hbm.OvertimeRecord;

public class Untitled1 {
    public Untitled1() {
    ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");
    IRecordDao recordDao = (IRecordDao)ctx.getBean("RecordDaoProxy");
    OvertimeRecord newor = new OvertimeRecord("004104","dada","100120","it","2006/04/02","2006/04/02","001145","david","001145","david","00","00","1","1","1","1");
    newor.setMark("0");
    recordDao.insert(newor);
    List l = recordDao.findAll("from OvertimeRecord");
    for(int i=0;i<l.size();i++){
    OvertimeRecord or = (OvertimeRecord)l.get(i);
    System.out.println(or.getId());
    }
    }
    public static void main(String[] a){
    Untitled1 u = new Untitled1();
    }
}

      一个Spring application context的定义能够被很多种不同的上下文实现所读取， 比如FileSystemXmlApplicationContext 和 ClassPathXmlApplicationContext以及XmlWebApplicationContext。 默认的情况下，一个web应用程序会从”WEB-INF/applicationContext.xml”中得到root context。 在所有的Spring应用中，XML文件中定义的application context会把所有相关的application beans连接起来， 包括Hibernate session factory以及数据访问和业务对象（就像上面定义的那些bean）。 它们中的大部分都不会意识到被Spring容器所管理，甚至在同其他bean合作的时候， 因为它们仅仅遵循JavaBeans的规范。一个bean属性及可以表示值参数，也可以是其他的合作bean。 下面的bean定义能够作为Spring web MVC context的一部分，在最基础的 application context中访问business beans。 
   
ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
ProductService productService = (ProductService) context.getBean("myProductService");
ApplicationContext context =
    new FileSystemXmlApplicationContext("C:/myContext.xml");
ProductService productService =
    (ProductService) context.getBean("myProductService");
ApplicationContext context =
    new ClassPathXmlApplicationContext("myContext.xml");
ProductService productService =
    (ProductService) context.getBean("myProductService");
分享到：
| hibernate的缓存和CRUD
评论
发表评论

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

相关推荐

    Spring4.0+Hibernate4.0+Struts2.3整合案例

    Spring4.0+Hibernate4.0+Struts2.3整合案例:实现增删改查。 ===================== application.xml: xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

    spring+hibernate+struts整合jar包

    在本整合中，Spring 2.5.6版本主要作为业务逻辑的管理和协调者，它可以通过配置文件管理Bean的生命周期，同时与Hibernate和Struts进行无缝集成。 Hibernate 3.2是一个流行的ORM（对象关系映射）工具，它消除了...

    三大框架整合（Spring+Hibernate+Struts1/Struts2）

    【三大框架整合（Spring+Hibernate+Struts1/Struts2）】 在IT行业中，SSH（Struts + Spring + Hibernate）是经典的Java企业级开发框架组合，用于构建高效、可维护的Web应用程序。以下是整合这三大框架的详细步骤，...

    Struts1+Spring+Hibernate整合注册登录(BLing原创).part1.rar

    Struts1+Spring+Hibernate整合注册登录(BLing原创).part1.rar 有二个文件

    Spring5.0.3 + Hibernate5.0.7 + Struts2.5.13全注解整合(SSH全注解整合)

    Spring5.0.3 + Hibernate5.0.7 + Struts2.5.13全注解整合(SSH全注解整合)Spring5.0.3 + Hibernate5.0.7 + Struts2.5.13全注解整合(SSH全注解整合)Spring5.0.3 + Hibernate5.0.7 + Struts2.5.13全注解整合(SSH全注解...

    SSH整合jar包-spring5.0+hibernate5.1+struts2.5

    SSH整合是指将Spring、Hibernate和Struts这三大Java开源框架集成在一起，用于构建高效、灵活的企业级Web应用程序。这三个框架分别负责不同的职责：Spring作为应用的基石，提供依赖注入（DI）和面向切面编程（AOP），...

    Ajax(DWR) + Spring + Hibernate + Struts整合登陆注册

    Ajax、Spring、Hibernate和Struts是Java Web开发中的四大核心技术，它们各司其职，共同构建了一个高效、灵活且功能强大的后端架构。这个小例子将这四个框架整合在一起，用于实现一个登录注册系统，提供了从客户端到...

    Spring+Hibernate+Struts资源共享系统

    在“Spring+Hibernate+Struts”系统中，Hibernate 负责处理数据库操作，将Java对象映射到数据库表，从而避免了繁琐的SQL代码编写。通过 Hibernate，开发者可以轻松地进行数据的增删改查操作，同时支持事务管理和缓存...

    spring+hibernate+struts整合开发模板

    这个"spring+hibernate+struts整合开发模板"是一个完整的开发框架，可以帮助开发者快速搭建基于SSH的项目结构，提高开发效率，并且包含了验证框架的实现。 **Spring框架**：Spring是一个开源的Java平台，核心功能是...

    spring+struts2+hibernate+mybatis

    一个简单的spring+struts2+hibernate+mybatis整合（数据库脚本放在项目资源文件的sql目录下） 因为没想好mvc用springmvc好，还是struts2好 所以没有整合进去

    spring+hibernate+Struts整合登录系统

    本项目"spring+hibernate+Struts整合登录系统"是将这三个框架整合在一起，构建一个完整的登录功能。这样的整合能够充分利用各自的优势，实现高效、灵活且易于维护的系统。 1. Spring框架： - **依赖注入**：Spring...

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis

    在`stm-ssh`和`SSHdemo`中，可能包含的是Struts2+Spring+Hibernate的整合示例。开发者通常会创建Action类来处理请求，定义Service层来封装业务逻辑，并使用Hibernate来操作数据库。Spring会管理这些对象的生命周期和...

    图书管理系统spring+struts+hibernate

    《图书管理系统spring+struts+hibernate》是一款基于Java技术栈开发的图书管理软件，其核心框架包括Spring、Struts和Hibernate。该系统利用MySQL作为数据库存储数据，提供了完整的数据库备份，确保了数据的安全性与...

    Struts+Spring+Hibernate整合教程

    本文将重点介绍Struts、Spring和Hibernate这三个框架的整合方式，并探讨它们在Web应用开发中的角色。 首先，我们来看Struts框架。Struts是一个用于创建表现层的框架，它允许开发人员管理用户的请求和响应，并将调用...

    spring+hibernate+struts2整合

    本项目主要涉及的是Spring、Hibernate和Struts2这三个主流的Java开发框架的整合。它们分别负责不同的职责：Spring作为全能型容器，管理对象和依赖注入；Hibernate是持久层框架，负责数据库操作；而Struts2则是一个...

    ssh框架整合详细步骤（spring+struts2+hibernate）

    ### SSH框架整合详细步骤（spring+struts2+hibernate） #### 一、整合概述 在现代Web应用开发中，SSH（Struts2、Spring、Hibernate）框架因其各自独特的功能和优势，常被组合使用以构建高效、稳定且易于维护的系统...

    Spring+Struts2+hibernate+Redis整合

    在IT行业中，SSH（Spring、Struts2、Hibernate）是一个经典的Java Web开发框架组合，而Redis则是一个高性能的键值存储系统，常用于缓存和数据持久化。将SSH与Redis整合，可以提升应用程序的性能和响应速度。下面将...

    spring+hibernate+struts

    标题 "spring+hibernate+struts" 指涉的是一个经典的Java Web开发框架组合，也被称为SSH（Spring、Struts和Hibernate）三位一体。这个组合在2000年代中期到后期非常流行，用于构建企业级应用。下面将详细阐述这三个...

    struts+spring+hibernate三大框架整合

    SSH三大框架，即Struts、Spring和Hibernate，是Java Web开发中的常用技术组合，它们各自负责不同的职责：Struts作为MVC模式中的Controller层，处理用户请求并转发到相应的业务逻辑；Spring则作为核心容器，负责依赖...

    struts+spring+hibernate实现图书修改和删除

    SSH整合的关键在于配置文件，包括Struts 2的struts.xml、Spring的applicationContext.xml和Hibernate的hibernate.cfg.xml。这些文件定义了各组件之间的关系和行为。例如，struts.xml中配置Action类及其结果视图，...

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