您现在的位置:首页 >> Web开发 >> Web基础 >> 内容

spring管理struts,hibernate整合学习--Java免费学习网

时间:2015-3-19 16:56:42

  核心提示:一、新建web工程,ssh 1. 导入struts,选择struts1.2的jar包 建立包:org.accp.struts copy到当前目录下 2. 导入spring 选择jar包,注意不要导入h...
一、新建web工程,ssh
  1. 导入struts,选择struts1.2的jar包
     建立包:org.accp.struts
     copy到当前目录下
  2. 导入spring
    选择jar包,注意不要导入hibernate2的包,其它全要。
    然后是applicationContext.xml放在src下,方便后期测试
    后期可以放到webRoot/web-inf下
    有重复的,选择覆盖
    copy到当前目录下
  3. 导入hibernate,
     要选3.0,spring不支持3.1
     选中copy...,再next
     选中生成在spring配置文件
     再next,选中已经存在的配置文件
     再写sessionFactory ID=sessionFactory,next
     填写数据源,beanid=ds,再next
     去掉create sessionFactory class代表全部由spring托管
     覆盖
   4. 建立包:
 org.accp.hibernate
 org.accp.hibernate.po
 org.accp.hibernate.dao
 org.accp.well.delegate
   5. 导入日志配置文件src/log4j.properties
   6. 导入mysql.jar,不能拷贝到lib下,也找不到,这时要在buildPath中导入外部jar
   7. 如果报错:<url>这里不能有空格或回车符</url>
 
二、spring整合hibernate
   1. 查看applicationContext.xml有了变化,多了hibernate的配置
   2. 建立表的映射
      选择数据库视图,accp数据库
      生成users.hbm.xml与Users.java
      去掉catagory属性,否则会报错
      也在applicationContext.xml中增加了映射
   3. 整合hibernate有两种方式
   4. 第一种方式,继承
      org.springframework.orm.hibernate3.HibernateTemplate,该类是spring封装了操作Hibernate的实现细节的类,用于代替Session的相关操作。主要方法: 
 Serializable save(Object?entity) :保存记录
 void update(Object?entity) :修改记录
 void delete(Object?entity) :删除记录
 Object get(Class?entityClass, Serializable?id)
 Object load(Class?entityClass, Serializable?id)
 List executeFind(HibernateCallback?action) :查询,返回集合
 Object execute(HibernateCallback?action):查询,返回对象
 总的说来,该类的方法和Session接口中定义的方法是一致的.
     1)在dao包中写接口IDao,
       public interface IDao {
 public void save(Users u);
 public List getAll();
 public boolean validate(Users u);
       }
 
       UserDao extends HibernateDaoSupport implements IDao
 public class UserDao extends HibernateDaoSupport implements IDao{
   public void save(Users u){
     this.getHibernateTemplate().save(u);
   }
 }
     2)在spring中配置UserDao,从哪取连接,property二择其一
        给继承了HibernateDaoSupport的对象我们注入一个sessionFactory 对象也可以,他会自动生成一个hibernateTemplate对象
 <bean id="userdao" class="org.accp.hibernate.dao.UserDao">
   <property name="sessionFactory" ref="sessionFactory" />
   <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
 </bean>
     3)测试
        导入mysql.jar,不能拷贝到lib下,也找不到,这时要在buildPath中导入外部jar
 去掉users.hbm.xml中的catagory属性,否则会报错
  
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  IDao dele = (IDao)ac.getBean("userdao");
  Users u = new Users();
  u.setUid("userdao");
  u.setPwd("123");
  u.setVersion(2);
  dele.save(u);
    
   5. 第二种方式
     1) 新建一个类UserDao2,加一成员变量HibernateTemplate
         加一构造函数,注入sessionFactory
  加一setter方法,注入sessionFactory
     public class UserDao2 implements IDao{
 private HibernateTemplate hibernateTemplate;
 public UserDao2(HibernateTemplate hibernateTemplate) {
  this.hibernateTemplate = hibernateTemplate;
 }
 public void save(Users u){
  hibernateTemplate.save(u);
 }
      }
    
     2) 改配置文件applicationContext.xml
 <bean id="userdao2" class="org.accp.hibernate.dao.UserDao2">
   <constructor-arg>
     <ref bean="hibernateTemplate"/>
   </constructor-arg>
 </bean> 
 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
 <property name="sessionFactory">
  <ref bean="sessionFactory"/>
 </property>
 </bean> 
 
   6. HibernateDaoSupport与连接的管理
 而调用getHibernateTemplate()就会自动关闭连接。
 这是日志
 [main] DEBUG org.springframework.orm.hibernate3.SessionFactoryUtils  - Closing Hibernate Session
 自动关闭连接会造成延迟加载初始化异常,此时可用OpenSessionInView模式解决。Spring提供Open Session In View来解决这个问题, 有两种方式。
 1) Interceptor,在applicationContext.xml配置
    <bean id="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
  <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  <property name="interceptors" ref="openSessionInViewInterceptor"/>
  <property name="mappings">
      <props>
      ......
      </props>
  </property>
    </bean>
 2) Filter,在web.xml中配置
 <filter>
   <filter-name>hibernateFilter</filter-name>
   <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
   <!-- 默认情况下,这个Filter会在Spring的bean池中找一个叫做sessionFactory的bean。如果使用了其他名字的SessionFactory,则应该在这里 -->
   <init-param>
     <param-name>sessionFactoryBeanName</param-name>
     <param-value>sessionFactory</param-value>
   </init-param>
   <!-- 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>
 
 加了这个配置,就要加监听器和初始文件的参数,否则报错
 <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/applicationContext.xml</param-value>
 </context-param>
 <listener>  
   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 
   7. HibernateDaoSupport与自动提交
     每执行一个sql,默认都是由spring自动提交事务。可以在数据源中插入进去
 <property name="defaultAutoCommit">
   <value>false</value>
 </property>
    
   8. spring整合hibernate事务
 Don't call me, I will call you
 更少代码,更少BUG
    Spring提供的事务管理可以分为两类:编程式的和声明式的。
    1) 编程式的
 比较灵活,但是代码量大,存在重复的代码比较多,当你只有很少的事务操作时,编程式事务管理通常比较合适。
    代码
 public class UserDao3 extends HibernateDaoSupport implements IDao{
 private HibernateTransactionManager transactionManager;
 public void setTransactionManager(HibernateTransactionManager transactionManager) {
  this.transactionManager = transactionManager;
 }
 public void save(Users u){
  DefaultTransactionDefinition def = new DefaultTransactionDefinition();
  TransactionStatus status = transactionManager.getTransaction(def);
  try{
    this.getHibernateTemplate().save(u);
    //不提交插入不了
    transactionManager.commit(status);
  }catch(Exception e) {
   transactionManager.rollback(status);
  }
   }
 }
     配置
      <bean id="userdao3" class="org.accp.hibernate.dao.UserDao3">
   <property name="sessionFactory" ref="sessionFactory"/>
   <property name="transactionManager" ref="transactionManager"/>
 </bean>
 <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
 </bean> 
 
    2) 声明式的
      其DAO必须要有接口,否则声明式事务就会报错。
      a) 事务属性
     <prop key="save*">PROPAGATION_REQUIRED,readOnly</prop>
        key属性确定代理应该给哪个方法增加事务行为。 PROPAGATION_REQUIRED--支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
 PROPAGATION_SUPPORTS--支持当前事务,如果当前没有事务,就以非事务方式执行。
 PROPAGATION_MANDATORY--支持当前事务,如果当前没有事务,就抛出异常。
 PROPAGATION_REQUIRES_NEW--新建事务,如果当前存在事务,把当前事务挂起。
 PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
 PROPAGATION_NEVER--以非事务方式执行,如果当前存在事务,则抛出异常。
 PROPAGATION_NESTED--如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。
 事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务,避免dirty checking。
     b) 事务策略
        为了实际执行事务,Spring所有的事务划分功能都通过传递适当的TransactionDefinition实例,委托给PlatformTransactionManager。
 Spring具有多种PlatformTransactionManager实现,它们分为两类:
 局部事务策略--针对单个资源执行事务(在多数情况下是针对单个的数据库)。
 全局事务管理--执行有可能跨越多个资源的全局事务。
     c) 事务代理
        TransactionProxyFactoryBean是Spring2.0之前的旧版本风格的配置
 TransactionInterceptor,它使用一个PlatformTransactionManager实现配合,在方法调用前后实施事务。
     d) 例子
       
 配置文件
     <bean id="userdao4" class="org.accp.hibernate.dao.UserDao4">
    <property name="sessionFactory" ref="sessionFactory"></property>  
  </bean>
 
    <bean id="proxyTemplate" class="org.springframework.transaction.interceptor.TransactionInterceptor">
  <property name="transactionManager">
   <ref bean="transactionManager"/>
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="save*">PROPAGATION_REQUIRED</prop>
    <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
   </bean>
 
   <bean id="nameproxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  <property name="beanNames">
    <list><value>userdao4</value></list>
  </property>
  <property name="interceptorNames">
         <list>
    <value>proxyTemplate</value>
         </list>
  </property>
   </bean>
 不用事务,即使报错也始终能插入进去一条。用了事务,一报错则一条都不进去。
    配置完成前,将defaultAutoCommit设成false后,始终插入不进去。
    配置完成后,将使用声明式事务能插入进去了。
 
   9. sql提高,修改UserDao
 // executeFind返回集合
 public List query() {
  return this.getHibernateTemplate().executeFind(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException,
     SQLException {
    return session.createQuery(
      "from " + cls.getName() + " as a order by a.uid desc").list();
   }
  });
 }
 
 // execute返回对象
 public boolean validate(final Users u) {
  List ls = (List) this.getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session)
       throws HibernateException, SQLException {
      Query qy = session
        .createQuery("from Users u where u.uid=:uid and u.pwd=:pwd");
      qy.setString("uid", u.getUid());
      qy.setString("pwd", u.getPwd());
      List li = qy.list();
      return li;
     }
    });
  return (ls.size() > 0);
 }
 
三、spring整合struts
  1. 在struts-config.xml中新建login用例
     form/action/jsp,use case=login
  2. 写代理UserDelegate,有保存、验证、查询所有的记录三个方法
     源代码
 public class UserDelegate {
 //一定要是IDao而不是UserDao,因为有了事务,自动代理将截获后返回的是IDao
 private IDao dao;
 public void setDao(IDao dao) {
  this.dao = dao;
 }
 public boolean validate(String uid,String pwd){
  return dao.validate(uid, pwd);
 }
 public List getAll() {
  return dao.getAll();
 }
 public void save(Users u) {
  dao.save(u);
 }
 }
     配置文件
      <bean id="ud" class="org.accp.well.delegate.UserDelegate">
   <property name="dao" ref="userdao"></property>
 </bean>
  3. 加上跳转页面
     新增succ.jsp
     succ对应succ.jsp,fail对应login.jsp
  4. 引入IOC,在action中引入代理
     修改LoginAction
      private UserDelegate ud;
 public void setUd(UserDelegate ud) {
  this.ud = ud;
 }
  5. 在action中写上登陆验证代码
  String uid = loginForm.getUid();
  String pwd = loginForm.getPwd();
  if(ld.validate(uid, pwd))
   return mapping.findForward("succ");
  return mapping.findForward("fail");
  6. 在struts中引入spring
     在struts-config.xml中注册,引入spring的插件,在message-resources标签后:
 <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
     <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml"/>
 </plug-in>
  7. 让spring管理struts的action,有三种方式
     1) 最简单的一种,改变其请求处理器:
     <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />
     2) 在struts的action中直接继承spring的一个ActionSupport
     3) 改action的配置中的type,换成spring的一个代理,这个每个action都要改,比较麻烦
        <type="org.springframework.web.struts.DelegatingActionProxy" >
  8. 采用第一种方式
     在spring的applicationContext.xml中注册struts的action
     其name(不能是id)对应于struts-config.xml中的path
      <bean name="/login" class="org.accp.struts.action.LoginAction">
   <property name="ud" ref="ud"></property>
 </bean> 
 
四、部署运行
  1. 发布
  2. 如果导入spring时,没有选中web的jar包,则集成到struts会出错
  3. 测试一切正常
  4. 将applicationContext.xml放到与web.xml平级目录
     修改struts-config.xml的配置,改<plug-in>路径
     再测试一切正常
  5. 将与struts的集成改成第一种方式
     改<action>标签的type
     加
     <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />
     再测试一切正常
  6. 看日志,session的开闭
 [http-8080-Processor25] DEBUG org.springframework.orm.hibernate3.SessionFactoryUtils  - Opening Hibernate Session
 ...
 [http-8080-Processor25] DEBUG org.hibernate.impl.SessionImpl  - closing session

关注微信号:javalearns  ,随时随地学Java

今天看到一个手机也能赚钱的网站,与大家分享(真实可信,已亲身体验):

http://javalearns.jifenqiang.com/

作者:不详 来源:网络
    你是从哪里知道本网站的?
  • 网友介绍的
  • 百度搜索的
  • Google搜索的
  • 其它搜索过来的
  • 网址输错了进来的
  • 太忙了不记得了
共有评论 0相关评论
发表我的评论
  • 大名:
  • 内容:
  • java学习网(www.javalearns.com) © 2014 版权所有 All Rights Reserved.
  • Email:javalearns@163.com 站长QQ:1356121699 晋ICP备14003680号-3
  • java学习网部分内容来自网络或网友发布,如侵犯了您利益,请发邮件至:javalearns@126.com,我们尽快处理!
  • Java学习网
  • 网站统计
  • 晋公网安备 14042902000001号