Java程序设计实验六 Socket网络程序设计

最新推荐文章于 2024-05-15 23:38:53 发布

Ace2NoU

最新推荐文章于 2024-05-15 23:38:53 发布

阅读量5.8k

点赞数 8

文章标签：网络 java 服务器 socket 经验分享

本文链接：https://blog.csdn.net/d33332/article/details/122101031

版权

[1]实验目的：理解Socket通信原理，掌握使用Socket和ServerSocket类进行TCP Socket通信的程序设计方法。

[2]实验内容：

1、使用ServerSocket类和Socket类实现按如下协议通信的服务器端和客户端程序。

服务器程序的处理规则如下：

向客户端程序发送Verifying Server!。
若读口令次数超过3次，则发送Illegal User!给客户端，程序退出。否则向下执行步骤3）。
读取客户端程序提供的口令。
若口令不正确，则发送PassWord Wrong!给客户端，并转步骤2），否则向下执行步骤5）。
发送Registration Successful!给客户端程序。

客户端程序的处理规则如下：

读取服务器反馈信息。
若反馈信息不是Verifying Server!，则提示Server Wrong!，程序退出。否则向下执行步骤3）
提示输入PassWord并将输入的口令发送给服务器。
读取服务器反馈信息。
若反馈信息是Illegal User!，则提示Illegal User!，程序退出。否则向下执行步骤6）
若反馈信息是PassWord Wrong!，则提示PassWord Wrong!，并转步骤3），否则向下执行步骤。
输出Registration Successful!。

服务器端：

package experiment6.exp6_1;

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

public class Exp6_1_Server {
    public static void main(String[] args) throws IOException {
            ServerSocket socket = new ServerSocket(6001);
            Socket server = socket.accept();
            String password;
            int count = 0;
            PrintWriter out = new PrintWriter(server.getOutputStream(), true);//返回TCP连接提供的字节输出流，将其格式化
            BufferedReader in = new BufferedReader(new InputStreamReader(server.getInputStream()));//字节输入流转换为字符输入流，
            //BufferedReader 提供以缓冲方式读取一行字符串的方法
            out.println("Verifying Server!");
            while (true) {
                password = in.readLine(); //读取客户端数据
                System.out.println("Client：" + password);
                if (Objects.equals(password, "123456")) {
                    out.println("Registration Successful!");
                    System.out.println("Server：Registration Successful!");
                    System.exit(0);
                } else {
                    count++;
                    if (count == 3) {
                        out.println("Illegal User!");
                        System.out.println("Server： Illegal User!");
                        break;
                    } else {
                        out.println(" PassWord Wrong!");
                        System.out.println("Server： PassWord Wrong!");
                    }
                }
            }
            out.close();
            in.close();
            server.close();
            socket.close();
    }
}

客户端

package experiment6.exp6_1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Exp6_1_Client {
    public static void main(String[] args) throws IOException {
            Socket ser=new Socket("10.200.229.170",6001);
            Scanner scanner =new Scanner(System.in);
            String str,sc;
            PrintWriter out=new PrintWriter(ser.getOutputStream(),true);
            BufferedReader in=new BufferedReader(new InputStreamReader(ser.getInputStream()));
            while(true)
            {
                str=in.readLine();
                System.out.println("Server："+str);
                if(str.equals("Illegal User!")||str.equals("Registration Successful!"))
                {
                    break;
                }
                System.out.print("Client：");
                sc= scanner.next();
                out.println(sc);
            }
            out.close();
            in.close();
            ser.close();
        }

}

登录失败情况：

Server:

Client:

登录成功情况：

Server:

Client:

2、实现聊天室功能。

1）完成服务器端和一个客户端之间的聊天功能。

2）扩展部分，采用多线程技术实现一个服务器端和多个客户端之间的聊天功能。

服务器端

package experiment6.exp6_2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;

public class server implements Runnable {// 服务端
    static List<Socket> socketList= new ArrayList<>();
    // 读取 In
    static Socket socket = null;
    static ServerSocket serverSocket = null;
    public server() {// 构造方法
        try {
            serverSocket = new ServerSocket(9999);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    int offline =0;
    public static void main(String[] args) {
        System.out.println("Server");
        server t = new server();
        System.out.println("Port 9999 remains to be connected......");
        int count = 0;
        while (true) {
            try {
                socket = serverSocket.accept();
                count++;
                System.out.println(count + " client(s) connected successfully!");
                socketList.add(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
            Print p = new Print(socket);
            Thread read = new Thread(t);
            Thread print = new Thread(p);
            read.start();
            print.start();
        }
    }
    @Override
    public void run() {
        // 重写run方法
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(socket
                    .getInputStream()));

            while (true) {
                //接收消息
                String jieshou = in.readLine();
                if(jieshou == null){
                    System.out.println("One client got offline");
                    offline++;
                    if(offline ==socketList.size()){
                        System.out.println("All clients offline. Server offline now!");
                        serverSocket.close();
                        socket.close();
                        System.exit(0);
                    }
                    break;}
                else
                    System.out.println(jieshou);

                //向每一个客户发送接受的消息
                for (int i = 0; i < socketList.size(); i++) {
                    Socket socket = socketList.get(i);
                    PrintWriter out = new PrintWriter(socket.getOutputStream());
                    out.println(jieshou);
                    out.flush();
                }
            }
        } catch (Exception e) {

        }
    }
}


class Print implements Runnable {
    static List<Socket> socketList= new ArrayList<>();
    Scanner input = new Scanner(System.in);
    public Print(Socket s) {// 构造方法
        try {
            socketList.add(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String msg = bufferedReader.readLine();
                if(Objects.equals(msg, "/quit")) System.exit(0);
                for (int i = 0; i < socketList.size(); i++) {
                    //对每一个客户端发送消息
                    Socket socket=socketList.get(i);
                    PrintWriter out = new PrintWriter(socket.getOutputStream());
                    out.println("Server: "+msg);
                    out.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

客户端

package experiment6.exp6_2;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Objects;
import java.util.Scanner;

public class client implements Runnable {// 客户端
    static Socket socket = null;
    Scanner input = new Scanner(System.in);
    String name;
    client(String name){this.name=name;}
    public void main1() {
        System.out.println("Client "+name);
        try {
            socket = new Socket("localhost", 9999);
            System.out.println("Connected!");
        } catch (Exception e) {
            e.printStackTrace();
        }
        client t = new client(name);
        Read r = new Read(socket);
        Thread print = new Thread(t);
        Thread read = new Thread(r);
        print.start();
        read.start();
    }
    @Override
    public void run() {
        try {
            PrintWriter out = new PrintWriter(socket.getOutputStream());
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                //向客户端发送消息
                String msg = bufferedReader.readLine();
                if(Objects.equals(msg, "/quit")){
                    socket.close();
                    System.exit(0);
                }

                out.println(name+": "+msg);
                out.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


class Read implements Runnable {
    static Socket socket = null;
    public Read(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(socket
                    .getInputStream()));
            while (true) {
                //接受服务器的消息
                System.out.println(in.readLine());
            }
        } catch (Exception e) {
            System.out.println("Server offline! Connection Dismissed!");
            System.exit(0);
        }
    }
}

//client1
package experiment6.exp6_2;

import java.util.Scanner;

public class client1 {
    public static void main(String[] args){
        System.out.println("请输入昵称：");
        Scanner scanner = new Scanner(System.in);
        client client_1 = new client(scanner.next());
        client_1.main1();
    }
}
//client2
package experiment6.exp6_2;

public class client2 {
    public static void main(String[] args){
        client client_2 = new client("fang");
        client_2.main1();
    }
}

Server:

Client1:

Client2:

[3]实验分析

第一题比较简单，只有单个客户端和单个服务器端的简单通信，使用PrintWriter返回TCP连接提供的字节输出流，将其格式化，用BufferReader将字节输入流转化为字符输入流，同时提供以缓冲方式读取一行字符串的方法。

对于第二题，为了实现一个服务器端和多个客户端之间的通信，将读和写的功能分别置于两个线程当中，服务器端用一个socket列表来存放与所有客户端建立连接的socket，每发生一个连接，启动新的读写线程来进行通信。客户端和服务器端用BufferReader来进行整行字符串的读取。

在服务器端接收到某个客户端的消息后，还会将其进行转发，发送至每一个客户端，是的所有客户端之间能看见互相发送的消息。同时，为客户端和服务器端设立退出关键字“/quit”，输入“/quit”之后，客户端会关闭socket，结束程序，客户端下线；服务器端则会关闭所有socket，使得所有客户端也被迫退出通信。如果所有客户端均退出，服务器端自动关闭。

客户端也具备自己决定昵称的功能。

Ace2NoU

关注

8
点赞
踩
63

收藏

觉得还不错? 一键收藏
打赏
5
评论
Java程序设计实验六 Socket网络程序设计

[1]实验目的：理解Socket通信原理，掌握使用Socket和ServerSocket类进行TCP Socket通信的程序设计方法。[2]实验内容：1、使用ServerSocket类和Socket类实现按如下协议通信的服务器端和客户端程序。服务器程序的处理规则如下：向客户端程序发送Verifying Server!。若读口令次数超过3次，则发送Illegal User!给客户端，程序退出。否则向下执行步骤3）。读取客户端程序提供的口令。若口令不正确，则发送PassWord Wr
复制链接

扫一扫