JSF集成Spring Framework和Hibernate开发实例

教 学 中心 的教学 资源越发 显 得 紧张有 限 ．实验 教学 的 业 务数 据 的表 现形 式 的问题 ．它包 含 了用 于在 各层 之
效 果受到 了一定 的影响 ．传 统 的实验 教学 方式 已经 难 问传 递 信息 的数据 集 。 根据需 求分析结 果 ， 每个 业务 实 以满足 教学 要求 的需 要 Ｉｔｒｅ 技术 的迅 猛发 展 为 体将 模 型化 物理数 据库 中 的特定信 息 ，并 选择 适 当的 ｎｅｎ ｔ ｒ ｉｅｎ ｔ 框 实 验教学 的改 革提供 了有 效 途径 ．利 用 Ｊ Ｖ Ｅ Ａ Ａ Ｅ ５平 方 式建 立不 同的业 务实体 本 系统采用 Ｈ ｂ ｒａｅ 架 Ｒ Ｐ 台 发基 于 Ｗｅ Ｆ ｂ的实验 教学 系统 ． 改革 传统 实 验教 学 将 关 系数 据表 Ｏ Ｍ 映射 成 Ｊ Ａ持久 对象 ．从而 完 成
系统 为教 师和学 生提供 了一个 良好 的教 学平 台， 学生 可以预 先 熟悉 实验教 学 内容 的相 关知识 ， 完成 实验 作 业 ， 师 可 以适 时批 阅 实验报 告 ， ．ｌ 线指 导 和答疑 ， 而提 高 实验 教 学质量 ， 教 ａ￣在 － 从 系统 具有 较 高的 实用 价
值 。文章介 绍 了 系统 的体 系结构 、 系统 主要 功 能和 系统 实现 的 关键 技 术。 【 关键词 】 Ｓ ； ｂ ｒａ ；ｊｘ 教 学 ：ＪＦ Ｈｉｅｎｔ Ａａ ； ｅ
福 建 电
脑
８ ７
色 分为 教 师 、 生 和系 统 管 理员 。 系 统管 理 员 模 块 主 则 负 责 数 据 的 表 现 系 统 所 有 功 能 模 块 中 的 交 互 如 添 学 要 实 现 系统 朋 户 信 息 管 理 、 据 库 备 份 、 验 教 学课 加 、 数 实 删除 、 改 等 ， 不需 要 刷 新 页 面 从 系统 界 面上 修 均 目管 理 的功 能 教师 模 块 主要 实 现个 人 信 息 管 理 、 发 看 ．它象一 个 Ｄ Ｉｈ 或 是 Ｖ ｅ ｉ ｐ Ｂ编 写 的 Ｃｓ系统 ． ， 但 布 课 程信 息 、 验报 告 管理 、 线 答疑 的功 能 。 生模 实 际 上 它 是 刚 Ｈ ＭＬ编 写 的 在 浏 览 器 中 运 行 的 ＢＳ系 实 在 学 Ｔ ／

1.Java对象持久化概述1.1.应用程序的分层体系结构1.1.1.基于B/S的典型三层架构说明：1，展现层：提供与用户交互的界面。

2，业务逻辑层：实现各种业务逻辑。

3，数据访问层：负责存放和管理应用程序的持久化业务数据。

1.1.2.数据访问层与Hibernate在Java应用程序中的角色数据访问层（持久化层）封装了数据访问的细节，为业务逻辑层提供了面向对象的API。

完善的持久化层应该达到的目标：1，代码重用性高，可完成所有的数据访问操作。

2，如果需要的话，能够支持多种数据库平台。

3，具有相对独立性，当持久化层变化时，不会影响上层实现。

在数据访问层（持久化层）中可以使用Hibernate框架以实现要求，如下图所示：1.2.软件模型1.2.1.各种模型的说明概念模型：模拟问题域中的真实实体。

描述每个实体的概念和属性及实体间关系。

不描述实体行为。

实体间的关系有一对一、一对多和多对多。

关系数据模型：在概念模型的基础上建立起来的，用于描述这些关系数据的静态结构。

有以下内容组成：1，若干表2，表的所有索引3，视图4，触发器5，表与表之间的参照完整性域模型：在软件的分析阶段创建概念模型，在软件设计阶段创建域模型。

组成部分：1，具有状态和行为的域对象。

2，域对象之间的关联。

域对象(domain object)：构成域模型的基本元素就是域对象。

对真实世界的实体的软件抽象，也叫做业务对象（Business Object，BO）。

域对象可代表业务领域中的人、地点、事物或概念。

域对象分为以下几种:1，实体域对象：通常是指业务领域中的名词。

（plain old java object，简单Java 对象）。

2，过程域对象：应用中的业务逻辑或流程。

依赖于实体域对象，业务领域中的动词。

如发出订单、登陆等。

3，事件域对象：应用中的一些事件（警告、异常）。

1.2.2.域对象间的关系关联：类间的引用关系。

以属性定义的方式表现。

依赖：类之间访问关系。

Hibernate+Spring多数据库解决方案我以前在项目中的探索和实践，写出来与大家分享。

大家有其他好的方式，也欢迎分享。

环境：JDK 1.4.x , Hibernate 3.1, Spring 2.0.6, JBOSS4.0, 开发模式: Service + DAO我们项目中需要同时使用多个数据库. 但 Hibernate 不能直接支持，为此我们对比了网上网友的方案，自己做了一点探索。

1. Demo需求我们的项目使用一个全省的公共库加十多个地市库的架构。

本文主要说明原理，将需求简化为两库模型。

主库：User管里，主要是系统管理，鉴权等数据；订单库：Order 管理，存放订单等业务性数据。

2. 原理：1） Hibernate 的每个配置文件对应一个数据库，因此多库需要做多个配置文件。

本文以两个为例：主库 hibernate_sys.cfg.xml，订单库 hibernate_order.cfg.xml每个库，Hibernate 对应一个 sessionFactory 实例，因此Hibernate 下的多库处理，就是在多个 sessionFactory 之间做好路由。

2) sessionFactory 有个 sessionFactory.getClassMetadata(voClass) 方法，返回值不为空时，表示该 VO 类在该库中(hbm.xml文件配置在了对应的hibernate.cfg.xml中)，该方法是数据路由的核心和关键所在。

因此， User.hbm.xml 配置在 hibernate_sys.cfg.xml ，Order数据位于配置到 hibernate_order.cfg.xml3）多库处理时，需要使用 XA 事务管理。

本例中使用 Jboss4.0 来做JTA事务管理；用JOTM，其他应用服务器原理相同。

3. 实现1）为做多 sessionFactory 实例的管理，设计 SessionFactoryManager 类，功能就是做数据路由，控制路由的核心是 sessionFactoryMap 属性，它按dbFlag=sessionFactory 的方式存储了多个库的引用。

spring4.x + hibernate4.x 配置详解关于spring和hibernate的使用以及特征等等，在此不再啰嗦，相信大家也都知道，或者去搜索一下即可。

本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式，当然spring3.x以及hibernate4.x也可以借鉴。

首先是配置文件web.xml 增加以下代码即可<!-- 加载spring相关的配置文件--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/applicationContext.xml</param-value> </context-param><!-- 启用spring监听--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</l istener-class></listener>然后建立 applicationContext.xml 文件，src下。

文件内容如下，注释我尽量写的很详细<beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:aop="http://ww /schema/aop"xmlns:context="/schema/context"xmlns:tx="ht tp:///schema/tx"xmlns:cache="/schema/cache"xmlns:p="http:// /schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd/schema/cache http://www.springframewor /schema/cache/spring-cache-4.0.xsd"><!-- 引入properties文件--><context:property-placeholder location="classpath*:/appConfig.properties"/> <!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--> <bean id="dataSource"class="boPooledDataSourc e"destroy-method="close"><!-- 设置JDBC驱动名称--><property name="driverClass"value="${jdbc.driver}"/><!-- 设置JDBC连接URL --><property name="jdbcUrl"value="${jdbc.url}"/><!-- 设置数据库用户名--><property name="user"value="${ername}"/><!-- 设置数据库密码--><property name="password"value="${jdbc.password}"/><!-- 设置连接池初始值--><property name="initialPoolSize"value="5"/></bean><!-- 配置sessionFactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><!-- 数据源--><property name="dataSource"ref="dataSource"/><!-- hibernate的相关属性配置--><property name="hibernateProperties"><value><!-- 设置数据库方言-->hibernate.dialect=org.hibernate.dialect.MySQLDialect<!-- 设置自动创建|更新|验证数据库表结构-->hibernate.hbm2ddl.auto=update<!-- 是否在控制台显示sql -->hibernate.show_sql=true<!-- 是否格式化sql，优化显示-->hibernate.format_sql=true<!-- 是否开启二级缓存-->e_second_level_cache=false<!-- 是否开启查询缓存-->e_query_cache=false<!-- 数据库批量查询最大数-->hibernate.jdbc.fetch_size=50<!-- 数据库批量更新、添加、删除操作最大数-->hibernate.jdbc.batch_size=50<!-- 是否自动提交事务-->hibernate.connection.autocommit=true<!-- 指定hibernate在何时释放JDBC连接-->hibernate.connection.release_mode=auto<!-- 创建session方式hibernate4.x 的方式-->hibernate.current_session_context_class=org.springframework.or m.hibernate4.SpringSessionContext<!-- javax.persistence.validation.mode默认情况下是auto的，就是说如果不设置的话它是会自动去你的classpath下面找一个bean-validation**包所以把它设置为none即可-->javax.persistence.validation.mode=none</value></property><!-- 自动扫描实体对象tdxy.bean的包结构中存放实体类--><property name="packagesToScan"value="tdxy.bean"/> </bean><!-- 定义事务管理--><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"ref="sessionFactory"/> </bean><!-- 定义Autowired 自动注入bean --><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotati onBeanPostProcessor"/><!-- 扫描有注解的文件base-package 包路径--><context:component-scan base-package="tdxy"/><tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><!-- 事务执行方式REQUIRED：指定当前方法必需在事务环境中运行，如果当前有事务环境就加入当前正在执行的事务环境，如果当前没有事务，就新建一个事务。

Struts的原理和优点.Struts工作原理MVC即Model—View—Controller的缩写，是一种常用的设计模式。

MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

MVC的工作原理，如下图1所示：Struts 是MVC的一种实现，它将Servlet和JSP 标记(属于J2EE 规范）用作实现的一部分。

Struts继承了MVC的各项特性,并根据J2EE的特点，做了相应的变化与扩展.Struts的工作原理，视图:主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库: Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。

控制：在Struts中,承担MVC中Controller角色的是一个Servlet，叫ActionServlet。

ActionServlet是一个通用的控制组件。

这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。

它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类）。

另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean），并传给动作类（通常称之为ActionBean）。

动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。

最后动作类把控制权传给后续的JSP 文件，后者生成视图。

所有这些控制逻辑利用Struts-config.xml文件来配置。

模型：模型以一个或多个java bean的形式存在。

这些bean分为三类：Action Form、Action、JavaBean or EJB.Action Form通常称之为FormBean，封装了来自于Client的用户请求信息,如表单信息。

Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。

属性可以是update、create和drop-create三个值。
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象 如果PO 实例与Session实例关联起来，且该实例关联到数据库的记录
脱管对象 如果PO实例曾经与Session实例关联过，但是因为Session的关闭等原 因，PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作，它具有数据库事务的概念 但它通过抽象，将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。 一个Session 之内可能包含多个Transaction对象。 所有的持久化操作都应该在事务管理下进行，即使是只读操作。
管态，对该对象操作无须锁定数据库，不会造成性能的下降。
持久化对象的状态迁移
持久化实体： 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态，该对象保存到数据库，指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例，初始 化该实例中的所有变量

一搭建三大框架步骤1 搭建s2sh步骤分析:1.1在MyEclipse 里面新建一个 java web project1.2新建三个 Source Folder :src : 源文件config : 存放配置文件 : hibernate , spring , struts2test: 测试类1.3 导入环境需要的jar 包 : WebRoot/WEB-INF/lib (一共64个)2 搭建Hibernate 和Spring 整合(*根据搭建需求谁能先测试就先搭建谁)2.1 在 src 源文件里面建立一个 cola.s2sh.domain[并且在该包下创建一个持久类和该类的映射文件] .2.2 配置核心文件在 config 里面建立一个hibernate 文件夹里面创建hibernate.cfg.xml配置文件(里面的内容拷贝就可以)2.3 在spring 文件夹里面创建并且把sessionFactory 交给spring 来管理: [applicationContext-db.xml中引入][<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"><value>classpath:hibernate/hibernate.cfg.xml</value> </property></bean>]在 applicationContext.xml 中 : 导入<import resource="applicationContext-db.xml"/>2.4 测试sessionFactory[编写SpringUtils 然后继承这个][public class SpringUtils {public static ApplicationContext context;static {context = newClassPathXmlApplicationContext("spring/applicationContext.xml" );}}]2.5 编写 dao .service 的包类和接口;PersonDaoImpl 要继承HibernateDaoSupport[public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {public void savePerson(Person person) {this.getHibernateTemplate().save(person);}}]2.6 把 dao ,service 放在spring 容器中:[<bean id="personDao"class="cola.s2sh.daoImpl.PersonDaoImpl"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><bean id="personService"class="cola.s2sh.service.impl.PersonServiceImpl"><property name="personDao"><ref bean="personDao"/></property></bean>]2.7 完成 spring 声明式处理 :[<!-- 事务管理 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><tx:advice id="tx"transaction-manager="transactionManager"><tx:attributes><tx:method name="save*"read-only="false"/><tx:method name="update*"read-only="false"/><tx:method name="delete*"read-only="false"/><!--除了上面三种情况以外的情况--><tx:method name="*"read-only="true"/></tx:attributes></tx:advice><aop:config><aop:pointcutexpression="execution(* cola.s2sh.service.impl.*.*(..))"id="perform"/><aop:advisor advice-ref="tx"pointcut-ref="perform"/> </aop:config>]2.8 整合struts 创建 action 类包 ;2.9 把action 放在spring 容器中* 注意在personAction的spring的配置中一定要写一个属性scope="prototype"[<bean id="personAction"class="cola.s2sh.action.PersonAction" scope="prototype"><property name="personService"><ref bean="personService"/></property></bean>]在这个中引入下面3.0 编写struts2中配置文件Struts –person.xml中Struts.xml3.1 编写web .xml文件[<?xml version="1.0"encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"id="WebApp_ID"version="3.0"><display-name>cola.s2sh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><!—将srping放在SrvletContext中进行加载当servlet加载时 spring 也完成加载 --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/applicationContext.xml</param-value> </context-param><filter><filter-name>OpenSessionInViewFilter</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping><filter-name>OpenSessionInViewFilter</filter-name><url-pattern>*.action</url-pattern></filter-mapping><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter -class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>]二原理分析:一、 Struts 2框架整合Spring步骤1、复制文件。

SpringMVC框架搭建说明Spring4.1.4 + hibernate4.3.81、web.xml配置程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet如下为web.xml的配置说明<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><!—-显示项目名称--><display-name>bmymis2</display-name><!-- 指定配置文件位置，contextConfigLocation是ContextLoaderListener中的一个参数，通过该参数在ContextLoaderListener中加载applicationContext-*.xml,并装配ApplicationContext --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value></context-param><!-- 定义SPRING监听器，启动Web容器时,自动装配ApplicationContext的配置信息--><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!—-字符编码过滤器,解决中文乱码问题--><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><!—- springmvc配置--><servlet><servlet-name>springServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup> //容器启动时首先初始化该servlet </servlet><servlet-mapping><servlet-name>springServlet</servlet-name><url-pattern>/</url-pattern> //表示所有页面都由springmvc处理</servlet-mapping><!—-浏览器输入到项目名，默认打开如下配置页面--><welcome-file-list><welcome-file>/web/login.jsp</welcome-file></welcome-file-list><!—-错误跳转页面--><error-page><error-code>404</error-code><location>/404.html</location></error-page></web-app>2、applicationContext-common.xml配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 加载资源文件其中包含变量信息，必须在Spring配置文件的最前面加载，即第一个加载--><context:property-placeholder location="classpath:application.properties"/><!—-扫描包路径选项，使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入，有了该配置,那么<context:annotation-config/>这个配置就可以省略（以下配置包含了<context:annotation-config/>配置）--><context:component-scan base-package="xxx.xxx.xxx"/><!-- 数据源配置,使用应用内的DBCP数据库连接池 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><!—Hibernate的注解配置 --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><prop key="hibernate.dialect">${hibernate.dialect}</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop></props></property><property name="packagesToScan" value="xxx.xxx.xxx.model" /></bean><!-- 配置Hibernate事务管理器 --><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置事务异常封装 --><bean id="persistenceExceptionTranslationPostProcessor"class="org.springframework.dao.annotation.PersistenceExceptionTranslationPost Processor"/><!-- 声明式容器事务管理 ,transaction-manager指定事务管理器为transactionManager --> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="add*" propagation="REQUIRED"/><tx:method name="get*" propagation="REQUIRED"/><tx:method name="*" read-only="true"/></tx:attributes></tx:advice><aop:config expose-proxy="true"><!-- 只对业务逻辑层实施事务 --><aop:pointcut id="txPointcut"expression="execution(*xxx.xxx.xxx.service..*.*(..))"/><!-- Advisor定义，切入点和通知分别为txPointcut、txAdvice --><aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/> </aop:config></beans>3、application.properties配置jdbc.driverClassName=org.postgresql.Driverjdbc.url=jdbc:postgresql://ip:5432/数据库名ername=postgresjdbc.password=123hibernate.dialect=org.hibernate.dialect.PostgreSQLDialecthibernate.show_sql=truehibernate.format_sql=false4、spring-mvc.xml配置<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 启用spring mvc 注解 --><mvc:annotation-driven><!-- 自动扫描且只扫描@Controller --><context:component-scan base-package="xxx.xxx.xxx "use-default-filters="false"></context:component-scan><!-- 定义JSP文件的位置 --><beanclass="org.springframework.web.servlet.view.InternalResourceView Resolver"><property name="prefix"value="/jsp/"/><property name="suffix"value=".jsp"/></bean><!-- 容器默认的DefaultServletHandler处理所有静态内容与无RequestMapping处理的URL--> <mvc:default-servlet-handler/><!-- 定义无需Controller的url<->view直接映射 --><mvc:view-controller path="/"view-name="login"/></beans>。

搭建SSH框架：Struts1.* + Spring2.5 + Hibernate3.0 一，项目结构：图(1)Jsp页面省略，主要是一些添删改查的页面；二，开始搭建项目环境，步骤如下：使用平台：MyEclipse6.0/6.5框架版本：Struts1.* + Spring2.5 + Hibernate3.0；1，添加过程：1>，新建项目: 打开MyEclipse,在Package Explorer视图下，右键单击New-> Web Project；注意：在新建项目时，JDK的版本最好要选择Java EE 5.0;因为版本过低，可能有些JSP方面的功能不支持；新建玩项目之后，把该导的包导入到下面,下图为SS H 框架所需要的Jar包，注意，该项目用的是ORACLE数据库；其中，activation与mail这两个包为Java发邮件的包;classes12为Oracle数据库的驱动包，如果不是Oracle数据库,可更换该Jar包;dwe为Ajax dwr 框架中的包;2>,接着就开始用MyEclipse辅助开发Struts,Spring,Hibernate了;3>,首先MyEclipse辅助开发Struts,方法:右键单击你所建的项目，出现一级菜单,选择Myeclipse,选择Myeclipse之后会出现二级菜单,接着选择Add Struts Capabilities;;接着具体操作如下面图示：点击Finish按钮完成;完成之后，可将包删除；在上图中，如果那个勾没有去掉的话，就会自动生产如下标签：当然，如果你觉得标签对你没什么用的话，可以删除；如果该勾去掉的话，就只生成标签，这是Struts的核心标签;4>,MyEclipse辅助开发Spring,方法跟上面的一样，选择Add Spring apabilities;;接着具体操作如下面图示：然后点击Next，具体操作如下图：接着点击 Finish按钮，完成此项操作；5>,,最后MyEclipse辅助开发Hibernate,在执行和上面类似方法之前,Hibernate 需要先做另外一件事情，那就是和数据建立连接，具体操作如下图：点击上图位置的或者右边的>> ，然后再选择MyEclipse Database Explorer切换到如下图页面:，然后右键单击，新建一个Database Driver;如下图：下面这个截图是该项目的数据库链接图：如图所示，测试数据库链接成功；然后可直接点击Finish完成；接着切换到窗口，按照上面第三小步的方法，选择Add Hibernate apabilities;;接着具体操作如下面图示：点击下一步：点击下一步：点击下一步：点击下一步：点击 Finish 完成；6>,最后一步，就是运用Hibernate的映射机制，把数据库的表与JAVA的对形成一个关系映射；在此之前，首先应该在项目SRC的目录下面新建一个包，如该项目所示，用来存放映射生成的POJO对象以及映射文件；如下图：有一点说一下，你生成的*.hbm.xml文件可能不止一个，对，你可以把它们整合到一个文件中；然后新建按第五小步的方法，把窗口切换到MyEclipse Database Explorer界面，然后打开右键刚才所建立的链接，选择属于你自己的用户；然后选择Tble;右键选择如上图的属性：接下来的操作如下图：点击 Next,进入下一步：点击 Next,进入下一步：至此，项目环境己经搭建完成；三，项目搭建完成，SSH各个部分配置文件的说明，以及它们之间存在的关系：1，首先是Struts的核心配置文件，即struts-config.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN""/dtds/struts-config_1_2.dtd"><struts-config><data-sources /><form-beans><!—建立Form表单，在此处进行登记 -→<form-bean name="userForm"type="erForm" /> </form-beans><global-exceptions /><global-forwards /><!—各个Action对应与之相对应的表单 -→<action-mappings><!-- 用户管理 --><action parameter="opers" attribute="userForm" name="userForm"path="/doUser" scope="request"><forward name="login_ok" path="/welcome.jsp"></forward><forward name="login_no" path="/index.jsp"></forward> </action></action-mappings><controllerprocessorClass="org.springframework.web.struts.DelegatingRequestProc essor"></controller><message-resourcesparameter="ermanagerview.struts.ApplicationResources"> </message-resources><!—Spring辅助Struts管理Struts-→<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/action-servlet.xml" /></plug-in></struts-config>2,其次就是Springd的applicationContext.xml文件和action-servlet.xml文件：applicationContext.xml文件：<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd"><!-- Session 工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate.cfg.xml"><!-- 可以不要配置文件（hibernate.cfg.xml），直接写在这个Spring的配置文件中 --></property></bean><!-- 模板 --><bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 事务器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManage r"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 对外代理 --><!-- 1,用户管理 --><bean id="userDaoImp"class="erDaoImp"><property name="hibernateTemplate" ref="hibernateTemplate" /> </bean><bean id="userServiceTarget"class="erServiceImp"> <property name="userdao"><ref local="userDaoImp" /></property></bean><bean id="userService"class="org.springframework.transaction.interceptor.TransactionProxyF actoryBean"><property name="transactionManager"><ref local="transactionManager" /></property><property name="target"><ref local="userServiceTarget" /></property><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>action-servlet.xml文件：<!—Spring辅助Struts管理Struts-<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd"> <bean name="/doUser"class="erAction"scope="prototype"></bean></beans>3,最后就是Hibernate的hibernate.cfg..xml文件:<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="ername">wangxiaodong</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.2:1521:ALIZEEDB</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><propertyname="myeclipse.connection.profile">Test</property><property name="connection.password">donny</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><mappingresource="com/ygkq/usermanager/model/entity/User.hbm.xml" /></session-factory></hibernate-configuration>该文件基本上不用动，都是自动生成的代码；当然，你也可以根据自己的需要添加代码，例如，你想在执行HQL语句的时候让它显示SQL语句，可将<property name="hibernate.show_sql">true</property>插入代码中；另外在图(1)中还有两个配置文件没有提到，那就是log4j.properties 与mytag.tld；其中log4j.properties是配置日志信息的；而mytag.tld主一个自定义标签；四，SSH框架搭建完成：SSH框架基本搭建完成，如果有不对或者不妥之处，请随时指教！~E-mail:jerry8059@。

3.3. 创建 Hibernate 配置文件 hibernate.cfg.xml
如果在src/resource目录下面建立，需要把resource目录作为源代码路径，目的 是使applicationContext.xml可以输出到WebRoot\WEB-INF\CLASSES目录下面；
第 6 页 共 11 页
Hibernate.cfg.xml配置文件的内容如下：
<?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/hibernate-configuration3.0.dtd"> <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost:3306/test</property> <property name="ername">root</property> <property name="connection.password">123123</property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 数据库方言 --> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 显示SQL语句 --> <property name="show_sql">true</property> <!-- 根据需要自动创建数据表 --> <property name="hbm2ddl.auto">update</property> <!-- 指定连接池最小、最大连接数 --> <property name="hibernate.c3p0.min_size">1</property> <property name="hibernate.c3p0.max_size">20</property> <!-- 指定连接池连接的超时时长 --> <property name="hibernate.c3p0.timeout">5000</property> <!-- 指定连接池最大缓存多少个statement对象 --> <property name="hibernate.c3p0.max_statements">100</property> <property name="hibernate.c3p0.idle_test_period">3000</property> <property name="hibernate.c3p0.acquire_increment">2</property> <property name="hibernate.c3p0.validate">true</property> <!-- 对象与数据库表格映像文件 --> <mapping resource="com/pakko/bus/domain/User.cfg.xml" /> </session-factory> </hibernate-configuration>

优秀java开源项目代码
有许多优秀的Java开源项目可供学习。

以下是一些示例：
1.Spring Framework：Spring是一个开源的Java平台，为开发者提供了
全面的编程和配置模型，以及一个轻量级的无侵入式框架。

它是一个为Java应用程序开发提供全面支持的框架，尤其在开发企业级应用程序方面表现突出。

2.Hibernate：Hibernate是一个对象关系映射(ORM)框架，它允许Java程
序员将对象模型映射到关系数据库中。

Hibernate提供了一种方式，使你可以直接将对象之间的相互作用映射到数据库的CRUD操作。

3.Apache Commons：Apache Commons是一组Java工具库，提供了许
多实用的功能，包括字符串操作、文件操作、数值计算等。

这个项目为Java开发者提供了许多易于使用且高效的工具。

4.Guava：Guava是Google的Java核心库，提供了很多有用的工具类和实
用程序，如缓存、并发库、原始类型支持、集合操作、字符串处理、I/O等。

flix Eureka：Eureka是一个服务发现组件，用于定位运行在AWS云
或其他云平台上的中间层服务，而不需要服务消费者知道服务提供者的实例ID。

flix Hystrix：Hystrix是一个容错管理工具，旨在隔离访问远程系统、
服务和第三方库的点，以防止级联故障。

flix Ribbon：Ribbon是一个客户端负载均衡器，有助于在云端实现
微服务之间的通信。

以上都是优秀的Java开源项目，你可以从中学习到很多知识和技巧。

获得Spring的系统库包文件1、下载Spring的系统库包（1）进入到Spring的下载包有两种,一种是带有“with-dependencies”名称的，这种包含了Spring常用到的第三方包，比如Hibernate、aopalliance、jakarta-commons等。

这里就使用了这种包，可以省却查找第三方包的麻烦。

（2）解压其*.zip文件（3）所需要的*.jar包在其\dist和\lib目录下，包含有所需要的库●dist/spring.jar●lib/jakarta-commons/commons-logging.jar●lib/log4j/log4j-1.2.9.jar（4）参考文档解压这个包，可以在 docs\reference目录下找到Spring 的参考手册，有html和pdf两种格式。

如果你的英文不太好，可以看看Spring中文论坛翻译的1.1版本的中文版（pdf格式）。

这个参考手册就是入门的不二法宝。

（5）Spring中的主要的*.jar包文件的作用（注意：不同的版本可能会由差别!）2、将Spring的系统库包文件添加到JBuilder中（1）主要涉及spring.jar、commons-logging.jar和log4j-1.2.9.jar在JBuilder 中创建Spring的J2SE的应用1、新建一个J2SE 的 Project（1）名称为SpringJ2SEApp（2）不需要服务器的设置2、在该Project中添加一个应用的主类名称为SpringApplication，包名称为springj2seapp删除所产生的Java Swing的窗口类只需要主类package springj2seapp;public class SpringApplication{public SpringApplication(){}public static void main(String[] args){new SpringApplication();}}执行该J2SE应用，以观察是否有错误（只要能够正常执行就可以）3、构建Spring基础代码（1）添加一个接口Action该Action 接口定义了一个execute 方法，在我们示例中，不同的Action 实现提供了各自的execute 方法，以完成目标逻辑处理的功能。

SpringBoot整合Hbase的实现⽰例简介当单表数据量过⼤的时候，关系性数据库会出现性能瓶颈，这时候我们就可以⽤NoSql，⽐如Hbase就是⼀个不错的解决⽅案。

接下来是⽤Spring整合Hbase的实际案例，且在最后会给出整合中可能会出现的问题，以及解决⽅案。

这⾥我是⽤本地Windows的IDEA，与局域⽹的伪分布Hbase集群做的连接，其中Hbase集群包括的组件有：Jdk1.8、Hadoop2.7.6、ZooKeeper3.4.10、Hbase2.0.1，因为这⾥只是开发环境，所以做⼀个伪分布的就好，之后部署的时候再按⽣产环境要求来即可整合步骤⽬录结构pom.xml这⾥要导⼊Hbase连接所需要包，需要找和你Hbase版本⼀致的包<dependency><groupId>org.apache.hbase</groupId><artifactId>hbase-client</artifactId><version>2.0.1</version></dependency>hbase-site.xml我是⽤的配置⽂件连接⽅法，这个配置⽂件你在hbase的安装⽬录下的conf⽬录就可以找到，然后你直接把它复制到项⽬的resources⽬录下就好，当然你也可以⽤application.properties配置⽂件外加注⼊和代码的⽅式代替这个配置⽂件HBaseConfig.java这⾥因为只需连接Hbase就没连接Hadoop，如果要连接Hadoop，Windows下还要下载winutils.exe⼯具，后⾯会介绍@Configurationpublic class HBaseConfig {@Beanpublic HBaseService getHbaseService() {//设置临时的hadoop环境变量，之后程序会去这个⽬录下的\bin⽬录下找winutils.exe⼯具，windows连接hadoop时会⽤到//System.setProperty("hadoop.home.dir", "D:\\Program Files\\Hadoop");//执⾏此步时，会去resources⽬录下找相应的配置⽂件，例如hbase-site.xmlorg.apache.hadoop.conf.Configuration conf = HBaseConfiguration.create();return new HBaseService(conf);}}HBaseService.java这是做连接后的⼀些操作可以参考之后⾃⼰写⼀下public class HBaseService {private Logger log = LoggerFactory.getLogger(HBaseService.class);/*** 管理员可以做表以及数据的增删改查功能*/private Admin admin = null;private Connection connection = null;public HBaseService(Configuration conf) {try {connection = ConnectionFactory.createConnection(conf);admin = connection.getAdmin();} catch (IOException e) {log.error("获取HBase连接失败!");}}/*** 创建表 create <table>, {NAME => <column family>, VERSIONS => <VERSIONS>}*/public boolean creatTable(String tableName, List<String> columnFamily) {try {//列族column familyList<ColumnFamilyDescriptor> cfDesc = new ArrayList<>(columnFamily.size());columnFamily.forEach(cf -> {cfDesc.add(ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf)).build());});//表 tableTableDescriptor tableDesc = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName)).setColumnFamilies(cfDesc).build();if (admin.tableExists(TableName.valueOf(tableName))) {log.debug("table Exists!");admin.createTable(tableDesc);log.debug("create table Success!");}} catch (IOException e) {log.error(MessageFormat.format("创建表{0}失败", tableName), e);return false;} finally {close(admin, null, null);}return true;}/*** 查询所有表的表名*/public List<String> getAllTableNames() {List<String> result = new ArrayList<>();try {TableName[] tableNames = admin.listTableNames();for (TableName tableName : tableNames) {result.add(tableName.getNameAsString());}} catch (IOException e) {log.error("获取所有表的表名失败", e);} finally {close(admin, null, null);}return result;}/*** 遍历查询指定表中的所有数据*/public Map<String, Map<String, String>> getResultScanner(String tableName) {Scan scan = new Scan();return this.queryData(tableName, scan);}/*** 通过表名及过滤条件查询数据*/private Map<String, Map<String, String>> queryData(String tableName, Scan scan) {// <rowKey,对应的⾏数据>Map<String, Map<String, String>> result = new HashMap<>();ResultScanner rs = null;//获取表Table table = null;try {table = getTable(tableName);rs = table.getScanner(scan);for (Result r : rs) {// 每⼀⾏数据Map<String, String> columnMap = new HashMap<>();String rowKey = null;// ⾏键，列族和列限定符⼀起确定⼀个单元（Cell）for (Cell cell : r.listCells()) {if (rowKey == null) {rowKey = Bytes.toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());}columnMap.put(//列限定符Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength()),//列族Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));}if (rowKey != null) {result.put(rowKey, columnMap);}}} catch (IOException e) {log.error(MessageFormat.format("遍历查询指定表中的所有数据失败,tableName:{0}", tableName), e);} finally {close(null, rs, table);}return result;}/*** 为表添加或者更新数据*/public void putData(String tableName, String rowKey, String familyName, String[] columns, String[] values) {Table table = null;try {table = getTable(tableName);putData(table, rowKey, tableName, familyName, columns, values);} catch (Exception e) {log.error(MessageFormat.format("为表添加 or 更新数据失败,tableName:{0},rowKey:{1},familyName:{2}", tableName, rowKey, familyName), e); } finally {close(null, null, table);}}private void putData(Table table, String rowKey, String tableName, String familyName, String[] columns, String[] values) {try {//设置rowkeyPut put = new Put(Bytes.toBytes(rowKey));if (columns != null && values != null && columns.length == values.length) {for (int i = 0; i < columns.length; i++) {if (columns[i] != null && values[i] != null) {put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes(columns[i]), Bytes.toBytes(values[i]));} else {throw new NullPointerException(MessageFormat.format("列名和列数据都不能为空,column:{0},value:{1}", columns[i], values[i]));}}}table.put(put);log.debug("putData add or update data Success,rowKey:" + rowKey);table.close();} catch (Exception e) {log.error(MessageFormat.format("为表添加 or 更新数据失败,tableName:{0},rowKey:{1},familyName:{2}",tableName, rowKey, familyName), e);}}/*** 根据表名获取table*/private Table getTable(String tableName) throws IOException {return connection.getTable(TableName.valueOf(tableName));}/*** 关闭流*/private void close(Admin admin, ResultScanner rs, Table table) {if (admin != null) {admin.close();} catch (IOException e) {log.error("关闭Admin失败", e);}if (rs != null) {rs.close();}if (table != null) {rs.close();}if (table != null) {try {table.close();} catch (IOException e) {log.error("关闭Table失败", e);}}}}}HBaseApplicationTests.java@RunWith(SpringJUnit4ClassRunner.class)@SpringBootTestclass HBaseApplicationTests {@Resourceprivate HBaseService hbaseService;//测试创建表@Testpublic void testCreateTable() {hbaseService.creatTable("test_base", Arrays.asList("a", "back"));}//测试加⼊数据@Testpublic void testPutData() {hbaseService.putData("test_base", "000001", "a", new String[]{"project_id", "varName", "coefs", "pvalues", "tvalues","create_time"}, new String[]{"40866", "mob_3", "0.9416","0.0000", "12.2293", "null"});hbaseService.putData("test_base", "000002", "a", new String[]{"project_id", "varName", "coefs", "pvalues", "tvalues","create_time"}, new String[]{"40866", "idno_prov", "0.9317","0.0000", "9.8679", "null"});hbaseService.putData("test_base", "000003", "a", new String[]{"project_id", "varName", "coefs", "pvalues", "tvalues","create_time"}, new String[]{"40866", "education", "0.8984","0.0000", "25.5649", "null"});}//测试遍历全表@Testpublic void testGetResultScanner() {Map<String, Map<String, String>> result2 = hbaseService.getResultScanner("test_base");System.out.println("-----遍历查询全表内容-----");result2.forEach((k, value) -> {System.out.println(k + "--->" + value);});}}运⾏结果Hbase数据库查询结果IDEA的遍历结果报错与解决⽅案报错⼀解决⽅案：这是参数配置的有问题，如果你是⽤hbase-site.xml配置⽂件配置的参数，那么检查它，⽤代码配置就检查代码参数解决⽅案：更改windows本地hosts⽂件，C:\Windows\System32\drivers\etc\hosts,添加Hbase服务所在主机地址与主机名称，这⾥你如果保存不了hosts⽂件，把它拉出到桌⾯改好再拉回即可报错三解决⽅案：这是因为在Windows下连接Hadoop需要⼀个叫Winutils.exe的⼯具，并且从源代码可知，它会去读你Windows下的环境变量，如果你不想在本地设置，可以⽤⽅法System.setProperty()设置实时环境变量，另外，如果你只⽤Hbase，其实这个报错并不影响你使⽤Hbase服务代码地址到此这篇关于SpringBoot整合Hbase的实现⽰例的⽂章就介绍到这了,更多相关SpringBoot整合Hbase内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

Flex4.6 + Spring2.5.6 + Hibernate3.2本实例是另用fsh框架来开发一个简单的点菜小实例，功能是输入几荤几素系统能够自动的随机的输出菜名1,先新建一个Web Project项目2，集成Spring在下面这五个选项前打上勾Spring 2.5 AOP LibrariesSpring 2.5 Core LibrariesSpring 2.5 Persistence Core Libraries Spring 2.5 Persistence JDBC LibrariesSpring 2.5 Web Libraries3，集成Hibernate4，集成Flex部分需要blazeds.war 此文件到adobe公司网站下载，具体下载url：blazeds-bin-4.0.0.14931.zip: /file/dpk18yqj blazeds-turnkey-4.0.0.14931.zip: /file/anckxhwy解压获得blazeds.war文件并继续解压它复制其中的flex和lib文件夹到项目的WEB-INF目录下，flex文件夹中只保留services-config.xml文件修改services-config.xml文件最终services-config.xml文件修改成<?xml version="1.0"encoding="UTF-8"?><services-config><services><default-channels><channel ref="my-amf"></channel></default-channels></services><channels><channel-definition id="my-amf"class="mx.messaging.channels.AMFChannel"><endpointurl="http://{}:{server.port}/{context.root}/mess agebroker/amf"class="flex.messaging.endpoints.AMFEndpoint"/> </channel-definition></channels></services-config>最终的web.xml文件为<?xml version="1.0"encoding="UTF-8"?><web-app version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><display-name></display-name><servlet><servlet-name>Spring MVC Dispatcher Servlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherSe rvlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value></param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>Spring MVC Dispatcher Servlet</servlet-name><url-pattern>/messagebroker/*</url-pattern></servlet-mapping><!-- 著名 Character Encoding filter --><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncod ingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><!-- spring IOC --><context-param><param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param><!-- blaseds监听器：用于获取服务器内置对象(request,application等) --><listener><listener-class>flex.messaging.HttpFlexSession</listener-cl ass></listener><!--Spring ApplicationContext 载入，必须 --><listener><listener-class>org.springframework.web.context.ContextLoad erListener</listener-class></listener><!-- Spring 刷新Introspector防止内存泄露 --><listener><listener-class>org.springframework.web.util.IntrospectorCl eanupListener</listener-class></listener><filter><filter-name>hibernateFilter</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInVie wFilter</filter-class><init-param><param-name>singleSession</param-name><param-value>true</param-value><!-- <param-value>true</param-value> <init-param><param-name>flushMode</param-name><param-value>AUTO </param-value> </init-param> --> </init-param></filter><filter-mapping><filter-name>hibernateFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>最终的applicationContext.xml文件为：<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"xmlns:flex="/schema/flex"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd/schema/flex/schema/flex/spring-flex-1.0. xsd"><!-- flex set --><flex:message-broker></flex:message-broker><!-- flex set end --><bean id="dataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="jdbc:mysql://localhost:3306/test"></property><property name="username"value="root"></property><property name="password"value="332501"></property> </bean><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.Annota tionSessionFactoryBean"><property name="dataSource"><ref bean="dataSource"/></property><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop></props></property><property name="annotatedClasses"><list><value>com.bean.Menu</value></list></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransact ionManager"><property name="sessionFactory"ref="sessionFactory"/> </bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.Transact ionInterceptor"><property name="transactionManager"ref="transactionManager"/><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean id="TestDest"class="com.dest.TestDest"><flex:remoting-destination></flex:remoting-destination><property name="testService"ref="TestService"></property></bean><bean id="TestService"class="com.service.TestService"> <property name="testDAO"ref="TestDAO"></property> </bean><bean id="TestDAO"class="com.dao.TestDAO"><property name="sessionFactory"ref="sessionFactory"></property></bean></beans>接下来是java的代码部分先来看来工程的结构：Menu.javapackage com.bean;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import static javax.persistence.GenerationType.IDENTITY; import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name = "menu", catalog = "test")public class Menu implements java.io.Serializable {private static final long serialVersionUID = 1L;// Fieldsprivate Integer key;private String okazu;private Integer syurui;// Constructors/** default constructor */public Menu() {}/** full constructor */public Menu(String okazu, Integer syurui) {this.okazu = okazu;this.syurui = syurui;}// Property accessors@Id@GeneratedV alue(strategy = IDENTITY)@Column(name = "key", unique = true, nullable = false) public Integer getKey() {return this.key;}public void setKey(Integer key) {this.key = key;}@Column(name = "okazu", nullable = false, length = 45) public String getOkazu() {return this.okazu;}public void setOkazu(String okazu) {this.okazu = okazu;}@Column(name = "syurui", nullable = false)public Integer getSyurui() {return this.syurui;}public void setSyurui(Integer syurui) {this.syurui = syurui;}}ComonFun.javapackage mon;import java.sql.Timestamp;import java.text.ParseException;import java.text.SimpleDateFormat;import org.apache.log4j.Logger;public class ComFun {private static Logger logger= Logger.getLogger(ComFun.class);/*** decide the data isn't null or blank** @param obj* @return*/public static boolean isNotBlank(Object obj) {if (obj == null || "".equals(obj.toString())) {return false;} else {return true;}}/*** get object data, if object is null return ""** @param obj* @return*/public static Object nullObj(Object obj) {if (obj == null) {return"";} else {return obj;}}/*** object to String type** @param obj* @return*/public static String obj2String(Object obj) {return nullObj(obj).toString().trim();}/*** object to Integer type** @param obj* @return*/public static Integer obj2Integer(Object obj) { String srt = nullObj(obj).toString().trim();if ("".equals(srt)) {srt = "0";}return Integer.parseInt(srt);}/*** object to Long type** @param obj* @return*/public static Long obj2Long(Object obj) { String srt = nullObj(obj).toString().trim();if ("".equals(srt)) {srt = "0";}return Long.parseLong(srt);}/*** object to Double type** @param obj* @return*/public static Double obj2Double(Object obj) { String srt = nullObj(obj).toString().trim();srt = srt.replaceAll(",", "");if ("".equals(srt)) {srt = "0";}return Double.parseDouble(srt);}* object to Boolean type** @param obj* @return*/public static Boolean obj2Boolean(Object obj) {returnBoolean.parseBoolean(nullObj(obj).toString().trim());}/*** format:<br/>* yyyy-MM-dd HH:mm:ss <br/>* yyyy-MM-dd** @param time* @param sdf* @return*/public static Timestamp obj2Timestamp(Object time, String formatStr) {Timestamp tsp = null;if (isNotBlank(time)) {SimpleDateFormat sdf = new SimpleDateFormat(formatStr);try {tsp = newTimestamp(sdf.parse(nullObj(time).toString()).getTime());} catch (ParseException e) {logger.error(e.getMessage());}}return tsp;}/*** fill the add string for string** @param str* @param len* @param addSide* true : left; false : right;* @param addStr* @returnpublic static String strAddLen(String str, int len, Boolean addSide, String addStr) {if (str.length() >= len) {return str;} else {for (int i = str.length(); i < len; i++) {if (addSide) {str = addStr + str;} else {str += addStr;}}return str;}}}TestDAO.javapackage com.dao;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import org.hibernate.Query;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import Fun;import com.vo.MenuVO;@SuppressWarnings("rawtypes")public class TestDAO extends HibernateDaoSupport {public List<MenuVO> searchNiku(int a) {try {StringBuffer sb = new StringBuffer();sb.append("select okazu from menu ");sb.append("where syurui = 2 ");sb.append("order by rand() limit ").append(a);Query query = getSession().createSQLQuery(sb.toString());List<MenuVO> aList = new ArrayList<MenuVO>();List list = query.list();Iterator it = list.iterator();while (it.hasNext()) {Object obj = (Object) it.next();MenuVO konndate = new MenuVO();konndate.setNiku(ComFun.obj2String(obj));aList.add(konndate);}return aList;} catch (RuntimeException e) {throw e;}}public List<MenuVO> searchYasai(int b) {try {StringBuffer sb = new StringBuffer();sb.append("select okazu from menu ");sb.append("where syurui = 1 ");sb.append("order by rand() limit ").append(b);Query query = getSession().createSQLQuery(sb.toString());List<MenuVO> aList = new ArrayList<MenuVO>();List list = query.list();Iterator it = list.iterator();while (it.hasNext()) {Object obj = (Object) it.next();MenuVO konndate = new MenuVO();konndate.setYasai(ComFun.obj2String(obj));aList.add(konndate);}return aList;} catch (RuntimeException e) {throw e;}}}TestDest.javapackage com.dest;import com.service.TestService;import com.vo.TestRtnVO;public class TestDest {private TestService testService;public TestRtnVO search(int a,int b) {return testService.search(a,b);}public void setTestService(TestService testService) { this.testService = testService;}public TestService getTestService() {return testService;}}TestService.javapackage com.service;import com.dao.TestDAO;import com.vo.TestRtnVO;public class TestService {private TestDAO testDAO;public TestRtnVO search(int a, int b) {TestRtnVO rtn = new TestRtnVO();try {rtn.setaList(testDAO.searchNiku(a));rtn.setbList(testDAO.searchYasai(b));} catch (Exception e) {e.printStackTrace();}return rtn;}public void setTestDAO(TestDAO testDAO) {this.testDAO = testDAO;}public TestDAO getTestDAO() {return testDAO;}}MenuVo.javapackage com.vo;public class MenuVO {public String niku;public String yasai;public String getNiku() {return niku;}public void setNiku(String niku) { this.niku = niku;}public String getYasai() {return yasai;}public void setYasai(String yasai) { this.yasai = yasai;}}TestRtnVo.javapackage com.vo;import java.util.List;public class TestRtnVO {private List<MenuVO> aList;private List<MenuVO> bList;private List<MenuVO> cList;public List<MenuVO> getcList() {return cList;}public void setcList(List<MenuVO> cList) {this.cList = cList;}public List<MenuVO> getaList() {return aList;}public void setaList(List<MenuVO> aList) {this.aList = aList;}public List<MenuVO> getbList() {return bList;}public void setbList(List<MenuVO> bList) {this.bList = bList;}}Flex部分先新建一个flex项目，唯一需要注意的是服务器地址要按照下面的图进行配置项目工程截图Flextest.mxml<?xml version="1.0" encoding="utf-8"?><s:Application xmlns:fx="/mxml/2009"xmlns:s="library:///flex/spark"xmlns:mx="library:///flex/mx"width="100%" height="100%"><fx:Script><![CDATA[import mx.collections.ArrayCollection;import mx.controls.Alert;import mx.rpc.Responder;import mx.rpc.events.FaultEvent;import mx.rpc.events.ResultEvent;import mx.rpc.http.mxml.HTTPService;import mx.rpc.remoting.mxml.RemoteObject;public var arr:Array;[Bindable] public var gridClt:ArrayCollection;private function send():void {var remote:RemoteObject = new RemoteObject();remote.destination = "TestDest";remote.endpoint = "/orderSys/messagebroker/amf";remote.showBusyCursor = true;remote.addEventListener(ResultEvent.RESULT, function(rstEvt:ResultEvent):void {var obj:Object = new Object();arr=new Array();var i:int=0;gridClt = new ArrayCollection();if(rstEvt.result.aList.length >=rstEvt.result.bList.length){for each(obj in rstEvt.result.bList){arr[i] = obj;i++;}i=0;for each (obj in rstEvt.result.aList){if(i<rstEvt.result.bList.length){obj.yasai = arr[i].yasai;i++;}gridClt.addItem(obj);}}else{i=0;for each(obj in rstEvt.result.aList){arr[i] = obj;i++;}i=0;for each(obj in rstEvt.result.bList){if(i<rstEvt.result.aList.length){obj.niku = arr[i].niku;i++;}gridClt.addItem(obj);}}});remote.search(int(niku.text),int(yasai.text));/* remote.addEventListener(FaultEvent.FAULT, function(fltEvt:FaultEvent):void {Alert.show("Error: " +fltEvt.message.toString());}); */}]]></fx:Script><s:VGroup x="414" y="130" width="203"><mx:FormItem label="niku："><s:TextInputid="niku"></s:TextInput></mx:FormItem><mx:FormItem label="yasai："><s:TextInputid="yasai"></s:TextInput></mx:FormItem></s:VGroup><s:Button id="testBtn" x="515" y="198" label="点菜"click="send()"/><s:DataGrid x="414" y="241" width="203"dataProvider="{gridClt}" requestedRowCount="12"><s:columns><s:ArrayList><s:GridColumn dataField="niku" headerText="荤菜"></s:GridColumn><s:GridColumn dataField="yasai" headerText="素菜"></s:GridColumn></s:ArrayList></s:columns></s:DataGrid></s:Application>Menu.aspackage{[RemoteClass(alias="test.Menu")]public class Menu {public var niku:String;public var yasai:String;public function Menu() {}}}最后附上mysql使用表的截图。

基于JSF技术的招生与就业网站建设研究摘要：针对提高Web应用程序开发效率的问题，基于JSF框架的Web 开发模式应用于招生就业信息网站后台管理子系统的开发中。

通过基于友好的服务器端UI框架，以Hibernate来完成对象和关系数据之间的映射，并由Spring框架将各种技术集成进来，将JSF架构应用于对网站后台管理子系统中的招生信息查询系统进行开发，运行结果表明，此改进方法是高效的。

关键词：JSF；Web应用；查询系统0引言Java Server Faces是Sun公司的一项基于MVC的网络开发新技术，是一种基于事件驱动的开发框架，简称JSF。

它的开发可以简单到只需将用户界面（UI）组件拖放到页面上。

丰富而强健的JSF API 提供了无与伦比的功能和编程的灵活性。

它还通过将良好构建的模型-视图-控制器（MVC）设计模式集成到它的体系结构中，确保了应用程序具有更高的可维护性。

同时，由于JSF 是通过Java Community Process （JCP）开发的一种Java 标准，因此，开发工具供应商完全能够为Java Server Faces 提供易于使用的、高效的可视化开发环境。

目前，80%以上的高校都设有招生就业信息网站，因招生、就业信息主要面向考生家长及用人单位这些信息浏览群，网站对外可以服务考生和社会，加强宣传力度，展示良好形象；对内可以体现系统办学，实现资源共享，提高工作效率，所以高校招生就业信息网的建设对于高校的发展具有重大的意义。

以前招生就业信息都是和学生工作管理信息或者教务管理信息混合在一起，这样使得大量的招生就业信息无法及时更新，导致信息交流相对滞后，越来越多的高校已充分意识到此块信息独立的重要性，高校管理高层对招生就业信息网站的建设和发展日益重视。

面对着日新月异信息发布和更新的实际需要，本文基于JSF技术在原有系统上进行进一步的研发，以求适应高校招生就业工作的需要。

本文在逻辑计算、页面层次、访问速度、功能模块等方面对系统做了进一步改善，运用UML等方法来设计网站，并增加了一些功能模块，使得网站层次更加清晰，维护起来更加方便。

基于JSF和Tiles的MVC模式的实现
罗红梅;陆鑫
【期刊名称】《计算机与现代化》
【年(卷),期】2006(000)002
【摘要】JSF是Web应用开发的新框架.本文结合一个实例,研究了JSF结合Tiles 实现页面框架继承和MVC模式的过程.结果表明在开发大型 Web 应用系统时,Tiles能增强基于组件的 Web UI 开发,Tiles与JSF协同工作能够大大提高开发效率,同时提高系统的可维护性和可扩充性.
【总页数】4页(P38-41)
【作者】罗红梅;陆鑫
【作者单位】电子科技大学计算机科学与工程学院,四川,成都,610054;电子科技大学计算机科学与工程学院,四川,成都,610054
【正文语种】中文
【中图分类】TP311
【相关文献】
1.基于JSFL自动批改Flash操作题的研究及实现 [J], 隋秀龙
2.基于JSF的电子邮件系统的设计与实现 [J], 邓林生
3.基于MVC模式的JSF架构的应用研究 [J], 张猛;孙忠林
4.基于MVC模式的JSF,Spring和Hibernate整合 [J], 李腊元;徐鹏
5.基于JSF实现MVC模式的Web应用 [J], 宋丽
因版权原因，仅展示原文概要，查看原文内容请购买。

系统可作为OA、网站、电子政务、ERP、CRM、APP后台等基于B/S架构的应用软件系统的快速开发框架。

一、特色功能1、采用Spring MVC的静态加载缓存功能，在首页将Javascript文件、CSS文件和图片等静态资源文件加载进来放进内存，极大提高ExtJS的加载速度。

2、三种皮肤主题：经典、灰色和海王星，支持多浏览器和多分辨率。

3、分别封装了模型层、控制层、业务逻辑层和数据持久层的通用操作模块，层次分明，大大减少代码冗余，二次开发效率高。

4、系统是公司多个项目的基础框架，稳定性好，支持大并发。

二、主要功能1、采用ExtJS 4.2.1.883无限制版本，放心用于网站开发。

2、ExtJS富文本编辑器增加修改信息。

3、ExtJS的HtmlEditor的图片文件上传插件。

4、Grid列表和表单，包含添加、删除、批量删除、修改、查看、图片查看和按条件查询列表等功能。

5、导入导出Excel数据，支持xlsx和xls文件。

6、资源管理（菜单管理）。

7、用户管理和部门管理。

8、权限管理。

不仅可管理各个功能模块的权限，也可以管理功能模块里的页面按钮权限。

9、报表统计。

也可以嵌入其他报表工具插件。

10、采用开源的互动地图Javascript库Leaflet，处理自定义在线地图。

Panel里包含2个组件，在2个组件间传递参数显示数据。

三、开发工具和采用技术1、开发工具：Eclipse、MyEclipse和其他IDE。

2、采用Spring 3中最新最稳定的Spring MVC 3.2.8版本。

3、采用Hibernate 4.1.7。

Spring MVC 3.2.8支持的最高Hibernate版本是4.1.7，更高的Hibernate版本和Spring MVC 3.2.8组合会遇到兼容问题。

4、Hibernate集成二级缓存框架Ehcache。

5、数据库是MySQL、Oracle和SQL Server，Hibernate的Dialect可使程序移植到其他数据库。