java Socket 网络编程

Java网络编程
Java网络编程主要是以Socket套接字编程为主。Socket套接字负责启动程序内部与外部的通信。将远程地址和端口传递给套接字构造器，套接字被打开以后，其中的getInputStream方法就会返回一个InputStream对象，该对象接受的是服务器端（或者客户端）传递过来的数据。该对象可以像其他的任何流对象一样使用。并且这个流对象会一直持续到客户端与服务器端断开连接为止。
此外，还有两种协议TCP（传输控制协议）以及UDP（用户数据报协议）必须要知道。TCP 是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。UDP 是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。

package test;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

/**
 * 
 * 
 * @author houst
 *
 */
public class SocketClientTest {

    public static void main(String[] args) {
        new SocketClientTest().startClient();
    }

    public void startClient() {
        Socket clientSocket = null;
        String serverName = "127.0.0.1";
        DataOutputStream dout = null;
        DataInputStream din = null;
        try {
            /* 3、服务器正在等待时，客户端实例化一个 Socket 对象，指定服务器名称和端口号来请求连接 */
            System.out.println("连接到服务器：" + serverName);
            clientSocket = new Socket(serverName, 9986);
            System.out.println("服务器地址：" + clientSocket.getRemoteSocketAddress());
            /*
             * 4、连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，
             * 客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。
             */
            //向服务器端发送信息
            dout = new DataOutputStream(clientSocket.getOutputStream());
            dout.writeUTF("hello");

            //打印服务器端传来的信息
            din = new DataInputStream(clientSocket.getInputStream());
            System.out.println(din.readUTF());

        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            try {
                if (dout != null) {
                    dout.close();
                }
                if (din != null) {
                    din.close();
                }
                if (clientSocket != null) {
                    clientSocket.close();
                }

            } catch (Exception e2) {
                e2.printStackTrace();
            }

        }
    }
}

package test;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 
 * @author houst
 *
 */
public class SocketServerTest {


    public static void main(String[] args) {
        new SocketServerTest().startServer();
    }

    /**
     * 启动服务器端
     */
    public void startServer () {
        ServerSocket serverSocket = null;
        Socket server = null;
        DataInputStream din = null;
        DataOutputStream dout = null;
        try {
             /*1、 服务器实例化一个 ServerSocket对象，并且绑定一个端口，用于服务器与客户端的通信*/

             serverSocket = new ServerSocket(9986);

             /*
              * ServerSocket的连接阻塞时间，如本例中如果100s没有client连接将弹出
              * SocketTimeoutException异常
              */             
             serverSocket.setSoTimeout(100000); 

             /*
              * 2、调用 ServerSocket 类的 accept() 方法，该方法将一直等待，
              *   直到客户端连接到服务器上给定的端口。accept()方法返回服务器上一个新的 socket 引用，
              *   该 socket 连接到客户端的 socket
              */
             System.out.println("等待远程连接.....");
             server = serverSocket.accept();
             System.out.println("远程客户端地址：" + server.getRemoteSocketAddress());

             /*
              * 第3步在客户端实现
              * 
              * 4、连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，
              * 客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。
              */

             //打印客户端传过来的数据
             din = new DataInputStream(server.getInputStream());
             System.out.println(din.readUTF());

             dout = new DataOutputStream(server.getOutputStream());
             dout.writeUTF("你好 client");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (dout != null) {
                    dout.close();
                }
                if (din != null) {
                    din.close();
                }
                if (server != null) {
                    server.close();
                } 
                if (serverSocket != null) {
                    serverSocket.close();
                } 
            } catch (Exception e2) {
                e2.printStackTrace();
            }

        }       
    }   
}

Socket 多线程编程

package test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * 
 * Client
 * @author houst
 *
 */
public class SocketClientTest {

    public static void main(String[] args) {
        new SocketClientTest().startClient();
    }

    public void startClient() {
        Socket clientSocket = null;
        String serverName = "127.0.0.1";
        PrintWriter pw = null;
        BufferedReader  br = null;
        int client = 0;
        try {
            while (true) {

                System.out.println("连接到服务器：" + serverName);
                clientSocket = new Socket(serverName, 9986);
                System.out.println("服务器地址：" + clientSocket.getRemoteSocketAddress());

                //向服务器发送信息
                pw = new PrintWriter(clientSocket.getOutputStream());
                pw.write("我是client" + (++client));              
                pw.flush();

                //关闭输出流
                clientSocket.shutdownOutput();

                //打印服务器端传来的信息
                br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                while (br.readLine() != null) {
                    System.out.println(br.readLine());
                }

            }
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            try {
                if (pw != null) {
                    pw.close();
                }
                if (br != null) {
                    br.close();
                }
                if (clientSocket != null) {
                    clientSocket.close();
                }

            } catch (Exception e2) {
                e2.printStackTrace();
            }

        }
    }
}

package test;

import java.io.BufferedReader;

import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;


/**
 * 服务器端线程类
 * @author houst
 *
 */
public class SocketServerThreadTest extends Thread {

    private Socket serverSocket;

    public SocketServerThreadTest(Socket serverSocket2) {
        this.serverSocket = serverSocket2;
    }

    @Override
    public void run() {

        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            //打印客户端传来的消息
           br = new BufferedReader(new InputStreamReader(serverSocket.getInputStream()));

            while (br.readLine() != null) {
                System.out.println(br.readLine());
            }
            serverSocket.shutdownInput();

            //向客户端端发送信息
           pw = new PrintWriter(serverSocket.getOutputStream());
            pw.write("欢迎您");
            pw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (pw != null) {
                    pw.close();
                }
                if (br != null) {
                    br.close();
                }
                if (serverSocket != null) {
                    serverSocket.close();
                }

            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }

    }

}

package test;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 
 * 服务器类
 * @author houst
 *
 */
public class SocketServerTest {


    public static void main(String[] args) {
        new SocketServerTest().startServer();
    }

    /**
     * 启动服务器端
     */
    public void startServer () {
        ServerSocket serverSocket = null;
        Socket server = null;
        DataInputStream din = null;
        DataOutputStream dout = null;
        try {
             /* 服务器实例化一个 ServerSocket对象，并且绑定一个端口，用于服务器与客户端的通信*/

             serverSocket = new ServerSocket(9986);

             /*
              * ServerSocket的连接阻塞时间，如本例中如果100s没有client连接将弹出
              * SocketTimeoutException异常
              */             
             serverSocket.setSoTimeout(100000); 

             /*
              *   调用 ServerSocket 类的 accept() 方法，该方法将一直等待，
              *   直到客户端连接到服务器上给定的端口。accept()方法返回服务器上一个新的 socket 引用，
              *   该 socket 连接到客户端的 socket
              */
             System.out.println("等待远程连接.....");

             //连接的client数量
             int count = 0;
             while (true) {
                 server = serverSocket.accept();
                 System.out.println("远程客户端地址：" + server.getRemoteSocketAddress());

                 //创建服务器线程类
                 SocketServerThreadTest socketServerThreadTest = new  SocketServerThreadTest(server);
                 //启动线程
                 socketServerThreadTest.start();

                 count++;
                 System.out.println("client:" + count + "," + server.getInetAddress().getHostAddress());
             }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (dout != null) {
                    dout.close();
                }
                if (din != null) {
                    din.close();
                }
                if (server != null) {
                    server.close();
                } 
                if (serverSocket != null) {
                    serverSocket.close();
                } 
            } catch (Exception e2) {
                e2.printStackTrace();
            }

        }       
    }   
}