BlogJava-LifeNote -随笔分类-Spring

Eclipse下的Java反编译插件：Jode Decompiler

LifeNote — Thu, 24 Apr 2008 07:05:00 GMT

这个工具感觉非常方便介绍给大家
安装方法：
help => Software Updates => Find and Install... => Search for new features to install,单击"New Remote Site..." 在URL栏输入 http://www.technoetic.com/eclipse/update.然后下一步，就可以看到“jode decompiler plugin *.*”，选上安装就可以了。

安装好后可以看到Window => Preferences... => Java => Jode Decompiler选项卡。

配置：Window => Preferences... => General => Editors => File Associations找到"*.class"在"Associated editors"里面可以看到"Jode class file viewer"选中它再单击Default按钮.

在Eclipse中展开jar文件,双击class文件即可看到反编译之后的源代码.

LifeNote 2008-04-24 15:05 发表评论

使用动态代理实现用AOP对数据库进行操作

LifeNote — Tue, 22 Apr 2008 01:54:00 GMT

要实现对数据库的操作，离不开数据源（DataSource）或者连接（Connection）,但是通常来说对数据库的操作都应该放在DAO中，而DAO又不应该与应用服务器相关联，所以一般都使用连接（Connection）。现在我们这里就有一个问题了，怎么在拦截器中获得连接。我想可以通过两种方式获得：
在分别讨论这两种方法之前，我们需要先讨论一下在处理数据库的时候的异常的处理。我这里做了一个TransactionException继承至RuntimeException然后在拦截器里面抛出，再又应用框架处理这个异常。下面试这个类的代码：
public class TransactionException extends RuntimeException {
    private Throwable superException;
    private String myMessage;

    public TransactionException(Throwable throwable){
        super(throwable);
        this.superException = throwable;
    }

    public TransactionException(Throwable throwable,String message){
        super(message,throwable);
        this.superException = throwable;
        this.myMessage = message;
    }

    /**
     * @return Returns the myMessage.
     */
    public String getMessage() {
        return myMessage;
    }

    /**
     * @return Returns the superException.
     */
    public Throwable getSuperException() {
        return superException;
    }

    /**
     * @param myMessage The myMessage to set.
     */
    public void setMyMessage(String message) {
        this.myMessage = message;
    }

    /**
     * @param superException The superException to set.
     */
    public void setSuperException(Throwable superException) {
        this.superException = superException;
    }


}
1）    通过方法的第一个参数传进去
l    DAO
import java.sql.Connection;

public class TestDao {
    public void insertA(Connection con,String a,String b,……){
        …………………………………………
一系列操作
…………………………………………
    }

    public String queryA(Connection con,…….){
    …………………………………………
一系列操作
…………………………………………
}

    public void updateA(Connection con,…….){
        …………………………………………
一系列操作
…………………………………………
}
}

l    拦截器
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class TransactionInterceptor implements Interceptor {

    public void before(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                throw new TransactionException(e);
            }
        }
    }

    public void after(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.commit();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    public void exceptionThrow(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.rollback();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    private List getNeedTransaction(){
        List needTransactions = new ArrayList();
        needTransactions.add("insert");
        needTransactions.add("update");
        return needTransactions;
    }

    private boolean isNeedTransactions(InvokeJniInfo invInfo){
        String needTransaction = "";
        List needTransactions = getNeedTransaction();
        for(int i = 0;i             needTransaction = (String)needTransactions.get(i);
            if(invInfo.getMethod().getName().startsWith(needTransaction)){
                return true;
            }
        }
        return false;
    }
}

需要注意的是：getNeedTransaction就是需要进行事务处理的方法的开头，这个方法可以写成一个从配置文件里面去读，这里我就写死在里面了。只是对insert和update开头的方法进行事务控制。
2）    将Connection对象放在ThreadLocal中
l    ConnectionUtil类：
import java.sql.Connection;

public final class ConnectionUtil {
    private static ThreadLocal connections = new ThreadLocal();
    public static Connection getConnection(){
        Connection conn = null;
        conn = (Connection) connections.get();
        if(conn == null){
            conn = getRealConnection();
            connections.set(conn);
        }
        return conn;
    }
    public static void realseConnection(Connection conn){
        connections.set(null);
    }
    private static Connection getRealConnection() {
        实现自己获取连接的代码
        return null;
    }
}
l    DAO类
public class TestDao {
    public void insertA(String a,String b){
        Connection conn = getConnection();
        …………………………………………
一系列操作
…………………………………………
    }
        public String queryA(Connection con,…….){
        Connection conn = getConnection();
    …………………………………………
一系列操作
…………………………………………
}

    public void updateA(Connection con,…….){
Connection conn = getConnection();
        …………………………………………
一系列操作
…………………………………………
}

    private Connection getConnection(){
        return ConnectionUtil.getConnection();
    }

}
l    拦截器
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class TransactionInterceptor implements Interceptor {

    public void before(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                throw new TransactionException(e);
            }
        }
    }

    public void after(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.commit();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                        releaseConnection(conn);
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    public void exceptionThrow(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.rollback();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                        releaseConnection(conn);
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    private Connection getConnection(){
        return ConnectionUtil.getConnection();
    }

    private void releaseConnection(Connection conn){
        ConnectionUtil.releaseConnection(conn);
    }
    private List getNeedTransaction(){
        List needTransactions = new ArrayList();
        needTransactions.add("insert");
        needTransactions.add("update");
        return needTransactions;
    }

    private boolean isNeedTransactions(InvokeJniInfo invInfo){
        String needTransaction = "";
        List needTransactions = getNeedTransaction();
        for(int i = 0;i             needTransaction = (String)needTransactions.get(i);
            if(invInfo.getMethod().getName().startsWith(needTransaction)){
                return true;
            }
        }
        return false;
    }
}
    最后将这个拦截器添加到AOP拦截框架中去，InterceptorHandler类中的getIntercetors方法中添加一个：

    private synchronized List getIntercetors(){
        if(null == interceptors){
            interceptors = new ArrayList();
            ……………………………………
interceptors.add(new TransactionInterceptor ());
            ……………………………………
        }
        return interceptors;
}

LifeNote 2008-04-22 09:54 发表评论

Hibernate中Criteria的完整用法

LifeNote — Wed, 12 Mar 2008 07:24:00 GMT

最近在项目中使用 Spring 和 Hibernate 进行开发，有感于 Criteria 比较好用，在查询方法

设计上可以灵活的根据 Criteria 的特点来方便地进行查询条件的组装。现在对 Hibernate的Criteria 的用法进行总结：
   Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口，下面提供了 Criteria和DetachedCriteria 。
   Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所
以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需
Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate
().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结
果。
   Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel
（冲刷 Session 的方式）和 LockMode （数据库锁模式）。
下面对 Criterion 和 Projection 进行详细说明。
     Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
添加查询条件。
     Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。而
Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操
作符进行来联结查询条件集合。
     Criterion 的实例可以通过 Restrictions 工具类来创建，Restrictions 提供了大量的静态
方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件
（SimpleExpression 实例）。除此之外， Restrictions 还提供了方法来创建 conjunction 和
disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合
。
     至于 Example 的创建有所不同， Example 本身提供了一个静态方法 create(Object
entity) ，即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些
过滤条件：
Example exampleUser =Example.create(u)
.ignoreCase() // 忽略大小写
.enableLike(MatchMode.ANYWHERE);
// 对 String 类型的属性，无论在那里值在那里都匹配。相当于 %value%
Project 主要是让 Criteria 能够进行报表查询，并可以实现分组。 Project 主要有
SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
ProjectionList 的实例化是由内建的 Projections 来完成，如提供的 avg 、 count 、 max 、
min 、 sum 可以让开发者很容易对某个字段进行统计查询。
       Property 是对某个字段进行查询条件的设置，如通过Porperty.forName(“color”).in
(new String[]{“black”,”red”,”write”}); 则可以创建一个 Project 实例。通过
criteria 的 add(Project) 方法加入到查询条件中去。
    使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查
询条件的创建和组装，下面介绍几种用法：
1. 创建一个Criteria 实例
org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。
Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

2. 限制结果集内容
一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。

org.hibernate.criterion.Restrictions类定义了获得某些内置Criterion类型的工厂方法。
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

约束可以按逻辑分组。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
        Restrictions.eq( "age", new Integer(0) ),
        Restrictions.isNull("age")
    ) )
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Restrictions.disjunction()
        .add( Restrictions.isNull("age") )
        .add( Restrictions.eq("age", new Integer(0) ) )
        .add( Restrictions.eq("age", new Integer(1) ) )
        .add( Restrictions.eq("age", new Integer(2) ) )
    ) )
    .list();

Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许

你直接使用SQL。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",

Hibernate.STRING) )
    .list();

{alias}占位符应当被替换为被查询实体的列别名。
Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个

Property。

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.disjunction()
        .add( age.isNull() )
        .add( age.eq( new Integer(0) ) )
        .add( age.eq( new Integer(1) ) )
        .add( age.eq( new Integer(2) ) )
    ) )
    .add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
    .list();

3. 结果集排序
你可以使用org.hibernate.criterion.Order来为查询结果排序。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Property.forName("name").like("F%") )
    .addOrder( Property.forName("name").asc() )
    .addOrder( Property.forName("age").desc() )
    .setMaxResults(50)
    .list();

4. 关联
你可以使用createCriteria()非常容易的在互相关联的实体间建立约束。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .createCriteria("kittens")
        .add( Restrictions.like("name", "F%")
    .list();

注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。
接下来，替换形态在某些情况下也是很有用的。

List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Restrictions.eqProperty("kt.name", "mt.name") )
    .list();

(createAlias()并不创建一个新的 Criteria实例。)
Cat实例所保存的之前两次查询所返回的kittens集合是没有被条件预过滤的。如果你希望只获得

符合条件的kittens，你必须使用returnMaps()。

List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
    .add( Restrictions.eq("name", "F%") )
    .returnMaps()
    .list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
    Map map = (Map) iter.next();
    Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
    Cat kitten = (Cat) map.get("kt");
}

5. 动态关联抓取
你可以使用setFetchMode()在运行时定义动态关联抓取的语义。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .setFetchMode("kittens", FetchMode.EAGER)
    .list();

这个查询可以通过外连接抓取mate和kittens。

6. 查询示例
org.hibernate.criterion.Example类允许你通过一个给定实例构建一个条件查询。

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .list();

版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。
可以自行调整Example使之更实用。

Example example = Example.create(cat)
    .excludeZeroes()           //exclude zero valued properties
    .excludeProperty("color") //exclude the property named "color"
    .ignoreCase()              //perform case insensitive string comparisons
    .enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
    .add(example)
    .list();

甚至可以使用examples在关联对象上放置条件。

List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
        .add( Example.create( cat.getMate() ) )
    .list();

7. 投影(Projections)、聚合（aggregation）和分组（grouping）
org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用

setProjection()应用投影到一个查询。

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.rowCount() )
    .add( Restrictions.eq("color", Color.BLACK) )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount() )
        .add( Projections.avg("weight") )
        .add( Projections.max("weight") )
        .add( Projections.groupProperty("color") )
    )
    .list();


在一个条件查询中没有必要显式的使用 "group by" 。某些投影类型就是被定义为分组投影，他

们也出现在SQL的group by子句中。

可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();



List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

alias()和as()方法简便的将一个投影实例包装到另外一个别名的Projection实例中。简而言之，

当你添加一个投影到一个投影列表中时你可以为它指定一个别名：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount(), "catCountByColor" )
        .add( Projections.avg("weight"), "avgWeight" )
        .add( Projections.max("weight"), "maxWeight" )
        .add( Projections.groupProperty("color"), "color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
        .add( Projections.property("cat.name"), "catName" )
        .add( Projections.property("kit.name"), "kitName" )
    )
    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();

也可以使用Property.forName()来表示投影：

List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount().as("catCountByColor") )
        .add( Property.forName("weight").avg().as("avgWeight") )
        .add( Property.forName("weight").max().as("maxWeight") )
        .add( Property.forName("color").group().as("color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

8. 离线(detached)查询和子查询
DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来

执行它。

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
    .add( Property.forName("sex").eq('F') );
//创建一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者
Property获得。

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

相互关联的子查询也是有可能的：

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();

LifeNote 2008-03-12 15:24 发表评论

深入理解Tapestry的Rewind

LifeNote — Sat, 08 Mar 2008 08:03:00 GMT

Tapestry的rewind一直是学习和使用Tapestry的难点，rewind是用来处理表单提交的，表单默认使用的是DirectService来提交。在详细介绍之前，先说明下此文中需要用到的一些概念，首先是表单组件，我这里指的是指继承自AbstractFormComponent类的组件，例如：TextField、TextArea、Checkbox等，而不是具体的Form组件，表单组件使用时必须在Form组件中，这些组件在rewind时调用继承自AbstractFormComponent的rewindFormComponent来读取数据，并将数据赋值给容器或者页面。
我们来看一下最简单的TextField组件，组件定义如下

Java代码

"price@TextField" type="text" value="ognl:picture.price" translator="translator:number,pattern=##.##" validators="validators:min=0" displayName="价格" class="input_text"/>

再看一下TextField中的rewindFormComponent组件方法

Java代码

protected void rewindFormComponent(IMarkupWriter writer, IRequestCycle cycle) {
//从请求中得到参数值
String value = cycle.getParameter(getName());
try {
//用translator来转换值
Object object = getTranslatedFieldSupport().parse(this, value);
//用validators来验证值
getValidatableFieldSupport().validate(this, writer, cycle, object);
//赋值给容器或者页面
setValue(object);
} catch (ValidatorException e) {
getForm().getDelegate().record(e);
}
}

protected void rewindFormComponent(IMarkupWriter writer, IRequestCycle cycle) {
//从请求中得到参数值
String value = cycle.getParameter(getName());
try {
//用translator来转换值
Object object = getTranslatedFieldSupport().parse(this, value);
//用validators来验证值
getValidatableFieldSupport().validate(this, writer, cycle, object);
//赋值给容器或者页面
setValue(object);
} catch (ValidatorException e) {
getForm().getDelegate().record(e);
}
}

可以看到在rewindFormComponent中，主要是从请求中取得用户输入的值，然后进行处理，最后赋值给容器或者页面，上面的例子中会调用页面类的getPicture().setPrice(“用户输入的值”)来进行赋值。这样整个表单的提交就可以理解为所有的表单组件读取用户输入的值并赋值给页面的过程。
整个表单提交的详细处理过程如下：

isRewinding

我们可以看到pageBeginRender和pageEndRender被调用了两次，两次中的区别为RequestCycle().isRewinding，因为我们在使用时经常利用pageBeginRender的初始化值，所以这里有很多使用上的误区，如果在pageBeginRender中从数据库读取数据来初始化跟表单提交无关的变量的话，就可能被调用两次，这个是应该避免的。什么叫跟表单提交无关的变量呢，就是表单组件中跟赋值无关的，例如上边提到的value="ognl:picture.price",这时picture就是与表单提交相关的变量，如果你没有初始化，那么在赋值时调用getPicture().setPrice()就会出现空指针异常，因为这是的picture为null。我们举个例子来看一下表单无关的变量，假如这个picture页面会显示一个创建picture的表单和所有picture的列表，那这个picture的列表就是与表单提交无关的变量，如果你在pageBeginRender中初始化的话，就需要区分是否rewind，否则表单提交时就会被初始化两次，让我们看一下代码：

Java代码

public abstract void setPictures(List pictures);
public abstract void setPictureInList();//用于For中的value
public abstract void setPicture(Picture picture);//用于表单创建
public abstract Picture getPicture();
public void pageBeginRender(PageEvent event) {
if(getPicture()==null){
setPicture(new Picture());
}
setPictures(getPictureService().findAll());
}

public abstract void setPictures(List pictures);
    public abstract void setPictureInList();//用于For中的value
    public abstract void setPicture(Picture picture);//用于表单创建
    public abstract Picture getPicture();
    public void pageBeginRender(PageEvent event) {
    if(getPicture()==null){
    setPicture(new Picture());
    }
    setPictures(getPictureService().findAll());
    }

判断picture是否为null并赋值在页面显示和rewind中都是需要的，因为页面显示时，需要调用getPicture().getPrice(),页面rewind时，需要调用getPicture().setPrice(),这两个阶段中的picture都不能为null。但setPictures会在表单提交时被调用两次，在rewind阶段初始化它是没有用处的，所以这时就要对是否rewind进行判断。修改后的代码如下：

Java代码

public void pageBeginRender(PageEvent event) {
if(getPicture()==null){
setPicture(new Picture());
}
if (!event.getRequestCycle().isRewinding()) {
setPictures(getPictureService().findAll());
}
}

public void pageBeginRender(PageEvent event) {
    if(getPicture()==null){
    setPicture(new Picture());
    }
    if (!event.getRequestCycle().isRewinding()) {
    setPictures(getPictureService().findAll());
    }
    }

这样就可以避免在rewind时对pictures进行不必要的赋值。这里还要提到的一点是页面显示和提交后的页面很可能不是同一个页面类的实例，大家都知道页面类的实例是从实例池取到的，用户打开页面显示表单完后的页面类实例和用户提交表单时的用来rewind的页面类实例不一定是同一个，即使是一个实例，也是被重新初始化过的，不要想当然的认为显示表单后再提交那个实例应该保存原来显示的东西，这个应该理清楚。

原文地址：http://www.javaeye.com/article/41724

LifeNote 2008-03-08 16:03 发表评论

《J2EE核心模式》(DAO模式)

LifeNote — Fri, 15 Feb 2008 09:09:00 GMT

很多的J2EE应用程序需要使用持久性数据(数据库、文件等)。不同的程序，持久性存储是各不相同的，并且用来访问这些不同的持久性存储机制的API也有很大的不同。如果应用程序要在不同的持久性存储间迁移，这些访问特定持久存储层的代码将面临重写。
如何解决这个问题?且看"DAO模式"

数据访问对象(Data Acess Object) 模式
一.环境
根据数据源不同，数据访问也不同。根据存储的类型(关系数据库、面向对象数据库、文件等等)和供应商实现不同，持久性存储(比如数据库)的访问差别也很大

二.问题
许多真是的J2EE应用程序需要在一定程度上使用持久性数据。对于许多应用程序，持久性存储是使用不同的机制实现的,并且用来访问这些不同的持久性存储机制的API也有很大的不同。
比如，应用程序使用实体bean(这里应该是指BMP的bean，CMP的bean已大大降低了与RDBMS的耦合)的分布式组件来表示持久性数据，或者使用JDBC API来访问驻留在某关系数据库管理系统(RDBMS)中的数据，这些组件中包含连接性性和数据访问代码会引入这些组件与数据源实现之间的紧密耦合。组件中这类代码依赖性使应用程序从某种数据源迁移到其他种类的数据源将变得非常麻烦和困难。当数据源变化时，组件也需要改变，以便于能够处理新类型的数据源

(举个例子来说，我们UPTEL系统是使用JDBC API对 ORACLE数据库进行连接和数据访问的，这些JDBC API与SQL语句散布在系统中，当我们需要将UPTEL迁移到其他RDBMS时，比如曾经迁移到INFORMIX，就面临重写数据库连接和访问数据的模块。)

三.作用力
1.诸如bean管理的实体bean、会话bean、servlet等组件往往需要从持久性存储数据源中检索数据，以及进行数据存储等操作。
2.根据产品供应商的不同，持久性存储API差别也很大，这些API和其能力同样根据存储的类型不同也有差别，这样存在以下缺点，即访问这些独立系统的API很不统一。
3.组件需要透明于实际的持久性存储或者数据源实现，以便于提供到不同供应商产品、不同存储类型和不同数据源类型的更容易的移植性。

四.解决方案
使用数据访问对象(DAO)模式来抽象和封装所有对数据源的访问。DAO管理着与数据源的连接以便检索和存储数据。
DAO实现了用来操作数据源的访问机制。数据源可以时RDBMS,LDAP,File等。依赖于DAO的业务组件为其客户端使用DAO提供更简单的接口。DAO完全向客户端隐藏了数据源实现细节。由于当低层数据源实现变化时，DAO向客户端提供的接口不会变化，所有该模式允许DAO调整到不同的存储模式，而不会影响其客户端或者业务组件。重要的是,DAO充当组件和数据源之间的适配器。

(按照这个理论，如果我们UPTEL系统使用了DAO模式,就可以无缝的从ORACLE迁移到任何一个RDBMS了。梦想总是很完美的，且看看DAO模式如何实现)

LifeNote 2008-02-15 17:09 发表评论

JSF中文输入乱码问题解决方法

LifeNote — Thu, 31 Jan 2008 07:05:00 GMT

该方法已知适用的版本tomact5.0.18,tomcat5.0.9。
已知不适用的版本为tomcat5.0.28。
问题描述：
在inputtext中输入中文，然后在输出，显示为乱码。
解决方法：
1、自定义转器
package util;
import java.util.Map;
import javax.faces.component.UIComponent;
import javax.faces.convert.Converter;
import javax.faces.context.FacesContext;
import javax.faces.convert.ConverterException;

public class StringConverter implements Converter {
public Object getAsObject(FacesContext context, UIComponent component,
   String newValues) throws ConverterException {
  String newstr = "";
  if (newValues == null) {
   newValues = "";
  }
  byte[] byte1 = null;
  try {
   byte1 = newValues.getBytes("ISO-8859-1");
   newstr = new String(byte1, "GB2312");
   UIInput input=(UIInput)component;//
   input.setSubmittedValue(newstr);
  } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
  }

return newstr;

}

public String getAsString(FacesContext context, UIComponent component,
Object Values) throws ConverterException {
return (String) Values;
}
}

2、注册转换器
faces-config.xml片段

util.stringconverter
util.StringConverter

3、在页面使用转换器

LifeNote 2008-01-31 15:05 发表评论

Tomcat,Weblogic 等服务器 SSL 安全登陆的例子---附证书文件生成器

LifeNote — Tue, 15 Jan 2008 04:32:00 GMT

公司今天一个登陆的地方要修改，需要加一个SSL安全登陆,于是查些资料并总结如下，希望对有用的着的朋友有帮助
文件打包地址：http://www.blogjava.net/Files/lifenote/tomcat配置ssl.rar
一下为帮助说明：

1.1. 安全登录 SSL
1.1.1 WebLogic下面SSL配置：
1．生成 keystoreFile：
* keystoreFile 文件的生成：
%Java_Home%\bin\keytool -genkey -alias localhost-weblogic -keyalg RSA -validity 365 -keystore ./testKey.jks

* csr 文件的生成：
%Java_Home%\bin\keytool -certreq -alias localhost-weblogic -sigalg MD5withRSA -file ./testServer.csr -keystore ./testKey.jks

* 注意： http 的默认端口是80，https 的默认端口是433，ftp 的默认端口是21。
2．部署keystore 文件
在中配置刚才生成的 testKey.jks 文件。

1.1.2 Tomcat 下面SSL配置

1．生成 keystoreFile：
* keystoreFile 文件的生成：
%Java_Home%\bin\keytool -genkey -alias localhost-weblogic -keyalg RSA -validity 365 -keystore ./testKey.jks

Example for inner test：
[root@localhost ~]#
/home/tomcat/jdk1.5.0_12/bin/keytool -genkey -alias localhost-tomcat -keyalg RSA -validity 365 -keystore /home/tomcat/apache-tomcat-5.5.23/conf/VCMarketKey.jks
Enter keystore password: someday2007
What is your first and last name?
[Unknown]: lifenote
What is the name of your organizational unit?
[Unknown]: Java
What is the name of your organization?
[Unknown]: Sunxc
What is the name of your City or Locality?
[Unknown]: Beijing
What is the name of your State or Province?
[Unknown]: Beijing
What is the two-letter country code for this unit?
[Unknown]: ZH
Is CN=lifenote, OU=Java, O=Sunxc, L=Beijing, ST=Beijing, C=ZH correct?
[no]: y

Enter key password for
(RETURN if same as keystore password): someday2007
[root@localhost ~]#

* csr 文件的生成：
%Java_Home%\bin\keytool -certreq -alias localhost-weblogic -sigalg MD5withRSA -file ./testServer.csr -keystore ./testKey.jks

* 注意： http 的默认端口是80，https 的默认端口是433，ftp 的默认端口是21。

2．部署keystore 文件
打开 server.xml 文件，修改内容如下：

* 只需去掉 server.xml 中对SSL定义的注释，在加上 keystoreFile、keystorePass 这两个属性即可。
      name="Catalina">
            port="8080"
  ...



                   maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"
      keystoreFile="e:/temp_E/ssl/testKey.jks"
      keystorePass="aaaaaa"/>

            port="8009"
  ...

...
Example for inner test：
                   maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"
      keystoreFile="/home/tomcat/apache-tomcat-5.5.23/conf/VCMarketKey.jks"
      keystorePass="password"/>

注意需默认要使用 443 而不是 8443，要使用8443要在apache中配置，保证从apache请求tomcat 采用 ... 的格式。

1.1.3 使用http访问WebService s的客户端配置
Servlet服务器配置好SSL之后，客户端可以使用https访问了。
对于用户使用浏览器访问https的方式，浏览器会弹出安装证书的对话框，确认之后可以正常使用https访问。
对于WebService 通过https方式访问，按照一下步骤：
1． WebService客户端要先取得keyStore文件；
2．虚拟机系统使用 System.setProperties(…) 设置keyStore信息；
3．使用 url= 访问WebService服务

LifeNote 2008-01-15 12:32 发表评论

一个Struts的上传下载文件的程序

LifeNote — Mon, 14 Jan 2008 13:24:00 GMT

参看了一些资料实现了一个Struts的上传下载文件的程序，提供下载学习，有什么不好的地方请留言多多指教
为了节省空间，文件中没有导入java包，导入eclipse后请自行加入java包

http://www.blogjava.net/Files/lifenote/使用struts实现文件上传下载.rar

要把上面的地址都复制哦

LifeNote 2008-01-14 21:24 发表评论

java.lang.OutOfMemoryError 的解决办法

LifeNote — Wed, 09 Jan 2008 05:27:00 GMT

最近在使用Tomcat +Tapestry的时候遇见一个问题，由于Tapestry修改些内容后要重新启动（即使配置了一下那参数有时候也要重启）当我修改了页面的内容需要调试不断刷新，发现页面显示的速度越来越慢最后就出现了 500错误java.lang.OutOfMemoryError 内存溢出，在网上查了一下资料
最后总结如下希望可以帮你解决同样的问题
解决java.lang.OutOfMemoryError的方法有如下几种：
1。增加jvm的内存大小。方法有：
             1）在执行某个class文件时候，可以使用java -Xmx256M aa.class来设置运行aa.class时jvm所允许占用的最大内存为256M。
             2）对tomcat容器，可以在启动时对jvm设置内存限度。对tomcat，可以在catalina.bat中添加：
  set CATALINA_OPTS=-Xms128M -Xmx256M
   set JAVA_OPTS=-Xms128M -Xmx256M
或者把%CATALINA_OPTS%和%JAVA_OPTS%代替为-Xms128M -Xmx256M

             3）对resin容器，同样可以在启动时对jvm设置内存限度。在bin文件夹下创建一个startup.bat文件，内容如下：
                  @echo off
                   call "httpd.exe"  "-Xms128M" "-Xmx256M"
                   :end
                   其中"-Xms128M"为最小内存，"-Xmx256M"为最大内存。

2. 优化程序，释放垃圾。

LifeNote 2008-01-09 13:27 发表评论

多模块Struts应用程序的几个问题（及部分解决方法）

LifeNote — Fri, 04 Jan 2008 05:35:00 GMT

Struts从1.1版本开始支持把应用程序分为多个模块，每个模块可以看作独立的应用程序，在带来方便的同时，我也发现了一些问题。比如有一个struts应用程序分了大约十个模块，现在有以下问题不知道大家一般是怎么解决的：

1、因为要进行验证，所以在每个模块对应的资源文件里都要有“errors.required={0} is required.”等资源，有没有只用在一个文件里定义的方法？

2、用tiles的时候，要在每个模块对应的tiles-defs.xml里定义几乎相同的definition，有没有只用在一个文件里定义的方法？（我试过在缺省模块里定义一个definition，然后在模块里extends它，但不行，extends似乎只找当前模块）

3、使用ExceptionHandler的时候，为什么在exception标签里指定了bundle属性还是只在当前模块里找资源？我希望把一些重复使用的异常处理声明在一个文件里，例如NotLoginException、NoSuchObjectException等等，并且它们对应的key也指向同一个资源文件里的资源（利用bundle属性），怎么实现？

经过一段时间的摸索，第一个和第三个问题基本上解决了，其实它们可以看作同一类问题，就是资源的问题。在struts-config-xxx.xml里定义资源文件时，可以指定一个factory属性，不指定时使用缺省的“org.apache.struts.util.PropertyMessageResourcesFactory”类。我的解决方法是自定义一个CustomMessageResourcesFactory类，将多个资源文件以逗号分隔的形式作为参数（即message-resources的parameter属性）传给它，在需要资源的地方会遍历它们进行查找。同时还要自定义一个CustomMessageResources类，它的getMessage()方法里是查找资源的关键代码，而factory只是解析逗号分隔的参数构造并返回CustomMessageResources实例。

CustomMessageResourcesFactory的代码比较简单，如下所示：

package eg;

import java.util.Arrays;

import org.apache.struts.util.MessageResources;
import org.apache.struts.util.MessageResourcesFactory;

public class CustomMessageResourcesFactory extends MessageResourcesFactory{

    public MessageResources createResources(String config) {

        return new CustomMessageResources(Arrays.asList(config.split(",")));
    }

}

CustomMessageResources就稍微复杂一些，不过很幸运，我在网上找到了一个完全符合自己要求的类，下载地址在

<message-resources factory="eg.CustomMessageResourcesFactory"
parameter="eg.ApplicationResources,eg.ErrorResources" />

上面参考了这篇文章

LifeNote 2008-01-04 13:35 发表评论

JSF和Spring集成

LifeNote — Thu, 03 Jan 2008 08:31:00 GMT

JSF和Spring集成原理是获得彼此的上下文引用,以此进一步获得各自管理的bean,这是可能的,因为两者是web应用框架都遵循servlet规范,为二者整合提供了可能和基础.

在Spring中ApplicationContext是相当重要的类,对于web应用,它还包装了javax.servlet.ServletContext,为web应用提供了所有可以利用的数据,包括可管理bean,Faces中通过FacesContext类可以获得所有可以利用的资源,同样包括JSF的可管理支持bean,它们都围绕着ServletContext提供了自己的门面,通过各自的门面在Servlet容器的世界里彼此相通.
本文介绍两种方式,实现二者集成:
1.         通过写自己的类来完成二者的连通,实际上只是获得彼此世界里存活的bean,对于JSF中事件处理可能需要更进一步的构思和编码,为了这点,第二个方法介绍了一种框架.
2.         使用框架完成二者集成.

一自己动手,下面的代码以示例为主,其它涉及的类和接口略去.
这个工具类提供在JSF世界里查找Spring管理的bean.也实现在Spring中查找JSF组件的方法.
package com.skysoft.rbac.dao;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.faces.context.FacesContext;
import javax.servlet.ServletContext;
import javax.faces.el.ValueBinding;
import javax.faces.FactoryFinder;
import javax.faces.application.Application;
import javax.faces.application.ApplicationFactory;

public final class SpringFacesUtil {
public SpringFacesUtil() {
}
/**
   * 从Spring中查找bean.
   * @param beanname String
   * @return Object
   */
public static Object findBean(String beanname) {
    ServletContext context = (ServletContext) FacesContext.getCurrentInstance().
        getExternalContext().getContext();
    ApplicationContext appctx = WebApplicationContextUtils.
        getRequiredWebApplicationContext(context);
    return appctx.getBean(beanname);
}
/**
   * 从JSF中查找bean.
   * @param beanname String
   * @return Object
   */
public static Object lookupBean(String beanname) {
    Object obj = getValueBinding(getJsfEl(beanname)).getValue(FacesContext.
        getCurrentInstance());
    return obj;
}

private static ValueBinding getValueBinding(String el) {
    return getApplication().createValueBinding(el);
}

private static Application getApplication() {
    ApplicationFactory appFactory = (ApplicationFactory) FactoryFinder.
        getFactory(FactoryFinder.APPLICATION_FACTORY);
    //FactoryFinder.FACES_CONTEXT_FACTORY
    //FactoryFinder.RENDER_KIT_FACTORY
    return appFactory.getApplication();
}

private static String getJsfEl(String value) {
    return "#{" + value + "}";
}
}
下面定义一个由JSF管理的bean:
package com.skysoft.rbac.dao;

import javax.servlet.ServletContext;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.skysoft.struts.jsf.util.FacesUtils;

public class ServiceLocatorBean
    implements ServiceLocator {
private static final String DAO_SERVICE_BEAN_NAME = "userDAO";
//这个dao就是由Spring提供的管理bean,这个dao可以使用Hibernate实现.
private UserDAO dao;

public ServiceLocatorBean() {
    this.dao = (UserDAO)SpringFacesUtil.findBean(DAO_SERVICE_BEAN_NAME);
}

public UserDAO getDao() {
    return dao;
}
}
下面是一个使用ServiceLocatorBean的类.
public class UserDAOImp
    extends HibernateDaoSupport implements UserDAO {
private UserDAO dao;
private List list;

public UserDAOImp() {}

public List getList() {
    if (list == null) {
      list = dao.getList();
    }
    return list;
}

public UserDAO getDao() {
    return dao;
}

public void setDao(UserDAO dao) {
    this.dao = dao;
}
}

在faces-config.xml中的配置:

              serviceLocatorBean
              com.skysoft.rbac.dao.ServiceLocatorBean
              session


              User
              com.skysoft.rbac.User
              request

                     serviceLocator
                     com.skysoft.rbac.dao.ServiceLocatorBean
                     #{serviceLocatorBean}


在applicationContext.xml中的配置:





二使用框架
1 介绍
这个框架是Spring相关项目,提供一个包de.mindmatters.faces.spring,这个包包含JSF和Spring框架综合集成的粘合代码,这些代码以独立于一个实现的方式完成,这样它能和任何JSF实现一起使用.
本包的提供的代码主要目的是尽可能透明的集成两个框架,主要特征:
l         JSF/JSP开发者应该能访问Spring管理的Beans,就好象它们是由JSF管理的.
l         JSF可管理beans应能集成入Spring.
l         RequestHandledEvent事件也应该能被发布到Spring.
2 JSF配置集成
本包构造了一个基于faces配置文件(e.g. /WEB-INF/faces-config.xml)的WebApplicationContext类, 让它成为遵循"spring-beans" DTD配置文件(e.g. defined in /WEB-INF/applicationContext.xml)来配置的ApplicationContext的孩子,这样依从"faces-config" DTD的WebApplicationContext就是全特征的,即自动拥有如下功能:
l         JSF可管理beans实现了Spring的*Aware interfaces:
ApplicationContextAware
BeanFactoryAware
BeanNameAware
ResourceLoaderAware
ServletContextAware
l         JSF可管理beans实现Spring的lifecycle interfaces:
InitializingBean
DisposableBean
l         实现Spring的FactoryBean interface
l         实现Spring的ApplicationListener interface
l         发布ApplicationEvent事件.
l         从资源中读取消息.
等等,更多可看Spring.
3 访问方式
1) 从JSF中程序化的访问Spring管理的beans.
因为在FacesWebApplicationContext和ApplicationContext之间有层次关系,所以你的JSF可管理支持beans能容易的实现ApplicationContextAware接口,并能通过getBean方法访问它而不管它是否定义在FacesWebApplicationContext中还是定义在父ApplicationContext类对象中.
2) 通过JSF EL从JSF中访问Spring管理的beans.
能够使用JSF EL访问beans无论你引用的bean由JSF管理还是由Spring管理.两个bean上下文在存取时间合并.
a) 直接访问:
如果一个带有请求名字的bean只存在于Spring上下文内的话,这个bean被使用,bean的singleton属性设置被完全保持.
b) 区域化访问(scoped access):
如果你要从JSF定义bean的作用域的能力上得益还想让那个bean由Spring管理,那么就要在两个上下文中定义,只是对于JSF上下文中的定义的类类型要使用de.mindmatters.faces.spring.SpringBeanFactory类,你还应该设置那个bean的singleton属性到false,因这能覆盖你的作用域设置.在你使用JSF EL访问bean时,你总能获得一个遵从你在JSF上下文中定义的作用域设置的由Spring管理的bean的实例.

三用法
通常,就象设置任何其它JSF web应用一样设置你的web应用,下面的样例配置展示怎样使能上面提到的特征。
在web.xml配置中必须加入下列配置条目,同时注意把该库的jsf-spring.jar放在适当的位置.

    .........


        RequestHandled
        de.mindmatters.faces.spring.support.RequestHandledFilter



        RequestHandled
        *.faces




        org.springframework.web.context.ContextLoaderListener

    .........

下面的一些说明,都可以通过下载这个Spring相关项目得到,列在这里只为演示上面的说明的功能.
WEB-INF/faces-config.xml

    jsfBean
    example.NameBean
    session

        name



              scopedAccessSpringBean
       de.mindmatters.faces.spring.SpringBeanScope
              session


    referencingBean
    example.ReferencingBean
    session

        referencedBean
        #{managedPropertyAccessSpringBean}


WEB-INF/applicationContext.xml (partial)

参考:
http://jsf-spring.sourceforge.net/   JSF-Spring,Spring相关项目官方站点,提供本文介绍的框架下载以及实例下载.
javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html">http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html 一篇关于JSF和Spring的文章.
bean的singleton属性设置被完全保持.

b) 区域化访问(scoped access):
如果你要从JSF定义bean的作用域的能力上得益还想让那个bean由Spring管理,那么就要在两个上下文中定义,只是对于JSF上下文中的定义的类类型要使用de.mindmatters.faces.spring.SpringBeanFactory类,你还应该设置那个bean的singleton属性到false,因这能覆盖你的作用域设置.在你使用JSF EL访问bean时,你总能获得一个遵从你在JSF上下文中定义的作用域设置的由Spring管理的bean的实例.

三用法
通常,就象设置任何其它JSF web应用一样设置你的web应用,下面的样例配置展示怎样使能上面提到的特征。
在web.xml配置中必须加入下列配置条目,同时注意把该库的jsf-spring.jar放在适当的位置.

    .........


        RequestHandled
        de.mindmatters.faces.spring.support.RequestHandledFilter



        RequestHandled
        *.faces




        org.springframework.web.context.ContextLoaderListener

    .........

下面的一些说明,都可以通过下载这个Spring相关项目得到,列在这里只为演示上面的说明的功能.
WEB-INF/faces-config.xml

    jsfBean
    example.NameBean
    session

        name



              scopedAccessSpringBean
       de.mindmatters.faces.spring.SpringBeanScope
              session


    referencingBean
    example.ReferencingBean
    session

        referencedBean
        #{managedPropertyAccessSpringBean}


WEB-INF/applicationContext.xml (partial)

参考:
http://jsf-spring.sourceforge.net/   JSF-Spring,Spring相关项目官方站点,提供本文介绍的框架下载以及实例下载.
http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html 一篇关于JSF和Spring的文章.

LifeNote 2008-01-03 16:31 发表评论

博客搬家程序是如何实现的

LifeNote — Thu, 27 Dec 2007 08:28:00 GMT

如题，找有开发过这样功能的朋友介绍一下，是分析html代码么那比如sina 的和163的代码肯定不一样的那不是要写很多这样的程序疑惑中。。。

LifeNote 2007-12-27 16:28 发表评论