BlogJava-黑武士的领地-随笔分类- JAVA技术

用Java实现Web服务器

黑武士 — Sat, 06 Aug 2005 01:39:00 GMT

　　HTTP协议简介

　　超文本传输协议（HTTP）是位于TCP/IP 协议的应用层，是最广为人知的协议，也是互连网中最核心的协议之一，同样，HTTP 也是基于 C/S 或 B/S 模型实现的。事实上，我们使用的浏览器如Netscape 或IE 是实现HTTP 协议中的客户端，而一些常用的Web 服务器软件如Apache、IIS 和iPlanet Web Server 等是实现HTTP 协议中的服务器端。Web 页由服务端资源定位，传输到浏览器，经过浏览器的解释后，被客户所看到。

　　Web 的工作基于客户机/服务器计算模型，由Web 浏览器(客户机)和Web服务器(服务器)构成，两者之间采用超文本传送协议（HTTP）进行通信。HTTP协议是Web浏览器和Web服务器之间的应用层协议，是通用的、无状态的、面向对象的协议。

　　一个完整的HTTP协议会话过程包括四个步骤：

　　◆ 连接，Web浏览器与Web服务器建立连接，打开一个称为Socket（套接字）的虚拟文件，此文件的建立标志着连接建立成功；

　　◆ 请求，Web浏览器通过Socket向Web服务器提交请求。HTTP的请求一般是GET或POST命令（POST用于FORM参数的传递）；

　　◆ 应答，Web浏览器提交请求后，通过HTTP协议传送给Web服务器。Web服务器接到后，进行事务处理，处理结果又通过HTTP传回给Web浏览器，从而在Web浏览器上显示出所请求的页面；

　　◆ 关闭连接，应答结束后Web浏览器与Web服务器必须断开，以保证其它Web浏览器能够与Web服务器建立连接。
　　编程思路

　　根据上述HTTP协议的会话过程，本实例中实现了GET请求的Web服务器程序的方法,方法如下：

　　通过创建ServerSocket 类对象，侦听用户指定的端口(为8080)，等待并接受客户机请求到端口。创建与Socket相关联的输入流和输出流，然后读取客户机的请求信息。若请求类型是GET，则从请求信息中获取所访问的HTML 文件名；如果HTML 文件存在，则打开HTML 文件，把HTTP 头信息和HTML 文件内容通过Socket 传回给Web浏览器，然后关闭文件，否则发送错误信息给Web 浏览器。最后关闭与相应Web 浏览器连接的Socket。

　　用Java编写Web服务器httpServer.java文件的源代码如下：

//httpServer.java
import java.net.*;
import java.io.*;
import java.util.*;
import java.lang.*;
public class httpServer{
public static void main(String args[]) {
int port;
ServerSocket server_socket;
//读取服务器端口号
try {
port = Integer.parseInt(args[0]);
}
catch (Exception e) {
port = 8080;
}
try {
//监听服务器端口，等待连接请求
server_socket = new ServerSocket(port);
System.out.println("httpServer running on port " +
server_socket.getLocalPort());
//显示启动信息
while(true) {
Socket socket = server_socket.accept();
System.out.println("New connection accepted " +
socket.getInetAddress() +
":" + socket.getPort());
//创建分线程
try {
httpRequestHandler request =
new httpRequestHandler(socket);
Thread thread = new Thread(request);
//启动线程
thread.start();
}
catch(Exception e) {
System.out.println(e);
}
}
}
catch (IOException e) {
System.out.println(e);
}
}
}
class httpRequestHandler implements Runnable
{
final static String CRLF = "\r\n";
Socket socket;
InputStream input;
OutputStream output;
BufferedReader br;
// 构造方法
public httpRequestHandler(Socket socket) throws Exception
{
this.socket = socket;
this.input = socket.getInputStream();
this.output = socket.getOutputStream();
this.br =
new BufferedReader(new InputStreamReader(socket.getInputStream()));
}
// 实现Runnable 接口的run()方法
public void run()
{
try {
processRequest();
}
catch(Exception e) {
System.out.println(e);
}
}
private void processRequest() throws Exception
{
while(true) {
//读取并显示Web 浏览器提交的请求信息
String headerLine = br.readLine();
System.out.println("The client request is "+headerLine);
if(headerLine.equals(CRLF) || headerLine.equals("")) break;
StringTokenizer s = new StringTokenizer(headerLine);
String temp = s.nextToken();
if(temp.equals("GET")) {
String fileName = s.nextToken();
fileName = "." + fileName ;
// 打开所请求的文件
FileInputStream fis = null ;
boolean fileExists = true ;
try
{
fis = new FileInputStream( fileName ) ;
}
catch ( FileNotFoundException e )
{
fileExists = false ;
}
// 完成回应消息
String serverLine = "Server: a simple java httpServer";
String statusLine = null;
String contentTypeLine = null;
String entityBody = null;
String contentLengthLine = "error";
if ( fileExists )
{
statusLine = "HTTP/1.0 200 OK" + CRLF ;
contentTypeLine = "Content-type: " +
contentType( fileName ) + CRLF ;
contentLengthLine = "Content-Length: "
+ (new Integer(fis.available())).toString()
+ CRLF;
}
else
{
statusLine = "HTTP/1.0 404 Not Found" + CRLF ;
contentTypeLine = "text/html" ;
entityBody = "＜HTML＞" +
"＜HEAD＞＜TITLE＞404 Not Found＜/TITLE＞＜/HEAD＞" +
"＜BODY＞404 Not Found"
+"＜br＞usage:http://yourHostName:port/"
+"fileName.html＜/BODY＞＜/HTML＞" ;
}
// 发送到服务器信息
output.write(statusLine.getBytes());
output.write(serverLine.getBytes());
output.write(contentTypeLine.getBytes());
output.write(contentLengthLine.getBytes());
output.write(CRLF.getBytes());
// 发送信息内容
if (fileExists)
{
sendBytes(fis, output) ;
fis.close();
}
else
{
output.write(entityBody.getBytes());
}
}
}
//关闭套接字和流
try {
output.close();
br.close();
socket.close();
}
catch(Exception e) {}
}
private static void sendBytes(FileInputStream fis, OutputStream os)
throws Exception
{
// 创建一个 1K buffer
byte[] buffer = new byte[1024] ;
int bytes = 0 ;
// 将文件输出到套接字输出流中
while ((bytes = fis.read(buffer)) != -1 )
{
os.write(buffer, 0, bytes);
}
}
private static String contentType(String fileName)
{
if (fileName.endsWith(".htm") || fileName.endsWith(".html"))
{
return "text/html";
}

return "fileName";
}
}

　　编程技巧说明

　　◆ 主线程设计

　　主线程的设计就是在主线程httpServer 类中实现了服务器端口的侦听，服务器接受一个客户端请求之后创建一个线程实例处理请求，代码如下：

import java.net.*;
import java.io.*;
import java.util.*;
import java.lang.*;
public class httpServer{
public static void main(String args[]) {
port;
ServerSocket server_socket;
//读取服务器端口号
try {
port = Integer.parseInt(args[0]);
}
catch (Exception e) {
port = 8080;
}
try {
//监听服务器端口，等待连接请求
server_socket = new ServerSocket(port);
System.out.println("httpServer running on port "
+server_socket.getLocalPort());
..........
..........

　　◆ 连接处理分线程设计

　　在分线程httpRequestHandler 类中实现了HTTP 协议的处理，这个类实现了Runnable 接口，代码如下：

class httpRequestHandler implements Runnable
{
final static String CRLF = "\r\n";
Socket socket;
InputStream input;
OutputStream output;
BufferedReader br;
// 构造方法
public httpRequestHandler(Socket socket) throws Exception
{
this.socket = socket;
//得到输入输出流
this.input = socket.getInputStream();
this.output = socket.getOutputStream();
this.br =
new BufferedReader(new InputStreamReader(socket.getInputStream()));
}

// 实现Runnable 接口的run()方法
public void run()
{
try {
processRequest();
}
catch(Exception e) {
System.out.println(e);
}
}

　　◆ 构建processRequest()方法来处理信息的接收和发送

　　作为实现Runnable 接口的主要内容，在run()方法中调用processRequest()方法来处理客户请求内容的接收和服务器返回信息的发送，代码如下：

private void processRequest() throws Exception
{
while(true) {
//读取并显示Web 浏览器提交的请求信息
String headerLine = br.readLine();
System.out.println("The client request is "+ headerLine);
if(headerLine.equals(CRLF) || headerLine.equals("")) break;
//根据请求字符串中的空格拆分客户请求
StringTokenizer s = new StringTokenizer(headerLine);
String temp = s.nextToken();
if(temp.equals("GET")) {
String fileName = s.nextToken();
fileName = "." + fileName ;
.............
.............

　　在processRequest()方法中得到客户端请求后，利用一个StringTokenizer 类完成了字符串的拆分，这个类可以实现根据字符串中指定的分隔符(缺省为空格)将字符串拆分成为字串的功能。利用nextToken()方法依次得到这些字串；sendBytes()方法完成信息内容的发送，contentType()方法用于判断文件的类型。

　　显示Web页面

　　显示 Web 页面的index.html 文件代码如下：

＜html＞
＜head＞
＜meta http-equiv="Content-Language" content="zh-cn"＞
＜meta name="GENERATOR" content="Microsoft FrontPage 5.0"＞
＜meta http-equiv="Content-Type" content="text/html; charset=gb2312"＞
＜title＞Java Web 服务器＜/title＞
＜/head＞
＜body＞
＜p＞********* ＜font color="#FF0000"＞欢迎你的到来！＜/font＞*********＜/p＞
＜p＞这是一个用 Java 语言实现的 Web 服务器＜/p＞
＜hr＞
＜/body＞
＜/html＞

　　运行实例

　　为了测试上述程序的正确性，将编译后的httpServer.class、httpRequestHandler.class和上面的index.html文件置于网络的某台主机的同一目录中。

　　首先运行服务器程序 java httpServer 8080，服务器程序运行后显示端口信息“httpServer runing on port 8080”，然后在浏览器的地址栏中输入http://localhost:8080/index.html，就可以正确显示网页，同时在显示“httpServer runing on port 8080 ”窗口中服务器会出现一些信息。

黑武士 2005-08-06 09:39 发表评论

基于J2EE的三层B/S信息系统研究

黑武士 — Thu, 04 Aug 2005 03:16:00 GMT

　随着软件系统的规模和复杂性的增加，软件体系结构的选择成为比数据结构和算法的选择更为重要的因素，三层客户/服务器体系结构为企业资源规划的整合提供了良好的框架，是建立企业级管理信息系统的最佳选择。随着体系结构的发展，软件框架结构方面也在不断发展，目前在多层应用结构方面出现Java技术和.net技术的实现的不同的解决方案，二者各有优缺点，分别适用于不同规模的系统的要求。本文将结合电信计划建设管理信息系统的实现，说明三层模式的体系结构，介绍基于三层模式的应用系统的分布式组件技术 ,阐述应用J2EE框架结构来实现应用系统的实现方法。

　　 一、系统结构的选择

　　 1、传统两层C/S结构的缺点

　　传统的两层客户/服务器模式比较适合于小规模、用户较少、单一数据库且在安全、快速的网络环境下 (例如局域网 )运行。但是，随着应用系统的规模不断扩大 ,复杂性越来越高在多用户、多数据库且非安全的网络环境下(例如:Internet) ,这种两层结构的应用模型将无法适应。而且传统的两层结构还存在以下缺陷：

　　(1)它是单一服务器且以局域网为中心的 ,所以难以扩展至大型企业广域网或 Intranet；

　　(2)受限于供应商，程序的升级维护必须由供应商重新开发扩展；

　　(3)软、硬件的组合及集成能力有限；在软件上呈现出胖客户端，用户必须在客户端安装特定的客户端应用程序，而且企业的业务逻辑都写在客户端应用程序中，程序维护困难，程序升级需要每个客户端都要安装新的客户端应用程序，同时，对于程序开发商来说，程序模块的重用性差，各个模块相对独立；

　　(4)C/S模式很难管理大量的客户机。

　　基于以上原因，传统的C/S模式已经不能适应发展的需要，随着网络技术的普及和用户需求的进一步提高，三层WEB模式应运而生。

　　2、三层WEB结构的优点

　　三层客户/服务器模式 (以下简称三层模式 )在两层模式的基础上，增加了新的一级。这种模式在逻辑上将应用功能分为三层：客户显示层、业务逻辑层、数据层。客户显示层是为客户提供应用服务的图形界面，有助于用户理解和高效的定位应用服务。业务逻辑层位于显示层和数据层之间，专门为实现企业的业务逻辑提供了一个明确的层次，在这个层次封装了与系统关联的应用模型，并把用户表示层和数据库代码分开。这个层次提供客户应用程序和数据服务之间的联系，主要功能是执行应用策略和封装应用模式，并将封装的模式呈现给客户应用程序。数据层是三层模式中最底层，他用来定义、维护、访问和更新数据并管理和满足应用服务对数据的请求。

　　三层模式的主要优点为：

　　①良好的灵活性和可扩展性。对于环境和应用条件经常变动的情况，只要对应用层实施相应的改变，就能够达到目的。

　　②可共享性。单个应用服务器可以为处于不同平台的客户应用程序提供服务，在很大程度上节省了开发时间和资金投入；

　　③较好的安全性。在这种结构中，客户应用程序不能直接访问数据，应用服务器不仅可控制哪些数据被改变和被访问，而且还可控制数据的改变和访问方式。

　　④增强了企业对象的重复可用性。“企业对象”是指封装了企业逻辑程序代码，能够执行特定功能的对象。随着组件技术的发展，这种可重用的组件模式越来越为软件开发所接受。

　　⑤三层模式成为真正意义上的“瘦客户端”，从而具备了很高的稳定性、延展性和执行校率。

　　⑥三层模式可以将服务集中在一起管理，统一服务于客户端，从而具备了良好的容错能力和负载平衡能力。

三层体系结构

　　电信计划建设管理信息系统是由省电信公司对下属地市电信公司进行统一管理，所有业务逻辑都集中在省公司管理和制定，地市公司负责数据的录入和查询统计，用户的分布广泛，数据集中处理，因此在设计时充分考虑各种体系结构的优缺点，选择三层WEB模式进行开发实现。

　　二、体系架构的选择

　　1、 DCOM分布式技术和CORBA分布式技术

　　Microsoft的分布式COM（DCOM）技术是将组建对象模型技术COM大大进行了扩展，是对在局域网、广域网甚至是Internet上计算机对象之间的通信提供了完全的支持。通过使用DCOM用户的应用程序就可以在任何网络位置上达到真正的分布性，从而满足客户应用的需要。整体结构如下图所示：

　　由OMG提出的公共对象请求代理结构CORBA对象是目前比较流行的一种中间件规范，也是一种构件实现规范，主要目标是使对象在分布式环境中可重用、可移植和可互操作，CORBA的整体结构如下图所示：

　　以上两种分布式结构可以实现在统一特定的环境下的应用，对于局域网中的实现比较流行，但是针对不同平台的应用和Internet上的应用，二者缺少灵活性。

　　2、 J2EE体系结构介绍

　　J2EE体系结构分为三个层次，分别是客户表示层、中间逻辑层和数据管理层及应用系统。本结构具有跨平台的特性，结构中的三个层次可以处于不同的平台下进行协作应用；因为客户表示层可以使用不同的客户端程序，因此具有很好的分布性，可以适应分布式管理的要求；在后台的应用系统集成中，可以把企业不同的应用系统集成到该结构中，因此可以有效的保护现有的资源不被破坏。基于J2EE来实现的WEB服务的核心框架如下图所示：

　　用基于J2EE的体系结构开发的WEB服务还具有以下的优点：

　　① 可以跨越中间防火墙进行通信。因为WEB服务是利用HTTP最为传输媒介，中间层使用WEB服务的话，可以从客户界面直接调用中间层组件，而不必建立页面。

　　② 应用系统的集成。要把企业里不同语言写成的，运行于不同平台上的各种程序集成起来必然会花费很大的开发力量。通过WEB服务可以使用标准的方法把功能和数据暴露出来，供其他程序使用。

　　③ 所有的企业逻辑和服务都集成封装在可重用、可移植的EJB组件中，因此系统维护性和可重用性好。

　　④中间件代码可以集中在处理业务逻辑上，无需考虑数据表示。

　　因为本次电信计划建设管理信息系统的业务逻辑和数据处理规则都是由集团公司和省公司统一管理，数据和程序集中在统一的服务器上，并且服务器运行平台与客户端的运行平台不同，因此采用J2EE的框架结构解决比较合适。

　　三、系统设计和实现

　　通过对各种解决方案和框架结构的比较，选择JAVA技术作为本次系统设计的应用技术，我们对系统的设计如下：

　　前台用户显示层使用jsp和servlet在浏览器上实现，中间使用EJB组件实现企业业务逻辑，后台数据库使用Sybase数据库。具体的企业应用结构如下所示：

　　其中中间件使用Bea公司的Weblogic7.0，开发工具使用JBuilder9.0，数据库使用SYBASE数据库。

　　在用户登录过程中，因为在整个客户端使用的用户比较多，因此在连接上我们使用连接池进行处理。具体的连接池实现如下：

class DBConnectionPool
{
　public DBConnectionPool(String name, String URL, String user, String password)
　{
　　this.name = name;
　　this.URL = URL;
　　this.user = user;
　　this.password = password;
　　this.maxConn = maxConn;
　}
　private void createPools(Properties props)
　{
　　private Hashtable pools = new Hashtable();
　　String poolName = props.getProperty("poolname").trim();
　　String url = props.getProperty(poolName+".url").trim();
　　String user = props.getProperty(poolName + ".user");
　　String password = props.getProperty(poolName + ".password");
　　String maxconn = props.getProperty(poolName + ".maxconn", "0");
　　int max;
　　DBConnectionPool pool=New DBConnectionPool(poolName, url, user, password);
　　Utility.log(pool.toString());
　　pools.put(poolName, pool);
　　Utility.log("成功创建连接池" + poolName);
　}
}

　　为了使用SessionBean进行登录确认处理，同时利用Bean的监听功能对用户的登录时间进行监听，超过一定时间，自动切断用户登录连接，让用户进行重新登录。在应用系统中，用户登录后的权限控制是一个重点，我们在使用J2EE框架结构的过程中，使用SERVLET的过滤功能来实现权限的控制，具体的实现结构如下：

　　过滤器的定义标记如下：

IE Filter

com.ibm.devworks.filters.IEFilter

　　在业务逻辑处理上，我们对各个业务进行相应的分解，然后针对每个业务逻辑应用EJB组件进行实现。客户做出请求后，使用SERVLET处理后调用各个业务模块处理逻辑，EJB组件访问数据库后将处理后的结果集返回给SERVLET，再汇集到客户端进行显示，供用户进行查询和使用。

　　四、总结

　　本文提出的B/S模式的系统结构已应用电信计划建设管理信息系统中，由于实际需要，在请求处理层中还增加了一个设备接口线程，用于通过SNMP协议获取网络设备的信息。与传统的CGI模式相比，本系统结构有明显的优势，具有较高系统效率，尤其适合于构造功能复杂的Web应用系统。另外在实现上还可以加强，比如进一步研究自动创建和撤销新的数据库操作线程的条件。

黑武士 2005-08-04 11:16 发表评论

图解Java开发工具JBuilder 9.0

黑武士 — Tue, 02 Aug 2005 00:22:00 GMT

　　一、概述

　　Jbuilder 9是功能强大的可视化Java集成开发工具，可以快速开发包括复杂企业级应用系统的各种Java程序，包括独立运行程序、Applet程序、Servlet、JSP、EJB、Web Service等，最新的Jbuilder 9版本支持Sun的J2SE 1.4和J2EE 1.4。使用可视化工具开发程序有很多好处，其中最显著的是能够快速生成程序框架、设计图形界面、调试程序等，此外Jbuilder 9内置了对一些企业级服务器的支持，包括Borland服务器、Bea公司的WebLogic服务器、IBM的WebSphere服务器和iPlanet服务器。Jbuilder 9在以前版本的基础上，增强和增加了许多功能。特性如下：

　　(1)工程管理(Project management)。增强了工程之间的鼠标拖放和其他管理功能，支持打开Together工程文件。

　　(2)编译(Build)。Make、Ant已经升级，支持工程导出到Ant。

　　(3)打包(Archive Builder)。该功能更加灵活方便。

　　(4)团队开发(Team development)。CVS、Visual SourceSafe、ClearCase得到升级，增加了StarTeam。

　　(5)Web Service。原有的Apache Axis toolkit和Apache SOAP toolkit已经升级，WebLogic toolkit添加了Web Services Console和Export As AnAsynchronous Web Service wizard。

　　(6)Productivity enhancements。编码工具和文档工具进一步增强，例如JavaDoc、Refactoring。

　　(7)Editor(编辑器)和Debuger(调试器)。增强的编辑器和调试器功能使代码编写更加方便。

　　(8)Web和J2EE。除了增加了新功能外，最重要的是支持目前最新的J2EE服务器，如BEA WebLogic Platform Server8.1、IBM WebSphere Application Server 5.0、Borland Enterprise Server 5.1.1-5.2.1 Sybase EAServer4.2等。

　　二、Jbuilder 9的安装与启动

　　1、Jbuilder 9的软硬件系统需求

　　在Windows平台上，JBuilder 9的系统需求如下：

　　(1)最少256MB内存(recommended minimum)、推荐512MB(recommended)。根据笔者经验，256MB内存可以运行，对学习JBuilder 9来说，稍微有点慢。

　　(2)700MB硬盘剩余空间。

　　(3)Microsoft Windows 2000(SP2)/2003，XP，or NT4.0(SP6)。

　　所以建议大家不要把JBuilder 9安装在非服务器版本的Windows平台例如Windows 2000 Professional上。

　　(4)Intel(r)Pentium(r)II 233MHz以上CPU。

　　2、Jbuilder 9的下载

　　JBuilder9可以从Borand网站上下载，共包括下面3个文件：

　　(1)程序文件JBuilder9.zip。

　　(2)联机手册JB9docs.zip。

　　(3)实例代码jb9samples.zip。

　　3、Jbuilder 9的安装

　　Jbuilder9的安装较简单,下面我们就简单介绍之。首先将jbuilder9.zip文件解包后，运行ent_trial_install.exe文件，开始jbuilder9的安装过程，如图1、2所示；

图1

图2

　　在图3中点击"next"按钮；

图3

　　在图4中选中"I accept the terms of the License Agreement"，点击"next"按钮；

图4

　　选择安装jbuilder9的路径为F:\jbuilder9，如图5所示，点击"next"按钮；

图5

　　在图6中选择"install"按钮，开始jbuilder9的安装，如图7所示；

图6

图7

　　安装好后出现图8的画面，点击"Done"按钮，至此Borland jbuilder 9 Enterprise Trial版本安装就算全部完成。

图8

　　4、Jbuilder 9的启动

　　1）获得试用授权文件或者序列号

　　你需要在Borland网站上注册，获得一个trial license key，这样才可合法地试用JBuilder9。这个key通过电子邮件发到用户注册时提供的信箱上，通常这个key是个文本文件而不是序列号，称为activate file，可以试用JBuilder 9一个月(31天)，不过有时这个key不一定可用，可能需要上网寻找合法的key。

　　2）第一次启动JBuilder9

　　第一次启动JBuilder9时，会出现一个界面，要求提供JBuilder 9产品的serial number(序列号)或者activate file(产品激活文件)，你应该选择activate file，然后根据提示选择activate file所在的目录和文件名。如果没有错误，JBuilder 9开始启动，会显示还有多少天的试用期，然后出现JBuilder 9的界面。第一次启动JBuilder 9时，会出现如图9所示的界面，提示界面中的文件类型是否由JBuilder9打开。

图9

　　我们看到的最前面的是Tip of th eDay(每日一诀)窗口，每次启动时会显示使用JBuilder 9的一个窍门(tip)，如果在Show tip of the day after launching前的方框打勾，那么以后启动JBuilder9时，就不会出现Tip of the Day窗口。单击Close按钮就关闭Tip of the Day窗口，此时开始正式使用JBuilder 9，这时看到的界面中，JBuilder9会自动打开一个后缀名为jpx的文件Welcome.jpx，见屏幕左上部鼠标所指处，jpx可能是java project(Java工程或者项目)文件的缩写。

　　希望大家最后安装联机手册jb9docs.zip和实例代码jb9samples.zip，这对于通过手册辅助学习JBuilder9是必须的。

　　三、Jbuilder 9集成开发环境简介

图10

　　从上图10中我们可以看出，JBuilder9的集成开发环境是一个使用单一窗口界面，集编辑、管理文件与工程、可视界面设计、浏览、编译、调试和其他操作等多功能于一体的开发平台。以下是各个部分的名称及其功能说明。

　　1、主菜单栏(main menu)

　　主菜单对于编写程序来说是非常重要的，比如用户可以用它打开、保存工程和文件，装载存储的文件，在文件之中查找文本，编译和调试程序等。

　　2、主工具栏(main toolbar)

　　主工具栏按照其功能划分成若干小工具栏，其上面的按钮主要提供对菜单命令的快捷访问方式。

　　3、工程窗口(project pane)

　　工程窗口可以显示所选工程的内容，用于浏览与操作工程树。

　　4、工程工具栏(Project bar)

　　工程工具栏包含了一个当前所打开工程的列表及一些按钮，这些按钮用来增加、删除文件，关闭及更新工程窗口中的工程文件。

　　5、结构窗口(Structure pane)

　　结构窗口用于显示内容窗口中当前文件的结构。对一个Java文件而言，该窗口以树的形式显示出所有方法、属性与事件。结构窗口具有向下展开的功能，双击一个类或者界面就可以查看它的祖先类，非常便于用户查找相关信息。

　　6、内容窗口(Content pane)

　　在内容窗口中可以查看所打开的文件。每一个打开的文件都有一个显示其文件名的标签以及位于底部的各种视图标签。

　　7、文件视图标签(Fileview tabs)

　　文件视图标签用于在内容窗口中切换文件的各种视图，如Source、Design、Bean、Doc 或History视图。

　　8、文件标签(File tabs)

　　文件标签用于显示打开的文件名。JBuilder9只显示活动工程的文件标签。要查看一个打开的文件，请选择它的文件标签。注意，当一个文件被修改时，它标签上的X符号为断开的，否则为没有断开的X符号。

　　9、状态栏(Status bar)

　　在状态栏可获得有关进程及其结果的最新信息。

　　以上各个部分是利用JBuilder编程时最常使用的，掌握了它们的功能，就会对JBuilder 9的编程环境有更深入的了解。

　　下面，就对JBuilder9的集成开发环境中的各项内容进行介绍。

　　一）菜单栏

　　JBuilder9的菜单栏是由一些子菜单组成的，用户可以通过鼠标或快捷键来选择需要的菜单项。下面将对一些常用和比较重要的菜单项进行介绍。

　　1、File(文件)菜单

　　1）New菜单项

　　单击File->New菜单项，将打开Object Gallery对话框，如图11所示。

图11

　　在这个对话框中，用户可以创建文件、工程、应用程序、Web应用、XML应用、CORBA、Build、Enterprise应用和测试处理等。

　　在本对话框中有8个标签，下面对一些主要标签中的主要工程进行简单的说明。

　　·General标签：用户可以通过General标签来创建多种类型的文件，例如，要创建应用程序文件，只需在相应的Application图标上双击即可。

　　·Proiect标签：在Proiect标签中可以创建新的工程。

　　·Web标签：Web标签中，可以创建和Web相关的应用程序和文件。

　　·XML标签：XML标签中，可以创建和XML相关的应用程序和文件。

　　·CORBA标签：CORBA标签中，可以创建和CORBA相关的多层次应用程序的服务器和客户机的接口和应用。

　　·Enterprise标签：Enterprise标签中，可以创建和Enterprise应用相关的接口和应用对象，这些功能只有企业版的JBuilder9才会有。

　　·Build标签：Build标签中，可以创建用于生成代码和工程创建过程中使用的任务。

　　·Test标签：在Test标签中，可以创建用于测试的应用框架和类对象。

　　另外，Obiect Gallery对话框中还包括Web Services以及Micro等标签，但是由于其应用范围不是很广，所以这里不再叙述。如有兴趣，可以参考相关的帮助信息。

　　2）Now Project菜单项

　　New Projiect菜单项的主要功能是创建一个JBuilder工程文件。单击该菜单项，将出现一个标准的创建JBuilder工程文件的向导对话框，按照向导的提示，就可以创建一个JBuilder工程文件了。

　　3）New Class菜单项

　　New Class菜单项主要用于创建一个Java class对象。单击该菜单项，将出现一个标准的创建Java class对象的向导对话框，按照向导就可以创建一个Javaclass对象文件。

　　4）Open Project菜单项

　　Open Project菜单项的功能是打开一个已有的工程。JBuilder9可以同时打开多个工程，系统还可以打开多个AppBrowser，显示多个不同的工程。

　　5）Open File菜单项

　　本菜单项用于打开已经存在的JBuilder文件、JBuilder工程文件、JBuilder包、C和C++文件、SQL文件、HTML文件、批处理文件、文本文件和类型文件等，该命令的快捷键是Ctrl+O。单击该菜单项，将出现一个标准的打开文件对话框，通过这个对话框，可以选择不同路径下的文件。如果文件是一个工程文件，将在集成开发环境中打开工程。如果是其他文件，可以在代码编辑器中查看文件并编辑它。不同类型的文件可以用文件过滤器进行过滤。

　　6）Reopen菜单项

　　Reopen菜单项用来打开最近使用的工程或模块。JBuilder 9对最近打开过的工程文件具有记忆功能，当单击该菜单时，会出现其级联菜单，其中列出了最近打开过的文件。

　　7）Close All Except "Frame1.java"菜单项

　　此菜单项的主要功能是关闭当前集成开发环境中打开的工程文件中除了正在使用的Java文件以外所有其他的文件，如果要关闭的文件有了变更，将会出现一个对话框，提示是否保存所做的修改。

　　8）Revert"Frame1.java"菜单项

　　此菜单项用来还原当前集成开发环境中打开的Java文件。如果当前文件有了变更，才会有还原为修改前的文件的操作，该菜单项才会被激活。

　　9）Page Layout菜单项

　　此菜单项的主要功能就是对打印代码进行页面设置。单击该菜单项会打开一个页面设置对话框，用于修改打印时的各种参数设置。

　　2、 Edit(编辑)菜单

　　"编辑"菜单的主要功能是用来管理处于用户设计阶段的文本和控件。

　　3、View(视图)菜单

　　视图"菜单的主要功能是决定在当前的IDE窗口显示哪些内容。在该菜单中的菜单项是用户根据自己的需要与爱好调整编程环境的重要工具。在"视图"菜单中提供了很多重要的工具，比如ToolBars(工具栏)、Project(工程窗口)、Content(内容窗口)、Structure(结构窗口)、Messages(消息窗口)、StatusBar(状态栏)和HideAll(隐藏所有的窗口)等等。其中，使用ToolBars可以选择需要显示的工具栏，主要有File，Editing，Search，Build，Run/Debug，Navigation和Help等等。

　　4 、Project(工程)菜单

　　在"工程"菜单中，JBuilder提供了一系列用于工程处理的菜单项，主要包括：

　　． Make Proiect 菜单项可以将当前工程中的所有文件进行编译和链接；

　　． Rebuild Proiect 菜单项可以将当前工程的所有文件进行重新编译和链接；

　　． Make 菜单项可以将当前工程文件进行编译；

　　． Rebuild 菜单项可以将当前工程文件进行重新编译和链接；

　　． Add Files/Packages 菜单项可向当前工程添加文件和包；

　　． New Folder 菜单项用于在当前的工程中添加新的文件夹；

　　． Remove from Proiect 菜单项用于从当前的工程中移除文件；

　　． Refresh 菜单项用于刷新当前工程窗口的内容：

　　． Rename 菜单项用于给当前工程中的文件重命名；

　　． Proiect Properties 菜单项用于设置当前工程的属性；

　　． Default Proiect Properties 菜单项用于设置系统默认的工程的属性。

　　在上面讲述的菜单项中，Make Projiect，Rebuild Project，Make和Rebuild等菜单项都是经常使用的工程菜单项。

　　5、Run(运行)菜单

　　"运行"菜单提供了各种运行和调试的菜单项。用户经常会使用到这些菜单项，这些菜单项在运行程序和调试程序时特别重要。下面就简单介绍其中的菜单项。

　　Run Proiect(运行工程)菜单项和Debug project(调试工程)菜单项是运行程序必不可少的，主要用于运行工程和调试工程。

　　Configurations(配置)菜单项可以打开Prpject Properties对话框并以Run页面显示，让用户选择要运行的主程序(这和Java中有Application程序和Applet小应用程序有关)。

　　Step Over(单步)菜单项和Run to Cursor(运行到光标处)菜单项则和调试程序有关，即单步执行和执行到光标。

　　对于Add Watch(添加观测变量)和Add BreakPoint(添加断点)等菜单项的使用以及其他的调试技巧。

　　6、Team(团队)菜单

　　"团队"菜单主要用于完成团队的开发协调工作。其中的Select Project VCS菜单项主要给工程配置用于团队开发的版本控制系统，单击该菜单项将弹出Select Project VCS对话框。

　　7、Wizards(向导)菜单

　　"向导"菜单提供了一系列用于向导的菜单项。

　　·Implement Interface菜单项主要用于打开一个可以创建可执行框架接口的向导，当JBuilder创建好框架接口后，就需要给出该接口下可执行方法的实际代码。

　　·Override Methods菜单项主要用来打开一个用于重载类方法的向导。

　　·EJB菜单项主要用于处理EJB方面的向导，其中包括三个子菜单项，分别为EJB1.x Interface Generator，EJB1.x Bean Generator和Use EJB Test Client。

　　·Use DataModule菜单项主要用于打开一个DataModule的向导，能够选择的数据模块只有那些已经建立并编译通过的数据模块，用户可以通过该向导选择一个已经存在的数据模块并把它加入自己的工程中。

　　·Use CORBA Interface 菜单项主要用来打开一个CORBA Client Interface Object From IDL向导，从一个IDL文件中生成CORBA客户。

　　·Resource Strings菜单项主要用于打开Resource Strings向导，将资源绑定到一些单独的类中。

　　·Archive Builder菜单项主要是将开发完成后的应用程序进行分发。Archive Builder可以收集程序所需的所有文件，依照选择了的归档类型进行分发，例如，这些文件可归档为JAR文件进行分发。该菜单命令和new向导中的Archive Builder的作用是一样的。

　　·Native Executable Builder菜单项主要是将开发完完成后的应用程序进行本地可执行代码分发处理。JBuilder9可生成在Windows，Linux，Solaris和Mac OS X等多个操作系统平台上使用的本地代码。该菜单项将打开一个等同于new向导中的Native Executable Builder向导。

　　·Javadoc菜单项主要是打开Javadoc向导，它可以为各种API源文件创建HTML格式的文档文件。

　　·External Build Task菜单项主要是打开External Build Task向导，用于创建一个在编译链接工程时使用的扩展Build任务程序。

　　8、Tools(工具)菜单

　　"工具"菜单主要提供各种环境的选项，用户可以自定义这些选项，设置适合自己的编程环境。其中主要包括IDE Options(环境选项)、Editor Options(编辑器选项)、Configure Libraries(类库配置选项)，Configure Servers(分发应用的服务器端配置)、Configure Palette(配置选项板)和Configure JDKs(JDK添加和配置)等菜单项。

　　另外，还提供了Enterprise Setup，Enterprise Deployment，Create EJB Client JAR，Beanlnsight和Package Migration等与Borland Enterprise Server有关的配置工具，以及JDBC Monitor，DatabasePilot，JDataStore Explorer和JDataStore Server等和数据库配置相关的工具。

　　Configure Tools，Configure File Associations和RMIRegistry等菜单项则用于文件关联等其他对象的配置工作。

　　二）控件栏

　　在任何可视化编程中，控件栏是用户取用控件库中存在的控件的最一般工具，也为程序设计提供了快捷和方便。在控件库中的每一个控件实际上就是一个对象，用户可以增加和改进其功能，并由此形成一个新的控件。另外，所形成的新控件可以被添加到控件库中，被程序所调用。

　　单击上图10中文件视图标签中的Design选项，在内容窗口显示的内容为用户界面设计器，它的上方就会出现"控件栏"，控件栏位于主菜单的右下方，按控件功能的不同划分为14组。

　　1、Swing页

　　Swing是Java基础类库(JFC)的重要组成部分，它实现了一组新的GUI(Graphics User Interface，图形用户界面)控件，具有可插接的外观感觉效果(可插接的外观感觉效果就是使用户只需要设计一个GUI控件集，就可以自动得到与任意OS平台(如Windows，Solaris，Macintosh)相吻合的外观感觉效果。Swing是以100%纯Java实现的，且以JDK(Java DevelopmentKit，Java开发工具包)Lightweight UI(User Interface，用户界面)框架为基础。

图12

　　在Swing控件中除了包含两个已有AWT(Abstract Window Toolkit，抽象窗口工具包)控件集(如按钮、滚动条、标签等)的纯Java版本外，还添加了一个高级控件的全集(例如树视图、列表框等)。

　　2、Swing Containers页

　　如图13所示，Swing Containers页主要包含了一些Swing控件所需要使用的容器外观等，以使Swing控件的布局更合理。

图13

　　3、DataExpress页

　　DataExpress页中所包含的控件都是Borland公司专为数据库处理设计的，如图14所示。

图14

　　4、dbSwing页和MoredbSwing页

　　dbSwing页(见图15)和More dbSwing页同样也是Borland公司设计的在数据库处理方面的控件集合。

图15

　　5、dbSwing Models页

　　dbSwing Models页同样也是Borland公司设计的在数据库处理方面的控件集合，如图16所示。

图16

　　6、EJB页

　　EJB(Enterprise JavaBean)在企业级的应用程序设计中非常有用，是J2EE的重要组成部分。其包含的控件如图17所示。

图17

　　7、AWT页

　　AWT是Java基础类库的重要组成部分，是Java在较早期的窗口工具集，具有十分强大的功能，包括：

　　．丰富的用户界面控件；

　　．强大的事件处理模型；

　　．图形和图像工具，包括形状、颜色和字体类：

　　．布局管理器，可以进行灵活的窗口布局而与特定窗口的尺寸和屏幕分辨率无关；

　　．数据传送类，可以通过本地平台的剪贴板来进行剪切和粘贴。

　　AWT页的控件如图18所示。

图18

　　另外，还有XML页、InternetBeans页、CORBA页、MIDP和MIDP Screens等在JBuilder中所使用的高级编程功能控件。这里就不多说了。

　　三）对象浏览器

　　在用户界面设计器上任选一个控件，则在右下方就会出现对象浏览器。对象浏览器在程序开发中具有非常重要的作用，是用户进行可视化编程的基础。对象浏览器的主要作用是向用户提供对象的声明段中的属性(Properties)的访问，如读取和修改。同时，对象浏览器还提供了对象的事件(Events)的设置，在这些设置中往往可以完成在面向对象技术中需要很多工作才能完成的任务，甚至这些改变属性和事件的工作就是编写程序的全部。这大大增加了代码的重用性，这就是面向对象技术的优势所在。

　　四）用户界面设计器

　　由于目前用户对界面的要求逐步提高，因此，现在的可视化编程已经取代了传统的用户界面的设计方法。而在可视化编程中，人机之间的直接联系主要是通过一些窗口和对话框来实现。JBuilder9也不例外，它也是通过这些窗口和对话框来实现窗体。用户需要的控件则可以直接放置在窗体上，利用这些控件来实现复杂的功能。

　　用户界面设计器是用户在编写程序过程中最常用到的工具。用户在进行界面设计时，只需单击文件视图标签中的Design页，就会出现该用户界面设计器。用户可以利用JBuilder提供的各种控件来搭建自己的程序界面。而且同时，JBuilder9还为这些界面自动生成了相应的代码，为用户提供了程序的环境。接下来，就要由用户设置属性，来编写一些实现用户特定功能的代码。这在很大程度上减少了用户界面设计的复杂度，使用户的主要精力投入到如何实现和加强功能上来。

　　五）源代码编辑器

　　只要用户进行有关的程序编写，就需要相应的程序编辑器，JBuilder9同样提供了这样一个编辑器，在进行程序设计时，只需单击文件视图标签中的Source页，就会出现源代码编辑器，利用它就可以进行JBuilder的程序编辑了。

　　对于源代码编辑器，用户还可以根据自己的喜好和习惯进行设置，其设置方法主要是：通过单击Tools->IDE Options显示IDE Options对话框，在这个对话框中可设置窗口大小、字体大小等信息。通过Tools->Editor Options菜单项打开的标签页可以对编辑器、显示、颜色、代码预览、模板、Java结构等内容进行设置。例如，用户可以设置自己喜欢的编辑显示模板。使用代码摸板也同样可以加快编程的速度。JBuilder9已经预定义了若于代码模板，包括类声明、if语句、if else语句、try/catch语句以及while语句等模板。

　　在程序代码编辑器中，如果用户想获得帮助，只要在将鼠标停放在想要查询的关键词、对象或其他标记上，然后按F1键，就能得到相应的帮助。当新建一个应用时，JBuilder 9 便在代码编辑器中为主窗体创建一单元文件Frame1.java。

　　如果要在源代码编辑器中访问其他文件，只要在工程窗口中单击相应的文件即可。在程序编译时，如果出现了错误，除了在消息框窗口显示错误信息，还会在源代码编辑器中高亮显示出现错误的行。用户可以在源代码编辑器中快速定位需要查找的方法、属性与事件。此外，双向设计工具支持在可视化编辑器对代码的修改，同时可以反映到设计视图中。

　　JBuilder9的代码预览功能(CodeInsight)可以在编辑器中显示一个与上下文相关的弹出窗口。它可以帮助用户快速、准确地编写Java代码。例如，单击一个对象，马上在相应位置出现其所有的属性和方法等内容，用户可以快速地选择所需要的内容。代码预览功能可帮助用户显示与上下文相关的数据成员与方法列表(MemberInsight)、当前代码中要使用的方法的参数列表(ParameterInsight)、可以通过当前类路径访问的类列表(ClassInsight)、结构窗口中的错误(ErrorInsight)以及在调试时显示变量值及表达式的值。

　　六）错误检查和调试

　　在JBuilder9中，在编辑器中可以用红点显示当前行的代码错误，但是并不能显示在逻辑上的错误，以及运行的错误，所以还需要进一步了解如何进行错误检查和调试，来排除逻辑以及运行时的错误。

　　首先，要进行断点设置。方法非常简单，在编辑器中的任意一行语句的前面单击鼠标，将会自动将该行设置为断点。上面的断点只是最简单的行断点，其实断点还有其他类型。断点共有5种类型：Line、exception、class、method和cross-process。具体的含义请大家参考帮助资料。

　　用户还可以通过选择Run菜单中的Debug ，用蓝色显示的是出错的文件Project菜单项进入程序的调试界面。在调试和运行程序时，系统会将错误显示出来(红色部分的文字)，其中名和程序行，单击该部分，在编辑器中将会切入该文件，并以高亮显示出错的程序行。当用户需要观测对象的情况时，首先要添加观测对象，方法是单击Run菜单中的Add Watch菜单项，然后找到该对象的断点，再运行Debug Project进入调试状态。

　　四、用Jbuilder 9开发一个简单的应用程序

　　在JBuilder 9中编写程序的一般过程包括下面4个步骤：

　　(1)建立一个工程文件。

　　(2)利用向导生成程序框架和界面。

　　(3)手工修改程序代码。

　　(4)编译和运行程序。

　　这里我们只介绍生成程序的"全自动"方法，不用手工修改程序代码。我们在了解了集成开发环境之后，现在就可以开始利用JBuilder9所提供的应用程序向导来进行应用程序设计。下面将以构建一个简单的框架应用程序为例，来说明JBuilder9应用程序的开发过程。

　　1、使用Proioct Wizard创建工程

　　用户可以使用JBuilder9的Project Wizard来创建工程。工程名为example.jpx。工程文件包含了工程中其他文件所在的目录信息。使用Project Wizard创建工程的具体步骤如下。

　　(1) 选择File->New Proiect菜单项，出现如图19所示的对话框。

图19

　　(2)在Name(名称)文本框中，输入example，其他选项使用默认值。

　　(3)单击Next按钮，进入如图20所示的对话框。

图20

　　(4)保持默认设置，单击Next按钮，进入如图21所示的对话框。

图21

　　(5)在Title(标题)中输入Example，并输入相关的Description(描述)信息以及Author(作者)等。

　　(6)单击Finish(完成)按钮，完成工程设置，JBuilder将会自动生成工程example。

　　2、使用Application Wizard创建应用程序

　　我们可以使用Application Wizard来创建一个Java应用程序，具体步骤如下。

　　(1)选择File->New菜单项，出现Object Gallery对话框。如图22所示，该对话框提供了创建各种不同文件的向导。

图22

　　(2)单击Application图标，出现Application Wizard对话框，如图23所示，保持默认设置，单击Next按钮，进入应用程序向导的步骤2。

图23

　　(3) 如图24所示，在Class(类)文本框中输入Frame1，在Title文本框中输入Example。

图24

　　(4)勾选Center frame on screen复选框，可以使应用程序运行在屏幕的中心位置，单击Next按钮，进入应用程序向导步骤3，如图25所示。

图25

　　(5)保持默认设置，单击Finish按钮，即完成Java应用程序的设置，系统会自动建立example.java和Frame1.java程序并添加到工程中，还会自动生成与该应用程序界面相对应的源程序。

　　单击Frame1.java和example.java就可以查看相应的源代码，如图26所示。

图26

　　选择Run->Run Project菜单项，或者按快捷键F9，系统会运行应用程序。结果如图27所示。

图27

黑武士 2005-08-02 08:22 发表评论

开发J2EE应用的要领

黑武士 — Tue, 02 Aug 2005 00:19:00 GMT

J2EE，作为开发mission-critical的企业级应用的一整套规范的整合平台。其规范之多、内容之广，从而给开发J2EE应用带来了很多“麻烦”。比如，为实现内容的RDBMS存储，我们可能的方法有JDBC、Entity Beans、JDO、O/R Mapping工具（TopLink、Hibernate）、XML-DBMS、JAXB等方法（其中一些方法不是J2EE规范所包含的）。因此，为实现J2EE各层（至少有表示层、控制层、商业逻辑层等3层）以及层与层之间的耦合，J2EE系统架构师需要考虑的问题会很多。加上，J2EE本身的快速发展，给架构、开发具有工业强度的J2EE应用带来一些难题。
同时，软件开发技术从来就没有“银弹”，所以J2EE技术也不是万能的。但是，如果我们在结合具体商业需求的基础上，合理的应用好J2EE技术，其结果可想而知。本文试探从自己以往的项目经验来探讨开发J2EE应用应该遵循的几点准测入手，以起到抛砖引玉的作用。如果能达到这一点要求，则万分激动。
本文结合JBoss 3.2.1下的J2EE应用开发为例展开论述。

1，结合商业需求选择合理的架构

如果脱离商业需求，而单独的讨论技术本身的优势是不够的。各项技术都有产生的特定背景，其中很多都是来自工业需求而触动的。一般而言，企业信息系统（EIS）都要求自己稳定、安全、可靠、高效、便于维护。同时，各个企业信息系统都有自己独特的要求，可能有些时候需要考虑与原有遗留系统的集成，所以了解各个企业信息系统具体的商业需求对于整个系统的架构显得很关键。
比如，如果待开发的J2EE应用系统中使用到的数据大部分来自于外在数据源；而这些数据可能是通过JDBC直接从外在数据源导入到待开发的J2EE系统的Database中。对于这种情形，如果在开发过程中，仅仅使用JDBC来操作数据库，对于小强度（并发访问用户少、数据流量少）的情形，显然是比较合适的；但如果，并发访问用户较多、数据流量大，对Database层使用较为频繁的情形，则显得有些力不从心。因此，对于这种需求，我们可以考虑采用Entity Beans with Caches。打个比方，在JBoss 3.2.1中对于Entity Beans的Cache策略有多种，这时可以考虑使用，，即“Standard CMP 2.x EntityBean”，方式并采用“D”类型的commit-option来保证Entity Beans的内容与数据源的同步，并使得系统的性能得到大大改善（同直接使用JDBC相比）。其中，可以将一些Entity Beans设置为read-only，以改善性能。
当然，在这里也可以采用其他一些O/R Mapping技术，比如TopLink。
再比如，考虑这样一种情形：如果待开发的企业信息系统使用到的数据都是由系统本身生成和操作的，则建议采用：CMP Entity Beans技术。Entity Beans给大家的印象很坏，这可能与EJB 1.1给大家留下的坏映象有关吧。但是，EJB 2.0(或者说2.1)得到了很大的改善，Local Interfaces、CMR、Read-Only、Session Façade模式给Entity Beans注入了活力。当然，并发用户多、数据流量很大时才会体现出使用Entity Beans的优势。其中，有一点很关键：要注重Entity Beans技术的性能调优，各个应用服务器都有自己的一套性能调优方案。对于JBoss 3.2.1，配置文件standardjboss.xml提供了Entity Beans技术调优的入口。比如，Bean Lock策略的合理使用对于Entity Beans的调优就显得很重要。这样使得，我们可以更加关注于系统的商业逻辑，而不只是底层的Database（EJB调优处于EJB Container中，因此我们处在J2EE性能的高端，而不是底端，即Database层。同时，Database层的调优使得J2EE系统的数据库移植性大打折扣。）。
简而言之，要结合各个系统的特定需求和状况给出具体的技术架构方案，而不能孤单的论述技术本身的好坏。

2，Framework的合理选用

设计模式在J2EE应用系统中扮演着重要的角色。因此，有一个问题摆在大家面前，是自己来实现具体的设计模式，还是借助于Third-party Framework。如果贵公司不大，或者说公司不想在J2EE基础应用Framework投入很多精力，选用现有的较为成熟的、稳定、与现有J2EE Specification兼容的技术框架会比较明智。
一般而言，Framework本身，或者说J2EE平台本身都是实现并优化了具体的设计模式、规则，比如业务代理、Service Locator（包括Web Tier和EJB Tier各自的服务定位器，起到统一管理有限资源、Cache相关资源的作用，便于系统移植）、Front Controller、DAO等等。现有的J2EE Framework比较丰富。比如：
Struts: 对于实现了Model 2类型的Framework，对于现在以及将来（随着JSF规范、技术的成熟），选用她是一种明智之举。目前，Struts已经发展到1.1版本。其内在的MVC主线、对后端数据操作方式没有限定、集合了Apache Jakarta项目组的优秀相关项目的精华，可谓是开发J2EE应用的佳品。同时，对于具有.NET Web Forms功能的下一代J2EE平台技术JSF而言，Struts本身可考虑到与JSF的兼容和集成性。比如，通过JSP呈现表示层、Servlet呈现控制层、EJB呈现数据存储层。各层之间，可以通过值对象、HTTP相关对象来通讯，实现J2EE相关技术的完美应用。
Log4j: 我想对于习惯采用“System.out.println(“”);”的读者而言，Log4j是大家的福音。尽管Java 2 Standard Edition也具备java.util.logging包来保证日志的输出，但Log4j的简单、高效、灵活已经成了很多项目的选择。日志，在某种程度上可以考验系统的稳定性、正确性，所以采用可配置的Log4j（目前，Log4j已经考虑到了与java.util.logging包的兼容性）是不会错的。比如，JBoss 3.2.1本身就是借助于Log4j来管理日志的。
realMethods: 可能有些读者还不知道这一款杀手锏。那好，这里就简要作一介绍。realMethods是一开发J2EE应用的Framework，她不同于Struts(主要在于实现Model 2，J2EE应用前端)；realMethods对于J2EE应用的各个层面都有详尽、高效的支持。同时，realMethods以前还是商用软件，现在已经成为了Open Source的产品，因此现在可以参看其全部源代码。
BC4J: Oracle公司推出的用于Java的商业组件。其内容和外在的特点和优势，不言而寓。
当然，类似的Framework很多很多。作为开发J2EE应用的团队而言，我们需要对各种Framework加以筛选，选择适合项目需求、团队、公司发展方向的框架。
一般情况下，待开发的目标产品不宜采用过多的Framework。其一，J2EE各个技术发展很快，过多的Framework使得系统的后续升级、维护不利；其二，可以借鉴其中的好的一面，比如研究realMethods实现的相应的设计模式，并改造她以适合我们的项目需求；其三，Framework本身会有变动，如果选用过多，会给开发团队加重负担，从而不利于项目管理。
有选择的使用现有的成熟Framework能提升大家的开发效率、开发水平。

3，开发模式的选择

开发J2EE应用要求目标开发人员能够掌握其中的各种技术。但是，现实情况不是这样。作为一个团队，每个人都有自己不同的技能优势、兴趣以及悟性。同时，J2EE本身需要体现社会分工。一般情况下，我们的开发团队不会有Specification所要求的各个开发角色。现实往往只有3种（也可能是两种）：美工、JSP程序员、EJB程序员。面对这种分工，团队更要注重沟通、交流，注重代码的一致性。
一般情况下，团队要尽量采用版本控制工具管理代码、尽量做到每天都有一个完整的运行版本。经过一段时间，团队都会适应这种开发模式。其中，版本控制工具一定要使用，便于代码的管理、控制和备份。这其中会牵扯到很多层面。比如，开发工具的选择要考虑到版本控制工具的使用、建模工具的合理使用有助于团队有效的沟通和交流。
基于现有的开发模式，个人认为这样3套方案不错。第一，采用Together作为建模工具、采用JBuilder作为IDE工具、采用VSS(或者CVS)作为版本控制工具、采用JBoss作为开发J2EE应用开发阶段的服务器。第二，采用WebSphere Studio整套工具。第三，采用Eclipse(或者JCreator)、Ant、XDoclets作为开发工具。
当然，手工完成J2EE应用的编写、编译、打包、部署、测试更能使开发者理解各个开发阶段的具体细节。但本人认为，只要开发者有这种关注具体细节的态度，选用功能强大的建模、开发工具是明智的。开发工具不能提高开发人员的开发技能，但是她能够引导开发人员正确的开发方向。比如,JBuidler 9 Enterprise提供的EJB精灵具有的“Struts + EJB + Session Façade + Value Object”等功能呈现了业界广泛应用的J2EE构架方式。

4，注重各个阶段的测试工作

测试工作往往是很多项目经理忽视，不愿意去花费时间、费用的内容，因为那样会增加项目的成本。但是，他们忽视了，项目的完成质量往往对项目的成本有很大的关系。比如，如果软件质量很差，并没有经历测试阶段，其后期部署、运行所带来的费用会远远超过前期的费用。
测试是分阶段的。单元测试，比如借助于JUnit，来保证功能正确等内容。集成测试，来保证系统没有内存泄漏等内容。其中，Optimizeite Suite Enterprise对于完成Profiler、Code Coverage、Thread Debugger等内容很有帮助。我记得，我写的一个Swing桌面应用存在内容泄漏，但是想了很多办法都没有解决问题。后来，采用Profiler获得了答案。因此，现在开发应用，我们很多时候都采用Optimizeite Suite Enterprise作为测试工具。尤其是，在做集成测试过程中，检查系统的内存泄漏、性能很有帮助。
测试是分类型的。压力测试、性能测试。就目前对支持J2EE应用的测试而言，并没有很好的测试工具。但是，一般情况下，借助于Rational Robot也能够取得不错的效果。

当然，成功开发J2EE应用的因素有很多。比如，Entity Beans的成功应用很大程度上与底层Database的设计有关系（如果表结构设计设计的不合理，将导致Entity Beans性能的急剧下降）；如何最大化挖掘、提升团队各个成员的J2EE技能。等等这些，设计面很广。

黑武士 2005-08-02 08:19 发表评论

各种语言多态性比较

黑武士 — Mon, 01 Aug 2005 07:21:00 GMT

简单整理了各种语言多态性的相关内容以及部分高级特性。
－－－－－－－－－－－－－－－－－－－－－－－－－
                                  Delphi
－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
加overload
【虚基类】
delphi不支持多继承，所以没有虚基类这一说。
【虚函数】
父类的虚函数定义有两种方式：
(1)procedure Draw; virtual;
(2)procedure Draw; dynamic；
两者基本是一样的，前者速度优化，后者容量优化。
子类用override覆盖就行了：
procedure Draw; override；
【纯虚函数】
父类定义如下
procedure fly(); virtual; abstract;
子类使用如下：
procedure fly(); override;
【抽象类】
不清楚DELPHI有没有这个概念，印象中好像没有提及过。
【接口】
IFoo=interface
['{2137BF60-AA33-11D0-A9BF-9A4537A42701}']
function F1:Integer;
end;
IBar=interface
['{2137BF61-AA33-11D0-A9BF-9A4537A42701}']
function F1:Interger;
end;
【属性】
TMyObject=class
private:
SomeValue:Integer;
procedure SetSomeValue(AValue:Integer);
public:
property Value:Integer read SomeValue write SetSomeValue;
end;
procedure TMyObject.SetSomeValue(AValue:Integer);
begin
if SomeValue<>AValue then
  SomeValue:=AValue;
end;
－－－－－－－－－－－－－－－－－－－－－－
                              C++
－－－－－－－－－－－－－－－－－－－－－－
【重载】
定义同名不同参的函数就行了，没有专门的关键字。
【虚基类】
多继承时用virtual关键字声明继承方式，避免基类中同类成员的多拷贝。
class A     //定义基类A
{
A(int i){}       //基类构造函数，有一个参数
    …
};
classB:virtual public A    //A作为B的虚基类
{
B(int n):A(n){}     //B类构造函数，在初始化表中对虚基类初始化
    …
};
classC:virtual public A //A作为C的虚基类
{
C(int n):A(n){}  //C类构造函数，在初始化表中对虚基类初始化
    …
};
classD:publicB，publicC    //类D的构造函数，在初始化表中对所有基类初始化
{
D(int n):A(n)，B(n)，C(n){}
…
  }
【虚函数】
在父类中用virtual声明函数，并实现函数的定义；
在子类中重载此函数，可以实现动态联编。
父类包含虚函数：
class Point
{
public:
Point(double i,double j) {x=i;y=j;}
virtual double Area() const {return 0.0;}
private:
double x,y;
};
子类中覆盖虚函数：
class Rectangle:public Point
{
public:
Rectangle(double i,double j,double k,double 1);
virtual double Area() const { return w*h;}
private:
double w,h;
};
调用这个函数实现动态联编：
void fun(Point &s)
{
cout<}
【纯虚函数】
用关键字virtual声明的函数，并且不实现函数的定义。
例如下面的类中定义了两个纯虚函数，
class point
{
public:
point(int i=0,int j=0) {x0=i;y0=j;}
virtual void set()=0;
virtual void draw()=0;
protected:
int x0,y0;
};
【抽象类】
称带有纯虚函数的类为抽象类，只能作为基类。
抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，它处于继承层次结构的较上层，抽象类是不能定义对象的，在实际中为了强调一个类是抽象类，可将该类的构造函数说明为保护的访问控制权限。
class Shape
{
public:
  virtual float area() const{return 0.0;}
  virtual float volume() const{return 0.0;}
  virtual void shapeName() const =0;
};
子类中若不重载父类中的函数，则子类也是抽象类。
【接口】
形式上就是把抽象类中的class换成interface，可以从其他接口继承，当然最主要的被别的类继承。
如COM中常用的IUnknown接口声明如下：
interface IUnknown{
virtual HRESULT STDMETHODCALLTYPE
  QueryInterface(REFIID riid,void **ppv)=0;
virtual ULONG STDMETHODCALLTYPE AddRef(void)=0;
virtual ULOND STDMETHODCALLTYPE Release(vod)=0;
};
C++中一般用抽象类来实现接口。
【属性】
标准C++中没这东东。
－－－－－－－－－－－－－－－－－－－－－－－－－－
                                     C#
－－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
定义同名不同参的函数就行了，没有专门的关键字，和C++一样。
【虚基类】
单继承下不流行这玩意。
【虚函数】
在父类中用virtual声明函数，并实现函数的定义；
public virtual bool SQLExe(bool b)
{
    return true;
}
在子类中用override覆盖此函数，可以实现动态联编。
【纯虚函数】
用关键字abstract声明的函数，并且不实现函数的定义，必须存在于抽象类中。
public abstract bool f();
在子类中用override覆盖此函数。
【抽象类】
用abstract声明，父类中可包含虚函数声明，并不实现虚函数的定义，只能作为基类。
public abstract class cl
{
    public cl(){}
    public abstract bool f();
}
【接口】
和类定义类似，用interface说明。
[attributes] [modifiers] interface identifier [:base-list] {interface-body}[;]
1、attributes（可选）：附加的定义性信息。
2、modifiers（可选）：允许使用的修饰符有 new 和四个访问修饰符。
分别是：new、public、protected、internal、 private。
在一个接口定义中同一修饰符不允许出现多次，new 修饰符只能出现在嵌套接口中，表示覆盖了继承而来的同名成员。
public, protected, internal, and private 修饰符定义了对接口的访问权限。
3、指示器和事件。
4、identifier：接口名称。
5、base-list（可选）:包含一个或多个显式基接口的列表，接口间由逗号分隔。
6、interface-body：对接口成员的定义。
7、接口可以是命名空间或类的成员，并且可以包含下列成员的签名：方法、属性、索引器。
8、一个接口可从一个或多个基接口继承。
允许实现多个接口
例如一个带事件的接口定义如下：
public delegate void StringListEvent(IStringList sender);
public interface IStringList
{
　void Add(string s);
　int Count { get; }
　event StringListEvent Changed;
　string this[int index] { get; set; }
}
【属性】
private int myheight;
public int MyHeight
{
   get{
         return this.myheight;
      }
   set
      {
         this.myheight = value;
      }
}
－－－－－－－－－－－－－－－－－－－－－－－－－－
                                      JAVA
－－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
函数同名不同参就行了。
【虚基类】
单继承不流行这玩意！
【虚函数】
没有这个概念，java自动实现了动态联编，不信你试试！
【纯虚函数】
在JAVA里叫抽象函数，不叫纯虚函数，必须定义在抽象类里面，而且没有方法体。例如：
abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝
【抽象类】
abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝
【接口】
知道有了抽象类，为什么还要接口吗？因为java是单继承，但是接口可以继承多个！
实现多数设计模式的关键技术：
interface Demo {
void method1();
void method2();
…
}
【final类】
final类不能被继承
如果你认为一个类的定义已经很完美，不需要再生成它的子类，这时也应把它修饰为final类
final class classname{...}

黑武士 2005-08-01 15:21 发表评论

J2EE平台架构上开发CRM的技术过程控制

黑武士 — Mon, 01 Aug 2005 05:17:00 GMT

　第一章概述

　　本文阐述了关于在J2EE
统的理解，利用J2EE平台开
等等。这些都是作者在实际
统分析员的重要性，尤其是
素质对于整个项目的成功与

平台上开发CRM应用系统的各方
发过程中要注意的一些技术深层
的工作中通过经验与教训所得来
对于以组件为主要开发对象的工
否起着非常关键性的作用。

面内容，包括本人对于CRM系
的问题，开发分析中要注意的原则
的。在工作中，我深刻的体会到系
程项目，系统分析员的技术与业务

　　需要说明的是，这并非
其中关于一些涉及到具体的

作者工作文档，而仅仅是一篇分
系统设计问题，我仅仅写了标题

享经验与教训的交流文档，因此，
，敬请谅解。

　　第二章 CRM

　　2.1 CRM概述

　　科学技术在不断的进步
源是他获胜的最重要的资源
成为关键；现代竞争其实就
所得到的体验，如何做到最
(CRM)应运而生，并成为近

，市场竞争日益激烈，对于企业
之一：首先企业竞争的优势不仅
是客户的全面争夺而客户对企业
大程度的满足客户是非常重要的
年来西方市场的热点和大买点。

来说，越来越强烈的感觉到客户资
仅是产品本身，先进的服务手段已
的信任程度往往是从其消费过程中
内容，因此，客户关系管理系统

　　实际上，CRM就是企业与客户的一种
过去的部门级别提升到了企业的层次，各
户交流，因此，这就要求能够将与客户通
的所有信息有机的整合。

一对一的需求关系管理。这样，对待客户的视角就从
个部门共享客户资源，以一个统一的对外接口来与客
过各种方式如传真、邮件、电话、网页等交流所获得

　　在设计CRM应用系统的过程中，我们
键是以客户为数据结构的核心，这其中包
怨、客户建议、客户服务记录、客户潜在
是使CRM应用系统有一个对于企业易于理
设计开发可以比较轻易地拓展，具有良好
员能够更加易于控制整个的开发过程，减

首先要注意数据结构的格式：CRM应用系统的实施关
括客户的基本信息、客户所购买的商品列表、客户抱
需求、客户对企业的忠诚度等等。这样设计的原因一
解，易于操作的用户接口，二是对于CRM应用系统的
的开发接口与开发弹性，对于项目负责人、系统分析
少项目开发的风险。

　　另外，我们仔细研究过
但同时也看到了这些产品的
原因在很大程度上是因为技
的J2EE平台上进行开发，这

国内的数家公司的CRM应用系统
不足，在本文的后面部分我们将
术的原因，因此，经过反复的论
样就很大程度上克服了那些不足

的产品，从中学到了很多的东西，
提到，我们发现，造成这种不足的
证，我们最终还是选择了在我熟悉
。

　　2.2 CRM应用系统模块划分

　　CRM应用系统主要由市场管理(Market
中心(Call Center)、电子商务(E_Busine

ing)、销售管理(Sales)、服务管理(Service)、呼叫
ss)五部分组成。

　　市场管理：提供易于使
跟踪市场策略，分析竞争对
过客户资料中的诸如地域、
等等有价值的信息来从不同
经进行或者正在进行的营销
加有效的销售策略。

用的界面与工具，使操作人员能
手的市场策略等等，以便更加有
消费层次，消费习惯与方式、潜
的角度彻底的进行市场的策略分
策略，以及通过对自己和竞争对

够彻底的分析市场、客户，策划和
效的拓展市场。在这个模块中，通
在需求、忠诚度、已购买产品列表
析，同时还可以评估和跟踪目前已
手的数据进行详细的分析，策划更

　　销售管理：管理用户信
员可以不受地域限制及时掌
感兴趣的商品列表以及价格
售队伍成员以及资源重新调
考，灵活进行产品配置、报
整合，以便达到多方位、多

息、商业机会以及销售渠道等等
握资源以及企业的最新的价格信
信息。本模块包括机会、账户、
配的管理，有效跟踪销售业绩，
价、打折、生成销售订单等。另
层次的销售，同时减少销售成本

各方面的内容，从而能够使销售人
息，并可以向客户提供最新的和最
合同等的管理，销售队伍组成、销
同时提供个体的销售方式与过程参
外，本模块还应该和电子商务模块
。

　　服务管理：本模块通过
客户的满意程度，并且捕捉
能够适时的向客户建议其他

动态建立知识库，使客户服务代
和跟踪服务中出现的商业机会、
的产品和服务。

表能够有效的提高服务质量，增加
产品质量信息、客户需求等等，并

　　呼叫中心：呼叫中心是实施CRM应用
务模块进行了一个高度的集成，使一般的
账户、合同等等信息，并通过知识库的支
叫中心提供当今最全面的计算机电话集成
号吗识别(ANI)，交互式语音应答系统(IV
技术，可以在用户拨叫的过程中业务代表

系统的重要的组成部分，他实际上是将销售模块和服
业务代表就可以进行实时的销售和服务。它通过管理
持，就可以最大程度的满足客户的多方面的需求。呼
技术(CTI)，通过对已拨号码识别服务(DNIS)，自动
R)得全面支持，通过采用系统预制的计算机电话集成
已经可以获得客户的资料，就灵活的进行业务处理。

　　电子商务：电子商务模块是以上所有
、高度集成以及易于使用的用户界面，在
购买、付款、寻求服务支持、查询产品与
联系在一起，最大程度的满足客户需求。

模块的一个逻辑集成，它提供了一个个性化、人性化
这个用户界面上客户可以进行几乎所有的需求，诸如
服务目录、查询订单状态等等，甚至可以与呼叫中心

　　由于我们采用J2EE架构
、服务管理以及呼叫中心模
以并且也应该使用销售管理
，要充分利用J2EE平台的优
同时可以控制开发的质量。
负责人、系统分析员必须把

平台的开发方式，所以可以很容
块的内容集成到电子商务模块中
、服务管理模块中开发的组件。
点，组件的高度可重用性，减少
在实际的开发中，对于EJB 、Se
握好质量。

易的将我们在市场管理、销售管理
，同时呼叫中心的大部分功能也可
因此，这就要求我们在开发过程中
开发的成本，加快开发的进度，并
rvlet的质量要求非常严格，项目

　　2.3 CRM应用系统模块内在关系

　　在前面已经提到，在开
为企业提供一个良好的易于
风险。以客户信息为核心，
大为提高，维护性加强。对
一种“插件”，各个模块功
制。

发CRM应用系统的数据结构时一
操作的用户界面，另一方面是提
所有的模块的内容都是围绕客户
于开发人员，尤其是系统分析员
能之间的耦合性大为降低，很显

定要以客户信息为核心，一方面是
高开发的可控性，减少开发成本与
，这样也使得应用系统的可拓展性
，所有的功能内容对于他来说都是
然会使整个的开发过程更加易于控

　　在各个模块的具体开发实施中，销售
过销售人员的销售活动的信息支持，对于
实时的给与市场人员以信息支持，从而随
应该说销售管理、服务管理、呼叫中心以
，同时反过来，市场管理策略也给与其余
结构地设计上以客户信息为核心数据。

模块是基础，他负责管理账户、机会等信息，并且经
客户的信息（如需求、购买行为等）的补充，就可以
时把握销售策略，便于及时调整。从某种意义上讲，
及电子商务这四个模块都是作为市场模块的信息支持
企业活动以策略支持。要实现这一点，就必须在数据

　　CRM应用系统各个模块
复杂的系统，我们不能按照
带来应用系统在开发、扩充
象，将客户资源作为操作的

之间的关系在企业业务上关系非
一般传统的软件工程观念，在各
以及维护方面等很多的问题。正
核心。

常紧密，但是作为一个非常庞大和
个模块之间通过接口通信，这样会
确合理的方案是将客户视做一个对

　　2.4 CRM应用系统各模块的技术要求

　　基于客户对于CRM应用
用系统各个模块中除了呼叫
成瘦客户端（浏览器）/服
较，我们最终确定采用在J2
较成熟的技术规范，相对于
从很久就一直跟踪分布式开
书籍)。因此，比较了几种
务逻辑抽象出来，写成组件
台界面，调用后台的商务逻

系统的实际需求以及考虑到系统
中心可以做成客户/服务器(C/S)
务器(B/S)模式。经过了反复的
EE平台上开发CRM应用系统的技
微软的.NET来说，它的开发要更
发的技术，对于J2EE的开发非常
开发平台之后，我们决定采用J2
，然后将其发布到服务器上，再
辑。

的未来拓展性、可维护性，CRM应
体系模式之外，其他模块都应该做
论证并且通过与别的技术方式的比
术方案。一方面是因为作为一种比
加安全、成本更低，另一方面，我
熟悉。(当时还没有相关的中文版
EE。在这种开发平台上，我们将业
通过前台程序的开发程序员开发前

　　市场管理、销售管理、服务管理之所
需要，可以不受地域的限制，随时随地地
。因为我们看到，在呼叫中心模块中有销
其余模块的商务逻辑，我们将其抽象出来
。

以采用分布式的开发，一方面是满足业务人员的办公
办公，另一方面也是为了降低开发的成本与维护成本
售管理、服务管理等内容，同时电子商务模块中又有
，一是组件复用，二是减少开发工作量同时减少风险

　　第三章：J2EE

　　3.1 J2EE概述

　　任何一个有经验的Java
综合程度，并且发展非常迅
统级别程序设计提供了丰富
，它定义了整个标准的应用
注意力集中在封装商业逻辑
都由应用程序容器或者服务
的运行时属性都可以使用高
供了一个简化的开发模型，
发商和应用服务器无关。

平台开发人员，都会知道这个平
速。Java平台的许多应用程序接
的功能。J2EE是一种技术规范，
开发体系结构和一个部署环境，
和商业规则上，一切与基础结构
器来处理。甚至，从属于事务、
度灵活的声明方法在部署环境中
它具有工业强度的可拓展性，支

台具有非常强大的功能和非常高的
口(API)为各种应用程序设计和系
他给开发人员提供了一种工作平台
在这个体系结构中，应用开发者的
服务相关的问题以及底层分配问题
持久化、安全等等方面的应用组件
定制(一般采用XML)。这个平台提
持合理的集成和灵活的部署，与开

　　3.2 J2EE组成部分

　　对于开发人员来说，J2EE平台提供给
式。

他们的就是三种，Jsp、Servlet、EJB这三种开发方

　　Jsp

　　Jsp其实是一种高层的S
在执行时有一些不同。Jsp
执行就和Servlet的一样了
然后输出结果。

ervlet。他与以往的其他网页编
引擎将它和它所在的HTML文件一
：先编译成.class文件，然后由

写脚本有很大的相似性，但是只是
起合成Servlet的代码，然后它的
支持java虚拟机的服务器来执行，

　　我们在使用Jsp中可以使用JavaBean来进行更加灵活的处理。

　　Servlet

　　Servlet可以被看作是
这两个对象来输出和接收用
问别的Servlet方法、调用E
具来进行开发。在一般的工
一般的java语言就可以进行

服务器端的applet，它通过Serv
户传递的参数，然后在内部的方
JB等等，然后将处理结果返回给
具中都已经构建好一个框架，程
开发了。

letResponse以及ServletRequest
法中执行操作，如访问数据库、访
客户端。可以通过集成化的开发工
序员只需要熟悉html标签以及熟悉

　　EJB

　　EJB如果除去它的语言特点外，我想
可以轻松理解，他非常类似于微软的DCOM
让客户进行透明调用，而不必关心位置，
相关的配置文件，以便告诉容器她要怎样
开发工具，如JBuilder，就可以大大减少
容器信息，我们可以通过它的模板来完成
。

对于大多数有比较丰富编程经验的开发人员来说应该
。他有一个自己要存活要活动的一个容器，为了可以
他还必须有一个本地和远程接口，同时还应该有一个
的活法。对于开发人员来说，如果采用一种集成化的
工作量。在JBuilder中通过配置相关的服务器路径、
一个EJB组件的开发以及分发，非常方便也非常简单

　　在开发过程中，建议的
但是对数据库的亲和，而会
以结合这两种bean的所有优
据库的访问同时会话bean用

开发方式是在会话bean内部调用
话bean中有我们为了控制程序而
点，来比较轻松的进行开发。比
来保存客户的上下文信息。

实体bean，因为实体bean没有状态
需要的上下文信息，因此，我们可
如在会话bean中用实体bean进行数

　　3.3 J2EE各组成部分在开发CRM应用系统中的脚色

　　我们已经提到过，开发一个健壮的、
外我们都将采用浏览器/服务器模式。因

可拓展的CRM应用系统中的各个模块，除了呼叫中心
此，下面的模式是除了呼叫中心模块之外的方式：

　　浏览器--------〉Jsp脚本文件-----
EJB------访问数据库---------〉处理返

---调用---------〉Servlet------调用--------〉
回。

　　其中Jsp属于前台开发
，使用性强，便于操作；

人员进行的开发内容，也就是提

供给客户的用户界面，要求是美观

　　Servlet、EJB为后台开
他们主要是进行企业的商务
的独立性与组合性。

发人员开发的具有可以重用性的
逻辑的处理。要求是开发的程序

包含商务逻辑的组件，也就是说，
一定要健壮，充分注意到业务逻辑

　　在开发CRM系统时，前面已经说过，
系统业务的理解程度将极大的决定了系统
完全细化到Servlet、EJB组件所封装的商

系统分析员自身对于J2EE技术的把握深度，对于CRM
的成功与否。就是在做系统分析时一定要做到将功能
务逻辑中去，并且要反复论证其合理性与独立性。

　　3.4 J2EE各技术实现CRM应用系统的特点

　　Jsp相对来说比较简单，但是在开发
放到Jsp文件中，有几个原因，一是Jsp文
的开发，将会极大的增加开发与维护成本
后将版面分割成不同的部分，用不同的被
某些与程序逻辑实现无关的动态内容最好
的Jsp文件时系统分析员要注意下面的几

过程中系统分析员一定要注意尽可能少地将商务逻辑
件本身的可维护性比较差，尤其是如果不采用的方式
。因此，在前台的Jsp开发中首先要划分出版面，然
包含文件来最终组成用户界面。另外要注意的一点是
放在数据库中，而不要放在文件中。所以在开发前台
个问题：

　　1、划分版面的界面逻辑，用包含文件的方式给程序员确定开发代码；

　　2、尽量不将商务逻辑放在Jsp文件中，所有的业务处理都要调用后台的组件；

　　3、当涉及到的界面逻
Jsp文件中直接嵌入java代

辑较多的时候，要给程序员设计
码，否则会造成Jsp文件的可读

JavaBean来进行处理，而不是在
性非常差，维护与调试异常困难。

　　Servlet作为在服务器
的、准确等的要求外，还有
相比通用网关接口CGI有着
的线程，但是可能很多程序
间是共享的，并且如果存在
鼓励程序员多注意利用Java
synchronized技术等）解决
的访问数据库会造成数据库
分配连接并在释放以后能够

后台进行处理的组件，除了业务
一个很重要的要求：就是线程安
明显的优点就是可以维护一个线
员都会意识不到一个经常会遇到
着Servlet链互调时，就会发生
提供的方法（如声明自己的类实
线程的问题，另外还要注意的是
服务器的负担同时使客户端的回
回收的连接池。所以，在开发Se

上商务逻辑要独立、完整、可组合
全性。显然，我们都知道Servlet
程池，不用每一次都要创建一个新
的问题：实例变量在所有的线程之
数据错误。因此系统分析员一定要
现了Runnable接口或者采用同步
数据库的连接问题，因为如果频繁
馈速度变慢，因此要注意利用预先
rvlet也要注意下面的3个问题：

　　1、鼓励程序员关注线
步synchronized技术等解决

程安全问题(如采用声明自己的
线程的问题)；

类实现了Runnable接口或者采用同

　　2、数据库的访问要充

分利用JDBC技术的预先分配连接

并在释放以后能够回收的连接池；

　　3、鼓励系统分析员将
实际的程序中通过Servlet

商务逻辑划分成单个的独立的可
链来完成某项商务逻辑。

通用的可重用的商务逻辑组件，在

　　EJB实际上单就程序的写作方面要比S
甚麽就可以了，而不必关心事务的处理，
要求：

ervlet简单的多，它使程序员只需要关心要实现的是
底层的操作等等问题。但是也还是有一些编程方面的

　　1、最好能够在程序中
出现时语义的不一致问题；

将所有的static字段都声明为fi

nal型的，这样可以保证多个实例

　　2、注意线程问题，同Servlet；

　　3、不使用文件系统。E
询，基本上是不用文件系统

JB组件可以通过环境命名上下文
。

用一种标准的方法进行环境实体查

　　4、禁用socket来进行监听和接收连接，或者用其进行多路发送。

　　5、不可能用awt函数来完成键盘的输
息，因为组件是用来在服务器端完成某一

入和输出，如果有的话，应该是向控制台输出控制信
项商务逻辑的。

　　第四章：J2EE平台架构开发CRM的内容

　　本章的内容是一个非常
，运行图等等。因为某种原

大的部分，他所涵盖的就是具体
因，这儿就不写了，请谅解。

的开发方案，其中包括使用案例图

　　第五章：技术层面控制J2EE平台架构开发CRM的过程

　　在J2EE平台上开发CRM应用系统，是
技术规范，各大IT服务器、中间件厂商也
竟.NET是一项新的技术规范，如果在其上
是在走向成熟。

一个非常优秀的方案，一方面J2EE是一项比较成熟的
都大力推崇并支持，尽管微软大力推出.NET，但是毕
进行开发的话，风险显然要大得多，而J2EE目前却正

　　正像任何事情一样，在
，在这个过程当中，有一个
握深度、对CRM应用系统的
系统分析员自身的素质决定
员对于客户的需求的理解程
；其次是系统分析员的思维
到将商务逻辑进一步细化成
有着非常深的掌握，这是实
就在服务器端组件的开发上
是否规范与合理，而系统分

先进的J2EE平台上开发CRM应用
非常重要的脚色：系统分析员。
业务理解程度很大得影响了开发
了开发的成功与否，这是一个非
度，只有深入的理解了客户的需
是否严密，是否严谨，是否具有
独立的可重用的业务逻辑与使用
施CRM的另外一个重要之处，因
，一个系统能否稳定，高效的运
析员在实施编码阶段的主要职责

系统必须要有一个良好的实施过程
系统分析员自身对于J2EE技术的掌
的过程，甚至可以毫不夸张的说，
常关键的因素。首先是系统分析
求，才能够将商务逻辑很好的划分
很强的逻辑思维能力，因为这涉及
逻辑。第三是其是否对于J2EE技术
为在整个的开发过程中，其实重心
行，很大程度上取决于开发技术上
就是负责检查程序员的程序代码

　　在开发过程中另外一个
概念不同，它有着严格的分

注意的是开发人员的分工。在J2
工：

EE平台上的开发与一般的软件开发

　　1、系统分析员；

　　2、后台组件开发程序员（主要是Servlet与EJB）;

　　3、后台服务器实施技术人员(主要负责组件的管理)；

　　4、后台组件测试人员；

　　5、前台用户界面程序员（主要是jsp程序员+美工）；

　　6、前台测试技术人员；

　　在实际的实施过程中，后台服务器实
，前台用户界面程序员可以充当前台测试

施技术人员可以充当后台组件测试人员的脚色，同样
技术人员，因为他的页面中所包含的逻辑比较少。

　　总结一下，关键的几点
含有一种商务逻辑，一般的
何组合就是看系统分析员的
，尽量避免前台程序员与后
而这是绝对不允许的，否则
在开发过程中一定要注意组
严格把关，这一点非常非常

：1、商务逻辑一定要划分的非
商务逻辑应该是通过几个组件的
功底了！）2、分工一定要明确
台程序员的脚色互换，否则很可
随着开发过程的进行，就会发现
件的商务逻辑的独立性与唯一性
重要。

常合理，原则是一个组件中应该只
协同合作来实现的（如何划分，如
，除了上面所列出的脚色充当之外
能造成商务逻辑组件之间的耦合，
越来越难以控制应用的开发。所以
，系统分析员和项目负责人一定要

　　第六章：CRM应用系统各个模块的具体技术实现

　　应用系统都是开发商基于对某项业务
，即便是同一行业也有不同，因此，要根
都有一个共同的框架，就是上面所提到的
架+具体商务逻辑。而框架部分则就是上
象出来做成组件，以备复用。

的深刻理解而产生的，不同的行业有不同的商务逻辑
据客户的实际需求来做。但是，作为一个CRM系统她
，因为，一套完整和实用的CRM系统可以看作是：框
面要求系统分析员所做的工作：将通用的商务逻辑抽

　　本章应该是一个详细的模块设计，其
。出于和第四章同样的原因，请谅解。

中包括组件组合使用图，流程图以及其他的文档等等

　　第七章：国内CRM系统目前存在的问题以及采用J2EE技术进行的解决方案

　　我们研究过国内几家CR
例子：

M系统，学习到很多的东西，但

同时也发现一些问题，现在举几个

　　1、大而全，但是各个功能做的太过于简单，无法实用。

　　2、缺乏集成能力，无法将网页、电邮、电话、传真等集成。

　　3、没有与客户的互动渠道。

　　就这三个原因，是因为在整个的设计
细、完整的划分成个体的、独立的功能组
加上如开发成本的压力等。而如果是采用
开发，就会解决或者避免或者减轻这些问
，电子商务模块基本上也就完成，只需要

上偏离了以客户为中心的原则，没有将客户的需求详
件，没有将各个功能做成是以客户为核心的插件，再
J2EE，并且严格的按照合理划分的组件的方式来进行
题。比如，在开发完销售模块与服务模块的组件之后
少许的其它组件就可以完成一个电子商务模块。

黑武士 2005-08-01 13:17 发表评论

Struts开发指南之MVC架构

黑武士 — Mon, 01 Aug 2005 00:29:00 GMT

　　模型-视图-控制器（MVC）是80年代Smalltalk-80出现的一种软件设计模式，现在已经被广泛的使用。

　　1、模型（Model）

　　模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑.

　　2、视图（View）

　　视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。

　　3、控制器（controller)

　　控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。

　　MVC 式的出现不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性

　　早期的程序中，如果不注意对数功能和显示的解耦合，常常会导致程序的复杂及难以维护。很多VB,Delphi等RAD程序都有这种问题。甚至现在的C#,Java有时候也会出现把业务逻辑写在显示模块中的现象

　　管MVC设计模式很早就提出，但在Web项目的开发中引入MVC却是步履维艰。主要原因：一是在早期的Web项目的开发中，程序语言和HTML的分离一直难以实现。CGI程序以字符串输出的形式动态地生成HTML内容。后来随着脚本语言的出现，前面的方式又被倒了过来，改成将脚本语言书写的程序嵌入在HTML内容中。这两种方式有一个相同的不足之处即它们总是无法将程序语言和HTML分离。二是脚本语言的功能相对较弱，缺乏支持MVC设计模式的一些必要的技术基础。直到基于J2EE的JSP Model 2问世时才得以改观。它用JSP技术实现视图的功能，用Servlet技术实现控制器的功能，用JavaBean技术实现模型的功能

　　JSP Model 1 与 JSP Model 2

　　SUN在JSP出现早期制定了两种规范，称为Model1和Model2。虽然Model2在一定程度上实现了MVC，但是它的应用用并不尽如人意

　　JSP Model 1

　　JSP Model 2

　　model2 容易使系统出现多个Controller，并且对页面导航的处理比较复杂

　　有些人觉得model2仍不够好，于是Craig R. McClanahan 2000年5月提交了一个WEB framework给Java Community.这就是后来的Struts.

　　2001年7月，Struts1.0，正式发布。该项目也成为了Apache Jakarta的子项目之一

　　Struts 质上就是在Model2的基础上实现的一个MVC架构。它只有一个中心控制器，他采用XML定制转向的URL。采用Action来处理逻辑

黑武士 2005-08-01 08:29 发表评论