Java Socket、计算机网络

一个服务器对应一个客户端

http://blog.51cto.com/wangdy/1588379

https://www.cnblogs.com/rocomp/p/4790340.html

package cn.day2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class MyClient {
    public static void client() throws Exception {
        Socket socket = new Socket("127.0.0.1", 10000);
        System.out.println("客户端启动.....");
        OutputStream out = socket.getOutputStream();
        DataOutputStream doutput = new DataOutputStream(out);
        doutput.writeUTF("客户端发送信息");
        doutput.flush();
        InputStream input = socket.getInputStream();
        DataInputStream dinput = new DataInputStream(input);
        String str = dinput.readUTF();
        System.out.print("客户端收到消息:" + str);

    }

    public static synchronized void client1() throws Exception {//错

            Socket socket[] = new Socket[5];
            for(int i=0;i<5;i++){
            socket[i] = new Socket("127.0.0.1", 10000);
            System.out.println("客户端启动.....");
            OutputStream out = socket[i].getOutputStream();
            DataOutputStream doutput = new DataOutputStream(out);
            doutput.writeUTF("客户端发送信息"+i);
            doutput.flush();

            InputStream input = socket[i].getInputStream();
            DataInputStream dinput = new DataInputStream(input);
            String str = dinput.readUTF();
            System.out.print("客户端收到消息:" + str);
        }
    }

    public static void main(String[] args) throws Exception {
//         client();
        client1();
    }
}

package cn.day2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {
    public static void server()throws Exception{
        ServerSocket server = new ServerSocket(10000);
        System.out.println("启动服务器.....");
        Socket socket = server.accept();
        InputStream binput = socket.getInputStream();
        DataInputStream dinput = new DataInputStream(binput);
        String str = dinput.readUTF();
        System.out.print("服务器收到信息：" + str);
        Thread.sleep(10000);
        OutputStream output = socket.getOutputStream();
        DataOutputStream dout = new DataOutputStream(output);
        dout.writeUTF("服务器发送信息");
        dout.flush();
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        server();
    }
}

一个服务端多个客户端

package cn.day2;

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

public class MyMulSocketServer extends ServerSocket {
    public static void main(String[] args) throws IOException {
        MyMulSocketServer server = new MyMulSocketServer();
    }
    public static final int PORT = 11112;

    public MyMulSocketServer() throws IOException{
        super(PORT);
        System.out.println("初始化服务器...");
        while(true){
            Socket socket = null;
            try {
                socket = accept();
                System.out.println("连接...");
                new MyThread(socket).start();;
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
//                try {
//                    if(null != socket){
//                        socket.close();
//                    }
//                } catch (IOException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
            }
        }
    }

    class MyThread extends Thread{
        MyThread(){

        }
        Socket socket = null;

        public MyThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try{
                System.out.println("开始运行...");
                BufferedReader br = null;
                PrintWriter pw = null;
                br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                pw = new PrintWriter(socket.getOutputStream(), true);
                String line = br.readLine();
                System.out.println("Hello " + line);
                pw.println("Hello " + line);
//                pw.flush();

                pw.close();
                br.close();
            }catch( Exception e){

            }finally{
//                try {
//                    if(null != socket){
//                        socket.close();
//                    }
//                } catch (IOException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
            }
        }
    }

}

package cn.day2;

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

public class MyMulClient {

    public static void main(String[] args) throws IOException, IOException {
//        for(int i=0;i<10;i++){
            System.out.println("客户端开始...");
            client();
//        }
    }

    public static void client(){
        try {
            Socket [] clients = new Socket[10];
            for(int i=0;i<10;i++){
                Socket client = new Socket("127.0.0.1", 11112);
                clients[i] = client;
            }
            for(int i=0;i<10;i++){
                Socket client = clients[i];
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

                PrintWriter pw = new PrintWriter(client.getOutputStream(), true);
                String line  = br.readLine();
                System.out.print(line);
    //            pw.write(line);
                pw.println(line);
                pw.flush();

                br.close();
                pw.close();
                client.close();
            }

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

计算机网络是通过传输介质、通信设施和网络通信协议，

网络传输介质是网络中发送方与接收方之间的物理通路，它对网络的数据通信具有一定的影响。常用的传输介质有双绞线、同轴电缆、光纤、无线传输媒介

OSI七层网络模型（开放系统互连参考模型）

OSI七层网络模型从上到下：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

其中应用层、表示层、会话层、传输层被称作主机层，是开发工程师通过开发应用程序处理和实现的内容

网络层、数据链路层、物理层

第一层：物理层

为设备之间的信息传输提供可靠环境，那么这个环境是什么呢？

就是如：同轴电缆、插头、接收器、水晶头、网线等。可以在通信的两个数据终端的设备之间连接起来形成一条通路。

第二层：数据链路层

提供数据的传送服务。这里涉及一个信息就是帧，它是数据传输的单元，不同的协议帧的长短也不同。它还有差错恢复，流量控制的功能，常见的有网卡，网桥

第三层：网络层

它的作用是路由的选择，网络的激活和终止。它还有的一个重要功能就是在一条数据链路上复用多条网络连接，大多采用的是分时复用的技术

我们常见的是路由器、网关等

第四层：传输层

它是两台计算机经过网络进行数据通信时最基础的端到端的一个层次。它的服务满足了传送质量、传达速度、传送费用的不同需要。它还具有差错恢复，流量控制的功能

二、三次握手与四次挥手

TCP是面向连接的协议，因此每个TCP连接都有三个阶段：建立连接、数据传送和连接释放。

连接建立经过三个步骤，通常称为“三次握手”

第一次握手：客户机发送连接请求报文段到服务器，并进入SYN_SENT状态，等待服务器确认

第二次握手：服务器收到连接请求报文，如果同意建立连接，向客户机发送确认报文段，并为该TCP连接分配缓存和变量

第三次握手：客户机收到服务器的确认报文段后，向服务器给出确认报文段，并且也要给该连接分配缓存和变量，此包发送完毕，

1. 客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。(ACK=1,seq=x+1,ack=y+1)。

TCP四次挥手过程如下：

由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。这原则是当一方完成它的数据发送任务后就能发送一个FIN来终止这个方向的连接。收到一个 FIN只意味着这一方向上没有数据流动，一个TCP连接在收到一个FIN后仍能发送数据。首先进行关闭的一方将执行主动关闭，而另一方执行被动关闭。

1. TCP客户端发送一个FIN，用来关闭客户到服务器的数据传送。
2. 服务器收到这个FIN，它发回一个ACK，确认序号为收到的序号加1。和SYN一样，一个FIN将占用一个序号。
3. 服务器关闭客户端的连接，发送一个FIN给客户端。
4. 客户端发回ACK报文确认，并将确认序号设置为收到序号加1。