Perifort Pro.

给大伙儿preview一个有意思的东西

pf_miles — Thu, 29 May 2008 22:58:53 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/198473 发表时间: 2008年05月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

用了一段时间的seam，感觉seam有很多先进的思想值得发扬，但这段时间内我正一步一步地变得不喜欢JSF；因为它的组件开发很困难，还因为JSF本身许多已实现的组件——像richFaces或iceFaces——也有很多很多让人眼花缭乱的属性在使用的过程中需要学习，熟悉，感觉还是很麻烦，不如直接使用HTML和JS的知识来作view方便。
我在这里没有带任何感情色彩地针对JSF，我只是实话实说我认为的JSF的缺点；
并且，更重要的，我想让seam脱离JSF也能使用，而且因为比较着急，我从上个星期开始，就在抽时间做一件事情——Seam-Velocity；并且到现在，这个工具（我暂且叫它工具吧），已经能胜任大部分的seam-web开发工作了，虽然可能会有一些bug；seam手册自带的前几个例子是没问题的；
好了，说说这个seam-velocity到底是个什么东西吧：
它当然是一个抛弃JSF，转而使用velocity，用传统的HTML、JS来开发seam应用的东西，彻底替换seam中view的开发技术，算是个小小的表现层——控制层框架。

介绍一些大致的信息：

首先，请求处理流程：

那么，front-controller的代码骨架就差不多是这样：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
            IOException {
        /*
         * if value binding exists, update values in contexts, except
         * conversationId, 'action' param and converter setting params
         */
        
        this.updateValue(req, exList);

        // if action event exists, execute the action
        if (StringUtils.isNotEmpty(req.getParameter(FORM_ACTION_PARAM))) {

            // invoke action
            String target = this.doAction(req);

            // action invoke returned non-null value
            if (StringUtils.isNotEmpty(target)) {

                // need redirect, doing redirect
                if (target.startsWith(REDIRECT_PREFIX)) {
                    resp.sendRedirect(StringUtils.substringAfter(target, REDIRECT_PREFIX));
                    return;
                    // end request
                } else {
                    /*
                     * need no redirect, merge returned page and context vars,
                     * send out conversation id, write response
                     */
                    try {
                        this.mergeContextVarsAndConversationIdAndWriteResponse(target, req, resp);
                    } catch (Exception e) {
                        log.error(e);
                    }
                    return;
                    // end request
                }
            }

            /*
             * action invoke returned empty, doing the same as
             * 'no-action-event-request'
             */
        }

        /*
         * no action event, merge requesting page and context vars, send out
         * conversation id, write response.
         */
        String requestingPageVm = this.getRequestingPageVm(req);
        try {
            this.mergeContextVarsAndConversationIdAndWriteResponse(requestingPageVm, req, resp);
        } catch (Exception e) {
            log.error("Write response failed!");
            log.error(e);
        }
        return;
        // end request
    }

也就是在一个SeamVelocityController的Servlet中描述了上图中所画出的请求处理流程。

以及我简单实现的一个小例子，跟手册里的第一个例子——registration差不多：

这个例子的页面写起来就是这样——完全是velocity的页面，没有JSF：

#set($entries=$pullTool.pull("entries"))


  Seam Without JSF Demo
  


	#if(${cid})
		ConversationId: ${cid}
	#end
	
	Add new entry: 
	
		Entry Title:
		

		Entry Content:
		
		

		
	
	#if(${entries}&&${entries.size()}!=0)
		
    			#foreach(${e} in ${entries})
    				
				#end
				
			
				
					Id
				
				
					Title
				
				
					Action
				
			
			

    					
    						${e.id}
    					
    					
    						${e.title}
    					
    					
    						
    						
    					
    				

			
		
	#else
		There are no entries.
	#end

可以从页面源码里面看到，已经支持了表单值绑定、action方法提交、pullTool工具；

这个例子很简单，以后我会用它实现更多手册里的示例；
这个小框架的目标是保留seam的所有功能，但砍掉JSF；

对于这个表现层本身，这里列一下我想要让他支持的功能：
1)数据单向绑定，提交时更新
2)表单提交时，可执行action方法
3)提供“拉（pullTool）”工具，让velocity页面里也能写EL表达式从服务端“拉”数据
4）表单提交值转换(converter)，以及自定义converter
5）分模块开发，seam-velocity并不会因为失去了Facelets而失去了分页面模块开发的功能

以后可能会再增加；

目前在googleCode上的项目地址：http://code.google.com/p/seam-velocity/

svn中有一个毛坯实现，基本能用，不过可能会有一些bug；暂不提供release下载，还需成熟。

接下来这段时间要忙论文的事情，所以要等到7月初的时候我再来推这个项目；
也正好，在这段停滞时间中可以听听圈子里的意见，我相信还有人跟我有类似的想法，想用别的东西来代替JSF。

欢迎大家讨论，最好能多提点意见。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

小谈Java Enum的多态性

pf_miles — Sat, 26 Apr 2008 22:23:36 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/187155 发表时间: 2008年04月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Enum+多态，我没说错，不过Enum是不可以被继承的，也不可以继承自别人，只是能实现接口而已，何谈多态？
不过还是先看看“现象”吧：

public enum Fruit {
    APPLE, PEAR, PEACH, ORANGE;
}

以上是一个简单的enum,关于它，我要补充一点：
Fruit是java.lang.Enum的子类，准确地说，是Enum的子类，这里出现了一个继承关系，不过这个继承是编译器帮我们做的，我们不能显式地去做。不信的话我们可以试着用一个Enum的引用去指向一个APPLE，肯定是没问题的，我就不再试了。
为了更直观地说明这一点，我们来看看Fruit的反编译结果吧：

package test;


public final class Fruit extends Enum
{

    private Fruit(String s, int i)
    {
        super(s, i);
    }

    public static Fruit[] values()
    {
        Fruit afruit[];
        int i;
        Fruit afruit1[];
        System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i);
        return afruit1;
    }

    public static Fruit valueOf(String s)
    {
        return (Fruit)Enum.valueOf(test/Fruit, s);
    }

    public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;
    private static final Fruit ENUM$VALUES[];

    static 
    {
        APPLE = new Fruit("APPLE", 0);
        PEAR = new Fruit("PEAR", 1);
        PEACH = new Fruit("PEACH", 2);
        ORANGE = new Fruit("ORANGE", 3);
        ENUM$VALUES = (new Fruit[] {
            APPLE, PEAR, PEACH, ORANGE
        });
    }
}

注意这几行：

public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;

看来JDK Enum的实现也不过就是沿袭了Effective Java中提出的TypeSafeEnum模式，只不过是在编译器和JVM等更底层的级别上提供了支持。

至此，至少说明了Fruit和Enum的继承关系，但问题是：现在不能继续再从Fruit派生子类，那么哪来的多态呢？

还是再多写点代码吧：

public enum Fruit {
    APPLE {

        public void test() {
            System.out.println("I am an apple.");
        }
    },
    PEAR {

        public void test() {
            System.out.println("I am a pear.");
        }
    },
    PEACH {

        public void test() {
            System.out.println("I am a peach.");
        }
    },
    ORANGE;

    public void test() {
        System.out.println("I am a fruit.");
    }
}

其中，只有Orange没有Overide test()方法；
我们在主函数中调用它们：

public static void main(String[] args) {
        Fruit.APPLE.test();
        Fruit.PEAR.test();
        Fruit.PEACH.test();
        Fruit.ORANGE.test();
    }

输出结果：

引用

I am an apple.
I am a pear.
I am a peach.
I am a fruit.

可以看到，重新定义了test方法的APPLE,PEAR,PEACH覆盖了从父类继承过来的默认行为，而未从新定义test方法的ORANGE却沿袭了父类的行为，多态性在这里展现出来了。

那么我们刚才明明看见过Fruit的反编译结果，没有任何新类继承自Fruit，那么这些多态行为是哪里冒出来的呢？说它是“多态”是否准确呢？
其实，Fruit类在这个时候已经发生了微妙的变化，一切都与JDK的Enum的实现有关，我们现在可以到编译结果目录下面看看：

怎么除了Fruit.class之外，还多了几个貌似是内部类的class文件？？也许看到这里我们能有点线索了，不过还是在这个时候在看看反编译结果吧，看看它到底在搞什么鬼：

// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Fruit.java

package test;

import java.io.PrintStream;

public class Fruit extends Enum
{

    private Fruit(String s, int i)
    {
        super(s, i);
    }

    public void test()
    {
        System.out.println("I am a fruit.");
    }

    public static Fruit[] values()
    {
        Fruit afruit[];
        int i;
        Fruit afruit1[];
        System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i);
        return afruit1;
    }

    public static Fruit valueOf(String s)
    {
        return (Fruit)Enum.valueOf(test/Fruit, s);
    }

    Fruit(String s, int i, Fruit fruit)
    {
        this(s, i);
    }

    public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;
    private static final Fruit ENUM$VALUES[];

    static 
    {
        APPLE = new Fruit("APPLE", 0) {

            public void test()
            {
                System.out.println("I am an apple.");
            }

        };
        PEAR = new Fruit("PEAR", 1) {

            public void test()
            {
                System.out.println("I am a pear.");
            }

        };
        PEACH = new Fruit("PEACH", 2) {

            public void test()
            {
                System.out.println("I am a peach.");
            }

        };
        ORANGE = new Fruit("ORANGE", 3);
        ENUM$VALUES = (new Fruit[] {
            APPLE, PEAR, PEACH, ORANGE
        });
    }
}

注意这段代码：

static 
    {
        APPLE = new Fruit("APPLE", 0) {

            public void test()
            {
                System.out.println("I am an apple.");
            }

        };
        PEAR = new Fruit("PEAR", 1) {

            public void test()
            {
                System.out.println("I am a pear.");
            }

        };
        PEACH = new Fruit("PEACH", 2) {

            public void test()
            {
                System.out.println("I am a peach.");
            }

        };
        ORANGE = new Fruit("ORANGE", 3);

这个时候的APPLE，PEAR，PEACH已经以匿名内部类的方式对Fruit进行了Overide，自然体现出了多态，多出的那三个疑似内部类的class文件也就是它们！而ORANGE，没有重写test方法，仍然以一个Fruit实例的形式出现。

关于Enum为什么会有多态大概也就这么点猫腻了，那我们来考虑一下它有多大价值吧？

我们或许可以利用这一点来改造Strategy模式，传统的Strategy会产生出稍微多一些的父类、子类，而如果用Enum的话，“一个类”（对程序作者来讲）就能搞定，能简化一下类层次，再说了，用枚举来表示区分各种不同策略也是很合情理的，所以，Java Enum的这点小小特性感觉还是比较有前途发挥一些作用的，起码在代码组织上；
更多应用可能或是局限性就还需要逐步在实际应用中摸索。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Jboss Seam, mysql中文乱码问题4步骤总结

pf_miles — Sun, 20 Apr 2008 22:54:46 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/184665 发表时间: 2008年04月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

其实以下总结适合于任何hibernate+mysql的情况；

步骤1：在创建数据库Schema的时候请指定编码，例如mysql，就用这样的语句来建立Schema:

create schema xxxx default character set utf8;

这一步必须这样，因为至少我在网上还没找到hbm2ddl的配置方法使得hibernate生成的数据库表的编码能被指定，那么为schema设置一个默认的编码就是最简便的方法；当然，你也可以不在schema上设置默认编码，等到hibernate生成表之后，在一个一个表地去改编码。具体可查阅数据库帮助文档。

“步骤1”得不到确认的话，下面的步骤可以忽略；

步骤2：在工程中的每一个页面，设置meta信息

这个不多解释了，设置了这个后，起码你的页面能“容得下”中文了。这一步建议在模板技术里解决，在最外层的模板里加上这个meta就行了，不用每个页面都加。

至此，你会发现直接写死在页面上的中文没问题；直接用数据库管理客户端的console插入的中文也没问题；就是经由程序插入的中文数据有问题；那么：

步骤3：指定数据库连接url的参数，例：

jdbc:mysql://localhost:3306/data115?useUnicode=true&amp;characterEncoding=utf-8

这样，经由程序插入的数据应该也能行了。

最后，有时候需要用GET方式在url的参数里传中文，url里的中文是需要被编码之后才能传的，像tomcat默认的uriEncoding是iso-8859-1，这会导致经由url传过来的中文值变乱码；这就需要在server.xml的connector节点里配置“URIEncoding='UTF-8'”，例如：

我这个是jboss的，server.xml位置在deploy/jboss-web.deployer下，tomcat的话很好找了，配置起来都一样。

最最后，你是不是认为还有一招“filter”的方式？以前用过一段时间struts的时候filter很管用，但现在我在seam下试验过后发觉有没有这个filter都没关系，只要确认上述4步骤那么乱码应该就能解决了；我估计如果框架程序里没有硬编码使用非UTF-8的字符集来encode的话都用不着filter.
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

李连杰在淘宝

pf_miles — Mon, 10 Mar 2008 21:02:01 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/169974 发表时间: 2008年03月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

李连杰和马云：

附：2007华人明星年收入排行榜（元）

　　1李连杰4.65亿

　　2成龙4.28亿

　　3张学友3亿

　　4梁朝伟2.9亿

　　5刘德华2.3亿

　　6周润发1亿

　　7杨紫琼8000万

　　8章子怡6500万

　　9S.H.E6250万

　　10周杰伦6000万
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Do what the fuck you want to!

pf_miles — Fri, 18 Jan 2008 16:59:26 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/157380 发表时间: 2008年01月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

这可能是世界上最自由的开源软件协议:
The license text:

引用

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
Version 2, December 2004

Copyright (C) 2004 Sam Hocevar
14 rue de Plaisance, 75014 Paris, France
Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. You just DO WHAT THE FUCK YOU WANT TO.

详见:http://sam.zoy.org/wtfpl/
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Perizone project started.

pf_miles — Tue, 11 Dec 2007 01:08:30 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/147437 发表时间: 2007年12月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

"This is a professional, web-based simulator of the game of Pokemon..."

I just started a project named Perizone on google code. My ultimate aim is to bring PMs into reality, and the web based Perizone project would be a very important step.
How could it be 'reality'? Err...it's not the time to talk about that, let me keep a little secret~
Any how, you can get detailed infomation and keep track of the progress of Perizone on the project's main page.

BTW, this newly created category will be the weblog page of Perizone.

我在google code上启动了一个名叫Perizone的项目。我的最终目标是将PM带到现实生活中来, 这次的基于web的Perizone项目将是非常重要的一步。
怎样才叫做“现实中”? 呃...现在还不是讨论那个的时候，请让我保留一点小秘密吧:D
总之，大家现在可以到Perizone的主页上获取更详细的信息并关注本项目的进展了。

另外，本博客新建立的本栏目将主要记录一些perizone项目进行过程中的一些重要事件。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

其实Annotation这样就美了...

pf_miles — Sun, 09 Dec 2007 19:53:57 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/147093 发表时间: 2007年12月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

是的，annotation的出现减少了繁杂的配置文件，将那些原本可能是runtimeException的东西扼杀在了编译期。
不过最近在考虑一个小项目的时候发现想要用它来完全代替传统的配置文件还很困难。
首先，它无疑使得代码变得难看，这一点不用多说了；
其次，它不支持多份配置：
因为annotation怎么说也是直接写在代码里的，写在类的定义里的。也就是说一个类也就只能对应一套annotation。那么遇到这种情况：我想初始化同一个类的很多个对象作为prototype或者说单例的共享对象，我要求这些对象虽然是同种类型、拥有同样的行为，但要包含不同的数据。我在项目中遇到这样配置要求的话目前的annotation根本无法满足，还得使用传统的“配置”。

上面说的只是“对象”层次的“多份配置”，或许有人认为这本来就不该是annotation的工作，所以不怎么有说服力。但是我仍然相信存在真正的“类”层次的“多份配置”的需求的：比如你想对同一个类做出同种类型但不同实例的代理呢？显然靠annotation是不行的。

那么，我有一个想法：为什么不把annotation“抽出来”呢？也就是把annotation从Java源码里面搬到一个专门的文件里。我们也许会觉得“这跟‘配置文件’有什么不同？”，但我觉得如果这成为Java的规范的话，它完全可以提供编译器的支持，把这些独立出来的文件当成那些java类文件的延伸，编译的时候还是作为一个整体处理...这样的话它既有了annotation的优势，又能像传统配置文件一样强大，就更美了。

另外，我也不是故意要将annotation用传统的配置文件的标准来衡量。其实依现在的annotation来看，它的目标并不是作为传统配置文件的替代品。它只是想让大家把那些“不至于”或者说根本不应该放在配置文件里的东西放到它里面来，可以缓解滥用配置文件的情况。但该“配置”的地方还是要配置，传统配置文件的作用在很多情况下仍然无可替代。

当然，我想如果annotation真的迈出这一步，那么它就真的能很大程度上替代传统配置文件了。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

一个有趣的配色方案在线生成工具

pf_miles — Mon, 26 Nov 2007 13:19:00 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/143603 发表时间: 2007年11月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

"The color wizard lets you submit your own base color, and it automatically returns matching colors for the one you selected. "

它能够将你提供的基础颜色在色调,饱和度,明暗方面做出搭配, 同时也给出好几套基于你给定的颜色的配色方案, 你可以选择基于互补色,或是相似的颜色等等来生成你的配色方案. 如果你连基础颜色都不想自己决定,那么这个工具自带的random功能会随机为你生成一种配色方案.

整个过程不需要什么配色原理理论知识,一下就能搞定:

http://www.colorsontheweb.com/colorwizard.asp#wizard

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

自由访问wikipedia的一个折衷方案

pf_miles — Tue, 20 Nov 2007 10:06:37 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/141942 发表时间: 2007年11月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

即"双浏览器"的方法.一个浏览器用来正常上网,而另一个设置专门的代理,专门用来访问wikipedia.我这样用得很满意:

到http://www.proxycn.com/html_proxy/30fastproxy-1.html上随便记一个国外的ip+端口号,然后在浏览器里设置它为代理,比如我在windows下平时用IE上网,我专门用火狐设置:工具->选项->网络->设置,点选"手动配置代理,"把刚才记的ip+端口号设置成http代理.这样就可以用火狐专门访问wikipedia,用IE上别的网了.

当然也可以使用其它浏览器搭配.

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

将由BeanUtils的getProperty方法返回的Date对象的字符串表示还原为对象

pf_miles — Sun, 04 Nov 2007 09:16:25 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/137910 发表时间: 2007年11月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

现象描述:

打算将由BeanUtils的getProperty方法返回的Date类型的字符串表示重新通过SimpleDateFormat转换成Date类型的对象老是失败,抛ParseException异常.

分析:

调用commons项目里的BeanUtils对象里的getProperty方法返回某个对象中的Date类型的成员变量.BeanUtil中对getProperty方法的描述如下:

Return the value of the specified property of the specified bean, no matter which property reference format is used, as a String.

也就是说,无论这个成员变量的类型是什么,经由getProperty方法返回的值都将是一个字符串.

如果这个成员变量的类型是java.util.Date,那么BeanUtils会调用一个专门为Date类型准备的converter来对这个Date进行转换,其实最终是调用了Date的toString方法.

在某些特殊的时候,我们需要将这个字符串表示的Date还原成真正的Date类,以备后用.

如果抛出异常,则肯定是由于转换格式的不匹配造成的.

解决过程及成果:

查阅JDK的manual,找到Date类的toString方法,其中描述说所有的Date类都将被转换成形如"dow mon dd hh:mm:ss zzz yyyy"的形式,"dow,mon"是什么?从表面上看,似乎是"E"和"MMM",由debug的跟踪结果来看,确实像是"E MMM dd hh:mm:ss zzz yyyy".

但是,以上述的格式对字符串进行转换,照样出错.没办法,直接冲入JDK源码,查看Date类的toString方法:

public String toString() {
// "EEE MMM dd HH:mm:ss zzz yyyy";
BaseCalendar.Date date = normalize();
StringBuilder sb = new StringBuilder(28);
int index = date.getDayOfWeek();
if (index == gcal.SUNDAY) {
index = 8;
}
convertToAbbr(sb, wtb[index]).append(' '); // EEE
convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' '); // MMM
CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 2).append(' '); // dd

CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');   // HH
CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm
CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss
TimeZone zi = date.getZone();
if (zi != null) {
     sb.append(zi.getDisplayName(date.isDaylightTime(), zi.SHORT, Locale.US)); // zzz
} else {
     sb.append("GMT");
}
sb.append(' ').append(date.getYear()); // yyyy
return sb.toString();
    }

这一眼就看出它的日期格式确实是用的"EEE MMM dd HH:mm:ss zzz yyyy"(都不用读代码,人家注释里直接告诉你了),这么说我最初判断它的格式字符串并没有错,确实是"E MMM dd hh:mm:ss zzz yyyy"(E的个数在1-3之间是没有区别的),那么到底问题在哪呢?

没办法,那么干脆照着"E MMM dd hh:mm:ss zzz yyyy"的格式,亲手把一个Date对象转换一下,看看出来是什么样子:

public static void main(String args[]) {
  Calendar c = Calendar.getInstance();
  SimpleDateFormat format = new SimpleDateFormat("E MMM dd hh:mm:ss z yyyy");
  System.out.println(format.format(c.getTime()));
}

输出结果:"星期日十一月 04 05:03:52 CST 2007"

好了,至此,可以恍然大悟了.原来是因为我们是中国人,身在中国,Java库的开发人员十分体贴我们,充满人性关怀地将SimpleDateFormat类使用的Locale默认成了我们所在位置的Locale,输出了符合我们中国人习惯的日期表示方式.然而,却没有在Date的toString方法里做同样的人性化设定,toString方法一律输出美国的时间字符串格式"Sun Nov 04 17:10:26 CST 2007".无奈中美语言不通,这样你来我往转换一个回合,不出错才叫怪了.

解决方法很简单,就是在构造SimpleDateFormat对象时使用两个参数的构造函数,将Locale指定为US,就可以了:

SimpleDateFormat format = new SimpleDateFormat("E MMM dd hh:mm:ss z yyyy", Locale.US);

完结.

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

ABC's of Life

pf_miles — Wed, 29 Aug 2007 01:17:25 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/118132 发表时间: 2007年08月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

To Achieve Your Dreams Remember Your ABC's

A-void negative sources, people, places, things and habits
B-elieve in yourself
C-onsider things from every angle
D-on't give up and don't give in
E-njoy life today, yesterday is gone and tomorrow may never come
F-amily and friends are hidden treasures, seek them and enjoy their
 riches
G-ive more than you planned to
H-ang on to your dreams
I-gnore those who try to discourage you
J-ust do it
K-eep trying no matter how hard it seems it will get easier
L-ove yourself first and most
M-ake it happen
N-ever lie, cheat or steal, always strike a fair deal 
O-pen your eyes and see things as they really are
P-ractice makes perfect
Q-uitters never win and winners never quit
R-ead study and learn about everything important in your life
S-top procrastinating
T-ake control of your own destiny
U-nderstand yourself in order to better understand others
V-isualize it
W-ant it more than anything
X-cellerate your efforts
Y-ou are unique of all God's creations nothing can replace you
Z-ero in on your target and go for it !

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

经历0分的洗礼，该死的6级终于结束了

pf_miles — Sat, 18 Aug 2007 07:06:44 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/113967 发表时间: 2007年08月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天四六级终于能查分了，522，过了。然我郁闷了好久的0分噩梦终于结束了。这是第二次考了，第一次考估分很高，但没想到下来是0分；这回没复习，也不如上次顺手，但总算结束了。

该死的考试，无聊的考试，但不考有那么令人不甘心，那么多人往里面扑，似乎没有那张薄薄的纸片就少了点什么似的。

要的不是形式，要的是能力，英语对我们专业的人是何其重要，这种形式化的东西早该废除了，眼看那么多同学为了它而浪费时间真是痛心。

学以致用才是真，形式主义是妖道。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

她太NB了，我承认她是御宅族的战士，但这句话也太NB了...

pf_miles — Mon, 06 Aug 2007 15:54:41 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/109555 发表时间: 2007年08月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

其实我玩了7年的口袋妖怪也才达到这个水平哦，而且只是中文名和部分英文名...日语实在不好。

PS:我想掐死她！除非她穿圣诞老人装给我看让我高兴高兴萌一回～

嗯，至少要把她头上那根蠢毛给拔掉！

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

SCJP 310-055 84%通过

pf_miles — Wed, 04 Jul 2007 14:40:09 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/97924 发表时间: 2007年07月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

DO NOT LOSE THIS REPORT

Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 Examination Score Report

CANDIDATE: YUE WEN

ADDRESS: YUNDING BLDG NO 24-2-4

WENCUI RD HEPING DIST

SHENYANG, 110004

CANDIDATE ID:SR2752976 DATE:July 04, 2007

REGISTRATION NUMBER:OF7SYD5221 SITE NUMBER:CN91U

EXAM:Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0

SERIES:055

Exam Results

Your percentage score was determined by taking the overall number of correct answers divided by the total number of questions.

There are 72 questions in this exam. You answered 61 questions correctly whitch gives you a score of 84%.

PASSING SCORE:59% YOUR SCORE:84% TEST STATUS:Pass

Assessment Section

This report shows the percentage of items in each section you answered correctly for the Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 exam. The following information is provided to give you feedback on your relative strengths on a per section basis.

SectionAnalysis Score %

Declarations, Initialization and Scoping.......................................100%

Flow Control...................................................................100%

API Contents...................................................................80%

Concurrency....................................................................50%

OO Concepts....................................................................100%

Collections / Generics.........................................................90%

Fundamentals...................................................................63%

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Jakarta Commons使用总结

pf_miles — Sun, 01 Jul 2007 15:03:52 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/96577 发表时间: 2007年07月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

浏览了一下《Jakarta Commons Cookbook》（Timothy M. O'Brien）。里面介绍了commons各子项目提供的各种实用类，大致浏览了一遍，做个总结，以后遇到相同的问题可以到commons里去寻找答案。

以下列出一些我认为比较有价值的功能，方便以后参考：

lang：

1）反射地生成hashcode、equals、toString方法。

2）反转数组

3）在数组中搜索指定项，并可设置起始位置

4）线程安全地使用日期格式化

5）验证方法参数的合法性

6）为程序计时

lang.StringUtils、WordUtils:

1）检查空字符串

2）省略字符串，可指定缩减位置

3）搜寻被嵌套的字符串，解析字符串

4）自定义要消除的字符，并执行操作

5）去掉串尾的换行符和回车符

6）反转字符串

7）以单词为单位反转字符串

8）设定一行的显示单词数量，且不破坏单词

9）检测字串内容（数字？字符？空格？混合？）

10）非海量文本中统计单词出现次数

11）计算字符串差别（差别字符，位置，编辑距离）

codec：12）计算字符串的soundex编码（语音编码）

beanUtils、propertyUtils

1）对某个bean的属性反射地访问、检查类型或设置或复制或克隆或检查可访问性，包括简单的、带下标的或Map型的属性

2）用Predicate验证bean

3）用map封装bean属性

4）动态创建bean

collections.comparators，beanUtils

1）将comparator链接为comparatorChain

2）以固定顺序比较（如“冠军”、“亚军”、“季军”）

3）使用predicate模拟电路的门逻辑

4）用transformer和closure封装对对象的操作，并可创建transformer链或closure链以及有条件的closure（commons functor项目中的UnaryFunction和UnaryProcedure对象可代替它们）

5）使用loopingIterator实现循环遍历

6）结合Predicate和FilterIterator筛选地遍历集合

7）使用Bag，一个维护对象数量或顺序的仿collection

8）使用MultiMap可将一个键对应到多个值上

9）使用BidiMap，根据值检索相应的键

10）使用LRUMap作为缓存

11）使用LazyMap直到检索时才加载相应的项

除了以上列出的功能外，commons还提供Digester包和BetWixt包来实现xml文件和java对象之间的映射和序列化功能；

CLI项目用来解析命令行参数；

Configuration项目用来读取property文件形式或xml形式的程序配置文件；

Math项目用来进行一些科学计算，涉及分数、复数运算、线性方程求解、求相关性等；

FreeMarker和Velocity提供两种可选的模板技术；

IO项目提供文件操作和流操作的一些便利，过滤文件等；

ORO项目专门处理正则表达式；

Net项目实现简单的FTP和mail客户端；

HttpClient项目处理对Http协议的编程；

Slide处理WebDEV协议的编程；

JXPath实现了xPath查询，用于查询xml节点和对象图等；

Lucene，一个高效的文本搜索实现。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

I've never missed my aims!

pf_miles — Tue, 26 Jun 2007 06:27:05 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/94437 发表时间: 2007年06月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最难搞的日文考试结束，接下来该进行课程实践了。

我们打算将这次的学院项目作为我们4人的课程设计来上交。

计划7月15号之前回家，之前有这个项目和scjp的考试，看来时间很紧，不过一定要拿下！

六级考试也结束了，上网估分，我不求多高的分数，只希望能得到一个真实地反应我水平的分数！别TM的再来0分了，分也不让查，四六级办公室的那帮傻X，对考生非常之不负责！不出意外就是万幸！多么颓废的想法！不过没办法，面对的就是颓废的东西。哦对了，最近我很讨厌说“没办法”这三个字——这次要再是出上次那种意外我不考6级了，两次够多了，已经感觉委屈得不得了，不会再考第三次了。水平摆在那里，还差它个证书么？

项目负责的同学又跟老师交流过了，得到两个很蹊跷的消息：

1）学院的老师队伍准备架设一个掌管全学院所有事务的巨型系统(感觉上像是ERP)，计划9月份动工。这个系统将包括我们现在这个项目的所有功能。这让我感觉现在让我们做的这个东西岂不是有点浪费？或者说学院估计那个类ERP项目要很久才能做完（老师队伍的效率通常不怎么高，其实这件事情开学初就有所耳闻，但现在还没动工），所以才叫我们做这个功能重复的项目暂时用上？总之，若是学院老师他们做成了那个系统，我们的这个系统将被并进去，或者干脆被取代。嗯，不过，这似乎我管不着了，那时候我早走了。

2）课程设计开始，所有班的所有同学都在找项目，11班的某某找到负责的老师，问他有没有项目可作为课程设计。那个老师干脆就把我们团队撰写的那份完整的需求文档给了他们说“那你们就做做这个吧”。也就是说，现在除了我们，11班还有一个团队在做这个项目，虽然他们的目的只是交差一个课程设计，但我比较反感老师把需求文档给了他们的做法，就算这份文档的所有权属于学院。虽然说最后真正上线运行的是我们做的系统，但我潜意识中仍然有“竞争”这个念头，我们要做得比11班的强（这是当然的，这个不足为惧），还要比老师队伍计划中的那个系统的这部分功能强，关键是用户体验上。

这个系统到底能运行多久取决于学院，不知道学院怎么打算的，我只是想实践动手，培养我们班的实践能力，并不是缺那少得可怜的1千来块钱，给自己人做东西有些事情是要忍一忍的。

不多说了，接下来拿出实际的东西来。目标的明确加上一点奉献精神，就一定能完成计划。

可怜的猎物只有哭的份，'cause I've never missed my aims.

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

企业应用开发分层原则

pf_miles — Tue, 29 May 2007 14:59:18 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/84609 发表时间: 2007年05月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

有什么标准足以不惜复杂度的增加让在系统中多出一个层次来呢？大概分为以下三个标准：

1）该层次是否具有重用的价值

2）独立一个层次就意味着保留了某种扩展性

3）有时候可能还为了明确一种依赖关系

嗯！暂时就这些，金玉良言，呵呵～写给自己看的，怕自己忘，做个笔记，不多解释了。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

为什么java要用checkedExceptions，精彩的争论

pf_miles — Sat, 26 May 2007 05:45:33 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/83434 发表时间: 2007年05月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

http://www.javaeye.com/topic/2038

这是javaeye论坛上的文章，比较老了，但看完后仍然感触很大，对进一步建立OO思想很有帮助，值得一看。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

iBatis学习笔记（映射文件小结）

pf_miles — Wed, 23 May 2007 12:23:52 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/82348 发表时间: 2007年05月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

映射文件总体形式：

PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"

"http://ibatis.apache.org/dtd/sql-map-2.dtd">

映射的查询语句形式：

id=”statementName”

[parameterClass=”some.class.Name”]

[resultClass=”some.class.Name”]

[parameterMap=”nameOfParameterMap”]

[resultMap=”nameOfResultMap”]

[cacheModel=”nameOfCache”]

[timeout=“5”]>

select * from PRODUCT where PRD_ID = [?|#propertyName#]

order by [$simpleDynamic$]

insert into PRODUCT (PRD_ID, PRD_DESCRIPTION) values (1, “Shih Tzu”)

下面的表格说明了所有支持的查询语句形式及其属性：

可定义SQL Fragments对部分SQL语句进行复用：

FROM items

WHERE parentid = 6

对某些数据库的自动增长键有支持，但不同的支持策略，例：

SELECT STOCKIDSEQUENCE.NEXTVAL AS ID FROM DUAL

insert into PRODUCT (PRD_ID,PRD_DESCRIPTION)

values (#id#,#description#)

insert into PRODUCT (PRD_DESCRIPTION)

values (#description#)

SELECT @@IDENTITY AS ID

更具体内容参见帮助文档。

存储过程：

{call swap_email_address (?, ?)}

存储过程影响数据库表，同时也影响参数对象，mode若是INOUT或OUT，参数对象会被改变，否则不改变。

对于映射查询，iBatis建议：参数使用inline-parameter，也就是parameterClass(不是parameterMap)，而结果使用resultMap（不是resultClass）。

parameterMap格式：

[nullValue=“-9999”]

[typeName=”{REF or user-defined type}”]

[resultMap=someResultMap]

[mode=IN|OUT|INOUT]

[typeHandler=someTypeHandler]

[numericScale=2]/>

resultMap格式：

[extends=”parent-resultMap”]

[groupBy=“some property list”]>

[columnIndex=”1”] [javaType=”int”] [jdbcType=”NUMERIC”]

[nullValue=”-999999”] [select=”someOtherStatement”]

[resultMap=“someOtherResultMap”]

[typeHandler=“com.mydomain.MyTypehandler”]

java.util.Map接口的实现类也可作为parameterMap或resultMap的class。

复杂查询：

N+1查询（结合cache的话会比连接查询好，没有cache很糟）：

PRD_CAT_ID” select=”getCategory”/>

连接查询（iBatis解决复杂查询的通常方式，但有cache时候可能不如N+1查询）：

CAT_ID” />

CAT_DESCRIPTION” />

或者：

CAT_ID” />

CAT_DESCRIPTION” />

复杂集合查询：

N+1法：

CAT_ID” select=” getProductsByCatId”/>

groupBy法：

注：groupBy属性不能和queryForPaginatedList()调用同时使用。

N+1查询中的符合查询：

…

{itemId=ORD_ID, custId=ORD_CST_ID}”

select=”getOrderPayments”/>

数据类型表：

自定义TypeHandler:

public class YesNoBoolTypeHandlerCallback implements TypeHandlerCallback {

private static final String YES = "Y";

private static final String NO = "N";

public Object getResult(ResultGetter getter)

throws SQLException {

String s = getter.getString();

if (YES.equalsIgnoreCase(s)) {

return new Boolean (true);

} else if (NO.equalsIgnoreCase(s)) {

return new Boolean (false);

} else {

throw new SQLException (

"Unexpected value " + s + " found where " + YES + " or " + NO + " was expected.");

}

public void setParameter(ParameterSetter setter, Object parameter)

throws SQLException {

boolean b = ((Boolean)parameter).booleanValue();

if (b) {

setter.setString(YES);

} else {

setter.setString(NO);

}

public Object valueOf(String s) {

if (YES.equalsIgnoreCase(s)) {

return new Boolean (true);

} else {

return new Boolean (false);

}

然后在sqlMapConfig文件里加上如下配置：

javaType="boolean"

jdbcType=”VARCHAR”

callback="org.apache.ibatis.sqlmap.extensions.YesNoBoolTypeHandlerCallback"/>

缓存设置：

Readonly属性默认为true，但若想要在返回的对象上做更改的话，设为false。

Serialize属性设置为false后，该cache为全局共享cache，这种cache不能是readOnly的（因为没意义）。

Cache的种类：

MEMORY——java特殊引用类实现的cache

所有的referencetype：

LRU——最少使用算法的cache:

FIFO——先进先出算法的cache：

OSCACHE——插件cache，opensymphony的cache实现，参见：http://www.opensymphony.com/oscache/

构造动态SQL语句：

元素：总的包含元素，并提供最外层的开头预设字、开始字符串和结束字符串。

prepend – 加在本体前面的预设字符 (可选)

open – 标识本体开始的开始字符串(可选)

close – 标识本题结束的结束字符串 (可选)

dynamic元素的removeFirstPrepend属性是强制的，所以它的第一个子元素的prepend字符串在生成语句的时候总是会被取消掉。

二元操作标记：

检查一个属性和一个给定值或另一个属性是否相等。

检查一个属性和一个给定值或另一个属性是否不相等。

检查一个属性是否大于一个给定值或另一个属性。

检查一个属性是否大于或等于一个给定值或另一个属性。

检查一个属性是否小于一个给定值或另一个属性。

检查一个属性是否小于或等于一个给定值或另一个属性。

属性：

prepend – the overridable SQL part that will be prepended to the statement (optional)

property – the property to be compared (required)

compareProperty – the other property to be compared (required or compareValue)

compareValue – the value to be compared (required or compareProperty)

removeFirstPrepend – removes the prepend of the first nested content producing tag (true|false, optional)

open – the string with which to open the entire resulting body content (optional)

close – the string with which to close the entire resulting body content (optional)

举例：

ADOLESCENT = ‘TRUE’

一元判断标记：

Checks if a property is available (i.e is a property of the parameter bean)

Checks if a property is unavailable (i.e not a property of the parameter bean)

Checks if a property is null.

Checks if a property is not null.

Checks to see if the value of a Collection, String or String.valueOf() property

is null or empty (“” or size() < 1).

Checks to see if the value of a Collection, String or String.valueOf() property

is not null and not empty (“” or size() < 1).

属性：

prepend – the overridable SQL part that will be prepended to the statement (optional)

property – the property to be checked (required)

removeFirstPrepend – removes the prepend of the first nested content producing tag (true|false, optional)

open – the string with which to open the entire resulting body content (optional)

close – the string with which to close the entire resulting body content (optional)

举例：

FIRST_NAME=#firstName#

其它标记：

Checks to see if the parameter object is present (not null).

Checks to see if the parameter object is not present (null).

属性：

prepend – the overridable SQL part that will be prepended to the statement (optional)

removeFirstPrepend – removes the prepend of the first nested content producing tag (true|false, optional)

open – the string with which to open the entire resulting body content (optional)

close – the string with which to close the entire resulting body content (optional)

举例：

EMPLOYEE_TYPE = ‘DEFAULT’

Iterates over a property that is an implementation java.util.Collection, or

java.util.Iterator, or is an array.

例：

open=”(” close=”)” conjunction=”OR”>

username=#userNameList[]#

当集合类单独被当作参数传进此查询时，也可以这么写：

username=#[]#

也可以像这样选择集合中对象的属性：

open=”(” close=”)” conjunction=”OR”>

firstname=#userList[].firstName# and

lastname=#userList[].lastName#

该标签还可以自己嵌套：

(

conjunction="and">

$orConditions[].conditions[].condition$

#orConditions[].conditions[].value#

)

若只是想生成一些简单的动态sql语句，这样写就可以：

注意“$”，不是“#”，这是和为preparedStatement赋值的普通属性的取得的不同之处。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

iBatis学习笔记（配置文件小结）

pf_miles — Tue, 22 May 2007 05:06:29 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/82020 发表时间: 2007年05月22日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

iBatis学习笔记：（versions 2.2.0 and higher）

配置文件SqlMapConfig.xml：

PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"

"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

cacheModelsEnabled="true"

enhancementEnabled="true"

lazyLoadingEnabled="true"

maxRequests="128"

maxSessions="10"

maxTransactions="5"

useStatementNamespaces="false"

defaultStatementTimeout="5"

statementCachingEnabled="true"

classInfoCacheEnabled="true"

其中：

元素指定了一个标准java properties文件的位置，用classpath相对位置或URL形式指定，之后整个配置文件以及所有被包含进来的映射文件都可以用${key}形式的占位符来获取properties文件中的value值。

元素：

设置一些全局属性，如延迟加载、缓存模式等。

所有可设置属性及其说明如下：

maxRequests This is the maximum number of threads that can execute an SQL

statement at a time. Threads beyond the set value will be blocked until

another thread completes execution. Different DBMS have different

limits, but no database is without these limits. This should usually be at

least 10 times maxTransactions (see below) and should always be greater

than both maxSessions and maxTransactions. Often reducing the

maximum number of concurrent requests can increase performance.

Example: maxRequests=”256”

Default: 512

maxSessions This is the number of sessions (or clients) that can be active at a given

time. A session is either an explicit session, requested

programmatically, or it is automatic whenever a thread makes use of an

SqlMapClient instance (e.g. executes a statement etc.). This should

always be greater than or equal to maxTransactions and less than

maxRequests. Reducing the maximum number of concurrent sessions

can reduce the overall memory footprint.

Example: maxSessions=”64”

Default: 128

maxTransactions This is the maximum number of threads that can enter

SqlMapClient.startTransaction() at a time. Threads beyond the set value

will be blocked until another thread exits. Different DBMS have

different limits, but no database is without these limits. This value

should always be less than or equal to maxSessions and always much

less than maxRequests. Often reducing the maximum number of

concurrent transactions can increase performance.

Example: maxTransactions=”16”

Default: 32

cacheModelsEnabled This setting globally enables or disables all cache models for an

SqlMapClient. This can come in handy for debugging.

Example: cacheModelsEnabled=”true”

Default: true (enabled)

lazyLoadingEnabled This setting globally enables or disables all lazy loading for an

SqlMapClient. This can come in handy for debugging.

Example: lazyLoadingEnabled=”true”

Default: true (enabled)

enhancementEnabled This setting enables runtime bytecode enhancement to facilitate

optimized JavaBean property access as well as enhanced lazy loading.

Example: enhancementEnabled=”true”

Default: false (disabled)

useStatementNamespaces With this setting enabled, you must always refer to mapped statements

by their fully qualified name, which is the combination of the sqlMap

name and the statement name. For example:

queryForObject(“sqlMapName.statementName”);

Example: useStatementNamespaces=”false”

Default: false (disabled)

defaultStatementTimeout (iBATIS versions 2.2.0 and later)

This setting is an integer value that will be applied as the JDBC query

timeout for all statements. This value can be overridden with the

“statement” attribute of any mapped statement. If not specified, no

query timeout will be set unless specified on the “statement” attribute of

a mapped statement. The specified value is the number of seconds the

driver will wait for a statement to finish. Note that not all drivers

support this setting.

classInfoCacheEnabled With this setting enabled, iBATIS will maintain a cache of introspected

classes. This will lead to a significant reduction in startup time if many

classes are reused.

Example: classInfoCacheEnabled=“true”

Default: true (enabled)

statementCachingEnabled (iBATIS versions 2.3.0 and later)

With this setting enabled, iBATIS will maintain a local cache of

prepared statements. This can lead to significant performance

improvements.

Example: statementCachingEnabled=“true”

Default: true (enabled)

元素：

指定对象生成工厂类，用于将查询结果封装成对象返回。这是可选设置，若不指定，ibatis将使用Class.newInstance()的方式生成查询结果类。对象工厂类必须实现com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory接口。

元素：

用来为一些亢长的类名起“别名”，例如：

以后就能用“shortname”来取代“com.long.class.path.Class”了。

除了自己定义别名外，iBatis框架预先定义了一些别名，以方便使用，他们是：

Transaction Manager Aliases：

JDBC com.ibatis.sqlmap.engine.transaction.jdbc.JdbcTransactionConfig

JTA com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig

EXTERNAL com.ibatis.sqlmap.engine.transaction.external.ExternalTransactionConfig

Data Source Factory Aliases：

SIMPLE com.ibatis.sqlmap.engine.datasource.SimpleDataSourceFactory

DBCP com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory

JNDI com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory

元素：

设置事务类型和元素，如上文所说，预定义的事务类型有JDBC, JTA, EXTERNAL；数据源类型有SIMPLE, DBCP, JNDI；若指定EXTERNAL或JTA，那就还有额外的属性需要设置：

元素：

在transactionManager元素中，定义数据源。预定义三种数据源工厂：SIMPLE, DBCP, JNDI，不过也可以自己写一个。

SIMPLE:在没有容器数据源支持的情况下使用的最简单的数据源实现，具体设置见刚才的例子。

DBCP:使用apache的DBCP数据源，ibatis框架对其直接提供支持，设置方法如下：

所有的设置属性请参考：http://jakarta.apache.org/commons/dbcp/configuration.html

注：以‘Driver.’开头的属性会被加入到JDBC的属性中（有些JDBC需要）。

JNDI:指定配置的JNDI数据源。设置格式：

上面只是使用普通的JDBC事务，但通常设置JNDI数据源更愿意用JTA全局事务：

元素：

用来包含SQL映射文件或另一个配置文件，以classpath或URL的形式：

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

学院项目的架构设计图&近期任务计划说明

pf_miles — Sat, 19 May 2007 15:58:50 +0800

作者: pf_miles 链接：http://pf-miles.javaeye.com/blog/81236 发表时间: 2007年05月19日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

考试告一段落，该忙乎院长交与的项目了。《学生信息管理系统》，准备用struts+iBatis+spring构建，今天算是考完试后小组的第一次开会，交代了近两个星期内的任务。我立刻将结构的想法画成简图，以及计划建议交给组长和各组员。以下是结构设计简图，精彩的工作由这里开始：

接下来是半个月左右的计划：
下星期完成数据层到服务层的详细类图，其间我将确定後的实体类图交与邓飞，让他们建表。
再下个星期开会+培训後组织第一阶段的编码，我打算这样的：首先我来建立工程，建立好包结构和服务层的所有接口、添加好所有需要的库，也就是搭个骨架。然后我将工程文件夹、开发工具（Eclipse）、JDK安装文件（统一JDK也很重要）、数据库一并打包传给每个参加编码的人。之后开始分配任务从右至左编码：从Sql查询语句开始至FacadeManagerImp类结束算是完成了这个阶段的任务，其间要注意代码同步，我担心subversion我们都没经验，硬要用上也不见得是好事。所以我觉得要避免代码版本冲突就要严格划分任务区域，各司其职就没事了。可以考虑在某个FTP中为每个人都指定一个代码文件夹，谁有新版本的代码就传到属于他自己的文件夹里，并放上一个名字为更新日期的文本文档，这样我们每隔一段时间就上这个FTP，去每个人的文件夹里下载最新的代码到本地覆盖就可以了。

如上计划完成了的话，我们几乎算是完成了一半的工作。剩下的工作分两种方案：一起作为一个阶段做完、分两个阶段做完。

1）：作为一个阶段做完：业务逻辑层就是struts框架的Action层，直接编写Action，并组织页面流程，完成之后整个项目也就差不多了。这样的话业务逻辑层和表现层就都交给struts来组织。
2）：分为两个阶段做完：先做我们自己定义的业务逻辑层的设计和实现（不跟任何struts的api耦合）（这一层的类多，但形式单一，属于劳动密集型，大概占总的20%的工作量），称为“业务逻辑组件”。；然后就是结合struts来摆纯的表现层，也就是最后30%的工作，其中“业务逻辑组件”中的方法要么返回某种计算结果，要么返回指示是否执行成功的true/false信息，也就是说跟struts达成“控制耦合”，Struts在这里就只管表现层。

方案1）其实属于一般常用做法，循规蹈矩；但方案2）由于实现了独立于任何框架的业务逻辑组件，今后如果要改表现层框架（如放弃struts用webwork或jsf），甚至想把本项目重做成C/S架构都是很方便的事情，只需要做最后30%的工作；但若是方案1）作出这样的改动的话就要做50%的工作（业务逻辑层以上均重新构建）。
也许方案2）有点画蛇添足，我们的项目或许做好后再也不需要做那么大的改动...这是鱼和熊掌的问题...
不过决定用那个方案起码是半个月之后的事情，现在不用着急，先完成最上面的计划吧。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐