Fatal编程技术网
  • java/
  • JAVA KeyEvent序列化错误

JAVA KeyEvent序列化错误

java oop serialization

JAVA KeyEvent序列化错误,java,oop,serialization,client-server,keyevent,Java,Oop,Serialization,Client Server,Keyevent,我试图通过套接字对象输出流发送一个包含KeyEvent字段的对象，javadoc说KeyEvent正在实现Serializable接口，但每当我试图发送它时，就会抛出java.io.notserializableeexception 我试图发送的对象是KeyboardCommand import java.awt.Robot; public interface ICommandAction { void doAction(Robot operator); public enum ActionT

我试图通过套接字对象输出流发送一个包含
KeyEvent
字段的对象，javadoc说
KeyEvent
正在实现
Serializable
接口，但每当我试图发送它时，就会抛出
java.io.notserializableeexception

我试图发送的对象是
KeyboardCommand

import java.awt.Robot;

public interface ICommandAction {
void doAction(Robot operator);
public enum ActionType {GenericAction, MouseAction, KeyboardAction, CheckBooleanAction};
ActionType getAction();
}

错误出现在
commandOutputStream.writeObject（command）
行，这意味着它无法在发送方进行序列化

据我所知，一切都应该是可序列化的，如果有人知道我把事情搞砸了，我们非常感谢你的帮助：）

微型示例：（键盘命令相同）

在这个例子中，同样的错误也会发生

如果有什么不清楚的地方，就评论这个问题

感谢您的时间：D

您是对的，KeyEvent是原因，可能是因为它包含对源对象的引用，您的JFrame，一个可能包含可序列化和不可序列化字段的复杂对象。。。。但您并不真正需要这些信息，因此想到了一个显而易见的解决方案——不要序列化KeyEvent，而是序列化和反序列化KeyEvent包含的关键信息，即keyCode、keyChar和extendedKeyCode字段。例如，请注意以下更改：

import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.Serializable;

public class KeyboardCommand extends CommandBase {

    private static final long serialVersionUID = 8L;
    // private KeyEvent event;
    private char keyChar;
    private int keyCode;
    private int extendedKeyCode;

    public KeyboardCommand(KeyEvent event) {
        super(ActionType.KeyboardAction);
        // this.event = event;
        keyChar = event.getKeyChar();
        keyCode = event.getKeyCode();
        extendedKeyCode = event.getExtendedKeyCode();
    }

    /**
     * Presses and releases the event's key
     */
    public void key(Robot operator, int delay) {
        // operator.keyPress(event.getExtendedKeyCode());
        operator.keyPress(extendedKeyCode);
        operator.delay(delay);
        // operator.keyRelease(event.getExtendedKeyCode());
        operator.keyRelease(extendedKeyCode);
    }

    /**
     * Performs the keyboard action
     */
    @Override
    public void doAction(Robot operator) {
        // boolean isUpperCase = Character.isUpperCase(event.getKeyChar());
        boolean isUpperCase = Character.isUpperCase(keyChar);
        if (isUpperCase)
            operator.keyPress(KeyEvent.SHIFT_DOWN_MASK);
        key(operator, 20);
        if (isUpperCase)
            operator.keyRelease(KeyEvent.SHIFT_DOWN_MASK);
        System.out.println("Keyboard command executed");
    }

    @Override
    public String toString() {
        // return "KeyCode: " + this.event.getKeyCode() + ", keyChar: " + this.event.getKeyChar();
        return "KeyCode: " + keyCode + ", keyChar: " + keyChar;
    }
}
@HovercraftFullOfEels好主意，添加了导入和错误消息谢谢，但请以代码格式文本的形式发布错误，并请指出涉及哪一行（stacktrace会告诉您），请发布用于序列化的代码。事实上--错误来自ControlFrame类，我甚至没有看到你发布这个类的代码。@POrekhov我没有显式地实现
Serializable
，我使用的是默认方法，因为这个类包含的所有对象都是可序列化的。谢谢你的帮助：）我是一名学生，这是我的兼职项目，我真的被这个恼人的错误吓坏了，但是现在我可以继续了，顺便说一句，这个项目是关于远程控制computer@OE.omergunr100：谢谢你尝试改进这个问题。顺便说一句，我喜欢它too@OE.omergunr100：是的，这是一个非常方便和强大的实用程序，但我希望它是面向对象的Maybe，但到目前为止，它在自动化重复任务方面仍然非常有用，若你们使用颜色或图像匹配，它甚至可以根据屏幕上的变化做出小决定 
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class KeyboardCommand extends CommandBase {

private static final long serialVersionUID = 8L;
private KeyEvent event;

public KeyboardCommand(KeyEvent event) {
    super(ActionType.KeyboardAction);
    this.event = event;
}

/**
 * Presses and releases the event's key 
 */
public void key(Robot operator, int delay){
    operator.keyPress(event.getExtendedKeyCode());
    operator.delay(delay);
    operator.keyRelease(event.getExtendedKeyCode());
}

/**
 * Performs the keyboard action
 */
@Override
public void doAction(Robot operator){
    boolean isUpperCase = Character.isUpperCase(event.getKeyChar());
    if(isUpperCase) operator.keyPress(KeyEvent.SHIFT_DOWN_MASK);
    key(operator, 20);
    if(isUpperCase) operator.keyRelease(KeyEvent.SHIFT_DOWN_MASK);
    System.out.println("Keyboard command executed");
}

@Override
public String toString(){
    return "KeyCode: " + this.event.getKeyCode() + ", keyChar: " + this.event.getKeyChar();
}        
}

public synchronized void sendCommand(CommandBase command){
    try {
        commandOutputStream.writeObject(command); //error is here
        commandOutputStream.flush();
        System.out.println("Sent " + command.getAction().toString());
    } catch (IOException e) {
        System.out.println("Failed to send " + command.getAction().toString());
        try {
            commandOutputStream.close();
            running = false;
            this.dispose();
            System.out.println("Closing command output stream");
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        e.printStackTrace();
    }
}

public class Constants {
final static int senderPort = 20000; 
final static int receiverPort = 20001;
}

import java.awt.BorderLayout;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.SocketAddress;

import javax.swing.JFrame;

import commands.CommandBase;
import commands.KeyboardCommand;

public class ControlFrame extends JFrame implements KeyListener, Runnable{
private static final long serialVersionUID = 12L;
private Socket sendAction;
private ObjectOutputStream commandOutputStream; 

public boolean running;

public ControlFrame(Socket socket){
    super("Controller");
    this.running = true;

    this.sendAction = socket;

    setSize(Toolkit.getDefaultToolkit().getScreenSize().width / 2, Toolkit.getDefaultToolkit().getScreenSize().height / 2);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLayout(new BorderLayout());
    setVisible(true);
    try {
        this.commandOutputStream = new ObjectOutputStream(sendAction.getOutputStream());
        System.out.println("Command output stream initialized");
    } catch (IOException e) {
        System.out.println("Command output stream failed to initialize");
        e.printStackTrace();
    } 

    Thread t = new Thread(this);
    t.start();
}

public synchronized void sendCommand(CommandBase command){
    try {
        commandOutputStream.writeObject(command);
        commandOutputStream.flush();
        System.out.println("Sent " + command.getAction().toString());
    } catch (IOException e) {
        System.out.println("Failed to send " + command.getAction().toString());
        try {
            commandOutputStream.close();
            running = false;
            this.dispose();
            System.out.println("Closing command output stream");
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        e.printStackTrace();
    }
}

@Override
public void keyTyped(KeyEvent e) {
    System.out.println("Key typed");
}

@Override
public void keyPressed(KeyEvent e) {
    System.out.println("Key pressed");
    System.out.println("Key command: " + e.toString());
    sendCommand(new KeyboardCommand(e));
}

@Override
public void keyReleased(KeyEvent e) {
    System.out.println("Key released");
}

@Override
public void run() {
    addKeyListener(this);

    while(running){
        if(sendAction.isOutputShutdown())
            running = false;
    }
}
}

import java.awt.AWTException;
import java.awt.Robot;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import commands.CommandBase;
import commands.ICommandAction.ActionType;
import commands.KeyboardCommand;

public class Receiver {

public static void main(String[] args) throws IOException, ClassNotFoundException, AWTException {

    ServerSocket acceptConnection = new ServerSocket(Constants.receiverPort);
    Socket receiver = acceptConnection.accept();

    ObjectInputStream receiverInput = new ObjectInputStream(receiver.getInputStream());
    Robot operator = new Robot();

    while(true){
        Object command = receiverInput.readObject();
        if(((CommandBase)command).getAction().equals(ActionType.KeyboardAction)){
            ((KeyboardCommand)command).doAction(operator);
        }
    }
}

}

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;

import FrameResources.ControlFrame;

public class Sender {

public static void main(String[] args) throws IOException {

    final InetAddress thisIP = InetAddress.getLocalHost();

    Socket sender = new Socket();
    sender.bind(new InetSocketAddress(thisIP, Constants.senderPort));

    sender.connect(new InetSocketAddress(thisIP, Constants.receiverPort));

    ControlFrame frame = new ControlFrame(sender);
}
}

import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.Serializable;

public class KeyboardCommand extends CommandBase {

    private static final long serialVersionUID = 8L;
    // private KeyEvent event;
    private char keyChar;
    private int keyCode;
    private int extendedKeyCode;

    public KeyboardCommand(KeyEvent event) {
        super(ActionType.KeyboardAction);
        // this.event = event;
        keyChar = event.getKeyChar();
        keyCode = event.getKeyCode();
        extendedKeyCode = event.getExtendedKeyCode();
    }

    /**
     * Presses and releases the event's key
     */
    public void key(Robot operator, int delay) {
        // operator.keyPress(event.getExtendedKeyCode());
        operator.keyPress(extendedKeyCode);
        operator.delay(delay);
        // operator.keyRelease(event.getExtendedKeyCode());
        operator.keyRelease(extendedKeyCode);
    }

    /**
     * Performs the keyboard action
     */
    @Override
    public void doAction(Robot operator) {
        // boolean isUpperCase = Character.isUpperCase(event.getKeyChar());
        boolean isUpperCase = Character.isUpperCase(keyChar);
        if (isUpperCase)
            operator.keyPress(KeyEvent.SHIFT_DOWN_MASK);
        key(operator, 20);
        if (isUpperCase)
            operator.keyRelease(KeyEvent.SHIFT_DOWN_MASK);
        System.out.println("Keyboard command executed");
    }

    @Override
    public String toString() {
        // return "KeyCode: " + this.event.getKeyCode() + ", keyChar: " + this.event.getKeyChar();
        return "KeyCode: " + keyCode + ", keyChar: " + keyChar;
    }
}