Java 网络编程学习总结

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

本文的主要内容：

[1]    网络编程认识              

 [2]  TCP/IP编程小例子

[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已经推出了异步编程相关内容，我还有学习过，以后继续努力。