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