静态内部类

静态内部类

静态内部类定义在类中,任何方法外,用static定义。

静态内部类只能访问外部类的静态成员。

生成(new)一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。

静态内部类的对象可以直接生成:  Outer.Inner in=new Outer.Inner();  而不需要通过生成外部类对象来生成。

这样实际上使静态内部类成为了一个顶级类。

静态内部类不可用private来进行定义

注意:当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。

用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。

例子:  对于两个类,拥有相同的方法:
class People  {  run();  }

interface Machine{  run();  }

此时有一个robot类:

class Robot extends People implement Machine.  此时run()不可直接实现。

interface Machine  {  void run();  }

class Person  {  void run(){System.out.println(“run”);}  }

class Robot extends Person  {

private class MachineHeart implements Machine  {

publicvoid run(){System.out.println(“heart run”);}

}

publicvoid run(){System.out.println(“Robot run”);}

Machine getMachine(){returnnew MachineHeart();}

}

class Test  {

publicstaticvoid main(String[] args)  {

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

PS:
java中的静态类只存在其内部类中。
为什么会有内部静态类的存在?
因为非静态内部类只能声明非静态成员或方法,而静态内部类则可拥有静态的成员和方法。
但静态内部类中只能引用其外部类的静态成员或变量。因为内部静态类并不与外部类对象关联。
此外,内部类的继承与接口与外部类独立,解决了多继承的问题。
PS1:

内部类的作用:

1、隐藏你不想让别人知道的操作,也即封装性。

2、一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!
内部类的功能在于,每个内部类都能独立的继承一个接口的实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多重继承的解决方案变得完整,并且内部类允许继承多个非接口类型(类或抽象类)。通过内部类分别继承一个基类,外部类创建内部类的对象,并使用内部类的方法,变相地实现了多继承。
java内部类有什么好处?为什么需要内部类?
1、举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。

2、真正的原因是这样的,java中的内部类和接口加在一起,可以解决常被C++程序员抱怨java中存在的一个问题:没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

静态内部类和非静态内部类的区别
1、和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。
2、在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。

内部类在封装类被继承时候

首先来看下一下两个类

/*
* @(#)Parant.java    Created on 2011-11-22
* Copyright (c) 2011 ZDSoft Networks, Inc. All rights reserved.
* $Id$
*/
package com.innerextend.www;

/**
* @author gex
* @version $Revision: 1.0 $, $Date: 2011-11-22 下午04:13:21 $
*/
public class Parant {

protected class ParantInner {

public void parantInnerPrint() {
System.out.println("parantInnerPrint");
}
}
}

 


/*
* @(#)Child.java    Created on 2011-11-22
* Copyright (c) 2011 ZDSoft Networks, Inc. All rights reserved.
* $Id$
*/
package com.innerextend.www;

/**
* @author gex
* @version $Revision: 1.0 $, $Date: 2011-11-22 下午04:20:04 $
*/
public class Child extends Parant {

/**
* @param args
*/
public static void main(String[] args) {
Child c = new Child();
c.childPrint();

}

// 这里注释去掉,会调用这个内部类而不是父类的内部类
// private class ParantInner {
//
// public void parantInnerPrint() {
// System.out.println("childInnerPrint");
// }
// }

public void childPrint() {
ParantInner pi = new ParantInner();
pi.parantInnerPrint();
}

}

我们注意一点,Parent和Child类都在同一个包下,所以在child类中new ParantInner();调用默认的构造函数

 

/**
* 注意这里没有权限修饰,也就是说包内可见,当然也要看子类的修饰以及本来的修饰,取最小的就得了
*/
ParantInner(){
}

 

这样运行下来,本程序没有问题。

但是,如果Parent和Child类不在同一个包下,在child类中new ParantInner()时就会包构造函数不可见,没法子创建,因为不同包下,默认构造函数没法继续下去。

解决方法:

1.在ParantInner内部类中自己创建一个public或则protected的构造函数。

2.就是把父类 子类都放到同个包下了。

ps:一般情况下都是第一种方式来处理。

.properties乱码解决

messages_zh_CN.properties编码格式为utf-8,

但是始终运行出来的是乱码

后来经过java转码工具:D:\test>native2ascii -encoding utf-8 messages_zh_CN.properties

messages_zh_CN_c.properties

将messages_zh_CN.properties内容:

 

register_userId_error_key = 用户名不能为空,必须由字母、数字、下划线构成,且长度在[4,10]范围内

register_password_error_key = 密码不能为空,必须由字母、数字、下划线构成,长度在[4,10]范围内,且不能同用户名相同

register_passwordConfirm_error_key = 密码验证必须和密码一致

register_phone_error_key = 电话必须由数字组成,长度在[7,11]范围内

register_email_error_key = email必须合法

register_address_error_key = 地址长度必须在[4,40]范围内

转化为:
register_userId_error_key = \u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a\uff0c\u5fc5\u987b\u7531\u5b57\u6bcd\u3001\u6570\u5b57\u3001\u4e0b\u5212\u7ebf\u6784\u6210,\u4e14\u957f\u5ea6\u5728[4,10]\u8303\u56f4\u5185
register_password_error_key = \u5bc6\u7801\u4e0d\u80fd\u4e3a\u7a7a\uff0c\u5fc5\u987b\u7531\u5b57\u6bcd\u3001\u6570\u5b57\u3001\u4e0b\u5212\u7ebf\u6784\u6210,\u957f\u5ea6\u5728[4,10]\u8303\u56f4\u5185\uff0c\u4e14\u4e0d\u80fd\u540c\u7528\u6237\u540d\u76f8\u540c
register_passwordConfirm_error_key = \u5bc6\u7801\u9a8c\u8bc1\u5fc5\u987b\u548c\u5bc6\u7801\u4e00\u81f4
register_phone_error_key = \u7535\u8bdd\u5fc5\u987b\u7531\u6570\u5b57\u7ec4\u6210,\u957f\u5ea6\u5728[7,11]\u8303\u56f4\u5185
register_email_error_key = email\u5fc5\u987b\u5408\u6cd5
register_address_error_key = \u5730\u5740\u957f\u5ea6\u5fc5\u987b\u5728[4,40]\u8303\u56f4\u5185
即可正常显示了

 

FileInputStream FileReader

C语言只需要一个File*就可以了,与C不同,java有一系列流类型,其数量超过60种。类库的设计者声称:“有足够的理由为用户提供丰富的流类型的选择:这样做可以减少程序的错误。”例如,在C语言种,许多人认为“将输出流写入一个只读模式的文件”是很常见的错误。(事实上,这并不常见。)

我们认为在C++语言中,流接口设计者避免程序出错的主要“工具”是小心谨慎的态度,在java语言中更是如此。流库的高度复杂性迫使程序设计人员谨小慎微。

1. File类
1)File类介绍(《core java》638页)
File类封装了对用户机器的文件系统进行操作的功能。例如,可以用File类获得文件上次修改的时间移动,或者对文件进行删除、重命名。换句话说,流类关注的是文件内容,而File类关注的是文件在磁盘上的存储。
File类的主要方法有:getName(),getCanonicalFile(),lastModified(),isDerector(),isFile(),getPath()等;

2)File类与FileInputStream类的区别:
流类关注的是文件内容,而File类关注的是文件在磁盘上的存储。

File不属于文件流,只能代表一个文件或是目录的路径名而已。

提示:(《core java》639页)
如果处理文件或者目录名,就应该使用File对象,而不是字符串。例如,File类的equals方法知道一些文件系统对大小写是敏感的,目录尾的“/”字符无关紧要。

自己的领会:
FileInputStream类或者FileReader类的构造函数有多个,其中典型的两个分别为:一个使用File对象为参数;而另一个使用表示路径的String对象作为参数;自己以前一直觉得直接用了String指定路径就可以了,一直不明白为什么很多人都先构造一个File对象,现在终于明白了,“如果处理文件或者目录名,就应该使用File对象,而不是字符串。”!
2. FileInputStream类
1)FileInputStream类介绍:
以字节为单位(非unicode)的流处理。字节序列即:二进制数据。与编码无关,不存在乱码问题。
FileInputStream类的主要方法有:
Read(),read(byte[] b),read(byte[],int off,int len),available();

2)FileInputStream类与FileReader类的区别:
两个类的构造函数的形式和参数都是相同的,参数为File对象或者表示路径的String,它们到底有何区别呢?
 Readers and Writers work only on line based character data, so plain text files.
For anything else, you MUST use Streams.
 JDK5 API:
FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams of characters, consider using FileReader.
FileReader is meant for reading streams of characters. For reading streams of raw bytes, consider using a FileInputStream.

 FileInputStream:以字节流方式读取;FileReader:把文件转换为字符流读入;
 InputStream提供的是字节流的读取,而非文本读取,这是和Reader类的根本区别。用Reader读取出来的是char数组或者String ,使用InputStream读取出来的是byte数组。
 Reader类及其子类提供的字符流的读取char(16位,unicode编码),inputStream及其子类提供字节流的读取byte(8位),所以FileReader类是将文件按字符流的方式读取,FileInputStream则按字节流的方式读取文件;InputStreamReader可以将读如stream转换成字符流方式,是reader和stream之间的桥梁
 最初Java是不支持对文本文件的处理的,为了弥补这个缺憾而引入了Reader和Writer两个类。
 FileInputStream类以二进制输入/输出,I/O速度快且效率搞,但是它的read()方法读到的是一个字节(二进制数据),很不利于人们阅读。
 而FileReader类弥补了这个缺陷,可以以文本格式输入/输出,非常方便;比如可以使用while((ch = filereader.read())!=-1 )循环来读取文件;可以使用BufferedReader的readLine()方法一行一行的读取文本。
 当我们读写文本文件的时候,采用Reader是非常方便的,比如FileReader, InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader,它是字节转换为字符的桥梁。 你可以在构造器重指定编码的方式,如果不指定的话将采用底层操作系统的默认编码方式,例如GBK等。
 FileReader与InputStreamReader涉及编码转换(指定编码方式或者采用os默认编码),可能在不同的平台上出现乱码现象!而FileInputStream以二进制方式处理,不会出现乱码现象.
3)自己的领会:
 如果处理纯文本文件,建议使用FileReader,因为更方便,也更适合阅读;但是要注意编码问题!
 其他情况(处理非纯文本文件),FileInputStream是唯一的选择;FileInputStream是进Socket通讯时会用到很多,如将文件流是Stream的方式传向服务器!

3. FileReader类
1) FileReader类介绍:
InputStreamReader类的子类,所有方法(read()等)都从父类InputStreamReader中继承而来;
2) 与InputStreamReader类的区别:
 自己的领会:
该类与它的父类InputStreamReader的主要不同在于构造函数,主要区别也就在于构造函数!从InputStreamReader的构造函数中看到,参数为InputStream和编码方式,可以看出,当要指定编码方式时,必须使用InputStreamReader类;而FileReader构造函数的参数与FileInputStream同,为File对象或表示path的String,可以看出,当要根据File对象或者String读取一个文件时,用FileReader;我想FileReader子类的作用也就在于这个小分工吧。
3) 一般用法:
FileReader fr = new FileReader(“ming.txt”);
char[] buffer = new char[1024];
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch);
}
4. InputStreamReader类
 以文本格式输入/输出,可以指定编码格式;
 主要方法:
getEncoding(),read();
 一般用法:
InputStreamReader isr = new InputStreamReader(new FileInputStream(“ming.txt”));
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
5. BufferedReader类
 Jdk5 api:
Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
 BufferedReader 由Reader类扩展而来,提供通用的缓冲方式文本读取,而且提供了很实用的readLine,读取分行文本很适合,BufferedReader是针对Reader的,不直接针对文件,也不是只针对文件读取。
 一般用法:
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(“ming.txt”)));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
6. 总结以上内容,得出比较好的规范用法:
1) File file = new File (“hello.txt”);
FileInputStream in=new FileInputStream(file);
2) File file = new File (“hello.txt”);
FileInputStream in=new FileInputStream(file);
InputStreamReader inReader=new InputStreamReader(in);
BufferedReader bufReader=new BufferedReader(inReader);
3) File file = new File (“hello.txt”);
FileReader fileReader=new FileReader(file);
BufferedReader bufReader=new BufferedReader(fileReader);

Android与服务器端数据交互(基于SOAP协议整合android+webservice)

那么什么是webService呢?,它是一种基于SAOP协议的远程调用标准,通过webservice可以将不同操作系统平台,不同语言,不同技术整合到一起。

我们在PC机器java客户端中,需要一些库,比如XFire,Axis2,CXF等等来支持访问WebService,但是这些库并不适合我们资源有限的android手机客户端,做过JAVA ME的人都知道有KSOAP这个第三方的类库,可以帮助我们获取服务器端webService调用,当然KSOAP已经提供了基于android版本的jar包了,那么我们就开始吧:

首先下载KSOAP包:ksoap2-android-assembly-2.5.2-jar-with-dependencies.jar包

然后新建android项目:并把下载的KSOAP包放在android项目的lib目录下:右键->build path->configure build path–选择Libraries,如图:

以下分为七个步骤来调用WebService方法:

第一:实例化SoapObject 对象,指定webService的命名空间(从相关WSDL文档中可以查看命名空间),以及调用方法名称。如:

View Code

//命名空间 private static final String serviceNameSpace="http://WebXml.com.cn/"; //调用方法(获得支持的城市) private static final String getSupportCity="getSupportCity"; //实例化SoapObject对象 SoapObject request=new SoapObject(serviceNameSpace, getSupportCity);

第二步:假设方法有参数的话,设置调用方法参数

request.addProperty(“参数名称”,”参数值”);

第三步:设置SOAP请求信息(参数部分为SOAP协议版本号,与你要调用的webService中版本号一致):

View Code

//获得序列化的Envelope SoapSerializationEnvelope envelope=
new SoapSerializationEnvelope(SoapEnvelope.VER11); envelope.bodyOut=request;

第四步:注册Envelope,

(new MarshalBase64()).register(envelope);

第五步:构建传输对象,并指明WSDL文档URL:

View Code

//请求URL private static final String serviceURL=
"http://www.webxml.com.cn/webservices/weatherwebservice.asmx"; //Android传输对象 AndroidHttpTransport transport=new AndroidHttpTransport(serviceURL); transport.debug=true;

第六步:调用WebService(其中参数为1:命名空间+方法名称,2:Envelope对象):

View Code

transport.call(serviceNameSpace+getWeatherbyCityName, envelope);

第七步:解析返回数据:

View Code

if(envelope.getResponse()!=null){

 

RPC、RMI、SOAP(webService)

RPC(Remote Procedure Call Protocol)——远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在,如TCP或UDP,为通信程序之间携带信息数据。在OSI网络通信模型中,RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

RMI(远程方法调用)

Web Service

在构建和使用Web Service时,主要用到以下几个关键的技术和规则:  1.XML:描述数据的标准方法.  2.SOAP:表示信息交换的协议.  3.WSDL:Web服务描述语言.  4.UDDI(Universal Description, Discovery and Integration):通用描述、发现与集成,它是一种独立于平台的,基于XML语言的用于在互联网上描述商务的协议。

RMI和RPC之间最主要的区别在于方法是如何别调用的。在RMI中,远程接口使每个远程方法都具有方法签名。如果一个方法在服务器上执行,但是没有相匹配的签名被添加到这个远程接口上,那么这个新方法就不能被RMI客户方所调用。在RPC中,当一个请求到达RPC服务器时,这个请求就包含了一个参数集和一个文本值,通常形成“classname.methodname”的形式。这就向RPC服务器表明,被请求的方法在为“classname”的类中,名叫“methodname”。然后RPC服务器就去搜索与之相匹配的类和方法,并把它作为那种方法参数类型的输入。这里的参数类型是与RPC请求中的类型是匹配的。一旦匹配成功,这个方法就被调用了,其结果被编码后返回客户方。

RMI目前使用Java远程消息交换协议JRMP(Java Remote Messaging Protocol)进行通信,但由于JRMP是专为Java对象制定的,因此,RMI对于用非Java语言开发的应用系统的支持不足。不能与用非Java语言书写的对象进行通信。

xml-rpc 这种远程过程调用使用http作为传输协议,XML作为传送信息的编码格式。Xml-Rpc的定义尽可能的保持了简单,但同时能够传送、处理、返回复杂的数据结构。

 

 

 

Spring2.5整合RMI技术-CLIENT端

二、客户端调用测试

客户端调用有两种方式,一种是使用Spring,一种不使用,这里仅介绍使用Spring的情况。

在Spring中配置客户端要调用服务:

 

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans
xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd”>
<bean id=”helloService” class=”org.springframework.remoting.rmi.RmiProxyFactoryBean”>
<property name=”serviceUrl” value=”rmi://192.168.14.117:8088/hello”/>
<property name=”serviceInterface” value=”lavasoft.sturmi.HelloService”/>
</bean>

<bean id=”helloServiceClient” class=”lavasoft.sturmi.HelloClient”>
<property name=”helloService” ref=”helloService”/>
</bean>
</beans>

 

客户端测试代码:

 

package lavasoft.sturmi;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.rmi.RemoteException;

/**
* 通过Spring来调用RMI服务
*
* @author leizhimin 2009-8-17 14:12:46
*/

public class HelloClient {
private HelloService helloService;

public static void main(String[] args) throws RemoteException {
ApplicationContext ctx = newClassPathXmlApplicationContext(“/applicationContext_rmi_client.xml”);
HelloService hs = (HelloService) ctx.getBean(“helloService”);
System.out.println(hs.helloWorld());
System.out.println(hs.sayHelloToSomeBody(“Lavasoft”));
}

public void setHelloService(HelloService helloService) {
this.helloService = helloService;
}
}

 

运行结果:

 

Spring2.5整合RMI技术-SERVER端

Java的RMI技术使用起来比较麻烦,有两点:服务发布和调用服务。

通过Spring的RMI支持,可以非常容易的暴露任何的服务。

下面是之前一篇《Java RMI之HelloWorld篇》文章的基础上,加入了Spring的框架来实现的例子。

环境:jdk1.5

spring-framework-2.5.6.SEC01

所用的第三方包优先从Spring的lib包中获取,以获取最佳的兼容性。

所依赖的jar包:

一、服务端实现

第一服务接口,和以前不一样了,不用实现远程接口了。

 

package lavasoft.sturmi;

/**
* 定义一个远程接口
*
* @author leizhimin 2009-8-17 13:53:38
*/

public interface HelloService {

/**
* 简单的返回“Hello World!”字样
*
* @return 返回“Hello World!”字样
*/

public String helloWorld();

/**
* 一个简单的业务方法,根据传入的人名返回相应的问候语
*
* @param someBodyName 人名
* @return 返回相应的问候语
*/

public String sayHelloToSomeBody(String someBodyName);
}

 

服务实现类

 

package lavasoft.sturmi;

/**
* 远程的接口的实现
*
* @author leizhimin 2009-8-17 13:54:38
*/

public class HelloServiceImpl implements HelloService {
public HelloServiceImpl() {
}

/**
* 简单的返回“Hello World!”字样
*
* @return 返回“Hello World!”字样
*/

public String helloWorld() {
return “Hello World!”;
}

/**
* 一个简单的业务方法,根据传入的人名返回相应的问候语
*
* @param someBodyName 人名
* @return 返回相应的问候语
*/

public String sayHelloToSomeBody(String someBodyName) {
return “你好,” + someBodyName + “!”;
}
}

 

Spring配置rmi服务

 

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>
<bean id=”helloService” class=”lavasoft.sturmi.HelloServiceImpl”/>

<bean id=”serviceExporter” class=”org.springframework.remoting.rmi.RmiServiceExporter”>
<property name=”service” ref=”helloService”/>
<!– 定义服务名 –>
<property name=”serviceName” value=”hello”/>
<property name=”serviceInterface” value=”lavasoft.sturmi.HelloService”/>
<property name=”registryPort” value=”8088″/>
</bean>
</beans>

 

服务端测试

 

package lavasoft.sturmi;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* 通过Spring发布RMI服务
*
* @author leizhimin 2009-8-17 14:22:06
*/

public class HelloHost {
public static void main(String[] args) {
ApplicationContext ctx = newClassPathXmlApplicationContext(“/applicationContext_rmi_server.xml”);
System.out.println(“RMI服务伴随Spring的启动而启动了…..”);
}
}

 

启动后如图所示:

 

DWR 入門與應用(三)

來寫個AJAX版的聊天室吧!先看看直接使用AJAX要如何做到,首先需要一個簡單的聊天室Servlet…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package onlyfun.caterpillar;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.LinkedList;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
 public class ChatRoomServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
     private static LinkedList<Message> messages = new LinkedList<Message>();
     
     public ChatRoomServlet() {
    super(); 
  }
    
    private List<Message> addMessage(String text) {
        if (text != null && text.trim().length() > 0) {
            messages.addFirst(new Message(text));
            while (messages.size() > 10) {
                messages.removeLast();
            }
        }
 
        return messages;
    }
 
    private List<Message> getMessages() {
        return messages;
    }
    
  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Message> list = null;
        
        if("send".equals(request.getParameter("task"))) {
             list = addMessage(request.getParameter("msg"));
        }
        else if("query".equals(request.getParameter("task"))){
             list = getMessages();
        }
 
        PrintWriter out = response.getWriter();
        response.setContentType("text/xml");
        response.setHeader("Cache-Control", "no-cache");
 
        out.println("<response>");
        for(int i = 0; i < list.size(); i++) {
            String msg = list.get(i).getText();
            out.println("<message>" + msg + "</message>");
        }
        out.println("</response>");
  }             
}

Message物件如下…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package onlyfun.caterpillar;
 
public class Message {
    private long id = System.currentTimeMillis();
    private String text;
    
    public Message(String newtext) {
        text = newtext;
        if (text.length() > 256) {
            text = text.substring(0, 256);
        }
        text = text.replace('<', '[');
        text = text.replace('&', '_');
    }
 
    public long getId() {
        return id;
    }
 
    public String getText() {
        return text;
    }
}

Servlet接受訊息新增與查詢,判斷的方式是檢查請求參數task是send或query。

Servlet會以XML傳回目前List當中的訊息,客戶端可以查詢或插入新訊息時,取得目前List中的訊息,接著在web.xml中設定一下…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <servlet>
    <description>
    </description>
    <display-name>
    ChatRoomServlet</display-name>
    <servlet-name>ChatRoomServlet</servlet-name>
    <servlet-class>
    onlyfun.caterpillar.ChatRoomServlet</servlet-class>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>ChatRoomServlet</servlet-name>
    <url-pattern>/ChatRoomServlet</url-pattern>
  </servlet-mapping>
  <session-config>
    <session-timeout>
            30
        </session-timeout>
  </session-config>  
</web-app>

在網頁中,使用者可以在輸入訊息後按下按鈕送出資訊,並在XML回應取得時,將訊息以一列一列的表格方式顯示出來,另外還設定了週期性的輪詢,即使不輸入新訊息,也可以週期性的取得新的聊天訊息…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=BIG5">
<title>Chat Room</title>
 
<script type="text/javascript">
var xmlHttp;
 
function createXMLHttpRequest() {
    if (window.ActiveXObject) {
        xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
    } 
    else if (window.XMLHttpRequest) {
        xmlHttp = new XMLHttpRequest();
    }
}
 
function sendMessage() {
  var msg = document.getElementById("text").value;
  
  if(msg == "") {
    refreshMessage();
    return;
  }
  
  var param = "task=send&msg=" + msg;
  ajaxRequest(param);
  document.getElementById("text").value = "";
}
 
function queryMessage() {
  var param = "task=query";
  ajaxRequest(param);
}
 
function ajaxRequest(param) {
  var url = "ChatRoomServlet?timestamp" + new Date().getTime();
    createXMLHttpRequest();
  xmlHttp.onreadystatechange = refreshMessage;
    xmlHttp.open("POST", url, true);
  xmlHttp.setRequestHeader("Content-Type",
           "application/x-www-form-urlencoded;");
    xmlHttp.send(param);
}
  
function refreshMessage() {
  if(xmlHttp.readyState == 4) {
        if(xmlHttp.status == 200) {
          var messages = xmlHttp.responseXML.getElementsByTagName("message");
  
          var table_body = document.getElementById("dynamicUpdateArea");
      var length = table_body.childNodes.length;
      for (var i = 0; i < length; i++) {
        table_body.removeChild(table_body.childNodes[0]);
      }
      
      var length = messages.length;
          for(var i = length - 1; i >= 0 ; i--) {
              var message = messages[i].firstChild.data;
              var row = createRow(message);
        
              table_body.appendChild(row);                        
          }
      setTimeout("queryMessage()", 2000);
        }
  }
}
 
function createRow(message) {
    var row = document.createElement("tr");
    var cell = document.createElement("td");
    var cell_data = document.createTextNode(message);
    cell.appendChild(cell_data);
    row.appendChild(cell);
    return row;
}
 
</script>
 
</head>
<body>
 
<p>
  Your Message:
  <input id="text"/>
  <input type="button" value="Send"
      onclick="sendMessage()"/>
</p>
 
<p>Messages:</p>
    <table align="left">
        <tbody id="dynamicUpdateArea"></tbody>
    </table>
 
</body>
</html>

簡單抓個畫面…

直接用AJAX,後端用JSP/Servlet,您要對請求參數做些判斷,看看是新增訊息或查詢,並要自行輸出XML,有的沒的…

改成DWR的話,就很簡單了,寫個簡單的Java物件…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package onlyfun.caterpillar;
 
import java.util.LinkedList;
import java.util.List;
 
public class Chat {
  private static LinkedList<Message> messages = new LinkedList<Message>();
 
  public List addMessage(String text) {
    if (text != null && text.trim().length() > 0) {
      messages.addFirst(new Message(text));
      while (messages.size() > 10) {
        messages.removeLast();
      }
    }
 
    return messages;
  }
 
  public List getMessages() {
    return messages;
  }
}

接著…在dwr.xml中開放一下…

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN" "http://www.getahead.ltd.uk/dwr/dwr10.dtd">
 
<dwr>
  <allow>
 
    <create creator="new" javascript="Chat">
      <param name="class" value="onlyfun.caterpillar.Chat"/>
    </create>
    
    <convert converter="bean" match="onlyfun.caterpillar.Message"/>      
  </allow>
</dwr>

使用者取得訊息時,是直接傳回List物件,而List中裝的是Message物件,Message物件是自訂物件,conterver設定為 bean,表示DWR會自動將Message的getter名稱轉換為傳回客戶端的JavaScript物件中的屬性,例如Message中有 getText(),則在客戶端可以用message.text這樣的方式來存取。

接著是簡單的客戶端網頁…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=BIG5">
<title>Insert title here</title>
 
<script src="dwr/interface/Chat.js" type="text/javascript"></script>
<script src="dwr/engine.js" type="text/javascript"></script>
<script src="dwr/util.js" type="text/javascript"></script>
 
<script type="text/javascript">
function sendMessage() {
    var text = DWRUtil.getValue("text");
    DWRUtil.setValue("text", "");
    Chat.addMessage(text, gotMessages);
}
 
function gotMessages(messages) {
    var chatlog = "";
    for (var data in messages) {
        chatlog = "<div>" + messages[data].text +
            "</div>" + chatlog;
    }
    DWRUtil.setValue("chatlog", chatlog);
  setTimeout("queryMessage()", 2000);
}
 
function queryMessage() {
  Chat.getMessages(gotMessages);
}
</script>
 
</head>
<body>
 
<p>
  Your Message:
  <input id="text"/>
  <input type="button" value="Send"
      onclick="sendMessage()"/>
</p>
 
<p>Messages:</p>
<div id="chatlog"></div>
 
</body>
</html>

當List物件傳回時,它成為gotMessages(messages)中的messages物件,而messages物件中包括 Message物件轉換後對應的JavaScript物件,由於我們已經設定了Converter,所以可以用messages[data].text來 取得傳回的訊息…

簡單抓個畫面…

 

DWR 入門與應用(二)

假設您要從資料庫中查詢出一些字串,然後填寫到表單的下拉選單中。

例如一個示意的Java程式如下:

1
2
3
4
5
6
7
8
package onlyfun.caterpillar;
 
public class Option {
  public String[] getOptions() {
                // 實際上這些字串是從資料庫中查到的啦…
    return new String[] {"良葛格", "毛美眉", "米小狗"}; 
  }
}

傳回的字串陣列,您要填寫到下拉選單中,當然,首先我們要在dwr.xml中開發這個物件…

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN" "http://www.getahead.ltd.uk/dwr/dwr10.dtd">
 
<dwr>
  <allow>
    <create creator="new" javascript="OPT">
        <param name="class" value="onlyfun.caterpillar.Option"/>
    </create>  
  </allow>
</dwr>

這是我們的網頁…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=BIG5">
<script src="option.js" type="text/javascript"></script>
<script src="dwr/interface/OPT.js" type="text/javascript"></script>
<script src="dwr/engine.js" type="text/javascript"></script>
<script src="dwr/util.js" type="text/javascript"></script>
 
</head>
 
<body>
    選項: <select id="opts"></select>
</body>
</html>

傳回的字串陣列會填入opts這個select中,我們的option.js如下…

1
2
3
4
5
6
7
8
window.onload = function() {
    OPT.getOptions(populate);  
};
 
function populate(list){
    DWRUtil.removeAllOptions("opts");
    DWRUtil.addOptions("opts", list);
}

夠簡單了…不需要解釋了…

看一下結果…

好啦!我知道有人在說了,這個程式有夠無聊…Dead

改一下!就是個不錯的範例了,例如連動方塊,唔!在Ajax in action中叫啥?Dynamic double combo?…

假設一個會去從資料庫中查詢資料的Java程式示意如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package onlyfun.caterpillar;
 
import java.util.Map;
import java.util.TreeMap;
 
public class Bike {
  private Map<String, String[]> bikes;
  
  public Bike() {
    bikes = new TreeMap<String, String[]>();
    bikes.put("2000", new String[] {"2000 T1", "2000 T2", "2000 T3"});
    bikes.put("2001", new String[] {"2001 A1", "2001 A2"});
    bikes.put("2002", new String[] {"2002 BW1", "2002 BW2", "2002 BW"});
    bikes.put("2003", new String[] {"2003 S320"});
    bikes.put("2004", new String[] {"2004 TA1", "2004 TA2", "2004 TA3"});
  }
  
  public String[] getYears() {
    String[] keys = new String[bikes.size()];
    int i = 0;
    for(String key : bikes.keySet()) {
      keys[i++] = key;
    }
    return keys; 
  }
  
  public String[] getBikes(String year) {
    return bikes.get(year);
  }
}

getYears()跟getBkies()分別表示產品的年份跟型號,這邊用Map模擬,實際上資料是來自資料庫的查詢。

一樣的,在dwr.xml中設定:

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN" "http://www.getahead.ltd.uk/dwr/dwr10.dtd">
 
<dwr>
  <allow>
    <create creator="new" javascript="Bike" scope="application">
        <param name="class" value="onlyfun.caterpillar.Bike"/>
    </create>
  </allow>
</dwr>

我們會有個腳踏車年份與型號查詢頁面:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=BIG5">
<title>Insert title here</title>
  <script type='text/javascript' src='dwr/interface/Bike.js'></script>
  <script type='text/javascript' src='dwr/engine.js'></script>
  <script type='text/javascript' src='dwr/util.js'></script>
  <script type='text/javascript' src='bike.js'></script>
</head>
<body onload="refreshYearList();">
  年份:<select id="years" onchange="refreshBikeList();"></select><br/><br/>
  型號:<select id="bikes"></select><br/>
</body>
</html>

注意,在選完第一個年份後,會觸發onchange事件,接著第二個下拉選單會自動填上對應年份的型號,而不是按鈕按下,再去取得第二個下拉選單,然後refresh…blah…blah…

bike.js如下…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function refreshYearList() {
    Bike.getYears(populateYearList);
}
 
function populateYearList(list){
    DWRUtil.removeAllOptions("years");
    DWRUtil.addOptions("years", list);
    refreshBikeList();
}
 
function refreshBikeList() {
    var year = $("years").value;
    Bike.getBikes(year, populateBikeList);
}
 
function populateBikeList(list){
    DWRUtil.removeAllOptions("bikes");
    DWRUtil.addOptions("bikes", list);
}

一樣很簡單…

看個無聊的畫面…XD