Struts2 + Spring3 + Hibernate3.5 整合（实际使用项目，version2）

Struts2学习日志(一)

NULL 博文链接：https://ozzzo.iteye.com/blog/441767

Struts2 + Spring3 + Hibernate3.5 整合（实际使用项目，version3）.part3

这是一个实际使用中的项目，可访问 http://cdbke.cuit.edu.cn 可查看效果及功能，后台需要登录后才能使用（出于安全性考虑这里就不给大家介绍了，另外还有一个struts1版本的，如有需要可以与我联系）。 此项目整合了目前主流和最前源的web开发技术：采用ehcache实现二级缓存（包含查询缓存）；用sf4j及logback（log4j的升级版）记录日志；proxool（据说是dbcp和c3p0三者中最优秀的）做连接池；使用jquery的ajax实现仿google人名自动补全；头像上传剪切压缩处理。 包含有完整的jar包和源代码，可以直接下载编译部署和运行，这是专门为我们实验室定制开发的。虽然后台逻辑并不复杂，但已经包含了架构基于s2sh技术型系统的全部基础部分：如分页，缓存，文件上传，连接池等。很适合学习使用，希望对初学JavaEE WEB开的人有所帮助。 这个资源在去年发布了第一版，已经有很多朋友下了觉得对他们有帮助，所以我才再发了一个第二版，希望对有需要的朋友有所帮助。本版本全面更新了jar包，全部使用了当前最新版本的jar包，struct2.1.8 spring3 hibernate3.5，全面使用注解取代xm的l配置。 另外增加了一个ant构建脚本，支持使用hudson完成每日构建，持续集成，自动测试，代码规范检查，代码审查等功能（与此相关的jar包由于上传文件大小限制未导入） 本系统一直在使用中，所以还会不段更新，之后我打算再做一个基于javaee6的实现，给需要想学习ejb3.1等技术的朋友一个参考实现 集成测试相关jar包和更新构建脚本下载：http://download.csdn.net/source/2427972 前面已经发了两个版，看到有好多人少说不错，对他们有帮助。因为最近比较忙EJB的一直没时间做，我又改了些东西，再发一个最新的上来。以前下过第二版的同志可以不用再下载这个版本了

Struts2 + Spring3 + Hibernate3.5 整合（实际使用项目，version3）.part1

这是一个实际使用中的项目，可访问 http://cdbke.cuit.edu.cn 可查看效果及功能，后台需要登录后才能使用（出于安全性考虑这里就不给大家介绍了，另外还有一个struts1版本的，如有需要可以与我联系）。 此项目整合了目前主流和最前源的web开发技术：采用ehcache实现二级缓存（包含查询缓存）；用sf4j及logback（log4j的升级版）记录日志；proxool（据说是dbcp和c3p0三者中最优秀的）做连接池；使用jquery的ajax实现仿google人名自动补全；头像上传剪切压缩处理。 包含有完整的jar包和源代码，可以直接下载编译部署和运行，这是专门为我们实验室定制开发的。虽然后台逻辑并不复杂，但已经包含了架构基于s2sh技术型系统的全部基础部分：如分页，缓存，文件上传，连接池等。很适合学习使用，希望对初学JavaEE WEB开的人有所帮助。 这个资源在去年发布了第一版，已经有很多朋友下了觉得对他们有帮助，所以我才再发了一个第二版，希望对有需要的朋友有所帮助。本版本全面更新了jar包，全部使用了当前最新版本的jar包，struct2.1.8 spring3 hibernate3.5，全面使用注解取代xm的l配置。 另外增加了一个ant构建脚本，支持使用hudson完成每日构建，持续集成，自动测试，代码规范检查，代码审查等功能（与此相关的jar包由于上传文件大小限制未导入） 本系统一直在使用中，所以还会不段更新，之后我打算再做一个基于javaee6的实现，给需要想学习ejb3.1等技术的朋友一个参考实现 集成测试相关jar包和更新构建脚本下载：http://download.csdn.net/source/2427972 前面已经发了两个版，看到有好多人少说不错，对他们有帮助。因为最近比较忙EJB的一直没时间做，我又改了些东西，再发一个最新的上来。网络不好分三个传的，以前下过第二版的同志可以不用再下载这个版本了

Struts2 + Spring 2.5 + Hibernate 3.3 整合（实际使用项目，version1）

这是一个实际使用中的项目，可访问 http://cdbke.cuit.edu.cn 可查看效果及功能，后台需要登录后才能使用（出于安全性考虑这里就不给大家介绍了，另外还有一个struts1版本的，如有需要可以与我联系）。 此项目整合了目前主流和最前源的web开发技术：采用ehcache实现二级缓存（包含查询缓存）；用sf4j及logback（log4j的升级版）记录日志；proxool（据说是dbcp和c3p0三者中最优秀的）做连接池；使用jquery的ajax实现仿google人名自动补全；头像上传剪切压缩处理。 包含有完整的jar包和源代码，这是专门为我们实验室定制开发的，包含了架构基于s2sh技术网站的参考实现（包括了全部基础部分：如分页，缓存，文件上传，连接池等等）希望对初学JavaEE WEB开的人有所帮助。 有更新版本的了，推荐下载新版的http://download.csdn.net/source/2342439

Struts2.1.18+Hibernate3.2+Spring3.0+MySQL整合

Struts2.1.18+Hibernate3.2+Spring3.0+MySQL整合 开发环境： Windows XP SP3 MyEclipse Enterprise Workbench Version: 8.5 Tomcat 6.0.18 JDK 6.0.20 MySQL 5.1

论坛系统（Struts 2+Hibernate+Spring实现）

论坛系统（Struts 2+Hibernate+Spring实现）<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE validators SYSTEM "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd" PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"> -<validators> -<validator type="requiredstring"> <param name="fieldName">name</param> <message>用户名必须输入</message> </validator> -<validator type="requiredstring"> <param name="fieldName">password</param> <message>密码必须输入</message> </validator> -<validator type="requiredstring"> <param name="fieldName">validationCode</param> <message>验证码必须输入</message> </validator> </validators>

Myeclipse开发struts+hibernate+spring新手入门--环境配置---项目开发示例

Myeclipse开发struts+hibernate+spring新手入门---环境配置----项目开发示例 Myeclipse开发struts+hibernate+spring小记 开发前准备工作： 1、下载eclipse3.1版本 下载地址： 2、下载Myeclipse插件 下载地址： 3、根据需要下载所需要的数据库驱动。 部分下载地址： 4、下载的eclipse3.1进行解压缩。安装Myeclipse，分为手工安装和自动安装两种安装方法。 具体安装方法如下： 手工安装： 自动安装： 5、安装完成后。启动Myeclipse。 准备开发工作： 步骤： 1、新建项目： New>projects后进入下图 本文主要介绍开发Web Project项目，因此需要选择Web Project，下一步，进入下图： Project Name：为需要建立的项目名称。填写好项目名称后，Finish。新建项目完成。本文在项目命名为test.。 项目建立完成之后，在Myeclipse视图中，Package Explorer中显示如下： test：为项目名称。 Src：为源文件所放路径。 WebRoot：为Web root folder 2、加载Struts 在所建立项目test上右键后，提示如下页面： 在弹出的菜单中，根据图例提示，选择Myeclipse后在弹出的二级菜单中选择Add Struts Capabilities…后提示如下图所示： 在弹出的对话框中，设置如下： Struts config path：默认，一般不需要改变。 Struts specification：选择Struts版本，在此项目中，选择Struts 1.2版本。 Base Package for new classes：设置为空。 取消Install Struts TLDs选项。 其他默认： Finish.后在Package Explorer的Lib包如下： 到此，加载Struts完成。在此需要关注Struts-config.xml文件。 3、加载hibernate: 同加载struts方式类似，选择Myeclipse后在弹出的二级菜单中选择Add Hibernate Capabilities…后提示如下图所示： 可以根据提示，选择Hibernate Specification：本项目选择Hibernate3，其他默认，Next> 默认后直接下一步。在此可以去掉Configuration File Name中的内容。Next> 后去掉下一级页面的Create SessionFactory class选项。然后Finish，Finish完成后，在Lib目录下会提示相关的jar包。 4、加载spring in action in action 同加载struts方式类似，选择Myeclipse后在弹出的二级菜单中选择Add spring in action in action Capabilities…后提示如下图所示： 选择所需要的spring in action in action包，然后默认下一步，直到完成。 到此，Struts+hibernate+spring配置完成。 附加：在项目名称的右键后进入Properties然后进入Java Build Path后查看加载的jar包。 具体项目的开发详细文档请见下一篇文章《struts+hibernate+spring项目开发示例》 Myeclipse平台struts+hibernate+spring项目开发示例 接：Myeclipse开发struts+hibernate+spring新手入门---环境配置 如果您按照上篇文章配置成功，可以进行开发简单的J2EE项目。 开发前准备: 1、新建项目包：如下图： Dao：数据层；service：逻辑层；web：web展现层。 2、建立好三层架构，部署好包名。建立一个jsp文件，取名为：login.jsp 代码如下： <% @ taglib uri = " http://struts.apache.org/tags-bean " prefix = " bean " %> <% @ taglib uri = " http://struts.apache.org/tags-html " prefix = " html " %> <% @ taglib uri = " http://struts.apache.org/tags-logic " prefix = " logic " %> <% @ taglib uri = " http://struts.apache.org/tags-tiles " prefix = " tiles " %> < HTML > < HEAD > < TITLE > test < TITLE > < HEAD > < BODY > < html:form action = " /login " method = " post " > 用户名： < html:text property = " username " size = " 15 " /> < br > 密 码： < html:password property = " password " size = " 15 " />< br > < html:submit property = " submit1 " style = " FONT-WEIGHT:bold;COLOR:red " > 登 录 < html:submit > < html:form > < BODY > < HTML > 3、配置struts-config.xml文件；建立action、formbean; 改配置可以自动生成，使用eclipse进行自动生成，在建立时，如下图，可直接生成对应的action类和formbean类。 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> 3 4 <struts-config> 5 <data-sources /> 6 <form-beans> 7 <form-bean name="LoginForm" type="com.test.web.form.LoginForm" /> 8 9 </form-beans> 10 11 <global-exceptions /> 12 <global-forwards /> 13 <action-mappings> 14 <action attribute="LoginForm" input="/login.jsp" name="LoginForm" path="LoginAction" scope="request" type="com.test.web.action.LoginAction" validate="true"> 15 <forward name="faile" path="faile.jsp" /> 16 <forward name="success" path="success.jsp" /> 17 </action> 18 19 </action-mappings> 20 21 <message-resources parameter="ApplicationResources" /> 22 </struts-config> 对应生成的formbean如下代码所示: 1 import javax.servlet.http.HttpServletRequest; 2 import org.apache.struts.action.ActionErrors; 3 import org.apache.struts.action.ActionForm; 4 import org.apache.struts.action.ActionMapping; 5 6 /** 7 * MyEclipse Struts 8 * Creation date: 11-10-2005 9 * 10 * XDoclet definition: 11 * @struts.form name="LoginForm" 12 */ 13 public class LoginForm extends ActionForm { 14 15 /** password property */ 16 private String password; 17 18 /** username property */ 19 private String username; 20 21 22 /** 23 * Method validate 24 * @param mapping

struts2.3+hibernate3.6+spring3.1整合的纯xml配置的小项目

application.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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <context:annotation-config></context:annotation-config> <context:component-scan base-package="org.whvcse"></context:component-scan> <tx:annotation-driven transaction-manager="txManager" /> <!-- <aop:config> <aop:pointcut id="defaultServiceOperation" expression="execution(* x.y.service.*Service.*(..))" /> <aop:pointcut id="noTxServiceOperation" expression="execution(* x.y.service.ddl.DefaultDdlManager.*(..))" /> <aop:advisor pointcut-ref="defaultServiceOperation" advice-ref="defaultTxAdvice" /> <aop:advisor pointcut-ref="noTxServiceOperation" advice-ref="noTxAdvice" /> </aop:config> <bean id="fooService" class="x.y.service.DefaultFooService" /> <bean id="anotherFooService" class="x.y.service.ddl.DefaultDdlManager" /> <tx:advice id="defaultTxAdvice"> <tx:attributes> <tx:method name="get*" read-only="true" /> <tx:method name="*" /> </tx:attributes> </tx:advice> <tx:advice id="noTxAdvice"> <tx:attributes> <tx:method name="*" propagation="NEVER" /> </tx:attributes> </tx:advice> --> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driverClassName}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </bean> <context:property-placeholder location="classpath:jdbc.properties" /> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <property name="annotatedClasses"> <list> <value> org.whvcse.model.Userinfo </value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.format_sql">true</prop> </props> </property> </bean> <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> </beans>

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

Spring4.0+Hibernate4.0+Struts2.3整合案例:实现增删改查。 ===================== application.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:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"> ============================================= 解决整合问题： 1、Spring 3.x 对 Hibernate 4.x 不提供 HibernateDaoSupport，所以在dao的实现层注入SessionFactory 2、报错:org.hibernate.HibernateException: No Session found for current thread 意思是必须在transcation.isActive()条件下才能执行， 可以解决办法是：当方法不需要事务支持的时候，使用 Session session = sessionFactory.openSession()来获得Session对象，问题解决！

虚拟数据层 Struts2、Hibernate、Spring整合的泛型DAO Version 2010.9.27

Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复标识为 “代码味道”，但我们大多数都已经学会忍受它。能不能不写重复的dao 呢 ？ 泛型dao,顾名思义就是一个dao可以对多个实体对象进行持久化。当应用中需要使用到上十张表时，DAO的维护变得日益困难，主要表现在这几个方面： 1）dao类的繁多，很多设计都是一个entity对应一个dao (不同的只有类名和方法名) 2）dao接口需要维护的method庞大。 3）业务逻辑改变时，dao需要同时修改两个类文件（接口和实现类） 在本文中，我将为您展示如何避免再三地重复 DAO 代码。 在这里我建议项目最好使用一个共通的DAO，因为这样会为你省去非常多的类，而那些类里的逻辑往往差不多。当然是用共通的DAO你需要对结果转型，转成你需要的bean，但这也比写那么多DAO强多了,你可以放下包袱，只关注你的业务逻辑。 如果你真能只用一个dao解决，那么祝贺你，你得到了一个虚拟数据层(高度抽象的数据接口)。这是一个比dao更高级的存在。 欢迎大家指正 -_- 虚心求教 代码层次： bean-->dao-->service-->action 技术概述：1.继承 继承是利用现有的类创建新类的过程，现有的类称作基类（或父类），创建的新类称作派生类（子类）。继承其实就是自动地共享基类中成员属性和成员方法的机制。引入继承，实现了代码重用； 2.泛型 泛型类型的限定 3.反射 代码概述： bean ：Person.java 这个人员类我就不说了 泛型dao接口 ：GenericDao<T, ID extends Serializable> 泛型作为DAO的通用接口 CRUD方法 dao接口 : PersonDAO extends GenericDao<Person, Integer> 可以不写代码,方法已经在父类泛型dao里了,这里为了说明:可扩展添加 findByNameExact（）方法 子类的附加方法。 泛型daoimpl ：GenericDaoImpl<T, ID extends Serializable> implements GenericDao<T, ID> 必须提供的构造方法,以便创建实例的时候就知道具体实体的类型。 daoimpl ：PersonDAOImpl extends GenericDaoImpl<Person, Integer> implements PersonDAO public PersonDAOImpl() { super(Person.class); } 告诉对哪个类操作,如不需要自定义扩展方法就作有一个构造方法。 泛型Service：GenericService.java 与泛型dao没有区别 Service ：PersonService.java 直接继承。 泛型serviceimpl与serviceimpl实现和dao层实现一样。 Action ： SavePersonAction直接调用PersonService。 下面是代码 为了演示减少代码量而且直观去掉些方法方便读者自己扩展写出适合自己的代码,这里我只抛砖引玉了。主要介绍这个技术。 本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zylyueliang/archive/2010/09/17/5890043.aspx

Spring + Hibernate + Struts 事务配置小例子（带提示框等小技巧）

前几天搞 Spring + Hibernate + Struts 事务配置 ，网上找了好多资料，不过好无语，大多都是 Ctrl + V，浪费俺的宝贵时间 现在我总结配出一套，给大家参考参考，可能有不足，请大家多多交流。 附：内有弹出对话框，Action乱码处理和一些好技巧。 2008-5-28 修改： 今天修改了 applicationContext.xml，以后的事务控制就万事大吉了，里面有详细注释哦。 有什么问题可以给我留言 ^_^，大家一起进步！ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>WEB-INF/jdbc.properties</value> </list> </property> </bean> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" dependency-check="none"> <property name="driverClass"> <value>${datasource.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${datasource.url}</value> </property> <property name="user"> <value>${datasource.username}</value> </property> <property name="password"> <value>${datasource.password}</value> </property> <property name="acquireIncrement"> <value>${c3p0.acquireIncrement}</value> </property> <property name="initialPoolSize"> <value>${c3p0.initialPoolSize}</value> </property> <property name="minPoolSize"> <value>${c3p0.minPoolSize}</value> </property> <property name="maxPoolSize"> <value>${c3p0.maxPoolSize}</value> </property> <property name="maxIdleTime"> <value>${c3p0.maxIdleTime}</value> </property> <property name="idleConnectionTestPeriod"> <value>${c3p0.idleConnectionTestPeriod}</value> </property> <property name="maxStatements"> <value>${c3p0.maxStatements}</value> </property> <property name="numHelperThreads"> <value>${c3p0.numHelperThreads}</value> </property> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource"> <ref local="dataSource" /> </property> <property name="mappingResources"> <list> <value>com/bean/Tuser.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect"> org.hibernate.dialect.OracleDialect </prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.cglib.use_reflection_optimizer"> true </prop> <prop key="hibernate.cache.provider_class"> org.hibernate.cache.EhCacheProvider </prop> <prop key="hibernate.cache.use_query_cache">true</prop> </props> </property> </bean> <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> </bean> <!-- 配置事务拦截器--> <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> <!-- 事务拦截器bean需要依赖注入一个事务管理器 --> <property name="transactionManager" ref="transactionManager" /> <property name="transactionAttributes"> <!-- 下面定义事务传播属性 [ bus* 事务的方法名]--> <props> <prop key="bus*">PROPAGATION_REQUIRED</prop> </props> </property> </bean> <!-- 定义BeanNameAutoProxyCreator,该bean是个bean后处理器，无需被引用，因此没有id属性--> <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <!-- 指定对满足哪些bean name的bean自动生成业务代理 --> <property name="beanNames"> <!-- 下面是所有需要自动创建事务代理的bean--> <list> <value>userManager</value> </list> <!-- 此处可增加其他需要自动创建事务代理的bean--> </property> <!-- 下面定义BeanNameAutoProxyCreator所需的事务拦截器--> <property name="interceptorNames"> <list> <value>transactionInterceptor</value> <!-- 此处可增加其他新的Interceptor --> </list> </property> </bean> <!--定义DAO Bean ,由于BeanNameAutoProxyCreator自动生成事务代理--> <bean id="userDAO" class="com.dao.impl.UserDAOHibernate"> <property name="sessionFactory"> <ref local="sessionFactory" /> </property> </bean> <bean id="userManager" class="com.service.impl.UserManagerImpl"> <property name="userDAO"> <ref local="userDAO" /> </property> </bean> <bean name="/user" class="com.action.UserAction" singleton="false"> <property name="userManager"> <ref bean="userManager" /> </property> </bean> </beans>

客户关系管理系统框架搭建（二）

crm项目的架构 * 创建web工程 * 引入jar包 * mysql的驱动包 * hibernate需要的jar包 * spring需要的jar包 * struts2需要的jar包 * jstl 需要的jar包 * junit需要的jar包 * 包的介绍 * cn.itcast.crm.container:重新封装spring容器 * cn.itcast.crm.dao:放置的是dao接口 * cn.itcast.crm.dao.impl:放置的是dao接口的实现类 * cn.itcast.crm.domain:放置的是po类、po类和数据库表关联的映射文件 * cn.itcast.crm.service:业务层的接口 * cn.itcast.crm.service.impl:业务层的接口的实现类 * cn.itcast.crm.web.action:struts2的action * cn.itcast.crm.web.form:封装页面数据的javaBean * junit:开发人员测试用的 * 搭建hibernate层 * 定义需求:部门信息的页面数据要插入到数据库中 * 定义表 CREATE TABLE `sys_user_group` ( `id` INTEGER(11) NOT NULL AUTO_INCREMENT, #编号 `remark` TEXT, #备注 `name` VARCHAR(100) DEFAULT NULL, #部门名称 `principal` VARCHAR(50) DEFAULT NULL, #部门负责人 `incumbent` VARCHAR(200) DEFAULT NULL, #部门职能 PRIMARY KEY (`id`) ) * 创建po对象,放置在cn.itcast.crm.domain包下 public class SysUserGroup implements java.io.Serializable { private Integer id; private String remark; // 备注 private String name; // 部门名称 private String principal; // 部门负责人 private String incumbent; // 部门职能 } * 创建表和po之间的映射文件SysUserGroup.hbm.xml 放置在cn.itcast.crm.domain包下 * SysUserGroup.hbm.xml文件的内容直接看该文件即可 * 创建hibernate.cfg.xml文件连接数据库,加载SysUserGroup.hbm.xml文件,放置src下 <session-factory> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/itcast0807crm</property> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.autocommit">true</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> <property name="hibernate.hbm2ddl.auto">update</property> <property name="hibernate.show_sql">true</property> <mapping resource="cn/itcast/crm/domain/SysUserGroup.hbm.xml"/> </session-factory> * 测试.放置在junit包下 public class TestHibernate { @Test public void testHibernateConf(){ Configuration config=new Configuration(); config.configure(); SessionFactory sf=config.buildSessionFactory(); Session s=sf.openSession(); Transaction tx=s.beginTransaction(); SysUserGroup sysUserGroup=new SysUserGroup(); sysUserGroup.setName("销售部"); sysUserGroup.setPrincipal("xxx"); sysUserGroup.setIncumbent("ttt"); s.save(sysUserGroup); tx.commit(); s.close(); } } * 搭建spring和hibernate * 创建beans.xml文件,放置在src下 * 引入命名空间 bean tx context aop <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> * 配置如下: <!-- 1 配置注解的自动扫描--> <context:component-scan base-package="cn.itcast.crm"/> <!--3 配置本地化代理工程bean,这是spring整合hibernate的入口 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"> <!--表示在类路径下加载hibernate.cfg.xml --> <value>classpath:hibernate.cfg.xml</value> </property> </bean> <!--4 创建事务管理器 aop切面--> <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!--5 配置处理事务的注解--> <tx:annotation-driven transaction-manager="txManager"/> * 创建dao层共同的接口,放置在cn.itcast.crm.dao下 public interface ICommonDao<T> { public void save(T entity); } * 创建dao层共同的接口的实现类,,放置在cn.itcast.crm.dao.impl下 public class CommonDaoImpl<T> extends HibernateDaoSupport implements ICommonDao<T> { public void save(T entity) { this.getHibernateTemplate().save(entity); } @Resource(name="sessionFactory") //注入sessionFactory public void setSessionFactoryDI(SessionFactory sessionFactory) { System.out.println("sessionFactory "+sessionFactory); //调用父类的setSessionFactory方法,注入sessionFactory super.setSessionFactory(sessionFactory); } } * 创建部门的dao接口 SysUserGroupDao接口 放在cn.itcast.crm.dao包下 public interface ISysUserGroupDao extends ICommonDao<SysUserGroup> { public final static String SERVICE_NAME="cn.itcast.crm.dao.impl.SysUserGroupDaoImpl"; } * 创建部门的dao接口的实现类 放在cn.itcast.crm.dao.impl包下 @Repository(ISysUserGroupDao.SERVICE_NAME) public class SysUserGroupDaoImpl extends CommonDaoImpl<SysUserGroup> implements ISysUserGroupDao { } * 测试,放置在junit包下 public class TestSysUserGroupDao { @Test public void testSave() { ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); ISysUserGroupDao sysUserGroupDao = (ISysUserGroupDao) ctx.getBean(ISysUserGroupDao.SERVICE_NAME); SysUserGroup sysUserGroup = new SysUserGroup(); sysUserGroup.setName("销售部"); sysUserGroup.setPrincipal("xxx"); sysUserGroup.setIncumbent("ttt"); sysUserGroupDao.save(sysUserGroup); } } * 创建部门的业务层接口 ,放置在cn.itcast.crm.service包下 public interface ISysUserGroupService { public final static String SERVICE_NAME="cn.itcast.crm.service.impl.SysUserGroupServiceImpl"; public void saveSysUserGroup(SysUserGroup sysUserGroup); } * 创建部门的业务层接口实现类,放置在cn.itcast.crm.service.impl包下 @Transactional(readOnly=true) @Service(ISysUserGroupService.SERVICE_NAME) public class SysUserGroupServiceImpl implements ISysUserGroupService { @Resource(name=ISysUserGroupDao.SERVICE_NAME) private ISysUserGroupDao sysUserGroupDao; @Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,readOnly=false) public void saveSysUserGroup(SysUserGroup sysUserGroup) { sysUserGroupDao.save(sysUserGroup); } } * 测试 public class TestSysUserGroupService { @Test public void testSavex() { ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); ISysUserGroupService sysUserGroupService = (ISysUserGroupService) ctx.getBean(ISysUserGroupService.SERVICE_NAME); SysUserGroup sysUserGroup = new SysUserGroup(); sysUserGroup.setName("销售部"); sysUserGroup.setPrincipal("xxx"); sysUserGroup.setIncumbent("ttt"); sysUserGroupService.saveSysUserGroup(sysUserGroup); } } * 搭建struts2(保存部门信息) * jsp页面(sys/group/add.jsp) * 请求的路径/sys/sysUserGroupAction_save.do * 根据路径创建SysUserGroupAction和在action中增加save方法，放置在cn.itcast.crm.web.action包下 public class SysUserGroupAction extends ActionSupport public String save() throws IllegalAccessException, InvocationTargetException{ System.out.println("xxxxxxxxxxxxxxxxxxxxxxxx "); return null; } } * 建立请求路径和action之间的关联 * 创建struts.xml文件,放置在src下 * 文件内容如下: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN" "http://struts.apache.org/dtds/struts-2.1.7.dtd"> <struts> <!-- 配置请求后缀名.do --> <constant name="struts.action.extension" value="do"/> <!-- 配置主题为简单主题 --> <constant name="struts.ui.theme" value="simple"/> <!--配置struts2的模式为开发模式--> <constant name="struts.devMode" value="true"/> <package name="sys" namespace="/sys" extends="struts-default"> <action name="sysUserGroupAction_*" class="cn.itcast.crm.web.action.SysUserGroupAction" method="{1}"> <result name="add">/sys/group/add.jsp</result> </action> </package> </struts> * 在web.xml文件配置struts2的过滤器 <filter> <filter-name>StrutsPrepareAndExecuteFilter</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter> <filter-mapping> <filter-name>StrutsPrepareAndExecuteFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> * 测试 * 定义javaBean(vo对象)接收表单数据,放置在cn.itcast.crm.web.form包下 public class SysUserGroupForm implements java.io.Serializable { private String id; private String name; private String principal; private String incumbent; private String remark; } * action要实现模型驱动接口 public class SysUserGroupAction extends ActionSupport implements ModelDriven<SysUserGroupForm>{ private SysUserGroupForm sysUserGroupForm=new SysUserGroupForm(); public String save() throws IllegalAccessException, InvocationTargetException{ System.out.println("xxxxxxxxxxxxxxxxxxxxxxxx "); return null; } public SysUserGroupForm getModel() { return sysUserGroupForm; } } * 测试，SysUserGroupForm是否接收到值 * 如何在struts2的SysUserGroupAction中的save方法中,获取spring容器中bean节点的对象 * 创建ServiceProvinderCore,加载beans.xml文件,放置在cn.itcast.crm.container包下 public class ServiceProvinderCore { protected ApplicationContext ctx; /** * @param filename beans.xml */ public void load(String filename){ ctx=new ClassPathXmlApplicationContext(filename); } } * 创建ServiceProvinder类,获取获取spring容器中bean节点的对象,放置在cn.itcast.crm.container包下 public class ServiceProvinder { private static ServiceProvinderCore sc; static{ System.err.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); sc=new ServiceProvinderCore(); sc.load("beans.xml"); } public static Object getService(String beanName){ System.err.println("ppppppppppppppppppppppp"); if(StringUtils.isBlank(beanName)){ throw new RuntimeException("您要访问的服务名称不能为空"); } Object bean=null; //如果spring容器中包含beanName if(sc.ctx.containsBean(beanName)){ bean=sc.ctx.getBean(beanName); } //如果spring容器中不包含beanName if(bean==null){ throw new RuntimeException("您要访问的服务名称["+beanName+"]不存在"); } return bean; } } * 测试 @Test public void testSave() { ISysUserGroupService sysUserGroupService=(ISysUserGroupService)ServiceProvinder.getService(ISysUserGroupService.SERVICE_NAME); SysUserGroup sysUserGroup = new SysUserGroup(); sysUserGroup.setName("销售部"); sysUserGroup.setPrincipal("xxx"); sysUserGroup.setIncumbent("ttt"); sysUserGroupService.saveSysUserGroup(sysUserGroup); } * 在 SysUserGroupAction中的save方法中增加如下代码 public String save() throws IllegalAccessException, InvocationTargetException{ System.out.println("sysUserGroupForm.getName() "+sysUserGroupForm.getName()); //实例化po对象 SysUserGroup sysUserGroup=new SysUserGroup(); //赋值vo对象的值到po中 BeanUtils.copyProperties(sysUserGroup, sysUserGroupForm); //获取业务层的对象(本项目struts2和spring是分离的) ISysUserGroupService sysUserGroupService= (ISysUserGroupService)ServiceProvinder.getService(ISysUserGroupService.SERVICE_NAME); //调用业务层保存po对象 sysUserGroupService.saveSysUserGroup(sysUserGroup); return null; } * 测试:

ssh（structs,spring,hibernate）框架中的上传下载

Struts+Spring+Hibernate实现上传下载 　　 　　本文将围绕SSH文件上传下载的主题，向您详细讲述如何开发基于SSH的Web程序。SSH各框架的均为当前最新版本： 　　•Struts 1.2 　　•Spring 1.2.5 　　•Hibernate 3.0 　　本文选用的数据库为Oracle 9i，当然你可以在不改动代码的情况下，通过配置文件的调整将其移植到任何具有Blob字段类型的数据库上，如MySQL，SQLServer等。 　　总体实现 　　上传文件保存到T_FILE表中，T_FILE表结构如下： 图 1 T_FILE表结构 　　其中： 　　•FILE_ID：文件ID，32个字符，用Hibernate的uuid.hex算法生成。 　　•FILE_NAME：文件名。 　　•FILE_CONTENT：文件内容，对应Oracle的Blob类型。 　　•REMARK：文件备注。 　　文件数据存储在Blob类型的FILE_CONTENT表字段上，在Spring中采用OracleLobHandler来处理Lob字段（包括Clob和Blob），由于在程序中不需要引用到oracle数据驱动程序的具体类且屏蔽了不同数据库处理Lob字段方法上的差别，从而撤除程序在多数据库移植上的樊篱。 　　1．首先数据表中的Blob字段在Java领域对象中声明为byte[]类型，而非java.sql.Blob类型。 　　2．数据表Blob字段在Hibernate持久化映射文件中的type为org.springframework.orm.hibernate3.support.BlobByteArrayType，即Spring所提供的用户自定义的类型，而非java.sql.Blob。 3在Spring中使用org.springframework.jdbc.support.lob.OracleLobHandler处理Oracle数据库的Blob类型字段。 　　通过这样的设置和配置，我们就可以象持久化表的一般字段类型一样处理Blob字段了。 　　以上是Spring＋Hibernate将文件二进制数据持久化到数据库的解决方案，而Struts通过将表单中file类型的组件映射为ActionForm中类型为org.apache.struts.upload. FormFile的属性来获取表单提交的文件数据。 　　工程的类按SSH的层次结构划分为数据持久层、业务层和Web层；WEB-INF下的applicationContext.xml为Spring的配置文件，struts-config.xml为Struts的配置文件，file-upload.jsp为文件上传页面，file-list.jsp为文件列表页面。 　　本文后面的章节将从数据持久层-＞业务层-＞Web层的开发顺序，逐层讲解文件上传下载的开发过程。 　　数据持久层 　　1、领域对象及映射文件 　　您可以使用Hibernate Middlegen、HIbernate Tools、Hibernate Syhchronizer等工具或手工的方式，编写Hibernate的领域对象和映射文件。其中对应T_FILE表的领域对象Tfile.java为： 　　代码 1 领域对象Tfile 1. package sshfile.model; 2. public class Tfile 3.{ 4. private String fileId; 5. private String fileName; 6. private byte[] fileContent; 7. private String remark; 8. …//getter and setter 9. } 　　特别需要注意的是：数据库表为Blob类型的字段在Tfile中的fileContent类型为byte[]。Tfile的Hibernate映射文件Tfile.hbm.xml放在Tfile .java类文件的相同目录下： 　　代码 2 领域对象映射文件 1. ＜?xml version="1.0"?＞ 2. ＜!DOCTYPE hibernate-mapping PUBLIC 3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" ＞ 5. ＜hibernate-mapping＞ 6. ＜class name="sshfile.model.Tfile" table="T_FILE"＞ 7. ＜id name="fileId" type="java.lang.String" column="FILE_ID"＞ 8. ＜generator class="uuid.hex"/＞ 9. ＜/id＞ 10. ＜property name="fileContent" 11. type="org.springframework.orm.hibernate3.support.BlobByteArrayType" 12. column="FILE_CONTENT" lazy="true"/＞ 13. …//其它一般字段的映射 14. ＜/class＞ 15. ＜/hibernate-mapping＞ 　　fileContent字段映射为Spring所提供的BlobByteArrayType类型，BlobByteArrayType是用户自定义的数据类型，它实现了Hibernate 的org.hibernate.usertype.UserType接口。BlobByteArrayType使用从sessionFactory获取的Lob操作句柄lobHandler将byte[]的数据保存到Blob数据库字段中。这样，我们就再没有必要通过硬编码的方式，先insert然后再update来完成Blob类型数据的持久化，这个原来难伺候的老爷终于被平民化了。关于lobHandler的配置请见本文后面的内容。 　　此外lazy="true"说明地返回整个Tfile对象时，并不返回fileContent这个字段的数据，只有在显式调用tfile.getFileContent()方法时才真正从数据库中获取fileContent的数据。这是Hibernate3引入的新特性，对于包含重量级大数据的表字段，这种抽取方式提高了对大字段操作的灵活性，否则加载Tfile对象的结果集时如果总是返回fileContent，这种批量的数据抽取将可以引起数据库的"洪泛效应"。 　　2、DAO编写和配置 　　Spring强调面向接口编程，所以我们将所有对Tfile的数据操作的方法定义在TfileDAO接口中，这些接口方法分别是： 　　•findByFildId(String fileId) 　　•save(Tfile tfile) 　　•List findAll() 　　TfileDAOHibernate提供了对TfileDAO接口基于Hibernate的实现，如代码 3所示： 　　代码 3 基于Hibernate 的fileDAO实现类 1. package sshfile.dao; 2. 3. import sshfile.model.*; 4. import org.springframework.orm.hibernate3.support.HibernateDaoSupport; 5. import java.util.List; 6. 7. public class TfileDAOHibernate 8. extends HibernateDaoSupport implements TfileDAO 9. { 10. public Tfile findByFildId(String fileId) 11. { 12. return (Tfile) getHibernateTemplate().get(Tfile.class, fileId); 13. } 14. public void save(Tfile tfile) 15. { 16. getHibernateTemplate().save(tfile); 17. getHibernateTemplate().flush(); 18. } 19. public List findAll() 20. { 21. return getHibernateTemplate().loadAll(Tfile.class); 22. } 23. } 　　TfileDAOHibernate通过扩展Spring提供的Hibernate支持类HibernateDaoSupport而建立，HibernateDaoSupport封装了HibernateTemplate，而HibernateTemplate封装了Hibernate所提供几乎所有的的数据操作方法，如execute(HibernateCallback action)，load(Class entityClass, Serializable id)，save(final Object entity)等等。 　　所以我们的DAO只需要简单地调用父类的HibernateTemplate就可以完成几乎所有的数据库操作了。 　　由于Spring通过代理Hibernate完成数据层的操作，所以原Hibernate的配置文件hibernate.cfg.xml的信息也转移到Spring的配置文件中： 　　代码 4 Spring中有关Hibernate的配置信息 1. ＜beans＞ 2. ＜!-- 数据源的配置 //--＞ 3. ＜bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 4. destroy-method="close"＞ 5. ＜property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/＞ 6. ＜property name="url" value="jdbc:oracle:thin:@localhost:1521:ora9i"/＞ 7. ＜property name="username" value="test"/＞ 8. ＜property name="password" value="test"/＞ 9. ＜/bean＞ 10. ＜!-- Hibernate会话工厂配置 //--＞ 11. ＜bean id="sessionFactory" 12. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"＞ 13. ＜property name="dataSource" ref="dataSource"/＞ 14. ＜property name="mappingDirectoryLocations"＞ 15. ＜list＞ 16. ＜value＞classpath:/sshfile/model＜/value＞ 17. ＜/list＞ 18. ＜/property＞ 19. ＜property name="hibernateProperties"＞ 20. ＜props＞ 21. ＜prop key="hibernate.dialect"＞org.hibernate.dialect.OracleDialect＜/prop＞ 22. ＜prop key="hibernate.cglib.use_reflection_optimizer"＞true＜/prop＞ 23. ＜/props＞ 24. ＜/property＞ 25. ＜/bean＞ 26. ＜!-- Hibernate 模板//--＞ 27. ＜bean id="hibernateTemplate" 28. class="org.springframework.orm.hibernate3.HibernateTemplate"＞ 29. ＜property name="sessionFactory" ref="sessionFactory"/＞ 30. ＜/bean＞ 31. ＜!--DAO配置 //--＞ 32. ＜bean id="tfileDAO" class="sshfile.dao.TfileDAOHibernate"＞ 33. ＜property name="hibernateTemplate" ref="hibernateTemplate" /＞ 34. ＜/bean＞ 35. … 36. ＜/beans＞ 　　第3~9行定义了一个数据源，其实现类是apache的BasicDataSource，第11~25行定义了Hibernate的会话工厂，会话工厂类用Spring提供的LocalSessionFactoryBean维护，它注入了数据源和资源映射文件，此外还通过一些键值对设置了Hibernate所需的属性。 　　其中第16行通过类路径的映射方式，将sshfile.model类包目录下的所有领域对象的映射文件装载进来，在本文的例子里，它将装载进Tfile.hbm.xml映射文件。如果有多个映射文件需要声明，使用类路径映射方式显然比直接单独指定映射文件名的方式要简便。 　　第27~30行定义了Spring代理Hibernate数据操作的HibernateTemplate模板，而第32~34行将该模板注入到tfileDAO中。 　　需要指定的是Spring 1.2.5提供了两套Hibernate的支持包，其中Hibernate 2相关的封装类位于org.springframework.orm.hibernate2.*包中，而Hibernate 3.0的封装类位于org.springframework.orm.hibernate3.*包中，需要根据您所选用Hibernate版本进行正确选择。 　　3、Lob字段处理的配置 　　我们前面已经指出Oracle的Lob字段和一般类型的字段在操作上有一个明显的区别--那就是你必须首先通过Oracle的empty_blob()/empty_clob()初始化Lob字段，然后获取该字段的引用，通过这个引用更改其值。所以要完成对Lob字段的操作，Hibernate必须执行两步数据库访问操作，先Insert再Update。 　　使用BlobByteArrayType字段类型后，为什么我们就可以象一般的字段类型一样操作Blob字段呢？可以确定的一点是：BlobByteArrayType不可能逾越Blob天生的操作方式，原来是BlobByteArrayType数据类型本身具体数据访问的功能，它通过LobHandler将两次数据访问的动作隐藏起来，使Blob字段的操作在表现上和其他一般字段业类型无异，所以LobHandler即是那个"苦了我一个，幸福十亿人"的那位幕后英雄。 　　LobHandler必须注入到Hibernate会话工厂sessionFactory中，因为sessionFactory负责产生与数据库交互的Session。LobHandler的配置如代码 5所示： 　　代码 5 Lob字段的处理句柄配置 1. ＜beans＞ 2. … 3. ＜bean id="nativeJdbcExtractor" 4. class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" 5. lazy-init="true"/＞ 6. ＜bean id="lobHandler" 7. class="org.springframework.jdbc.support.lob.OracleLobHandler" lazy-init="true"＞ 8. ＜property name="nativeJdbcExtractor"＞ 9. ＜ref local="nativeJdbcExtractor"/＞ 10. ＜/property＞ 11. ＜/bean＞ 12. … 13. ＜/beans＞ 　　首先，必须定义一个能够从连接池中抽取出本地数据库JDBC对象（如OracleConnection，OracleResultSet等）的抽取器：nativeJdbcExtractor，这样才可以执行一些特定数据库的操作。对于那些仅封装了Connection而未包括Statement的简单数据连接池，SimpleNativeJdbcExtractor是效率最高的抽取器实现类，但具体到apache的BasicDataSource连接池，它封装了所有JDBC的对象，这时就需要使用CommonsDbcpNativeJdbcExtractor了。Spring针对几个著名的Web服务器的数据源提供了相应的JDBC抽取器： 　　•WebLogic：WebLogicNativeJdbcExtractor 　　•WebSphere：WebSphereNativeJdbcExtractor 　　•JBoss：JBossNativeJdbcExtractor 　　在定义了JDBC抽取器后，再定义lobHandler。Spring 1.2.5提供了两个lobHandler： 　　•DefaultLobHandler：适用于大部分的数据库，如SqlServer，MySQL，对Oracle 10g也适用，但不适用于Oracle 9i（看来Oracle 9i确实是个怪胎，谁叫Oracle 公司自己都说Oracle 9i是一个过渡性的产品呢）。 　　•OracleLobHandler：适用于Oracle 9i和Oracle 10g。 　　由于我们的数据库是Oracle9i，所以使用OracleLobHandler。 　　在配置完LobHandler后， 还需要将其注入到sessionFactory的Bean中，下面是调用后的sessionFactory Bean的配置： 　　代码 6 将lobHandler注入到sessionFactory中的配置 1. ＜beans＞ 2. … 3. ＜bean id="sessionFactory" 4. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"＞ 5. ＜property name="dataSource" ref="dataSource"/＞ 6. ＜!-- 为处理Blob类型字段的句柄声明 //--＞ 7. ＜property name="lobHandler" ref="lobHandler"/＞ 8. … 9. ＜/bean＞ 10. … 11. ＜/beans＞ 　　如第7所示，通过sessionFactory的lobHandler属性进行注入。 　业务层 　　1、业务层接口 　　"面向接口而非面向类编程"是Spring不遗余力所推荐的编程原则，这条原则也已经为大部开发者所接受；此外，JDK的动态代理只对接口有效，否则必须使用CGLIB生成目标类的子类。我们依从于Spring的倡导为业务类定义一个接口： 　　代码 7 业务层操作接口 1. public interface FileService 2. { 3. void save(FileActionForm fileForm);//将提交的上传文件保存到数据表中 4. List getAllFile();//得到T_FILE所示记录 5. void write(OutputStream os,String fileId);//将某个文件的文件数据写出到输出流中 6. String getFileName(String fileId);//获取文件名 7. } 　　其中save(FileActionForm fileForm)方法，将封装在fileForm中的上传文件保存到数据库中，这里我们使用FileActionForm作为方法入参，FileActionForm是Web层的表单数据对象，它封装了提交表单的数据。将FileActionForm直接作为业务层的接口入参，相当于将Web层传播到业务层中去，即将业务层绑定在特定的Web层实现技术中，按照分层模型学院派的观点，这是一种反模块化的设计，但在"一般"的业务系统并无需提供多种UI界面，系统Web层将来切换到另一种实现技术的可能性也微乎其微，所以笔者觉得没有必要为了这个业务层完全独立于调用层的过高目标而去搞一个额外的隔离层，浪费了原材料不说，还将系统搞得过于复杂，相比于其它原则，"简单"始终是最大的一条原则。 　　getAllFile()负责获取T_FILE表所有记录，以便在网页上显示出来。 　　而getFileName(String fileId)和write(OutputStream os,String fileId)则用于下载某个特定的文件。具体的调用是将Web层将response.getOutputStream()传给write(OutputStream os,String fileId)接口，业务层直接将文件数据输出到这个响应流中。具体实现请参见错误！未找到引用源。节下载文件部分。 　　2、业务层接口实现类 　　FileService的实现类为FileServiceImpl，其中save(FileActionForm fileForm)的实现如下所示： 　　代码 8 业务接口实现类之save() 1. … 2. public class FileServiceImpl 3. implements FileService 4. { 5. private TfileDAO tfileDAO; 6. public void save(FileActionForm fileForm) 7. { 8. Tfile tfile = new Tfile(); 9. try 10. { 11. tfile.setFileContent(fileForm.getFileContent().getFileData()); 12. } 13. catch (FileNotFoundException ex) 14. { 15. throw new RuntimeException(ex); 16. } 17. catch (IOException ex) 18. { 19. throw new RuntimeException(ex); 20. } 21. tfile.setFileName(fileForm.getFileContent().getFileName()); 22. tfile.setRemark(fileForm.getRemark()); 23. tfileDAO.save(tfile); 24. } 25. … 26. } 　　在save(FileActionForm fileForm)方法里，完成两个步骤： 　　其一，象在水桶间倒水一样，将FileActionForm对象中的数据倒入到Tfile对象中； 　　其二，调用TfileDAO保存数据。 　　需要特别注意的是代码的第11行，FileActionForm的fileContent属性为org.apache.struts.upload.FormFile类型，FormFile提供了一个方便的方法getFileData()，即可获取文件的二进制数据。通过解读FormFile接口实现类DiskFile的原码，我们可能知道FormFile本身并不缓存文件的数据，只有实际调用getFileData()时，才从磁盘文件输入流中获取数据。由于FormFile使用流读取方式获取数据，本身没有缓存文件的所有数据，所以对于上传超大体积的文件，也是没有问题的；但是，由于数据持久层的Tfile使用byte[]来缓存文件的数据，所以并不适合处理超大体积的文件（如100M），对于超大体积的文件，依然需要使用java.sql.Blob类型以常规流操作的方式来处理。 　　此外，通过FileForm的getFileName()方法就可以获得上传文件的文件名，如第21行代码所示。 　　write(OutputStream os,String fileId)方法的实现，如代码 9所示： 　　代码 9 业务接口实现类之write() 1. … 2. public class FileServiceImpl 3. implements FileService 4. { 5. 6. public void write(OutputStream os, String fileId) 7. { 8. Tfile tfile = tfileDAO.findByFildId(fileId); 9. try 10. { 11. os.write(tfile.getFileContent()); 12. os.flush(); 13. } 14. catch (IOException ex) 15. { 16. throw new RuntimeException(ex); 17. } 18. } 19. … 20. } 　　write(OutputStream os,String fileId)也简单地分为两个操作步骤，首先，根据fileId加载表记录，然后将fileContent写入到输出流中。 　　3、Spring事务配置 　　下面，我们来看如何在Spring配置文件中为FileService配置声明性的事务 1. ＜beans＞ 2. … 3. ＜bean id="transactionManager" 4. class="org.springframework.orm.hibernate3.HibernateTransactionManager"＞ 5. ＜property name="sessionFactory" ref="sessionFactory"/＞ 6. ＜/bean＞ 7. ＜!-- 事务处理的AOP配置 //--＞ 8. ＜bean id="txProxyTemplate" abstract="true" 9. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"＞ 10. ＜property name="transactionManager" ref="transactionManager"/＞ 11. ＜property name="transactionAttributes"＞ 12. ＜props＞ 13. ＜prop key="get*"＞PROPAGATION_REQUIRED,readOnly＜/prop＞ 14. ＜prop key="find*"＞PROPAGATION_REQUIRED,readOnly＜/prop＞ 15. ＜prop key="save"＞PROPAGATION_REQUIRED＜/prop＞ 16. ＜prop key="write"＞PROPAGATION_REQUIRED,readOnly＜/prop＞ 17. ＜/props＞ 18. ＜/property＞ 19. ＜/bean＞ 20. ＜bean id="fileService" parent="txProxyTemplate"＞ 21. ＜property name="target"＞ 22. ＜bean class="sshfile.service.FileServiceImpl"＞ 23. ＜property name="tfileDAO" ref="tfileDAO"/＞ 24. ＜/bean＞ 25. ＜/property＞ 26. ＜/bean＞ 27. ＜/beans＞ 　　Spring的事务配置包括两个部分： 　　其一，定义事务管理器transactionManager，使用HibernateTransactionManager实现事务管理； 　　其二，对各个业务接口进行定义，其实txProxyTemplate和fileService是父子节点的关系，本来可以将txProxyTemplate定义的内容合并到fileService中一起定义，由于我们的系统仅有一个业务接口需要定义，所以将其定义的一部分抽象到父节点txProxyTemplate中意义确实不大，但是对于真实的系统，往往拥有为数众多的业务接口需要定义，将这些业务接口定义内容的共同部分抽取到一个父节点中，然后在子节点中通过parent进行关联，就可以大大简化业务接口的配置了。 　　父节点txProxyTemplate注入了事务管理器，此外还定义了业务接口事务管理的方法（允许通过通配符的方式进行匹配声明，如前两个接口方法），有些接口方法仅对数据进行读操作，而另一些接口方法需要涉及到数据的更改。对于前者，可以通过readOnly标识出来，这样有利于操作性能的提高，需要注意的是由于父类节点定义的Bean仅是子节点配置信息的抽象，并不能具体实现化一个Bean对象，所以需要特别标注为abstract="true"，如第8行所示。 　　fileService作为一个目标类被注入到事务代理器中，而fileService实现类所需要的tfileDAO实例，通过引用3.2节中定义的tfileDAO Bean注入。 　　Web层实现 　　1、Web层的构件和交互流程 　　Web层包括主要3个功能： 　　•上传文件。 　　•列出所有已经上传的文件列表，以供点击下载。 　　•下载文件。 　　Web层实现构件包括与2个JSP页面，1个ActionForm及一个Action： 　　•file-upload.jsp：上传文件的页面。 　　•file-list.jsp：已经上传文件的列表页面。 　　•FileActionForm：file-upload.jsp页面表单对应的ActionForm。 　　•FileAction：继承org.apache.struts.actions.DispatchAction的Action，这样这个Action就可以通过一个URL参数区分中响应不同的请求。 　　Web层的这些构件的交互流程如图 6所示： 图 6 Web层Struts流程图 　　其中，在执行文件上传的请求时，FileAction在执行文件上传后，forward到loadAllFile出口中，loadAllFile加载数据库中所有已经上传的记录，然后forward到名为fileListPage的出口中，调用file-list.jsp页面显示已经上传的记录。 　　2、FileAction功能 　　Struts 1.0的Action有一个弱项：一个Action只能处理一种请求，Struts 1.1中引入了一个DispatchAction，允许通过URL参数指定调用Action中的某个方法，如http://yourwebsite/fileAction.do?method=upload即调用FileAction中的upload方法。通过这种方式，我们就可以将一些相关的请求集中到一个Action当中编写，而没有必要为某个请求操作编写一个Action类。但是参数名是要在struts-config.xml中配置的： 1. ＜struts-config＞ 2. ＜form-beans＞ 3. ＜form-bean name="fileActionForm" type="sshfile.web.FileActionForm" /＞ 4. ＜/form-beans＞ 5. ＜action-mappings＞ 6. ＜action name="fileActionForm" parameter="method" path="/fileAction" 7. type="sshfile.web.FileAction"＞ 8. ＜forward name="fileListPage" path="/file-list.jsp" /＞ 9. ＜forward name="loadAllFile" path="/fileAction.do?method=listAllFile" /＞ 10. ＜/action＞ 11. ＜/action-mappings＞ 12. ＜/struts-config＞ 　　第6行的parameter="method"指定了承载方法名的参数，第9行中，我们还配置了一个调用FileAction不同方法的Action出口。 　　FileAction共有3个请求响应的方法，它们分别是： 　　•upload(…)：处理上传文件的请求。 　　•listAllFile(…)：处理加载数据库表中所有记录的请求。 　　•download（…）：处理下载文件的请求。 　　下面我们分别对这3个请求处理方法进行讲解。 　　2.1 上传文件 　　上传文件的请求处理方法非常简单，简之言之，就是从Spring容器中获取业务层处理类FileService，调用其save(FileActionForm form)方法上传文件，如下所示： 1. public class FileAction 2. extends DispatchAction 3. { 4. //将上传文件保存到数据库中 5. public ActionForward upload(ActionMapping mapping, ActionForm form, 6. HttpServletRequest request, 7. HttpServletResponse response) 8. { 9. FileActionForm fileForm = (FileActionForm) form; 10. FileService fileService = getFileService(); 11. fileService.save(fileForm); 12. return mapping.findForward("loadAllFile"); 13. } 14. //从Spring容器中获取FileService对象 15. private FileService getFileService() 16. { 17. ApplicationContext appContext = WebApplicationContextUtils. 18. getWebApplicationContext(this.getServlet().getServletContext()); 19. return (FileService) appContext.getBean("fileService"); 20. } 21. … 22. } 　　由于FileAction其它两个请求处理方法也需要从Spring容器中获取FileService实例，所以我们特别提供了一个getFileService()方法（第15~21行）。重构的一条原则就是："发现代码中有重复的表达式，将其提取为一个变量；发现类中有重复的代码段，将其提取为一个方法；发现不同类中有相同的方法，将其提取为一个类"。在真实的系统中，往往拥有多个Action和多个Service类，这时一个比较好的设置思路是，提供一个获取所有Service实现对象的工具类，这样就可以将Spring 的Service配置信息屏蔽在一个类中，否则Service的配置名字散落在程序各处，维护性是很差的。 　　2.2 列出所有已经上传的文件 　　listAllFile方法调用Servie层方法加载T_FILE表中所有记录，并将其保存在Request域中，然后forward到列表页面中： 1. public class FileAction 2. extends DispatchAction 3. { 4. … 5. public ActionForward listAllFile(ActionMapping mapping, ActionForm form, 6. HttpServletRequest request, 7. HttpServletResponse response) 8. throws ModuleException 9. { 10. FileService fileService = getFileService(); 11. List fileList = fileService.getAllFile(); 12. request.setAttribute("fileList",fileList); 13. return mapping.findForward("fileListPage"); 14. } 15. } 　　file-list.jsp页面使用Struts标签展示出保存在Request域中的记录： 1. ＜%@page contentType="text/html; charset=GBK"%＞ 2. ＜%@taglib uri="/WEB-INF/struts-logic.tld" prefix="logic"%＞ 3. ＜%@taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%＞ 4. ＜html＞ 5. ＜head＞ 6. ＜title＞file-download＜/title＞ 7. ＜/head＞ 8. ＜body bgcolor="#ffffff"＞ 9. ＜ol＞ 10. ＜logic:iterate id="item" name="fileList" scope="request"＞ 11. ＜li＞ 12. ＜a href=&#39;fileAction.do?method=download&fileId= 13. ＜bean:write name="item"property="fileId"/＞&#39;＞ 14. ＜bean:write name="item" property="fileName"/＞ 15. ＜/a＞ 16. ＜/li＞ 17. ＜/logic:iterate＞ 18. ＜/ol＞ 19. ＜/body＞ 20. ＜/html＞ 　　展现页面的每条记录挂接着一个链接地址，形如：fileAction.do?method=download&fileId=xxx，method参数指定了这个请求由FileAction的download方法来响应，fileId指定了记录的主键。 　　由于在FileActionForm中，我们定义了fileId的属性，所以在download响应方法中，我们将可以从FileActionForm中取得fileId的值。这里涉及到一个处理多个请求Action所对应的ActionForm的设计问题，由于原来的Action只能对应一个请求，那么原来的ActionForm非常简单，它仅需要将这个请求的参数项作为其属性就可以了，但现在一个Action对应多个请求，每个请求所对应的参数项是不一样的，此时的ActionForm的属性就必须是多请求参数项的并集了。所以，除了文件上传请求所对应的fileContent和remark属性外还包括文件下载的fileId属性： 图 7 FileActionForm 　　当然这样会造成属性的冗余，比如在文件上传的请求中，只会用到fileContent和remark属性，而在文件下载的请求时，只会使用到fileId属性。但这种冗余是会带来好处的--它使得一个Action可以处理多个请求。 　　2.3 下载文件 　　在列表页面中点击一个文件下载，其请求由FileAction的download方法来响应，download方法调用业务层的FileService方法，获取文件数据并写出到response的响应流中。通过合理设置HTTP响应头参数，将响应流在客户端表现为一个下载文件对话框，其代码如下所示： 　　代码 10 业务接口实现类之download 1. public class FileAction 2. extends DispatchAction 3. { 4. … 5. public ActionForward download(ActionMapping mapping, ActionForm form, 6. HttpServletRequest request, 7. HttpServletResponse response) 8. throws ModuleException 9. { 10. FileActionForm fileForm = (FileActionForm) form; 11. FileService fileService = getFileService(); 12. String fileName = fileService.getFileName(fileForm.getFileId()); 13. try 14. { 15. response.setContentType("application/x-msdownload"); 16. response.setHeader("Content-Disposition", 17. "attachment;" + " filename="+ 18. new String(fileName.getBytes(), "ISO-8859-1")); 19. fileService.write(response.getOutputStream(), fileForm.getFileId()); 20. } 21. catch (Exception e) 22. { 23. throw new ModuleException(e.getMessage()); 24. } 25. return null; 26. } 27. } 　　第15~18行，设置HTTP响应头，将响应类型设置为application/x-msdownload MIME类型，则响应流在IE中将弹出一个文件下载的对话框，如图 4所示。IE所支持的MIME类型多达26种，您可以通过这个网址查看其他的MIME类型： http://msdn.microsoft.com/workshop/networking/moniker/overview/appendix_a.asp。 　　如果下载文件的文件名含有中文字符，如果不对其进行硬编码，如第18行所示，客户文件下载对话框中出现的文件名将会发生乱码。 第19行代码获得response的输出流，作为FileServie write(OutputStream os,String fileId)的入参，这样文件的内容将写到response的输出流中。 　　3、web.xml文件的配置 Spring容器在何时启动呢？我可以在Web容器初始化来执行启动Spring容器的操作，Spring提供了两种方式启动的方法： 　　•通过org.springframework.web.context .ContextLoaderListener容器监听器，在Web容器初始化时触发初始化Spring容器，在web.xml中通过＜listener＞＜/listener＞对其进行配置。 　　•通过Servlet org.springframework.web.context.ContextLoaderServlet，将其配置为自动启动的Servlet，在Web容器初始化时，通过这个Servlet启动Spring容器。 　　在初始化Spring容器之前，必须先初始化log4J的引擎，Spring也提供了容器监听器和自动启动Servlet两种方式对log4J引擎进行初始化： 　•org.springframework.web.util .Log4jConfigListener 　•org.springframework.web.util.Log4jConfigServlet 　　下面我们来说明如何配置web.xml启动Spring容器： 　　代码 11 web.xml中对应Spring的配置内容 1. ＜web-app＞ 2. ＜context-param＞ 3. ＜param-name＞contextConfigLocation＜/param-name＞ 4. ＜param-value＞/WEB-INF/applicationContext.xml＜/param-value＞ 5. ＜/context-param＞ 6. ＜context-param＞ 7. ＜param-name＞log4jConfigLocation＜/param-name＞ 8. ＜param-value＞/WEB-INF/log4j.properties＜/param-value＞ 9. ＜/context-param＞ 10. ＜servlet＞ 11. ＜servlet-name＞log4jInitServlet＜/servlet-name＞ 12. ＜servlet-class＞org.springframework.web.util.Log4jConfigServlet＜/servlet-class＞ 13. ＜load-on-startup＞1＜/load-on-startup＞ 14. ＜/servlet＞ 15. ＜servlet＞ 16. ＜servlet-name＞springInitServlet＜/servlet-name＞ 17. ＜servlet-class＞org.springframework.web.context.ContextLoaderServlet＜/servlet-class＞ 18. ＜load-on-startup＞2＜/load-on-startup＞ 19. ＜/servlet＞ 20. … 21. ＜/web-app＞ 　　启动Spring容器时，需要得到两个信息：Spring配置文件的地址和Log4J属性文件，这两上信息分别通过contextConfigLocationWeb和log4jConfigLocation容器参数指定，如果有多个Spring配置文件，则用逗号隔开，如： /WEB-INF/applicationContext_1.xml, /WEB-INF/applicationContext_1.xm2 　　由于在启动ContextLoaderServlet之前，必须事先初始化Log4J的引擎，所以Log4jConfigServlet必须在ContextLoaderServlet之前启动，这通过＜load-on-startup＞来指定它们启动的先后顺序。 　　乱码是开发Web应用程序一个比较老套又常见问题，由于不同Web应用服务器的默认编码是不一样的，为了方便Web应用在不同的Web应用服务器上移植，最好的做法是Web程序自身来处理编码转换的工作。经典的作法是在web.xml中配置一个编码转换过滤器，Spring就提供了一个编码过滤器类CharacterEncodingFilter，下面，我们为应用配置上这个过滤器： 1. ＜web-app＞ 2. … 3. ＜filter＞ 4. ＜filter-name＞encodingFilter＜/filter-name＞ 5. ＜filter-class＞org.springframework.web.filter.CharacterEncodingFilter＜/filter-class＞ 6. ＜init-param＞ 7. ＜param-name＞encoding＜/param-name＞ 8. ＜param-value＞GBK＜/param-value＞ 9. ＜/init-param＞ 10. ＜/filter＞ 11. ＜filter-mapping＞ 12. ＜filter-name＞encodingFilter＜/filter-name＞ 13. ＜url-pattern＞/*＜/url-pattern＞ 14. ＜/filter-mapping＞ 15. … 16. ＜/web-app＞ 　　Spring的过滤器类是org.springframework.web.filter.CharacterEncodingFilter，通过encoding参数指定编码转换类型为GBK，＜filter-mapping＞的配置使该过滤器截获所有的请示。 　　Struts的框架也需要在web.xml中配置，想必读者朋友对Struts的配置都很熟悉，故在此不再提及，请参见本文所提供的源码。 　　总结 　　本文通过一个文件上传下载的Web应用，讲解了如何构建基于SSH的Web应用，通过Struts和FormFile，Spring的LobHandler以及Spring为HibernateBlob处理所提供的用户类BlobByteArrayType ，实现上传和下载文件的功能仅需要廖廖数行的代码即告完成。读者只需对程序作稍许的调整，即可处理Clob字段： 　　•领域对象对应Clob字段的属性声明为String类型； 　　•映射文件对应Clob字段的属性声明为org.springframework.orm.hibernate3.support.ClobStringType类型。

北大青鸟java毕业设计项目《CRM客户关系管理系统》

Author：青鸟学子 QQ：64578820 Msn：foart@hotmail.com 开发环境：myEclipse6.5 + jdk1.6 + tomcat6.0 struts1.x + spring 2.x + hibernate 3.x 使用了SSH框架 + DWR + Json 演示地址：http://foart.cn:8080/crm 用户信息： id userName userPW userRole state version -------------------- ---------- ---------- -------- ----- -------------------- 5 sa sa 客户经理 正常 0 7 pk pk 高管 正常 0 10 sop sop 客户经理 正常 0 11 kao kao 销售主管 正常 0 15 admin admin 管理员 正常 0 项目是小组完成的，我把我负责的部分共享出来。 【营销管理】 销售机会管理 客户开发计划 【客户管理】 客户信息管理 客户流失管理 【统计报表】 客户贡献分析 客户构成分析 【基础数据】 数据字典管理

北大青鸟客户管理系统

开发环境：myEclipse6.5 + jdk1.6 + tomcat6.0 struts1.x + spring 2.x + hibernate 3.x 使用了SSH框架 + DWR + Json 演示地址：http://foart.cn:8080/crm 用户信息： id userName userPW userRole state version

spring_MVC源码

弃用了struts，用spring mvc框架做了几个项目，感觉都不错，而且使用了注解方式，可以省掉一大堆配置文件。本文主要介绍使用注解方式配置的spring mvc，之前写的spring3.0 mvc和rest小例子没有介绍到数据层的内容，现在这一篇补上。下面开始贴代码。 文中用的框架版本：spring 3,hibernate 3,没有的，自己上网下。 先说web.xml配置： [java] view plaincopy 01.&lt;?xml version="1.0" encoding="UTF-8"?&gt; 02.<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"> 03. <display-name>s3h3</display-name> 04. <context-param> 05. <param-name>contextConfigLocation</param-name> 06. <param-value>classpath:applicationContext*.xml</param-value> 07. </context-param> 08. <listener> 09. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 10. </listener> 11. 12. <servlet> 13. <servlet-name>spring</servlet-name> 14. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 15. <load-on-startup>1</load-on-startup> 16. </servlet> 17. <servlet-mapping> 18. <servlet-name>spring</servlet-name> &lt;!-- 这里在配成spring,下边也要写一个名为spring-servlet.xml的文件，主要用来配置它的controller --&gt; 19. <url-pattern>*.do</url-pattern> 20. </servlet-mapping> 21. <welcome-file-list> 22. <welcome-file>index.jsp</welcome-file> 23. </welcome-file-list> 24.</web-app> spring-servlet,主要配置controller的信息 [java] view plaincopy 01.&lt;?xml version="1.0" encoding="UTF-8"?&gt; 02. <beans 03. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 04. xmlns:context="http://www.springframework.org/schema/context" 05. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 06. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 07. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 08. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> 09. 10. <context:annotation-config /> 11. &lt;!-- 把标记了@Controller注解的类转换为bean --&gt; 12. <context:component-scan base-package="com.mvc.controller" /> 13. &lt;!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 --&gt; 14. <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /> 15. 16. &lt;!-- 对模型视图名称的解析，即在模型视图名称添加前后缀 --&gt; 17. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" 18. p:prefix="/WEB-INF/view/" p:suffix=".jsp" /> 19. 20. <bean id="multipartResolver" 21. class="org.springframework.web.multipart.commons.CommonsMultipartResolver" 22. p:defaultEncoding="utf-8" /> 23. </beans> applicationContext.xml代码 [java] view plaincopy 01.&lt;?xml version="1.0" encoding="UTF-8"?&gt; 02.<beans 03. xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" 04. xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" 05. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 06. xsi:schemaLocation=" 07. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 08. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 09. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 10. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"> 11. 12. <context:annotation-config /> 13. <context:component-scan base-package="com.mvc" /> &lt;!-- 自动扫描所有注解该路径 --&gt; 14. 15. <context:property-placeholder location="classpath:/hibernate.properties" /> 16. 17. <bean id="sessionFactory" 18. class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> 19. <property name="dataSource" ref="dataSource" /> 20. <property name="hibernateProperties"> 21. <props> 22. <prop key="hibernate.dialect">${dataSource.dialect}</prop> 23. <prop key="hibernate.hbm2ddl.auto">${dataSource.hbm2ddl.auto}</prop> 24. <prop key="hibernate.hbm2ddl.auto">update</prop> 25. </props> 26. </property> 27. <property name="packagesToScan"> 28. <list> 29. <value>com.mvc.entity</value>&lt;!-- 扫描实体类，也就是平时所说的model --&gt; 30. </list> 31. </property> 32. </bean> 33. 34. <bean id="transactionManager" 35. class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 36. <property name="sessionFactory" ref="sessionFactory" /> 37. <property name="dataSource" ref="dataSource" /> 38. </bean> 39. 40. <bean id="dataSource" 41. class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 42. <property name="driverClassName" value="${dataSource.driverClassName}" /> 43. <property name="url" value="${dataSource.url}" /> 44. <property name="username" value="${dataSource.username}" /> 45. <property name="password" value="${dataSource.password}" /> 46. </bean> 47. &lt;!-- Dao的实现 --&gt; 48. <bean id="entityDao" class="com.mvc.dao.EntityDaoImpl"> 49. <property name="sessionFactory" ref="sessionFactory" /> 50. </bean> 51. <tx:annotation-driven transaction-manager="transactionManager" /> 52. <tx:annotation-driven mode="aspectj"/> 53. 54. <aop:aspectj-autoproxy/> 55.</beans> hibernate.properties数据库连接配置 [java] view plaincopy 01.dataSource.password=123 02.dataSource.username=root 03.dataSource.databaseName=test 04.dataSource.driverClassName=com.mysql.jdbc.Driver 05.dataSource.dialect=org.hibernate.dialect.MySQL5Dialect 06.dataSource.serverName=localhost:3306 07.dataSource.url=jdbc:mysql://localhost:3306/test 08.dataSource.properties=user=${dataSource.username};databaseName=${dataSource.databaseName};serverName=${dataSource.serverName};password=${dataSource.password} 09.dataSource.hbm2ddl.auto=update 配置已经完成，下面开始例子 先在数据库建表，例子用的是mysql数据库 [java] view plaincopy 01.CREATE TABLE `test`.`student` ( 02. `id` int(10) unsigned NOT NULL AUTO_INCREMENT, 03. `name` varchar(45) NOT NULL, 04. `psw` varchar(45) NOT NULL, 05. PRIMARY KEY (`id`) 06.) 建好表后，生成实体类 [java] view plaincopy 01.package com.mvc.entity; 02. 03.import java.io.Serializable; 04. 05.import javax.persistence.Basic; 06.import javax.persistence.Column; 07.import javax.persistence.Entity; 08.import javax.persistence.GeneratedValue; 09.import javax.persistence.GenerationType; 10.import javax.persistence.Id; 11.import javax.persistence.Table; 12. 13.@Entity 14.@Table(name = "student") 15.public class Student implements Serializable { 16. private static final long serialVersionUID = 1L; 17. @Id 18. @Basic(optional = false) 19. @GeneratedValue(strategy = GenerationType.IDENTITY) 20. @Column(name = "id", nullable = false) 21. private Integer id; 22. @Column(name = "name") 23. private String user; 24. @Column(name = "psw") 25. private String psw; 26. public Integer getId() { 27. return id; 28. } 29. public void setId(Integer id) { 30. this.id = id; 31. } 32. 33. public String getUser() { 34. return user; 35. } 36. public void setUser(String user) { 37. this.user = user; 38. } 39. public String getPsw() { 40. return psw; 41. } 42. public void setPsw(String psw) { 43. this.psw = psw; 44. } 45.} Dao层实现 [java] view plaincopy 01.package com.mvc.dao; 02. 03.import java.util.List; 04. 05.public interface EntityDao { 06. public List&lt;Object&gt; createQuery(final String queryString); 07. public Object save(final Object model); 08. public void update(final Object model); 09. public void delete(final Object model); 10.} [java] view plaincopy 01.package com.mvc.dao; 02. 03.import java.util.List; 04. 05.import org.hibernate.Query; 06.import org.springframework.orm.hibernate3.HibernateCallback; 07.import org.springframework.orm.hibernate3.support.HibernateDaoSupport; 08. 09.public class EntityDaoImpl extends HibernateDaoSupport implements EntityDao{ 10. public List&lt;Object&gt; createQuery(final String queryString) { 11. return (List&lt;Object&gt;) getHibernateTemplate().execute( 12. new HibernateCallback&lt;Object&gt;() { 13. public Object doInHibernate(org.hibernate.Session session) 14. throws org.hibernate.HibernateException { 15. Query query = session.createQuery(queryString); 16. List&lt;Object&gt; rows = query.list(); 17. return rows; 18. } 19. }); 20. } 21. public Object save(final Object model) { 22. return getHibernateTemplate().execute( 23. new HibernateCallback&lt;Object&gt;() { 24. public Object doInHibernate(org.hibernate.Session session) 25. throws org.hibernate.HibernateException { 26. session.save(model); 27. return null; 28. } 29. }); 30. } 31. public void update(final Object model) { 32. getHibernateTemplate().execute(new HibernateCallback&lt;Object&gt;() { 33. public Object doInHibernate(org.hibernate.Session session) 34. throws org.hibernate.HibernateException { 35. session.update(model); 36. return null; 37. } 38. }); 39. } 40. public void delete(final Object model) { 41. getHibernateTemplate().execute(new HibernateCallback&lt;Object&gt;() { 42. public Object doInHibernate(org.hibernate.Session session) 43. throws org.hibernate.HibernateException { 44. session.delete(model); 45. return null; 46. } 47. }); 48. } 49.} Dao在applicationContext.xml注入 <bean id="entityDao" class="com.mvc.dao.EntityDaoImpl"> <property name="sessionFactory" ref="sessionFactory" /> </bean> Dao只有一个类的实现，直接供其它service层调用，如果你想更换为其它的Dao实现，也只需修改这里的配置就行了。 开始写view页面，WEB-INF/view下新建页面student.jsp，WEB-INF/view这路径是在spring-servlet.xml文件配置的，你可以配置成其它，也可以多个路径。student.jsp代码 [xhtml] view plaincopy 01.<%@ page language="java" contentType="text/html; charset=UTF-8" 02. pageEncoding="UTF-8"%> 03.<%@ include file="/include/head.jsp"%> 04.<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 05.&lt;html&gt; 06.&lt;head&gt; 07.&lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&gt; 08.&lt;title&gt;添加&lt;/title&gt; 09.<mce:script language="javascript" src="<%=request.getContextPath()%>&lt;!-- 10./script/jquery.min.js"> 11.// --&gt;</mce:script> 12.<mce:style>&lt;!-- 13.table{ border-collapse:collapse; } 14.td{ border:1px solid #f00; } 15.--&gt;</mce:style>&lt;style mce_bogus="1"&gt;table{ border-collapse:collapse; } 16.td{ border:1px solid #f00; }&lt;/style&gt; 17.<mce:script type="text/javascript">&lt;!-- 18.function add(){ 19. [removed].href="&lt;%=request.getContextPath() %&gt;/student.do?method=add"; 20.} 21. 22.function del(id){ 23.$.ajax( { 24. type : "POST", 25. url : "<%=request.getContextPath()%>/student.do?method=del&id;=" + id, 26. dataType: "json", 27. success : function(data) { 28. if(data.del == "true"){ 29. alert&#40;"删除成功！"&#41;; 30. $("#" + id).remove(); 31. } 32. else{ 33. alert&#40;"删除失败！"&#41;; 34. } 35. }, 36. error :function(){ 37. alert&#40;"网络连接出错！"&#41;; 38. } 39.}); 40.} 41.// --&gt;</mce:script> 42.&lt;/head&gt; 43.&lt;body&gt; 44. 45.&lt;input id="add" type="button" value="添加"/&gt; 46.<table > 47. <tr> 48. <td>序号</td> 49. <td>姓名</td> 50. <td>密码</td> 51. <td>操作</td> 52. </tr> 53. <c:forEach items="${list}" var="student"> 54. <tr id="<c:out value="${student.id}"/>"> 55. <td><c:out value="${student.id}"/></td> 56. <td><c:out value="${student.user}"/></td> 57. <td><c:out value="${student.psw}"/></td> 58. <td> 59. &lt;input type="button" value="编辑"/&gt; 60. &lt;input type="button" value="${student.id}"/&gt;&#39;)" value="删除"/> 61. </td> 62. </tr> 63. </c:forEach> 64. 65.</table> 66.&lt;/body&gt; 67.&lt;/html&gt; student_add.jsp [xhtml] view plaincopy 01.<%@ page language="java" contentType="text/html; charset=UTF-8" 02. pageEncoding="UTF-8"%> 03.<%@ include file="/include/head.jsp"%> 04.<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 05.&lt;html&gt; 06.&lt;head&gt; 07.&lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&gt; 08.&lt;title&gt;学生添加&lt;/title&gt; 09.<mce:script type="text/javascript">&lt;!-- 10.function turnback(){ 11. [removed].href="&lt;%=request.getContextPath() %&gt;/student.do"; 12.} 13.// --&gt;</mce:script> 14.&lt;/head&gt; 15.&lt;body&gt; 16.&lt;form method="post" action="&lt;%=request.getContextPath() %>/student.do?method=save"> 17.<div><c:out value="${addstate}"></c:out></div> 18.<table> 19. <tr><td>姓名</td><td>&lt;input id="user" name="user" type="text" /&gt;&lt;/td></tr> 20. <tr><td>密码</td><td>&lt;input id="psw" name="psw" type="text" /&gt;&lt;/td></tr> 21. <tr><td colSpan="2" align="center">&lt;input type="submit" value="提交"/&gt;&lt;input type="button" value="返回" /> </td></tr> 22.</table> 23. 24.&lt;/form&gt; 25.&lt;/body&gt; 26.&lt;/html&gt; controller类实现，只需把注解写上，spring就会自动帮你找到相应的bean，相应的注解标记意义，不明白的，可以自己查下@Service，@Controller，@Entity等等的内容。 [java] view plaincopy 01.package com.mvc.controller; 02. 03.import java.util.List; 04. 05.import javax.servlet.http.HttpServletRequest; 06.import javax.servlet.http.HttpServletResponse; 07. 08.import org.apache.commons.logging.Log; 09.import org.apache.commons.logging.LogFactory; 10.import org.springframework.beans.factory.annotation.Autowired; 11.import org.springframework.stereotype.Controller; 12.import org.springframework.ui.ModelMap; 13.import org.springframework.web.bind.annotation.RequestMapping; 14.import org.springframework.web.bind.annotation.RequestMethod; 15.import org.springframework.web.bind.annotation.RequestParam; 16.import org.springframework.web.servlet.ModelAndView; 17. 18.import com.mvc.entity.Student; 19.import com.mvc.service.StudentService; 20. 21.@Controller 22.@RequestMapping("/student.do") 23.public class StudentController { 24. protected final transient Log log = LogFactory 25. .getLog(StudentController.class); 26. @Autowired 27. private StudentService studentService; 28. public StudentController(){ 29. 30. } 31. 32. @RequestMapping 33. public String load(ModelMap modelMap){ 34. List&lt;Object&gt; list = studentService.getStudentList(); 35. modelMap.put("list", list); 36. return "student"; 37. } 38. 39. @RequestMapping(params = "method=add") 40. public String add(HttpServletRequest request, ModelMap modelMap) throws Exception{ 41. return "student_add"; 42. } 43. 44. @RequestMapping(params = "method=save") 45. public String save(HttpServletRequest request, ModelMap modelMap){ 46. String user = request.getParameter("user"); 47. String psw = request.getParameter("psw"); 48. Student st = new Student(); 49. st.setUser(user); 50. st.setPsw(psw); 51. try{ 52. studentService.save(st); 53. modelMap.put("addstate", "添加成功"); 54. } 55. catch(Exception e){ 56. log.error(e.getMessage()); 57. modelMap.put("addstate", "添加失败"); 58. } 59. 60. return "student_add"; 61. } 62. 63. @RequestMapping(params = "method=del") 64. public void del(@RequestParam("id") String id, HttpServletResponse response){ 65. try{ 66. Student st = new Student(); 67. st.setId(Integer.valueOf(id)); 68. studentService.delete(st); 69. response.getWriter().print("{/"del/":/"true/"}"); 70. } 71. catch(Exception e){ 72. log.error(e.getMessage()); 73. e.printStackTrace(); 74. } 75. } 76.} service类实现 [java] view plaincopy 01.package com.mvc.service; 02. 03.import java.util.List; 04. 05.import org.springframework.beans.factory.annotation.Autowired; 06.import org.springframework.stereotype.Service; 07.import org.springframework.transaction.annotation.Transactional; 08. 09.import com.mvc.dao.EntityDao; 10.import com.mvc.entity.Student; 11. 12.@Service 13.public class StudentService { 14. @Autowired 15. private EntityDao entityDao; 16. 17. @Transactional 18. public List&lt;Object&gt; getStudentList(){ 19. StringBuffer sff = new StringBuffer(); 20. sff.append("select a from ").append(Student.class.getSimpleName()).append(" a "); 21. List&lt;Object&gt; list = entityDao.createQuery(sff.toString()); 22. return list; 23. } 24. 25. public void save(Student st){ 26. entityDao.save(st); 27. } 28. public void delete(Object obj){ 29. entityDao.delete(obj); 30. } 31.} OK，例子写完。有其它业务内容，只需直接新建view，并实现相应comtroller和service就行了，配置和dao层的内容基本不变，也就是每次只需写jsp（view），controller和service调用dao就行了。 怎样，看了这个，spring mvc是不是比ssh实现更方便灵活。

ssh 整合的实例-----员工表的增删查改

ssh 框架整合的实例。 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" 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-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <bean id="mydataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="username" value="root"> </property> <property name="password" value="tarena"> </property> <property name="url" value="jdbc:mysql://localhost:3306/test"> </property> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="initialSize" value="2"> </property> </bean> <bean id="mysessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="mydataSource"> </property> <property name="mappingResources"> <list> <value>com/mysteelsoft/entity/Employee.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.format_sql">true</prop> <prop key="hibernate.dialect"> org.hibernate.dialect.SQLServerDialect </prop> </props> </property> </bean> <bean id="employeeDao" class="com.mysteelsoft.dao.impl.EmployeeDaoHibernateImpl"> <property name="sessionFactory" ref="mysessionFactory"> </property> </bean> <bean name="/searchEmployee" scope="prototype" class="com.mysteelsoft.action.EmployeeAction"> <property name="employeeDao" ref="employeeDao"/> </bean> <bean name="/addEmployee" scope="prototype" class="com.mysteelsoft.action.AddEmployeeAction"> <property name="employeeDao" ref="employeeDao"/> </bean> <bean name="/deleteEmployee" scope="prototype" class="com.mysteelsoft.action.DeleteEmployeeAction"> <property name="employeeDao" ref="employeeDao"/> </bean> <bean name="/showEmployee" scope="prototype" class="com.mysteelsoft.action.ShowEmployeeAction"> <property name="employeeDao" ref="employeeDao"/> </bean> <bean name="/updateEmployee" scope="prototype" class="com.mysteelsoft.action.UpdateEmployeeAction"> <property name="employeeDao" ref="employeeDao"/> </bean> </beans>

windows2003关闭启动时的错误提示

windows2003关闭启动时的错误提示 ,是个小注册表。