Edward's Blog » 后端语言

GlassFish Family

Edward — Tue, 07 Apr 2009 06:30:11 +0000

现在最新的发行版是:GFv2.1

再提多态

Edward — Mon, 30 Mar 2009 07:04:23 +0000

记得进入Sun的面试的时候Leon就问了我Java如何实现多态。当时的答案是通过重载和继承，后者也就是动态绑定。今天看到PHP与MySQL5程序设计里面的关于PHP不支持方法重载的时候，再次引起我对“多态”这个概念的探究。首先，多态是面向对象方面的一个重要特性，它本不应该依赖于特定的编程语言。WIKI 中对Polymorphism的定义如下：
In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B.
Operator Overloading the numerical operators +, -, /, * allow polymorphic treatment of the various numerical types integer, unsigned integer, float, decimal, etc; each of which have different ranges, bit patterns, and representations. Another common example is the use of the “+” operator which allows similar or polymorphic treatment of numbers (addition), strings (concatenation), and lists (attachment). This is a lesser used feature of polymorphism.
The primary usage of polymorphism in industry (object-oriented programming theory) is the ability of objects belonging to different types to respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. The programmer (and the program) does not have to know the exact type of the object in advance, and so the exact behavior is determined at run time (this is called late binding or dynamic binding).
从中我们可以看到，其实重载(override)并不是polymorphism，只是利于国人理解的一种解释。网上好多类似的讨论，一时也把我搞糊涂了，我特意去查了一下Thinking in Java，证实了以上的说法。总结一下就是继承是多态的基础，多态使得不同对象对同一条指令做出各自不同的响应。所以我当初的答案是不准确的，但是动态多态和静态多态的概念在C＋＋教学中普遍使用，使得在在中文中多态又多了一层含义。

而PHP不支持方法重载的很大原因也在于PHP是弱类型语言，类型本身就可以自动变更，方法重载也就省了。

使用NetBeans Profiler优化

Edward — Wed, 17 Dec 2008 09:36:33 +0000

啥也不说了！看视频：

NetBeans6.5 下载地址

Edward — Tue, 25 Nov 2008 07:42:43 +0000

NetBeans IDE 6.5 完全支持所有 Java 平台（Java SE、Java EE、Java ME 和 JavaFX），此外还是 PHP、Ajax 和 JavaScript、Groovy 和 Grails、Ruby 和 Ruby on Rails 以及 C/C++ 软件开发的理想工具。6.5 发行版增强了对 Web 框架 (Hibernate, Spring, JSF, JPA)、GlassFish v3 应用服务器以及数据库的支持。此外，它还包括新增的在 IDE 范围内快速搜索的快捷键、更加友好的用户界面以及自动在保存时编译功能。

NetBeans 6.5 国内本地下载：
http://zh-cn.netbeans.org/download/6.5/ml/
查看 NetBeans 6.5 发行信息：
http://zh-cn.netbeans.org/community/releases/65/index.html
JDK 1.6 Update 10 本地下载：
http://developers.sun.com.cn/download/java_se.html

寻找子串算法（Java）

Edward — Fri, 22 Aug 2008 11:24:38 +0000

这个算法用在DocWeb中的method的查找过程中。在ClassDoc中分别有API name()和method()。前一个是返回这个ClassDoc类型的名字的，也就是Java源码中某个类的名字的，例如AnnotationDesc，而后一个返回的是一个数组，数组中存储的这个Class的所有方法，但是其中存储的是它的全路径例如，com.sun.javadoc.AnnotationDesc.annotationType()。这时候，我就面对这样一个问题，我需要取出后面的字符串，在我这个例子中是annotationType().

算法如下：

static private int getNo(String str,String subStr)
{
int end=str.length()-subStr.length();
if(end>=0)
{
for(int k=0;k<=end;k++){
for(int l=0;str.charAt(k+l)==subStr.charAt(l);l++){
if(l==subStr.length()-1) return(k+l+1);
}
}
}
return(-1);
}

这里返回的整数就是下一个要输出字符串的位置。

主函数如下：

public static void main(String[] args) {
          String a="sdlfkabcdf";
          String b="abc";
          int no=getNo(a,b);
          if(no>0){
          System.out.println(a.substring(no));
          }else{
              System.out.println("an erro accured");
          }
}

输出结果：

这个算法的时间复杂度是O(n2),算法的效率一般，但是工作起来还可以，下次可以参考KMP算法作出改进。

What is SOAP

Edward — Tue, 29 Jul 2008 01:00:38 +0000

SOAP stands for Simple object access protocol.It is used for exchanging XML based message over networks.It normally uses HTTP, and it forms the foundation of web services protocol stack providing a basic message frame.

Tim Bray抨击SOAP和Java

Edward — Mon, 28 Jul 2008 13:41:16 +0000

这是一篇来自在JW的By Paul Krill的文章，稳重Bary（Sun工程师）认为SOAP是失败的。

正文如下：

旧金山（07/24/2008）来自sun公司的工程师Tim Bary说Web Services中的SOAP堆栈是失败的，他认为REST机制可以作为SOAP的替代品。

sun的web技术方面的主管Bray在O‘Reilly的开源公约中的访谈中认为“这些年来，SOAP 堆栈是一个令人印象深刻的失败，REST 完成了SOAP 想要做到的，更加的可视化，优雅，便宜，同时是可以担负的起的，但是唯一的缺点就是到目前为止缺乏现有的工具支持。”

REST 可以被用来做集成和使用。例如PHP页面前端必须要和Java制造系统相适应。

将会有一些工具可以帮助开发者使用REST，这些工具将会来自像sun，微软和oracle这样的公司。这些工具将会使得创建和测试REST服务更加的方便。

SOAP和一系列WS-＊定义了安全，通信和其他的特定功能。其中一些包括Ruby on Rails的创始人Heinemeir Hansson，同时命名为“WS Death star”，模仿了“Star Wars”中地方的大本营的名字。

定义了SOA和Web Services的ZapThink的分析师坚决和Bary持相反意见。

ZapThink的资深分析师说，”Tim Bary是一个REST支持者，他必然会抨击SOAP以促进REST，SOAP现在活的很好，但是现在SOAP没有采取广泛的活动，如果你能找到相关的证据，请让我知道！”

ZapThink的合伙人Jason Bloomberg说，“具有讽刺意味的是，缺乏REST工具的认识，实际省JackBe，Corizon和其他工具都支持REST”

Bray也引用了一个迫切的对REST测试（面向协议和架构）工具的需求来表明他的观点。

在周五OSCON的一个主要报告中，Brat将会讨论关于“语言拐点”，在这个演讲中各种编程语言例如Perl，Pathon和Ruby正在积蓄势力意在和Java和.Net平台竞争。

“直到两年前，如果你一个写Java或是.Net程序的程序员，现在你有很多其他的选择，这真是一个拐点。”

Bray说“Java平台现在推荐一些脚本语言例如Ruby和Pathon，Sun的JVM已经能够兼容这些脚本语言了，Java已经不是哪些新潮小孩的选择了”

他还说“但是，Java还是在我们身边无处不在，Java不会离去，这是世界上最流行的编程语言。”

最后，他强调：“不管我是否喜欢，将来将会是多语言并存的时代”

How to set your html head

Edward — Thu, 17 Jul 2008 07:40:45 +0000

在你每一个页面的顶端，你需要文档声明。是的，必须。

如果不指定文档类型，你的HTML不是合法的HTML，并且大部分浏览器会用“怪癖模式（quirks mode）”来处理页面，这意味着浏览器认为你自己也不知道究竟做什么，并且按浏览器自己的方式来处理你的代码。你可以是一个HTML大师，在地球上打遍天下无敌手，或者你的HTML可以无瑕疵，CSS可以很完美，但如果没有文档声明，或者错误的文档声明，你的网页与一个短视的，独眼的长臂猿婴儿十分艰难地堆砌起来的没两样。

XHTML 1.0 Strict（严格）的文档声明是这样的：

http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd“>

下面的是XHTML 1.1的文档声明，作为XHTML的最新版本，看起来更完美，但还是有一些问题，随后我们会稍微讲解……

http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd“>

如果你不愿放弃HTML 4或者你还有Netscape 4死忠用户，你可以使用XHTML 1.0 Transitional（过渡型）：

http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd“>

你使用这的唯一理由是你还要兼容老版本的，少用的浏览器。过渡型XHTML 1.0允许HTML 4的表现元素，其也可能在如Netscape 4的浏览器中表现更好。但使用这些元素将对你网页的效率和可用性有害。

最后，如果你是使用框架的怪人之一，可以使用像下面一样的XHTML 1.0 Frameset（框架）文档类型声明：

http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd“>

注意DOCTYPE标签必须大写和前置一个英文半角感叹号!。它是唯一一个打破规则的标签，它不需要关闭。

语言声明

即使HTTP头或者在html起始标签内设置了xml:lang属性，你也必须为文档指定一个主要语言。尽管处理一个合法的XHTML文档这不是必须的，但也是一个易用性的考虑。值是缩写的，比如en（English，英语），fr（French，法语），de（German，德语）或者mg （Malagasy，这是什么语？译者也不知道，呵呵。——译者注）。

声明一个主要用英语内容的文档，例子是这样的：

http://www.w3.org/1999/xhtml” xml:lang=”en”>

在声明主要语言之后，假如还需要使用其他语言，你还可以在内联中使用xml:lang属性（比如HTML Hund）。

内容类型

HTML文档的媒体类型和字体集也许要指定，可以使用HTTP头来完成，比如：

Content-Type: text/html; charset=UTF-8

HTTP头部的第一部分（如text/html)是文件MIME类型，让浏览器知道文件的媒体类型因此可以知道怎么处理。所有的文件都有MIME类型。JPEG图像是image/jpeg，CSS文件是text/csss和HTML一般使用text/html。

HTTP头部的第二部分（如UTF-8部分）是字符集。
也许设置HTTP头的最简易方法是在HTML中使用“HTTP同义（HTTP-equivalent）”的头标签，像这样：

些微复杂当更好的方法是使用服务器端脚本语言来发送头。用PHP的话，你可以这样做：

如果你不愿意（或不能）使用服务器端脚本语言，你也许可以直接给服务器设置一个“.htaccess”文件。大部分服务器（Apache兼容）可以在根目录使用一个“.htaccess”的小文本文件，写入下面的内容，你就可以把所有的“html”后缀文件都与MIME类型和字符集关联：

AddType text/html;charset=UTF-8 html

字符集包括大部分西方基于拉丁文语言的“ISO-8859-1”，日语的“SHIFT_JIS”，中文的“GB18030”和UTF-8，一个 Unicode Transformation Format版本，提供大范围的多种语言的单个字符。基本上，你应该使用一个你知道的，能为你用户清楚认知的字符集。除非你使用基于拉丁语的语言（包括英语）（ISO-8859-1被普遍接受的），你应该使用UTF-8因为它可以显示大多数语言的大多数字符，使用它也是安全的，因为它可以在大部的计算机上使用。

注意

XHTML应该当作application/xhtml+xml的MIME类型来使用，再清楚不过，这是XML程序。不幸的是，大部分浏览器没有对这没有第一线索。所以，一般认为使用text/html的MIME类型是不错的。根据W3C的建议和网页标准工程的未来亮点，调味的XHTML 1.0也许可以作text/html使用，但XHTML 1.1不应该，这就是这个网站以XHTML 1.0 Strict（严格）作为例子，假定text/html的MIME类型。但是你仍然可以（或许不应该）为它们设置正确的MIME类型给浏览器，轻微的调用一下服务器端即可。

这个网站使用PHP为XHTML 1.1设置application/xhtml+xml的MIME类型给那些能够理解和处理这个类型的浏览器（如Mozilla），为XHTML 1.0 Strict设置text/html给其他浏览器（如IE）。为每一个页面的顶部加入如下代码：

http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd”>’); } else { header(”Content-Type: text/html; charset=UTF-8″); echo (’http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>’); } ?>

这些检查核实浏览器是否接受application/xhtml+xml的MIME类型，如果接受，就发送这个MIME类型并把XHTML 1.1文类类型写到HTML中。如果这个MIME类型不被接受，就发送text/html的MIME类型并把XHTML 1.0 Strict（严格）的文档类型写入HTML。

除了你知道你正在做着正确的事情和为自己准备将来的路的平和想法外，最直接的益处就是，使用这个方法，Mozilla浏览器把你的文件当作 XML程序对待并且如果你的XHTML还没有抓痒，就是说不合式的，Mozilla就不会工作。然后你就可以排错了，而不需要用校验器来运行你的文档了。

A concept of Glassfish

Edward — Thu, 17 Jul 2008 07:11:01 +0000

GlassFish has a concept of a domain. More precisely, it is the administrative domain. At first, it may be perceived a little difficult to understand, especially given that in Java EE paradigm, one is used to servers rather than domains. This is especially true with developers.
This post tries to explain what a GlassFish Domain (domain, henceforth) is, how to use it effectively if you want to quickly deploy your applications to GlassFish and the reasons to call it a domain.
A domain (statically) is an administrative name space. It’s a boundary, all GlassFish entities within which are controlled by an administrator or more precisely administrative three tuple (Let’s call it Admin 3T). This three tuple is called “admin user, admin password, certificate database password (or master password). If you are a developer, you don’t really care about the master password and it defaults to “changeit“. This is the password with which your keystore (cacerts.jks) is locked and most of the times, you don’t care about this.

This is how your domains look like.

A domain (dynamically) is a Java EE Engine. Thus it is your server, once you have started it. In other words, at run time, a domain = server. Thus, a running domain can host user Java EE applications and can be effectively used as the target for your deployments. For developers, this is what they care about. It is for developers that this gap has been bridged and they can forget about the domain. The defaults are so carefully chosen that you’d never need to know about the fact that you are managing and deploying to a domain!

So, what is that that domain provides on top of behaving like a server? Here is a list of things:

Domain provides you with a built-in administration capability.
Domain has multiple system applications predeployed which facilitate the management. Thus the entire admin console
is available as a system web application. All you need to do it connect to “http://localhost:admin-port(4848)”.
Domain has another system application predeployed to take care of all the asadmin commands. Note that (almost) all the asadmin commands invoke the running domain in
Domain has an EJB Timer Service already configured to work with. A timer database is also created.
Domain has a JDBC Connection Pool configured for the EJB timer database.
Domain has two keyfiles created by default so that one has authentication realms for the security conscious people. All you need to do is create the security mappings in your applications.
Domain has a default web.xml that decides the default behavior of all deployed web applications.
Domain has a JMX Connector’s Server end so that you can easily connect to the admin infrastructure, using JConsole and browse the MBeans. As you know MBeans are to Administration what EJB’s are to Enterprise Computing.

All this is enabled by a simple set of steps:

Either you download GlassFish and invoke ant -f setup.xml that creates the so-called fully configured, ready-to-go default domain, OR
Explode the GlassFish image and do [glassfish]/bin/asadmin create-domain –adminport 4848 mydomain

All this is great. But how does a developer exploit it?

Simple. Your answer is NetBeans. Just download “The” IDE and do the following:

Go to the Runtime tab and right click for “Adding a target server”.
See how NetBeans itentifies your default domain, domain1. The port is also identified. This is the administration port. Next, you could provide the user name and password for administration. That’s it. This domain is now deployment ready .
You need to create a web application. Just create it using the intuitive menus in the IDE.
The IDE is so well integrated with the GlassFish domain/server is that it just allows you to start the GlassFish server in debug mode and debug your application. This is really seamless!
Here is your application deployed and being tested!

This is how I develop and test my applications. I am a developer. Hope fellow developers find this as easy as I do.

If you are a CLI fan, there are a bunch of intuitive asadmin commands that configure the domain/server.
If you are an ANT fan, there are ANT tasks like sun-appserv-deploy that help you continue to write your build.xml files.
We are planning to integrate asadmin into a scripting language of your choice. You’d have to wait till Mustang releases, though.
I know this sounds easy. But it sounds so because it is so.

Finally, the $1M Question: Why do you call it a domain? Well, the reason lies in more sophisticated Sun Software like Application Server Standard Edition (SE) . When you enter into the real enterprise arena, it is no more a server. It is a bunch of servers (which are also known as app server instances, each of which is a Java EE Engine) that are woven into clusters to impart the coveted high availability. Still, the “Administrative” domain remains the same. You don’t have to learn a new concept when you go from one edition of the product to an advanced one. A set of simple rules emerges:

A Domain is comprised of a set of Instances. A Domain is “bigger” than an Instance.
Domain has a “dual nature”. For a simple case, Domain equals Instance (I tend to relate to the dual nature of electron — “is it a wave, is it a particle” here ).

Thus, it is the best of both the worlds: For developers, a domain is a server. For system administrators, a domain is something that they manage so that an uninterrupted service is provided!

Makes sense to me. How about you? Please let me know …

Study Report(5.22)

Edward — Thu, 22 May 2008 11:16:26 +0000

营销课（5.22）

Java高级特性（4）作业

Edward — Tue, 20 May 2008 12:55:24 +0000

题目：

试编写一个基于消息队列的股票交易价格显示程序。该程序中的一个线程模拟从卫星通信、微波通信或股票信息发射台等不同途径获取最新的股票交易价格信息，并将价格数据写入一个消息队列中；程序中的另一个线程负责从消息队列中取出价格数据，并以图形方式展示给终端用户。
（提示：设计本程序的关键是处理好消息队列的同步问题；还可考虑使用输入?输出流或JDBC 实现消息队列的持久性。）

什么是消息队列：

消息队列是线程间通讯的手段：

import java.util.*

public class MsgQueue{

private Vector queue = null;

public MsgQueue(){

queue = new Vector();

}

public synchronized void send(Object o)

{

queue.addElement(o);

}

public synchronized Object recv()

{

if(queue.size()==0)

return null;

Object o = queue.firstElement();

queue.removeElementAt(0);//or queue[0] = null can also work

return o;

}

同时可以使用java.util.concurrent来实现连接池、消息队列

多线程：

实现方式：

extend Thread

implements Runnable

构造是Thread(适合Run方法小的情况下)

线程加锁:synchronized

线程之间的通信：wait() 和notifyAll()

Web服务器(Web Container such as Tomcat and Apache)的作用：产生一个连接池，为每一个连接分类一个线程，这样做能够省去每个请求创建Thread对象的开销。

JSP、Servlet、Tomcat、JDK、J2EE版本比较

Edward — Mon, 29 Nov 1999 16:00:00 +0000

一 JSP2.0与JSP1.2比较
JSP 2.0是对JSP 1.2的升级，新增功能：
1. Expression Language

2. 新增Simple Tag和Tag File

3.web.xml新增元素

特别说明web.xml.
web.xml新增元素

元素主要用来设定JSP相关配置，包括和
子元素。

(1)其中以前的Jsp1.2中就有的,taglib主要作用是作为页面taglib标签中的uri和tld文件的一个映射关系

(2)其中是JSP2.0种新增的元素。
主要包括8个子元素，它们分别是：

设定的说明

设定名称

设定值所影响的范围

若为true则不支持EL语法<／el-ignored>

ISO-8859-1

若为true则不支持<% scripting%> 语法

设置JSP网页的抬头,扩展名为.jspf

设置JSP网页的结尾,扩展名为.jspf

例如: 其中抬头程序:
prelude.jspf

文本内容

结尾程序:
coda.jspf

文本内容

二、Servlet个版本比较
servlet 2.3 新增功能:
2000年10月份出来
Servlet API 2.3中最重大的改变是增加了filters

servlet 2.4 新增功能:
2003年11月份出来
1、web.xml DTD改用了XML Schema;

Servlet 2.3之前的版本使用DTD作为部署描述文件的定义，其web.xml的格式为如下所示：

PUBLIC “-//sunMicrosystems,Inc.//DTD WebApplication 2.3f//EN”
“http://java.sun.com/j2ee/dtds/web-app_2.3.dtd“>

…….

Servlet 2.4版首次使用XML Schema定义作为部署描述文件，这样Web容器更容易校验web.xml语法。同时XML Schema提供了更好的扩充性，其web.xml中的格式如下所示：

http://java.sun.com/xml/ns/j2ee”
xmlns:workflow=”http://www.workflow.com”
xmins:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd“>
………

注意: 改为Schema后主要加强了两项功能:
(1) 元素不依照顺序设定
(2) 更强大的验证机制
主要体现在:
a.检查元素的值是否为合法的值
b.检查元素的值是否为合法的文字字符或者数字字符
c.检查Servlet,Filter,EJB-ref等等元素的名称是否唯一
2.新增Filter四种设定：REQUEST、FORWARD、INCLUDE和ERROR。
3.新增Request Listener、Event和Request Attribute Listener、Enent。
4.取消SingleThreadModel接口。当Servlet实现SingleThreadModel接口时，它能确保同时间内，只能有一个thread执行此Servlet。
5.可以为Servlet。
6.ServletRequest接口新增一些方法。
public String getLocalName()
public String getLocalAddr()
public int getLocalPort()
public int getRemotePort()

Servlet 2.5的新特征
2005年9月发布Servlet 2.5
Servlet2.5一些变化的介绍：
1）基于最新的J2SE 5.0开发的。
2）支持annotations 。
3） web.xml中的几处配置更加方便。
4）去除了少数的限制。
5）优化了一些实例

servlet的各个版本对监听器的变化有：
(1)servlet2.2和jsp1.1
新增Listener:HttpSessionBindingListener
新增Event: HttpSessionBindingEvent
(2)servlet2.3和jsp1.2
新增Listener:ServletContextListener,ServletContextAttributeListener
,HttpSessionListener,HttpSessionActivationListener,HttpSessionAttributeListener
新增Event: ServletContextEvent,ServletContextAttributeEvent,HttpSessionEvent
(3)servlet2.4和jsp2.0
新增Listener:ServletRequestListener,ServletRequestAttribureListener
新增Event: ServletRequestEvent,ServletRequestAttributeEvent
三、J2EE规范版本比较
1.J2EE的发展

1997年Servlet技术的产生以及紧接着JSP的产生，为Java对抗PHP，ASP等等服务器端语言带来了筹码。1998年，Sun发布了EJB1.0标准，至此J2EE平台的三个核心技术都已经出现。于是，1999年，Sun正式发布了J2EE的第一个版本。并与1999年底发布了J2EE1.2，在2001年发布了J2EE1.3，2003年发布了J2EE1.4。

2.J2EE1.3
J2EE1.3的架构，其中主要包含了Applet容器，Application Client容器，Web容器和EJB容器，并且包含了Web Component，EJB Component，Application Client Component，以JMS，JAAS，JAXP，JDBC，JAF，JavaMail，JTA等等技术做为基础。

1.3中引入了几个值得注意的功能：Java消息服务（定义了JMS的一组API），J2EE连接器技术（定义了扩展J2EE服务到非J2EE应用程序的标准），XML解析器的一组Java API，Servlet2.3，JSP1.2也都进行了性能扩展与优化，全新的CMP组件模型和MDB（消息Bean）。

3.J2EE1.4

J2EE1.4大体上的框架和J2EE1.3是一致的，1.4增加了对Web服务的支持，主要是Web Service，JAX-RPC，SAAJ，JAXR，还对EJB的消息传递机制进行了完善（EJB2.1）,部署与管理工具的增强（JMX），以及新版本的Servlet2.4和JSP2.0使得Web应用更加容易。

四、Tomcat版本比较
Tomcat 3.x
servlet2.2和jsp1.1标准
Tomcat 4.x
Servlet 2.3 和 JSP 1.2 版本
Tomcat 5.x
Servlet 2.4或2.5 和 JSP 2.0 版本

五、JDK版本比较
已发行的版本:
版本号名称中文名发布日期
JDK 1.1.4 Sparkler 宝石 1997-09-12
JDK 1.1.5 Pumpkin 南瓜 1997-12-13
JDK 1.1.6 Abigail 阿比盖尔–女子名 1998-04-24
JDK 1.1.7 Brutus 布鲁图–古罗马政治家和将军 1998-09-28
JDK 1.1.8 Chelsea 切尔西–城市名 1999-04-08
J2SE 1.2 Playground 运动场 1998-12-04
J2SE 1.2.1 none 无 1999-03-30
J2SE 1.2.2 Cricket 蟋蟀 1999-07-08
J2SE 1.3 Kestrel 美洲红隼 2000-05-08
J2SE 1.3.1 Ladybird 瓢虫 2001-05-17
J2SE 1.4.0 Merlin 灰背隼 2002-02-13
J2SE 1.4.1 grasshopper 蚱蜢 2002-09-16
J2SE 1.4.2 Mantis 螳螂 2003-06-26
将发行的版本:
J2SE 5.0 (1.5.0) Tiger 老虎已发布了Beta版本
J2SE 5.1 (1.5.1) Dragonfly 蜻蜓未发布
J2SE 6.0 (1.6.0) Mustang 野马未发布

JSP、Servlet、Tomcat、JDK、J2EE版本比较

Edward — Mon, 29 Nov 1999 16:00:00 +0000

一 JSP2.0与JSP1.2比较
JSP 2.0是对JSP 1.2的升级，新增功能：
1. Expression Language

2. 新增Simple Tag和Tag File

3.web.xml新增元素

特别说明web.xml.
web.xml新增元素

元素主要用来设定JSP相关配置，包括和
子元素。

(1)其中以前的Jsp1.2中就有的,taglib主要作用是作为页面taglib标签中的uri和tld文件的一个映射关系

(2)其中是JSP2.0种新增的元素。
主要包括8个子元素，它们分别是：

设定的说明

设定名称

设定值所影响的范围

若为true则不支持EL语法<／el-ignored>

ISO-8859-1

若为true则不支持<% scripting%> 语法

设置JSP网页的抬头,扩展名为.jspf

设置JSP网页的结尾,扩展名为.jspf

例如: 其中抬头程序:
prelude.jspf

文本内容

结尾程序:
coda.jspf

文本内容

二、Servlet个版本比较
servlet 2.3 新增功能:
2000年10月份出来
Servlet API 2.3中最重大的改变是增加了filters

servlet 2.4 新增功能:
2003年11月份出来
1、web.xml DTD改用了XML Schema;

Servlet 2.3之前的版本使用DTD作为部署描述文件的定义，其web.xml的格式为如下所示：

PUBLIC “-//sunMicrosystems,Inc.//DTD WebApplication 2.3f//EN”
“http://java.sun.com/j2ee/dtds/web-app_2.3.dtd“>

…….

Servlet 2.4版首次使用XML Schema定义作为部署描述文件，这样Web容器更容易校验web.xml语法。同时XML Schema提供了更好的扩充性，其web.xml中的格式如下所示：

3.J2EE1.4

四、Tomcat版本比较
Tomcat 3.x
servlet2.2和jsp1.1标准
Tomcat 4.x
Servlet 2.3 和 JSP 1.2 版本
Tomcat 5.x
Servlet 2.4或2.5 和 JSP 2.0 版本

J2EE项目中的数据持久层设计

Edward — Mon, 29 Nov 1999 16:00:00 +0000

数据持久层的设计目标是为整个项目提供一个高层、统一、安全和并发的数据持久机制。完成对各种数据进行持久化的编程工作，并为系统业务逻辑层提供服务。数据持久层提供了数据访问方法，能够使其它程序员避免手工编写程序访问数据持久层(Persistene layer)，使其专注于业务逻辑的开发，并且能够在不同项目中重用映射框架，大大简化了数据增、删、改、查等功能的开发过程，同时又不丧失多层结构的天然优势，继承延续J2EE特有的可伸缩性和可扩展性。

1 数据持久层及ORM映射框架

笔者从事的项目中的数据持久层，是基于J2EE体系结构，并采用了Hibernate作为持久映射框架。

Hibernate是一种新的ORM映射工具，是JDBC的轻量级的对象封装。Hibernate可以用在JDBC可以使用的任何场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。Hibernate不仅提供了从Java类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来手工操作数据库，使用Hibernate，可以大大减少操作数据库的工作量。

Hibernate是一个和JDBC密切关联的、独立的对象持久层框架，可以搭配各种App Server、Web Server、EJB Container共同使用，Hibernate的兼容性仅同JDBC驱动、底层数据库产品间有一定的关系，但是和使用它的Java程序、App Server没有任何关系，也不存在兼容性问题。而且事实表明Hibernate可以和多种Web服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器（达16种）。

在较为常用的数据持久方案中，Hibernate无疑是最优秀的，下面是对各种持久方案的比较。

¨ 流行的数据持久层架构：

Business Layer <-> Session Bean <-> Entity Bean <-> DB

¨ 为了解决性能障碍的替代架构：

Business Layer <-> DAO <-> JDBC <-> DB

¨ 使用Hibernate来提高上面架构的开发效率的架构：

Business Layer <-> DAO <-> Hibernate <-> DB

我们就上面3个架构来作如下分析。

(1)内存消耗：采用JDBC的架构无疑是最省内存的，Hibernate的架构次之，EB的架构最差。

(2)运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。EB的架构效率会差的很远。

(3)开发效率：在有Eclipse、JBuilder等开发工具的支持下，对于简单的项目，EB架构开发效率最高，JDBC次之，Hibernate最差。但是在大的项目，特别是持久层关系映射很复杂的情况下，Hibernate效率高的惊人，JDBC次之，而EB架构很可能会失败。

2 数据持久层设计

复杂性是应用开发过程中最令人头疼的一个问题。每当在一个应用中增加一个功能时，它的复杂性通常呈几何级的增长。这种复杂性往往导致程序的开发无法再继续下去。这也是现在为什么许多应用只有Beta版本而没有正式版的原因。

专家将应用开发过程产生的复杂性分为两类，即非本质的（accidental）和本质的（essential）。本质的复杂性是对于解决目标问题所必然产生的复杂性，非本质的复杂性是由于选择了不适当的开发工具和设计工具而产生的复杂性。对于一个功能确定的程序来讲，本质的复杂性是确定的，而非本质的复杂性则是没有限制的。因此，一个应用的开发要想较顺利地取得成功，就需要尽可能地减少非本质的复杂性。

设计模式使人们可以更加简单方便地复用成功的设计和体系结构。将已证实的技术表述成设计模式，也会使新系统开发者更加容易理解其设计思路。

衡量一个系统优秀与否的关键因素，除了能够满足用户需求外还有如下方面：首先是灵活性。灵活性意指这种结构或模式不依赖于任何实际应用，应该与操作系统、应用程序无关。提供独立的结构，可以提供最大的重用。其次是可扩展性。随着业务的扩展，新的业务不断增加，业务逻辑自然增加，系统必然会进行修改或添加相应功能模块。再次是可配置性。最后是安全性。

数据持久层的设计采纳了多种设计模式，最大限度的降低了系统内部各模块、子系统间的耦合性，使得系统相对易于扩展，并且能够在进行改变时，保证持久层的业务逻辑层相对稳定，基本不需要因持久层的调整改变而进行逻辑层的变动。

笔者在项目中采用了如下设计模式。

2.1 整体架构——MVC模式（模型-视图-控制器）

¨ 模型（Model）：模型包含完成任务所需要的所有的行为和数据。在数据持久层中，模型即为值对象以及数据访问对象。

¨ 视图（View）：数据持久层中，视图就是持久层同其它层进行数据交换的值对象（Transfer Object）和视图助手对象。

¨ 控制器（Controller）：持久层所需的控制相对简单，因此集成到了控制代理中。

持久层整体采用MVC模式，使得整个数据持久层的实现部分与项目的业务逻辑部分隔离开来，能够实现对接口作大的修改而不需要对相应的模型进行修改。另外，持久层某子系统发生变化时，不会影响到其它子系统。有利于提高系统的稳定性、可维护性。

2.2 值对象模式（Value Object Pattern）

值对象用来封装业务对象。相应的方法调用是设置（getter）和检索（setter）值对象。它是任意的可串行化的Java对象，当客户端Bean请求业务数据时，该Bean可以构造值对象，用属性值来填充，并按照值把它传递给客户端。

在笔者开发项目的数据持久层体系结构中，值对象主要应用在子系统间传递、交换数据（Transfer Object）和映射数据表两个方面（Persistent Object）。

在各子系统间进行数据传递和数据交换时，使用值对象模式能够最大化地降低系统间数据传递的开销。在这种策略下传递的是对象而不再是一个个的有意义的数据，使得系统在进行扩充、修改时，各子系统间数据传递部分不会受到影响，因为各子系统仅需要关心是否有值对象被传递，而并不去关心传递的到底是什么数据。

在映射数据库表时，值对象类及其子类所构成的树形结构被用来映射一个数据库表，该继承树通过XML配置文件对应数据库中的单个表，这使得最底层的关系型的数据库表结构能够面向对象模型所隐藏，另外，由于面向对象设计方法中类的可继承性，采用继承树对应一个表的策略使得该映射策略极易扩展，并且能够将一个复杂的数据表转化成若干简单的值对象来表示，提高了系统的可维护性和可修改性。

2.3 数据访问对象（DAO）

根据数据源不同，数据访问也不同。根据存储的类型(关系数据库、面向对象数据库等)和供应商不同，持久性存储(比如数据库)的访问差别也很大。当业务组件或表示组件需要访问某数据源时，它们可以使用合适的API来获得连接性，以及操作该数据源。但是在这些组件中包含连接性和数据访问代码会引入这些组件及数据源实现之间的紧密耦合。组件中这类代码依赖性使应用程序

J2EE

Edward — Mon, 29 Nov 1999 16:00:00 +0000

J2EE学习者越来越多，J2EE本身技术不断在发展，涌现出各种概念，本文章试图从一种容易理解的角度对这些概念向初学者进行解释，以便掌握学习J2EE学习方向。

首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一种语言，已经代表与微软不同的另外一个巨大阵营，所以Java有时是指一种软件系统的流派，当然目前主要是.NET和Java两大主流体系。

J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B/S（Browser浏览器/Server服务器）结构，而J2EE主要是指B/S结构的实现。

J2EE又是一种框架和标准，框架类似API、库的概念，但是要超出它们。如果需要详细了解框架，可先从设计模式开始学习。

J2EE是一个虚的大的概念，J2EE标准主要有三种子技术标准：WEB技术、EJB技术和JMS，谈到J2EE应该说最终要落实到这三个子概念上。

这三种技术的每个技术在应用时都涉及两个部分：容器部分和应用部分，Web容器也是指Jsp/Servlet容器，你如果要开发一个Web应用，无论是编译或运行，都必须要有Jsp/Servlet库或API支持（除了JDK/J2SE以外）。

Web技术中除了Jsp/Servlet技术外，还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初裸体简称为Jsp/Servlet+JavaBeans系统。

谈到JavaBeans技术，就涉及到组件构件技术（component），这是Java的核心基础部分，很多软件设计概念（设计模式）都是通过JavaBeans实现的。

JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet）调用，那么JavaBeans就运行在J2EE的Web容器中；如果它被EJB调用，它就运行在EJB容器中。

EJB（企业JavaBeans）是普通JavaBeans的一种提升和规范，因为企业信息系统开发中需要一个可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。

至此，JavaBeans组件发展到EJB后，并不是说以前的那种JavaBeans形式就消失了，这就自然形成了两种JavaBeans技术：EJB 和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且这个JavaBeans不依附某种框架，或者干脆可以说：这个 JavaBeans是你为这个应用程序单独开发创建的。

J2EE应用系统开发工具有很多：如 JBuilder、Eclipse等，这些IDE首先是Java开发工具，也就是说，它们首要基本功能是可以开发出JavaBeans或Java class，但是如果要开发出J2EE系统，就要落实到要么是Web技术或EJB技术，那么就有可能要一些专门模块功能(如eclipse需要 lomboz插件)，最重要的是，因为J2EE系统区分为容器和应用两个部分，所以，在任何开发工具中开发J2EE都需要指定J2EE容器。

J2EE容器分为WEB容器和EJB容器，Tomcat/Resin 是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用 Tomcat实现的。所以你开发的Web应用程序可以在上面两种容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上运行，商业产品 Websphere/Weblogic等和JBoss属于同一种性质。

J2EE容器也称为J2EE服务器，大部分时它们概念是一致的。

如果你的J2EE应用系统的数据库连接是通过JNDI获得，也就是说是从容器中获得，那么你的J2EE应用系统基本与数据库无关，如果你在你的J2EE 应用系统耦合了数据库JDBC驱动的配置，那么你的J2EE应用系统就有数据库概念色彩，作为一个成熟需要推广的J2EE应用系统，不推荐和具体数据库耦合，当然这其中如何保证J2EE应用系统运行性能又是体现你的设计水平了。

衡量J2EE应用系统设计开发水平高低的标准就是：解耦性；你的应用系统各个功能是否能够彻底脱离？是否不相互依赖，也只有这样，才能体现可维护性、可拓展性的软件设计目标。

为了达到这个目的，诞生各种框架概念，J2EE框架标准将一个系统划分为WEB和EJB主要部分，当然我们有时不是以这个具体技术区分，而是从设计上抽象为表现层、服务层和持久层，这三个层次从一个高度将J2EE分离开来，实现解耦目的。

因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现，这时，你可以使用EJB规范实现服务层和持久层，Web技术实现表现层；

EJB为什么能将服务层从Jsp/Servlet手中分离出来，因为它对JavaBeans编码有强制的约束，现在有一种对JavaBeans弱约束，使用Ioc模式实现的（当然EJB 3.0也采取这种方式），在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans约束，形成一个服务层，这也是是Jive这样开源论坛设计原理之一。

由此，将服务层从表现层中分离出来目前有两种可选架构选择：管理普通JavaBeans（POJO）框架(如Spring、 JdonFramework)以及管理EJB的EJB框架，因为EJB不只是框架，还是标准，而标准可以扩展发展，所以，这两种区别将来是可能模糊，被纳入同一个标准了。

但是，个人认为：标准制定是为某个目的服务的，总要牺牲一些换取另外一些，所以，这两种架构会长时间并存。

前面谈了服务层框架，使用服务层框架可以将JavaBeans从Jsp/Servlet中分离出来，而使用表现层框架则可以将Jsp中剩余的 JavaBeans完全分离，这部分JavaBeans主要负责显示相关，一般是通过标签库（taglib）实现，不同框架有不同自己的标签库， Struts是应用比较广泛的一种表现层框架。

这样，表现层和服务层的分离是通过两种框架达到目的，剩余的就是持久层框架了，通过持久层的框架将数据库存储从服务层中分离出来是其目的，持久层框架有两种方向：直接自己编写JDBC等SQL语句（如iBatis）；使用O/R Mapping技术实现的Hibernate和JDO技术；当然还有EJB中的实体Bean技术。

持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架，当然，表现层框架现在又出来了一个JSF，它代表的页面组件概念是一个新的发展方向，但是复杂的实现让人有些忘而却步。

在所有这些J2EE技术中，虽然SUN公司发挥了很大的作用，不过总体来说：网络上有这样一个评价：SUN的理论天下无敌；SUN的产品用起来撞墙；对于初学者，特别是那些试图通过或已经通过SUN认证的初学者，赶快摆脱SUN的阴影，立即开溜，使用开源领域的产品来实现自己的应用系统。

最后，你的J2EE应用系统如果采取上面提到的表现层、服务层和持久层的框架实现，基本你也可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系统了。

还要注意的是: 开发出一个高质量的J2EE系统还需要正确的业务需求理解，那么域建模提供了一种比较切实可行的正确理解业务需求的方法，相关详细知识可从UML角度结合理解。

当然，如果你想设计自己的行业框架，那么第一步从设计模式开始吧，因为设计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会了系统基本单元JavaBean
或类之间解耦时，那么系统模块之间的解耦你就可能掌握，进而你就可以实现行业框架的提炼了，这又是另外一个发展方向了。

以上理念可以总结为一句话：

J2EE开发三件宝: Domain Model（域建模）、patterns（模式）和framework（框架）。

我的第一个JDBC程序

Edward — Mon, 05 May 2008 02:58:59 +0000

try {
            Class.forName(”com.mysql.jdbc.Driver”);
            String connectionUrl1 = “jdbc:mysql://localhost/test?” +
                                   “user=root&password=admin”;
            Connection con = DriverManager.getConnection(connectionUrl1);
            System.out.println(”I have connect database”);
            Statement sm=con.createStatement();
             sm.executeUpdate(”delete from `test`.`test` where id=1″);
             sm.executeUpdate(”insert into `test`.`test` values(1,’Visual J++ Bible’,38)”);
            /*sm.executeUpdate(”insert into test”+”values(3,’java language’,40)”);*/
            sm.close();
            con.close();
        } catch (SQLException e) {
            System.out.println(”SQL Exception: “+ e.toString());
        } catch (ClassNotFoundException cE) {
            System.out.println(”Class Not Found Exception: “+ cE.toString());
        }

学习JDBC的使用和MySQL的使用（1）

Edward — Sun, 04 May 2008 07:57:12 +0000

利用JDBC对MySQL中数据进行操作

Suppose that I have MySQL running remotely on IP:192.168.1.101 with default port (3306) and I want to connect to Northwind database with username is ‘root’ and password is ‘123456’. The connection string will be

String connectionUrl = "jdbc:mysql://192.168.1.101:3306/Northwind?" +             "user=root&password=123456";

Retrieve data from a database

To get some data, I need to execute query on the MySQL and get the result back to me. First, I create stmt (Statement object) and execute query in SQL language. Then I store the result on ResultSet object and iterative show the result on the output window.

            Statement stmt = null;             ResultSet rs = null;             //SQL query command             String SQL = "SELECT * FROM Products";             stmt = con.createStatement();             rs = stmt.executeQuery(SQL);             while (rs.next()) {                 System.out.println(rs.getString("ProductName") + " : " + rs.getString("UnitPrice"));             }

Code Explanation:

- Statement objects allow you to execute basic SQL queries and retrieve the results through the ResultSet class.

- In while-loop, iterative in the ResultSet object to show result in console (ProductName and UnitPrice columns in Products table) on output window.

The example result will be similar to below.

Note: I have imported only 4 records from Products table in Northwind database.

Update data on database

To insert, update and delete records on SQL Server, you can use the code from retrieve data from database and simply change SQL command and also modify some code a little bit. On update, I must use executeUpdate(”SQL”) method on statement object instead executeQuery(“SQL”) and the return value will be rows affected instead of a record set.

Example

INSERT command

            // SQL insert command             String strSQL = "INSERT INTO Products (ProductName,QuantityPerUnit,UnitPrice,UnitsInStock,UnitsOnOrder," +                             "ReOrderLevel,Discontinued) VALUES ('MyProduct','10 Kg.',1234.0000,100,50,30,0)";             int rowsEffected = stmt.executeUpdate(strSQL);             System.out.println(rowsEffected + " rows effected");

UPDATE command

            // SQL update command             String strSQL = "UPDATE Products SET UnitPrice = 900, UnitsInStock = 55, UnitsOnOrder = 5 WHERE ProductName = 'MyProduct'";             int rowsEffected = stmt.executeUpdate(strSQL);             System.out.println(rowsEffected + " rows effected");

DELETE command

            // SQL delete command             String strSQL = "DELETE FROM Products WHERE ProductName = 'MyProduct'");             int rowsEffected = stmt.executeUpdate(strSQL);             System.out.println(rowsEffected + " rows effected");

Summary

You can download source code example testMySQL.java (Right-click on the link and select Save target As…).

But you have to change connection string to match your environment. The example code will connect to Northwind database and try to retrieve records, insert a new record, update the record and delete the record from Products table. The result is below.

实现JDBC功能的3种方式

Edward — Sun, 04 May 2008 05:55:04 +0000

直接和数据库进行通信（高效但是复杂）

通过驱动（便利，主流）

通过ODBC与数据源进行通信（遗留系统）

Java之多线程（2）

Edward — Sun, 04 May 2008 03:36:04 +0000

下次课星期六下午2点 3202

进程的调度状态

执行状态
就绪状态
阻塞状态

线程状态

新建状态
可运行状态
正运行状态
结束状态

Java中，显示正在运行的不一定真的在运行。只是虚拟机将运行的命令给了操作系统而已。

相同优先级的两个线程的调度是否能够时间片轮转取决于操作系统。

基于优先级的线程调度时，优先级高的可能会抢占优先级低的程序。

到底如何实现线程的轮换？？

线程组！

任何线程都隶属于某个线程组，系统有预设线程组main

守护线程：与普通的线程相比唯一的区别是JVM不将守护线程视为应用程序的核心部分。

资源共享与线程同步

如果没有很好的机制，不能保证其安全性。则，我们要实现线程的安全性o

使用Synchronized

其他协调进程的手段：

sleep(); 睡眠状态时，不释放任何锁，可以使用interrupted对睡眠的进程进行打断
Join(); 没有搞懂
wait(), notify(); notifyAll();

Java之多线程（1）

Edward — Sat, 03 May 2008 15:51:16 +0000

线程是操作调用的基本单位

进程是资源分配的基本单位，拥有独立的地址空间

春游中，以班为单位申请春游资源，每个同学春游回来之后需要给校长做Report，一次仅一个同学和校长做Report。一个班里的同学可以在黑板上写东西做交流。不同班的同学则不行。

为什么多线程？？

问题空间需要并发的需求问题：并发，并行，同步，异步，同步之间的区别？多核就是多个ALU（算数运算单元）

同步摘一个并扔一个，接一个。双方动作协调（狗熊掰棒子）在课程中借用了同步的概念，多个线程共享同步代码段，这个过程称为同步，实际意义是不同的

异步发者和接者的关系是独立的，狗熊掰了一堆棒子，放在空地上，然后另外一个可以单个或多个一起拿回去。

并发并发是并行的一种模拟，一般用时间片轮换的方法

并行两个程序一起进行，在多个CPU的时候能够实现，但是单CPU的时候是不能实现的，只能模拟。利用并发

并行和并发是操作系统层面，和进程线程关系不大。

Everything is object

要创建一个线程就要写一个类实现java.lang.Runnable或继承类java.lang.Thread

线程的不确定执行造成多线程程序很难调试

问题：两个枪手互射，如何设计算法使得更公平。