随笔-71  评论-4  文章-0  trackbacks-0
1. Client/Server Networking
Java通过socket来完成它所有的
网络 底层的通讯,socket是一种通讯的通道,通过它可以将数据通过特定的端中发送及接收。Java中的socket可以分成二大类:

(1) Datagram Sockets:数据包socket;

(2) Stream Sockets:流socket;

1.2 Datagram Socket
Datagram socket使用UDP来实现数据通讯,因此它不能保证数据能够到达目的地,但是由于它不需要专用的
网络 链接,所以它所需的资源相对少的多。

Datagram以包的方式发送数据,但它不能保证这些数据包以特定的顺序到达目的,因此包中往往需要包含序列号的信息,接收方可以根据序列号的信息决定是否所有的包都已收到,并按正常顺序重组这些包。

Java通过两个类DatagramSocket和DatagramPacket来支持Datagram socket。DatagramSocket实现了Datagram socket的基本功能,而DatagramPacket则提供了对包的一些支持。

DatagramSocket的几个重要方法:

(1) DatagramSocket():随机绑定一个有效的端口;

(2) DatagramSocket(int port):绑定指定的端口;

(3) Void send(DatagramPacket p):发送数据报,由于目的地的地址信息已包含在数据报中,所以不需要在本函数中提供地址信息;

(4) synchronized void receive(DatagramPacket p):接收数据包,线程安全;

(5) synchronized void close():关闭socket;

在DatagramSocket中并不区分ServerSocket和ClientSocket,如果一定要区分,那么发送的是client,而接收的是server。

DatagramPacket有以几个重要的方法:

(1) DatagramPacket(byte ibuf[], int ilength):用于接收数据报;

(2) DatagramPacket(byte ibuf[], int ilength, InetAddressiaddr, int iport):用于发送的数据报;

(3) byte[] getData()

(4) int getLength()

以下是完整的Datagram Socket的例子:

接收端,Server端代码:

import java.io.*;

import java.net.*;



class FortuneServer1 extends Thread

{

DatagramSocket ServerSocket;

public FortuneServer1()

{

super("FortuneServer1");

try

{

ServerSocket = new DatagramSocket(1114);

System.out.println("FortuneServer up and running...");

}

catch (SocketException e)

{

System.err.println("Exception: couldn't create datagram socket");

System.exit(1);

} }



public static void main(String[] args)

{

FortuneServer1 server = new FortuneServer1();

server.start();

}



public void run()

{

if (ServerSocket == null)

return;



while (true)

{

try

{

InetAddress address;

int port;

DatagramPacket packet;

byte[] data = new byte[256];

int num = 1;



packet = new DatagramPacket(data, data.length);

ServerSocket.receive(packet);

address = packet.getAddress();

port = packet.getPort();



File inFile = new File("Fortunes.txt");

FileInputStream inStream = new FileInputStream(inFile);



if (inStream.read(data) <= 0)

{

System.err.println("Error: couldn't read fortunes");

}



packet = new DatagramPacket(data, data.length, address, port);

ServerSocket.send(packet);

}

catch (Exception e)

{

System.err.println("Exception: " + e);

e.printStackTrace();

} } } }

说明:

(1) 这个例子中接收端的socket使用了多线程,多线程的概念可以参考本文的多线程部分;

(2) 在构造函数中创建了DatagramSocket,并且使用了1114这个端口;

(3) 本例子的关键函数是run,它使用了死循环,在循环中使用了receive这方法来临听1114端口,如果1114端口没有请求数据到来,那么这个程序就一直停留在receive这个位置,不再往下执行;

(4) 当1114端有数据时,receive方法将接收到的DatagramPacket数据包放在packet这个对象中,然后解析其中的数据,获取发送方的地址信息;

(5) 然后再创建DatagramPacket包,并填充数据,发送到原接收端。

以下是发送端的代码:

import java.io.*;

import java.net.*;

class FortuneClient

{

public static void main(String args[])

{

FortuneClient client = new FortuneClient();

System.out.println(client.getMessage());

}



public String getMessage()

{

String fortune;

try {

DatagramSocket socket;

DatagramPacket packet;

byte[] data = new byte[256];



socket = new DatagramSocket();

packet = new DatagramPacket(data, data.length,InetAddress.getByName("127.0.0.1"), 1114);

socket.send(packet);



packet = new DatagramPacket(data, data.length);

socket.receive(packet);

fortune = new String(packet.getData(), 0);

socket.close();

}

catch (UnknownHostException e) {

System.err.println("Exception: host could not be found");

return null;

}

catch (Exception e) {

System.err.println("Exception: " + e);

e.printStackTrace();

return null;

}

return fortune;

} }

客户端的代码与服务器端的代码基本相同,只是没有了循环,并且处理步骤与服务器端的基本相反。这也说明了Datagram Socket不真正区分Server和Client。

1.3 Stream Socket
Stream Socket与Datagram Socket不同,它有一个永久性的链接,可以确保数据可靠的发送到对方。但是Stream Socket所占的资源更多。

Java主要通过Socket及ServerSocket来实现Stream Socket,一个用于客户端,另一个用户服务器端。

Socket类的几个重要方法如下:

(1) Socket(String host, int port)

(2) Socket(InetAddress address, int port)

(3) synchronized void close()

(4) InputStream getInputStream()

(5) OutputStream getOutputStream()

可以看出Stream Socket中的Socket与Datagram Socket中的Socket的区别:

(1) 在构造函数中,这里需要指定服务器的地址与端口,用于它发送数据之前建立链接,而Datagram的Socket不需要建立链接,它仅需要在要发送的数据包中包含地址信息即可;

(2) Stream Socket的两个重要方法和其它流的方法类似,而且在操作上也相似,其实在操作Stream Socket时,只要建立了链接,那么以后的操作和流的操作一样了,你可以忘了你在操作Socket,只当做自己在操作普通的流。

ServerSocket有以下几个重要的方法:

(1) ServerSocket(int port):监听指定端口,监听时间为默认值50;

(2) ServerSocket(int port, int count):监听指定端口,并指定监听时间;

(3) ServerSocket(int port, int backlog, InetAddress bindAddr):只接收指定接口发过来的数据;

(4) Socket accept():accpet方法会返回一个Socket对象,使用该Socket对象的getInputStream及getOutputStream方法获取输入及输出流。由此可见无论是服务器端还是客户端,它们都是通过Socket对象来收发数据的。程序执行到accpet时会进入监听状态,不再向下执行一直到接收到数据。

(5) void close()

以下是关于Stream Socket的一个例子,在这个例子中使用单独的二个类Receiver和Sender负责对指定的输入及输出流进行操作,用另一个类SocketPerformer来创建Receiver和Sender这两个类的实例,并传入指定的输入及输出流,而在Client及Server这两个类中,负责创建SocketPerformer对象,并传入指定的Socket。因此这五个类在功能上分为三层,第一层负责对流进行操作,第二层负责创建指定的Socket流,并这些Socket流传到第一层,第三层负责创建Socket并将这些Socket传到第二层。

Receriver代码:

package socketChat;

import java.io.BufferedReader;

public class Receiver extends Thread {

BufferedReader reader;

public Receiver(BufferedReader theSocketReader) {

reader = theSocketReader;

}



public void run() {

while (true) {

try {

String words = reader.readLine(); System.out.println("\r\n<<< " + words);

} catch (Exception e) {

e.printStackTrace();

return;

} } }}

Sender代码:

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;



public class Sender extends Thread {

PrintWriter writer;

public Sender(PrintWriter theWriter) {

writer = theWriter;

}

public void run() {

try {

while (true) {

BufferedReader consoleReader = new BufferedReader(

new InputStreamReader(System.in));

String userInput = consoleReader.readLine();

writer.write(userInput + "\r\n");

writer.flush(); // send the data in buffer immediately

}

} catch (Exception e) {

e.printStackTrace();

return;

} }}

SocketPerformer代码:

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class SocketPerformer {

Socket socket;

public SocketPerformer(Socket theSoc){

socket = theSoc;

}

public void execut() throws Exception{

BufferedReader socketReader = new BufferedReader(new InputStreamReader(

socket.getInputStream()));

PrintWriter socketWriter = new PrintWriter(socket.getOutputStream());

System.out.println("connection built !");



Receiver rec = new Receiver(socketReader);

rec.start();



Sender sender = new Sender(socketWriter);

sender.start();

}}

Server代码:

package socketChat;



import java.net.ServerSocket;

import java.net.Socket;

public class Server {

public static void main(String[] args) throws Exception {

ServerSocket server = new ServerSocket(30000, 5);

Socket socket = null;

System.out.println("waiting incoming connection...");

socket = server.accept();

System.out.println("a connection built!");

System.out.println("the peer ip is: " + socket.getInetAddress().getHostAddress());

new SocketPerformer(socket).execut();

server.close();

}}

Client端代码如下:

package socketChat;

import java.net.Socket;

public class Client {



public static void main(String[] args) throws Exception {

String ip = "127.0.0.1";

int port = 30000;

System.out.println("connecting to server: " + ip

+ " at port: " + port + " ...");



Socket soc = new Socket(ip, port);

new SocketPerformer(soc).execut();

}}

2. 其它
(1) 常量定义以final做修饰符,如final int I = 3;final还可以用在class及method上,如果用在class上,那么该class不能被继承,如果用在method上,那么该method不能被重载

(2) 类变量定义:static int sum

(3) 判断对象类型:objName instanceof className,如"helloWorld" instanceof String,判断的结果是true

(4) 提取对象的类名:objName.getClass().getName()

(5) java.lang:Java最基本的包,包含java语言最基本的定义

(6) java.util:包含如Date,及基本的集合类,如Vector、Hashtable等

(7) java.io:包含输入输出的定义

(8) java.net:包含如Socket等

(9) java.awt:用于Window界面开发

(10) java.applet:用于applet开发

(11) null关键字引用null对象,注意大小写

(12) 每个基本的数据类型如int,都有相应的类与之对应中Int

(13) 构造函数名与类名相同,并且不需要返回类型,即在构造函数前不需要加类型修饰符

(14) 调用自身的构造函数:this(参数列表);

(15) 调用父类的构造函数:super(参数列表);

(16) 调用父类已被重载的函数:super.方法名(参数列表);

(17) 在同一文件中可以有多个类的定义,但只能有一个类是public并且类名与文件一样,该文件编译成功后会生成多个.class文件,与类的定义一一对应;

(18) 接口比抽象类功能强有:抽象类属于特定的类结构树中,它不能被其它树中的类共享;

(19) 接口的定义与类的定义类似,只需将class改成interface即可,但接口定义必须是public或者缺省的(package);

(20) 在接口中可以定义方法和变量,接口中的定义的方法应是public并且是abstract的(缺省);变量的定义必须是public static final(缺省);

(21) String.copyValueOf(buffer, 0, offset):用于从字符数组中取出字符,并形成字符串;

(22) new String(buf, 0, count)

(23) System.in(标准输入)是一个InputStream;

(24) System.err是一个PrintStream;

(25) System.out是一个PrintStream;

posted on 2006-03-20 12:21 zjw_albert 阅读(403) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。


网站导航: