我无法将多个传感器连接到 java 套接字程序中的服务器

Question

我已经使用套接字实现了服务器和客户端。在这种情况下，多个客户端必须能够连接。

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.HashMap;
import java.util.Set;
import sensors.FireAlarmSensor;
public class SensorServer {
    private static final int port = 9000;
    private static HashMap<String, PrintWriter> fireSensorPrintersList = new HashMap<String, PrintWriter>();
    private static HashMap<String,FireAlarmSensor> fireSensorsList = new HashMap<String,FireAlarmSensor>();
    private static String sensorIDNumber;
    private static double temperatureLevel;
    private static double CO2Level;
    private static double batteryLevel;
    private static double smokeLevel;
    public static void main(String args[]){
        System.out.println("Sensor Server Is Running");
        ServerSocket clientListener = null;
        try {
            clientListener = new ServerSocket(port);
            new sensorHandler(clientListener.accept()).start();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally {
            try {
                clientListener.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }   
    }
    public static class sensorHandler extends Thread{
        private String sensorID;
        private Socket socket;
        private BufferedReader receiver;
        private PrintWriter sender;
        public sensorHandler(Socket socket) {
            this.socket = socket;
            try {
                this.receiver = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                this.sender = new PrintWriter(socket.getOutputStream(),true);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        @Override
        public void run(){
            while(true){
                sender.println("REQUESTID");
                try {
                    sensorID = receiver.readLine();             
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if(sensorID == null){
                    System.out.println("Empty Sensor ID");
                }
                synchronized (fireSensorPrintersList) {
                    if(!fireSensorPrintersList.containsKey(sensorID)){
                        fireSensorPrintersList.put(sensorID,sender);
                        break;
                    }   
                }               
            }
            sender.println("SENSORACCEPTED");
            try{
                while(true){
                    //Set<String> sensorIDList= fireSensorPrintersList.keySet();
                    /*for(PrintWriter writer:fireSensorPrintersList.values()){
                        sensorIDNumber = fireSensorsList.get(sensorIDList).getSensorID();
                        temperatureLevel = fireSensorsList.get(sensorIDList).getTemperatureLevel();
                        batteryLevel = fireSensorsList.get(sensorIDList).getBatteryLevel();
                        CO2Level = fireSensorsList.get(sensorIDList).getCO2Level();
                        smokeLevel = fireSensorsList.get(sensorIDList).getSmokeLevel();
                    }*/
                    /*try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }*/
                }   
            }
            finally {
                try {
                    socket.close();
                    System.out.println("Sensor server closed");
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

这是客户端(传感器(的代码。

package sensors;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Serializable;
import java.net.Socket;
import java.util.Scanner;
public class FireAlarmSensor implements Serializable{
    BufferedReader lineIn;
    PrintWriter lineOut;
    private String sensorID = "Not Set";
    private BatterySensor batterySensor;
    private TemperatureSensor temperatureSensor;
    private SmokeSensor smokeSensor;
    private CO2Sensor co2Sensor;
    public FireAlarmSensor(String sensorID){
        this.sensorID = sensorID;
        this.batterySensor = new BatterySensor();   
        this.temperatureSensor = new TemperatureSensor();
        this.smokeSensor = new SmokeSensor();
        this.co2Sensor = new CO2Sensor();
    }
    public FireAlarmSensor(){
        /*JFrame frame = new JFrame();
        frame.setSize(500, 500);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);*/
    }
    public String getSensorID(){
        return this.sensorID;
    }
    public double getBatteryLevel(){
        return batterySensor.getSensorData();
    }
    public double getTemperatureLevel(){
        return temperatureSensor.getSensorData();
    }
    public double getSmokeLevel(){
        return smokeSensor.getSensorData();
    }
    public double getCO2Level(){
        return co2Sensor.getSensorData();
    }
    public void run(){
        String serverAddress = "localhost";
        Socket socket = null;
        try {
            socket = new Socket(serverAddress,9000);
            lineIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            lineOut = new PrintWriter(socket.getOutputStream(),true);
            while(true){
                String serverInput = lineIn.readLine();
                if(serverInput.startsWith("REQUESTID")){
                    Scanner userInput = new Scanner(System.in);
                    System.out.print("Enter the Sensor ID : ");
                    String sensorID = userInput.nextLine();
                    lineOut.println(sensorID);
                }
                else if(serverInput.startsWith("SENSORACCEPTED")){
                    System.out.println("Sensor Is Accepted");
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        /*finally{
            try {
                socket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }*/
    }
    public static void main(String args[]){
        FireAlarmSensor sensor = new FireAlarmSensor();
        sensor.run();
    }
}

服务器在我的程序中运行良好。它不会在任何时候崩溃，第一个传感器也可以与服务器连接，也永远不会崩溃。但是，当尝试通过运行FireAlarmSensor.class文件将另一个传感器连接到服务器时，第二个传感器会给我以下异常和崩溃。

java.net.ConnectException: Connection refused: connect
at java.net.DualStackPlainSocketImpl.connect0(Native Method)
at java.net.DualStackPlainSocketImpl.socketConnect(Unknown Source)
at java.net.AbstractPlainSocketImpl.doConnect(Unknown Source)
at java.net.AbstractPlainSocketImpl.connectToAddress(Unknown Source)
at java.net.AbstractPlainSocketImpl.connect(Unknown Source)
at java.net.PlainSocketImpl.connect(Unknown Source)
at java.net.SocksSocketImpl.connect(Unknown Source)
at java.net.Socket.connect(Unknown Source)
at java.net.Socket.connect(Unknown Source)
at java.net.Socket.<init>(Unknown Source)
at java.net.Socket.<init>(Unknown Source)
at sensors.FireAlarmSensor.run(FireAlarmSensor.java:64)
at sensors.FireAlarmSensor.main(FireAlarmSensor.java:96)

我正在使用日食霓虹灯在同一台机器上运行服务器和所有传感器。

客户端(传感器(中从 16 到 27 的行会导致错误，因为我尚未上传该 java 文件。请在运行时评论或删除它们。

Answer 1

main 方法只调用accept一次，因此只有一个客户端可以连接也就不足为奇了。尝试循环接受客户端：

private static boolean shouldExit = false;
public static void main(String args[]) {
    System.out.println("Sensor Server Is Running");
    try (ServerSocket listener = new ServerSocket(port)) {
        acceptLoop(listener);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
private static void acceptLoop(ServerSocket listener) throws IOException {
    while (!shouldExit) {
        // accept() blocks until a connection is made
        Socket client = listener.accept();
        new sensorHandler(client).start();
    }
}

这将做的是永远循环，接受新客户，直到您将shouldExit设置为true。主线程，即。

我冒昧地使用了Java 7 try-with-resources语句(try (ServerSocket listener = ...)(。它基本上做了你复杂的try-catch-final所做的 - 自动关闭ServerSocket。