02--Java Socket编程--IO方式

一、基础知识

1. TCP状态转换知识，可参考：

http://www.cnblogs.com/qlee/archive/2011/07/12/2104089.html

2. 数据传输

3. TCP/IP五层模型

应用层：HTTP、FTP、SMTP、Telnet等

传输层：TCP/IP

网络层：

数据链路层：

物理层：网线、双绞线、网卡等

4. 常用类,java.net.*

此包下主要类结构图如下：

4.1 InetAddress

InetAddress类用于标识网络上的硬件资源，标识互联网协议(IP)地址。该类没有构造方法，由于涉及DNS解析，该类一般用单例模式。

1 //获取本机的InetAddress实例

2 InetAddress address =InetAddress.getLocalHost();

3 address.getHostName();//获取计算机名

4 address.getHostAddress();//获取IP地址

5 byte[] bytes = address.getAddress();//获取字节数组形式的IP地址,以点分隔的四部分

6

7 //获取其他主机的InetAddress实例

8 InetAddress address2 =InetAddress.getByName("其他主机名");

9 InetAddress address3 =InetAddress.getByName("IP地址");

4.2 URL类

URL(Uniform Resource Locator)统一资源定位符，表示Internet上某一资源的地址，协议名：资源名称

 1 //创建一个URL的实例

 2 URL baidu =new URL("http://www.baidu.com");

 3 URL url =new URL(baidu,"/index.html?username=tom#test");//？表示参数，#表示锚点

 4 url.getProtocol();//获取协议

 5 url.getHost();//获取主机

 6 url.getPort();//如果没有指定端口号，根据协议不同使用默认端口。此时getPort()方法的返回值为 -1

 7 url.getPath();//获取文件路径

 8 url.getFile();//文件名，包括文件路径+参数

 9 url.getRef();//相对路径，就是锚点，即#号后面的内容

10 url.getQuery();//查询字符串，即参数

4.3 Socket类

代表通讯过程中的客户端。

4.4 ServerSocket类

代表通讯过程中的服务器端。

二、Socket编程模型及步骤

1. Socket模型图

2. ServerSocket工作步骤

① 创建ServerSocket对象，绑定监听端口
② 通过accept()方法监听客户端请求，此处会堵塞。
③ 连接建立后，通过输入流读取客户端发送的请求信息
④ 通过输出流向客户端发送乡音信息
⑤ 关闭相关资源

3. Socket工作步骤

① 创建ServerSocket和Socket
② 打开连接到Socket的输入/输出流
③ 按照协议对Socket进行读/写操作
④ 关闭输入输出流、关闭Socket

三、常用工作模型

1. 服务器单线程监听和处理服务，客户端单线程，2个文件

package com.yyn.io.net;

import java.io.BufferedOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.sql.Date;

public class SingleThreadServer extends Thread{

 /**

  *  单线程的,仅仅是能够应答连接的客户就立即断开连接了

  */

    private static ServerSocket serverSocket;

    public SingleThreadServer(){

        super();

        try{

            serverSocket = new ServerSocket(1112);

            System.out.println("SingleThreadSocket creating....");

        }catch (Exception e) {

            System.out.println("SingleThreadSocket create failed....");

            System.exit(1);

        }

    }

    @Override

    public void run() {

        // TODO Auto-generated method stub

        Socket client = null;

        while (true) {

            if (serverSocket == null) {

                return;

            }

            try{

                client = serverSocket.accept();

                InputStream in = client.getInputStream();

                OutputStream out = client.getOutputStream();

                BufferedOutputStream bos = new BufferedOutputStream(out);

                PrintWriter writer = new PrintWriter(bos);

                Date now = new Date(System.currentTimeMillis());

                writer.write(now.toString());

                System.out.println("New Connection Accepted:"+client.getRemoteSocketAddress());

                writer.flush();

                client.close();

            }catch (Exception e) {

                // TODO: handle exception

            }

        }

    }

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        SingleThreadServer server = new SingleThreadServer();

        server.start();

    }

}

package com.yyn.io.net;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

import java.nio.Buffer;

public class SingleThreadClient {

    public static void main(String[] args) throws UnknownHostException, IOException {

        // TODO Auto-generated method stub

        Socket server = new Socket("127.0.0.1", 1112);

        OutputStream out = server.getOutputStream();

        BufferedOutputStream bos = new BufferedOutputStream(out);

        PrintWriter writer = new PrintWriter(bos);

        writer.write("Hello server!!!");

        InputStream in = server.getInputStream();

        InputStreamReader isr = new InputStreamReader(in);

        BufferedReader reader = new BufferedReader(isr);

        String info = null;

        info = reader.readLine();

        System.out.println("####Server Message: " + info);

        reader.close();

        isr.close();

        in.close();

        writer.close();

        bos.close();

        out.close();

        server.close();

    }

}

2. 服务器单线程监听，连接客户端后(ACCEPT成功后)，启动新线程处理服务。

package com.yyn.io.net;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

//获取用户连接请求，请求成功后，调用MultiThreadSeverThread进行服务

public class MultiThreadServerReceiver {

    public static final int PORT = 12002;

    public static void main(String[] args) throws Exception {

        // TODO Auto-generated method stub

        init();

    }

    public static void init() throws Exception{

        ServerSocket server = new ServerSocket(PORT);

        System.out.println("Server is started");

        int count = 0;

        while(true){

            Socket client = server.accept();

            System.out.println("Accepted at: " + client.getRemoteSocketAddress());

            MultiThreadSeverThread serverThread = new MultiThreadSeverThread(client);

            System.out.println("Start Thread to process!!!");

            serverThread.start();

            count++;

            while (count >=3) {

                return;

            }

        }

    }

}

package com.yyn.io.net;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

//请求连接后，accept成功后，负责服务的线程类

public class MultiThreadSeverThread extends Thread{

        private Socket client = null;

        private PrintWriter writer = null;

        private BufferedReader reader = null;

        public static final String CHARSET = "UTF-8";

        public MultiThreadSeverThread(Socket client) throws Exception{

            this.client = client;

            try{

                // Init writer

                OutputStreamWriter osw = new OutputStreamWriter(client.getOutputStream(),CHARSET);

                BufferedWriter bw = new BufferedWriter(osw);

                this.writer = new PrintWriter(bw);

                // Init reader

                InputStreamReader isr = new InputStreamReader(client.getInputStream(),CHARSET);

                this.reader = new BufferedReader(isr);

            }catch(Exception e){

                e.printStackTrace();

                throw new Exception("Init MultiThreadServerThread failed!!!");

            }

            System.out.println("#######Welcome to server,input commands please!!!");

        }

        @Override

        public void run(){

            String command = null;

            boolean flag = true;

            System.out.println("thread to process!!!");

            while (flag) {

                try {

                    command = this.reader.readLine();

                    System.out.println("client command:" + command);

                } catch (Exception e) {

                    e.printStackTrace();

                    flag = false;

                }

                if (command == null) {

                    return ;

                }

                // if command is not null ,then trim it and change to upper case

                command = command.trim().toUpperCase();

                if(command.equals("QUIT")){

                    flag = false;

                }else if (command.equals("HELP")) {

                    this.writer.println("本服务器可收到的请求有：");

                    this.writer.println("list");

                    this.writer.println("push");

                    this.writer.println("pop");

                }else if(command.equals("LIST") || command.equals("PUSH") || command.equals("POP")) {

                    this.writer.println("输入命令正确");

                }else{

                    this.writer.println("输入命令有误，请重新输入！！！");

                }

                writer.flush();

            }

            // close socket connection

            try {

                this.client.close();

            } catch (IOException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

}

package com.yyn.io.net;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.Iterator;

import java.util.stream.Stream;

public class MultiThreadServerClient {

    public static final int PORT = 12002;

    public static void main(String[] args) throws UnknownHostException, IOException {

        // TODO Auto-generated method stub

        Socket socket = new Socket("127.0.0.1",PORT);

        // in stream from console

        InputStreamReader isr = new InputStreamReader(System.in,"UTF-8");

        BufferedReader in = new BufferedReader(isr);

        // out stream from socket

        OutputStreamWriter osw =

                new OutputStreamWriter(new BufferedOutputStream(socket.getOutputStream()), "UTF-8");

        PrintWriter out = new PrintWriter(osw);

        String command = null;

        while(true){

            System.out.println("#######################");

            command = in.readLine();

            if (command == null) {

                socket.shutdownInput();

                break;

            }

            command = command.trim().toUpperCase();

            if (command.equals("EXIT")) {

                socket.shutdownInput();

                break;

            }

            out.println(command); //必须用println方法，不能用write，否则服务端无法获取数据，会堵塞

            out.flush();

            System.out.println("data send to server:"+command);

        }

    }

}

巴特西