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;