且行且珍惜

java road

常用链接

统计

最新评论

2009年1月15日 #

java equals == 区别

服务类中有个一判断条件propertys.get(WIN_INDEXMONTH).toString() != "",在tomcat上能正常处理。
但是到weblogic上就出现问题了。
而后改成
if(!"".equals(propertys.get(WIN_INDEXMONTH).toString())){
。。
}
就都正确了。

equals 是用于比较两个对象的内容是否相等。
== 用于比较基本数据类型 和 引用类型时的区别为
比较两个基本数据类型,若两个值相同则返回true
比较引用时,如果引用指向内存中的同一个对象,则返回true

String str = new String("aaa");

str.equals("aaa");---true
str == "aaa";---false

posted @ 2009-01-15 17:32 jws-21 阅读(154) | 评论 (0)编辑 收藏

2008年10月20日 #

struts webwork 比较

Struts、Webwork比较
比较内容 Struts WebWork2
Action   类 在Struts里面,每一个
Action   Class都需要扩展org.apache.struts.action.Action;这个在Java编程中会引来一些问题,就是关于多种继承的问题 Webwork仅仅需要implement   com.opensymphony.xwork.Action   Interface,您也可以implement其它的interface来实现更多的功能,譬如:validate(验证),localware(国际化)等,当然   webwork2也提供了一个类ActionSupport   集成了以上功能。Developer可以根据需要实现不同的功能。
线程模型 Struts   Actions必须是thread-safe方式,它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必须统一同步,这个就引起了线程安全的问题。 Webwork   2   actions每一个请求对应一个action,因此没有线程的安全问题。实际上Servlet   容器对应每一个请求会产生许多Object,这种一个请求产生许多object的例子没有证明对性能产生太多的影响。现在Web容器都是这么处理Servlet的。
Servlet的依赖 Struts处理一个Action时候必须要依赖ServletRequest   and   ServletResponse。所以这一层摆脱不了Server容器。而serveltRequest可能会被web层的Context使用。 Webwork2   每一个action不依赖任何层和任何容器。他们使用Request和response是通过ActionContext,所以这个对于逻辑层的分离是很重要的。
测试 因为Struts的每一个action都必须用到request和response所以都必须通过web层来进行测试。这就导致了许多测试struts都要通过web容器(尽管现在有许多测试方法cactus   mock   等)。 Webwork的action能够通过赋予一定的属性。就可以执行。同时您可以使用一个mock的实例去测试,而不是通过启动web容器来进行测试。
FormBean Struts   需要一个FormBeans针对每一个Form。而使用DynaBeans实际上没有太大的意义。不能够很好的处理现有的模型。 Webwork   能够动态的收集web的数据然后在赋值给bean。同时它还能够使用FormBean模式。Webwork2还允许现有的ModelDrvien进行导入处理。能够处理它就像处理action自己的属性一样。
前端表达语言 Struts大部分使用的是JSTL   EL(JSP2。0)去获得数据的。在Collection上面处理显得很弱。 Webwork前端可以使用JSTL同时也可以使用多种表现形式。譬如:velocity   freemaker   jspparer   xml等等。Webwork2   利用ongl建立一个valuestack来搜集数据
类型的转换 Struts   FormBeans把所有的数据都作为string类型。得到一个自己需要的类型然后展示给用户是很困难的。 Webwork2   数据都是转换成Java中的类型。这个根据Form的类型自动转换。然后操作这些bean十分方便。
对Action   执行前和后的处理 Struts处理action的时候是基于class的hierarchies,很难在action处理前和后进行操作。 Webwork2   允许您处理action可以通过interceptor,就是在每一个action处理前或者后进行其它操作。
验证处理 因为struts的FormBean的属性都被认为是string类型。许多类型的验证都要进行类型转换的处理。FormBean对一个验证链的处理显然不行。 而webwork2的验证采用的是interceptor设计模式。它的这种验证方式决定了它十分灵活。而且一个验证可以重复不断的使用仅仅需要一个XML文件的定义。实际上webwork2的验证是采用了xwork的验证框架。
Action的链的控制 Struts里面每一个action对应一个处理,如果一个action转向另外一个action就很困难了。 Webwork使用一个强大的DispatcherChain去处理这个action链。很方便的从一个处理到另外一个处理。

posted @ 2008-10-20 14:53 jws-21 阅读(115) | 评论 (0)编辑 收藏

2008年10月9日 #

Spring 中事务管理的配置和注入

在spring基础文件中配置数据源,事务管理和事务管理代理bean的。

 <!-- ======================== Properties  ======================== -->
 <bean id="propertyConfigurer"
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
   <list>
    <value>classpath*:conf/configure.properties</value>
   </list>
  </property>
 </bean>

 <!-- ========================   data configure   ========================== -->
 <!-- Apache Database Connection Pool  -->
 <bean id="dataSource"<!--BasicDataSource类的别名-->
  class="org.apache.commons.dbcp.BasicDataSource""<!--BasicDataSource类的别名所指向的真正类-->
  destroy-method="close">
  <property name="driverClassName">"<!--对应到BasicDataSource类中的属性-->
   <value>${db.driver}</value>"<!--该属性值绑定到BasicDataSource类中的属性此处为property中name多对应的属性-->
  </property>
  <property name="url">
   <value>${db.url}</value>
  </property>
  <property name="username">
   <value>${db.user}</value>
  </property>
  <property name="password">
   <value>${db.password}</value>
  </property>
  <property name="initialSize">
   <value>15</value>
  </property>
  <property name="maxActive">
   <value>30</value>
  </property>
  <property name="maxIdle">
   <value>30</value>
  </property>
  <property name="minIdle">
   <value>5</value>
  </property>
 </bean>

<!-- Transaction manager for a single JDBC DataSource DAO IoC -->
 <bean id="transactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>

<!--
  - A parent bean definition which is a base definition for transaction proxies.
  - It's marked as abstract, since it's not supposed to be instantiated itself.
  - We set shared transaction attributes here, following our naming patterns.
  - The attributes can still be overridden in child bean definitions.  
  -  
 -->
 <bean id="baseTransactionProxy"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
  abstract="true"><!-- 为了避免ApplicationContext对它预先的初始化 -->
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="update*">PROPAGATION_REQUIRED</prop>
    <prop key="delete*">PROPAGATION_REQUIRED</prop>
    <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>

 </bean>
如果有很多的bean的某些定义都是类似的(比如对于transaction的定义),那么可以给他们的定义作一个模板。
使用parent可以实现这一点。(注意parent并非意味着两个bean之间存在着java的继承关系,只是表示他们的定义之间存在着共同的部分)。
child bean使用parent来继承模板的定义,同样还可以覆盖模板的定义。
很多时候模板并不需要被实例化,为了避免ApplicationContext对它预先的初始化,一般设置abstract="true"
为了提高事务代理的复用程度,没有在baseTransactionProxy设置target属性。此时设置abstract="true"
下面以一个用户管理UserInfo 用户管理模块为例,设置模块中各个bean的依赖注入和事务的管理
首先定义service实现类

 <!-- user target bean -->
 <bean id="userTarget"
  class="com.zhjy.gmp.service.impl.UserInfoServiceImpl">
  <property name="userDAO">
   <ref local="userDAO" />
  </property>
  <!-- 部门DAO -->
  <property name="orgDAO">
   <ref local="orgInfoDAO" />
  </property>

  <!-- 角色DAO -->
  <property name="roleDAO">
   <ref local="roleDAO" />
  </property>

 </bean>
这里注入了UserInfoServiceImpl所需要的三个dao实例。
接下来对该service进行事务管理的配置
 <!-- user service bean -->
 <bean id="userService" parent="baseTransactionProxy">
  <property name="target">
   <ref bean="userTarget" />
  </property>
 </bean>
此处通过target属性将userTarget实例注入到事务代理中。
最后定义dao实例
 <!-- user dao bean -->
 <bean id="userDAO" class="com.zhjy.gmp.dao.impl.UserInfoDAOImpl">
  <property name="dataSource">
   <ref bean="dataSource" /><!-- ref bean 与 ref local 的区别,后者表示从本地的(同一个)xml文件中来寻找bean,前者是全局范围内寻找bean。 -->
  </property>
 </bean>





posted @ 2008-10-09 11:30 jws-21 阅读(360) | 评论 (0)编辑 收藏

2008年10月8日 #

spring 事务管理之 声明式事务管理

spring提供声明式事务管理,这是通过aop实现的,这是最少影响应用代码的选择。
通常通过TransactionProxyFactoryBean实现事务代理。需要一个目标对象包装在事务代理中。当我们定义TransactionProxyFactoryBean是,我们需要一个关于PlatformTransactionManager的实现引用和事务属性,是无属性含有事务定义。


 <bean id="transactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>

 </bean>
以上代码是关于PlatformTransactionManager的实现类的定义。在事务代理定义中将引用这个javabean。

 <bean id="baseTransactionProxy"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
  abstract="true">
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="update*">PROPAGATION_REQUIRED</prop>
    <prop key="delete*">PROPAGATION_REQUIRED</prop>
    <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>
此处是定义事务代理,其中应用了关于PlatformTransactionManager的实现和事务属性。

spring中的事务策略
spring事务抽象的关键是事务策略的概念。这个概念由 org.springframework.transaction.PlatformTransactionManager 接口体现。


public interface PlatformTransactionManager
{

    public abstract TransactionStatus getTransaction(TransactionDefinition transactiondefinition)
        throws TransactionException;

    public abstract void commit(TransactionStatus transactionstatus)
        throws TransactionException;

    public abstract void rollback(TransactionStatus transactionstatus)
        throws TransactionException;
}

getTransaction根据一个类型为TransactionDefinition 参数返回一个TransactionStatus 类型的对象,返回的 TransactionStatus对象可能代表一个新的或已经存在的事 务(如果在当前调用堆栈有一个符合条件的事务)。

TransactionDefinition接口指定:

  • 事务隔离:当前事务和其它事务的隔离的程度。 例如,这个事务能否看到其他事务未提交的写数据?

  • 事务传播:通常在一个事务中执行的 所有代码都会在这个事务中运行。但是,如果一个事务上下文已经存在, 有几个选项可以指定一个事务性方法的执行行为:例如,简单地在现有的 事务中运行(大多数情况);或者挂起现有事务,创建一个新的事务。 Spring提供EJB CMT中熟悉的事务传播选项。

  • 事务超时: 事务在超时前能运行多 久(自动被底层的事务基础设施回滚)。

  • 只读状态: 只读事务不修改任何数 据。只读事务在某些情况下(例如当使用Hibernate时)可可是一种非常有用的优化

PlatformTransactionManager实现是如何定义的,它将和JDBC一起工作
首先需要定义jdbc数据源。然后使用DataSourceTransactionManager,为它提供一个数据源引用。
<bean id="dataSource"  <!-- BasicDataSource的别名 -->
    class="org.apache.commons.dbcp.BasicDataSource"  <!-- BasicDataSource类的别名所对应的类 -->
    destroy-method="close">
    <property name="driverClassName"><!-- 对应BasicDataSource类中的属性 -->
    <value>${jdbc.driverClassName}</value><!-- 该属性值将绑定到BasicDataSource上所对应的属性上(driverClassName) -->
    </property>
    <property name="url"><value>${jdbc.url}</value></property>
    <property name="username"><value>${jdbc.username}</value></property>
    <property name="password"><value>${jdbc.password}</value></property>
</bean>
PlatformTransactionManager的定义如下.

 <bean id="transactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource">
   <ref local="dataSource" />
  </property>

 </bean>

如果我们使用JTA, 我们需要使用通过JNDI获得的容器数据源,和一个JtaTransactionManager实 现。JtaTransactionManager不需要知道数据源,或任何其他特定资源,因为它将 使用容器的全局事务管理。

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>jdbc/jpetstore</value></property>
</bean>
<bean id="transactionManager"
class="org.springframework.transaction.jta.JtaTransactionManager"/>
 
使用hibernate局部事务的配置

在这种情况下,我们需要定义一个Hibernate的LocalSessionFactory,应用程 序将使用它获得Hibernate的会话。

数据源bean定义和上面例子类似,这里不再罗列(如果这是容器数据源,它应该是非事务的,因为Spring会管理事务, 而不是容器)。

这种情况下,“transactionManager” bean的类型是HibernateTransactionManager。
和DataSourceTransactionManager拥有一个数据源的引用一样, HibernateTransactionManager需要一个SessionFactory的引用。

<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource"><ref local="dataSource"/></property>
<property name="mappingResources">
<value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
</props>
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>


 





 


posted @ 2008-10-08 16:58 jws-21 阅读(98) | 评论 (0)编辑 收藏

2008年10月7日 #

ibatis学习

ibatis 开发指南
相对Hibernate和Apache OJB 等“一站式”ORM解决方案而言,ibatis 是一种“半
自动化”的ORM实现。
所谓“半自动”,可能理解上有点生涩。纵观目前主流的ORM,无论Hibernate 还是
Apache OJB,都对数据库结构提供了较为完整的封装,提供了从POJO 到数据库表的全
套映射机制。程序员往往只需定义好了POJO 到数据库表的映射关系,即可通过Hibernate
或者OJB 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握,
Hibernate/OJB 会根据制定的存储逻辑,自动生成对应的SQL 并调用JDBC 接口加以执
行。
大多数情况下(特别是对新项目,新系统的开发而言),这样的机制无往不利,大有一
统天下的势头。但是,在一些特定的环境下,这种一站式的解决方案却未必灵光。
在笔者的系统咨询工作过程中,常常遇到以下情况:
1. 系统的部分或全部数据来自现有数据库,处于安全考虑,只对开发团队提供几
条Select SQL(或存储过程)以获取所需数据,具体的表结构不予公开。
2. 开发规范中要求,所有牵涉到业务逻辑部分的数据库操作,必须在数据库层由
存储过程实现(就笔者工作所面向的金融行业而言,工商银行、中国银行、交
通银行,都在开发规范中严格指定)
3. 系统数据处理量巨大,性能要求极为苛刻,这往往意味着我们必须通过经过高
度优化的SQL语句(或存储过程)才能达到系统性能设计指标。
面对这样的需求,再次举起Hibernate 大刀,却发现刀锋不再锐利,甚至无法使用,
奈何?恍惚之际,只好再摸出JDBC 准备拼死一搏……,说得未免有些凄凉,直接使用JDBC
进行数据库操作实际上也是不错的选择,只是拖沓的数据库访问代码,乏味的字段读取操作
令人厌烦。
“半自动化”的ibatis,却刚好解决了这个问题。
这里的“半自动化”,是相对Hibernate等提供了全面的数据库封装机制的“全自动化”
ORM 实现而言,“全自动”ORM 实现了POJO 和数据库表之间的映射,以及SQL 的自动
生成和执行。而ibatis 的着力点,则在于POJO 与SQL之间的映射关系。也就是说,ibatis
并不会为程序员在运行期自动生成SQL 执行。具体的SQL 需要程序员编写,然后通过映
射配置文件,将SQL所需的参数,以及返回的结果字段映射到指定POJO。
使用ibatis 提供的ORM机制,对业务逻辑实现人员而言,面对的是纯粹的Java对象,
这一层与通过Hibernate 实现ORM 而言基本一致,而对于具体的数据操作,Hibernate
会自动生成SQL 语句,而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等
“全自动”ORM机制而言,ibatis 以SQL开发的工作量和数据库移植性上的让步,为系统
设计提供了更大的自由空间。作为“全自动”ORM 实现的一种有益补充,ibatis 的出现显
得别具意义。

posted @ 2008-10-07 17:23 jws-21 阅读(108) | 评论 (0)编辑 收藏

2008年8月12日 #

hibernate3 annotation学习

    对于采用hibernate方式实现数据持久化映射的方式,过去,Hibernate 依靠外部的XML文件来配置持久化对象,数据库映射文件定义在一组XML映射文件里并且在程序开始的时候被装载。最近的Hibernate版本里,一个新的建立在Java 5 注解之上更为优雅的方法出现了.利用新的Hibernate Annonations 库,你可以发布一次如你以前的映射文件所定义的信息。
    为 了使用Hibernate Annotations,你需要最新的Hibernate 3.2 ,当然还有Java 5 你可以在Hibernate web site 这个网站下载Hibernate 3.2和Hibernate Annotations库.除了标准的Hibernate 库文件和必须的依赖库之外,还需要下载 Hibernate Annotations库和Java 持久化API ---ejb3-persstence.jar文件。
    在hibernate配置文件中声明采用Hibernate Annotations方式配置的hibernate sessionFactory,具体配置如下:

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/>
  <property name="configLocations">
   <list>
    <value>classpath*:conf/hibernate.cfg.xml</value>
    <!-- 在此声明配置文件里声明持久化类,如hibernate.cfg.xml文件内容如下
 <hibernate-configuration>
 <session-factory>
  <mapping class="com.zhjy.gea.module.assessment.appraisal.domain.Appraisal" />
    <!-- 声明的持久化类-->  
 </session-factory>
</hibernate-configuration>

 -->
    </list>
  </property>
  <property name="mappingDirectoryLocations">
   <list>
   ×××××××
   </list>
  </property>
   <property name="lobHandler" ref="lobHandler" />
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
    <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
    <prop key="hibernate.cache.use_query_cache">true</prop>
    <prop key="hibernate.show_sql">true</prop>
    <prop key="hibernate.hbm2ddl.auto">false</prop>
    <prop key="hibernate.max_fetch_depth">2</prop>
    <prop key="hibernate.jdbc.fetch_size">50</prop>
    <prop key="hibernate.jdbc.batch_size">50</prop>
    <prop key="hibernate.use_outer_join">true</prop>
   </props>
   <!-- props>
    <prop key="hibernate.dialect">org.hibernate.dialect.OscarDialect</prop>
    <prop key="hibernate.show_sql">true</prop>
    <prop key="hibernate.cglib.use_reflection_optimizer">true</prop>
   </props -->
  </property>
 </bean>
在此声明了一个基于Annotations 的Hibernate Session Factory。
如果你集成spring,你也可以采用
<bean id="sessionFactory"
         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource">
      <ref bean="dataSource"/>
    </property>
    <property name="hibernateProperties">
      <props>
        <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
        <prop key="hibernate.hbm2ddl.auto">create</prop>
        ...
      </props>
    </property>
    <property name="annotatedClasses">
      <list>
        <value>com.onjava.modelplanes.domain.PlaneType</value>
        <value>com.onjava.modelplanes.domain.ModelPlane</value>
        ...
      </list>
    </property>
</bean>
方式来声明sessionFactory类。

映射关系:Onetomany


实体类对应表名的注解
 例:
  

@SuppressWarnings("serial")
@Entity
@Table(name = "GEA_APPRAISAL")//这里对应数据库中的表名
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)//采用缓存设置
public class Appraisal extends BaseAssessment {    
    @OneToMany(mappedBy="appraisal",cascade ={CascadeType.ALL},fetch=FetchType.LAZY)//mappedBy="appraisal"
//这个appraisal对应的是many一端即Buy实体类里面的one属性,即AppraisalEvent中定义的ManyToOne中One对应的//实体类.
    @OrderBy("ranking")//many方按ranking排序
    //@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
    private List<AppraisalEvent> appraisalEvents = new ArrayList<AppraisalEvent>();

 对应的Many方的配置ManyToOne

@SuppressWarnings("serial")
@Entity
@Table(name = "GEA_APPRAISALEVENT")
public class AppraisalEvent extends BaseAssessment {
    @ManyToOne(cascade ={CascadeType.PERSIST,CascadeType.MERGE})
    @JoinColumn(name = "Id")   //这个Id是one一边对应数据库中的主键名
    /** 对应的One方的实体类 */
    private Appraisal appraisal;
在many方的表中自动生成appraisal_id字段与One所指的实体类映射的表的主键关联,实际的数据库表关联语句为
alter table GEA_APPRAISALEVENT
  add constraint FKCC003B712ABC052 foreign key (APPRAISAL_ID)
  references GEA_APPRAISAL (ID);

posted @ 2008-08-12 14:32 jws-21 阅读(580) | 评论 (0)编辑 收藏

2008年8月5日 #

关于struts 中 LazyValidatorForm 模式的学习

struts 中LazyValidatorForm特别适用于FormBean中并不包含POJO商业对象所有属性的情况,因为通常项目里都属于这种情况,所以springside默认使用lazyValidatorForm. 
    比如User对象 有 id,name,status三个属性,而form表单中只有id和name两个input框,如果使用其他模式,直接把user 作为 form bean,  user对象的status因为没设值,将为null,  copy 到作为商业对象的user时,就会以null覆盖原值。而lazyBean就没有这个问题,如果form中没有status属性,它不会将它copy给商业对象。
    实际工程中将封装beanUtils中的copyProperties方法,用于将form中的属性绑定到实体对象中,
    /**
     * 将FormBean中的内容通过BeanUtils的copyProperties()绑定到Object中.
     * 因为BeanUtils中两个参数的顺序很容易搞错,因此封装此函数.
     */
    protected void bindEntity(ActionForm form, Object object)
    {
        if (form != null)
        {
            try
            {
                BeanUtils.copyProperties(object, form);
            }
            catch (Exception e)
            {
                ReflectionUtils.handleReflectionException(e);
            }
        }
    }
注意实体对象被自动绑定,默认Integer id 在空值时会被赋值为0,需要增加converter,让其默认为null,虽然也可以在web.xml里进行相关配置,但还是在基类里配置了比较安全。在工程中可以这样实现
 /**
     * 设置Struts 中数字<->字符串转换,字符串为空值时,数字默认为null,而不是0.
     * 也可以在web.xml中设置struts的参数达到相同效果,在这里设置可以防止用户漏设web.xml.
     */
    public static void registConverter()
    {
        ConvertUtils.register(new StringConvert("yyyy-MM-dd"), String.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new DateConvert("yyyy-MM-dd"), Date.class);
    }

将属性绑定过程中的一些空默认值修改为null

posted @ 2008-08-05 12:15 jws-21 阅读(1256) | 评论 (0)编辑 收藏

仅列出标题