Java 套接字客户端永远阻塞

我正在用Java编写套接字客户端。 在程序中，我想从服务器获取信息。 当服务器接收到“GET_LIGHTS”命令时，它以JSON格式发回数据

但是在我的代码中，

bw.write（）

和

bw.flush（）

在

socket.close（）之前不起作用。
因此，BufferedReader对象尚未就绪：
br.ready（）
返回false

我的密码有错误吗

客户机代码如下所示

package monitor;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;

public class SocketClient {
    static private int port;
    static private String hostName;
    private Socket socket;

    public SocketClient(String host, int port) {
        this.hostName = host;
        this.port = port;
    }

    // get lights by JSON
    public void getLights() {
        try {
            // generate socket
            InetSocketAddress endpoint = new InetSocketAddress(hostName, port);
            socket = new Socket();
            socket.connect(endpoint);

            // setting
            OutputStreamWriter out = new OutputStreamWriter(socket.getOutputStream());
            BufferedWriter bw = new BufferedWriter(out);

            InputStreamReader in = new InputStreamReader(socket.getInputStream());
            BufferedReader br = new BufferedReader(in);

            // send command
            bw.write("GET_LIGHTS");
            bw.flush();

            // receive message from server
            System.out.println(br.readLine());

            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void initLights(ArrayList<Light> lights) {
        getLights();
    }

}

包装监视器；
导入java.io.*；
导入java.net.InetSocketAddress；
导入java.net.Socket；
导入java.util.ArrayList；
公共类SocketClient{
静态专用int端口；
静态私有字符串主机名；
专用插座；
公共SocketClient（字符串主机，int端口）{
this.hostName=host；
this.port=端口；
}
//通过JSON获取灯光
公共照明{
试一试{
//生成套接字
InetSocketAddress端点=新的InetSocketAddress（主机名、端口）；
套接字=新套接字（）；
socket.connect（端点）；
//背景
OutputStreamWriter out=新的OutputStreamWriter（socket.getOutputStream（））；
BufferedWriter bw=新的BufferedWriter（输出）；
InputStreamReader in=新的InputStreamReader（socket.getInputStream（））；
BufferedReader br=新的BufferedReader（in）；
//发送命令
写下（“获取灯光”）；
bw.flush（）；
//从服务器接收消息
System.out.println（br.readLine（））；
socket.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
公共灯光（阵列列表灯光）{
getLights（）；
}
}

编辑：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class SocketServer extends Thread{
    static final int PORT = 44344;
    static private ILS ils;
    private ServerSocket serverSocket;
    private Socket socket;

    public SocketServer(ILS ils) {
        this.ils = ils;
    }
    @Override
    public void run() {
        serverSocket = null;
        System.out.println("Server: listening");

        try {
            serverSocket = new ServerSocket(PORT);
            while(true){
                socket = serverSocket.accept();

                BufferedReader br = new BufferedReader(
                        new InputStreamReader(socket.getInputStream()));
                ArrayList<String> cmd = new ArrayList<>();
                String in;
                while( (in = br.readLine()) != null ){
                    cmd.add(in);
                }
                command(cmd);
                if( socket != null){
                    socket.close();
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        if( serverSocket != null){
            try {
                serverSocket.close();
                serverSocket = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // send message to client
    private void sendMessage(String str) {
        System.out.println(str);
        try {
            OutputStream output = socket.getOutputStream();
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(output));
            bw.write(str + "¥n");
            bw.flush();
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // error
    private void printError(String err) {
        String str = "ERROR; ";
        str += err;
        sendMessage(str);
    }

    public void command(ArrayList<String> cmd) {
        String mode = cmd.get(0);
        if(mode == null){

        }else switch(mode){
            case "MANUAL_SIG-ALL":
                System.out.println("全照明一括 信号値指定調光");
                manualSigAll(cmd.get(1));
                break;
            case "MANUAL_SIG-INDIVIDUAL":
                System.out.println("全照明独立 信号値指定調光");
                manualSigIndividual(cmd.get(1));
                break;
            case "MANUAL_ID-SIG":
                System.out.println("照明ID・信号値指定調光");
                manualIDSig(cmd.get(1));
                break;
            case "MANUAL_ID-RELATIVE":
                System.out.println("照明ID・相対信号値指定調光");
                break;
            case "DOWNLIGHT_ALL":
                System.out.println("Downlight: All Control");
                downlightAll(cmd.get(1));
                break;
            case "DOWNLIGHT_INDIVIDUAL":
                System.out.println("Downlight: Individual control");
                downlightIndividual(cmd.get(1));
                break;
            case "GET_LIGHTS":
                System.out.println("Sending lights via JSON");
                sendLights();
                break;
            default:
                System.out.println("Error: 不明なmode command");
        }
    }

    // 全照明一括 信号値指定調光
    private void manualSigAll(String sigs) {
        if(sigs == null) {
            System.out.println("信号値のフォーマットを確認してください");
        } else {
            ArrayList<Integer> s = new ArrayList<>();
            String[] buf = sigs.split(",");
            for(String i:buf) s.add(Integer.parseInt(i));
            for(Light l: ils.getLights()) {
                l.setLumPct((double)s.get(0)/255.0*100.0);
                l.setSignal(s.get(0), s.get(1));
            }
        }
        // 調光
        ils.downlightDimmer.send();

    }

    // 全照明独立 信号値指定調光
    private void manualSigIndividual(String sigs) {
        if(sigs == null) {
            System.out.println("信号値のフォーマットを確認してください");
        } else {
            ArrayList<Integer> s = new ArrayList<>();
            String[] buf = sigs.split(",");
            for(String i:buf) s.add(Integer.parseInt(i));
            for(int i=0; i<ils.getLights().size(); i++) {
                ils.getLights().get(i).setSignal(s.get(0), s.get(1));
                s.remove(0);
                s.remove(0);
            }
        }
        ils.downlightDimmer.send();
    }

    // 照明ID・信号値指定調光
    private void manualIDSig(String sigs) {
        if(sigs == null) {
            System.out.println("信号値のフォーマットを確認してください");
        } else {
            ArrayList<Integer> s = new ArrayList<>();
            String[] buf = sigs.split(",");
            for(String i:buf) s.add(Integer.parseInt(i));
            System.out.println(s.get(0));
            ils.getLight(s.get(0)).setSignal(s.get(1), s.get(2));
        }
        ils.downlightDimmer.send();
    }

    private void downlightAll(String cmd) {
        if(cmd == null) {
            printError("Check for data command.");
        } else {
            ArrayList<Double> data = new ArrayList<>();
            String[] buf = cmd.split(",");
            for(String i:buf) data.add(Double.parseDouble(i));
            for(Light l: ils.getLights()) {
                l.setLumPct(data.get(0));
                l.setTemperature(data.get(1));
            }
        }
        // dimming
        ils.downlightDimmer.send();
    }

    private void downlightIndividual(String cmd) {
        if(cmd == null) {
            printError("Check for data command.");
        } else {
            ArrayList<Integer> id = new ArrayList<>();
            ArrayList<Double> lumPct = new ArrayList<>();
            ArrayList<Integer> temp = new ArrayList<>();

            String[] buf = cmd.split(",");
            if(buf.length % 3 != 0) {printError("invalid number of data.");}

            for(int i=0; i<buf.length/3; i++) {
                int n = i*3;
                try {
                    id.add(Integer.parseInt(buf[n]));
                    lumPct.add(Double.parseDouble(buf[n + 1]));
                    temp.add(Integer.parseInt(buf[n + 2]));
                } catch (Exception e) {
                    printError(e.getMessage());
                    return;
                }
            }

            while (id.size() > 0) {
                // update light object
                Light light = ils.getLight(id.get(0));
                light.setLumPct(lumPct.get(0));
                light.setTemperature(temp.get(0));

                // remove data from array list
                id.remove(0);
                lumPct.remove(0);
                temp.remove(0);
            }

            // dimming
            ils.downlightDimmer.send();

        }
    }

    private void sendLights() {
        ObjectMapper mapper = new ObjectMapper();
        String json = "";
        try {
            json = mapper.writeValueAsString(ils.getLights());
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        // output
        sendMessage(json);
    }



}

import com.fasterxml.jackson.core.JsonProcessingException；
导入com.fasterxml.jackson.databind.ObjectMapper；
导入java.io.*；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.ArrayList；
公共类SocketServer扩展线程{
静态最终int端口=44344；
静态专用ILS；
私有服务器套接字服务器套接字；
专用插座；
公共SocketServer（ILS）{
this.ils=ils；
}
@凌驾
公开募捐{
serverSocket=null；
System.out.println（“服务器：侦听”）；
试一试{
serverSocket=新的serverSocket（端口）；
while（true）{
socket=serverSocket.accept（）；
BufferedReader br=新的BufferedReader(
新的InputStreamReader（socket.getInputStream（））；
ArrayList cmd=新的ArrayList（）；
串入；
而（（in=br.readLine（））！=null）{
cmd.add（in）；
}
指挥部（cmd）；
if（套接字！=null）{
socket.close（）；
}
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
if（serverSocket！=null）{
试一试{
serverSocket.close（）；
serverSocket=null；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
//向客户端发送消息
私有void发送消息（字符串str）{
系统输出打印项次（str）；
试一试{
OutputStream输出=socket.getOutputStream（）；
BufferedWriter bw=新的BufferedWriter（新的OutputStreamWriter（输出））；
bw.写入（str+“¥n”）；
bw.flush（）；
bw.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
//错误
私有void打印错误（字符串错误）{
String str=“ERROR；”；
str+=err；
发送消息（str）；
}
public void命令（ArrayList cmd）{
字符串模式=cmd.get（0）；
如果（模式==null）{
}else开关（模式）{
案例“手动_SIG-ALL”：
System.out.println（“全照明一括 信号値指定調光");
手动信号发生器（指令get（1））；
打破
案例“手动信号个人”：
System.out.println（“全照明独立 信号値指定調光");
手动信号发生器（指令get（1））；
打破
案例“手动识别信号”：
System.out.println（“照明身份证件・信号値指定調光");
手动IDSIG（命令get（1））；
打破
案例“手动识别-相关”：
System.out.println（“照明身份证件・相対信号値指定調光");
打破
案例“筒灯所有”：
System.out.println（“筒灯：所有控制”）；
downlightAll（命令获取（1））；
打破
案例“筒灯\个人”：
System.out.println（“筒灯：单独控制”）；
筒灯个人（命令获取（1））；
打破
案例“获取灯光”：
System.out.println（“通过JSON发送灯光”）；
sendLights（）；
打破
违约：
System.out.println（“错误：不明な模式命令）；
}
}
// 全照明一括 信号値指定調光
专用无效手动SIGALL（字符串sigs）{
如果（sigs==null）{
System.out.println（“信号値のフォーマットを確認してください");
}否则{
ArrayList s=新的ArrayList（）；
字符串[]buf=sigs.split（“，”）；
对于（stringi:buf）s.add（Integer.parseInt（i））；
对于（灯光l:ils.getLights（））{
l、 setLumPct（（双）s.get（0）/255.0*100.0）；
l、 设置信号（s.get（0），s.get（1））；
}
}
// 調光
ils.downlightDimmer.send（）；
}
// 全照明独立 信号値指定調光
私有无效手动sigs个人（字符串sigs）{
如果（sigs==null）{
System.out.println（“?
while( (in = br.readLine()) != null ){
    cmd.add(in);
}