Tang Liang's notebook: Java技术

jigloo插件简介

Sun, 19 Nov 2006 14:39:04 GMT

jigloo插件简介

一 3大GUI开发插件的特色

Eclipse并不自带GUI的可视化开发工具，那么如果要在Eclipse进行可视化的GUI开发，就需要依靠第三方的插件。

1. Visual Editor

Eclipse官方提供了一个叫做Visual Editor(VE)的开源GUI插件，功能还是比较强。可以根据用户的界面GUI设计，自动生成相应的JAVA代码。同样也可以通过相应的JAVA代码，生成其匹配的可视化GUI编辑界面。不过VE缺点比较大，我从3.1到3.2之前一直在用VE，没有多少改观。VE是通过另外启动一个JVM来模拟执行GUI的class，然后在Eclipse的界面内生成一个可视化效果。

回顾一下Visual C++,NetBeans等其它IDE进行GUI可视化的方法，都是基于另外一个界面管理资源文件，非用户可以直接修改的。而直接通过程序代码来管理可视化的GUI编辑器，就需要极强的代码parse能力。很可惜，VE想这样做，确没有能够做到。

VE使用起来问题很多，网上有网友直接评价说VE是“可用性不强”。我自己用起来的感觉，问题就出在一下几个方面：

1). 另外启动JVM速度很慢，而且如果要同时打开几个Visual Class，那么就要启动几个JVM，内存消耗也大。而且，有些时候,反复打开关闭一个Visual Class，JVM还启动不起来。

2). 对于用户自己编辑的可视化Java代码的parse能力很弱。常见的错误就是，明明是正确的可视化GUI代码，但是VE里面窗口打开半天，结果只能显示一把叉。很多时候，就根本不能显示出一个完整的可视化窗口。而对于窗口上某个控件的定位能力不强，用户自己的代码稍微转几道弯儿，VE就不知道这个控件是在哪里产生的了，顶多只能显示出来，但是无法可视化编辑。

4). 3.1的VE编辑的代码到了3.2的VE里面，显示出来完全不一样了。

5). 安装比较麻烦，还需要用户自行去安装不只一个的辅助插件。

综上所述，VE真的“可用性不强”

2. SWT-Designer

SWT-Designer是大家公认的，最强的Eclipse下开发GUI的插件http://www.swt-designer.com/。很多Eclipse书籍上都是直接拿SWT-Designer来讲解如何在Eclipse开发GUI界面程序。不过SWT-Designer是一个收费的插件。不收费的是基础版本，功能受到很大的限制。当然，网上也有完整版的破解版。SWT-Designer做得比较大，6.0最新的安装文件有几十M，可想其功能之强大。

3. jigloo

jigloo严格意义上来说也是收费的，不过他提供了non_commercial的版本，而这个版本的功能和commercial是完全一样的http://www.cloudgarden.com/jigloo/。作为个人开发来说，是不受限制的。jigloo很小，最新的版本才3MB多，安装也比较简单。

jigloo同时支持SWT和Swing。

jigloo也是完全基于Java代码的，不过它的code parse的能力远比VE要强，也要快。至少我很多在VE下出现问题，不能显示的Visual Class可以很好地在jigloo下编辑，至今还没有遇到jigloo不能编辑，parse出错的时候。而jigloo还可以集成了一写比较好的Java GUI风格代码的支持，功能上比VE要强大一些。

当然，3MB多的插件，再强也强不过SWT-Designer完整版的，但是比其基础版的要好很多。而SWT-Designer也并不是完全基于JAVA开发的，比如Windows版本的，还携带了dll文件。而jigloo是完全基于JAVA开发的，下载下来只有一个class的zip文件，也支持Eclipse的在线安装。

二 jigloo的安装和使用

jigloo的安装很简单，和其它Eclipse插件一样，不需要任何安装程序，直接解压出来就行了。

创建新的窗口，直接输入File->New->Others->GUI Forms就可以了。

而如果要打开一个已经存在的Visual Class，可以直接右键点击，选择Open With->Form Editor打开就可以了。打开后，首先要进行code parse，不过这个速度很快，也不需要像VE那样还启动一个JVM。

下面是我的Eclipse下使用jigloo的截图:

三. 总结

根据3大Eclipse的GUI开发插件可以看出，基本都是基于Java code的GUI编辑管理。这种编辑器管理，当然就比以前Visual C++那样管理Windows界面程序要困难很多。但是，现行的很多IDE，比如Visual Studio .NET,2005都还是能够做得比较快。主要的就是要看起code parsing的能力。

VE前面的缺点已经总结得比较多，不知道这个官方的插件什么时候才能让人真正放心。作为开发者来说，心里还是最想给VE加把劲的，毕竟VE是开源的，随便用的。

SWT-Designer功能最强大，可惜价格不低。而jigloo可谓介于两者之间，对于个人开发者来说，可以免费使用，而且其功能也足够到开发各种大型的GUI应用程序了，应该是一个合适的选择。

Java对象序列化给分布式计算带来的方便

Mon, 21 Aug 2006 09:52:06 GMT

在面向对象程序语言中做分布式计算的时候，经常需要将对象在不同的主机之间传输，我这次在实现分布式计算的时候，需要将一个计算对象从中央服务器Server分发给所有的客户端client。

通过网络TCP，建立Socket，传输一个对象，就需要将对象转换成一段字节流，也就叫做对象的序列化。同时，也要求可以从这段字节流，创建出对应的对象出来。

C++里面的做法就是在每个类里面实现两个接口函数，自己通过写读和写对象的方法，来实现序列化。因为每个类的成员变量的值和成员变量的类型作者自己肯定晓得，所以就需要自己来通过把一个个成员变量写到流里面，最终实现了对象到字节流的转换。

C++里面针对纯数据类型的结构体，就是成员变量没有指针的对象的话，还可以通过拷贝内存块到字节流的方法memcpy，也可以很容易实现序列化，但是这只能是针对成员变量都是数据类型，没有指针类型的对象。

在Java里面就比较方便了，直接通过实现java.io.Serializable接口，JVM就能自动来将类实现序列化。同时，java.io.Serializable接口没有任何接口函数，只是一个空接口，唯一的作用就是标志一下这个类是可以序列化。

其实，Java里面的对象序列化，是JVM在做的，因为JVM可以掌控整个对象的内部数据结构，就可以简单遍历树的方法，来实现把一个对象的所有成员变量写到字节流里面。当然，居然怎么做的，我也不太清楚，但是所有JVM来说，要做这一点还是很容易的。

Java里面，几乎所有的类只要实现了java.io.Serializable接口，就可以实现序列化。但是要求这个类里面的所有成员变量也是可以序列化的。比如类A有个成员变量对象是类B，如果A能序列化，要求B也要能够序列化，也就是A实现了java.io.Serializable，要求B也一定实现java.io.Serializable。

网上关于具体实现序列化的Sample代码很多了，我这里只是贴出一段参考：

序列化对象都是通过Java的ObjectInputStream和ObjectOutputStream来实现的。

写：

ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(A);

读:

ObjectInputStream ios =new ObjectInputStream(is);
A a=(A)ios.readObject();

一个简单的RMI入门例程(转贴)

Wed, 12 Jul 2006 11:51:09 GMT

前提，J2SDK安装，本例使用的是1.4.2_07。

RMI主要用在分布式应用中，一般情况下的使用是这样子，即业务逻辑在Server端的类中实现，而使用者即客户端则主要的调用Server提供的方法来得到结果。

下面就写一下这个例子，主要实现的功能是打印个1+2=3的等式。

哦，这儿要先想一下，即，对Client来讲，它需要知道Server提供了哪些东西，这个由一个接口来进行约束，即Server提供并实现了该接口里面的方法，而Client则参照该接口进行调用，就是这样一个思路。

那么Client是如何得到这些方法的实现呢，这就要归功于RMI，在Server那边同时提供一个RMI端口监听程序，来接受Client的呼叫调用。RMI同时建立一个基本框架。

这样一个思路应该比较明显，即建立一个Server程序放在RMI的框架中用于监听，然后建立一个接口来约束基本方法的实现，Server对该接口进行了实现，Client则通过呼叫Server程序来调用该实现。

好了，如上所示，先建立一个接口，因为这个其实才是应用的业务核心所在：

RMIInterface.java:

import java.rmi.*;
public interface RMIInterface extends Remote{
// 实现一个加法
public int sum(int a, int b) throws RemoteException;
}

然后对该接口实现：

RMIInterfaceImpl.java:

import java.rmi.*;
import java.rmi.server.*;
public class RMIInterfaceImpl extends UnicastRemoteObject implements RmiSample{
public RMIInterfaceImpl () throws RemoteException{ super(); }
// 在这儿对该方法进行了实现
public int sum(int a, int b) throws RemoteException{
return a + b;
}
}

这样实现了以后，在Client那边才能得到想要的结果，下面建立RMIServer程序，如下：

RMIServer.java:

import java.rmi.*;
import java.rmi.registry.*;
public class RMIServer{
public static void main(String[] args) {
  try{
   LocateRegistry.createRegistry(8808); // 注册端口
   RMIInterfaceImpl server = new RMIInterfaceImpl();
   // Binding
   Naming.rebind("//localhost:8808/RMI", server); // 将实现类绑到一个名字上去
   }catch(java.net.MalformedURLException me){
   System.out.println("Malformed URL:" + me.toString());
   }catch(RemoteException e){
   System.out.println("Remote Exception:" + e.toString());
   }
}
}

这样Server端的相差程序已经建立OK啦，下面就建立Client那边的程序，其实就是一个调用，到某个地址那里去找RMI的监听，然后取得对象，来调用得到结果：

RMIClient.java:

import java.rmi.*;
import java.rmi.server.*;
public class RMIClient {
public static void main(String[] args){
  try {
   String url = "//190.0.0.112:8808/SAMPLE-SERVER";
   RMIInterface RMIObject = (RMIInterface)Naming.lookup(url); // 寻得对象
   System.out.println(" 1 + 2 = " + RMIObject.sum(1,2) );
   } catch (RemoteException exc) {
   System.out.println("Lookup error: " + exc.toString());
   } catch (java.net.MalformedURLException ex) {
   System.out.println("Malformed URL: " + ex.toString());
   } catch (java.rmi.NotBoundException e) {
   System.out.println("Not Bound: " + e.toString());
   }
}
}

这里可能会有一个问题，就是对于这一句不免会有一点想法：

RMIInterface RMIObject = (RMIInterface)Naming.lookup(url); // 寻得对象

嘿嘿，这个嘛，偶目前也有点不清楚，怎么用接口来取得对象。

好了，程序已经编完啦，只有四个类，下面编译，在本例中，四个类都放在缺省包下，编写一个用于编译的批处理文件，和这四个JAVA文件放在一起，至于这个并不重要，只是因为懒一点，所以写了，省得每次打那么多字：

Compile.bat:

javac *.java
rmic -d . RMIInterfaceImpl

编译完成后会出现六个类，这是怎么回事儿吶，原来多了两个类：

RMIInterfaceImpl_Skel.class
RMIInterfaceImpl_Stub.class

就是RMI的框架需要的类啦，不过在这里，Client只需要stub类就行了，别问我为什么，不知道，哈哈。

好了，下面就是分成两组，这儿可能.NET的兄弟又在说J2EE就是麻烦，呵呵，这是最无聊且没营养的一种说法，技术本身没有绝对的优劣，只有适合不适合于应用。

这六个类文件，其中Client端需要三个：
RMIInterface.class
RMIClient.class
RMIInterfaceImpl_Stub.class

服务端则需要五个文件：
RMIInterface.class
RMIInterfaceImpl.class
RMIServer.class
RMIInterfaceImpl_Skel.class
RMIInterfaceImpl_Stub.class

这儿可能再建立两个文件夹来分别copy一下，分成server和client应该比较容易理解和发布吧，呵呵，这个动作完全可以随手写个程序来完成的，由于偶没什么大的应用，所以就懒得写啦。

该动作的程序思路应该是这样子，即生成接口，在编译接口的时候，C和S各一份，然后做实现和Server程序，扔S那里去，而做Client调用程序的时候则扔C那里去，在用RMIC对实现建立框架的时候，则C和S也各一份，如此，就形成服务端和客户端分开的情况了。

当然Server的监听程序和Client的调用程序自动生成的东西比较多，嘿嘿

好了，对每个目录进行打包：
/server
Jar cvf server.jar *.class

/client
Jar cvf server.jar *.class

这儿其实可以不用打包，直接来用，不这不利于发布，也就写一下吧。
在生成server.jar和client.jar后，就可以进行“分布式”应用啦，哈哈，分布式其实挺简单的，就是在不同的机器单元上协同起来做同一件事情嘛。
分别为Server和Client写一个批处理，该例中，批处理和相应的jar文件是放在一起的：
Server.bat:
java -classpath "server.jar" RMIServer

Client.bat:
java -classpath "client.jar" RMIClient

OK，先运行server.bat，然后运行N次client.bat，不过每次的结果都是一样的，呵呵

自己写的一个JSP上传文件和下载文件的JavaBean

Sun, 16 Apr 2006 13:21:32 GMT

这个周末终于可以好好锻炼一下我的IBM ThinkPad T43了。今天看了一些关于JSP，Servlet方面的资料，写了简单的两个JavaBean。一个是UpLoad,一个是DownLoad。写得很简单，没有使用其它任何组件，自己做的。大家可以来看看。

1.RunningUpLoader上传Bean

首先是RunningUpLoader.java，代码有些多，因为我是自己来解析输入流的。

package testupload;
import java.io.*;
import javax.servlet.http.HttpServletRequest;

public class RunningUpLoader {
public RunningUpLoader() {
}

    /**
     * 上传文件
     * @param request HttpServletRequest Servlet的请求对象
     * @param name String 要上传的文件在表单中的参数名
     * @param fileName String 保存在服务器上的文件名
     * @throws IOException
     */
    public void doUpload(HttpServletRequest request, String name,String fileName) throws
            IOException {
        InputStream in = request.getInputStream();
        byte[] buffer = getFileContent(name,in);
        FileOutputStream fos = new FileOutputStream(fileName);
        fos.write(buffer,0,buffer.length-2);
        fos.close();
    }

    /**
     * 获取上传的文件buffer,结尾处将多2个字节
     * @param name String 文件上传参数的名字
     * @param is InputStream 服务器对话的输入流
     * @return byte[] 返回获取的文件的buffer,结尾处将多2个字节
     * @throws IOException
     */
    private byte[] getFileContent(String name, InputStream is) throws IOException{
        int index;
        boolean isEnd = false;
        byte[] lineSeparatorByte;
        byte[] lineData;
        String content_disposition;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        BufferedInputStream bis = new BufferedInputStream(is);

        lineSeparatorByte = readStreamLine(bis);
        while(!isEnd) {
            lineData = readStreamLine(bis);
            if(lineData == null) {
                break;
            }
            content_disposition = new String(lineData,"ASCII");
            index = content_disposition.indexOf("name=\"" + name + "\"");
            if (index >= 0 && index < content_disposition.length()) {
                readStreamLineAsString(bis); // skip a line
                readStreamLineAsString(bis); // skip a line

                while ((lineData = readStreamLine(bis)) != null) {
                    System.out.println(new String(lineData));
                    if (isByteArraystartWith(lineData, lineSeparatorByte)) { // end
                        isEnd = true;
                        break;
                    } else {
                        bos.write(lineData);
                    }
                }
            }else {
                lineData = readStreamLine(bis);
                if(lineData == null)
                    return null;
                while(!isByteArraystartWith(lineData, lineSeparatorByte)) {
                    lineData = readStreamLine(bis);
                    if(lineData == null)
                        return null;
                }
            }
        }
        return bos.toByteArray();
    }

    private byte[] readStreamLine(BufferedInputStream in) throws IOException{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int b = in.read();
        if(b== -1)
            return null;
        while(b != -1) {
            bos.write(b);
            if(b == '\n') break;
            b = in.read();
        }
        return bos.toByteArray();
    }

    private String readStreamLineAsString(BufferedInputStream in) throws IOException {
        return new String(readStreamLine(in),"ASCII");
    }

    private boolean isByteArraystartWith(byte[] arr,byte[] pat) {
        int i;
        if(arr == null || pat == null)
            return false;
        if(arr.length < pat.length)
            return false;
        for(i=0;i<pat.length;i++) {
            if(arr[i] != pat[i])
                return false;
        }
        return true;
    }
}

上传文件文件的时候，需要在之前的html中增加一个form表单，里面需要有个<input type="file" name="fileUpload" >的输入按钮。这样，浏览器才会将要上传的文件递交给服务器。其中name="fileUpload"的名字，就是RunnningUpLoader.doUpload函数中的name参数。

使用的时候直接用bean就OK了。比如upload.jsp如下：

<jsp:useBean id="upBean" scope="page" class="testupload.RunningUpLoader" />

upBean.doUpload(request,"fileupload","runningUpLoad.txt");

2. RunningDownLoader下载Bean

package testupload;
import java.io.*;
import javax.servlet.http.HttpServletResponse;
import java.net.URLEncoder;

public class RunningDownLoader {
public RunningDownLoader() {
}

    public void doDownload(HttpServletResponse response, String filePath,String fileName) throws
            IOException {
        response.reset();//可以加也可以不加
     response.setContentType("application/x-download");//设置为下载application/x-download
     System.out.println(this.getClass().getClassLoader().getResource("/").getPath());
     String filenamedownload = filePath;
     String filenamedisplay = fileName;//系统解决方案.txt
     filenamedisplay = URLEncoder.encode(filenamedisplay,"UTF-8");
     response.addHeader("Content-Disposition","attachment;filename=" + filenamedisplay);

     OutputStream output = null;
     FileInputStream fis = null;
     try
     {
         output = response.getOutputStream();
         fis = new FileInputStream(filenamedownload);

byte[] b = new byte[1024];
int i = 0;

         while((i = fis.read(b)) > 0)
         {
             output.write(b, 0, i);
         }
         output.flush();
     }
     catch(Exception e)
     {
         System.out.println("Error!");
         e.printStackTrace();
     }
     finally
     {
         if(fis != null)
         {
             fis.close();
             fis = null;
         }
         if(output != null)
         {
             output.close();
             output = null;
         }
     }

}

下载文件，最好是做到Servlet上。直接在Servlet的doGet下面增加如下代码即可

//Process the HTTP Get request
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws
            ServletException, IOException {
        RunningDownLoader downloader= new RunningDownLoader();
        downloader.doDownload(response,"E:\\MyProjects\\testupload.rar","upload.bin");
    }