BlogJava-生活源于奋斗不息（一切皆有可能）-随笔分类-Java

远程方法调用入门指南

生活源于奋斗不息 — Thu, 08 Nov 2007 15:25:00 GMT

Java 远程方法调用（Remote Method Invocation, RMI）使得运行在一个 Java 虚拟机（Java Virtual Machine, JVM）的对象可以调用运行另一个 JVM 之上的其他对象的方法，从而提供了程序间进行远程通讯的途径。RMI 是 J2EE 的很多分布式技术的基础，比如 RMI-IIOP 乃至 EJB。本文是 RMI 的一个入门指南，目的在于帮助读者快速建立对 Java RMI 的一个感性认识，以便进行更深层次的学习。事实上，如果你了解 RMI 的目的在于更好的理解和学习 EJB，那么本文就再合适不过了。通过本文所了解的 RMI 的知识和技巧，应该足够服务于这个目的了。

1. 简介

我们知道远程过程调用（Remote Procedure Call, RPC）可以用于一个进程调用另一个进程（很可能在另一个远程主机上）中的过程，从而提供了过程的分布能力。Java 的 RMI 则在 RPC 的基础上向前又迈进了一步，即提供分布式对象间的通讯，允许我们获得在远程进程中的对象（称为远程对象）的引用（称为远程引用），进而通过引用调用远程对象的方法，就好像该对象是与你的客户端代码同样运行在本地进程中一样。RMI 使用了术语"方法"（Method）强调了这种进步，即在分布式基础上，充分支持面向对象的特性。

RMI 并不是 Java 中支持远程方法调用的唯一选择。在 RMI 基础上发展而来的 RMI-IIOP（Java Remote Method Invocation over the Internet Inter-ORB Protocol），不但继承了 RMI 的大部分优点，并且可以兼容于 CORBA。J2EE 和 EJB 都要求使用 RMI-IIOP 而不是 RMI。尽管如此，理解 RMI 将大大有助于 RMI-IIOP 的理解。所以，即便你的兴趣在 RMI-IIOP 或者 EJB，相信本文也会对你很有帮助。另外，如果你现在就对 API 感兴趣，那么可以告诉你，RMI 使用 java.rmi 包，而 RMI-IIOP 则既使用 java.rmi 也使用扩展的 javax.rmi 包。

本文的随后内容将仅针对 Java RMI。

2. 分布式对象

在学习 RMI 之前，我们需要了解一些基础知识。首先需要了解所谓的分布式对象（Distributed Object）。分布式对象是指一个对象可以被远程系统所调用。对于 Java 而言，即对象不仅可以被同一虚拟机中的其他客户程序（Client）调用，也可以被运行于其他虚拟机中的客户程序调用，甚至可以通过网络被其他远程主机之上的客户程序调用。

下面的图示说明了客户程序是如何调用分布式对象的：

从图上我们可以看到，分布式对象被调用的过程是这样的：

客户程序调用一个被称为 Stub （有时译作存根，为了不产生歧义，本文将使用其英文形式）的客户端代理对象。该代理对象负责对客户端隐藏网络通讯的细节。Stub 知道如何通过网络套接字（Socket）发送调用，包括如何将调用参数转换为适当的形式以便传输等。
Stub 通过网络将调用传递到服务器端，也就是分布对象一端的一个被称为 Skeleton 的代理对象。同样，该代理对象负责对分布式对象隐藏网络通讯的细节。Skeleton 知道如何从网络套接字（Socket）中接受调用，包括如何将调用参数从网络传输形式转换为 Java 形式等。
Skeleton 将调用传递给分布式对象。分布式对象执行相应的调用，之后将返回值传递给 Skeleton，进而传递到 Stub，最终返回给客户程序。

这个场景基于一个基本的法则，即行为的定义和行为的具体实现相分离。如图所示，客户端代理对象 Stub 和分布式对象都实现了相同的接口，该接口称为远程接口（Remote Interface）。正是该接口定义了行为，而分布式对象本身则提供具体的实现。对于 Java RMI 而言，我们用接口（interface）定义行为，用类（class）定义实现。

3. RMI 架构

RMI 的底层架构由三层构成：

首先是 Stub/Skeleton 层。该层提供了客户程序和服务程序彼此交互的接口。
然后是远程引用（Remote Reference）层。这一层相当于在其之上的 Stub/Skeleton 层和在其之下的传输协议层之前的中间件，负责处理远程对象引用的创建和管理。
最后是传输协议（Transport Protocol）层。该层提供了数据协议，用以通过线路传输客户程序和远程对象间的请求和应答。

这些层之间的交互可以参照下面的示意图：

和其它分布式对象机制一样，Java RMI 的客户程序使用客户端的 Stub 向远程对象请求方法调用；服务器对象则通过服务器端的 Skeleton 接受请求。我们深入进去，来看看其中的一些细节。

注意: 事实上，在 Java 1.2 之后，RMI 不再需要 Skeleton 对象，而是通过 Java 的反射机制（Reflection）来完成对服务器端的远程对象的调用。为了便于说明问题，本文以下内容仍然基于 Skeleton 来讲解。

当客户程序调用 Stub 时，Stub 负责将方法的参数转换为序列化（Serialized）形式，我们使用一个特殊的术语，即编列（Marshal）来指代这个过程。编列的目的是将这些参数转换为可移植的形式，从而可以通过网络传输到远程的服务对象一端。不幸的是，这个过程没有想象中那么简单。这里我们首先要理解一个经典的问题，即方法调用时，参数究竟是传值还是传引用呢？对于 Java RMI 来说，存在四种情况，我们将分别加以说明。

对于基本的原始类型（整型，字符型等等），将被自动的序列化，以传值的方式编列。
对于 Java 的对象，如果该对象是可序列化的（实现了 java.io.Serializable 接口），则通过 Java 序列化机制自动地加以序列化，以传值的方式编列。对象之中包含的原始类型以及所有被该对象引用，且没有声明为 transient 的对象也将自动的序列化。当然，这些被引用的对象也必须是可序列化的。
绝大多数内建的 Java 对象都是可序列化的。对于不可序列化的 Java 对象（java.io.File 最典型），或者对象中包含对不可序列化，且没有声明为 transient 的其它对象的引用。则编列过程将向客户程序抛出异常，而宣告失败。
客户程序可以调用远程对象，没有理由禁止调用参数本身也是远程对象（实现了 java.rmi.Remote 接口的类的实例）。此时，RMI 采用一种模拟的传引用方式（当然不是传统意义的传引用，因为本地对内存的引用到了远程变得毫无意义），而不是将参数直接编列复制到远程。这种情况下，交互的双方发生的戏剧性变化值得我们注意。参数是远程对象，意味着该参数对象可以远程调用。当客户程序指定远程对象作为参数调用服务器端远程对象的方法时，RMI 的运行时机制将向服务器端的远程对象发送作为参数的远程对象的一个 Stub 对象。这样服务器端的远程对象就可以回调（Callback）这个 Stub 对象的方法，进而调用在客户端的远程对象的对应方法。通过这种方法，服务器端的远程对象就可以修改作为参数的客户端远程对象的内部状态，这正是传统意义的传引用所具备的特性。是不是有点晕？这里的关键是要明白，在分布式环境中，所谓服务器和客户端都是相对的。被请求的一方就是服务器，而发出请求的一方就是客户端。

在调用参数的编列过程成功后，客户端的远程引用层从 Stub 那里获得了编列后的参数以及对服务器端远程对象的远程引用（参见 java.rmi.server.RemoteRef API）。该层负责将客户程序的请求依据底层的 RMI 数据传输协议转换为传输层请求。在 RMI 中，有多种的可能的传输机制，比如点对点（Point-to-Point）以及广播（Multicast）等。不过，在当前的 JMI 版本中只支持点对点协议，即远程引用层将生成唯一的传输层请求，发往指定的唯一远程对象（参见 java.rmi.server.UnicastRemoteObject API）。

在服务器端，服务器端的远程引用层接收传输层请求，并将其转换为对远程对象的服务器端代理对象 Skeleton 的调用。Skeleton 对象负责将请求转换为对实际的远程对象的方法调用。这是通过与编列过程相对的反编列（Unmarshal）过程实现的。所有序列化的参数被转换为 Java 形式，其中作为参数的远程对象（实际上发送的是远程引用）被转换为服务器端本地的 Stub 对象。

如果方法调用有返回值或者抛出异常，则 Skeleton 负责编列返回值或者异常，通过服务器端的远程引用层，经传输层传递给客户端；相应地，客户端的远程引用层和 Stub 负责反编列并最终将结果返回给客户程序。

整个过程中，可能最让人迷惑的是远程引用层。这里只要明白，本地的 Stub 对象是如何产生的，就不难理解远程引用的意义所在了。远程引用中包含了其所指向的远程对象的信息，该远程引用将用于构造作为本地代理对象的 Stub 对象。构造后，Stub 对象内部将维护该远程引用。真正在网络上传输的实际上就是这个远程引用，而不是 Stub 对象。

4. RMI 对象服务

在 RMI 的基本架构之上，RMI 提供服务与分布式应用程序的一些对象服务，包括对象的命名/注册（Naming/Registry）服务，远程对象激活（Activation）服务以及分布式垃圾收集（Distributed Garbage Collection, DGC）。作为入门指南，本文将指介绍其中的命名/注册服务，因为它是实战 RMI 所必备的。其它内容请读者自行参考其它更加深入的资料。

在前一节中，如果你喜欢刨根问底，可能已经注意到，客户端要调用远程对象，是通过其代理对象 Stub 完成的，那么 Stub 最早是从哪里得来的呢？RMI 的命名/注册服务正是解决这一问题的。当服务器端想向客户端提供基于 RMI 的服务时，它需要将一个或多个远程对象注册到本地的 RMI 注册表中（参见java.rmi.registry.Registry API）。每个对象在注册时都被指定一个将来用于客户程序引用该对象的名称。客户程序通过命名服务（参见 java.rmi.Naming API），指定类似 URL 的对象名称就可以获得指向远程对象的远程引用。在 Naming 中的 lookup() 方法找到远程对象所在的主机后，它将检索该主机上的 RMI 注册表，并请求所需的远程对象。如果注册表发现被请求的远程对象，它将生成一个对该远程对象的远程引用，并将其返回给客户端，客户端则基于远程引用生成相应的 Stub 对象，并将引用传递给调用者。之后，双方就可以按照我们前面讲过的方式进行交互了。

注意: RMI 命名服务提供的 Naming 类并不是你的唯一选择。RMI 的注册表可以与其他命名服务绑定，比如 JNDI，这样你就可以通过 JNDI 来访问 RMI 的注册表了。

5. 实战 RMI

理论离不开实践，理解 RMI 的最好办法就是通过例子。开发 RMI 的分布式对象的大体过程包括如下几步：

定义远程接口。这一步是通过扩展 java.rmi.Remote 接口，并定义所需的业务方法实现的。
定义远程接口的实现类。即实现上一步所定义的接口，给出业务方法的具体实现逻辑。
编译远程接口和实现类，并通过 RMI 编译器 rmic 基于实现类生成所需的 Stub 和 Skeleton 类。

RMI 中各个组件之间的关系如下面这个示意图所示：

回忆我们上一节所讲的，Stub 和 Skeleton 负责代理客户和服务器之间的通讯。但我们并不需要自己生成它们，相反，RMI 的编译器 rmic 可以帮我们基于远程接口和实现类生成这些类。当客户端对象通过命名服务向服务器端的 RMI 注册表请求远程对象时，RMI 将自动构造对应远程对象的 Skeleton 实例对象，并通过 Skeleton 对象将远程引用返回给客户端。在客户端，该远程引用将用于构造 Stub 类的实例对象。之后，Stub 对象和 Skeleton 对象就可以代理客户对象和远程对象之间的交互了。

我们的例子展现了一个简单的应用场景。服务器端部署了一个计算引擎，负责接受来自客户端的计算任务，在服务器端执行计算任务，并将结果返回给客户端。客户端将发送并调用计算引擎的计算任务实际上是计算指定精度的 π 值。

重要: 本文的例子改编自 The Java™ Tutorial Trail:RMI。所有权利属于相应的所有人。

6. 定义远程接口

定义远程接口与非分布式应用中定义接口的方法没有太多的区别。只要遵守下面两个要求：

远程接口必须直接或者间接的扩展自 java.rmi.Remote 接口。远程接口还可以在扩展该接口的基础上，同时扩展其它接口，只要被扩展的接口的所有方法与远程接口的所有方法一样满足下一个要求。
在远程接口或者其超接口（Super-interface）中声明的方法必须满足下列对远程方法的要求：
- 远程方法必须声明抛出 java.rmi.RemoteException 异常，或者该异常的超类（Superclass），比如 java.io.IOException 或者 java.lang.Exception 异常。在此基础上，远程方法可以声明抛出应用特定的其它异常。
- 在远程方法声明中，作为参数或者返回值的远程对象，或者包含在其它非远程对象中的远程对象，必须声明为其对应的远程接口，而不是实际的实现类。

注意: 在 Java 1.2 之前，上面关于抛出异常的要求更严格，即必须抛出 java.rmi.RemoteExcption，不允许类似 java.io.IOException 这样的超类。现在之所以放宽了这一要求，是希望可以使定义既可以用于远程对象，也可以用于本地对象的接口变得容易一些（想想 EJB 中的本地接口和远程接口）。当然，这并没有使问题好多少，你还是必须声明异常。不过，一种观点认为这不是问题，强制声明异常可以使开发人员保持清醒的头脑，因为远程对象和本地对象在调用时传参的语意是不同的。本地对象是传引用，而远程对象主要是传值，这意味对参数内部状态的修改产生的结果是不同的。

对于第一个要求，java.rmi.Remote 接口实际上没有任何方法，而只是用作标记接口。RMI 的运行环境依赖该接口判断对象是否是远程对象。第二个要求则是因为分布式应用可能发生任何问题，比如网络问题等等。

例 1 列出了我们的远程接口定义。该接口只有一个方法：executeTask() 用以执行指定的计算任务，并返回相应的结果。注意，我们用后缀 Remote 表明接口是远程接口。

例 1. ComputeEngineRemote 远程接口

package rmitutorial;
    import java.rmi.Remote;
    import java.rmi.RemoteException;
    public interface ComputeEngineRemote extends Remote {
    public Object executeTask(Task task) throws RemoteException;
    }

例 2 列出了计算任务接口的定义。该接口也只有一个方法：execute() 用以执行实际的计算逻辑，并返回结果。注意，该接口不是远程接口，所以没有扩展 java.rmi.Remote 接口；其方法也不必抛出 java.rmi.RemoteException 异常。但是，因为它将用作远程方法的参数，所以扩展了 java.io.Serializable 接口。

例 2. Task 接口

package rmitutorial;
    import java.io.Serializable;
    public interface Task extends Serializable {
    Object execute();
    }

7. 实现远程接口

接下来，我们将实现前面定义的远程接口。例 3给出了实现的源代码。

例 3. ComputeEngine 实现

package rmitutorial;
    import java.rmi.RemoteException;
    import java.rmi.server.UnicastRemoteObject;
    public class ComputeEngine extends UnicastRemoteObject
    implements ComputeEngineRemote {
    public ComputeEngine() throws RemoteException {
    super();
    }
    public Object executeTask(Task task) throws RemoteException {
    return task.execute();
    }
    }

类 ComputeEngine 实现了之前定义的远程接口，同时继承自 java.rmi.server.UnicastRemoteObject 超类。UnicastRemoteObject 类是一个便捷类，它实现了我们前面所讲的基于 TCP/IP 的点对点通讯机制。远程对象都必须从该类扩展（除非你想自己实现几乎所有 UnicastRemoteObject 的方法）。在我们的实现类的构造函数中，调用了超类的构造函数（当然，即使你不显式的调用这个构建函数，它也一样会被调用。这里这样做，只是为了突出强调这种调用而已）。该构造函数的最重要的意义就是调用 UnicastRemoteObject 类的 exportObject() 方法。导出（Export）对象是指使远程对象准备就绪，可以接受进来的调用的过程。而这个过程的最重要内容就是建立服务器套接字，监听特定的端口，等待客户端的调用请求。

8. 引导程序

为了让客户程序可以找到我们的远程对象，就需要将我们的远程对象注册到 RMI 的注册表。这个过程有时被称为"引导"过程（Bootstrap）。我们将为此编写一个独立的引导程序负责创建和注册远程对象。例 4 给出了引导程序的源代码。

例 4. 引导程序

package rmitutorial;
    import java.rmi.Naming;
    import java.rmi.RMISecurityManager;
    public class Bootstrap {
    public static void main(String[] args) throws Exception {
    String name = "ComputeEngine";
    ComputeEngine engine = new ComputeEngine();
    System.out.println("ComputerEngine exported");
    Naming.rebind(name, engine);
    System.out.println("ComputeEngine bound");
    }
    }

可以看到，我们首先创建了一个远程对象（同时导出了该对象），之后将该对象绑定到 RMI 注册表中。Naming 的 rebind() 方法接受一个 URL 形式的名字作绑定之用。其完整格式如下：

protocol://host:port/object

其中，协议（Protocol）默认为 rmi；主机名默认为 localhost；端口默认为 1099。注意，JDK 中提供的默认 Naming 实现只支持 rmi 协议。在我们的引导程序里面只给出了对象绑定的名字，而其它部分均使用缺省值。

9. 客户端程序

例 5 给出了我们的客户端程序。该程序接受两个参数，分别是远程对象所在的主机地址和希望获得的 π 值的精度。

例 5. Client.java

package rmitutorial;
    import java.math.BigDecimal;
    import java.rmi.Naming;
    public class Client {
    public static void main(String args[]) throws Exception {
    String name = "rmi://" + args[0] + "/ComputeEngine";
    ComputeEngineRemote engineRemote =
    (ComputeEngineRemote)Naming.lookup(name);
    Pi task = new Pi(Integer.parseInt(args[1]));
    BigDecimal pi = (BigDecimal)(engineRemote.executeTask(task));
    System.out.println(pi);
    }
    }

例 6. Pi.java

package rmitutorial;
    import java.math.*;
    public class Pi implements Task {
    private static final BigDecimal ZERO =
    BigDecimal.valueOf(0);
    private static final BigDecimal  ONE =
    BigDecimal.valueOf(1);
    private static final BigDecimal FOUR =
    BigDecimal.valueOf(4);
    private static final int roundingMode =
    BigDecimal.ROUND_HALF_EVEN;
    private int digits;
    public Pi(int digits) {
    this.digits = digits;
    }
    public Object execute() {
    return computePi(digits);
    }
    public static BigDecimal computePi(int digits) {
    int scale = digits + 5;
    BigDecimal arctan1_5 = arctan(5, scale);
    BigDecimal arctan1_239 = arctan(239, scale);
    BigDecimal pi = arctan1_5.multiply(FOUR).subtract(
    arctan1_239).multiply(FOUR);
    return pi.setScale(digits,
    BigDecimal.ROUND_HALF_UP);
    }
    public static BigDecimal arctan(int inverseX,
    int scale) {
    BigDecimal result, numer, term;
    BigDecimal invX = BigDecimal.valueOf(inverseX);
    BigDecimal invX2 =
    BigDecimal.valueOf(inverseX * inverseX);
    numer = ONE.divide(invX, scale, roundingMode);
    result = numer;
    int i = 1;
    do {
    numer =
    numer.divide(invX2, scale, roundingMode);
    int denom = 2 * i + 1;
    term =
    numer.divide(BigDecimal.valueOf(denom),
    scale, roundingMode);
    if ((i % 2) != 0) {
    result = result.subtract(term);
    } else {
    result = result.add(term);
    }
    i++;
    } while (term.compareTo(ZERO) != 0);
    return result;
    }
    }

10. 编译示例程序

编译我们的示例程序和编译其它非分布式的应用没什么区别。只是编译之后，需要使用 RMI 编译器，即 rmic 生成所需 Stub 和 Skeleton 实现。使用 rmic 的方式是将我们的远程对象的实现类（不是远程接口）的全类名作为参数来运行 rmic 命令。参考下面的示例：

E:\classes\rmic rmitutorial.ComputeEngine

编译之后将生成 rmitutorial.ComputeEngine_Skel 和 rmitutorial.ComputeEngine_Stub 两个类。

11. 运行示例程序

远程对象的引用通常是通过 RMI 的注册表服务以及 java.rmi.Naming 接口获得的。远程对象需要导出（注册）相应的远程引用到注册表服务，之后注册表服务就可以监听并服务于客户端对远程对象引用的请求。标准的 Sun Java SDK 提供了一个简单的 RMI 注册表服务程序，即 rmiregistry 用于监听特定的端口，等待远程对象的注册，以及客户端对这些远程对象引用的检索请求。

在运行我们的示例程序之前，首先要启动 RMI 的注册表服务。这个过程很简单，只要直接运行 rmiregistry 命令即可。缺省的情况下，该服务将监听 1099 端口。如果需要指定其它的监听端口，可以在命令行指定希望监听的端口（如果你指定了其它端口，需要修改示例程序以适应环境）。如果希望该程序在后台运行，在 Unix 上可以以如下方式运行（当然，可以缺省端口参数）：

$ rmiregistry 1099 &

在 Windows 操作系统中可以这样运行：

C:\> start rmiregistry 1099

我们的 rmitutorial.Bootstrap 类将用于启动远程对象，并将其绑定在 RMI 注册表中。运行该类后，远程对象也将进入监听状态，等待来自客户端的方法调用请求。

$ java rmitutorial.Bootstrap
    ComputeEngine exported
    ComputeEngine bound

启动远程对象后，打开另一个命令行窗口，运行客户端。命令行的第一个参数为 RMI 注册表的地址，第二个参数为期望的 π 值精度。参考下面的示例：

$ java rmitutorial.Client localhost 50
    3.14159265358979323846264338327950288419716939937511

12. 其它信息

在演示示例程序时，我们实际上是在同一主机上运行的服务器和客户端，并且无论是服务器和客户端所需的类都在相同的类路径上，可以同时被服务器和客户端所访问。这忽略了 Java RMI 的一个重要细节，即动态类装载。因为 RMI 的特性（包括其它几个特性）并不适用于 J2EE 的 RMI-IIOP 和 EJB 技术，所以，本文将不作详细介绍，请读者自行参考本文给出的参考资料。不过，为了让好奇的读者不至于过分失望，这里简单介绍一下动态类装载的基本思想。

RMI 运行时系统采用动态类装载机制来装载分布式应用所需的类。如果你可以直接访问应用所涉及的所有包括服务器端客户端在内的主机，并且可以把分布式应用所需的所有类都安装在每个主机的 CLASSPATH 中（上面的示例就是极端情况，所有的东西都在本地主机），那么你完全不必关心 RMI 类装载的细节。显然，既然是分布式应用，情况往往正相反。对于 RMI 应用，客户端需要装载客户端自身所需的类，将要调用的远程对象的远程接口类以及对应的 Stub 类；服务器端则要装载远程对象的实现类以及对应的 Skeleton 类（Java 1.2 之后不需要 Skeleton 类）。RMI 在处理远程调用涉及的远程引用，参数以及返回值时，可以将一个指定的 URL 编码到流中。交互的另一端可以通过该 URL 获得处理这些对象所需的类文件。这一点类似于 Applet 中的 CODEBASE 的概念，交互的两端通过 HTTP 服务器发布各自控制的类，允许交互的另一端动态下载这些类。以我们的示例为例，客户端不必部署 ComputeEngine_Stub 的类文件，而可以通过服务器端的 HTTP 服务器获得类文件。同样，服务器端也不需要客户端实现的定制任务 Pi 的类文件。

注意，这种动态类装载将需要交互的两端加载定制的安全管理器（参见 java.rmi.RMISecurityManager API），以及对应的策略文件。

生活源于奋斗不息 2007-11-08 23:25 发表评论

重新认识一下Java

生活源于奋斗不息 — Thu, 08 Nov 2007 14:43:00 GMT

Java是巨大的推动力量， Java已用动态的交互应用软件使Web栩栩如生。它使开发人员具有‘编写一次到处运行TM”的巨大能力。而且，借助其JavaAPI 及其编程语言上的Java虚拟机，它已产生一种分布信息的崭新模式。这种模式叫做Java企业计算，正在帮助各企业以各种不同的方法取得竞争优势。网管和控制已大大简化。软件分配基本上是免费的，而且立即可实现。电子贸易已获得。占有成本大幅度降低。信息和应用软件到处可存取。

Java建立在简单的前提基础上，即所有微处理器都应讲同一种语言——所有内部采用芯片的产品都应能一起工作，无缝而方便地 共享信息。它已经改变企业和个人同Internet大交道的方式。现在，它正在对消费类产品产生明显的影响，而且从总体上更加深刻地影响企业计算。

借助Java，您可自由自在地使用您已拥有的硬件和软件。这是因为Java是独立于平台的。它还可使您超越企业计算，使应用软件在便携式计算机、信息亭、电视、蜂窝电话和其他大量设备上运行。全世界的公司都已发现Java数不胜数的用途。所有用途可从其无可比拟的能力，即提高可靠性、安全性和简化各种不同计算产品和环境的能力中受益非浅，而且节省的时间和费用十分可观。

Java无处不在。它已拥有几百万个用户，其发展速度要快于在它以前的其他任何一种计算机产品。它可位于任何地方，而且能到处运行。Java正在迅速被用做传播信息的事实上标准，这是因为它既可给企业，也可给最终用户带来似乎数不清的好处。因此，请您仔细考察一下Java。它的优点是很容易发现的。

“Java正在进入企业、家庭和学校。它正在象Internet本身一样成为普遍存在的技术。”
Oracle 公司董事长和首席执行官
Larru Ellison

“Java正在改变我们使用Internet的方法，改变我们在公司内部存取信息的方法，甚至改变我们使用蜂窝电话的方法。它正在从根本上改变制作信息、销售信息和分配信息的方法。”
EarthWeb公司董事长和首席执行官
Jack Hidary

Java的来龙去脉

Sun公司一小组工程师聚集在一起，认真思考日常生活中的数字系统——因为烤面包机、恒温器、游戏机和其他无数设备都包含越来越复杂的CPU——以及他们如何能使这些数字系统共享信息。

创造未来的计算

制造产品的人当然全都从不同的方面来考虑其设计，视他们所使用的硬件平台、操作系统和应用软件而定。但是，如果您要使这些产品中的一些产品一起工作，那怎么办？安全性、可靠性和网络问题又这么样呢？

因此，Sun公司这些工程师把各种不同的产品折开来，然后又把它们重新组装起来，其目标是要使这些不同的设备相互交谈。他们把这些研究对象相互传来传去，并理解所有其他研究对象的特性，以便使他们能更好地一起工作。这就把制造商的问题缩减到最低程度，并使消费者能方便地进行集成。当传统的语言证明是不适用时，工程师们就打算找到某种简单的现代新语言。于是， Java应运而生。

人们很快发现，Java有可能超越工程师的想象。Java的魅力在于它提供给开发人员和用户的简便性。开发人员拥有广大的用户基础、平台独立性、降低的开发费用和始终如一的执行环境，而用户则可从生动的内容、即时软件和增大的安全性中受益。但是，Java正是从置于World Wide Web那时起才真正起飞。

Java 使全世界大为震动，因为它使Web页面栩栩如生，而且不久变得很明显，Java拥有大得多的潜力。人们之所以采纳Java，是因为它有独特的能力来编制和部署能在任何一个网络、任何一个操作系统上运行的应用软件。分配软件的时间和费用实际上已不复存在，使得各公司可把更多的资源用来开发其产品。而且，某些工业专家认为，Java可能会改变软件销售模式，从固定价格改变为按使用量收费，这样做更有利可图，而且可阻止非法盗版。

Java是一种网络计算的通用开放标准平台。这种平台可从电话一直扩展到极端重要的应用，建立在您现有的硬件和软件体系结构基础上，从而创造出一个全部联网的企业或者制造出超出的创新产品。

“由于Java具有可缩放性，因而我们可以把Java应用于小应用软件或大应用软件，把它芯片组以及大型计算机和服务器，并使它为各种不同的应用领域服务。”
三菱公司系统营销副总裁
Steve Hester

“借助Java，您可以用一种能最有效地使用的方式动态地分发和分配交互式商务应用软件一一在需要运行应用软件的地方，在需要运行应用软件的时候。”
Novell公司开发者服务部副总和总经理
Gary Mueller

Java扎下根来

在某种意义上，Java具体体现了Sun Microsystiems公司自其14年前创建以来所追述的目标。当时，它创造了“网络就是计算机”这局名言。它市基于Web的新网络计算模式的完美平台，因为它建立在各个组织现有的硬件和软件体系结构基础上，能建立一个全部联网的企业。

Java是一个完整而全面的解决方案Java远不止是一种编程语言，它是企业内外的完整计算环境，而且万事齐备，从开发工具、操作系统、服务器软件和瘦／肥客户机一直到网络管理工具、支持、培训、咨询和集成服务，一应俱全。Java使用起来非常简单，部分原因是Sun提供一种全面统一的解决方案.

主要组成部分包括：
*Java开发工具和服务：有助于简化开发Java应用软件的产品和服务

*JavaOS：一种结构紧凑的操作系统，可使Java应用软件在网络计算机和蜂窝电话等设备上运行

*Java虚拟机：一层软件，嵌入Windows、Macintosh和UNIX等计算机操作系统，或在这些操作系统上运行，从而使计算机能运行Java应用软件

*Java API：标准软件界面，位于Java应用软件和数据库检索和安全性等服务软件之间

*Java芯片：一系列为Java优化的为处理器

*Solstice WorkShop：Java启动的网络管理工具

*Java培训：一个由教师指导和基于多媒体的完整课程，教会编程员如何开发Java应用软件，包括一个用来验证熟练程度的认证计划

*JavaWorkShop支持：900号电话服务，可为Java WorkShop用户（仅限美国用户）立即提供按需支持这些产品依靠由Sun的核心技术和服务提供的基础，包括：

*Solaris操作系统
*Sikstuce企业管理系统
*WorkShop开发者工具
*SunSpectrum支持服务
*Internet咨询和集成服务
*Java和Internet教育服务
*ultra工作站和Ultra Enterprise服务器;Netra服务器

难怪大公司和日益增多的全球2000公司正在把Java计算用做系统以及其终产品的主要方面。

“您不会把您自己锁住在任何一家公司的专有技术中。开放意味着选择。而Java使您有选择余地。”

Oracle公司董事长和首席执行官
Larry Ellison

生活源于奋斗不息 2007-11-08 22:43 发表评论

在Java代码（非JSP及Action，Servlet，Controller）中获得WebRoot的物理路径

生活源于奋斗不息 — Thu, 08 Nov 2007 14:14:00 GMT

在开发Web方面的应用时, 经常需要获取服务器中当前WebRoot的物理路径

如果是Servlet , Action , Controller, 或则Filter , Listener , 拦截器等相关类时，我们只需要获得ServletContext，然后通过ServletContext.getRealPath("/")来获取当前应用在服务器上的物理地址

如果在类中取不到ServletContext时，有两种方式可以做到

1） 利用Java的类加载机制 调用 XXX.class.getClassLoader().getResource(""); 方法来获取到ClassPath , 然后处理获得WebRoot目录

这种方式只能是该class在WebRoot/WEB-INF/classes下才能生效，如果该class被打包到一个jar文件中，则该方法失效。这时就应该用下面一种方式

2） spring框架的思路, 在WEB-INF/web.xml中，创建一个webAppRootKey的param, 指定一个值（默认为webapp.root）作为键值，然后通过Listener , 或者Filter , 或者Servlet 执行String webAppRootKey = getServletContext().getRealPath("/"); 并将webAppRootKey对应的webapp.root 分别作为Key , Value写到System Properties系统属性中。之后在程序中通过System.getProperty("webapp.root")来获得WebRoot的物理路径

根据第二种的思路，我们还可以再扩展一下。不过对于在部署在一台服务器中的应用来说，已经足够了。

有更好的方法，版权所有：姜利阳★无限风光在险峰★ ，欢迎大家讨论，

生活源于奋斗不息 2007-11-08 22:14 发表评论

Aqua Data Studio 万能数据库客户端

生活源于奋斗不息 — Thu, 08 Nov 2007 13:29:00 GMT

强大的Aqua Data Studio 能够连接几乎所有的数据库，

如：标准的JDBC/ODBC数据源， Mysql， SQLServer2000/2005 ， DB2 ， Oracle ， Sybase， PostgreSQL ， Informix 系列 , ……

且功能强大，自带JRE50MB左右，去掉JRE 20MB左右，推荐使用!

截图：

官方网站：http://www.aquafold.com/

生活源于奋斗不息 2007-11-08 21:29 发表评论

Jboss下Ejb简介

生活源于奋斗不息 — Tue, 06 Nov 2007 23:42:00 GMT

JBoss是一个运行EJB的 J2EE应用服务器。它是开放源代码的项目，遵循最新的J2EE规范。从JBoss项目开始至今，它已经从一个EJB容器发展成为一个基于的J2EE的一个web 操作系统（operating system for web），它体现了J2EE规范中最新的技术，并且它还在the JavaWorld Editors' Choice 2002评选中获得“最佳Java应用服务器”大奖。无论是学习还是应用，JBoss为我们提供了一个非常优秀的平台。有关JBoss的详细信息请参阅其主页http://www.jboss.org。

刚开始使用JBoss进行EJB开发时，由于可供参考的资源不是很多，所以有一个比较困难的起步阶段。JBoss的配置和使用没有提供图形向导界面，所以开发部署EJB相对比较复杂。本文通过尽量具体的演示来对JBoss3.0下的EJB开发和部署的进行一个简单的介绍，从而使刚开始使用JBoss的用户可以很快地进入到真正的J2EE应用开发中。

由于本文主要介绍JBoss3.0中不同类型EJB的配置和部署，不对基本的EJB开发做太多的描述，所以希望读者具有J2EE和EJB的经验。想要了解有关信息请查阅参考资料1。

2．JBoss3.0中基本的ejb配置和部署
根据J2EE规范的要求，一个基本的ejb jar包使用的描述文件是ejb-jar.xml。web应用的war包使用的是web.xml。企业应用的ear包使用的是 application.xml。这些配置文件都是中性的和平台无关的。同时应用服务器可以使用一些其他的配置文件用于描述特定服务器的相关信息。在 JBoss中这样的文件有jboss.xml，jboss-web.xml等。JBoss容器中这些文件不是必须的，如果提供了那么jboss.xml和 ejb-jar.xml放在同一目录下，jboss-web.xml和web.xml放在同一目录下。关于jboss.xml和jboss- web.xml的规范请参考JBoss安装目录下docs/dtd/目录下的对应的DTD文件。

2．1 JBoss中关于EJB客户端的配置：
调用EJB的客户端可以是JSP、Servlet或客户端应用程序。如果客户端和服务器不在同一个Java VM上，那么在客户端必须提供一个jndi.properties文件告诉客户端进行有关JNDI命名服务的信息，并且把这个文件所在目录设定到环境变量 classpath中。

以下是一个jndi.properties的样例：

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099 (服务器地址和端口号)
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
通过这个文件和JBoss的一些客户端类库，就可以使用JBoss提供的EJB对象服务了。

2．2 JBoss中部署EJB：
首先介绍JBoss容器中部署各类EJB对象的两种方法。下面的演示以Session Bean为例，客户端是一个本机上的web应用。这里不对演示程序进行具体介绍。

第一种方式：

把开发好的ejb jar包和web应用的war包公共放在deploy目录下。

演示1：不需要jboss.xml文件和其他任何特殊的设置。

ejb-jar.xml:

······ ejbtest ······

客户端：web应用中对web.xml不需要添加ejb信息，不需要jboss-web.xml文件。引用ejb对象的jsp文件如下：

······ InitialContext ctx = new InitialContext(); Object objref = ctx.lookup("ejbtest"); //使用 beanHome=(zcxejb1Home)PortableRemoteObject.narrow(objref,ejbtestHome.class); ······

演示2：使用jboss.xml文件。

在缺省情况下JBoss的JNDI服务将通过ejb-jar.xml中XXX中的 XXX来使用EJB的home interface。但是如果有多个ejb对象在相同的ejb jar包中，在ejb-jar.xml中通过XXX就可能不能很好的表示某一个 ejb对象，所以一般我们希望可以提供一些附加的信息，例如采用这样的格式"[应用名]/[bean名]"来引用一个EJB对象。这时JNDI服务就可能不能正确地找到你的ejb对象，我们就需要使用jboss.xml文件，通过它实现jndi 名到ejb名的重定向。这个文件必须和ejb-jar.xml一起放到META-INFO目录下。

ejb-jar.xml:

······ ejbtest ······

jboss.xml:

ejbtest example/ejbtest

客户端：需要使用新的jndi名进行ejb定位。

······ InitialContext ctx = new InitialContext(); Object objref = ctx.lookup("example/ejbtest"); //使用 beanHome=(zcxejb1Home)PortableRemoteObject.narrow(objref,ejbtestHome.class);······

第二种方式：

把ejb 和web应用包装成一个企业应用包。部署ear时可以简单地把通过application.xml描述ejb jar包和web应用的war包，同样在web.war中不需要提供特殊的信息就可以和第一种方式一样使用ejb对象。客户端代码也不需要进行改动。这里不再举例说明。

此外我们可以进行更进一步的部署，这时需要使用到web.xml和jboss-web.xml。jboss-web.xml是JBoss提供的一个针对web应用进行配置的文件。jboss-web.xml和web.xml一起放在web应用的WEB-INF目录下。

演示1：改动web.xml文件，添加标记，不使用jboss-web.xml文件。

（注意包括内部引用和外部引用。如果是同一个单元的可以通过直接进行引用，而不用提供其他信息。）

web.xml:

······ ejb/ejbtest Session org.zcx.test.zcxejb1Home org.zcx.test.zcxejb1 ejbtest ······

客户端：由于在web.xml中引入ejb引用描述这时ejb定位发生了变化：

······ InitialContext ctx = new InitialContext(); Object objref = ctx.lookup("java:comp/env/ ejb/ejbtest "); //使用java:comp/env命名空间 beanHome=(zcxejb1Home)PortableRemoteObject.narrow(objref,ejbtestHome.class);······

演示2：联合使用web.xml和jboss-web.xml

web.xml

······ejb/ejbtest Session org.zcx.test.zcxejb1Home org.zcx.test.zcxejb1······

jboss-web.xml

ejb/ejbtest example/ejbtest

客户端：

nitialContext ctx = new InitialContext(); Object objref = ctx.lookup("java:comp/env/ ejb/ejbtest "); beanHome=(zcxejb1Home)PortableRemoteObject.narrow(objref,ejbtestHome.class);

以上的所有演示说明了ejb-jar.xml、jboss.xml、web.xml、jboss-web.xml之间的基本关系和它们的使用方式。它们是部署各类ejb对象的关键文件。接下来介绍针对不同类型的ejb对象所需要的特殊配置。

3．JBoss3.0中对于CMP2.0 Entity Bean的有关配置
JBoss3.0 中JBossCMP引擎实现了EJB2.0 CMP2.0规范。JBoss3.0以前的版本CMP的引擎是Jaws，它通过standardjaws.xml和jaws.xml进行有关的配置。在新的JBossCMP引擎中Jboss3.0通过standardjbosscmp-jdbc.xml和josscmp-jdbc.xml来配置 Entity Bean。JBoss3.0首先处理standardjbosscmp-jdbc.xml然后根据ejb jar中是否提供jbosscmp-jdbc.xml来做进一步处理。通过standardjbosscmp-jdbc.xml和jbosscmp- jdbc.xml可以为entity bean的部署提供如下的功能有：

l 指定所使用的数据源和对应的类型映射

l 指定一些引擎关心的属性

l 指定引擎如何创建和管理数据库表的原则

l 描述finder和ejbSelect方法

l 指定属性和字段的类型映射

这里主要根据standardjbosscmp-jdbc.xml/jbosscmp-jdbc.xml介绍CMP2.0的配置方法。JBoss中原有的 Jaws引擎的配置方法和新的JBossCMP的配置方法类似。这些文件的具体的信息可以参考JBoss安装路径下\docs\dtd中对应的DTD文件。

3．1增加新的数据源
JBoss自带的数据库是Hypersonic数据库，我们可以增加一些新的数据源。具体的步骤很简单，参照Jboss安装目录下\docs\examples\jca中的*-service.xml文件可以增加找到对应类型的数据库配置样本文件。以mysql-service.xml文件为例，它可以配置一个MySQL数据库作为Entity Bean的数据源。以下演示创建一个名为MySQLDS的MySQL数据源。

图一是配置好的mysql-service.xml文件的一段代码样本，通过属性设置可以定制数据源的名称和有关连接的其他属性。注意该文件中所有name属性必须保持一致。

图一 mysql-servic.xml的样本代码

在配置好这个文件后，把它部署在JBoss的deploy目录下，把对应的jdbc驱动也放在lib目录下。重新启动Jboss就会加载这个新的数据源。

3．2 Entity Bean 对数据源的使用
第一种方式：

直接改动standardjbosscmp-jdbc.xml。把原有的数据源java:/DefautlDS屏蔽掉使用新的数据源java: /MySQLDS。（Java前缀是必须的。）不需在其他地方作改动。JBoss会实现新的数据源做为缺省的数据源。图二是一个配置好的文件片断。

图二 standardjbosscmp-jdbc.xml的样本代码

第二种方式：

由于有可能不同的Entity Bean使用不同的数据源，而不是都使用同样的缺省配置，所以必须为单独的Entity Bean提供定制数据源信息的支持。这时不需要改动standardjbosscmp-jdbc.xml文件，可以通过在Entity Bean的jar包中META-INFO目录下添加新的部署文件jbosscmp-jdbc.xml来完成。通过这个文件可以描述特定的Entity Bean的关于数据源的配置信息。图三是一个配置好的文件片断。

图三 jbosscmp-jdbc.xml的样本代码

4．JBoss3.0中对于Message Driven Bean的配置
在JBoss 中开发MDB需要使用JMS功能。JMS是Sun公司开发的面向消息的中间件API。它的主要目的是创造一种统一的面向消息编程的JavaAPI，从而避免使用提供商特定的API。现在有几种不同的JMS系统可供使用。JBoss3.0中提供的是JBossMQ。

4．1 JBoss3.0中配置JMS服务
在JBoss3.0 中与JMS服务相关的配置文件包括两个文件：jbossMQ-service.xml和jbossMQ-destinations- service.xml。jbossMQ-service.xml配置了jbossMQ服务中的核心对象信息。一般我们不需要处理这个配置文件。 jbossMQ-destinations-service.xml用于定义具体应用所需的目的地信息。通过编辑它我们可以创建新的Topic和 Queue用于具体的JMS应用的目的地。在JBoss中创建应用特定的Topic和Queues的步骤比较简单，参照jbossMQ- destinations-service.xml文件格式在该文件中添加自己应用程序所需的Topic名为myTestAppTopic和Queue名为myTestAppQueue。如图四所示。

图四 jbossMQ-destinations-service.xml的样本代码

4．2 JBoss3.0中EJB使用JMS服务的配置
在开发MDB 时要在部署文件中指定所使用的JMS服务中的目的地信息。JBoss中通过ejb-jar.xml和jboss.xml共同说明。在jboss.xml中通过标记描述所使用的目的地信息。

Ejb-jar.xml

HelloTopicMDB org.zcx.test.HelloMDB Container javax.jms.Topic NonDurable

jboss.xml

HelloTopicMDB Standard Message Driven Bean topic/myAppTestTopic

客户端：

······Context context = new InitialContext(); // Get the connection factory // Create the connection // Create the session······// Look up the destination topic = (Topic)context.lookup("topic/myTestAppTopic"); // Create a publisher// Publish the message······

5．JBoss3.0中EJB使用JavaMail服务的配置。
由于JBoss提供了JavaMail服务的实现，所以在JBoss中使用JavaMail是非常方便地。它所需要配置的是mail.service文件。这个文件非常地简单不用多介绍。按照mail.service文件的的注释就可以顺利地完成配置。

图五是使用JavaMail服务的一个sessionBean的代码片断

图五使用javamail的样本代码

以上通过例子简单的介绍了JBoss3.0中Session Bean、Entity Bean 和Message Drive Bean 最基本的配置和部署方法，通过这些介绍现在已经可以在JBoss中进行基本的EJB应用的开发了。本文中对于EJB应用中比较复杂的一些配置像权限设置、资源管理和CMP2.0中的众多配置等都没有涉及到，希望大家可以在不断的实践和交流中更好地掌握JBoss的使用和配置。

参考资料：
1． http://java.sun.com/j2ee/ J2EE 和 EJB

2． http://www.jboss.org/ JBoss项目主页和在线手册

3．《JBoss3.0 Quick Start》 the JBoss Group

4．《Mastering Enterprise Java Beans, 2nd Edition》 Ed Roman, Scott Ambler, and Tyler Jewel.

生活源于奋斗不息 2007-11-07 07:42 发表评论

JBoss简介

生活源于奋斗不息 — Tue, 06 Nov 2007 14:34:00 GMT

解释1:

　Jboss是 web服务器的一种，主要做ejb容器，和tomcat集成就可以jsp,servlet,ejb通吃了
　Jboss有两种版本，一种是独立的，一种是和tomcat集成的，当然都是免费的啦
　EJB(enterprise javabean)，他不是javabean简单的升级，而是一些提供分布式访问的类
　包括实体bean,会话bean,消息驱动bean
---------------------------------------------------------------
JBoss简介
　JBoss是一个运行EJB的J2EE应用服务器。它是开放源代码的项目，遵循最新的J2EE规范。从JBoss项目开始至今，它已经从一个EJB容器发展成为一个基于的J2EE的一个web 操作系统（operating system for web），它体现了J2EE规范中最新的技术，并且它还在the JavaWorld Editors' Choice 2002评选中获得“最佳Java应用服务器”大奖。无论是学习还是应用，JBoss为我们提供了一个非常优秀的平台。有关JBoss的详细信息请参阅其主页http://www.jboss.org。

　刚开始使用JBoss进行EJB开发时，由于可供参考的资源不是很多，所以有一个比较困难的起步阶段。JBoss的配置和使用没有提供图形向导界面，所以开发部署EJB相对比较复杂。本文通过尽量具体的演示来对JBoss3.0下的EJB开发和部署的进行一个简单的介绍，从而使刚开始使用JBoss的用户可以很快地进入到真正的J2EE应用开发中。

　Enterprise JavaBean (EJB)规范定义了开发和部署基于事务性、分布式对象应用程序的服务器端软件组件的体系结构。企业组织可以构建它们自己的组件，或从第三方供应商购买组件。这些服务器端组件称作 Enterprise Bean，它们是 Enterprise JavaBean 容器中驻留的分布式对象，为分布在网络中的客户机提供远程服务。

解释2:

　JBoss是一个开源的符合J2EE规范的应用服务器，作为J2EE规范的补充，Jboss中引入了AOP框架，为普通Java类提供了J2EE服务，而无需遵循EJB规范。Jboss通过类载入时，使用Javassist对字节码操作实现动态AOP框架，Javassist是一个开源的编辑字节码的类库。

　Jboss中参考，切入点与方面也由普通Java对象实现，并使用XML文件配置。Jboss的连接点模型与AspectJ略有不同，提供了一系列预定义的切入点，包括类匹配，方法调用，构造器调用，域访问，特定的调用与被调用关系。通过这些切入点的逻辑运算，可以实现更为复杂的切入点。方面为Java类，参考是其中的一个方法，方面中不含切入点，方面主要为各种拦截器（Interceptor），拦截器即为只含一个参考的方面，单一连接点上可由多个拦截器形成拦截器链，拦截器执行额外的操作。对方法的拦截由Advisor类管理，在连接点依次调用拦截器，并最终调用被逻辑的方法。而关于切入点，参考已及方面的信息由AspectManager管理。此外，Jboss提供对元数据的支持，用于为类，方法，构造器以及域添加额外的属性，并可在运行期访问。

　为实现拦截，Jboss需要修改类的字节码，大致过程如下。

　XML配置文件中关于切入点，拦截器，元数据以及混合类的信息在应用程序部署时被读入、解析，并生成相应的对象，这些信息与实例化的对象由AspectManager管理。在需要混入方面代码的类载入时，AspectManager将创建Advisor类，将方面相关信息传递给它，并对类的字节码进行修改，之后将修改过的字节码交给类载入器完成类的装载。字节码的修改主要是对被载入的类添加一系列方法用于代理那些匹配连接点的方法调用，构造器调用，域访问以及方法导入，转为对Advisor类相应方法的调用。类中各方法将重命名，保留原方法体，并添加一个与原方法同名的方法，在这个方法中调用那些代理方法，用来将调用代理给Advisor类，或调用重命名的原方法。对于域访问，分别添加两个方法，对应于读与写操作，将域访问代理至Advisor类，在访问这个域的类中，则需将对域的访问转换为对上述方法的调用。对于构造器调用，则添加一个方法，将调用代理至Advisor类，并对构造对象的类的构造代码作相应转换。对于导入，被导入的类中将添加一个混合类实现的引用，并添加混合类接口中的方法，将对混合类方法的调用代理至Advisor类，并最终调用混合类的实现。相关类载入后，初始化Advisor类，填入拦截器链，以完成整个处理过程。

一、JBoss简介

近年来，在J2EE应用服务器领域，JBoss是发展最为迅速的应用服务器。JBoss是免费的，开放源代码J2EE的实现，它通过LGPL许可证进行发布,这使得JBoss广为流行。Boss是一个运行EJB的J2EE应用服务器，例如：数据库访问JDBC、交易(JTA/JTS)、消息机制(JTS)、命名机制(JNDI)和管理支持(JMX)。它是开放源代码的项目，遵循最新的J2EE规范。目前的JBoss发布版2.2.4实现了EJB 1.1和部分EJB 2.0的标准、JMS 1.0.1、Servlet 2.2、JSP 1.1、JMX 1.0、JNDI 1.0、JDBC 1.2和2.0扩充(支持连接池 (Connection Polling))、JavaMail/JAF、JTA 1.0和JAAS1.0标准，JBoss是100%纯Java实现能运行于任何平台。

从JBoss项目开始至今，它已经从一个EJB容器发展成为一个基于的J2EE的一个web 操作系统（operating system for web），它体现了J2EE规范中最新的技术，并且它还在the JavaWorld Editors' Choice 2002评选中获得“最佳Java应用服务器”大奖。无论是学习还是应用，JBoss为我们提供了一个非常优秀的平台。

另外，JBoss应用服务器还具有许多优秀的特质:

它将具有革命性的JMX微内核服务作为其总线结构；
它本身就是面向服务的架构（Service-Oriented Architecture，SOA）；
它还具有统一的类装载器，从而能够实现应用的热部署和热卸载能力。
因此，它是高度模块化的和松耦合的。JBoss用户的积极反馈告诉我们，JBoss应用服务器是健壮的、高质量的，而且还具有良好的性能。

二、JBoss的发展

为满足企业级市场日益增长的需求，JBoss公司从2003年开始就推出了24*7、专业级产品支持服务。同时，为拓展JBoss的企业级市场， JBoss公司还签订了许多渠道合作伙伴。在2004年6月，JBoss公司宣布，JBoss应用服务器通过了Sun公司的J2EE认证。这是JBoss应用服务器发展史上至今为止最重要的里程碑。与此同时，JBoss一直在紧跟最新的J2EE规范，而且在某些技术领域引领J2EE规范的开发。因此，无论在商业领域，还是在开源社区， JBoss成为了第一个通过J2EE 1.4认证的主流应用服务器。现在，JBoss应用服务器已经真正发展成具有企业强度（即，支持关键级任务的应用）的应用服务器。

近年来，Hibernate已经成为了事实上的持久化引擎。JBoss公司致力于将自身发展成为开源项目的社区，最新版的JBoss应用服务器已经将Hibernate集成为JMXMBean服务。这使得用户能够在应用服务器环境中直接使用Hibernate，而不管它是否处于J2EE上下文中。在最新版的JBoss应用服务器中，用户能够直接通过JMXMBean服务访问到JBossCache提供的服务。下一代的JBoss应用服务器（暂定名为，JBoss5.0）将提供大量的新功能。除了支持最新的EJB 3.0规范外，新版的JBoss AOP将同它正式发布。同时，JBoss开发团队还计划开发新的微内核层，即独立于JMX，使得它能够独立使用。

三、JBoss的服务器架构概述

JBoss的构架和其他J2EE应用服务器的构架有着巨大的不同。JBoss的模块架构是建立在JMX底层上的，下图展现了JBoss主要组件和JMX的联系。

     JMX - 层次
     JMX是一个可复用框架，它为远程(Remote)和本地(Local)管理工具扩展了应用。它的架构是层式架构。他们是实现层(instrumentation layer)、代理层(agent layer)和发布层(distribution layer)。其中，发布层还在等待未来的标准化。简要的表述是，用户使用管理Bean，MBean来提供获得相应资源的实现方法。实现层实现相关的特性资源并将它发布于JMX相关应用中，它的代理层控制和发布相应的注册在MBeanServer代理上的管理资源。

     JBoss主要模块
     主要的JBoss模块是在MeanServer上的可管理MBean。

1.JBoss EJB容器是JBoss服务器的核心实现。它有两个特性，第一是在运行期产生EJB 对象的Stub和Skeleton类，第二是支持热部署。

2.JBossNS是JBoss命名服务用来定位对象和资源。它实现了JNDI J2EE规范.

3.JBossTX 是由JTA/JTS支持的交易管理控制.

4.部署服务支持EJB(jar)、Web应用文档(war)和企业级应用文档(ears)的部署。它会时刻关心J2EE应用的URL情况，一旦它们被改变或出现的时候将自动部署。

5.JBossMQ使Java 消息规范(JMS)的实现。

6.JBossSX支持基于JAAS的或不支持JAAS机制的安全实现。

7.JBossCX实现了部分JCA的功能。JCA制订了J2EE应用组件如何访问基于连接的资源。

8.Web服务器支持Web容器和Servlet引擎。JBoss 2.4.x版本支持Tomcat 4.0.1，Tomcat 3.23和Jetty 3.x服务.

四、JBoss架构设计中的两个重要的特性

第一是使用JMX作为一个软件总线垂直的贯穿其所有的服务，通过将新的服务组件遵循JMX规范挂接上"总线"，使得系统扩展现有的服务变得容易。可插入式框架被广泛的运用于服务的实现。开发者可以选择他们需要的服务并编写他们所需要的相应实现，通过定义在部署描述文件中，让JBoss服务器知道。

第二是容器被设计成为动态代理机制，这样使容器的实现变得简单和使开发者避免费劲的将jar文件进行预编译以获得stub和skeleton代码。但是这样做潜在的问题是性能和可测性，因为我们知道java反射机制会引起性能的损失。JBoss中存在着相应的优化方案并且在将来的研究中我们会论述该优化方法在什么时候工作并且是如何工作的

摘自：厚积而薄发

生活源于奋斗不息 2007-11-06 22:34 发表评论

Apache2.2 配置负载均衡实例说明

生活源于奋斗不息 — Fri, 02 Nov 2007 15:00:00 GMT

在Apache2.2 版本中，自带了均衡负载模块，只需配置一下即可

在%ApacheHome%conf/httpd.conf 文件里面

############################### 修改过的apache动态加载模块################

# AddDefaultCharset gb2312

LoadModule proxy_module modules/mod_proxy.so

LoadModule proxy_ajp_module modules/mod_proxy_ajp.so

LoadModule proxy_balancer_module modules/mod_proxy_balancer.so

LoadModule proxy_http_module modules/mod_proxy_http.so

NameVirtualHost *:80

#########################如果没有匹配，则默认系统选择第一个虚拟主机#####################################

ProxyRequests Off

ServerName site120

# ProxyPass / balancer://cluster1/

# ProxyPass / balancer://cluster1 stickysession=jsessionid nofailover=On

# balancer://cluster1/>

# BalancerMember ajp://site120:8009 route=Tomcat1

# BalancerMember ajp://site120:20009 route=Tomcat2

ProxyRequests Off

ServerName site120

ProxyPass / balancer://cluster1/

# ProxyPass / balancer://cluster1 stickysession=jsessionid nofailover=On

balancer://cluster1/>

BalancerMember ajp://site120:8009 route=Tomcat1

# BalancerMember ajp://site120:20009 route=Tomcat2

生活源于奋斗不息 2007-11-02 23:00 发表评论

MyEclipse 6.0.1 6.0GA 6.0M1 5.5GA 5.1.1GA 注册码

生活源于奋斗不息 — Sun, 28 Oct 2007 02:03:00 GMT

MyEclipse 6.0.1 注册码

Subscriber: administrator
Subscription Code: nLR7ZL-655342-54657656405281154

注册后：

Subscriber: administrator
Product ID: E2MY (MyEclipse Standard Subscription)
License version: 1.0
Full Maintenance Included
Subscription expiration date (YYYYMMDD): 20091021
Number of licenses: 897

下面把 6.0GA / M1 和 5.5GA 版本的“注册信息”“注册码”“破解”给大家：

Subscriber:
Subscriber Code: jLR8ZC-655355-5450765457039125
或者
Subscriber:
Subscriber Code: jLR7ZL-655355-5450755330522962

适用于早期的 5.5 M2 版本的：

Subscriber:
Subscriber Code: jLR8ZC-956-55-5467865833584547

适用于早期的 5.1.1 GA 和 5.5 M1 版本的：

Subscriber:
Subscriber Code: jLR8ZC-444-55-4467865481680090

注册成功后会发现：

Subscriber:
Product ID: E3MP (MyEclipse Professional Subscription)
License version: x.x
Full Maintenance Included
Subscription expiration date (YYYYMMDD): 20090520
Number of licenses: 800

生活源于奋斗不息 2007-10-28 10:03 发表评论

WebWork + Spring + Hibernate 快速上手教程千万不要错过哦

生活源于奋斗不息 — Mon, 27 Aug 2007 06:11:00 GMT

对于想学WebWork , Spring , Hibernate 的同学，

这是一份非常不错的速成基础入门教程，言简意赅，容易上手。

如果有要的留下Email！

在看到的第一时间内回复。

=============================

由于工作较忙，请大家以后从该地址下载教材，谢谢各位配合

已将该教材发布到csdn上，地址：
http://download.csdn.net/source/1007883

欢迎大家共同讨论，姜利阳★无限风光在险峰★

=============================

生活源于奋斗不息 2007-08-27 14:11 发表评论

AntLr

生活源于奋斗不息 — Thu, 01 Feb 2007 17:01:00 GMT

一个非常不错的开源语言解析工具, Hibernate 就是利用此对HQL语言进行分析的
有机会熟悉一下. 其里面的ATS(语法抽象树) 用来描述一种业务规则. 利用它我们甚至可以开始出自己的编程语言.

生活源于奋斗不息 2007-02-02 01:01 发表评论

用Jakarta Commons组件重写Object 对象的equals , hashCode方法

生活源于奋斗不息 — Thu, 01 Feb 2007 16:27:00 GMT

对于一些编程当中的机制,有的是需要我们重写equals,hashCode方法的.
比如:
   1) Map类型中的Key, 首先它必须是对象, 其次它得要重构方法equals , hashCode , 以此来查找键,并确定两键值是否相同

   2) 在Set 集合中, set容器里面的一个值(这里面判断两个对象是否是相同的值也是依靠equals与hashCode的)只能存放一次, 那它也要求重构equals , hashCode方法

   3) 在Hibernate的映射文件里面, 其中的ID对象如果是复合主键,则也同样要求重构equlas, hashCode方法
...

重写这两个方法一般都比较烦琐, 下面我们可以利用apache 的commons组件来帮助我们完成

-----------------------------------------------以下转自其它网站-----------------------------------------------------
Jakarta-Commons的org.apache.commons.lang.builder包中，完全由一些类组成，他们专门设计为协助实现，继承了java.lang.Object的类的一些基本方法。比如：equals() , hashCode() , and toString()。他们被称为建造器，是因为他们提供了一组简便易用的API为了达到实现这些方法的效果。

The EqualsBuilder

首先讨论的是EqualsBuilder。这个类，可能你已经猜到了，是帮助重写object 的equals方法的。

让我们先写一个class：

1 public class MyClass
2 {
3    private String field1;
4    private String field2;
5    private double [] field3;
6 }
7
8

下面我们将使用EqualsBuilder去处理两个实现了相同类的object是否相同的方法。

1 public boolean equals(Object o) {
2     if ( ! (o instanceof MyClass) ) {
3      return false ;
4    }
5   MyClass rhs = (MyClass) o;
6    return new EqualsBuilder()
7                  .appendSuper( super .equals(o))
8                  .append(field1, rhs.field1)
9                  .append(field2, rhs.field2)
10                  .append(field3, rhs.field3)
11                  .isEquals();
12   }

这个特别的建造器并没有彻底的从这种标准的实现中节省时间，除了自动的处理了数组。

另外，你也可以选择使用反射机制的静态方法：

1 public boolean equals(Object o) {
2 return EqualsBuilder.reflectionEquals( this , o);
3 }
4

这种方法实现equals算法，有两个缺点。

1、因为使用了反射机制，所以速度可能会比较慢。

2、在安全-受限的JVMs中，在使用中的字段修改将会导致这个方法失效。

不过，对于快速开发，这是个很好的工具。

The HashCodeBuilder

是一个节省时间并能很好地避免错误的建造器。下面将实现一个hashcode算法。

1 public int hashCode() {
2 return new HashCodeBuilder( 61 , 15 )
3 .appendSuper( super .hashCode())
4 .append(field1)
5 .append(field2)
6 .append(field3)
7 .toHashCode();
8 }

看起来很象equals建造器。注意有两个不同的数字在构造函数中，不能是零，而且是奇数。这些数帮助避免冲突，在各个object的hashcode值间。

另外，也可以使用反射机制的方法。

1
2 public int hashCode() {
3 return HashCodeBuilder.reflectionHashCode( this );
4 }

生活源于奋斗不息 2007-02-02 00:27 发表评论

利用Ecipse生成Javadoc乱码(编码问题)终极解决方法

生活源于奋斗不息 — Thu, 01 Feb 2007 13:21:00 GMT

利用Ecipse生成Javadoc乱码(编码问题)终极解决方法

这里面有两个指定编码问题的参数
1) -encoding charsetName
2) -charset charsetName

第一个参数表示javadoc 程序读取java源文件时候应该采用什么编码
第二个参数表示javadoc 程序写html文件时采用的编码形式,并会在HTML中加入如下标签

1 DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
2
3 < HTML >
4 < HEAD >
5
6
7 < META http-equiv ="Content-Type" content ="text/html; charset=utf-8" >

如果文件格式为UTF8格式的,可以采用如下形式进行Generate Javadoc:

javadoc -encoding UTF-8 -charset UTF-8

生活源于奋斗不息 2007-02-01 21:21 发表评论

如何明确，完整地描述一个系统 , 欢迎大家一起讨论

生活源于奋斗不息 — Tue, 30 Jan 2007 16:54:00 GMT

如题，应该从哪些角度去看待这个系统呢？

１，从系统功能角度去看，应该有哪几大功能，或者子系统，通过功能结构图可以描述
２，数据流动过程来看，每一个功能，他都应该有一个流程图，数据从哪开始，流经过哪，怎么处理，最终流到哪里....等等.
３，ＥＲ图，就是在数据库设计中的实体Entity 关系Relative图，与ＵＭＬ有点相像

在黑盒测试时，应该了解这些，　先从功能入手，细化每一个功能，最终的每个功能都应该有相应的操作流程.　之后遍历这些流程.　这样，思路就应该比较清晰.
功能是横向，流程是纵向.　这有点像时序图，几个功能一排，某个功能的具体操作流程，可能会与其它功能打交道.　其它功能处理完之后，又回到原功能流程中的某一步继续执行......

这就是面向过程开发　－－－－－＞　ＯＰＰ
这个方法，虽然可以设计并实现出一个系统，但随着系统庞大，复杂，这样处理起来将会越来越复杂.
OO的出现将大大降低这个复杂度，提高灵活度，安全性
尤其是封装 , 多态 , 通过面向接口编程，也大大降低偶合度.
之后利用现成的开源框架，分层处理,如:

针对Web应用来说有:
Ｗeb层/View层 -----(将请求封装为对象)--> 控制层 -----> 权限拦截层 ----> 业务层 -----> 持久层 ---------(ORMapping)----> 数据库
每层各尽其职, 不涉及跨层操作, 只认接口,下层向上层提供操作接口,
就像ISO/OSI七层模型一样
应用层 --> 表示层 ---> 会话层 ---> 传输层 ---> 网络层 ---> 数据链路层 ---> 物理层 ,
底层向上层接口服务接口

不过通过比较,发现, 这个分层图对应于OPP当中的数据流程图 , 也可以说定了一个标准,一个框架, 具体的业务逻辑,可以在业务层中有不同的操作

但从中可以发现, 不论是面向对象 , 还是面向过程 , 总体的设计应该还是 功能是横向，流程是纵向

起了个头,这里面所讲得都是我的理解过程, 并非一定正确, 欢迎大家一块讨论.

生活源于奋斗不息 2007-01-31 00:54 发表评论

Hibernate对视图的映射

生活源于奋斗不息 — Tue, 30 Jan 2007 15:54:00 GMT

在Hibernate当中，视图与表是公平对待的, 所以在 Hibernate 视图映射 时，Hibernate把视图当成是表来处理，但处理主键（不能重复）时，有两种方法
１，可以通过组合键来设置ＩＤ
２，可以将基本一个表的主键作为视图的ＩＤ

目前，我只想到这两种.　如果有更好的，大家可以共享出来一起讨论

生活源于奋斗不息 2007-01-30 23:54 发表评论

谈对象之间的关系

生活源于奋斗不息 — Tue, 30 Jan 2007 14:02:00 GMT

对象与对象之间的关系有以下几种关系
   1)继承
         1) 一种父子关系
         2) 有共同特点 , 或者有普通和特殊关系
         3) 如: 一种进化关系, 如: 有机物 --> 蛋白质 --> 微生物 --> 动物 --> 人

   2) 依赖
         1) 就是一个对象调用被依赖对象中的某些方法而得以完成这个对象的一些职责
         2) 这是一种比较松散的关系 , 并且这是短期的. 我们的过程与对象往往依赖于我们的实体域对象
         3) 如: WebWork中的Action 依赖于业务层中的方法 ,  业务层中的Service或者Bussiness依赖于持久层(DAO)中的方法等等 ( 如果碰到这种关系 , 通常用面向接口编程的方法来处理, 使其具有更好的扩展性, 维护性)

   3) 关联

         1) 指一个类指到另一个类中的属性.

         2) 而且是长期的

         3) 关联关系又可以分为以下几种
               0) 一般关联: 只要一个对象联系到另外一个对象就形成了关联关系

               1) 聚合关系 , 较强于一般关联 , 有整体与局部之间的关系,并且没有了整体,局部也可单独存在,如小组与小组里面的成员, 小组不存在, 成员也可单独存在 , 也可加入其它小组, 又如: 一个分子由多个原子按一定的结构,排列组织而成, 在化学变化时(针对原子的操作),按这个角度去看 , 原子之间会脱离开,另外合成另一种物质. 其组成关系可以共享

               2) 组合关系 , 也叫合成关系 , 是一种更强的整合与局部的关系 , 其关系更加紧密 ., 如: 一个分子由多个原子按一定的结构组织而成, 在物理变化中(针对分子的操作), 按这个角度去看 , 分子间发生变化 , 变成另一种状态, 但分子结构不变, 还是这种物质. 其组成关系多原子组成结构不可以共享.

----------------------------------------------------------------------------------------------------------------

生活源于奋斗不息 2007-01-30 22:02 发表评论

在Javascript或者Java当中判断润年闰年【最最简单的】方法

生活源于奋斗不息 — Mon, 15 Jan 2007 14:05:00 GMT

Javascript判断闰年(润年)函数isSmoothYear()，如下：

1<script language="javascript">
2    var isSmoothYear = function(year)
3    {
4        return (new Date(year , 2 , 0).getDate() == 29);
5    }
6    alert("2004年是润年吗? \t" + isSmoothYear(2004));
7    alert("2005年是润年吗? \t" + isSmoothYear(2005));
8    alert("2006年是润年吗? \t" + isSmoothYear(2006));
9    alert("2007年是润年吗? \t" + isSmoothYear(2007));
10    alert("2008年是润年吗? \t" + isSmoothYear(2008));
11script>

Java代码判断闰年(润年)同样道理：

1import java.util.*;
2
3class TestDate
4{
5    public static void main(String[] args)
6    {
7        Date date = new Date(2004 , 2 , 0);
8        System.out.println(date.getDate());
9    }
10}
11

生活源于奋斗不息 2007-01-15 22:05 发表评论

开源站点收集

生活源于奋斗不息 — Thu, 11 Jan 2007 15:37:00 GMT

1，http://www.open-open.com
2, http://sourceForge.net 全国最大的开源网站
3, http://java-source.net/ 　Java open Source
4, http://www.apache.org/ 这个不用说了吧
5, http://community.java.net/projects/ 又是一个Java open Source 社区
6, http://www.google.com/codesearch?hl=en 　更强悍，提供搜索开源代码功能

生活源于奋斗不息 2007-01-11 23:37 发表评论

深入了解synchronized及对象锁

生活源于奋斗不息 — Mon, 08 Jan 2007 16:25:00 GMT

1 , Synchronized 锁定的是对象而非函数或代码。
2 , 每个Object只有一把锁(Lock)与之关联，当进行到Synchronized语句或函数的时候，这把锁就会被当前的线程（thread）拿走，其他的（thread）再去访问的时候拿不到锁就被暂停了
3, 只有当Synchronized的是同一个对象的才是线程安全的（thread-safe）
如:
   1) public Synchronized void method1 : 锁住的是该对象,类的其中一个实例 , 当该对象(仅仅是这一个对象)在不同线程中执行这个同步方法时,线程之间会形成互斥.达到同步效果,但如果不同线程同时对该类的不同对象执行这个同步方法时,则线程之间不会形成互斥,因为他们拥有的是不同的锁.
   2) Synchronized(this){ //TODO } 同一

   3) public Synchronizedstatic void method3 : 锁住的是该类,当所有该类的对象(多个对象)在不同线程中调用这个static 同步方法时,线程之间会形成互斥,达到同步效果 , 但如果多个线程同时调用method1 , method3,则不会引互斥,具体讲看最后讲解.
   4) Synchronized(Test.class){ //TODo} 同三

   5) synchronized(o) {} 这里面的o可以是一个任何Object对象或数组,并不一定是它本身对象或者类,谁拥有o这个锁,谁就能够操作该块程序代码.

这里面1) 与2) 是线程安全的,但1)与3) , 2)与3) 他们所拥有的锁不一样,故不是同步的,不是线程安全的.

最后, synchronized 所同步的代码应该尽量少.如果没有必要同步的就不要列为其中
    联想到数据库的并发控制
假如有如下操作
   1) 从数据库中读取数据
   2) 修改数据
   3) 提交数据
解决方案一
1) 读取数据
synchronized(XXX)
{
   2)修改数据
   3) 提交数据
}

解决方案二
synchronized(XXX)
{
   1) 读取数据
   2)修改数据
   3) 提交数据
}

解决方案三
synchronized(XXX)
{
   3) 提交数据
}

这里面到底用哪一种方案视具体情况而定, 要注意的是synchronized(同步)的代价,开销是很大的.

生活源于奋斗不息 2007-01-09 00:25 发表评论

Java 多线程程序设计要点(synchronized..)

生活源于奋斗不息 — Mon, 08 Jan 2007 15:48:00 GMT

也是一遍不错的文章
-----------------------------------------------------------------------------------------------------
----选择自 duoshanx 的 Blog

1.多线程中有主内存和工作内存之分，在JVM中，有一个主内存，专门负责所有线程共享数据；而每个线程都有他自己私有的工作内存，主内存和工作内存分贝在JVM的stack区和heap区。

2.线程的状态有'Ready', 'Running', 'Sleeping', 'Blocked', 和 'Waiting'几个状态，
'Ready' 表示线程正在等待CPU分配允许运行的时间。

3.线程运行次序并不是按照我们创建他们时的顺序来运行的，CPU处理线程的顺序是不确定的，如果需要确定，那么必须手工介入，使用setPriority()方法设置优先级。

4.我们无从知道一个线程什么时候运行，两个或多个线程在访问同一个资源时，需要synchronized

5. 每个线程会注册自己，实际某处存在着对它的引用，因此，垃圾回收机制对它就“束手无策”了。

6. Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。

7. 一个对象中的所有synchronized方法都共享一把锁，这把锁能够防止多个方法对通用内存同时进行的写操作。synchronized static方法可在一个类范围内被相互间锁定起来。

8. 对于访问某个关键共享资源的所有方法，都必须把它们设为synchronized，否则就不能正常工作。

9. 假设已知一个方法不会造成冲突，最明智的方法是不要使用synchronized，能提高些性能。

10. 如果一个\"同步"方法修改了一个变量，而我们的方法要用到这个变量(可能是只读),最好将自己的这个方法也设为 synchronized。

11. synchronized不能继承，父类的方法是synchronized，那么其子类重载方法中就不会继承“同步”。

12. 线程堵塞Blocked有几个原因造成：

(1)线程在等候一些IO操作
(2)线程试图调用另外一个对象的“同步”方法，但那个对象处于锁定状态，暂时无法使用。

13.原子型操作(atomic), 对原始型变量(primitive)的操作是原子型的atomic. 意味着这些操作是线程安全的，但是大部分情况下，我们并不能正确使用，来看看 i = i + 1 , i是int型，属于原始型变量：

(1)从主内存中读取i值到本地内存.
(2)将值从本地内存装载到线程工作拷贝中.
(3)装载变量1.
(4)将i 加 1.
(5)将结果给变量i.
(6)将i保存到线程本地工作拷贝中.
(7)写回主内存.

注意原子型操作只限于第1步到第2步的读取以及第6到第7步的写, i的值还是可能被同时执行i=i+1的多线程中断打扰(在第4步)。

double 和long 变量是非原子型的(non-atomic)。数组是object 非原子型。

14. 由于13条的原因，我们解决办法是：

class xxx extends Thread{
//i会被经常修改
private int i;

public synchronized int read(){ return i;}

public synchronized void update(){ i = i + 1;}

..........

}

15. Volatile变量， volatile变量表示保证它必须是与主内存保持一致，它实际是"变量的同步", 也就是说对于volatile变量的操作是原子型的，如用在long 或 double变量前。

16. 使用yield()会自动放弃CPU，有时比sleep更能提升性能。

17. sleep()和wait()的区别是：wait()方法被调用时会解除锁定，但是我们能使用它的地方只是在一个同步的方法或代码块内。

18. 通过制造缩小同步范围，尽可能的实现代码块同步，wait(毫秒数)可在指定的毫秒数可退出wait；对于wait()需要被notisfy()或notifyAll()踢醒。

19. 构造两个线程之间实时通信的方法分几步：
(1). 创建一个PipedWriter和一个PipedReader和它们之间的管道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要发送信息的线程开始之前，将外部的PipedWriter导向给其内部的Writer实例out
(3). 在需要接受信息的线程开始之前，将外部的PipedReader导向给其内部的Reader实例in
(4). 这样放入out的所有东西度可从in中提取出来。

20. synchronized带来的问题除性能有所下降外，最大的缺点是会带来死锁DeadLock，只有通过谨慎设计来防止死锁，其他毫无办法，这也是线程难以驯服的一个原因。不要再使用stop() suspend() resume()和destory()方法

21. 在大量线程被堵塞时，最高优先级的线程先运行。但是不表示低级别线程不会运行，运行概率小而已。

22. 线程组的主要优点是：使用单个命令可完成对整个线程组的操作。很少需要用到线程组。

23. 从以下几个方面提升多线程的性能：

检查所有可能Block的地方，尽可能的多的使用sleep或yield()以及wait();

尽可能延长sleep(毫秒数)的时间;

运行的线程不用超过100个，不能太多；

不同平台linux或windows以及不同JVM运行性能差别很大。

生活源于奋斗不息 2007-01-08 23:48 发表评论

关于java当中的多线程设计, wait/notify机制 , synchronized与对象锁

生活源于奋斗不息 — Mon, 08 Jan 2007 15:29:00 GMT

下面这遍文章讲得简洁易懂.
----------------------------------------------------------------------------------------------------------------

java多线程设计wait/notify机制 (synchronized与对象锁)

作者:--猥琐ing

多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。

以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：

synchronized(obj) {
    while(!condition) {
        obj.wait();
    }
    obj.doSomething();
}

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait() , 放弃对象锁.

之后在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

synchronized(obj) {
condition = true;
obj.notify();
}

需要注意的概念是：

# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。

# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。

# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。

# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

# obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

生活源于奋斗不息 2007-01-08 23:29 发表评论

java -verbose 命令选项

生活源于奋斗不息 — Sat, 06 Jan 2007 04:46:00 GMT

1 ,C:\Documents and Settings\site120_007>java -verbose:class 可以查看JVM加载类的细节情况,如:

1 [Opened C:\Program Files\Java\jre1.5.0\lib\rt.jar]
2 [Opened C:\Program Files\Java\jre1.5.0\lib\jsse.jar]
3 [Opened C:\Program Files\Java\jre1.5.0\lib\jce.jar]
4 [Opened C:\Program Files\Java\jre1.5.0\lib\charsets.jar]
5 [Loaded java.lang.Object from shared objects file]
6 [Loaded java.io.Serializable from shared objects file]
7 [Loaded java.lang.Comparable from shared objects file]
8 [Loaded java.lang.CharSequence from shared objects file]
9 [Loaded java.lang.String from shared objects file]
10 [Loaded java.lang.reflect.GenericDeclaration from shared objects file]
11 [Loaded java.lang.reflect.Type from shared objects file]
12 [Loaded java.lang.reflect.AnnotatedElement from shared objects file]
13
14 [Loaded java.lang.Shutdown from shared objects file]
15 [Loaded java.lang.Shutdown$Lock from shared objects file]
16 Usage: java [-options] class [args]
17            (to execute a class)
18    or  java [-options] -jar jarfile [args]
19            (to execute a jar file)
20
21 where options include:
22     -client      to select the "client" VM
23     -server      to select the "server" VM
24     -hotspot      is a synonym for the "client" VM  [deprecated]
25                   The default VM is client.
26
27     -cp <class search path of directories and zip/jar files>
28     -classpath <class search path of directories and zip/jar files>
29                   A ; separated list of directories, JAR archives,
30                   and ZIP archives to search for class files.
31     -D<name>=<value>
32                   set a system property
33     -verbose[:class|gc|jni]
34                   enable verbose output
35     -version      print product version and exit
36     -version:<value>
37                   require the specified version to run
38     -showversion  print product version and continue
39     -jre-restrict-search | -jre-no-restrict-search
40                   include/exclude user private JREs in the version search
41     -? -help      print this help message
42     -X            print help on non-standard options
43     -ea[:<packagename>|:<classname>]
44     -enableassertions[:<packagename>|:<classname>]
45                   enable assertions
46     -da[:<packagename>|:<classname>]
47     -disableassertions[:<packagename>|:<classname>]
48                   disable assertions
49     -esa | -enablesystemassertions
50                   enable system assertions
51     -dsa | -disablesystemassertions
52                   disable system assertions
53     -agentlib:<libname>[=<options>]
54                   load native agent library <libname>, e.g. -agentlib:hprof
55                     see also, -agentlib:jdwp=help and -agentlib:hprof=help
56     -agentpath:<pathname>[=<options>]
57                   load native agent library by full pathname
58     -javaagent:<jarpath>[=<options>]
59                   load Java programming language agent, see java.lang.instrument
60

2 ,C:\Documents and Settings\site120_007>java -verbose:gc 可以查看JVM中垃圾回收器(Garbage Collector)的细节情况

生活源于奋斗不息 2007-01-06 12:46 发表评论

[UML基础与Rose建模]-----读书笔记.面向对象

生活源于奋斗不息 — Sat, 06 Jan 2007 04:34:00 GMT

面向对象方法使用对象,类,继承,封装等一些核心元素进行程序设计.客观实体与实体之间的联系构成了现实世界的所有问题.面向对象技术通过将客观实体抽象成对象的方法，尽可能地利用人类自然的思维方式构造软件系统

面向对象技术概述
1. 面向对象的基本概念
  1. 基本观点
    1. 客观世界由对象组成，任何客观实体都是对象，复杂对象可以由简单对象组成
    2. 具有相同数据和操作的对象可以归纳成类，对象是类的一个实例
    3. 类可以派生出子类，子类除了继承父类的全部特性外还可以有自己的特性
    4. 对象之间的联系通过消息传递来维系。由于类的封装性，它具有某些外界不可见的数据，这些数据只能通过消息请求调用可见方法来访问
    5. 面向对象的基本出发点就是尽可能地按照人类认识世界的方法和思维方式来分析和解决问题，使人们分析，设计一个系统的方法尽可能接近认识一个系统的方法
  2. 对象
    1. 客观世界里面的任何实体都可以被称之为对象
    2. 对象可以是有形的物，如汽车，飞机
    3. 也可以是无形的事物与概念，如事件，规则，计划，活动等等
    4. 复杂的对象可由相对比较简单的对象以某种方式组成，甚至整个世界也可以从一些最原始的对象开始，层层组合而成。
    5. 对象在软件生命周期当中的各个阶段可能有不同的表示形式。
      1. 如：在分析与设计阶段，对象表现为某种OOA／OOD方法给出的粗略定义
      2. 而在编程阶段表现为一种程序设计语言写出的详细而明确的源程序代码
    6. 如一台收音机对象的实例：
      1. 整个收音机封装也如下行为
        调节声音
        关闭
        打开
        调节频道
        ...
      2. 同时也封装了内部状态
        音量
        频道
        打开还是关闭
        ....
      3. 这些状态值可以，也只能通过上面的行为来得以改变。
  3. 封装
    1. 封装也是面向对象的一个重要原则
    2. 封装指把状态与行为，属性与操作，数据与方法封装到一个对象里面。它的内部信息对外隐藏，不允许外界直接修改对象的属性，只能通过对象提供的有限的接口来对对象的属性数据进行修改，操作。
    3. 对于外界而言，只能知晓对象的外部行为而无法了解对象内部实现细节，这样可以保证对象内部状态，属性，数据的安全性
    4. 总的来讲，封装有两层含义
      1. 结合性
        将对象的全部属性与方法结合起来，形成一个独立的不可分割的单位
      2. 信息隐蔽性
        即尽可能的隐蔽对象内部细节，对外形成了一个边界，只保留有限的对外接口使这与外部发生联系
    5. 封装的基本单位是对象
      1. 如：一块集成电路被封装起来，其内部电路是不可见的。
      2. 集成电路的使用者只关心芯片引脚的个数，引脚的电气参数以及引脚所提供的功能
      3. 通过这些引脚，使用者对这个电路芯片的功能就有大致的了解，便可以使用这块芯片组装成具有一定功能的产品
    6. 封装的目的在于将对象的使用者与设计制造者分离，使用者不必知道行为实际的细节，只需向这个对象发送相应的消息访问访对象即可。
    7. 将定义模块（即使用模块）与实现模块分开（可参考“开闭原则.面向接口编程”），可以大大提高软件的可维护性，可修改性。
  4. 消息
    1. 对象通过对外提供的服务在系统中发挥自己的作用
    2. 当系统中其它对象请求该对象执行某个服务时，些对象就响应这个服务以完成服务所需求的职责
    3. 消息就是面向对象发出的请求，一个消息包含
      1. 消息名
      2. 接收对象的标志
      3. 服务标志
      4. 输入信息
      5. 回答信息
    4. 当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息。接收到消息的对象经过解释，然后予以响应。这种通信机制叫做消息传递。
    5. 面向对象技术的封装机制使得对象相互独立，各个对象要相互协作实现系统的功能就少不了消息传递机制。
    6. 某一个对象在执行相应的处理时，如果需要，它可以通过传递消息请求其它对象完成某些处理工作或者回答某些信息，其它对象在执行所要求的处理活动时，同样也可以通过传递消息与另的对象取得联系。
    7. 在对象传递消中只包含发送者的要求，它指示接收者需要完成哪些处理，但并不告诉接收者应该如何完成这些处理，接收者接收到消息后要独立决定采用什么方式完成所需的处理。
    8. 一个对象能够接收多种形式，内容不同的消息，相同形式的消息可以送往不同的对象，不同的对象对于形式相同的消息可以有不同的解释，做出不同的响应。
  5. 类
    1. 类是一组具有相同的数据结构和相同的操作的对象的集合。类是对象的抽象，它将一组属性和在数据上的一组合法操作抽象封装。
    2. 类好比是对象模板，模型，基于类就可以生成多个具有不同属性值的对象，在类的定义当中，可以为某个属性指定一个值，作为它的默认值。
  6. 继承
    1. 继承指子类可以拥有父类的全部属性与操作
    2. 这个使用已存在的定义作为基础建立新定义的技术使用父类与子类之间能够共享数据与方法
    3. 在现实世界建模时，可以根据事物的共性抽象出一批基类，在基类的基础之上，事物可以根据个性添加自己的属性与操作，抽象出新的对象类。
    4. 这些新类既有基类的全部属性与操作，又有自己的属性与操作，被称之为基类的子类或者派生类，基类被称之为父类或者超类。这种产生子类的方法叫继承
    5. 继承又可以分为两种：
      1. 单重继承
        一个子类只能有一个父类
        这种继承链最终关系结构是一棵自顶向下的树，顶部表示根基类，一直向下发展，延伸
      2. 多生继承
        一个子类有多于一个的父类
        这种继承链最终关系结构是图
    6. 继承简化了世界的描述，定义子类时不必重复定义那些在父类中已经定义过的属性与操作，而只需专注于自己特有的属性与操作
  7. 多态性
    1. 多态性是面向对象技术的一个重要概念。
    2. 同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。这就是多态。
    3. 多态性通常通过重载基类的方法来实现
    4. 多态性可以分为两种
      1. 编译时的多态。
        编译时的多态性是通过重载来实现的，系统在编译时，根据传递的参数信息决定实现何种操作。
      2. 运行时多态
        运行时的多态就是指到系统运行时，才根据实现情况决定实现何种操作
    5. 多态大致有以下3种实现方式
      1. 通过接口实现多态。
      2. 通过继承实现多态。主要是重写基类的操作以提供不同的实现
      3. 通过抽象类实现多态
        抽象类为多态的实现提供了极大的灵活性
        因为它同时提供继承和接口的元素。
    6. 结构与连接
      1. 为了使系统能够有效地映射问题域，系统开发者需认识并描述对象之间的以下几种关系
        对象的分类关系
        对象之间的组成关系
        对象属性之间的静态联系
        对象行为之间的动态联系
      2. 面向对象方法分别利用
        一般／特殊结构
        整体／部分结构
        实例连接／消息连接，来描述对象之间的上述四种关系
      3. 一般／特殊结构：
        又称为分类结构，是一组由一般／特殊关系的类所组成的结构
        它是以一个类为节点，以继承关系为边的连通有向图，
        由仅存在单继承的类构成的结构称为层次图。层次图是一种树形图
        由存在多继承的类构成的结构称为网络图，网络图是一个网状结构。
      4. 整体／部分结构
        又称为组装结构，如组装电脑一样。
      5. 实例连接
        实例连接反映了对象与对象间的静态关系。
      6. 消息连接
        消息连接描述对象之间的动态联系。
        若一个对象在执行服务时需要通过消息请求其它对象为它完成某个服务，则表明第一个对象与第二个对象之间存在着消息连接
        消息连接是有向的，从消息发送者指向消息接收者。
2. 面向对象的开发语言
  1. 面向对象的软件开发不仅限于编码，还包括系统前期分析与设计，
  2. 这里所说的设计就是第1
3. 面向对象的分析设计与开发工具

生活源于奋斗不息 2007-01-06 12:34 发表评论

common-logging 与 log4j 的使用

生活源于奋斗不息 — Fri, 05 Jan 2007 14:15:00 GMT

为了兼容多个Log实现(sun的JDK Logger,apache的Log4j Logger等）Apache实现一个开源软件Common-logging来封装这些Logger，那么当我们写Log log = LogFactory.getLog(**.class)的时候，Common-logging首先会找自己的commons-logging.properties，如果找不到，再进行判断是否能找到org.apache.log4j.Logger类，找到的话，则使用Log4j的Logger，找不到的话，再继续找java.util.logging.Logger类，找到则使用JDK1.4 Logger，找不着再找Jdk13LumberjackLogger，如果还是找不到的话，则使用自己的org.apache.commons.logging.impl.SimpleLog

log4j.rootLogger=INFO,stdout,file

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd EEE HH:mm:ss:SSS} %5p %c{2}:%L - %m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=c:/XXX.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.appender.file.MaxFileSize=1024KB
log4j.appender.file.MaxBackupIndex=100

#这里面的log4j.logger.后面的org.hibernate或者com.XXX表示,这个包下面的所有调试信息级别都为warn,debug
log4j.logger.org.hibernate=warn
log4j.logger.org.hibernate.cache=debug
log4j.logger.com.XXX=debug
log4j.logger.org.springframework=warn
log4j.logger.com.opensymphony=warn

生活源于奋斗不息 2007-01-05 22:15 发表评论

[Hibernate]-----又谈session.load操作(一个很容易让人忽视的问题)

生活源于奋斗不息 — Tue, 05 Dec 2006 01:45:00 GMT

一,session.load
session.load方法在调用时只返回一个（数据初始化代替）对象
只有你访问这个返回的对象的具体方法时 (如toString() ,该对象自有方法 ),　这个对象才真正去访问数据库.而且如果数据库没有对应的数据时,则抛出如下异常:

1 org.hibernate.ObjectNotFoundException: No row with the given identifier exists:XXX.XXX.XXX

注意: 如果没有找到记录,并不会返回null.

二, session.get

如果要返回null,可以利用get()方法
session.get方法是立即访问数据库的.如果没有对应的数据则返回 NULL

三, session级缓存(一级缓存)
当然,如果在session容器里面已经有po了,则直接从缓存里面取得

生活源于奋斗不息 2006-12-05 09:45 发表评论

[设计模式]-----Factory Method模式

生活源于奋斗不息 — Sat, 02 Dec 2006 05:59:00 GMT

一 ,  工厂方法（Factory Method）模式的之定义
工厂方法模式的意义就是定义创建产品对象的工厂接口,将实际的创建工作交给下一级具体工厂去负责.
核心的工厂类不再负责具体产品的创建,这样核心类就成为一个抽象工厂角色,仅仅负责(具体工厂要实现)接口定义.这样进一步抽象的好处就是:工厂方法模式可以使系统在不修改具体工厂角色的情况通过增加新的具体工厂角色下引进新产品.

二 , 工厂方法模式的角色关系
1) 抽象工厂(Creator)角色:
   工厂方法模式的核心,与应用程序相关逻辑无关,任何创建产品对象的具体工厂类都必须实现抽象工厂的接口

2) 具体工厂(Concrete Creator)角色:
实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建该产品对象

3) 抽象产品角色:
   工厂方法模式所创建的产品对象,这是一种产口超类,也就是产品对象的共同父类,或者是共同拥有的接口

4) 具体产品角色:
   这个角色实现了抽象产品所定义的接口,即抽象产品角色的实现类. 具体产品的创建由具体工厂来创建

三 , 示例
1) 抽象工厂角色:

1 //抽象工厂角色,工厂模式的核心,定义要生产何种产品! 在这里为该工厂生产手机和CPU
2 public interface   AbstractFactory
3 {
4     public Mobile createMobile();
5     public CPU createCPU();
6 }

2) 具体工厂角色:
工厂一:专门生产TCL手机与IntelCPU

1 public class FactoryNO1 implements AbstractFactory
2 {
3     public Mobile createMobile()
4     {
5         return new TCLMobile();
6     }
7     public CPU createCPU()
8     {
9         return new IntelCPU();
10     }
11 }
12

工厂二:专门生产Nokia手机与ADMCPU

1 public class FactoryNO2 implements AbstractFactory
2 {
3     public Mobile createMobile()
4     {
5         return new NOKIAMobile();
6     }
7     public CPU createCPU()
8     {
9         return new AMDCPU();
10     }
11 }
12

3) 抽象产品角色

1 //手机产品
2 public interface Mobile
3 {
4 }
5
6 //CPU产品
7 public interface CPU
8 {
9 }
10

4) 具体产品角色

1 public class TCLMobile implements Mobile
2 {
3 }
4
5 public class NOKIAMobile implements Mobile
6 {
7 }
8
9 public class IntelCPU implements CPU
10 {
11 }
12
13 public class AMDCPU implements CPU
14 {
15 }

5) 使用

1 public class TestFactoryMothod
2 {
3     AbstractFactory factory = new FactoryNo1();
4     Mobile tCLMobile = factory.createMobile();
5     //
6 }

总结：
工厂方法模式四种角色，当系统扩展需要添加引进新产品时，仅仅需要添加一个具体产品及具体工厂类即可，原有的工厂对象不用去修改它，这也符合了ＯＣＰ开闭原则,对扩展开放，对修改关闭.

参考: http://dev.yesky.com/48/2483548.shtml

生活源于奋斗不息 2006-12-02 13:59 发表评论

[设计模式]-----概述

生活源于奋斗不息 — Fri, 01 Dec 2006 15:20:00 GMT

设计模式,是前辈们经过长期的实践积累下来的宝贵的面向对象设计分析的经验
它不仅仅适用于Java语言,凡是面向对象的语言,Java , C++ , .Net等甚至是Javascript也可以采用这些模式.
这是一个编程思想,相对于古代武林高手而言,这是一种内功修行.在OOP领域要想更进一层,这可以说是必不可少的学习部分.
下面就简单地从大的方面列举各种模式
GOF的23种设计模式
1) 创建型 Creational patterns
Factory Method
Abstract Factory
Builder
Prototype
Singleton

2) 结构型 Structural patterns

Adapter_Class
Adapter_Object
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

3) 行为型 Behavioral patterns
Interpreter
Template Method Bridge

Composite
Decorator
Facade
Flyweight
Proxy Chain of Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor

生活源于奋斗不息 2006-12-01 23:20 发表评论

[OO原则]-----开闭原则OCP

生活源于奋斗不息 — Fri, 01 Dec 2006 02:15:00 GMT

Open-Close Priciple
软件实体应当对扩展开放，对修改关闭，即软件实体应当在不修改（在Java当中可能通过代理模式来达到这个目的）的前提下扩展
这一点对于软件的可维护性来说,能很灵活地适应软件的不断变化。对于评价软件的可维护性而言，提供了一个依据。
另一方面,开闭,也代表:能不开放的属性或者方法就不开放.仅仅开放必须的接口.

设计模式的应用就是使软件的结构在一定程度上面符合这个原则

开闭原则，仅仅是原则，并没有指明具体的实现方法，其实也很难指明，不同的编程语言，不同的应用领域可能实现的方法都不一样。

一, 面向对象编程我们常见的是“面向接口编程”
   1) 降低程序各部分之间的耦合性，使程序模块互换成为可能
   2) 使软件各部分便于单元测试，通过编制与接口一致的模拟类（Mock），可以很容易地实现软件各部分的单元测试
   3) 已于实现软件的模块的呼唤，软件升级时可以只部署发生变化的部分，而不会影响其它部分

二,封装变化
   将可以发生变化的部分封装成一个对象,如: 状态, 消息,,算法,数据结构等等 , 封装变化也是实现"开闭原则"的一个重要手段
如经常发生变化的状态值,如温度,气压,颜色,积分,排名,等等,可以将这些作为独立的属性,如果参数之间有关系,有必要进行抽象
对于行为,如果是基本不变的,则可以直接作为对象的方法,否则考虑抽象或者封装这些行为.
   封装尽可能变化的部分,在OOD当中,对象不仅仅是现实在存在的事物,任何可能的变化的部分都是候选对象...

三,采用组合来代替继承
   依据开闭原则,我们尽量不要修改类,只扩展类,但在有些情况下会出现一些比较怪异的状况.这时可以采用几个类进行组合来完成.

生活源于奋斗不息 2006-12-01 10:15 发表评论

[OO思想]-----多态

生活源于奋斗不息 — Fri, 01 Dec 2006 01:39:00 GMT

多态（Polymorphism ），也叫多形
就是一种类型可以代表着多种类型，比如说：
张三... --> 男人 --> 人 --> 动物 --> 生物 ...

这里的男人，即可以代表人，也可以代表动物，也可以代表生物。

现在假如一家公司要面试，当然面试的对象是人，那么男人是人，可以参加面试。而猪，狗，猫就不行，它们不属于人这一范畴。
现在又有一个给植物服务的农药，它能毒害动物，那么男人是人，是动物，也就受其毒害范围。

转化到编程里面，公司面试这个方法的参数就是类型“人”。受农药影响的是类型“动物”....

这就是多态，多形，Polymorphism....

[多态是一种机制、一种能力，而非某个关键字。它在类的继承中得以实现，在类的方法调用中得以体现。]

生活源于奋斗不息 2006-12-01 09:39 发表评论

[联想]-----Java异常与项目管理

生活源于奋斗不息 — Fri, 01 Dec 2006 01:24:00 GMT

1 try
2 {
3 //TODO 程序代码
4 }
5 catch(Throwable t)
6 {
7 //处理异常，如果处理不了，则throw t，向上一级抛出异常，直到能处理该异常的程序段，否则程序中止执行
8 }
9

那项目管理呢？项目经理给每个程序员分发任务。

每个程序员去实现分发的任务，当在实现的过程当中碰到问题，如果自己能够解决的，就自己解决，如果自己不能解决，则反映问题，并将问题抛上上一级去处理。以此类推，一级级往上抛，直到能够解决，或者中止此任务。

生活源于奋斗不息 2006-12-01 09:24 发表评论

[Hibernate]-----二级缓存

生活源于奋斗不息 — Fri, 01 Dec 2006 00:12:00 GMT

Hibernate Session提供了一级缓存,每一个session,对同一个po,当有多次load时,只load第一次,但是,当session关闭的时候,一级缓存就失效了.

二级缓存就是sessionFactory级别的缓存,它底下可以用不同的缓存类库,比如,ehcache , oscache,需要设置hibernate.cache.provider_class

缓存可以简单看着是 Key-Value 类型的数据,如Map,HashTable等.通过Key查找里面的Value

Class(单个PO)的缓存
对于一条记录,也就是一个PO,是根据ID来查找的,缓存的Key就是ID, Value就是Po,无论是List,load还是Iterator方式读取出来的,都会填充该缓存(Class缓存) [对于list,iterator还会填充其它缓存].

查询缓存(对象集合)
对于缓存,缓存的Key就是根据HQL生成的SQL语句,再加上参数, 但Value并不是整个结果集,而是查询出来的一串ID , 再根据Class缓存去取得某ID详细信息,但是只要更新过一个表,涉及该表的所有查询缓存就会失效

Collection缓存
Collection缓存与查询缓存一样,也是存取ID串,不过它并不会因为这个表更新过而失效,一个Collection缓存仅在该Collection中有增删操作的时候才失效,但如果这个集合是经过排序的,当修改其中一个元素排序字段时,导致顺序改变时,但Collection缓存并不作更新.

生活源于奋斗不息 2006-12-01 08:12 发表评论