愛德華日誌

OSGi 起源於1999 年三月，是由一些家用閘道器相關產業廠商所組合而成的組織，目前約有八十餘家廠商加入。包括了 IBM、Sun、BMW、Motorola、Nortel、Nokia、 Philips、Panasonic、Sony、Toshiba、Echelon 等。目前最新的標準是OSGi Specification 3.0。

當初制定OSGi 標準的最主要的目的，是要為遠端的服務提供者 (Service Provider) 與本地端的設備 (Device) 之間提供完整的點對點服務傳送解決方案。因此，OSGi 定義了一個開放性的平台，使得遠端軟體服務供應商所提供的應用程式 及加值服務，能視使用者需求，隨時下載至靠近用戶的閘道器 (Gateway) 上，並且自動安裝執行，而這裡所指的閘道器通常是連接家庭網路(Home Network)、辦公室網路 (Office Network) 與廣域網路間的一個裝置，如機上盒 (Set-top Box;STB)、ADSL數據機、纜線數據機 (Cable Modem)、住宅區閘道器 (Residential Gateway)等。透過這個開放性的平台，不同廠商所開發出的服務軟體及設備都能互相溝通及搭配使用。

在 OSGi 網站上的 FAQ 中，指出 OSGi 應用方向包括：

• Services in the Home:
• • Communication
  • Information/entertainment
  • Safety and security monitoring
  • Energy management and metering
  • Appliance diagnostics and servicing
  • Telemedicine and healthcare monitoring
• Services in the Car:
• • Navigation
  • Emergency assistance
  • Mobile commerce
  • Information/entertainment
  • Vehicle diagnostics
  • Location-based services

Again, we see java succeeded in J2ME. We can see many big-name companies in the OSGi member name list which include many companies come from many industries.

最近 OSGi 在軟體業最為人雀躍的發展，莫過於 Eclpise Java IDE 支援 OSGi 標準。這是一個有趣的現象，本來是設計給其他產業的運用，卻在軟體業也有不凡的表現。這也讓我想起 Java 的發展歷史，本來也是為了 embedded 系統而設計，卻意外的在 internet 竄起的年代獲得各方的矚目，更在 enterprise application 中立於不敗之地...

JMX 與 OSGi 在功能上的許多重疊之處，在國外已經有人討論過 (例如 Eclipse Embeds OSGi Based MicroKernel 及 JMX vs. OSGi - The New Flavor of the Eclipse Runtime)。不過我認為重點是：

1. JMX 本來設計的用途就只為了管理，我們不該把他拿來 (over use) 作為開發應用程式的元件 (那是 EJB 或 JavaBeans 該做的事)。但 OSGi 卻可以!
2. JMX 多數用於 server 系統中，而 OSGi 卻不限於所開發的應用程式。你可以用它開發 embedded 系統、desktop 程式，甚至是 server 程式。

OSGi 不但提供了與 JMX 相似的容器管理能力，甚至它本身就是一套精密的 Framework。OSGi 採用Micro-Kernel 的架構，可以提供無限延伸的功能。OSGi 的 Bundles 線上更新功能、以及應用程式之微量記憶體執行能力，都是開發應用程式的利基。

OSGi 與 J2EE 在設計上，我覺得完全是兩種思維模式：J2EE 的思維是 build on large scale，OSGi 的思維是 build on dynamic scale。OSGi 以小搏大...

OSGi Resources:

• Welcome to the OSGi Alliance - OSGi official web site
• alphaWorks : OptimalGrid
• ServiceBinder - Automatic service dependency management in OSGi
• IBM Service Management Framework - IBM Software
• Oxygen project homepage
• Oscar - An OSGi framework implementation
• Knopflerfish OSGi

註:

目前我看到與 OSGi 有關的 JSR 為：

• JSR 8: Open Services Gateway Specification (OSGi)
• JSR 232: Mobile Operational Management

AOP (Aspect-oriented Programming) 強調的是面向分割 (separation of concern)，並且試圖由程式語言 (compiler)、框架 (framework) 或執行期 (runtime) 層次對橫切物件功能的服務考量 (crosscutting concerns) 提供支援。

AOP 本身是開發應用程式框架的有力工具，透過 AOP 的手法，可以輕易解決傳統 OOP 窒礙難行的問題。例如充斥在整個系統中的橫切服務--包括日誌、交易、安全的議題，都可透過 AOP 的支援而輕易實作出來。

不過 AOP 也引入一些問題，例如透過 AOP 手法建築的系統，其元件間的互動關係較難以理解及追蹤，因此個人認為 AOP 適用於開發 application framework 的底層，但卻並不適合拿它直接來開發應用系統。
而個人對於 SOA 所謂的 Concerns 則有二種看法：

• Business Concerns: 如何達到 (business) services independency
• 如同 AOP 中之 crosscutting concern：這在 SOA 中給它負予了一個可怖的稱謂，叫 Enterprise Concerns，其實也不過就是 log, monitor, access rights 這些非使用者功能導向的服務需求。不過 SOA 不在程式語言、編譯器或框架(framework)上解決此議題，而在架構層級解決

SOA 之所以也能達到 separation of concerns 的訴求，完全是因為它將服務的兩端抽象化，並將呼叫訊息化。在 client 與 service 之間，可以加入許多的 proxy, router, interceptor 這樣的東東，因此可以在兩造之間加入許多的 QoS(Quality of Services, 即上述的 Enterprise Concerns)。

這樣一來，這些 QoS 就可獨立出來個別設計，再於佈署時期或執行時期動態的設定，也就達到 separation of concerns 的訴求。從這個面向來說，SOA 達到了最為動態的 AOP。不過，相對的 SOA 之切點的設定便無法如傳統 AOP 的作法 (在程式語言上下功夫) 那樣的精密了。

在這 Web 2.0 的時代，現今的 Java Web Framework 也與過去第一代的 Java Web Framework 有些不同，先列出我所關注的幾個：

Spring Framework

• Spring Framework - http://static.springframework.org/
  
  輕量級的 Java 應用程式容器，同時支援 Rich Client、Web及 Java EE 應用系統之開發。
  
  
• Spring Web MVC Framework - http://static.springframework.org/spring/docs/2.0.x/refer...
  
  Spring Web MVC 是一簡單易用的 web MVC 套件，可讓開發人員把 View, Controller 及 Model 分離，開發出容易維護的 Web 程式碼。由於其 View 端採用 pluggable 方式設計，可搭配 JSP, Struts 或 JSF 展示框架使用。
  
  由於 Struts 架構因限制特定用途且開發動能不足，目前已呈老化之趨勢，開發新專案時，不建議採用。對過去只採用 JSP 的系統來說，採用 Spring Web MVC + JSP 將是最可行而簡易的升級方案。
  
  
• 中文版的 Spring Framework 教材 - http://caterpillar.onlyfun.net/Gossip/SpringGossip/Spring...
  
  良葛格寫的，其中對 Spring Framework 有深入淺出的介紹。若對 Spring Framework 不熟悉，建議先看這裡的介紹，大致上看完後對基本的應用就足夠了。若有不足處，可再參考官方參考手冊(http: //static.springframework.org/spring/docs/2.0.x/reference/)。
  
  
• Spring Web Flow - http://opensource.atlassian.com/confluence/spring/display...
  
  Spring Web Flow 讓開發人員定義一組態設定檔，透過定義 page 及 action 的 binding，完成 page flow 的定義。令人興奮的是，在 Spring IDE(http://springide.org/project/wiki/SpringideFeatures) 中，提供對 Spring Web Flow 的支援，讓開發人員可以透過視覺化的方式(http://springide.org/project/wiki/WebFlowEditor)， 來定義 網頁流程。

Echo2

• Echo2 - http://www.nextapp.com/platform/echo2/echo/
  
  支援 Ajax 最徹底的 Web Framework，其特色是 Echo2 將網頁元素完全物件化，透過它所開發出來的網頁程式，不用寫到一行 HTML, javascript 程式碼。如果開發者對 Swing 熟悉，那麼開發 Echo2 程式將會輕而易舉。想要了解 Echo2 所開發出來的程式風格，可參考其 demo(http://www.nextapp.com/platform/echo2/echo/demo/)。 看過 Echo2 令人印象深刻的展示程式後，會覺得其他 Web Framework 的展示程式是那麼軟弱無力。
  
  另外，我發現 Echo2 的社群也是非常活躍，像是其 forum(http://forum.nextapp.com/forum/) 或 wiki(http://wiki.nextapp.com/echowiki/) 裡，可以找到不錯的參考資源。而 EndPointNG (http://wiki.nextapp.com/echowiki/EchoPointNG) 則提供了許多額外的元件，像是 Tree, TreeTable, PageableTable 等。
  
  在應用上，把所有 web 元素通通轉換成 Java 資源放在 session 裡面，對於使用者眾多的應用程式將非常不利(但若是像我們公司這類程式由於非訴諸一般 end user，則無所謂)。
  

Google Web Toolkit

• Google Web Toolkit - http://code.google.com/webtoolkit/
  
  Google 所出品的 Java Ajax Web Framework。其實說它是 Java Web Framework 有些不對，因為它在開發的過程中，採用與 Echo2 類似的 Approach，是以 Java 物件來代表/處理 Web 元素。但是真正佈署前，必須將這些 Java 物件 compile 成 HTML 及 Javascript，再佈署這些轉譯後的 web 資源。因此這些資源極有可能佈署至一般的 web server 內(如 Apache)，而不需要特定的 Java web container(如 tomcat)。
  
  由於 GWT 已經實際應用於 Google 的產品線(如 Gmail、Google Calendar 等)由於 Google 的Ajax 技術已經過實際應用，因此可以確認的是它的效能不成問題。另外由於它的展現層與邏輯層完全分離，兩者之間採用 jscon 或 RPC 的方式進行呼叫，因此 server 端完全免除 UI 的 loading，只要專注於 service 的邏輯即可。再加上它可透過 JavaScript Native Interface (JSNI) 來整合既有 javascript 撰寫的網頁元件，對於 third-party 的元件，將較容易整合與移植。結論是：GWT 是一適用於高負載，運用彈性靈活的 web framework。

Wicket

• Wicket - http://wicket.sourceforge.net/
  
  Wicket 是 web 應用程式中，將 Java 程式與 HTML 源碼切割的最乾淨的一套 web framework。與 JSP 一樣，Wicket 將 view 端的 UI 定義在 HTML 中，但與 JSP 不同的是，它並不是採用 <%%> 這類特殊的 tag 來夾注 server 端的邏輯，而是利用 XML namespace 的方式，在一般的 html tag 中加注 Wicket id 來達到 server 端邏輯連結的效果。
  
  Wicket 與 Echo2 一樣，將所有的 UI 元素都轉換成 Java 物件存在 session 裡，對於流量大的應用程式非常不適用。實際試用 Wicket 之後，發現在使用既有元件的情況下，要完成相同的工作，它所需的程式碼要比 Echo2 來的多。且由於 Echo2 是所謂 "一頁式" 的 web 應用程式，而 Wicket 可支援多個頁面，因此它在 URL 連結及 session 的處理上更為複雜。所得到的益處是，Wicket 同時支援 Ajax 與 refresh based 的 web 應用程式開發，且支援 bookmarkable URL。
  
  另外，由於 Wicket 使用 HTML 作為網頁元素樣版，因此可以在美工人員與程式設計師之間作良好的分工。而既有的 javascript 在整合上，也會較 Echo2 來的簡易。
  

接下來，我想透過分析以上幾個 frameworks，檢視應用程式框架發展、轉變背後所隱含的意義：

支持輕量級開發

所謂輕量級開發，可以由幾個角度來檢視，一個是元件模型，UI 與 Server 端的邏輯是否容易連結。另一是在開發應用程式的過程中，是否需要採用特殊的工具，如特殊的 GUI Builder 或 configure file editor。最後，則是其執行環境是否單純，或是需要特定的 web 容器。

在第一點上，個人認為 Wicket 及 Echo2 皆有良好的表現。因為它們所採用的方式，是直接撰寫視覺元件的 action listener，與 Swing 的作法一致。而 Spring Web Framework 則承襲第一代 web framework，採用 dispatcher/handler 的作法，在觀念是 request/response 模式。至於 GWT，由於 client 端邏輯純粹由 javascript 負責，它所提供的 javascript 包含 RPC 呼叫程式，用來呼叫 server 端的應用程式邏輯。而 GWT 的 server 端邏輯，是一種特殊型式的 servlet。因此，如果系統中後端邏輯複雜多變，需要多個 server 端元件時，採用 GWT 預計就要維持很多個 servlet，可能會令人相當頭疼。

第二點，應用程式之開發環境，在 GWT, Wicket 及 Echo2 中，都是直接以既有的 Java IDE 即可開發，至於 Spring Web Framework 在這一點上，因為其 View 端採 plugable 設計，基本上是獨立的。不過其 config file，個人認為若有合適的 editor，會較容易使用。最仰賴 GUI builder 的，我想是 JSF，不過也不排除有存在樂於 hand coding JSF tags 的天才。

最後是運行環境，這方面的贏家是 GWT，因為它在運行時甚是不需要 server 環境。至於 Spring、Wicket 及 Echo2 等，則需要(只要)一搬的 java web container, 加上 framework 特有函式庫即可。 

另外，這裡我並未強調元件模型是否為 POJO，因為繫結視覺元素與後端邏輯，本身就是 glue code。你只能看它是否夠不夠簡易，而無需用 model layer 的標準來要求，

支援新一代的動態網頁技術

Wicket、Echo2 及 GWT 都支援所謂的 Ajax 技術。在使用上，Echo2 的方式相當靈活，因為它讓你可以動態的在 clinet 端加入與移除視覺元件。Wicket 在使用上感覺就有些限制，因為它要求 Web UI 元件與後端的處理元件，需存在一對一的對應。

對於標準的支持

這一項有些含糊，因為每個 framework 所重視的標準不一。像是 GWT 重視的是平台的獨立性，而 Spring 重視的是支援既存的各種 framework，達到中立性。Wicket 重視的是 HTML 語法的相容性，而 Echo2 重視的則是瀏覽器的相容性，以及 Swing 風格的設計思路。不過總而言之，新一代的 web framework 在這個面向已進步許多。

視覺元件與程式邏輯更明確的分割

這可分為「看起來是」與「實際上是」，像是 Wicket 就做到看起來是。有趣的是，Echo2 是看起來不是，但實際上卻是。至於 GWT 嗎，由於它的 server 端的邏輯是另外寫成 service，而 client 端的視覺元素在開發時也是以 java 撰寫。兩者採用一致的方式，不過卻必須分開撰寫，可以說它是實際上是，至於看起來是不是，就見仁見智了。

Web Application Framework:

MVC(Model-View-Controller)架構向來是設計GUI架構的標準架構。Java 在 web based 的 MVC 架構尤其大放異彩，百家爭鳴。Here is a Feature Matrix。比較著名的解決方案包括：

• Struts + JSF + JSP + JSTL: See also:
• • Display tag library: The display tag library is an open source suite of custom tags that provide high level web presentation patterns which will work in a MVC model, and provide a significant amount of functionality while still being simple and straight-forward to use.
  • Layout Helper: Tiles, SiteMesh,
• Tea/Velocity
• Tapestry
• Echo
• Wicket: Wicket is a Java web application framework that takes simplicity, separation of concerns and ease of development to a whole new level. Wicket pages can be mocked up, previewed and later revised using standard WYSIWYG HTML design tools. Dynamic content processing and form handling is all handled in Java code using a Swing-like component model backed by POJO data beans that can easily be persisted with Hibernate.
• XMLC/??
• JPublish: 不過我覺得它不是一個完整的Content Management系統，它反倒比較像是Content Management底層的一個 Framework。另外，如果你檢視它的設計，你也會發現它是一個很好的 MVC 架構。
• • ps: alternate to JPublish, OpenCms is a pure CMS, but don't integration with potal.
• WebWork: WebWork is a web application framework for J2EE. It is based on a concept called "Pull HMVC" (Pull Hierarchical Model View Controller)
• SOFIA: SOFIA sets a new standard for Java development by delivering so much more in a framework matching best-of-breed tools integration with robust JSP class and tag libraries. SOFIA shortens application development time on the strength of its visual development capabilities and pre-built Java components that dramatically simplify coding.
• Japple: Japple is a rapid application development environment for building web applications and services. Built on the JavaTM2 Platform and open-standards, Japple allows you to develop and deploy web applications faster, easier and more efficiently than traditional methods.

Server Application Framework:

• Spring:
• Keel Framework: Keel is ready made server side infrastructure. Keel incorporates multiple open source projects to provide you with a best of breed framework that works right out of the box.
  • Security layer
  • Database abstraction layer
  • Messaging layer
  • Business logic layer
  • User Interface layer
  • Struts
  • Cocoon
  • Velocity
  • Others in the works.
• eXo platform: Based on the most innovative tools, API and frameworks such as Java Server Faces, Pico Container, JbossMX and AspectJ, the eXo platform is probably one of the most promising Open Source project these days.
• J2EE for sure ....

Java web server 的 performance report

下列連結顯示各種 Java web server 的 performance report,

http://webperformanceinc.com/library/ServletReport/index....

由其中可以看出，Tomcat 的 performance 算是相當不錯。在 6 種測試的產品中，總體效能位居第 2 至第 3。

UI Plugins/Application Framework:

• JDesktop Network Components (JDNC) and JDesktop Integration Components (JDIC)
• JavaBeans Activation Framework (JAF): "JavaBeans Activation Framework"
  • See also:
  • The Bean Builder: "The Bean Builder is a simple component assembler that demonstrates new and emerging technologies within the Java platform that allow for the visual construction of applications using component assembly mechanisms."
• Eclipse Platform
  • Eclipse internally use OSGi framework to implement its plug-in framework. See alos:
  • Oscar - An OSGi framework implementation: "Oscar is an open source implementation of the Open Services Gateway Initiative (OSGi) framework specification; the goal is to to provide a compliant and completely implementation. To this end, Oscar is currently compliant with a large portion of the OSGi 2 and 3 specifications, although certain compliance work still needs to be completed. Despite this fact, the OSGi framework functionality provided by Oscar is very stable and is in use by many people."
• NetBeans: See "NetBeans Windowing System Quick Guide" - The renewed NetBeans IDE. A great GUI design.
• JRoots Application Framework
• Fractal
• JTwister: Development framework for rich Java/Swing client applications. Very good design. Worth a look!
• The Naked Objects Framework: A software framework that makes it easy to design and build business systems using the naked objects approach.

  Using the framework, a new business application is defined solely in terms of the business domain objects such as Customer, Product and Order. All the required business functionality is specified asbehaviours (methods) on those objects.

  When the business objects are compiled together with the framework classes, the resulting system automatically provides a user interface, that directly reflects the business domain objects and their behaviours. (It is possible to specify which business object classes, and which of their attributes and methods, are available to a particular user or in a particular context, but by default they are all made available.)

  • Resource:
  • Naked Objects Modules: SwingGUI: a Swing-based viewer for the Naked Objects framework.

XML Based Framework:

• Jelly : Executable XML
• XML Windowing Toolkit (XWT)
• Luxor
• Thinlets
• SwiXml
• XUI: Looks great!!
• JBrix - Xybrix: Xybrix is an XML application construction kit. It includes a rich set of libraries that allow applications that edit or otherwise work with XML to be defined, constructed and operated completely from XML configuration files. In other words, the resulting applications are both built from, and work with, XML. Xybrix can also be used to create applications that work with any other type of data as well - text, graphics, audio - anything that can be read from and written to a binary stream.
• RemoteRichGui: RemoteRichGui: Looks interesting. A client/server, thin-client/scripting framework use following project:
  • SwiXml (xml based Swing rendering engine) - www.swixml.org
  • BeanShell (embedded Java interpreter) - www.beanshell.org
  • DualRpcServer (bidirectional RPC framework) - www.retrogui.com
  • RemoteRichGui (this library) - www.retrogui.com
• form4j: form4j is a java package to provide easy interactive GUI forms.

  Basic Features:

  • Data interchange based completely on XML. form4j eats any data in XML format.
  • Form definitions also in XML
  • XPath expressions are used to give full flexibility to reference any data from specific form fields.
  • The form layout is based on TableLayout to give enough flexibility without too many layouting attributes.
  • A DOMModel ensures full MVC (Model-View-Controller) functionality among different form fields pointing to the same underlying data.
  • Conditional form elements: Any fields or form areas may be bound to XPath expressions on the data, to control Visibility and Editability.
  • Inherited attributes: To avoid stupid repetition of field attributes within the form definition, many attributes are inheritable from ancestor elements.

UI Library:

• JGoodies: include JGoodies Form, Look&Feel Libraries
• HtmlLayout: "HtmlLayout is a Java LayoutManager that allows you to specify the layout and resize behaviors of your components using a simple html-like syntax (no need to learn another language). HtmlLayout is similar to the GridBadLayout included with the JDK except that it is reasonably easy to use. "
• JForm: "JForm is a Swing component for handling form based user input. It handles form navigation and has support for databinding and validation."
• JWizardComponent: "Java Swing Wizard Component designed to be traveled through using Next, Back, Finish, Cancel. I have done many searches for something similar and was only able to find proprietary solutions that were as robust as I wanted them to be."
• JCustomizer: Ever want to "persistence" your UI preference in runtime? The target of this project is the customization of Java AWT/Swing GUI's at runtime, that means a support assistant or an user can customize the appearance of the graphical application he/she is deploying or using. This absolves developers from writing statements like setFont(new Font('i don't know')).

  A nice accompaniment is a WYSIWYG access to internationalization without programming efforts, including the possibility to switch the language of the GUI at runtime.

Resource TWiki . Main . SwingComponents: a list of enhanced Swing component

Frameworks that use Inversion of Control(IoC) Design Pattern:

• PicoContainer: PicoContainer is a small, simple container for arbitrary components. It is embeddable and extentensible. PicoContainer is designed for server and client side. PicoContainer is more than an IoC container. It's a tribute to simple, but controlled power.
• NanoContainer: The NanoContainer project is a collection of PicoContainer extensions
• Apache Avalon Framework: The Avalon Framework consists of interfaces that define relationships between commonly used application components, best-of-practice pattern enforcements, and several lightweight convenience implementations of the generic components.
• Loom: Loom is a micro-kernel designed and implemented on top of the DNA framework and supports components developed using the Avalon. In the future Loom will support DNA and Pico components.
• Spring (J2EE) Application Framework: Spring is a collection of small, well-focused, loosely coupled Java frameworks that can be used independently or collectively to build industrial strength applications of many different types. It is particularly useful for building enterprise applications.
• HiveMind: Using HiveMind means writing less code; code that you would ordinarily write for reading configuration files ... gone. Code for managing singleton service objects ... gone. The use of interceptors means that much repetetive coding also dissappears. For example, you can have a service automatically log method entry and exit using an interceptor rather than in your own code. In addition, a key HiveMind concept is plugability : a clean separation of interface and implementation is enforced. All code inside HiveMind must code against interfaces, because the implementations are dynamically located or even dynamically assembled.

See also:

• Inversion of Control Containers: a good blog on IoC concept and comparision of 3 major IoC design - HiveMind, PicoContainer and Spring

XML Component Framework:

• metaframework: MetaFramework - MetaFramework User Guide: MetaFramework is a request processing framework built around metadata. It allows developers to quickly and easily build and configure an application's Model, View, and Controller components using metadata.
• Xbeans: Xbeans are Java Beans that manipulate XML data. With the appropriate set of Xbeans and a Java Bean design tool, it is possible to build useful distributed applications with little or no programming. (We will describe several applications later.)

Other Component Framework:

• The Carbon Component Framework - The Carbon Project: Carbon is a light-weight component model and services framework providing enterprise quality services. Carbon is built on the following principles:
• • Create a more flexible architecture via a decoupled, metadata-centric system
  • Reduce complexity by providing access to services as small replaceable components
  • Encourage the separation of concerns, resulting in code assets that are easier to maintain, adapt and reuse in a complex and dynamic operating environment
  • Improve quality with highly documented, fully tested code
• WerX - Take Control of your Framework: WerX is a lightweight messaging system that utilizes reflection in a manner that facilitates the use of other controllers written by you, the developer.

Framework Library ESW Project: ESW is building an elegant, efficient, and effective software application framework in Java that makes creating n -tier applications much easier. Our programs handle data access, transport, data structure, and services architecture to speed application development.

Network Library:

• Spread: Spread is a toolkit that provides a high performance messaging service that is resilient to faults across external or internal networks. Spread functions as a unified message bus for distributed applications, and provides highly tuned application-level multicast and group communication support. Spread services range from reliable message passing to fully ordered messages with delivery guarantees, even in case of computer failures and network partitions. Spread is designed to encapsulate the challenging aspects of asynchronous networks and enable the construction of scalable distributed applications, allowing application builders to focus on the differentiating components of their application.
• ProActive: ProActive is a Java library (Source code under LGPL licence) for parallel, distributed, and concurrent computing, also featuring mobility and security in a uniform framework. With a reduced set of simple primitives, ProActive provides a comprehensive API allowing to simplify the programming of applications that are distributed on Local Area Network (LAN), on cluster of workstations, or on Internet Grids.
• Jakarta Commons/Net: an Internet protocol suite Java library originally developed by ORO, Inc. This version supports Finger, Whois, TFTP, Telnet, POP3, FTP, NNTP, SMTP, and some miscellaneous protocols like Time and Echo as well as BSD R command support. The purpose of the library is to provide fundamental protocol access, not higher-level abstractions. Therefore, some of the design violates object-oriented design principles. Our
  philosophy is to make the global functionality of a protocal accesible (e.g., TFTP send file and receive file) when possible, but also provide access to the fundamental protocols where applicable so that the programmer may construct his own custom implementations (e.g, the TFTP packet classes and the TFTP packet send and receive methods are exposed). NetComponents was originally a commercial product, but after ORO dissolved, it was continued to be made available for those who found it useful. However, no updates have been made since version 1.3.8, released in 1998. Now that certain contract obligations have
  expired, it is possible to make the source code freely available under the The Apache Software License.
  
• QuickServer: QuickServer is a free, open source Java library for robust and quick creation of a multi-threaded, multi-client TCP server applications.
  

RMI releated:

• Java 1.5 RMI支援執行時動態產生 stub class 的功能了!: "This release adds support for the dynamic generation of stub classes at runtime, obviating the need to use the Java(tm) Remote Method Invocation (Java RMI) stub compiler, rmic, to pregenerate stub classes for remote objects. Note that rmic must still be used to pregenerate stub classes for remote objects that need to support clients running on earlier versions."
  
• Frequently Asked Questions - RMI and Object Serialization: 最近遇到一個 RMI 的問題，就是當 RMI server 啟動在一台有兩個 IP address 的機器上時，client 端有可能抓到錯的 ip 位址。最後我在上面的連結之中找到解答!
  
• Apache Tomcat RMI Tunnelling How To: "10 Steps to RMI Tunneling"
  
• jGuru: Remote Method Invocation (RMI): "This short course covers the fundamentals of the Remote Method Invocation (RMI) technology, as found in the Java 2 platform."
  
• RmiJdbc - Home Page: "RmiJdbc is a client/server JDBC Driver that relies on Java RMI.
  All JDBC classes (like Connection, ResultSet, etc...) are distributed as RMI objects, so that you can distribute as you like the access to any database supporting the JDBC API."
  
• SwitchRMI - SwitchRMI: "SwitchRMI is a framework for remote method invocation from Java that allows the client to choose from one of several RMI protocols. Objects can be made available over a number of transports; HTTP and SMTP are implemented. Any object vended can respond to an RMI request in any one of the supported protocols. Clients and servers can interact with third party implementations of supported protocols. New protocols and transports can be plugged in to the framework at runtime."
  
• AltRMI - Overview: "AltRMI is a from-scratch replacement for RMI. It has a number of different features that make it easier to use. It tries as far as possible to be transparent in use. It is also inspired by the remoting facility in .NET. This does not mean that it has SOAP capabilty (yet), as it is more like the proprietary RPC transport for the .NET framework."