Spring MVC+BlazeDS+Flex框架实践：Database篇

来源：互联网发布：制作网站的软件编辑：程序博客网时间：2024/06/05 08:38

在http://blog.csdn.net/meteorlWJ/archive/2009/09/12/4545858.aspx中实践了此框架的基础搭建，本次的实践将在此基础上引入hibernate配置，并创建FLEX应用实现数据库操作。

一、环境配置
MyEclipse 7.0

Flex Builder 3.0

Tomcat 6.0

JDK1.6

Flex sdk 3.2

Oracle 10g :XE

二、Hibernate+Proxool配置
Hibernate管理JAVA类到数据库表的映射，并提供数据查询和获取的方法。Hibernate对JDBC进行了轻量级的对象封装，完成了数据持久化的重任。
这是一个Java SQL Driver驱动程序，提供了对你选择的其它类型的驱动程序的连接池封装。Proxool提供一个健壮、易用的连接池，最为关键的是这个连接池提供监控的功能，方便易用，便于发现连接泄漏的情况。

1）连接池配置：proxool.xml
在JAVA工程src下创建proxool.xml，添加如下配置：

其中参数详解如下：
   alias ：数据源别名
     driver-url ：连接字符串
     driver-class ：驱动类
     statistics ：连接池使用状态统计
     driver-properties ：数据库连接用户名/密码
     house-keeping-sleep-time ：house keeper保留线程处于睡眠状态的最长时间，
     house-keeper的职责就是检查各个连接的状态，并判断是否需要销毁或创建
     maximum-new-connections ：没有空闲连接时可以分配在队列中等待的最大请求数
     maximum-connection-count ：最大连接数
     minimum-connection-count ：最小连接数
     trace ：每个被执行的SQL语句是执行期是否用被LOG记录
     verbose ：详细信息设置

<br><br><?xml version="1.0" encoding="UTF-8"?><something-else-entirely><proxool><alias>test</alias><driver-url>jdbc:oracle:thin:@localhost:1521:xe</driver-url><driver-class>oracle.jdbc.driver.OracleDriver</driver-class><statistics>1m,15m,1d</statistics><driver-properties><property name="user" value="hosf" /> <property name="password" value="hosf" /> </driver-properties><house-keeping-sleep-time>90000</house-keeping-sleep-time><maximum-new-connections>20</maximum-new-connections><prototype-count>5</prototype-count> <maximum-active-time>3600000</maximum-active-time><maximum-connection-count>100</maximum-connection-count><minimum-connection-count>10</minimum-connection-count><trace>true</trace><verbose>true</verbose><house-keeping-test-sql>select sysdate from dual</house-keeping-test-sql></proxool></something-else-entirely>

2）hibernate配置
在JAVA工程src目录下创建Application-hibernate.xml，添下如下配置
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:security="http://www.springframework.org/schema/security"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsdhttp://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><property name="packagesToScan" value="com.hand.**.domain" /><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop><prop key="hibernate.show_sql">false</prop><prop key="hibernate.connection.autocommit">true</prop><prop key="hibernate.cglib.use_reflection_optimizer">true</prop><prop key="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</prop><prop key="hibernate.proxool.pool_alias">test</prop><prop key="hibernate.proxool.xml">proxool.xml</prop><prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop><prop key="hibernate.cache.use_query_cache">true</prop><prop key="hibernate.cache.use_structured_entries">true</prop></props></property></bean><tx:annotation-driven transaction-manager="transactionManager" /><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean>

3）配置web.xml

在上一篇中提到web.xml中配置了初始化时加载的文件，在添加了hibernate配置后，同样需要将其添加到web.xml的初始化文件列表中，

修改web.xml中的相关配置：
<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:ApplicationContext.xml,classpath:Application-Flex.xml,classpath:Application-hibernate.xml</param-value></context-param>

三、数据库对象映射配置
项目中使用Hibernate管理JAVA类到数据库表的映射，它可以实现ORM(Object Relational Mapping)，将关系数据库中表的数据映射成对象。

1）创建数据库对象
通过以下脚本创建数据库对象
-- Create tablecreate table FWK.FWK_USERS( USER_ID NUMBER not null, USER_NAME VARCHAR2(100) not null, USER_PASSWORD VARCHAR2(240), USER_DESCRIPTION VARCHAR2(240), EMAIL_ADDRESS VARCHAR2(240), START_DATE_ACTIVE DATE, END_DATE_ACTIVE DATE, OBJECT_VERSION_NUMBER NUMBER, CREATED_BY NUMBER not null, CREATION_DATE DATE not null, LAST_UPDATED_BY NUMBER not null, LAST_UPDATE_DATE DATE not null);create unique index FWK_USERS_PK on fwk_users(USER_ID);create sequence fwk_users_s start with 1000;

2）创建Who字段映射类
如果你接触过ORACLE数据库，相信对WHO字段应该很熟悉了吧，这里就不多做解释了。本例中将WHO字段的映射独立出来，这样对所有的数据库映射类都能同样使用，而不用重复相同的代码。
在src下创建package com.common.domain，创建BaseWhoEntity.java
package com.common.domain;import java.io.Serializable;import java.util.Date;import javax.persistence.Column;import javax.persistence.MappedSuperclass;@MappedSuperclasspublic class BaseWhoEntity implements Serializable{// DataType:NUMBER@Column(name = "OBJECT_VERSION_NUMBER", nullable = true)private Long objectVersionNumber;// DataType:NUMBER@Column(name = "CREATED_BY", nullable = false)private Long createdBy;// DataType:DATE@Column(name = "CREATION_DATE", nullable = false)private Date creationDate;// DataType:NUMBER@Column(name = "LAST_UPDATED_BY", nullable = false)private Long lastUpdatedBy;// DataType:DATE@Column(name = "LAST_UPDATE_DATE", nullable = false)private Date lastUpdateDate;public Long getObjectVersionNumber() {return objectVersionNumber;}public void setObjectVersionNumber(Long objectVersionNumber) {this.objectVersionNumber = objectVersionNumber;}public Long getCreatedBy() {return createdBy;}public void setCreatedBy(Long createdBy) {this.createdBy = createdBy;}public Date getCreationDate() {return creationDate;}public void setCreationDate(Date creationDate) {this.creationDate = creationDate;}public Long getLastUpdatedBy() {return lastUpdatedBy;}public void setLastUpdatedBy(Long lastUpdatedBy) {this.lastUpdatedBy = lastUpdatedBy;}public Date getLastUpdateDate() {return lastUpdateDate;}public void setLastUpdateDate(Date lastUpdateDate) {this.lastUpdateDate = lastUpdateDate;}}

3）创建数据库实体类
在创建完数据库表FwkUsers后，我们需要创建与之对应的JAVA实体类，通过Hibernate的annotation实现对象映射
在JAVA工程src下创建package com.admin.domain，创建FrameworkUser.java
package com.admin.domain;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.SequenceGenerator;import javax.persistence.Table;import com.common.domain.BaseWhoEntity;@Entity@Table(name = "FWK_USERS")public class FrameworkUser extends BaseWhoEntity{// DataType:NUMBER@Id@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "FWK_USERS_S")@SequenceGenerator(name = "FWK_USERS_S", sequenceName = "FWK_USERS_S")@Column(name = "USER_ID", nullable = false)private Long userId;// DataType:VARCHAR2@Column(name = "USER_NAME", nullable = false, length = 100)private String userName;// DataType:VARCHAR2@Column(name = "USER_PASSWORD", nullable = true, length = 240)private String userPassword;// DataType:VARCHAR2@Column(name = "USER_DESCRIPTION", nullable = true, length = 240)private String userDescription;// DataType:VARCHAR2@Column(name = "EMAIL_ADDRESS", nullable = true, length = 240)private String emailAddress;// DataType:DATE@Column(name = "START_DATE_ACTIVE", nullable = true)private Date startDateActive;// DataType:DATE@Column(name = "END_DATE_ACTIVE", nullable = true)private Date endDateActive;public Long getUserId() {return userId;}public void setUserId(Long userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getUserPassword() {return userPassword;}public void setUserPassword(String userPassword) {this.userPassword = userPassword;}public String getUserDescription() {return userDescription;}public void setUserDescription(String userDescription) {this.userDescription = userDescription;}public String getEmailAddress() {return emailAddress;}public void setEmailAddress(String emailAddress) {this.emailAddress = emailAddress;}public Date getStartDateActive() {return startDateActive;}public void setStartDateActive(Date startDateActive) {this.startDateActive = startDateActive;}public Date getEndDateActive() {return endDateActive;}public void setEndDateActive(Date endDateActive) {this.endDateActive = endDateActive;}}

4）创建对象扫描类
项目中使用Hibernate映射数据库对象，在做CUDI(Create、Update、Delete、Insert)时希望能够通过对象名自动找到对应的DAO进行事务处理。
在JAVA工程src目录下创建package com.common.util，创建ExtSpringPackageScan.java
package com.common.util;import java.util.ArrayList;import java.util.List;import org.springframework.core.io.Resource;import org.springframework.core.io.support.PathMatchingResourcePatternResolver;import org.springframework.core.io.support.ResourcePatternResolver;import org.springframework.core.type.classreading.CachingMetadataReaderFactory;import org.springframework.core.type.classreading.MetadataReader;import org.springframework.core.type.classreading.MetadataReaderFactory;import org.springframework.util.ClassUtils;public class ExtSpringPackageScan {static ResourcePatternResolver resourcePatternResolver=new PathMatchingResourcePatternResolver();public static List<String> getClasses(final String[] packagesToScan){List<String> classNames=new ArrayList<String>();if(packagesToScan != null) try { int len = packagesToScan.length; for(int i = 0; i < len; i++) { String pkg =packagesToScan[i]; String pattern = (new StringBuilder()).append("classpath*:").append(ClassUtils.convertClassNameToResourcePath(pkg)).append("**/*.class").toString(); Resource resources[] = resourcePatternResolver.getResources(pattern); MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver); Resource arr$[] = resources; int len$ = arr$.length; for(int i$ = 0; i$ < len$; i$++) { Resource resource = arr$[i$]; if(!resource.isReadable()) continue; MetadataReader reader = readerFactory.getMetadataReader(resource); String className = reader.getClassMetadata().getClassName(); classNames.add(className); } } } catch(Exception ex) { ex.printStackTrace(); } return classNames;}}

四、DAO设计
DAO层的设计采用的是泛型设计。泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

1）DAO接口设计
在JAVA 工程src下创建package com.common.hibernate，创建GenericDao.java
package com.common.hibernate;import java.io.Serializable;import java.lang.reflect.InvocationTargetException;import java.util.List;import java.util.Map;import org.springframework.orm.hibernate3.HibernateCallback;public interface GenericDao<T, PK extends Serializable> {public PK save(T value) throws Exception;public T get(PK id, Class<T> klass);public T beforeSave(T value) throws Exception;}

2）DAO接口实现
在JAVA工程com.common.hibernate下创建GenericDaoImpl.java
package com.common.hibernate;import java.io.Serializable;import java.math.BigDecimal;import java.sql.SQLException;import java.util.Date;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Set;import org.apache.commons.beanutils.BeanUtils;import org.apache.log4j.Logger;import org.hibernate.Criteria;import org.hibernate.HibernateException;import org.hibernate.Query;import org.hibernate.SQLQuery;import org.hibernate.Session;import org.hibernate.criterion.Example;import org.hibernate.criterion.Projections;import org.perf4j.aop.Profiled;import org.springframework.orm.hibernate3.HibernateCallback;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import com.common.domain.BaseWhoEntity;public class GenericDaoImpl<T, PK extends Serializable> extends HibernateDaoSupport implements GenericDao<T, PK> {public T beforeSave(T value) throws Exception {if (value instanceof BaseWhoEntity) {BaseWhoEntity temp = (BaseWhoEntity) value;Map map = new HashMap();map.put("createdBy", new Long(7));map.put("creationDate", new Date());map.put("lastUpdatedBy", new Long(7));map.put("lastUpdateDate", new Date());map.put("objectVersionNumber", new Long(1));try {BeanUtils.populate(value, map);} catch (Exception e) {logger.error("将Map转化为对像时出错", e);throw e;}}return value;}@Profiled(tag = "GenericDaoImpl.save")public PK save(T value) throws Exception {try {System.out.println("执行保存!");return (PK) this.getHibernateTemplate().save(beforeSave(value));} catch (Exception e) {throw e;}}@Profiled(tag = "GenericDaoImpl.get")@SuppressWarnings("unchecked")public T get(PK id, Class<T> klass) {return (T) getHibernateTemplate().get(klass, id);}}

五、Service设计
通过设计Service层，实现与FLEX之间的数据传递。

1）在JAVA 工程src下创建package com.common.service，创建GenericService.java
package com.common.hibernate;import java.io.Serializable;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.hibernate.SessionFactory;import org.springframework.beans.factory.InitializingBean;import org.springframework.orm.hibernate3.HibernateCallback;import com.common.util.ExtSpringPackageScan;public class GenericService implements InitializingBean {private static final Log logger = LogFactory.getLog(GenericService.class);private SessionFactory sessionFactory;private String[] packagesToScan;@SuppressWarnings("unchecked")private Map<String, GenericDao> daoMap = new HashMap<String, GenericDao>();private List<String> classList = new ArrayList<String>();public Map<String, GenericDao> getDaoMap() {return daoMap;}public void setDaoMap(Map<String, GenericDao> daoMap) {this.daoMap = daoMap;}public String[] getPackagesToScan() {return packagesToScan;}public void setPackagesToScan(String[] packagesToScan) {this.packagesToScan = packagesToScan;}@SuppressWarnings("unchecked")public void afterPropertiesSet() throws Exception {classList.addAll(ExtSpringPackageScan.getClasses(packagesToScan));StringBuffer sb = new StringBuffer();for (String className : classList)sb.append(className + ",");logger.info("初始化完成Pojo与表的映射:" + sb.toString());logger.info("初始化完成DaoMap:" + daoMap);}public SessionFactory getSessionFactory() {return sessionFactory;}public void setSessionFactory(SessionFactory sessionFactory) {this.sessionFactory = sessionFactory;}@SuppressWarnings("unchecked")public <T, PK> PK save(T value) throws Exception {try {GenericDao gd = getDao(value.getClass().getName());if (gd != null) {return (PK) gd.save(value);} else {logger.error("保存错误，无法找到相应的DAO来处理，请确认配置信息是否正确！");return null;}} catch (Exception e) {throw e;}}public String getClass(String className) {for (String classInList : classList) {if (classInList.endsWith(className) || classInList.equals(className))return classInList;}return null;}@SuppressWarnings("unchecked")public GenericDao getDao(String fullClassName) {GenericDao gd = null;if (daoMap.get(fullClassName) == null) {logger.debug("使用缺省的Dao");gd = daoMap.get("default");} else {gd = daoMap.get(fullClassName);logger.debug("使用Dao:" + gd.getClass().getName());}return gd;}@SuppressWarnings("unchecked")public <T, PK extends Serializable> T get(PK id, String className) {try {String fullClassName = getClass(className);Class<T> klass = (Class<T>) Class.forName(fullClassName);GenericDao gd = getDao(fullClassName);return (T) gd.get(id, klass);} catch (ClassNotFoundException e) {e.printStackTrace();} catch (NullPointerException ne) {logger.error("传入类型：" + className + "不存在！");ne.printStackTrace();}return null;}}

2）创建具体应用类BaseService.java
在JAVA工程com.common.service下创建BaseService.java
package com.common.service;import java.util.Date;import java.util.Map;import org.apache.commons.beanutils.BeanUtils;import org.apache.commons.beanutils.ConvertUtils;import org.apache.commons.beanutils.PropertyUtilsBean;import org.apache.commons.beanutils.converters.DateConverter;import org.springframework.transaction.annotation.Propagation;import org.springframework.transaction.annotation.Transactional;import com.common.hibernate.GenericService;public class BaseService {GenericService genericService;private PropertyUtilsBean pb = new PropertyUtilsBean();static {ConvertUtils.deregister(Date.class);DateConverter dateConverter = new DateConverter(null);ConvertUtils.register(dateConverter, Date.class);}public GenericService getGenericService() {return genericService;}public void setGenericService(GenericService genericService) {this.genericService = genericService;}@Transactional(propagation = Propagation.SUPPORTS)@SuppressWarnings("unchecked")public Map save(Map map) throws Exception {try {if (map.get("className") != null) {Object value = this.popMapToObject(map);genericService.save(value);return pb.describe(value);}} catch (Exception e) {e.printStackTrace();throw e;}return null;}public Object popMapToObject(Map proerties) throws Exception {System.out.println("组装POJO参数：" + proerties);if (proerties.get("className") != null) {String className = (String) proerties.get("className");Object value = Class.forName(genericService.getClass(className)).newInstance();BeanUtils.populate(value, proerties);System.out.println("组装后的class：" + BeanUtils.describe(value));return value;}return null;}}

3）完成DAO与Service层的设计后，需要修改hibernate配置
修改Application-hibernate.xml，添加如下配置：
<bean id="genericService" class="com.hand.common.hibernate.GenericService"><property name="sessionFactory"><ref bean="sessionFactory" /></property><property name="packagesToScan"><list><value>com.hand.**.domain</value></list></property><property name="daoMap"><map><entry key="default"><ref bean="defaultDAO" /></entry></map></property></bean> <bean id="defaultDAO" class="com.hand.common.hibernate.GenericDaoImpl"><property name="sessionFactory"><ref bean="sessionFactory" /></property></bean>

六、远程服务应用
1）发布BaseService
修改Application-Flex.xml，添加如下配置：
<bean id="BaseService" class="com.hand.common.service.BaseService"><property name="genericService" ref="genericService"/><flex:remoting-destination /></bean>

2）FLEX引用BaseService
修改FLEX工程remoting-config.xml，添加如下配置：
<destination id="BaseService"><properties><source>BaseService</source></properties></destination>

3）创建UserModule.mxml
在FLEX工程src/modules下创admin目录，创建UserModule.mxml，通过RemoteObject调用远程服务
<?xml version="1.0" encoding="utf-8"?><mx:Module xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" width="400" height="300"> <mx:Script> </mx:Script><mx:RemoteObject id="BaseService" destination="BaseService"/><mx:VBox width="50%" left="43" top="90"><mx:FormItem label="User Name:" width="100%" labelWidth="100"><mx:TextInput width="200" id="username"/></mx:FormItem><mx:FormItem label="Password:" width="100%" labelWidth="100"> <mx:TextInput width="200" id="password" displayAsPassword="true"/></mx:FormItem><mx:FormItem label="Email:" width="100%" labelWidth="100"> <mx:TextInput width="200" id="email"/></mx:FormItem><mx:HBox width="100%"> <mx:Spacer width="100%"/> <mx:Button label="保存" width="80" click="saveRecord()" x="761" y="277" cornerRadius="9"/></mx:HBox></mx:VBox></mx:Module>

4）修改Index.mxml，添加如下内容：
<mx:ModuleLoader url="../admin/UserModule.swf" width="50%" height="50%"/>

七、编译运行
1）编译FLEX工程
选择Project—>Clean—>TestProject
2）拷贝编译目录bin-debug/modules到JAVA工程WebRoot下
3）启动本地数据库
4）启动Tomcat服务器
5）服务器正常启动后，在浏览器中输入地址(其中9090为服务器端口)
http://localhost:9090/TestProject/modules/common/Index.html

运行结果如下：
首页：

保存数据，检查JAVA与FLEX通信是否正常：

访问数据库，检查数据是否保存成功：