fan's technical blog

haha

2011-03-02T00:52:00.001-08:00

这里是上牌摇号，外地人限购，那边是将养不起的人口划拨出去。

同一个地球，同一个主义，同一个做法啊。

in reference to:

"这里是上牌摇号，外地人限购，那边是将养不起的人口划拨出去。同一个地球，同一个主义，同一个做法啊。"
- 南方周末 - 金贵的平壤户口 (view on Google Sidewiki)

开源的源

2009-06-16T07:29:00.000-07:00

如果没有源代码，分析问题就不能追本溯源，就会流于表面。
虽然自己不一定会从头到尾的看代码，然后有源代码在那里，让人总觉得有安全感。

代码的开源，还表示了一种“授之以鱼，不如授之以渔”的态度。源代码提供了更多的信息，提供了解决问题的方式。而自有的产品更多的只是关于配置相关的文档，其后的原理一般人不甚了了。

site moved to fkpwolf.net

gPhone(T1)买后感受

2009-05-29T16:35:00.000-07:00

1. 这种东西还可以移植到Netbook上面。对于上网本，肯定是个不小的冲击。相比较linux上网本，虽然内核一样，但是google做过包装，它包装的应该比一般的发行版要好，特别是UI方面。

2.Android用Freetype作的字体渲染器，效果还是很不错的，初一看比Linux上的还要好，这可能是屏幕尺寸的原因。有了字体的反锯齿，屏幕显示就会与众不同了。不知道有没有使用x-window，应该没有，否则负担太重了。

3.Android上的Market模式有点模仿Apple App Store，但是个人认为这会同个人电脑上的软件开发一样，手工作坊式的开发只是小打小闹的。但是容易安装的优点和长尾的考虑让其有一席之地。

4.手机上的开发最后势必考虑到跨平台，所以如果移动平台最后如果能同现在的桌面平台一样流行和重要的话，web模式或者RIA之类的东西势必代替各个应用厂商的SDK。

View Google Reader in Android Browser through Yahoo Pipes

2009-05-27T18:34:00.000-07:00

I am fan of Google Reader. So when I got a Android G1 device, soon I visited the site through it. Now I can view blogs when I was on the traffic to office. It is cool. But one problem I encountered is the font size is too small to read comfortably. I have tried to set the font size to "large" in browser setting and it works at some common page like www.google.com but not Reader. It looks that Google Reder did some optimize for mobile device(It designed for iPhone at first) and the browser can't adjust itself on font size.

I think I just to want to make the main content's font of blog item bigger.

Greasemonkey is power tool to customize web page. I tried OilCan - Greasymonkey on Android browser. It has an innovative idea but still at beta phase. Google chromium has supported it but at Android chrome lite should not support it at now.

Yahoo Pipes fits this case perfectly. Look below pipe flow:

It was simple: just surround the blog content with a font size modification. Then it works. You can view this pipe from here. Thanks Yahoo to create this great tool. The web UI is impressed and intuitive for building a flow. All operations can be finished by drag & drop or drop-box.

More on this, Pipes can be seen as cloud computing. It is running at Yahoo's server. Different with Google App Engine which is sophisticated and for programmer, it is for general user who does not need to have programming experience. Of course it has less function then full feature language. Its input just accepts RSS and others feeds defined in advance. The more inputs type, the more powerful Pipes becomes.

Use Apache Synapse as web service proxy

2009-04-17T00:00:00.001-07:00

This is a power configuration tool to mock and test web service.

edit on android

2009-02-25T04:23:00.000-08:00

Some site like Google Reader has cared this device. Some not, like this site.
Should we need to refactory site? Or write a new client expecially for specific application. Some like write a offline blog writter. Because here when javascript is complex, android cannot render correctly.

CouchDB初次体验

2008-12-26T18:50:00.000-08:00

我是在Ubuntu上面安装的，还算顺利，几个命令行就搞定，Windows下面可能得花些功夫。
启动Server后，它有个控制台，Web界面的，功能虽不多，但是界面做的很专业，不知道采用的那个theme，看了下web的代码，用了不少jquery的东西。
对数据库的管理方式让人很容易联想到Google App Base，可以自由的添加新的field。访问客户端的语言有很多种选择，我用java试了下，没遇到什么困难。
乍看这东西没啥神秘，不过是一个大的hashmap，每个条目是一个document。有什么用途呢？
SimpleDB也是采用类似的方式，这些大厂商这样做应该有自己的目的吧。

MySpace and Portlet

2008-07-29T07:24:00.000-07:00

MySpace looks some like Portlet. Is it just like at face?
MySpace has a MySpace Developer Platform. What is it?

different framework, different web page

2008-07-08T06:07:00.000-07:00

the Struts treats a page as a Command;
the Portlet treats a page as a Window;
the JSF treats a page as a lot of Components;
the Spring Web Flow treats a lot of pages as a Flow;
the Tapestry treats a page as a Java class

JSF Custom Compoment development tips

2008-07-03T06:55:00.000-07:00

1. JSP taglib
In JSF, the scriplet like "#{RequestBean1.name}" is treated as a ValueExpression field in tab class. The corresponding tab lib definition file should nests the attribute type with deferred-value.

And also in tld file, jsp-version 2.1 element should be included. If this scriplet is missed, some container like Tomcat 6.0.16 will take this tag as generial tag and if we invoke isLiteralText() on the ValueExpression object, true will return. It was not excepted. But the GlassFish V2 ignored this and took 2.1 as default.

2. Why setProperties() in tag handler java is not invoked?
You should define all property of jsf component java in faces-config.xml. Sometimes it looks like that a attribute is defined twice: one in tld, one in faces-config.xml. JSF Template can make these things easy by generating all configuration file. In order to archive this, it introduces some anonations.

3. Why did some data shown on page disappear after re-loading the page?
implement the saveState/restoreState method.

Ubuntu 8.04 使用感受

2008-05-12T06:03:00.000-07:00

前些天试了下Ubuntu 8.04，有些感触。
首先，安装。我用的是硬盘安装的方式，可以参考这里。主要是在ubuntu.com找到对应的内核文件。最后MBR要装在linux的主分区上。由于vista sp1采用了新的启动方式，没有了boot.ini文件，要多重启动，需要额外的程序：EasyBCD，这个小工具可以重写MBR来引导多个OS，使用起来还是很方便的。

启动后，主题上，ubuntu变化不大，还是老样子。接上我的ipod，系统可以自动认出，可以关联到相应的程序，运行，提示缺少mp3 plug，然后自动安装，这样就可以播放MP3了，而且mp3 tag中的中文可以正常的显示，这在我的系统的语言是en的前提下，较之以前，是一个很大的进步了。

对于字体，现在相对于以前，有所改进。但是跟vista下的cleartype相比，差距还是蛮明显的。

系统自带Firefox 3.0 beta，所有功能跟vista下的一致。我常用的插件也是可以无碍的使用，可以看出firefox大大的提高了linux的接受程度。和java一样，一个容器就是一个平台，催生了一系列的相关软件。

在Netbeans 6.1中使用dojo开发自定义的JSF组件

2008-04-12T19:18:00.000-07:00

前提：netbeans 6.1 beta。

目的：开发一个功能最简的JSF woodstock组件。

准备：Firefox + FireBug插件

原文在这里。压根儿拷贝不过来，又一个信息孤岛。

从JSP到Velocity

2008-03-15T02:02:00.000-07:00

1.JSP有优点。
Rails页面脚本的做法跟JSP其实差不多，也是在HTML中通过<%...%>将Server端语言嵌入其中，这应该是最容易实现的方法。如果说比JSP有强出的地方，那就是Ruby的语法比Java简洁很多。
Grails:

Struts:

对于这种用XML格式来表达逻辑，同JSTL大同小异，个人感觉总是别扭。一则不如Server端语言灵活，二则要掌握另外一种语法。
相比velocity就做的很直观了：


#foreach ( $item in [1..5] )
On this iteration, refers to the value $item.
#end

其做法更多是贴近一般语言的习惯，仿佛只不过是在语句前加上#（velocity里面称为Directives），变量前加上$。
Grails里面变量的表示为"${}"。一些流行的Javascript框架如prototype、JQuery也采用这种写法。不过这种变量的表示在JSP 2.0里面也被引入，我们就再也不必看到难看如<%=name%>的写法了。

对于XML格式的标签写法，可能对于机器来说容易处理，其实在这里没有一般的语法的校验，有的只是XML的scheme的校验，当然这也是一种语法，不过就容易处理多了。
对于Velocity，其采用了Antlr来产生语法分析器，在其源代码包org\apache\velocity\runtime\parser 下可以看到详细的代码。

还有另外一种模板框架freemarker，跟velocity很类似。

如果我们采用更为简洁的做法：将逻辑和页面彻底的分离，如JSF或者Tapestry的做法，让页面更为单一和纯净。这可能是最理想的做法，也有更好的对页面组件的重用性。但是当前台页面异常复杂，需要浏览器端较多javascript操作，特别是AJAX的引入，势必有越来越多的页面逻辑转移到客户端，从而破坏了整个架构的一致性，让扩展更难处理。

这说明B/S架构中的逻辑存在于浏览器端和server段是导致系统复杂的根本原因。
C/S就没有这样的烦恼。
为什么呢？

对旧技术的补丁，最好的技术是GWT，其将逻辑集中于java代码中（虽然客户端的代码和server端的代码还是分开的）。
而新的技术，则是RIA。

jQuery的做法

2008-03-09T00:41:00.000-08:00

最近学习jQuery.
jQuery正如其名字一样，是一个用来方便的查找到HTML文档中的元素的javascript框架，其查找条件的语法借鉴了CSS和XPath中对DOM元素定位的方式，由于CSS的广泛流行，jQuery可以很快的上手。

jQuery对查询的结果统一返回为集合，而且可以对该集合再次查询，如：


$('div.disText').attr('title','点击来编辑数据').mousemove(handleMouseMove).mouseout(handleMouseOut).click(handleClick);

这是很直观的方式，让人奇怪：为什么很少在其他地方见到这样的简洁的模式呢？
(其实在JAVA中也有，比如：


        StringBuffer buff = new StringBuffer(128);
        buff.append(getModuleName("dojo"))
            .append(".require('")
            .append(getModuleName(name))
            .append("');");

)

jQuery这种视一切为“集合”的方式对“批量”的处理DOM可谓得心应手，而在Web应用中，页面可以显示大量的信息，这些信息可以以常以相同的样式表现，比如“超链接”，在这里用jQuery就可以统一的这些元素处理。和传统的Fat Client不一样，这些页面以XML的格式来定义，还有比如XUL，也以XML来定义界面。XML是一种结构化的数据格式，所以就需要jQuery这样的框架。

后记：LINQ，.net下的一个框架，也有跟上面类似的语法：


var myList = [
           {FirstName:"Chris",LastName:"Pearson"},
           {FirstName:"Kate",LastName:"Johnson"},
           {FirstName:"Josh",LastName:"Sutherland"},
           {FirstName:"John",LastName:"Ronald"},
           {FirstName:"Steve",LastName:"Pinkerton"}
           ];
         
var exampleArray = From(myList).
                  Where("item.FirstName == 'Chris'").
                  OrderBy("item.FirstName").
                  Select("item.FirstName");

异步I/O实践：Linux & Java

2007-12-25T19:21:00.001-08:00

Linux上面的称为AIO，可以参考这篇文章：

使用异步 I/O 大大提高应用程序的性能

编译时使用“gcc a.c -lrt"。这表示链接时包含库/usr/lib/librt.XX，这个库里面可能包含了aio的库，否则会出现"Undefined reference to aio_read"的错误。

My linux enviroment setting

2007-12-13T22:23:00.001-08:00

1. close noisy bell

setterm -bfreq 0 -blength 0

Rethink the big element in web page: Data Table

2007-11-27T22:54:00.000-08:00

Data Table is heavily used in information system. In most case, these tables just display a query result set. They are read only. The operations on them are: paging, sorting, single selection and multi-selection. The all elements of a table include: field, field title, sort and page number state, and value format(or convert). In some extend, a data table is not too much associated with other page elements. So it will be a better way to define a table in one place other than several places in application.

Commet, Grizzly and Tomcat 6

2007-11-27T17:16:00.000-08:00

一个比较早的对这方面讨论的帖子在这里: Comet，下一代Ajax？ DW上面好几篇文章做了介绍：Comet：基于 HTTP 长连接的“服务器推”技术，面向 Java 开发人员的 Ajax: 使用 Jetty 和 Direct Web Remoting 编写可扩展的 Comet 应用程序。在《Ajax Design Patterns》这本书上也有介绍，不过称为HTTP Streaming。Java EE 迎合 Web 2.0 采用事件驱动的异步架构应对现代 Web 应用程序带来的挑战这篇文章从理论的高度说明了异步模式对提高系统吞吐量的作用。
如果要实现Comet，Server端就需要NIO来解决HTTP长连接的问题，否则Server端支持的并发数就会大大减少。

Servlet和NIO的使用可以参考Servlet API 和 NIO: 最终组合在一起使用非阻塞 I/O 构建基于 Servlet 的 Web 服务器。虽然是一篇较早的文章，仍然提供了很多关于NIO的有用信息。

Tomcat 6里面相关NIO的配置可以参考其文档，只用修改Connector的protocol即可。接下来可以写一个简单的Servlet A，其implements CometProcessor接口。为测试方便，将Sender存放在Application变量中，在另外一个Servlet B中就可以调用Sender的send(...)方法，当浏览器访问A时，可以动态看到Server端push过来的信息（这时浏览器会一直处于页面正在装载的状态，实际应用中可以用AJAX来接受信息）。

由于是长连接，数据在传送过程中就存在缓冲的问题。一般的一个Server端的发送到客户端的消息（注意这里不是一个响应）不会很大，而默认的Tomcat缓冲配置偏大，导致客户端响应滞后，出现这种奇怪的现象：1）当send(...)方法触发多次后，server才会一次把消息全部push到客户端（即是每次使用了flush方法）；2）1 发生后，每次的send(...)的调用会导致server段立即把这条消息发送到客户端（这是buffer又好像不存在一样）。

对于Tomcat 6自带例子里面的bug，也有位哥们在他的blog中提到：Asynchronous IO is hard!。

Use JPA with Hibernate in Netbeans(Tomcat)

2007-11-25T16:49:00.000-08:00

0. prerequisite
Tomcat 6.0.14
Netbeans 6 rc1
Hibernate core 3.2.5GA
Hibernate EntityManager 3.3.1GA

1. Add a new JPA library implement
The default used TopLink. Change to Hibernate.

2. Adjust in JSF design
The default data provider ObjectArrayDataProvider works not well with JSF design UI.

My target is when let a jsf table "Bind to Data", the all fields of a Hibernate JOPO can be chosen as the above dialog. These displayed fields come from provider's getFieldKeys method which is part of interface DataProvider signature. So the simplest way is to extends ObjectArrayDataProvider and overide that method. Or just use setObjectType(Student.class). Be sure to compile that class manually so the JSF Design can take this change into account.

Why not use :

private ObjectArrayDataProvider objectArrayDataProvider1 = new ObjectArrayDataProvider(someType);

It does not work. Even I put them in _init() method of backend bean, as the CachedRowSet provider does.

3. Done.

A nice article about JSF state

2007-10-31T05:48:00.000-07:00

developerWorks recently posted an article: Auto-save JSF forms with Ajax. The article provided an approach to implement auto-save function(some like Word's auto-save) in web tie. It told us where the data saved and how to recover from the saved data. This article used much JSF knowledge(some like component state) which is different from JSP tag-lib or other technology and in this case we can see JSF and Ajax is powerful.
And more, in some other scenario where auto-save is no need. For example, the customer want to keep some crucial form and he can resume from it later, he can do it by click a "Save" button by himself. Because auto-save isn't needed everywhere. And auto-save sometimes makes customers confused. Only the customer thinks that he has finished the form nearly, then recover from that point is constructive for him. Though AJAX is useless here, the way the author provided is also helpful and suggestive if JSF is still the choice of web framework.

So from the viewpoint of an end user, a good designed page should tell him, whether the current form is auto-save or not. Something should notify the user, whether the save action is success or failed. And the user can find all forms he has saved somewhere. So he can resume from there conveniently. At last the system looks maybe some like a workflow system.

Skip List查找算法

2007-10-14T19:47:00.000-07:00

最先是从InfoQ上（Java集合类、Skip列表以及Google）看到的。可以将该算法形象的比喻为带索引的地址本。一般的说，该算法属于Red-Black tree（Java中TreeMap的算法）的变形。

to be continued

The unique of Tapestry

2007-09-12T06:45:00.000-07:00

What's the difference between web development and traditional C/S application such Swing? Personally I like Swing because it let me more efficient. All the code is Java code and there is little type-cast. And Tapestry also follows this way. The author admitted that:

An advantage for Tapestry, I think, is the way the two pages (the firsts containing the form, the second displaying the result) communicate ... in proper, type-safe Java code.

This means if you want to invoke a web page, what you face is a java class. Blow is a example:

public IPage doSubmit()
{
ShowProject showProject = getShowProject();
showProject.setProject(getProject());
return showProject;
}

Get a page class(by injection), give it some value and then you can forward to that page. The page class has included a page and we can say it is the interface of the page. But the best way, I think, is the function like way. Some likes "showProject(project);". Compared with Object initialization which is not undocumented and not self-explaining, function maybe is more intuitive.

Tapestry just resolved the problem of the two pages communicate. As to multi-page, or a conversation, there are a lot of work. For example, how to get a page's return value?

Unlike this way that page and bean are bound together, JSF let page outside the backend bean. And a jsf page can bind multi-bean. A backend bean can be used in many jsf pages. This loose bind let a page include another page easily.

JPDA(Java Platform Debugger Architecture)

2007-08-01T19:36:00.001-07:00

How let your changed java code updated to server? It is a big problem in develpping any non-trivial JEE project.

Resently, I run a JBoss 4.04 outside of Eclipse. The application archive(EAR) is so big that we can not run it in IDE environment. Then the debug process is boring. After having modify the java code, I have to package it, copy to deploy directory and restart the server. Ant can help me a lot but a debug round still takes me much of time.

In this situation, JPDA will useful. With the help of eclipse, I can use it to connect to a "Remote Java Application". You can find it in "Debug" dialog. Then you can inspect value of a varible and even modify the java code. ~~Before that, you have to add a breakpoint to your java code. Only java with breakpoint can be modified and replaced to the server. This is a nice feature when you need modify code many times.~~ When eclipse has attached remote server, any modified java code could be updated to the server. This is so-called "Hotswap Bug Fixing". Of course the source code should be added to the debug instance's "Source lookup path". Otherwise the server didn't suspend at your breakpoint. And you should mind that the compiled classes were swapped just in the server's memory and didn't updated to the server's file system. So after finished debug, you should copy the classes to the server's deploy directory.

Some other approaches I often used include Hot deploy and restart application (not server).

Hot deploy is used to deploy a archive such as .war or .jar(EJB) automatically when you put them in deploy directory. Most servers has this feature.

Restart application or Reload Context is used to reload all resource(classes and configuration) in one application eg EJB, or War. This approach is heavier than others. Tomcat will throw exception "Out of memory" after reloaded a web application many times.

To Netbeans, It provides debug mode also. There are some differences on "hot class replace" between it and eclipse.

Above is netbeans 6M10 debug tool bar. It has a "Apply Code Changes" button to submit the changed code to server. It need you do manually. This way is different from eclipse which done automatically.

Cygwin tips

2007-06-19T23:16:00.001-07:00

1.if the os is windows, the file type will be dos by default. So if you new a shell script, then run it in cygwin, the error like "who/r command not found" will happen. The solution is changing the file type to unix. A approch is using vi. In vi, use ":set ff?" to inquiry file type. Then use ":set fileformat=unix" or ":set ff=unix".

2.In my machine, cygwin.bat is:bash --login -i. This will let shell be a login shell. But only an interactive shell that is not a login shell will read and execute ~/.bashrc. If we want our personal bash, we should create a .profile file in home directory instead of of .bashrc. One example is:

alias h="history"
alias hg="h|grep"

#alias ls='ls --color=auto'
alias la='ls -A'
alias lf='ls -F'
alias ll='ls -l'

3.use wget with proxy. create a .wgetrc in home directory.

http_proxy = proxy.com:81
no_proxy = localhost

This will make wget to fetch data with proxy by default and you didn't need to swith to proxy model by " -Y on".

RESTful Web development

2007-06-06T05:06:00.001-07:00

What RESTful means? I found this document : RESTful Rails development is very clear to express this point. And It is also quickly to test it in Rails. Soon you will find the amazing of RESTful. It just used HTTP GET, POST, DELETE, PUT to manage the resource and some likes JDBC CRUD implement. And more it is a new RPC implement. It has been used widely in web service. So a web service can be invoked by RESTful URL. And I think it make web service more powerful. In some traditional web application, for example a struts or JSF application, RESTful just provides nice URL format.

But obviously RESTful will be more important when application need to invoke 3rd party functions

Visual library of NetBeans

2007-06-02T07:01:00.001-07:00

Today I evaluated Visual library of NetBeans org. There are not too much information about it on Sun's site. And it is a part of NetBeans 6 M9. I guest it was just separated from Netbeans as a standalone project. It's many feature is same as JGraph which has been used by many users. But I think this library provides more about UI design but not only concerning on graph as done by JGrah. For example, it has a feature "ComponentWidget - AWT/Swing components on scene". So you can do this:

JButton button = new JButton();
button.setText("xixi");
ComponentWidget widget = new ComponentWidget(this,button);

Then I have a question: Is Visual Web (netbeans) developed on this library? If so, Visual Library is very cool! (From this post, just page flow navigator is based on Visual Library.)
There is a video which created a demo on Visual library. You can find that a JasperReports tool called jarvis is also base on this library. It looks powerful.

Question on JSF state saving

2007-05-07T19:23:00.001-07:00

JSF state is restored or used in "Restore View" of JSF life cycle. These state can be stored in 2 places:client and server. There are some links about the difference of them:

http://www.jroller.com/page/mert?entry=state_saving_method_client_side
http://www.jroller.com/page/cagataycivici?entry=jsf_state_saving_best_of
http://www.jroller.com/page/cenkcivici?entry=changing_default_state_management_method

These states are used to store data about the JSF component tree(the elements in f:view), including components and component id. They can be seen between 2 request. That is the difference from backend bean. At first thought most of components have no state, or just have a value which presents its state. A text field has state? But YES. Disable/Enable is a common state. In the component implement java code, saveState and restoreState methods deal all these work: choose some attributes and save them to an object which can be found as a hidden field named javax.faces.ViewState in client's browser source code. It was Base64 encoding. And of course, the view state has been configurated to be stored in the client. In Sun's webui implement, many attributes are stored in view state, such as javascript event method and style.

Some component such as Table can be very complex and has its own states such as the current page number and ordered column. If these states doesn't be stored in component tree, we have to save them in hidden input field.

Myfaces even has a component t:saveState just for storing data. See here.

This technology is powerful when user's action is within one page. When page is refreshed, all he has done are saved. If he just jumps between page, navigate from one page to another page, then the state of a page is discarded, and more it is useless. In one page scenario, AJAX is also a good choice. They all improve user's experience.

Somebody provides stateless approach.

There is a cool tool called FacesTrace to monitor JSF application. It displays not only session data, but also the whole JSF life cycle dynamically.

test code and use Microsoft Writer

2007-05-04T00:01:00.000-07:00

test code
if (component instanceof ValueHolder && (null != (converter = ((ValueHolder)

the css please refers here. make sure that css code block should be placed in <head> and started with .post.

In your blog, you should enbrace your code with <code> tag in HTML view. And in your code block, you cann't use <> these simble. You change it into HTML code by some tools like phpfi. It also provides highlighting feature.

But this approach is some boring. Later I found M$ Live Writer. It is cool. You can edit blog on offline mode and post it when online. You also can download blog item, modify it, and update it to Blogger. You also can delete blog by Writer although Writer didn't remind you. The editor is css-enable. And more interesting it is extensible.

It's disadvantage I found until now is that it cann't upload image file(Blogger does not support it). It can just add a image link.

(6.4 add)Today Writer beta2 is released. It has many nice feature. The biggest imprement is that my article can use tag. Well Done! It looks really cool! I think Microsoft will let it more powerful.

The reason of Writer's existen is:1)It provide offline edit mode; 2)It is WYEIWYS editor; 3) web editor is not so much convenient until now. You will find these problem specially when the article is some long.

use ajax4jsf

2007-05-03T23:28:00.001-07:00

Ajax4JSF is a framework which inserts AJAX function to JSF. It is easy to transform orginal JSF code to Ajax-able. Ajax4JSF just changed the way of http message.
It's document is here. It has a simple example. Look at blow code:

the reRender property points out whose data in JSF component tree should be return from server. After JSF engine renders that component, Ajax4JSF then sends response. So this approach didn't do harsh to JSF. We can code in JSF bean:


private HtmlOutputText rep2 = new HtmlOutputText(); 
...... 
String style="border-color: rgb(204, 0, 255); backgroun....."; 
this.rep2.setStyle(style);

We can see the benefit of JSF component model. But this model don't consider the position of the javascript or it is hard to add javascript function. For example, if we want to hightlight the outputText, Should I write a new class extends HtmlOutputText which has a cool appearance? Maybe a Decrtor Pattern is better. No matter which approach we use, we should encapsulate the javascript into JSF component and give user a consistent usage. On the other hand, If we have a JSF component which is not ajax-able but provides hightlight function, we can use it directly in Ajax4JSF. So the problem is the matter of JSF instead of Ajax4JSF.

why Ruby over Java

2007-04-04T05:28:00.000-07:00

这个帖子很不错，可以参照来学习Ruby。总结来说Ruby的优点在于：
* closures
* multiple implementation inheritance via mixins (simplifies a lot designs where we would use decorators and factories in java)
* messages to objects as if they were first class methods (natural way of doing AOP, used a lot in ActiveRecord). This actually also counts for the famous java properties support planned for java 7...
缺点在于没有了Java的类型检查，而这是提高Java开发效率的关键：通过编译就可以排除大部分的错误，也提高了系统的安全性。但是在开发一个完整的 Java应用时，经常会遇到DSL语言的地方，比如jsp, sql，这些都是没有办法进行类型检查的地方（DSL的特点吗？）。再比如对Session的处理不可避免的会用到类型cast。
在RJS里面，html, rjs, rb这些文件之间存在的变量type和name的合约（或契约）更多，而只能手工检查。
疑问：Ruby里面method的参数的类型会在运行时进行类型检查？
那JRuby会起到一个粘合剂的作用吗？这会提高系统的复杂性，而且一个系统中使用两种语言也少见，除非是一个遗留系统。

Sun的一些新动向

2007-03-31T05:29:00.000-07:00

最近忙于找工作，荒疏了一些东西。
1.pet store 2.0发布了。看上去好像是web 2.0的跟风作品，AJAX，RSS，TAG，SEARCH都用上了，还没来仔细研究。用了不少开源的库，可以借鉴下。
2.一则netbeans有了新的插件：Visual Web Pack，看上去很不错的东西，应该是从creator里面提取出来的，这样比较eclipse的web开发，netbeans强了很多。记得原来使用 creator时，由于deploy服务器只能使用sun application server，速度很慢，还设法过把部署环境改为tomcat，这下方便多了。
产品的定位跟Microsoft visual web developer express类似。
相比下，eclipse的可视化编辑界面就差了很多，VE发展到现在还是个小玩具。个人感觉Swing比较swt可能难看点，但是灵活性更好些。
3.新的application server增加了很多SOA的支持，比如REST，BPEL。有个netbeans演示BPEL开发过程的Video，图形拖放的方式，很是cool。

Questions on Jboss Seam

2007-01-13T06:57:00.000-08:00

Obviously, seam has many cool features. There are some questions:
1.Seam introduced many kinds of context, and much more than Spring. Are they better than Spring?
2.any bean marked with @Name() will be treated as managed component. client just uses "DumyBean cc = (DumyBean) Component.getInstance("dumyBean", true);" to access the bean. Maybe this approach is clearer than Spring xml configuration. Is this approach less efficiently?
3.debug.seam page is right around thing! It should exist in Spring. Is it a servlet? Where is its configuration?
4.@Logger looks cool. This annotation is introduced by jboss. How to do this?In org.jboss.seam.Component, there is: if ( field.isAnnotationPresent(org.jboss.seam.annotations.Logger.class) )So, It looks that Logger is a build-in service. There is no way to configure it or add my service, yeah?
5.eclipse's command works very well with Ant? For example: when I click save button, eclipse automatically invokes Ant's task. How to do this?6.annotation is largely used in Seam. What about this?

MDB应用实例

2006-12-18T05:31:00.000-08:00

Message Drive Bean据说是EJB 2.0规范里面最有好的一个特性，可惜一般应用和项目中鲜有EJB的使用，更不谈MDB了。
应用中需要将一些消息发送email到主机，为此配置服务器jms，建立消息的queue和factory（使用工具如WSAD可快速的配置，可以参考developerworks的这篇文章和这篇）。创建一SLSB AlertsService，该bean作为jms的工具类bean，提供接口将消息发送到队列。该EJB有对queue和factory的resource-ref。
在EJB中建立jms监听端口（在queue, factory上），创建一MDB OutboundAlerts监听该端口，在onMessage()中处理消息：send emails to host。MDB的目标类型为Queue(只有一个消息接受者)。
这里用jms的原因是：发送email可能延误时间，必须为异步的。相对用多线程的实现异步方法，MDB提供了持久性（只有Topic才有这个功能），更稳定。
这里MDB的onMessage的事务类型为：NotSupported，一般消息的发送者和接受者分别在各自的事务中，不可能在一个事务中。

jdk6 has been released!

2006-12-16T05:32:00.000-08:00

Tonight I occasionally browsed java.sun.com, It was very surprising that J2SE 6 had been available. COOL! Well Done! It was so quickly that sun pushed the newer edition of jdk.
After going through this page, I found there are not too much exciting features in this release except script.
More detail documents can be found in DevX: Mustang Must-Haves: What's Cool in Java SE 6 and Java SE 6's New Scripting and Compiling Goodies .
You can see another cool stuff is compile API. Even there is a project gosling using compile API as a replacement for ANT. It used java as build language other than xml. Also it used some advanced feature such as annotation, compile API.
The questions for gosling are :
1) the build java file need not be compiled?
2) Is it more quickly than old ANT?
3) Why not use script as a language? Though the java maybe be a better choice than XML, it also has a more complex grammar than XML. With XSL XML can be validated easily. If the java don't be compiled in eclipse, how can I make sure my java is correct? till the run-time? How about script? maybe it is more appropriate.

JSP，Velocity,Jelly and Ruby

2006-10-26T07:11:00.000-07:00

项目中要动态产生文档，开始用JSP做了个简单原型，后来觉得代码比较混乱，换上了Velocity：一种模板语言。虽然大同小异，但有些地方还是很方便。比如原来jsp中：
<%=person.getPostion()%>
现在只要$person.position就可以了，少了很多讨厌的百分号。还可以定义function，以及其他一些你能想到的特性。很有点脚本语言的味道，有如prototype.js的$()，更符合编程思路，大家都喜欢，觉得这样才自然（prototype这里大概从ruby中汲取了灵感）。
还有另外一个类是的库jellyXML-based scripting and processing engine。使用了一种XML和${}的混和语法。比如:


<j:forEach items="${IMPORTS}" var="i" trim="false">
import ${i};</j:forEach>

而velocity则较为一致：


#macro( getBox $thisboxvalue $boxvalue )
#if ( $thisboxvalue == $boxvalue ) a #else b #end
#end

单从语法上讲，jelly类似jsp + jstl。While Jelly has found some success in projects such as Maven, the general consensus is that XML is a poor choice for a programming language even the creator of Jelly apologized at http://radio.weblogs.com/0112098/2004/03/26.html#a472.
其实ANT用XML作语言也有同样的问题。TheServerSide上有篇文章Allen Holub: Just Say No to XML 说明了这一点。那为什么jsp不做成这样子呢？连rails也是这种讨厌的风格？（还好ruby的语法很方便）个人认为一则效率的考虑：velocity大概有个预先装入、解析、预编译的过程（待考证），还会将结果放在cache中。二则（更主要）多了一种语法，造成复杂和重复。
velocity还有些设计上的亮点：使用中遇到一种情况，从bean中取出属性后要作个代码页转换然后在页面上显示。由于原来bean的getXXX方法都已经产生好，手工改费力不讨好。这时参考velocity文档时发现有一个get()的方法：当对于属性A，bean不存在getA()方法时，调用 bean的该方法。nice! 让人想到了ruby也有类似设计：Object有个method_missing的方法.也是很好的idea，方法简单但是效果很好。（参考我的blog:Ruby的method的动态特性）
从脚本语言看，Groovy之类从语法上更为强大，也更复杂。如果Java有成熟的、广泛接受的脚本语言技术，velocity大概也无立足之地了。
另： Roller Weblogger的模板也是用了Velocity技术。

小试Rails RJS

2006-10-20T18:06:00.000-07:00

    RJS是Rails1.1的一个ajax的功能点。这里是一个简单明了的turturail。
    这个framework引入了一个rjs类型的文件，当control的function执行后，同名的rjs文件会被执行来动态产生出（或者说是被翻译为）javascript文件。
    rjs可以为如下的形式：
a = "fkp"
page.insert_html :bottom, 'list',
                 content_tag("li", "Fox2")
page.visual_effect :highlight, 'list', :duration => 3
page.replace_html 'header',
                  a + "b"
利用工具(for example:charles)可以得到其产生的response为：
try {
new Insertion.Bottom("list", "<li>Fox2</li>");
new Effect.Highlight("list",{duration:3});
Element.update("header2", "fkpb");
} catch (e) ......
    让人惊奇！我原来以为返回的是xml形式的（ajax必须返回xml吗？）。
    这样的做法产生一个问题就是js的代码量可能过大，当然这里是因为直接调用而显得很简短（application.js就可以放自定义的js function的地方）。这些js基本上是没有变化的，那么能不能直接传参数呢？这样产生出来的js可以cache（google web tools好像是这样做的）。而rjs的做法感觉是对于page.methodxx的返回值每次来个字符串的相加？
    rjs不仅提供了ruby语法的api来简化js的开发，更重要的是将ajax从view曾剥离出来，而且可以访问server端同名function的导出变量(@开头的？这湮没了xml在B/S间的传递)。
    跟其它的ajax框架不一样（大多可以用js直接访问后台的java function），这种方式去掉了访问的接口的定义（method的返回值没有定义），灵活性更强，因为view可能改变频繁。
    用这种模式后，契约存在两个地方：1）rjs和html。rjs用id来对html element控制，一般的ajax模式是把js和html混合写，由于id粒度过低，分开加大了耦合度；2）ruby和rjs之间的context。显然，google web tools解决了这些问题，但是需要讨厌的compile的过程。
    如果用java来实现，rjs模板可以用java写，也可以为脚本语言（jdk6有更好的支持)，而主要不同可能是java代码和模板之间的contex的共享：java可能没有ruby实现的优雅。
    模板产生出来的javascriptbroswer端用如下的形式引用：
<script src="/javascripts/prototype.js?1159875410" type="text/javascript"></script>
<script src="/javascripts/effects.js?1159875410" type="text/javascript"></script>
还不知这些number是做何用处。

XUL中的UI重用

2006-10-19T05:33:00.000-07:00

XUL是Mozilla的界面描述语言,用来解决跨平台的问题。
XUL的Overlays特性令人感兴趣，其描述为：
Overlays are XUL files used to describe extra content for the UI. They are a general mechanism for adding UI for additional components, overriding small pieces of a XUL file without having to resupply the whole UI, and reusing particular pieces of the UI.
有点类似OO中的继承和方法重写。
一般来说，页面级的重用是比较困难的。JSF（组件级的重用）或者jsp tag只是重用了页面的一部分，开发起来也是费周折。

XP中的人生哲学

2006-09-21T05:34:00.000-07:00

我过去对极限编程一直不是很热忱，抱有很多的偏见。首先就这个名称从字面上而言，极限？好像是噱头，或是旁门左道的东西。
其实里面很多都是朴素的道理。
比如：增量开发。“对于一个婴儿来说，他的力量就是成长的力量。”，“真正的光明决不是永没有黑暗的时间，只是永不被黑暗所掩蔽罢了。真正的英雄决不是永没有卑下的情操，只是永不被卑下的情操所屈服罢了。所以在你要战胜外来的敌人之前，先得战胜你内在的敌人；你不必害怕沉沦堕落，只消你能不断的自拔与更新。”
比如：测试驱动。告诉我们的道理是做事前要先确定好目标，有的放矢。或者“没有反省的生活是没有意义的。”

Hibernate乐观离线锁(Appfuse Practise)

2006-09-09T05:36:00.000-07:00

一个在Hibernate中的实践操作描述的很好的文档在这里。原理上的描述在Addison Wesley : Patterns of Enterprise Application Architecture Chapter 16里面有详尽的描写，这本Martin Fowler撰写的书称乐观锁定为Optimistic Offline Lock，Hibernate的实现基本上跟这本书里面的一样。里面有副时序图，画的相当的明白。(copy from the book. copyleft.)

另外一本书Hibernate in Action将乐观锁划分为Application Transacation，而悲观锁则划分为Database Transaction（Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！见：Hibernate的reference document）。
Appfuse实践
Appfuse可以generate一个model的CRUD所有jsf页面，这可以作为实践上的起步。然后，version字段应该在页面上不能修改，而是作为一个hidden的字段，这样在显示record详细信息界面上就需要有两个hidden字段：
<h:inputHidden value="#{personForm.person.id}" id="id"/>
<h:inputHidden value="#{personForm.person.version}" id="version"/>
Patterns of Enterprise Application Architecture里面的做法是将version作为session变量，都是可以的。只要这个值是读取对象时取出来的就可以。
这样做后，如果两个不同的用户同时修改一条记录时，hibernate就会报错Row was updated or deleted by another transaction。

appfuse（1.9.3）中的几个小问题

2006-08-30T05:39:00.000-07:00

1.如果创建了一个新的应用，ApplicationResources_zh_CN.properties在创建过程中被转换为乱码。简单的做法就是用appfuse原来的文件直接覆盖。
2.displaytag_zh_CN.properties没被转换。修改build.xml的copy-resources task：

<target name="copy-resources" depends="prepare"
description="Copy .properties and .xml files from source directory">
<copy todir="${build.dir}/web/classes" includeEmptyDirs="no">
<fileset dir="web/WEB-INF/classes">
<exclude name="ApplicationResources_zh*.properties"/>
<exclude name="displaytag_zh_CN.properties"/>
<include name="*.properties"/>
<include name="*.xml"/>
<include name="*.vm"/>
</fileset>
<filterset refid="variables.to.replace"/>
</copy>
<native2ascii src="web/WEB-INF/classes" dest="${build.dir}/web/classes"
includes="*_zh*.properties" encoding="UTF-8"/>
<generate-database-properties/>
<copy todir="${build.dir}/web/classes" file="database.properties"/>
</target>
3.appgen的ant install的做法
ant install的所做的工作包括了ant[default]的工作，好像文档写的不是很准确。而且这个appgen一股脑的将ibtias and hibernate的dao都产生出来，没有一个设置目标DAO的地方。
忘了在哪里看到的说法：j2ee开发中deploy是一个非常关键的过程，确实真知灼见。
发布过程要有几个特征：
1.方便（自动化的发布）；
2.灵活（定制）；
3.有升级的功能（持续的升级）；
4.速度要快。这样才能减少测试－开发－测试需要的round时间。

4.中文编码的问题
刚开始遇到中文问题的时候，觉得小case：统一将编码改为gb2312，原来就是经常这么干的。后来网上查了会儿，原来大家现在都用UTF-8了，就像google一样，cool！
appfuse本身就是utf-8的配置，问题在于数据库的编码，需要在my.ini中加入：
[mysqld]
default-character-set=utf8
或者mysqld命令行带上参数。
但是ant setup-db后，依然乱码。后来发现新建表的character set为latin1，column也为latin1，god! 都改为utf8后问题解决。而如何让ant setup-db自动创建utf-8的table呢？
所以appfuse的中文问题就是所有地方都要用utf-8编码！

continuation in Spring Web Flow

2006-08-16T18:04:00.000-07:00

   平心而论，SWF是现在java中对continuation支持最好的和最现实的，虽然这种支持是模拟的。其他的一些框架都有点技术上的理想而造成的不成熟。
    SWF默认使用的控制是SimpleFlowExecutionRepository，这是不支持continuation的，比如浏览器回退、新开浏览器等。如果要支持，要使用ContinuationFlowExecutionRepository。SWF这样的设置是很灵活的，因为一般的应用可以使用SimpleFlowExecutionRepository来避免continuation引起的不必要的开销。
    以swf-sample中的guessnumber为例（guess number是一个经典的例子），修改/web-inf/dispatcher-servlet.xml相关内容如下：
     <bean name="/play.htm" class="org.springframework.webflow.executor.mvc.FlowController">             <property name="flowExecutor" ref="flowExecutor"/>      </bean>     <bean id="flowExecutor" class="org.springframework.webflow.executor.FlowExecutorImpl">         <constructor-arg ref="repositoryFactory"/>     </bean>     <bean id="repositoryFactory" class="org.springframework.webflow.execution.repository.continuation.ContinuationFlowExecutionRepositoryFactory">         <constructor-arg ref="flowRegistry"/>     </bean>       如此后，应用就支持浏览器后退键了。这里的后退键是跟后台逻辑关联在一起的：按下后退键，相当于刚才的猜测不算，再猜一次，而计数也“后退”（或者说“恢复”）到前面到状态。如果是购物篮应用，后退就表示“退回”刚才购买的商品。（这种方式也可能造成用户感觉上的混乱）
    这种功能用一般的会话变量（比如将计数存在session中、将购物篮存在session中）是很难处理的。这里的会话变量比如计数、购物篮是一个会话活动中多个步骤的结果的记录，用一个变量是无法记录这些步骤的先后顺序的。而一般的会话变量只是一个步骤中标志或者状态的记录，一个变量就足够使用。
    SWF的解决方法就是在每个步骤中添加一个标志，当这个步骤提交时，后台根据提交上来的标志恢复（在回退的情况下）当时这个步骤的上下文，这样就可以在work flow中继续运行下去。
    例如当步骤1->2->3->4，当浏览器在步骤4时回退时，浏览器会把步骤2提交的数据再次提交。
    用户每次提交，后台都要形成一个上下文的continuation（每次提交的数据都可能不一样），这可能会占用大量的资源。

Spring中Singletons的线程安全

2006-08-16T05:41:00.000-07:00

Thread-safe在Java Concurrency in Practice这本书里面的定义是：

A class is thread-safe if it behaves correctly when accessed from multiple threads, regardless of the scheduling or interleaving of the execution of those threads by the runtime environment, and with no additional synchronization or other coordination on the part of the calling code.

Spring本人不是很熟悉，网上Google了下相关方面的话题，得到的有用的结果很少。可以参考的是：Thread safety, singletons and Spring。还有一篇是：Thread-safe webapps using Spring。
基本上，Spring的thread-safe是其API自身的thread-safe。比如一个常见的场景（from appfuse）：
public class UserManagerImpl extends BaseManager implements UserManager {
private UserDao dao;
......
public class UserDaoHibernate extends BaseDaoHibernate implements UserDao, UserDetailsService {
......
public class BaseDaoHibernate extends HibernateDaoSupport implements Dao {
这些bean都是Singletons的。
一个类如果没有成员变量，那这个类肯定是thread-safe的，所以UserDaoHibernate的thread-safe取决于其父类。而 UserManagerImpl 的安全性又取决于UserDaoHibernate，最后是HibernateTemplate。可以看出，这里的bean都小心翼翼的维护其成员变量，或者基本没有成员变量，而将thread-safe转嫁给Spring的API。如果开发者按照约定的或者用自动产生的工具（appgen不错）来编写数据访问层，是没有线程安全性的问题的。Spring本身不提供这方面的保证。
或者bean的定义为Singletons="false"，也可以参考前面的一篇文章Thread safety, singletons and Spring，用lookup-method。<pro spring> charpter 5介绍的更详细：
Lookup Method Injection was added to Spring to overcome the problems encountered when a bean depends on another bean with a different lifecycle—specifically, when a singleton depends on a non-singleton. In this situation, both setter and constructor injection result in the singleton maintaining a single instance of what should be a non-singleton bean. In some cases, you will want to have the singleton bean obtain a new instance of the non-singleton every time it requires the bean in question.
显然，如果A(Singletons) depends B(Propotype)，使用这种方式可以避免A对B的访问并发和争用的问题。
<pro spring>这本书（强于spring in action，后者感觉是本reference book）也对Singletons＝“true/false"的选择做了个小结：
使用Singletons的情况有：
1.Shared objects with no state;
2.Shared object with read-only state;
3.Shared object with shared state;
4.High throughput objects with writable state. (synchronizing is need)
使用propotype的情况有：
1.Objects with writable stat;
2.Objects with private state.
与Spring的高度灵活不同，EJB的规范将同步作为一个服务（one of primary services），开发者开编写bean时不必考虑（也不能）线程相关的问题。session bean其分为两类，也有同步上的考虑。
虽然thread-safe的问题总是存在，EJB也没有从本质上解决这个问题，但是其提出了这个问题，并给出了规范。