Java网络Day05 2020-05-02

内容

1.客户端和服务器端连接介绍
2.实现点对点对聊
3.实现群聊

一.客户端和服务器端连接介绍

1.注意点

①一般来讲，有时候没有严格意义的服务器端和客户端
比如A端去连接远程网络中的B端，那么此时B端就扮演服务器的角色，A端扮演客户端的角色②缓存：当B不在线时，A先发给腾讯的服务器(这里假如是QQ)，这里面的内容包括B的IP地址，还有端口号，还有具体的内容，当B上线时，就发给B。这里就相当于做了一个缓存。

2.作为一个客户端必须提供的两个内容

①IP地址(通过这个找到某个设备)
②端口号(找到提供服务的程序，比如qq)

3.客户端和服务器端如何连接(socket)

(1)使用Socket实现连接

Socket的英文原义是“孔”或“插座”。在网络编程中，网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。Socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。 Socket实质上提供了进程通信的端点。进程通信之前，双方首先必须各自创建一个端点，否则是没有办法建立联系并相互通信的。正如打电话之前，双方必须各自拥有一台电话机一样。
而serversocket 建立的是socket的服务端，socket建立的是客户端。所以服务器端使用ServerSocket
客户端使用Socket

(2)使用socket实现网络编程的步骤

1.分别在服务器端和客户端完成ServerSocket和Socket的创建，这也是我们实现网络通信的基础
2.打开连接到Socket的相关的输入输出流，进行数据的通信
3.按照协议对Socket进行读写操作
4.在通信完成以后关闭输入输出流，关闭socket

如果分两步的话，就是

第一步是监听(等待数据发送过来)，用来接收数据，需要指定监听的端口号
第二步是发送，需要指定发送到哪个计算机(IP地址)，需要指定发送到这个计算机的哪个端口。

(3)具体来说

对于服务器端可以
①创建ServerSocket
②使用accept等待客户端连接
③使用OutputStream发送数据
④使用InputStream接收数据
⑤在通信完成以后关闭输入输出流，关闭socket
对于客户端可以
①创建Socket对象，连接服务器端
②使用InputStream接收数据
③使用OutputStream发送数据
④在通信完成以后关闭输入输出流，关闭socket

二.实现点对点对聊

1.简单的接收数据

在进行较为复杂的操作之前，我们不妨先进行一些简单的接收数据的操作。比如下面

服务器端

import java.io.*;
import java.net.*;

//创建一个类Server管理服务器端的内容
//1.服务器端的程序运行在服务器上，所以IP地址默认是当前电脑的IP地址
class Server{
    private int port;//端口号
    private ServerSocket serverSocket;
    
    public Server(int port) {
        this.port = port;
    }
    
    public void start() throws IOException {
        //创建提供服务的socket
        serverSocket = new ServerSocket(port);
        
        //等待用户连接accept
        //如果有客户端来连接，就得到这个客户端的socket对象
        //如果没有客户端来连接，就阻塞(一直等待)
        Socket socket = serverSocket.accept();
        
        //有了连接，就可以向客户端发送响应信息
        //输出流如果输出完毕，必须关闭，表示输出结束
        OutputStream os = socket.getOutputStream();
        
        PrintStream ps = new PrintStream(os);
        ps.println("连接成功，可以通信了！");
        
        socket.shutdownOutput();//关闭输出流
        
        //接收客户端的响应信息
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);    
        //读取数据
        System.out.println(br.readLine());
    }
}
public class Myclass {
   public static void main(String[] args) throws IOException {
       Server server = new Server(8888);
       server.start();
   }
}

客户端

import java.io.*;
import java.net.*;

//创建一个类Client管理客户端的内容
class Client{
    private int port;//客户端的端口号
    private String ipAddr;//客户端的IP地址
    private Socket socket;
    
    public Client(int port,String ipAddr) {
         this.port = port;
         this.ipAddr = ipAddr;
    }
    
    public void start() throws UnknownHostException, IOException {
        //向服务器端发起连接
        socket = new Socket(ipAddr,port);
        
        //接收服务器端的响应信息
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);    
        //读取数据
        System.out.println(br.readLine());
        
        //向服务器端发送数据
        OutputStream os = socket.getOutputStream();
        OutputStreamWriter osw = new OutputStreamWriter(os);
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("你好！");
        bw.flush();//注意，要flush
        //关闭输出流
        socket.shutdownOutput();
    }
}
public class Myclass {
     public static void main(String[] args) throws UnknownHostException, IOException {
         Client client = new Client(8888,"127.0.0.1");
         client.start();
     }
}

以上程序实现了服务器端的简单连接和数据的简单发送。下面，让程序稍微复杂一点服务器端

//服务器端不断输入
        Scanner scanner = new Scanner(System.in);
        OutputStream os = socket.getOutputStream();
        
        PrintStream ps = new PrintStream(os);
        while(scanner.hasNext()) {
            ps.println(scanner.nextLine());
        }

客户端

//接收服务器端的响应信息
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);    
        //读取数据(不断接收)
        String line = null;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }

这样，在服务器端发送数据，客户端就可以接收到并且打印出来，这样就实现了点对点的对聊注意：readLine()这个方法会阻塞，也就是说它会一直等待内容，没有内容就一直等着。包括scanner的nextLine()也是，一直等着你输入，也会阻塞。

三.实现群聊

1.引

上面实现的点对点对聊只能是单方向的，不能既发送数据又接收数据，因为只有一个主线程，程序执行是从上到下的。所以若想真正实现两者之间的”对话“，就必须使用多线程。一个线程是接收数据的，一个线程是发送数据的。不论是客户端还是服务器端，都是如此。这里就不再写，之间实现群聊功能。

2.介绍

做群聊的时候，服务器起的作用就是 数据的缓存和分发。当一个客户端发送数据给服务器端之后，服务器端要把这个数据向所有的(除了发送此数据的客户端)客户端发送这个数据，从而造成的结果是一个人在群里面发送消息，群里面所有人都能接收到。

3.注意点

①一定要在receive接收之后再分发。②要把每个客户端的socket保存在数组中

4.具体代码

服务器端

import java.io.*;
import java.net.*;
import java.util.ArrayList;
import java.util.Scanner;

//创建一个类Server管理服务器端的内容
//1.服务器端的程序运行在服务器上，所以IP地址默认是当前电脑的IP地址
class Server{
    private int port;
    private ServerSocket serverSocket;
    //private Socket socket;
    private ArrayList<Socket> sockets;
    
    public Server(int port) {
        this.port = port;
        sockets = new ArrayList<>();
    }
    
    public void start() {
        //创建服务的socket对象
        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        
        //等待连接
        while(true) {
            try {
                //接收客户端的连接
                Socket socket = serverSocket.accept();
                
                //保存这个客户端对应的socket对象
                sockets.add(socket);
                
                //创建一个线程用于发送数据
                new Send(socket).start();
                
                //创建一个线程用于接收数据
                new Receive(socket,sockets).start();
            } catch (Exception e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            
            
        }
    }
}

//发送线程
class Send extends Thread{
    private Socket socket;

    
    public Send(Socket socket) {
        this.socket = socket;
 
    }
    
    public void run() {
        Scanner scanner = null;
        PrintStream ps = null;
        
        try {
             scanner = new Scanner(System.in);           
             ps = new PrintStream(socket.getOutputStream());
             while(scanner.hasNext()) {
                 ps.println(scanner.nextLine());
             }
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally{
            scanner.close();
            ps.close();
        }
    }
}
//接收线程
class Receive extends Thread{
    private Socket socket;
    private ArrayList<Socket> lists;
    
    public Receive(Socket socket,ArrayList<Socket> lists) {
        this.socket = socket;
        this.lists = lists;
    }
    
    public void run() {
        
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            
            String line = null;
            while((line = br.readLine()) != null) {
                //分发内容
                for(Socket s:lists) {
                    //判断是不是当前这个客户端
                    if(s != socket) {
                    PrintStream ps = new PrintStream(s.getOutputStream());
                    
                    ps.println(line);
                    }
                }
            }
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
}
public class Myclass {
   public static void main(String[] args) throws IOException {
         Server server = new Server(8888);
         server.start();
   }
}

客户端(客户端可以有多个，但是代码都可以是一样的，所以我在这里就写出一个)

import java.io.*;
import java.net.*;
import java.util.Scanner;

//创建一个类Client管理客户端的内容
class Client{
   private int port;
   private String ip;
   private Socket socket;
   
   public Client(int port,String ip) {
       this.port = port;
       this.ip = ip;
   }
   
   public void start() {
       //连接服务器端
       try {
        socket = new Socket(ip,port);
       }catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
       } 
       
       //开启线程发送数据
       new Send(socket).start();
       //开启线程接收数据
       new Receive(socket).start();
   }
    
}

class Send extends Thread{
    private Socket socket;
    
    public Send(Socket socket) {
        this.socket = socket;
    }
    
    public void run() {
        Scanner scanner = null;
        PrintStream ps = null;
        
        try {
            scanner = new Scanner(System.in);
            ps = new PrintStream(socket.getOutputStream());
            
            while(scanner.hasNext()) {
                ps.println(scanner.nextLine());
            }
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            scanner.close();
            ps.close();
        }
    }
}
class Receive extends Thread{
    private Socket socket;
    
    public Receive(Socket socket) {
        this.socket = socket;
    }
    
    public void run() {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String line = null;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
}
public class Myclass {
     public static void main(String[] args) throws UnknownHostException, IOException {
        Client client = new Client(8888,"127.0.0.1");
        client.start();
     }
}

总结

一开始socket没有搞懂，后来通过查阅很多资料就大概了解是什么意思了。在网络编程的这些代码中，很多代码思路都是一样的，比如客户端和服务器端的代码就有很多相同点和类似的地方。比如都要有端口号呀，然后都有接收和发送数据等等。到今天为止网络编程学习结束，但是我自知自己还未完全掌握，甚至连百分之五十都可能没掌握到，没真正学会，所以还是得抽时间复习网络编程的这些内容，包括之前Java的部分内容。