尝试使用 firepropertychange、propertychangesupport 更改值

Question

我使用 propertychangesupport、propertychange 和 fireproperty change 编写 java 程序，现在它可以工作，但根本不是这样当我把它放在while条件下时，改变它只是想退出循环，

公共类主{

public static void main(String[] args) {
        CLI cli = new CLI(System.in,System.out);
        Server server = new Server(34567);
        cli.addPropertyChangeListener(server);
        new Thread(cli).start();
}

}

公共类 CLI 实现 Runnable{

private Scanner scanner;
private String userInput;
private PropertyChangeSupport pcs;
private Boolean serverIsRunning;

public CLI(InputStream in, OutputStream out){
    this.scanner = new Scanner(in);
    pcs = new PropertyChangeSupport(this);
    serverIsRunning = false;
}


@Override
public void run() {

    while (true) {
        System.out.println("pls enter your command:");
        userInput = scanner.nextLine().trim().toUpperCase();
        switch (userInput) {
            case "START":
                if (!serverIsRunning)   {
                    pcs.firePropertyChange(userInput, null, "START");
                    new Thread(new Server(34567)).start();
                    serverIsRunning = true;
                } else {
                    System.out.println("server is already running");
                }
                break;
            case "SHUTDOWN":
                if (serverIsRunning) {
                    pcs.firePropertyChange(userInput, null, "SHUTDOWN");
                    serverIsRunning = false;
                } else {
                    System.out.println("server is not running");
                }
                break;
        }
    }
}

public void addPropertyChangeListener(PropertyChangeListener pcl){
    this.pcs.addPropertyChangeListener(pcl);
}

public void removePropertyChangeListener(PropertyChangeListener pcl){
    this.pcs.removePropertyChangeListener(pcl);
}

}

公共类Server实现Runnable、PropertyChangeListener {

private int port;
private ServerSocket server;
private String userInput = "";
private Boolean serverIsRunning;

public Server(int port) {
    this.port = port;
    serverIsRunning = true;
}

public void propertyChange(PropertyChangeEvent evt) {
        userInput = evt.getNewValue().toString();
        switch (userInput) {
            case "START":
                System.out.println("Starting server...");
                serverIsRunning = true;
                break;
            case "SHUTDOWN":
                serverIsRunning = false;
                break;
        }
    }


@Override
public void run() {
    try {
        server = new ServerSocket(port);
    } catch (IOException e) { }

    while (serverIsRunning) {
        try {
            new Thread(new Client(server.accept())).start();
        } catch (IOException e) { }
    }

    try {
        server.close();
        System.out.println("shutdown");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}

Answer 1

再一次，使用监听器设计模式的主要目的是避免必须使用 while 循环来不断轮询状态变化，而是让监听器和监听器支持协同工作以通知您何时对象的状态发生变化。

其他问题：

• Bean 应保存已侦听或“绑定”字段
• bean 本身应在状态更改位置调用fireXxx 方法，而不是您的任何其他类。
• 侦听器不应具有或不需要while (true) 循环。它应该做的就是监听并响应 Bean 中的状态变化，不多也不少。

例如说你的 bean 看起来像这样：

public class Bean2 {
    // constant for the property change name
    public static final String STATE = "state";
    private PropertyChangeSupport pcs;

    // this is the "bound" field
    private String state = "";

    public Bean2() {
        pcs = new PropertyChangeSupport(this);
    }

    public String getState() {
        return state;
    }

    // notify listeners within the setter
    public void setState(String state) {
        String oldValue = this.state;
        String newValue = state;
        this.state = state;
        pcs.firePropertyChange(STATE, oldValue, newValue);
    }

    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(propertyName, listener);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(listener);
    }

    // method to remove... 

}

那么你的监听器可以这么简单：

public class Listener2 implements PropertyChangeListener {
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        System.out.println("From listener: state change -- new state: " + evt.getNewValue());
        // this code will obviously need to do more...
    }
}

并像这样使用：

public static void main(String[] args) {
    Bean2 bean = new Bean2();
    Listener2 listener = new Listener2();
    bean.addPropertyChangeListener(Bean2.STATE, listener);

    Scanner scanner = new Scanner(System.in);
    String text = "";
    while (!text.equalsIgnoreCase(EXIT)) {
        System.out.print("Enter text or \"EXIT\" to quit: ");
        text = scanner.nextLine();
        if (!text.equalsIgnoreCase(EXIT)) {
            bean.setState(text);
        }
    }
    scanner.close();
}

看，没有while循环，没有从bean调用fireXxx

---

关于您的编辑，我仍然不能 100% 确定您的整个程序设置，但可能是这样的：

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class MyServer2 {
    private static final String EXIT = "exit";
    public static final int PORT = 4444;
    private ServerSocket server;

    public MyServer2() throws IOException {
        server = new ServerSocket(PORT);
    }

    public void beanChanged(String text) {
        // *** not sure what you want to do with this text 
        // *** other than to check that it != EXIT
        if (!text.equalsIgnoreCase(EXIT)) {
            try {
                new Thread(new Client(server.accept()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            // System.exit(0); // ????
        }
    }

    public static void main(String[] args) {
        MyServer2 server = null;
        try {
            server = new MyServer2();
        } catch (IOException e) {
            e.printStackTrace();
        }
        Bean2 bean = new Bean2();
        Listener2 listener = new Listener2(server);
        bean.addPropertyChangeListener(Bean2.STATE, listener);

        Scanner scanner = new Scanner(System.in);
        String text = "";
        while (!text.equalsIgnoreCase(EXIT)) {
            System.out.print("Enter text or \"EXIT\" to quit: ");
            text = scanner.nextLine();
            if (!text.equalsIgnoreCase(EXIT)) {
                bean.setState(text);
            }
        }
        scanner.close();
    }

}

public class Bean2 {
    // constant for the property change name
    public static final String STATE = "state";
    private PropertyChangeSupport pcs;

    // this is the "bound" field
    private String state = "";

    public Bean2() {
        pcs = new PropertyChangeSupport(this);
    }

    public String getState() {
        return state;
    }

    // notify listeners within the setter
    public void setState(String state) {
        String oldValue = this.state;
        String newValue = state;
        this.state = state;
        pcs.firePropertyChange(STATE, oldValue, newValue);
    }

    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(propertyName, listener);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(listener);
    }

    // method to remove...

}

public class Listener2 implements PropertyChangeListener {
    private MyServer2 myServer2;

    public Listener2(MyServer2 myServer2) {
        this.myServer2 = myServer2;
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        // notify server by calling its public method with new value
        myServer2.beanChanged((String) evt.getNewValue());
    }
}

public class Client implements Runnable {
    private Socket socket;

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

    @Override
    public void run() {
        // TODO finish coding

    }

}

但这仍然让人感到尴尬。请注意，我通常会将我的代码放到accept() 一个新客户端的线程中，因为它会阻塞代码，例如：

new Thread(() -> {
    while (true) {
        try {
            new Thread(new Client(server.accept()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}).start();