BlogJava-mulinka-文章分类-我的JAVA

在Java程序中运行外部类文件（转）

魔之卡卡 — Mon, 29 Aug 2005 05:03:00 GMT

一、引言

无论是用传统的编程语言（C++、VB等）还是Java语言编程，都经常需要在一个运行的程序中执行另外一个独立的外部程序。例如用Java设计一个IDE程序，那么这个IDE程序就必需能够调式、运行其它独立的外部Java程序。况且直接运行已经存在的外部程序来实现本程序的某些特定的功能，也是提高程序开发效率的一种重要手段。

Java2为实现在一个Java程序中运行外部类文件（即Java程序）提供了的两种解决方案，即在同一进程中运行外部类文件和在不同进程中运行外部类文件。

二、在同一进程中运行外部类文件

Java规定任何Java应用（application）的入口都是：main()，因此要实现在同一进程中运行外部类文件，只要想办法在程序中直接调用外部类文件的main()方法即可。

Java2中的映象（Reflection）API可以对Java虚拟机中的类、接口、对象等进行映象，通过它能够动态地得到类、接口、对象的各种信息，还能够动态地设置对象的域的值，并可以动态地调用对象中的各种方法。

因此，我们可以利用Reflection API在运行时（runtime）动态地确定外部类文件的main()方法，然后调用它。例如：

假定将被执行的外部类文件（Invoked.java）如下：

public class Invoked {

public static void main(String[] args) {

if (args.length != 2) {

System.err.println("Usage: java Invoked name sex ");

System.exit(1);

}

System.out.println("Hello, I come from OutClassFile!");

System.out.println("my name is "+args[0]);

System.out.println("my sex is "+args[1]);

}

运行上述类文件的主程序（Invoker.java）一般具有如下形式：

import java.lang.reflect.*;

public class Invoker {

public static void main(String[] args) {

//args[0]存储被执行的外部类名，本例中args[0]=“Invoked”

if (args.length != 1) {

System.err.println("Usage: java Invoker ");

System.exit(1);

}

Class[] argTypes = new Class[1];

argTypes[0] = String[].class;

try {

Method mainMethod = Class.forName(args[0]).getDeclaredMethod("main",argTypes);

Object[] argListForInvokedMain = new Object[1];

//被调用的main()方法的参数个数=1

argListForInvokedMain[0] = new String[2];

//被调用的main()方法的参数是一个长度为2的String数组

String argsToinvoked[]={"WangShuangLin","Man"};

ArgListForInvokedMain[0]= argsToinvoked;

//设置传递给被调用的外部类的main()方法的参数

mainMethod.invoke(null, argListForInvokedMain);

//inkoke(Object obj, Object[] args)是调用方法；

//其中obj是方法所在的对象实例; 但因为这里的main()是静态方法，

//所以无须实例化，填上null即可；

//args是传递给该方法的参数。

}

catch (ClassNotFoundException ex) {

System.err.println("Class"+args[0]+"not found in classpath.");

}

catch (NoSuchMethodException ex) {

System.err.println("Class "+args[0]+" does not define public static void main(String[])");

}

catch (InvocationTargetException ex) {

System.err.println("Exception while executing "+args[0]+ ":"+ex.getTargetException());

}

catch (IllegalAccessException ex) {

System.err.println("main(String[]) in class "+args[0] + "is not public");

}

用如下的命令行运行主程序：java Invoker Invoked。

这个例子简单展示了如何在同一进程（process）中执行外部类文件，不仅如此，而且还是在同一线程（thread）中，当然完全可以在不同的线程中来完成。

三、在不同进程中运行外部类文件

要在不同进程中运行外部类文件，只要想办法在程序中直接执行：

java 外部类文件（本例即为：java Invoked）即可。

幸运的是java.lang.Runtime 类提供了exce()方法来完成对外部可执行程序的调用。注意：在这里exce()方法调用的其实是java解释器这个可执行程序，外部类文件Invoked.class只不过是作为java解释器的参数出现。事实上，exce()方法还可以直接调用其它的可执行文件，而不仅仅是java解释器。

假定将被执行的外部类文件仍然是上面的Invoked.java；

那么运行上述类文件的主程序（InvokerFromSeparateProcess.java）如下：

public class InvokerFromSeparateProcess {

public static void main(String[] args) {

if (args.length != 1) {

System.err.println("Usage: java InvokerFromSeparateProcess ");

System.exit(1);

}

String name=” WangShuangLin”;

String sex=” man”;

try {

Process p = Runtime.getRuntime().exec("java "+args[0]+name+sex);

}

catch (java.io.IOException ex) {

System.err.println("Problems invoking class "+args[0]+": "+ex);

}

用如下的命令行运行主程序：java InvokerFromSeparateProcess Invoked。

你也许会发现并没有看到被调用的外部类文件Invoked.class的输出。问题在于新进程（new porcess）的标准输出流（standard output stream）并不会自动地定向到stdout。为了得到并显示新进程的输出信息，我们可以利用p.getInputStream()来读取新进程的输出信息，然后把读到的信息发送到标准输出流（standard output）上。

四、结语

利用Java2中的映象（Reflection）API实现在同一进程（process）中执行外部类文件的方法，优点是消耗资源较少，因为它不打开新的进程；功能强大，因为它不但可以执行外部类文件的main()方法，而且还可以执行外部类文件的其它方法，可以非常细致地利用外部类文件的一切资源。缺点是它只能执行用Java编写的外部类文件，而不能执行其它形式的可执行文件，如EXE、COM等；其次是编程较第二种形式稍微复杂一点。

利用java.lang.Runtime 类提供了exce()方法来完成对外部可执行程序的调用的方法，优点是编程简单，并且可以运行一切可执行程序，包括用其它语言编写的程序。缺点是消耗资源较多，因为它要打开新的进程；其次是它只能整体运行外部类文件，而不能细致地访问被调用程序的内部资源。

一般情况下，如果要运行用Java编写的外部类文件，选择第一种方法较为灵活、恰当；如果要运行用其它语言编写的可执行程序，选择第二种方法较为方便、直接，但是一般情况下要尽量避免这样做，否则将降低Java程序的跨平台性，因为这种外部程序一般是平台相关的。

魔之卡卡 2005-08-29 13:03 发表评论

Dynamic proxy（动态代理模式）

魔之卡卡 — Fri, 29 Jul 2005 03:10:00 GMT

Java 1.3引入了名为“动态代理类”（Dynamic Proxy Class）的新特性，利用它可为“已知接口的实现”动态地创建包装器（wrapper）类。

使用动态代理，你创建的包装器类不要求为所有方法都使用显式的包装器，创建的子类也不要求具有严格的出身，两者方法可任选一种你认为最好的。但是，动态代理仍然有一个限制。当你使用动态代理时，要包装/扩展的对象必须实现一个接口，该接口定义了准备在包装器中使用的所有方法。这一限制的宗旨是鼓励良好的设计，而不是为你带来更多的麻烦。根据经验，每个类都至少应该实现一个接口（nonconstant接口）。良好的接口用法不仅使动态代理成为可能，还有利于程序的模块化。

2种写invoke()
注意:必须有return method.invoke(wrapped, args)

以下内容为程序代码:

public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Class[] paramTypes = method.getParameterTypes();
        for (int i=0; i < paramTypes.length; i++) {
            if (Tool.class.isAssignableFrom(paramTypes[i])) {
                args[i] = Tool.RATCHET;
            }
        }
        return method.invoke(wrapped, args);
    }

  public Object invoke(Object proxy, Method m, Object[] args)
           throws Throwable {
       Object result;
       try {
           System.out.println("before method " + m.getName());
           result = m.invoke(obj, args);
       } catch (InvocationTargetException e) {
           throw e.getTargetException();
       } catch (Exception e) {
           throw new RuntimeException("unexpected invocation exception: "
                  + e.getMessage());
       } finally {
           System.out.println("after method " + m.getName());
       }
       return result;
    }
}

运行效果如下：
before method bar
after method bar

dynamic proxy的实战步骤
实际上dynamic proxy只有关键以下几个东西
一、业务接口：一个Interface
二、实现业务接口的类：一个继承Interface的Class
三、自己写一个继承了java.lang.reflect.InvocationHandler的Handler类
四、在这个Handler类中实现invoke（）方法
五、在invoke（）方法中一定要记得写return method.invoke(wrapped, args)
六、要使Handler和自己的业务接口关联还的写下面的代码（一般写在Handler类中）

以下内容为程序代码:

    public static Object newInstance(Object obj) {
       return java.lang.reflect.Proxy.newProxyInstance(obj.getClass()
              .getClassLoader(), obj.getClass().getInterfaces(),new Handler(obj));
    }

这样返回的就是经过代理的对象了（把原对象和Handler绑定到一起）

dynamic proxy的典型应用《使用JAVA中的动态代理实现数据库连接池》

dynamic proxy在JDBC上的应用
IBM文章:
《使用JAVA中的动态代理实现数据库连接池》

魔之卡卡 2005-07-29 11:10 发表评论

Java中ThreadLocal的设计与使用

魔之卡卡 — Fri, 08 Jul 2005 08:54:00 GMT

Java中ThreadLocal的设计与使用

原文出处：http://www.huawei.org.cn/news/article_show.asp?id=27413

　　早在Java 1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。使用这个工具类可以很简洁地编写出优美的多线程程序，虽然ThreadLocal非常有用，但是似乎现在了解它、使用它的朋友还不多。
　　
　　ThreadLocal是什么

　　ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。
　　
　　ThreadLocal的设计
　　
　　首先看看ThreadLocal的接口：
　　
　　Object get() ; // 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值
　　void set(Object value); // 设置当前线程的线程局部变量副本的值
　　
　　ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：
　　
　　

protected Object initialValue() { return null; }

　　
　　ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：
　　
　　

public class ThreadLocal
　　{
　　private Map values = Collections.synchronizedMap(new HashMap());
　　public Object get()
　　{
　　Thread curThread = Thread.currentThread();
　　Object o = values.get(curThread);
　　if (o == null && !values.containsKey(curThread))
　　{
　　o = initialValue();
　　values.put(curThread, o);
　　}
　　return o;
　　}
　　
　　public void set(Object newValue)
　　{
　　values.put(Thread.currentThread(), newValue);
　　}
　　
　　public Object initialValue()
　　{
　　return null;
　　}
　　}

　　
　　当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。
　　
　　ThreadLocal的使用
　　
　　如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：
　　
　　

public class SerialNum
　　{
　　// The next serial number to be assigned
　　
　　private static int nextSerialNum = 0;
　　private static ThreadLocal serialNum = new ThreadLocal()
　　{
　　protected synchronized Object initialValue()
　　{
　　return new Integer(nextSerialNum++);
　　}
　　};
　　
　　public static int get()
　　{
　　return ((Integer) (serialNum.get())).intValue();
　　}
　　}
　　

　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：
　　
　

　int serial = SerialNum.get();

　　
　　即可。
　　
　　在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。
　　
　　ThreadLocal与其它同步机制的比较
　　ThreadLocal和其它同步机制相比有什么优势呢？ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。
　　
　　由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal类将从中受益。也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。
　　
　　总结
　　当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁。

魔之卡卡 2005-07-08 16:54 发表评论