标签: objectoutputstream

我在applet端有以下代码:

URL servlet = new URL(appletCodeBase, "FormsServlet?form=requestRoom");
URLConnection con = servlet.openConnection();

con.setDoOutput(true);
con.setDoInput(true);
con.setUseCaches(false);
con.setRequestProperty("Content-Type", "application/octet-stream");

ObjectOutputStream out = new ObjectOutputStream(con.getOutputStream());
out.writeObject(user);//user is an object of a serializable class
out.flush();
out.close();

ObjectInputStream in = new ObjectInputStream(con.getInputStream());
status = (String)in.readObject();
in.close();
if("success".equals("status")) {
    JOptionPane.showMessageDialog(rootPane, "Request submitted successfully.");
} else {
    JOptionPane.showMessageDialog(rootPane, "ERROR! Request cannot be made at this 
    time");
}

在servlet方面,我收到如下代码:

    form = request.getParameter("form");
    if("requestRoom".equals(form)) {
        String fullName, eID, reason;
        UserRequestingRoom user;

        try {
            in = new ObjectInputStream(request.getInputStream());
            user = (UserRequestingRoom)in.readObject(); …

我正在编写一个使用对象输出和输入流的应用程序.但是我有一个问题,因为我无法正确发送我的对象.我将它写入流,并且服务器给我一个类未找到异常,即使客户端和服务器都具有完全相同的此类副本(唯一的区别是包名称)具有相同的序列ID.这是我的班级:

import java.io.Serializable;

public class Message implements Serializable {

/**
 * 
 */
private static final long serialVersionUID = 1L;
private String username = null;
private String hashedPassword = null;
private Integer code = null;
private String from = null;
private String to = null;
private Object data = null;

public Message() {

}

public Message(Integer code) {
    this.code = code;
}

public Message(Integer code, Object data) {
    this.code = code;
    this.data = data;
}

public Message(String username, String hashedPassword, Integer …

我有以下问题。我可以将事务状态设置为“开始、结束或正在进行”。我设置了这个，然后将我的 Transaction 对象序列化到服务器，后者检索它。第一次（当事务处于启动模式时）像魅力一样工作，但是当我重新发送对象时，这次在“正在进行”模式下，服务器继续在“启动”模式下看到它。我已经在序列化之前的行和反序列化之后的行中测试了代码，这绝对是问题所在。任何帮助将不胜感激。相关代码片段如下：

连载

        if ((query instanceof Transaction) && !(trx.getTransactionState()==Consts.trx_start)) System.out.println("Not start");
        oos.writeObject(query);
        oos.flush();

反序列化

    while (true) {
                Object statement = null;

                try {

                    statement = ois.readObject();
                    if ((statement instanceof Transaction) && !(((Transaction) statement).getTransactionState()==Consts.trx_start)) System.out.println("Not start 2");
                    handle_statement(statement, socket);
                } catch (IOException e) {

和交易类：

    public class Transaction extends Statement{

/**
 * 
 */
private static final long serialVersionUID = -2284996855537430822L;
Statement statement_list;
int trx_state; 


/**
 * 
 */
public Transaction() {
    trx_state = Consts.trx_start;; 
}

/**
 * @param statement
 */
public …

我已经成功地使用 ObjectOutputStream 和 ObjectInputStream 来序列化和反序列化我正在编写的服务器和客户端的对象。服务器和客户端通常在两台不同的机器上，但由于它将是一个回合制纸牌游戏，我也希望用户在本地玩，然后客户端和服务器将在同一台机器上运行。

现在，我正在编写我的连接接口的替代实现。接口包含 void sendToServer(Object) 和 Object receiveFromServer() 等方法

通常 sendToServer(Object) 函数只会通过 ObjectOutputStream 发送对象，但由于对象在同一台机器上，我可以创建一个对象队列，并在每次调用发送或接收时推送和弹出。然而，问题是我不希望客户端引用服务器使用的对象，我希望它是一个副本。而且我没有复制构造函数，并且对象不可克隆。

在我的情况下你会怎么做？

我需要将此对象存储到手机的内部存储器中,并且我<uses-permission android:name="android.permission.WRITE_INTERNAL_STORAGE"></uses-permission>在清单上有该 设置.对象本身有两个静态方法用于存储并从内部存储器重新加载它:

public class SaveState implements Serializable {
static public List<FullMagazine> fms = new ArrayList<FullMagazine>();
static SaveState instance=null;

public static SaveState getInstance(){      
    if( instance == null )
        instance = new SaveState();     
    return instance;
}

public static void saveData(SaveState instance){
    ObjectOutput out;
    try {
        out = new ObjectOutputStream(new FileOutputStream("appSaveState.data"));        
        out.writeObject(instance);
        out.close();
    } catch (Exception e) {e.printStackTrace();}
}

public static SaveState loadData(){
    ObjectInput in;
    SaveState ss=null;
    try {
        in = new ObjectInputStream(new FileInputStream("appSaveState.data"));       
        ss=(SaveState) in.readObject();
        in.close();
    } catch (Exception …

public static void main(String[] args) throws Exception {
    Socket socket = new Socket("127.0.0.1", 2345);

    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
    Map<Integer, Integer> testMap = new HashMap<Integer, Integer>();

    testMap.put(1,1);
    oos.writeObject(testMap);
    oos.flush();

    testMap.put(2,2);
    oos.writeObject(testMap);
    oos.flush();

    oos.close();
}


public static void main(String[] args) throws Exception {
    ServerSocket ss = new ServerSocket(2345);
    Socket s = ss.accept();
    ObjectInputStream ois = new ObjectInputStream(s.getInputStream());

    System.out.println((HashMap<Integer, Integer>) ois.readObject());
    System.out.println((HashMap<Integer, Integer>) ois.readObject());

    ois.close;
}

上面的代码来自两个文件.运行它们时,控制台会打印相同的结果:

{1=1}
{1=1}

怎么会发生这种情况？

在客户端和服务器类中,我有一个完全相同的内部类,称为Data.使用以下命令从服务器发送此Data对象:

ObjectOutputStream output= new ObjectOutputStream(socket.getOutputStream());
output.writeObject(d);

(其中d是Data对象)

在客户端接收此对象并强制转换为Data对象:

ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
Object receiveObject = input.readObject();
if (receiveObject instanceof Data){
    Data receiveData = (Data) receiveObject;
    // some code here... 
}

我正在接受java.lang.ClassNotFoundException: TCPServer$Data这条线Object receiveObject = input.readObject();

我的猜测是它试图在服务器端寻找Data类而无法找到它,但我不确定......我该如何解决这个问题？

我对java有一个奇怪的问题.我想在ObjectOutputStream中写一个byte []并从那里写到一个新文件.该字节数组表示从磁盘读取的另一个文件.

之后,在写入新创建的文件后,我想从该文件中读取.但是现在从ObjectInputStream读取的byte []与写入的不同.

这就是我的问题:为什么这个字节[]不同？

为了清楚说明并让每个人都检查,我写了一个简短的程序,它将准确地表明我的意思:

import java.io.*;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.security.MessageDigest;
import org.bouncycastle.util.encoders.Hex;

public class MyTest {

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

        // 1st step:
        // ------------------------------------------------
        byte[] data = openFile();

        // Create file to write
        FileOutputStream fos = new FileOutputStream(new File("test"));
        ObjectOutputStream oosf = new ObjectOutputStream(fos);
        // Write byte[]-length and byte[]
        oosf.writeInt(data.length);
        oosf.write(data);

        // Flush & Close
        fos.flush();
        fos.close();

        // Print hash value of saved byte[]
        try {
            final MessageDigest messageDigest …

我正在做java服务器客户端应用程序,我有问题.当我想让ObjectInputStream卡住时,我成功地获得了客户端的套接字.

码:

serverSocket = new ServerSocket(9999);

while(true){
    System.out.println("Waiting for player");
    Socket socket = serverSocket.accept();
    System.out.println("Player connected, waiting for command");

    ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
    System.out.println("input created");      
}

输出:
Waiting for player Player connected, waiting for command

我该怎么办？

我写了以下简单的代码

public static void main(String args[]) throws FileNotFoundException, IOException, ClassNotFoundException
{
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("data.txt")));
    Human human = new Human();
    human.setAge(21);
    human.setName("Test");
    System.out.println("Human : " + human);
    oos.writeObject(human);
    human.setName("Test123");
    oos.writeObject(human);
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("data.txt")));
    Human newHuman1  = (Human)ois.readObject();
    System.out.println("newHuman1 :" + newHuman1);
    Human newHuman2  = (Human)ois.readObject();
    System.out.println("newHuman2 :" + newHuman2);
}

它打印 -

Human : Human [age=21, name=Test]
newHuman1 :Human [age=21, name=Test]
newHuman2 :Human [age=21, name=Test]

我无法理解为什么它不打印

newHuman2 :Human [age=21, name=Test123]

为什么更改实例状态不会反映在序列化对象中？