Java 网络编程学习总结

新手一枚，Java学习中，把自己学习网络编程的知识总结一下，梳理下知识，方便日后查阅，高手莫进。

本文的主要内容：

[1] 网络编程认识

[2] TCP/IP编程[b]小例子[/b]

[3] UDP编程小例子

[4] 简单线程池实例

一、网络编程的主要认识

Java是一种基于网络设计的语言，用于开发网络软件特别便利。

它对于网络的操作都是基于IP层以上的，也就是对TCP/UDP进行操作，所以java的网络编程又称为Socket编程。

　　一种是TCP/IP 网络编程，

　　一种是UDP编程。

TCP是Tranfer Control Protocol的 简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建 立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送 或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

另外，网络编程不同于WEB编程。

此处只把我自己学习时写的两个小例子贴出来。

关于Java网络编程更详细的介绍，感觉一些前辈总结的不错，贴出地址，各位如有需要，可以自己查阅。
http://www.cnblogs.com/springcsc/archive/2009/12/03/1616413.html
二、 TCP/IP编程

服务端代码：

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);// 实例化一个ServerSocket对象那个，用于监视服务器的
// 8888 端口
Socket socket = server.accept();// 调用access（）阻塞方法，等待客户端发送数据过来
// 设置输入缓冲流，把键盘输入的数据保存在流中
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
// 用两个数据流来读取和输出ServerSocket对象server的接收数据和发送数据
DataOutputStream write = new DataOutputStream(socket.getOutputStream());
DataInputStream read = new DataInputStream(socket.getInputStream());
// 阻塞方法，接收数据
String line = read.readUTF();

while (line != "bye") {
// 输出接受的数据
System.out.println(socket.getInetAddress() + " : " + socket.getPort() + " say:" + line);
// 阻塞方法，接收用户键盘输入的数据，用于发送给客户端
line = input.readLine();
System.out.println("server say:" + line);
// 服务器发送数据
write.writeUTF(line);
line = read.readUTF();
}
// 关闭流和ServerSocket
read.close();
write.close();
input.close();
socket.close();
server.close();
}
}

Client 端代码

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {
public static void main(String[] args) throws IOException {
BufferedReader inputStream = null;
DataInputStream reader = null;
DataOutputStream writer = null;
Socket socket = null;
String line = null;
// 实例化Socket 用于指定所要发送数据的目标地址为127.0.0.1。端口为8888
socket = new Socket("127.0.0.1", 8888);

inputStream = new BufferedReader(new InputStreamReader(System.in));
reader = new DataInputStream(socket.getInputStream());
writer = new DataOutputStream(socket.getOutputStream());

line = inputStream.readLine();

while (line != "bye") {
System.out.println("client say: " + line);
writer.writeUTF(line);
line = reader.readUTF();
System.out.println("server say: " + line);
line = inputStream.readLine();
}
inputStream.close();
reader.close();
writer.close();
socket.close();

}
}

三、UDP编程

服务端代码：

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPServer {
public static void main(String[] args) throws IOException {
// 定义缓冲区大小
byte[] buff = new byte[1024];
// 实例化一个DatagramPacket对象，用于接受消息
DatagramPacket packet = new DatagramPacket(buff, buff.length);
DatagramSocket socket = new DatagramSocket(8888);
while (true) {
// 阻塞方法
socket.receive(packet);
ByteArrayInputStream bais = new ByteArrayInputStream(buff, 0, packet.getLength());
DataInputStream stream = new DataInputStream(bais);
long l = stream.readLong();
System.out.println(l);
}
}
}

Client端代码：

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UDPClient {
public static void main(String[] args) throws IOException {
// 发送long类型数据
long n = 100000L;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream outputStream = new DataOutputStream(baos);
outputStream.writeLong(n);
byte[] buff = baos.toByteArray();
DatagramPacket packet = new DatagramPacket(buff, buff.length, new InetSocketAddress("127.0.0.1", 8888));
DatagramSocket socket = new DatagramSocket(9999);
socket.send(packet);
socket.close();
}
}

四、简单的线程池代码：

import java.util.LinkedList;

public class TestThreadPool {
public static void main(String[] args) {
int numThreads = 3;
MyThreadPool pool = new MyThreadPool(numThreads);
int numTasks = 10;
for (int i = 0; i < numTasks; i++) {
pool.performTask(new MyTask(i));
}
pool.join();
}

}

// 线程池类，继承自ThreadGroup
class MyThreadPool extends ThreadGroup {
private boolean isAlive;// 表示线程池是否可以使用
private LinkedList taskQueue;// 工作队列
private int threadId;// 线程池内线程id
private static int threadPoolId;// 线程池id，可以实例化多个线程池

public MyThreadPool(int numThreads)
{
super("threadPoolID" + (threadPoolId++));
super.setDaemon(true);
this.isAlive = true;
// 初始化工作队列
this.taskQueue = new LinkedList();
for (int i = 0; i < numThreads; i++) {
// PooledThread是处理工作的线程类
new PooledThread().start();
}
}

/** 添加新任务 */
public synchronized void performTask(Task task) {
if (!this.isAlive) {
throw new IllegalStateException();
}
if (task != null) {
this.taskQueue.add(task);
notify();
}
}

/**
* 获取任务
* @throws InterruptedException
*/
protected synchronized Task getTask() throws InterruptedException {
while (this.taskQueue.size() == 0) {
if (!this.isAlive)
return null;
this.wait();
}
return (Task) this.taskQueue.removeFirst();
}

/** 关闭线程池，所有线程停止，不再执行 */
public synchronized void close() {
if (this.isAlive) {
this.isAlive = false;
this.taskQueue.clear();
this.interrupt();
}
}

/** 关闭线程池，并等待线程池中所有任务运行完成，不能接受新任务 */
public void join() {
synchronized (this) {
isAlive = false;
notifyAll();
}
Thread[] threads = new Thread[this.activeCount()];
int count = this.enumerate(threads);
for (int i = 0; i < count; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

// 内部类，用于执行任务的工作线程
class PooledThread extends Thread {
public PooledThread()
{
super(MyThreadPool.this, "PooledThread" + (threadId++));
}

public void run() {
while (!Thread.interrupted()) {
// 获取任务
Task task = null;
try {
task = getTask();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (task == null)
return;
try {
task.perform();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
}

}

// 定义任务的接口类
interface Task {
/**
* 执行任务 执行过程中可能出现异常
*/
public void perform() throws Exception;
}

// 实现上面接口的任务类
class MyTask implements Task {
private int TaskId = 0;

public MyTask(int id)
{
this.TaskId = id;
}

@Override
public void perform() throws Exception {
System.out.println("MyTask " + TaskId + " Start");
Thread.sleep(1000);
System.out.println("MyTask " + TaskId + " end");
}

}

最后，无论是TCP/IP 编程，还是UDP编程，都只是同步的，就用到的是阻塞方法，当服务器或者客户端没有发送来数据时，就一直处于等待状态。

最新的JDK已经推出了异步编程相关内容，我还有学习过，以后继续努力。