http://liyong0527.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/154634  发表时间: 2008年01月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Swing技巧8:完美的LookAndFeel解决方案

在
Swing技巧4:设置系统窗口,边框,标题,最小化,还原,最大化按钮
和
Swing技巧5:运行中重设LookAndFeel
中,我使用
if(currentLookAndFeel.getSupportsWindowDecorations()){
frame.setUndecorated(true);
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
}
和
public static void setLookAndFeel(Component target, LookAndFeel lnf){
try{
UIManager.setLookAndFeel(lnf);
SwingUtilities.updateComponentTreeUI(target);
}catch(Exception e){
System.out.println("ERROR: " + e);
}
}
达到不但设置LookAndFeel,更使系统窗口,边框,标题,最小化,还原,最大化按钮也有LookAndFeel的目的.

但此种方法缺点也很明显:
1.Matrix网友sslazio21反映新弹出的JFileChooser的系统窗口边框任为System LookAndFeel
2.对没有系统窗口,边框,标题的LookAndFeel,比如Windows,Motif及他们的子类,根JFrame也就没有系统窗口,边框,标题,导致无法最小化,还原,最大,改变大小.

1的解决方法是我在Swing技巧4:设置系统窗口,边框,标题,最小化,还原,最大化按钮中提到的方法1:全局设置
//JFrame,JDialog.setDefaultLookAndFeelDecorated
//static global setting
//Provides a hint as to whether or not newly created JDialogs and JFrames should have their Window decorations
//(such as borders, widgets to close the window, title...) provided by the current look and feel.
JFrame.setDefaultLookAndFeelDecorated(true);


完整的初始化是
try{
Class lafClass=Class.forName(currentLookAndFeel);
LookAndFeel laf=(LookAndFeel)(lafClass.newInstance());
JFrame.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
JDialog.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
}catch(Exception e){}

必须对JFrame和JDialog都设置.

注意frame.setUndecorated(true)和JFrame.setDefaultLookAndFeelDecorated(true)必须在窗口显示之前,也就是frame.show()或frame.setVisible(true)之前.
因为setUndecorated的java doc说This method can only be called while the frame is not displayable.
setDefaultLookAndFeelDecorated的java doc说newly created JDialogs and JFrames,对新建窗口有效.

对于2,我希望窗口,边框,标题的LookAndFeel随着setLookAndFeel而更改,如果是对没有窗口,边框,标题的LookAndFeel那么就使用System的系统窗口,边框,标题.
除了前面的初始化以外,我还改一下setLookAndFeel:
public static void setLookAndFeel(Component target, LookAndFeel lnf){
try{
JFrame.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
JDialog.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
UIManager.setLookAndFeel(lnf);
SwingUtilities.updateComponentTreeUI(target);
}catch(Exception e){
System.out.println("ERROR: " + e);
}
}
对新建窗口(新弹出的JFileChooser)是有效了,但对已经存在的窗口,边框,标题不会改变.
看来对已经存在的窗口,必须使用
frame.setUndecorated(true);
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
但有setUndecorated:This method can only be called while the frame is not displayable.
试试
frame.hide();
frame.setUndecorated(true);
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
frame.show();
不但没有效果,在setLookAndFeel时还失去响应.

查java doc发现the frame is not displayable的状态只有在frame的第一次show()之前和dispose()以后.
只有dispose()以后了:
frame.dispose();
frame.setUndecorated(true);
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
frame.show();


这样可以说是Swing LookAndFeel的完美解决方案,最终代码如下:

初始化时,第一个窗口建立之前:
try{
Class lafClass=Class.forName(currentLookAndFeel);
LookAndFeel laf=(LookAndFeel)(lafClass.newInstance());
JFrame.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
JDialog.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
}catch(Exception e){}

public static void setLookAndFeel(JFrame frame, LookAndFeel lnf){
try{
//改变全局设置
JFrame.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
JDialog.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
UIManager.setLookAndFeel(lnf);

//改变当前frame的窗口,边框,标题
frame.dispose();
frame.setUndecorated(lnf.getSupportsWindowDecorations());
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
frame.show();

SwingUtilities.updateComponentTreeUI(frame);
}catch(Exception e){
System.out.println("ERROR: " + e);
}
}
很不幸,对JDialog必须也有一个,虽然只改了一个单词,还是要有.
public static void setLookAndFeel(JDialog frame, LookAndFeel lnf){
try{
//改变全局设置
JFrame.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
JDialog.setDefaultLookAndFeelDecorated(laf.getSupportsWindowDecorations());
UIManager.setLookAndFeel(lnf);

//改变当前frame的窗口,边框,标题
frame.dispose();
frame.setUndecorated(lnf.getSupportsWindowDecorations());
frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
frame.show();

SwingUtilities.updateComponentTreeUI(frame);
}catch(Exception e){
System.out.println("ERROR: " + e);
}
}

参考资料:
1.Java Docs
2.Swing技巧5:运行中重设LookAndFeel,来自SwingSet2源码
3.Swing技巧4:设置系统窗口,边框,标题,最小化,还原,最大化按钮,中第二种方法,来自BeanBuilder源码

PS:
1.用此种方法改造的SwingSet2:
『 点击下载 』
可以用ant编译.
只改了SwingSet2.java文件,大家可以用Windiff(Vc6中有)或WinMerge与原始文件(在%Java_home%\demo\jfc\SwingSet2\SwingSet2.jar\src\中)比较.
第三方LookAndFeel,可以到 www.javootoo.com 下载,放在%Java_home%\jre\lib\ext\中.中

2.为什么对JFrame和JDialog,有一个完全相同的setLookAndFeel?
因为Swing的继承体系:
Window
/ | Frame | Dialog
| | |
| JWindow |
| |
JFrame JDialog
setUndecorated只有JFrame和JDialog中有.
很奇怪的继承体系,不是吗?JFrame和JDialog也应该是JWindow的子类,这样才符合直觉.但java是单根继承的,sun又该死的弄了两套gui,awt和swing.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Thu, 10 Jan 2008 10:06:15 +0800 http://liyong0527.javaeye.com/blog/154634 http://liyong0527.javaeye.com/blog/154634 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/151131  发表时间: 2007年12月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1:对Console的支持

对于一些需要Dos窗口或者是Linux的管理台的程序来说,这是非常不错的消息.

演示代码:

import java.io.*;
public class ConsoleTest {
public static void main(String[] args) {
Console console = System.console();//获得Console实例
Object[] a1={};
Object[] a2={};
if(console!=null){//判断console是否可用
String user = new String(console.readLine("Enter user:",a1)); //读取整行字符
String pwd = new String(console.readPassword("Enter passowrd:",a2)); //读取密码,密码输入时不会显示
console.printf("User is:"+user+"\n",a1);
console.printf("Password is:"+pwd+"\n",a2);
}else{
System.out.println("Console is unavailable");
}
}

}


当然如果你在IDE开发环境下运行可能报错哦。不过你在windows 的CMD下运行.你就可以发现:

Enter user:chinajash
Enter passowrd:
User is:chinajash
Password is:chinajash

2:对动态编辑技术的支持。

我们在使用Eclipse开发Jsp的时候就会发现,如果你修改了java代码,每次都要从新发布一次,真是非常麻烦,所以如果能支持动态编译那将是多么的好啊。

一看以下代码那将全明白啦.

public class CompilerAPITester {
　private static String JAVA_SOURCE_FILE = "DynamicObject.java";
　private static String JAVA_CLASS_FILE = "DynamicObject.class";
　private static String JAVA_CLASS_NAME = "DynamicObject";
　public static void main(String[] args) {
　　JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
　　StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
　　generateJavaClass();
　　try {
　　　//将产生的类文件拷贝到程序的ClassPath下面,下面这一行代码是特定于Windows＋IntelliJ IDEA 6.0项目,不具有移植性
　　　Runtime.getRuntime().exec("cmd /c copy "+JAVA_CLASS_FILE+" classes\\production\\JDK6Features");
　　　Iterable sourcefiles = fileManager.getJavaFileObjects(JAVA_SOURCE_FILE);
　　　compiler.getTask(null, fileManager, null, null, null, sourcefiles).call();
　　　fileManager.close();
　　　Class.forName(JAVA_CLASS_NAME).newInstance();//创建动态编译得到的DynamicObject类的实例
　　} catch (Exception ex) {
　　　ex.printStackTrace();
　　}
　}

　public static void generateJavaClass(){
　　try {
　　　FileWriter fw = new FileWriter(JAVA_SOURCE_FILE);
　　　BufferedWriter bw = new BufferedWriter(fw);
　　　bw.write("public class "+JAVA_CLASS_NAME+"{");
　　　bw.newLine();
　　　bw.write("public "+JAVA_CLASS_NAME+"(){System.out.println(\"In the constructor of DynamicObject\");}}");
　　　bw.flush();
　　　bw.close();
　　} catch (IOException ex) {
　　　ex.printStackTrace();
　　}
　}
}


程序运行后，会产生DynamicObject.java和DynamicObject.class两个文件，并在控制台输出：

　　In the constructor of DynamicObject

加上classloader使用那将使你的程序将完全具备动态的能力!

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Thu, 27 Dec 2007 10:17:39 +0800 http://liyong0527.javaeye.com/blog/151131 http://liyong0527.javaeye.com/blog/151131 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/151130  发表时间: 2007年12月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

概述

　　Java 语言从诞生的那天起，就非常注重网络编程方面的应用。随着互联网应用的飞速发展，Java 的基础类库也不断地对网络相关的 API 进行加强和扩展。在 Java SE 6 当中，围绕着 HTTP 协议出现了很多实用的新特性：NTLM 认证提供了一种 Window 平台下较为安全的认证机制；JDK 当中提供了一个轻量级的 HTTP 服务器；提供了较为完善的 HTTP Cookie 管理功能；更为实用的 NetworkInterface；DNS 域名的国际化支持等等。

　　NTLM 认证

　　不可避免，网络中有很多资源是被安全域保护起来的。访问这些资源需要对用户的身份进行认证。下面是一个简单的例子：


import java.net.*;
import java.io.*;

public class Test {
　public static void main(String[] args) throws Exception {
　　URL url = new URL("http://PROTECTED.com");
　　URLConnection connection = url.openConnection();
　　InputStream in = connection.getInputStream();
　　byte[] data = new byte[1024];
　　while(in.read(data)>0)
　　{
　　　//do something for data
　　}
　　in.close();
　}
}


　　当 Java 程序试图从一个要求认证的网站读取信息的时候，也就是说，从联系于 http://Protected.com 这个 URLConnection 的 InputStream 中 read 数据时，会引发 FileNotFoundException。尽管笔者认为，这个 Exception 的类型与实际错误发生的原因实在是相去甚远；但这个错误确实是由网络认证失败所导致的。

　　要解决这个问题，有两种方法：

　　其一，是给 URLConnection 设定一个“Authentication”属性：


String credit = USERNAME + ":" + PASSWORD;
String encoding = new sun.misc.BASE64Encoder().encode (credit.getBytes());
connection.setRequestProperty ("Authorization", "Basic " + encoding);


　　这里假设 http://PROTECTED.COM 使用了基本（Basic）认证类型。

　　从上面的例子，我们可以看出，设定 Authentication 属性还是比较复杂的：用户必须了解认证方式的细节，才能将用户名/密码以一定的规范给出，然后用特定的编码方式加以编码。Java 类库有没有提供一个封装了认证细节，只需要给出用户名/密码的工具呢？

　　这就是我们要介绍的另一种方法，使用 java.net.Authentication 类。

　　每当遇到网站需要认证的时候，HttpURLConnection 都会向 Authentication 类询问用户名和密码。

　　Authentication 类不会知道究竟用户应该使用哪个 username/password 那么用户如何向 Authentication 类提供自己的用户名和密码呢?

　　提供一个继承于 Authentication 的类，实现 getPasswordAuthentication 方法，在 PasswordAuthentication 中给出用户名和密码：


class DefaultAuthenticator extends Authenticator {
　public PasswordAuthentication getPasswordAuthentication () {
　　return new PasswordAuthentication ("USER", "PASSWORD".toCharArray());
　}
}


　　然后，将它设为默认的（全局）Authentication:


Authenticator.setDefault (new DefaultAuthenticator());


　　那么，不同的网站需要不同的用户名/密码又怎么办呢?

　　Authentication 提供了关于认证发起者的足够多的信息，让继承类根据这些信息进行判断，在 getPasswordAuthentication 方法中给出了不同的认证信息：


getRequestingHost()
getRequestingPort()
getRequestingPrompt()
getRequestingProtocol()
getRequestingScheme()
getRequestingURL()
getRequestingSite()
getRequestorType()


　　另一件关于 Authentication 的重要问题是认证类型。不同的认证类型需要 Authentication 执行不同的协议。至 Java SE 6.0 为止，Authentication 支持的认证方式有：


HTTP Basic authentication
HTTP Digest authentication
NTLM
Http SPNEGO Negotiate
Kerberos
NTLM


　　这里我们着重介绍 NTLM。

　　NTLM 是 NT LAN Manager 的缩写。早期的 SMB 协议在网络上明文传输口令，这是很不安全的。微软随后提出了 WindowsNT 挑战/响应验证机制，即 NTLM。

　　NTLM 协议是这样的：

　　·客户端首先将用户的密码加密成为密码散列；

　　·客户端向服务器发送自己的用户名，这个用户名是用明文直接传输的；

　　·服务器产生一个 16 位的随机数字发送给客户端，作为一个 challenge（挑战） ；

　　·客户端用步骤1得到的密码散列来加密这个 challenge ，然后把这个返回给服务器；

　　·服务器把用户名、给客户端的 challenge 、客户端返回的 response 这三个东西，发送域控制器 ；

　　·域控制器用这个用户名在 SAM 密码管理库中找到这个用户的密码散列，然后使用这个密码散列来加密 challenge；

　　·域控制器比较两次加密的 challenge ，如果一样，那么认证成功；

　　Java 6 以前的版本，是不支持 NTLM 认证的。用户若想使用 HttpConnection 连接到一个使用有 Windows 域保护的网站时，是无法通过 NTLM 认证的。另一种方法，是用户自己用 Socket 这样的底层单元实现整个协议过程，这无疑是十分复杂的。

　　终于，Java 6 的 Authentication 类提供了对 NTLM 的支持。使用十分方便，就像其他的认证协议一样：


class DefaultAuthenticator extends Authenticator {
　private static String username = "username ";
　private static String domain = "domain ";
　private static String password = "password ";

　public PasswordAuthentication getPasswordAuthentication() {
　　String usernamewithdomain = domain + "/ "+username;
　　return (new PasswordAuthentication(usernamewithdomain, password.toCharArray()));
　}
}


　　这里，根据 Windows 域账户的命名规范，账户名为域名+”/”+域用户名。如果不想每生成 PasswordAuthentication 时，每次添加域名，可以设定一个系统变量名“http.auth.ntlm.domain“。

　　Java 6 中 Authentication 的另一个特性是认证协商。目前的服务器一般同时提供几种认证协议，根据客户端的不同能力，协商出一种认证方式。比如，IIS 服务器会同时提供 NTLM with kerberos 和 NTLM 两种认证方式，当客户端不支持 NTLM with kerberos 时，执行 NTLM 认证。

　　目前，Authentication 的默认协商次序是：

GSS/SPNEGO -> Digest -> NTLM -> Basic

　　那么 kerberos 的位置究竟在哪里呢?

　　事实上，GSS/SPNEGO 以 JAAS 为基石，而后者实际上就是使用 kerberos 的。

　　轻量级 HTTP 服务器

　　Java 6 还提供了一个轻量级的纯 Java Http 服务器的实现。下面是一个简单的例子：


public static void main(String[] args) throws Exception{
　HttpServerProvider httpServerProvider = HttpServerProvider.provider();
　InetSocketAddress addr = new InetSocketAddress(7778);
　HttpServer httpServer = httpServerProvider.createHttpServer(addr, 1);
　httpServer.createContext("/myapp/", new MyHttpHandler());
　httpServer.setExecutor(null);
　httpServer.start();
　System.out.println("started");
}

static class MyHttpHandler implements HttpHandler{
　public void handle(HttpExchange httpExchange) throws IOException {
　　String response = "Hello world!";
　　httpExchange.sendResponseHeaders(200, response.length());
　　OutputStream out = httpExchange.getResponseBody();
　　out.write(response.getBytes());
　　out.close();
　}
}


　　然后，在浏览器中访问 http://localhost:7778/myapp/，我们得到：


图一 浏览器显示

　　首先，HttpServer 是从 HttpProvider 处得到的，这里我们使用了 JDK 6 提供的实现。用户也可以自行实现一个 HttpProvider 和相应的 HttpServer 实现。

　　其次，HttpServer 是有上下文（context）的概念的。比如，http://localhost:7778/myapp/ 中“/myapp/”就是相对于 HttpServer Root 的上下文。对于每个上下文，都有一个 HttpHandler 来接收 http 请求并给出回答。

　　最后，在 HttpHandler 给出具体回答之前，一般先要返回一个 Http head。这里使用 HttpExchange.sendResponseHeaders(int code, int length)。其中 code 是 Http 响应的返回值，比如那个著名的 404。length 指的是 response 的长度，以字节为单位。

Cookie 管理特性

　　Cookie 是 Web 应用当中非常常用的一种技术， 用于储存某些特定的用户信息。虽然，我们不能把一些特别敏感的信息存放在 Cookie 里面，但是，Cookie 依然可以帮助我们储存一些琐碎的信息，帮助 Web 用户在访问网页时获得更好的体验，例如个人的搜索参数，颜色偏好以及上次的访问时间等等。网络程序开发者可以利用 Cookie 来创建有状态的网络会话（Stateful Session）。 Cookie 的应用越来越普遍。在 Windows 里面，我们可以在“Documents And Settings”文件夹里面找到IE使用的 Cookie，假设用户名为 admin，那么在 admin 文件夹的 Cookies 文件夹里面，我们可以看到名为“admin@(domain)”的一些文件，其中的 domain 就是表示创建这些 Cookie 文件的网络域， 文件里面就储存着用户的一些信息。

　　JavaScript 等脚本语言对 Cookie 有着很不错的支持。 .NET 里面也有相关的类来支持开发者对 Cookie 的管理。 不过，在 Java SE 6 之前， Java一直都没有提供 Cookie 管理的功能。在 Java SE 5 里面， java.net 包里面有一个 CookieHandler 抽象类，不过并没有提供其他具体的实现。到了 Java SE 6， Cookie 相关的管理类在 Java 类库里面才得到了实现。有了这些 Cookie 相关支持的类，Java 开发者可以在服务器端编程中很好的操作 Cookie， 更好的支持 HTTP 相关应用，创建有状态的 HTTP 会话。

　　·用 HttpCookie 代表 Cookie

　　java.net.HttpCookie 类是 Java SE 6 新增的一个表示 HTTP Cookie 的新类， 其对象可以表示 Cookie 的内容， 可以支持所有三种 Cookie 规范：

　　Netscape 草案
　　RFC 2109 - http://www.ietf.org/rfc/rfc2109.txt
　　RFC 2965 - http://www.ietf.org/rfc/rfc2965.txt
　　这个类储存了 Cookie 的名称，路径，值，协议版本号，是否过期，网络域，最大生命期等等信息。

　　·用 CookiePolicy 规定 Cookie 接受策略

　　java.net.CookiePolicy 接口可以规定 Cookie 的接受策略。 其中唯一的方法用来判断某一特定的 Cookie 是否能被某一特定的地址所接受。 这个类内置了 3 个实现的子类。一个类接受所有的 Cookie，另一个则拒绝所有，还有一个类则接受所有来自原地址的 Cookie。

　　·用CookieStore 储存 Cookie

　　java.net.CookieStore 接口负责储存和取出 Cookie。 当有 HTTP 请求的时候，它便储存那些被接受的 Cookie； 当有 HTTP 回应的时候，它便取出相应的 Cookie。 另外，当一个 Cookie 过期的时候，它还负责自动删去这个 Cookie。

　　·用 CookieManger/CookieHandler 管理 Cookie

　　java.net.CookieManager 是整个 Cookie 管理机制的核心，它是 CookieHandler 的默认实现子类。下图显示了整个 HTTP Cookie 管理机制的结构：



图 2. Cookie 管理类的关系

　　一个 CookieManager 里面有一个 CookieStore 和一个 CookiePolicy，分别负责储存 Cookie 和规定策略。用户可以指定两者，也可以使用系统默认的 CookieManger。

　　例子

　　下面这个简单的例子说明了 Cookie 相关的管理功能：


// 创建一个默认的 CookieManager
CookieManager manager = new CookieManager();

// 将规则改掉，接受所有的 Cookie
manager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);

// 保存这个定制的 CookieManager
CookieHandler.setDefault(manager);

// 接受 HTTP 请求的时候，得到和保存新的 Cookie
HttpCookie cookie = new HttpCookie("...(name)...","...(value)...");
manager.getCookieStore().add(uri, cookie);

// 使用 Cookie 的时候：
// 取出 CookieStore
CookieStore store = manager.getCookieStore();

// 得到所有的 URI
List<URI> uris = store.getURIs();
for (URI uri : uris) {
// 筛选需要的 URI
// 得到属于这个 URI 的所有 Cookie
List<HttpCookie> cookies = store.get(uri);
for (HttpCookie cookie : cookies) {
　// 取出了 Cookie
}
}

// 或者，取出这个 CookieStore 里面的全部 Cookie
// 过期的 Cookie 将会被自动删除
List<HttpCookie> cookies = store.getCookies();
for (HttpCookie cookie : cookies) {
　// 取出了 Cookie
}


其他新特性

　　·NetworkInterface 的增强

　　从 Java SE 1.4 开始，JDK 当中出现了一个网络工具类 java.net.NetworkInterface，提供了一些网络的实用功能。 在 Java SE 6 当中，这个工具类得到了很大的加强，新增了很多实用的方法。例如：

　　public boolean isUp()
　　用来判断网络接口是否启动并运行

　　public boolean isLoopback()
　　用来判断网络接口是否是环回接口（loopback）

　　public boolean isPointToPoint()
　　用来判断网络接口是否是点对点（P2P）网络

　　public boolean supportsMulticast()
　　用来判断网络接口是否支持多播

　　public byte[] getHardwareAddress()
　　用来得到硬件地址（MAC）

　　public int getMTU()
　　用来得到最大传输单位（MTU，Maximum Transmission Unit）

　　public boolean isVirtual()
　　用来判断网络接口是否是虚饨涌?

　　关于此工具类的具体信息，请参考 Java SE 6 相应文档（见 参考资源）。

　　·域名的国际化

　　在最近的一些 RFC 文档当中，规定 DNS 服务器可以解析除开 ASCII 以外的编码字符。有一个算法可以在这种情况下做 Unicode 与 ASCII 码之间的转换，实现域名的国际化。java.net.IDN 就是实现这个国际化域名转换的新类，IDN 是“国际化域名”的缩写（internationalized domain names）。这个类很简单，主要包括 4 个静态函数，做字符的转换。

　　结束语

　　Java SE 6 有着很多 HTTP 相关的新特性，使得 Java SE 平台本身对网络编程，尤其是基于 HTTP 协议的因特网编程，有了更加强大的支持。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Thu, 27 Dec 2007 10:16:18 +0800 http://liyong0527.javaeye.com/blog/151130 http://liyong0527.javaeye.com/blog/151130 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/148317  发表时间: 2007年12月14日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Apache CXF Developing a Service using JAX-WS
two approaches:
I.WSDL First Development
Generate starting point code.
Implement the service's operations.
Publish the implemented service.
II.Java First Development

Create a Service Endpoint Interface (SEI) that defines the methods you wish to expose as a service.
Add the required annotations to your code.
Generate the WSDL contract for your service.
Publish the service.
注意事项：
JAX-WS relies on the annotation feature of Java 5. 通过对Interface和implement class添加annotation来映射wsdl.
使用Java First Development，首先要创建SEI和实现类。
然后添加annotation
@WebService
name：用于Interface，属映射到wsdl:portType element的name属性。
targetNamespace：用于Interface和implement，如果不指定，缺省会使用包名做为wsdl名空间。
serviceName：用于implement，表示wsdl服务名。
portName：用于implement，表示wsdl:port 的name属性。
endpointInterface：用于implement，指定Interface全名，包括包名。
如果Service Endpoint Interface中包含用户自定义的复杂类型，如Address，Role etc.
@SOAPBinding如果用document style（缺省），parameterStyle要使用ParameterStyle.BARW（缺省是ParameterStyle.WRAPPED ），如果用RPC style,则只能使用ParameterStyle.WRAPPED。
@WebMethod(exclude=true)可以将不希望暴露的方法屏蔽。
对于简单的web service,其他annotation可以省略不用。

Property Values Description
style Style.DOCUMENT (default)
Style.RPC Specifies the style of the SOAP message. If RPC style is specified, each message part within the SOAP body is a parameter or return value and will appear inside a wrapper element within the soap:body element. The message parts within the wrapper element correspond to operation parameters and must appear in the same order as the parameters in the operation. If DOCUMENT style is specified, the contents of the SOAP body must be a valid XML document, but its form is not as tightly constrained.
use Use.LITERAL (default)
Use.ENCODED Specifies how the data of the SOAP message is streamed.
parameterStyle ParameterStyle.BARE
ParameterStyle.WRAPPED (default) Specifies how the method parameters, which correspond to message parts in a WSDL contract, are placed into the SOAP message body. A parameter style of BARE means that each parameter is placed into the message body as a child element of the message root. A parameter style of WRAPPED means that all of the input parameters are wrapped into a single element on a request message and that all of the output parameters are wrapped into a single element in the response message. If you set the style to RPC you must use the WRAPPED parameter style.


This example will lead you through creating your first service with Spring. You'll learn how to:

Set up your build for CXF
Writing a simple JAX-WS service
Set up the HTTP transport
This example corresponds to the spring_http example in the CXF distribution.

Setting up your build
Open up your favorite IDE and create a new project. The first thing we need to do is add the necessary CXF dependencies to the project. You can find these dependencies in the CXF distribution in the lib directory.

commons-logging-1.1.jar
geronimo-activation_1.1_spec-1.0-M1.jar (or Sun's Activation jar)
geronimo-annotation_1.0_spec-1.1.jar (JSR 250)
geronimo-javamail_1.4_spec-1.0-M1.jar (or Sun's JavaMail jar)
geronimo-servlet_2.5_spec-1.1-M1.jar (or Sun's Servlet jar)
geronimo-ws-metadata_2.0_spec-1.1.1.jar (JSR 181)
jaxb-api-2.0.jar
jaxb-impl-2.0.5.jar
jaxws-api-2.0.jar
saaj-api-1.3.jar
saaj-impl-1.3.jar
stax-api-1.0.1.jar
wsdl4j-1.6.1.jar
wstx-asl-3.2.1.jar
XmlSchema-1.2.jarThe Spring jars:

aopalliance-1.0.jar
spring-core-2.0.4.jar
sprint-beans-2.0.4.jar
spring-context-2.0.4.jar
spring-web-2.0.4.jarAnd the CXF jar:

cxf-2.0-incubator.jarWriting your Service
First we'll write our service interface. It will have one operation called "sayHello" which says "Hello" to whoever submits their name.

package demo.spring;

import javax.jws.WebService;

@WebService
public interface HelloWorld {
String sayHi(String text);
}Our implementation will then look like this:

package demo.spring;

import javax.jws.WebService;

@WebService(endpointInterface = "demo.spring.HelloWorld")
public class HelloWorldImpl implements HelloWorld {

public String sayHi(String text) {
return "Hello " + text;
}
}The @WebService annotation on the implementation class lets CXF know which interface we want to create our WSDL with. In this case its simply our HelloWorld interface.

Declaring your server beans
CXF contains support for "nice XML" within Spring 2.0. For the JAX-WS side of things, we have a <jaxws:endpoint> bean which sets up a server side endpoint.

Lets create a "beans.xml" file in our WEB-INF directory which declares an endpoint bean:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

<jaxws:endpoint
id="helloWorld"
implementor="demo.spring.HelloWorldImpl"
address="/HelloWorld" />

</beans>The bean is pretty self explanatory. The id becomes the id of the bean in the Spring context. The serviceClass property is our implementation class. Finally, the address property specifies the location which we want to host our service at. This can be either a full address with host & port or just a path.

To provide a bean name instead of a classname as an implementor, simply supply the bean-name prepended with "#", e.g. implementor="#myBean".

Setting up the Servlet
We'll need to add two things to our web.xml. First, the Spring ContextLoaderLister. This starts Spring and loads our beans.xml file. We can specify where our file is via a <context-param>. The second thing is the CXF Servlet.

<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/beans.xml</param-value>
</context-param>

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<servlet>
<servlet-name>CXFServlet</servlet-name>
<display-name>CXF Servlet</display-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>It is important to note that the address that you chose for your endpoint bean must be one your servlet listens on. For instance, if my Servlet was register for "/some-services/*" but my address was "/more-services/HelloWorld", there is no way CXF could receive a request.

Create a Client
CXF includes a JaxWsProxyFactory bean which create a client for you from your service interface. You simply need to tell it what your service class is (the HelloWorld interface in this case) and the URL of your service. You can then create a client bean via the JaxWsProxyFactory bean by calling it's create() method.

Here's an example:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schema/jaxws.xsd">

<bean id="client" class="demo.spring.HelloWorld"
factory-bean="clientFactory" factory-method="create"/>

<bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
<property name="serviceClass" value="demo.spring.HelloWorld"/>
<property name="address" value="http://localhost:9002/HelloWorld"/>
</bean>

</beans>If you were going to access your client you could now simply pull it out of the Spring context (or better yet, inject it into your application using Spring!):

ApplicationContext context = ...; // your Spring ApplicationContext
HellWorld client = (HelloWorld) context.getBean("client");

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Fri, 14 Dec 2007 13:22:35 +0800 http://liyong0527.javaeye.com/blog/148317 http://liyong0527.javaeye.com/blog/148317 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/147765  发表时间: 2007年12月12日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

线程是被个别创建的，但可以将它们归类到线程组中，以便于调试和监视。只能在创建线程的同时将它与一个线程组相关联。在使用大量线程的程序中，使用线程组组织线程可能很有帮助。可以将它们看作是计算机上的目录和文件结构。

线程间发信

当线程在继续执行前需要等待一个条件时，仅有 synchronized 关键字是不够的。虽然 synchronized 关键字阻止并发更新一个对象，但它没有实现线程间发信。Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()。以全球气候预测程序为例。这些程序通过将地球分为许多单元，在每个循环中，每个单元的计算都是隔离进行的，直到这些值趋于稳定， 然后相邻单元之间就会交换一些数据。所以，从本质上讲，在每个循环中各个线程都必须等待所有线程完成各自的任务以后才能进入下一个循环。这个模型称为 屏蔽同步，下例说明了这个模型：

屏蔽同步

public class BSync {　int totalThreads;　int currentThreads;　public BSync(int x) {　　totalThreads = x;　　currentThreads = 0;　}　public synchronized void waitForAll() {　　currentThreads++;　　if(currentThreads < totalThreads) {　　　try {　　　　wait();　　　} catch (Exception e) {}　　}　　else {　　　currentThreads = 0;　　　notifyAll();　　}　}}


当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止。因此，在前一个示例中，不同的线程在完成它们的工作以后将调用 waitForAll() 函数，最后一个线程将触发 notifyAll() 函数，该函数将释放所有的线程。第三个函数 notify() 只通知一个正在等待的线程，当对每次只能由一个线程使用的资源进行访问限制时，这个函数很有用。但是，不可能预知哪个线程会获得这个通知，因为这取决于 Java 虚拟机 (JVM) 调度算法。

将 CPU 让给另一个线程

当线程放弃某个稀有的资源（如数据库连接或网络端口）时，它可能调用 yield() 函数临时降低自己的优先级，以便某个其他线程能够运行。

守护线程

有两类线程：用户线程和守护线程。用户线程是那些完成有用工作的线程。 守护线程是那些仅提供辅助功能的线程。Thread 类提供了 setDaemon() 函数。Java 程序将运行到所有用户线程终止，然后它将破坏所有的守护线程。在 Java 虚拟机 (JVM) 中，即使在 main 结束以后，如果另一个用户线程仍在运行，则程序仍然可以继续运行。

避免不提倡使用的方法

不提倡使用的方法是为支持向后兼容性而保留的那些方法，它们在以后的版本中可能出 现，也可能不出现。Java 多线程支持在版本 1.1 和版本 1.2 中做了重大修订，stop()、suspend() 和 resume() 函数已不提倡使用。这些函数在 JVM 中可能引入微妙的错误。虽然函数名可能听起来很诱人，但请抵制诱惑不要使用它们。

调试线程化的程序

在线程化的程序中，可能发生的某些常见而讨厌的情况是死锁、活锁、内存损坏和资源耗尽。

死锁

死锁可能是多线程程序最常见的问题。当一个线程需要一个资源而另一个线程持有该资源 的锁时，就会发生死锁。这种情况通常很难检测。但是，解决方案却相当好：在所有的线程中按相同的次序获取所有资源锁。例如，如果有四个资源 ?A、B、C 和 D ? 并且一个线程可能要获取四个资源中任何一个资源的锁，则请确保在获取对 B 的锁之前首先获取对 A 的锁，依此类推。如果“线程 1”希望获取对 B 和 C 的锁，而“线程 2”获取了 A、C 和 D 的锁，则这一技术可能导致阻塞，但它永远不会在这四个锁上造成死锁。

活锁

当一个线程忙于接受新任务以致它永远没有机会完成任何任务时，就会发生活锁。这个线程最终将超出缓冲区并导致程序崩溃。试想一个秘书需要录入一封信，但她一直在忙于接电话，所以这封信永远不会被录入。 内存损坏

如果明智地使用 synchronized 关键字，则完全可以避免内存错误这种气死人的问题。

资源耗尽

某些系统资源是有限的，如文件描述符。多线程程序可能耗尽资源，因为每个线程都可能 希望有一个这样的资源。如果线程数相当大，或者某个资源的侯选线程数远远超过了可用的资源数，则最好使用 资源池。一个最好的示例是数据库连接池。只要线程需要使用一个数据库连接，它就从池中取出一个，使用以后再将它返回池中。资源池也称为 资源库。

调试大量的线程

有时一个程序因为有大量的线程在运行而极难调试。在这种情况下，下面的这个类可能会派上用场：

public class Probe extends Thread {　public Probe() {}　public void run() {　　while(true) {　　　Thread[] x = new Thread[100];　　　Thread.enumerate(x);　　　for(int i=0; i<100; i++) {　　　　Thread t = x[i];　　　　if(t == null)　　　　　break;　　　　else　　　　　System.out.println(t.getName() + "\t" + t.getPriority()+ "\t" + t.isAlive() + "\t" +t.isDaemon());　　　}　　}　}}


限制线程优先级和调度

Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。但是，该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统 策略。在某些情况下，优先级相同的线程分时运行；在另一些情况下，线程将一直运行到结束。请记住，Java 支持 10 个优先级，基层操作系统支持的优先级可能要少得多，这样会造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来完成。通常情况下，请不要依靠线程优先级来控制线程的状态。

小结

本文说明了在 Java 程序中如何使用线程。像是否应该使用线程这样的更重要的问题在很大程序上取决于手头的应用程序。决定是否在应用程序中使用多线程的一种方法是，估计可以并行运行的代码量。并记住以下几点：

使用多线程不会增加 CPU 的能力。但是如果使用 JVM 的本地线程实现，则不同的线程可以在不同的处理器上同时运行（在多 CPU 的机器中），从而使多 CPU 机器得到充分利用。

如果应用程序是计算密集型的，并受 CPU 功能的制约，则只有多 CPU 机器能够从更多的线程中受益。

当应用程序必须等待缓慢的资源（如网络连接或数据库连接）时，或者当应用程序是非交互式的时，多线程通常是有利的。

基于 Internet 的软件有必要是多线程的；否则，用户将感觉应用程序反映迟钝。例如，当开发要支持大量客户机的服务器时，多线程可以使编程较为容易。在这种情况下，每个线 程可以为不同的客户或客户组服务，从而缩短了响应时间。 某些程序员可能在 C 和其他语言中使用过线程，在那些语言中对线程没有语言支持。这些程序员可能通常都被搞得对线程失去了信心。

已有 1 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Wed, 12 Dec 2007 12:33:02 +0800 http://liyong0527.javaeye.com/blog/147765 http://liyong0527.javaeye.com/blog/147765 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/146476  发表时间: 2007年12月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

public static BufferedImage flipHorizontalJ2D(BufferedImage bufferedImage) ...{
int width = bufferedImage.getWidth();
int height = bufferedImage.getHeight();

BufferedImage dstImage = new BufferedImage(width, height, bufferedImage.getType());

AffineTransform affineTransform = new AffineTransform( -1, 0, 0, 1, width, 0);
AffineTransformOp affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);

return affineTransformOp.filter(bufferedImage, dstImage);
}

/**
* 图像竖直翻转。
* @param bufferedImage 原图像。
* @return 返回竖直翻转后的图像。
*/
public static BufferedImage flipVerticalJ2D(BufferedImage bufferedImage) ...{
int width = bufferedImage.getWidth();
int height = bufferedImage.getHeight();

BufferedImage dstImage = new BufferedImage(width, height, bufferedImage.getType());

AffineTransform affineTransform = new AffineTransform(1, 0, 0, -1, 0, height);
AffineTransformOp affineTransformOp = new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);

return affineTransformOp.filter(bufferedImage, dstImage);
}

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Thu, 06 Dec 2007 18:30:18 +0800 http://liyong0527.javaeye.com/blog/146476 http://liyong0527.javaeye.com/blog/146476 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/145951  发表时间: 2007年12月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一:简介

　　本文介绍了Java与.NET开发的Web Services相互调用的技术。本文包括两个部分，第一部分介绍了如何用.NET做客户端调用Java写的Web Services,第二部分介绍了如何用Java做客户端调用.NET开发的Web Services。

　　二:项目需要的工具

　　Windows2000 Server(IIS)

　　Jbuilder9.0( 含有Tomcat , axis)

　　JDK1.4+Java Web Services Develop

　　VS.Net 2003

　　备注:如果没有JBuilder的话就需要自己下载安装Tomcat4.1 以及 Axis的开发包，并做相应配置。由于网上有很多这样的文章，这里就不一一说明了。

　　三:用.NET做客户端调用Java写的Web Services

　　1. 生成一个Java Web Services

　　使用JBuilder 生成一个Web Services是非常简单的，我完全是按照它的帮助做的，只要一步步做下去就可以了。具体路径是Developing Web Services -> tutorials : Web Services(Axis) -> Creating a simple Web Services

　　2. 发布这个Web Services并得到它的WSDL

　　Web Services生成好之后，F9运行这个项目。然后，单击View浏览现有的Web 服务，单击Bean1的WSDL连接，我们可以在浏览器中察看它的WSDL描述。在浏览器地址栏复制WSDL地址，为下一步使用.NET开发客户端调用程序做准备。

　　3. 用VS.NET生成一个.NET的客户端

　　新建一个项目(WinForm,ASP.net都可以)，我在这里使用的是一个Asp.Net项目。在起始页面上放置一个文本输入框用来显示调用Web Services的结果，放置一个按钮，用来单击调用Web Services。然后，选择添加Web 引用，在WSDL一栏中把刚才得到的WSDL地址复制过来，Web 引用的名称输入JavaService，单击添加引用按钮就可以了。此时，我们可以在VS.net 的Solution Explore中看到这个Web 引用。

　　在按钮的单击事件中输入下列代码:

　　JavaService.Bean1 bean = new JavaService.Bean1();
　　TextBox1.Text = bean.getSample.ToString ();

　　这样，一个.NET客户端就完成了，测试一下，工作正常，OK.

四:用Java做客户端调用.NET写的 Web Services

　　有了上面的成功，使我以为用Java做客户端调用也是一件十分容易的事情，可实际情况却耗费了我两天时间才得以实现。

　　1. 用VS.NET新建一个Asp Web Services工程，添加一个web 服务，命名为SumService.asmx。新增一个web method，代码如下:

　　[WebMethod]
　　public int IntAdd(int a,int b)
　　{
　　return a+b ;
　　}

　　然后运行它，并利用IE进行测试成功。

　　2. 打开jbuilder9.0,新建一个项目，添加一个java class ，命名为TestNetService，输入下列代码:

package MyWebServiceJavaClient;
import java.util.Date;
import java.text.DateFormat;
import java.util.Date;
import java.text.DateFormat;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import javax.xml.namespace.QName;
import java.lang.Integer;
import javax.xml.rpc.ParameterMode;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2004
* Company:
* @author not attributable
* @version 1.0
*/
public class TestNetService {
public TestNetService() {
}
public static void main(String[] args) {
try {
Integer i = new Integer(1);
Integer j = new Integer(2);
String endpoint="http://localhost/MyServices/WebServiceTest/SumService.asmx";
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
call.setOperationName(new QName("http://www.my.com/SU","IntAdd"));
call.addParameter("a",org.apache.axis.encoding.XMLType.XSD_DATE,javax.xml.rpc.ParameterMode.IN);
call.addParameter("b",org.apache.axis.encoding.XMLType.XSD_DATE,javax.xml.rpc.ParameterMode.IN);
call.setReturnType(org.apache.axis.encoding.XMLType.XSD_INT);
call.setUseSOAPAction(true);
call.setSOAPActionURI("http://www.my.com/Rpc");
Integer k = (Integer)call.invoke(new Object[]{i,j});
System.out.println( "result is " + k.toString() + ".");
}
catch (Exception e) {System.err.println(e.toString());}
}
}

　运行上面的java客户端程序，你会发现系统会抛出一个SoapAction异常。奇怪，怎么会错误呢?想到了我开发的asp web services没有指定SoapAction，于是在SumService.asmx中的 [web method] 的上一行添加下列代码:

[SoapRpcMethod(Action="http://www.my.com/Rpc",RequestNamespace="http://www.my.com/SU",ResponseNamespace="http://www.my.com/SU")]

　　重新编译运行asp web services后，在执行java程序，这时会发现输出了正确的结果3。

　　这样，用java调用.net生成的web services也算初步完成了，好像也不是很复杂是吧。其实，在实际工作中，我一开始并没有在网上找到一个很好的代码例子，全部是依靠jbuilder 和 axis的帮助完成的, 可总是提示什么找不到相应的SoapAction。而实际上，我在运行了asp web services后是可以在IE浏览器中看到那个SoapAction的。我试验过将默认的SoapAction拷贝到java代码中，但是java客户端依然抛出同样的异常，这要我也很迷惑。

　　五:总结

　　经过两天的试验，终于从技术上明确了通过Web Services实现.net 与 java的互通是可能的。当然有几点是需要注意的:

　　1. 在提供Web Services的时候，尽量使用xml schema中支持的变量类型做参数。如果使用.net 中的dataset这种类型，对于java来说解析起来将是一个灾难，当然，理论上是可以解析的。但是从效率角度来说，在Web Services与客户端交换信息的过程中，始终有一个序列化和反序列化的问题。如果使用dataset这种类型，系统还需要对它进行序列化操作，这将是一个很耗费资源的过程。而使用string类型将简单很多。

　　2. 如果使用了soap header等扩展功能，例如使用了微软提供的WSE技术，它们之间的相互通信需要作特殊处理。



一:简介

　　本文介绍了Java与.NET开发的Web Services相互调用的技术。本文包括两个部分，第一部分介绍了如何用.NET做客户端调用Java写的Web Services,第二部分介绍了如何用Java做客户端调用.NET开发的Web Services。

　　二:项目需要的工具

　　Windows2000 Server(IIS)

　　Jbuilder9.0( 含有Tomcat , axis)

　　JDK1.4+Java Web Services Develop

　　VS.Net 2003

　　备注:如果没有JBuilder的话就需要自己下载安装Tomcat4.1 以及 Axis的开发包，并做相应配置。由于网上有很多这样的文章，这里就不一一说明了。

　　三:用.NET做客户端调用Java写的Web Services

　　1. 生成一个Java Web Services

　　使用JBuilder 生成一个Web Services是非常简单的，我完全是按照它的帮助做的，只要一步步做下去就可以了。具体路径是Developing Web Services -> tutorials : Web Services(Axis) -> Creating a simple Web Services

　　2. 发布这个Web Services并得到它的WSDL

　　Web Services生成好之后，F9运行这个项目。然后，单击View浏览现有的Web 服务，单击Bean1的WSDL连接，我们可以在浏览器中察看它的WSDL描述。在浏览器地址栏复制WSDL地址，为下一步使用.NET开发客户端调用程序做准备。

　　3. 用VS.NET生成一个.NET的客户端

　　新建一个项目(WinForm,ASP.net都可以)，我在这里使用的是一个Asp.Net项目。在起始页面上放置一个文本输入框用来显示调用Web Services的结果，放置一个按钮，用来单击调用Web Services。然后，选择添加Web 引用，在WSDL一栏中把刚才得到的WSDL地址复制过来，Web 引用的名称输入JavaService，单击添加引用按钮就可以了。此时，我们可以在VS.net 的Solution Explore中看到这个Web 引用。

　　在按钮的单击事件中输入下列代码:

　　JavaService.Bean1 bean = new JavaService.Bean1();
　　TextBox1.Text = bean.getSample.ToString ();

　　这样，一个.NET客户端就完成了，测试一下，工作正常，OK.

四:用Java做客户端调用.NET写的 Web Services

　　有了上面的成功，使我以为用Java做客户端调用也是一件十分容易的事情，可实际情况却耗费了我两天时间才得以实现。

　　1. 用VS.NET新建一个Asp Web Services工程，添加一个web 服务，命名为SumService.asmx。新增一个web method，代码如下:

　　[WebMethod]
　　public int IntAdd(int a,int b)
　　{
　　return a+b ;
　　}

　　然后运行它，并利用IE进行测试成功。

　　2. 打开jbuilder9.0,新建一个项目，添加一个java class ，命名为TestNetService，输入下列代码:

package MyWebServiceJavaClient;
import java.util.Date;
import java.text.DateFormat;
import java.util.Date;
import java.text.DateFormat;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import javax.xml.namespace.QName;
import java.lang.Integer;
import javax.xml.rpc.ParameterMode;
/**
* Title:
* Description:
* Copyright: Copyright (c) 2004
* Company:
* @author not attributable
* @version 1.0
*/
public class TestNetService {
public TestNetService() {
}
public static void main(String[] args) {
try {
Integer i = new Integer(1);
Integer j = new Integer(2);
String endpoint="http://localhost/MyServices/WebServiceTest/SumService.asmx";
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
call.setOperationName(new QName("http://www.my.com/SU","IntAdd"));
call.addParameter("a",org.apache.axis.encoding.XMLType.XSD_DATE,javax.xml.rpc.ParameterMode.IN);
call.addParameter("b",org.apache.axis.encoding.XMLType.XSD_DATE,javax.xml.rpc.ParameterMode.IN);
call.setReturnType(org.apache.axis.encoding.XMLType.XSD_INT);
call.setUseSOAPAction(true);
call.setSOAPActionURI("http://www.my.com/Rpc");
Integer k = (Integer)call.invoke(new Object[]{i,j});
System.out.println( "result is " + k.toString() + ".");
}
catch (Exception e) {System.err.println(e.toString());}
}
}

　运行上面的java客户端程序，你会发现系统会抛出一个SoapAction异常。奇怪，怎么会错误呢?想到了我开发的asp web services没有指定SoapAction，于是在SumService.asmx中的 [web method] 的上一行添加下列代码:

[SoapRpcMethod(Action="http://www.my.com/Rpc",RequestNamespace="http://www.my.com/SU",ResponseNamespace="http://www.my.com/SU")]

　　重新编译运行asp web services后，在执行java程序，这时会发现输出了正确的结果3。

　　这样，用java调用.net生成的web services也算初步完成了，好像也不是很复杂是吧。其实，在实际工作中，我一开始并没有在网上找到一个很好的代码例子，全部是依靠jbuilder 和 axis的帮助完成的, 可总是提示什么找不到相应的SoapAction。而实际上，我在运行了asp web services后是可以在IE浏览器中看到那个SoapAction的。我试验过将默认的SoapAction拷贝到java代码中，但是java客户端依然抛出同样的异常，这要我也很迷惑。

　　五:总结

　　经过两天的试验，终于从技术上明确了通过Web Services实现.net 与 java的互通是可能的。当然有几点是需要注意的:

　　1. 在提供Web Services的时候，尽量使用xml schema中支持的变量类型做参数。如果使用.net 中的dataset这种类型，对于java来说解析起来将是一个灾难，当然，理论上是可以解析的。但是从效率角度来说，在Web Services与客户端交换信息的过程中，始终有一个序列化和反序列化的问题。如果使用dataset这种类型，系统还需要对它进行序列化操作，这将是一个很耗费资源的过程。而使用string类型将简单很多。

　　2. 如果使用了soap header等扩展功能，例如使用了微软提供的WSE技术，它们之间的相互通信需要作特殊处理。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Tue, 04 Dec 2007 17:53:19 +0800 http://liyong0527.javaeye.com/blog/145951 http://liyong0527.javaeye.com/blog/145951 liyong0527 作者: liyong0527  链接：http://liyong0527.javaeye.com/blog/145949  发表时间: 2007年12月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

如果是 jar 包，在 Plugin 中配置

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<addMavenDescriptor>false</addMavenDescriptor>
</archive>
</configuration>
</plugin>
</plugins>
</build>

如果是 war 包，在 Plugin 中配置

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<configuration>
<archive>
<addMavenDescriptor>false</addMavenDescriptor>
</archive>
</configuration>
</plugin>
</plugins>
</build>

这个是在 maven-archiver 中设置的，可以查看代码。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Tue, 04 Dec 2007 17:47:39 +0800 http://liyong0527.javaeye.com/blog/145949 http://liyong0527.javaeye.com/blog/145949