java类对象转化为byte数组

[lijianli9]

本人有一个类
public class packhead implements Serializable
{
byte[] from = new byte[16];
byte[] to = new byte[16];
int ntype;
int nlength;
}
在socket通讯的时候这么写，但是效果却达不到，
packhead headheart = new packhead();
String strHeadFrom = "javaserver";
headheart.from = strHeadFrom.getBytes();
strHeadFrom = "vcclient";
headheart.to = strHeadFrom.getBytes();
headheart.nlength = 40;
headheart.ntype = 90;



Byte_File_Object objto= new Byte_File_Object();
byte[] bufobject1 = objto.getBytesFromObject(headheart);

System.out.print("\n转换后的数据为" + bufobject1);

packhead headto = (packhead) objto.getObjectFromBytes(bufobject1);

byte[] bufobject2 = objto.getBytesFromObject(headto);
System.out.print("\n反转回来" + bufobject2);
其中使用的转化类
class Byte_File_Object {

public static Object getObjectFromBytes(byte[] objBytes) throws Exception {
if (objBytes == null || objBytes.length == 0) {
return null;
}
ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
ObjectInputStream oi = new ObjectInputStream(bi);
return oi.readObject();
}

public static byte[] getBytesFromObject(Serializable obj) throws Exception {
if (obj == null) {
return null;
}
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(obj);
return bo.toByteArray();
}

}
转化后的数据发送到客户端是乱码，而且转换前后数据都不对应了。

[打油的程序员]

完全可以：

import java.io.*;
import java.util.Arrays;

class PackHead implements Serializable {
    byte[] from = new byte[16];
    byte[] to = new byte[16];
    int ntype;
    int nlength;
    public PackHead(byte[] from, byte[] to, int ntype, int nlength) {
	super();
	this.from = from;
	this.to = to;
	this.ntype = ntype;
	this.nlength = nlength;
    }
    
    public String toString() {
	return Arrays.toString(from) + "   " + Arrays.toString(to) + "  " + ntype + "   " + nlength;
    }
}

// 在socket通讯的时候这么写，但是效果却达不到，

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

	PackHead headheart = new PackHead("javaserver".getBytes(),"vcclient".getBytes(),40,90);
	System.out.print("旧对象是");
	System.out.println(headheart);
	
	byte[] bufobject = Byte_File_Object.getBytesFromObject(headheart);

	
	System.out.println("原对象转换后的字节对象为" + bufobject);
	System.out.println("原对象转换后的字节数据为" );
	for(int i=0 ; i<bufobject.length ; i++) {
	    System.out.print(bufobject[i] + " ");
	}
	System.out.println();

	PackHead headto = (PackHead) Byte_File_Object
		.getObjectFromBytes(bufobject);
	
	System.out.print("新对象是");
	System.out.println(headto);
	
	byte[] bufobject2 = Byte_File_Object.getBytesFromObject(headto);

	System.out.println("新对象转换后的字节数据为" + bufobject2);//此时是新对象，内存地址当然不同，结果的hashcode也是不同的
	System.out.println("新对象转换后的字节数据为" );
	for(int i=0 ; i<bufobject2.length ; i++) {
	    System.out.print(bufobject2[i] + " ");
	}
	System.out.println();

    }
}

class Byte_File_Object {
    public static Object getObjectFromBytes(byte[] objBytes) throws Exception {
	if (objBytes == null || objBytes.length == 0) {
	    return null;
	}
	ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
	ObjectInputStream ois = new ObjectInputStream(bi);
	return ois.readObject();
    }

    public static byte[] getBytesFromObject(Serializable obj) throws Exception {
	if (obj == null) {
	    return null;
	}
	ByteArrayOutputStream bo = new ByteArrayOutputStream();
	ObjectOutputStream oos = new ObjectOutputStream(bo);
	oos.writeObject(obj);
	return bo.toByteArray();
    }

}


/*
 旧对象是[106, 97, 118, 97, 115, 101, 114, 118, 101, 114]   [118, 99, 99, 108, 105, 101, 110, 116]  40   90
原对象转换后的字节对象为[B@1a679b7
原对象转换后的字节数据为
-84 -19 0 5 115 114 0 8 80 97 99 107 72 101 97 100 -16 69 -4 -30 28 -10 78 -70 2 0 4 73 0 7 110 108 101 110 103 116 104 73 0 5 110 116 121 112 101 91 0 4 102 114 111 109 116 0 2 91 66 91 0 2 116 111 113 0 126 0 1 120 112 0 0 0 90 0 0 0 40 117 114 0 2 91 66 -84 -13 23 -8 6 8 84 -32 2 0 0 120 112 0 0 0 10 106 97 118 97 115 101 114 118 101 114 117 113 0 126 0 3 0 0 0 8 118 99 99 108 105 101 110 116 
新对象是[106, 97, 118, 97, 115, 101, 114, 118, 101, 114]   [118, 99, 99, 108, 105, 101, 110, 116]  40   90
新对象转换后的字节数据为[B@1e0bc08
新对象转换后的字节数据为
-84 -19 0 5 115 114 0 8 80 97 99 107 72 101 97 100 -16 69 -4 -30 28 -10 78 -70 2 0 4 73 0 7 110 108 101 110 103 116 104 73 0 5 110 116 121 112 101 91 0 4 102 114 111 109 116 0 2 91 66 91 0 2 116 111 113 0 126 0 1 120 112 0 0 0 90 0 0 0 40 117 114 0 2 91 66 -84 -13 23 -8 6 8 84 -32 2 0 0 120 112 0 0 0 10 106 97 118 97 115 101 114 118 101 114 117 113 0 126 0 3 0 0 0 8 118 99 99 108 105 101 110 116 

  
  
  */

[打油的程序员]

新旧Byte对象的hashcode不一样

[淡定的峰哥]

你的类既然实现了Serializable接口，但是缺少一个
private static final long serialVersionUID = ×××××××××L;
这样的serialVersionUID 的属性

[lijianli9]

DataInputStream dis = new DataInputStream(socket.getInputStream());
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());

Byte_File_Object objto= new Byte_File_Object();
byte[] bufobject1 = objto.getBytesFromObject(headheart);
dos.write(bufobject1);
dos.flush();
那我转换后将这个字节发送给vc客户端，接收到得和发送的不一样，

[阳明 to life]

DataOutputStream 都是针对java对象的...
byte数组直接使用OutPutStream或者BufferedOutputStream

[lijianli9]

使用BufferedInputStream，BufferedOutputStream后还是乱码，我接收VC client发送过来的结构体可以正常解析，但是java再将这个结构体发送出去，vc client端缺无法解析。

[阳明 to life]

你这个类并不复杂，组建xml或json传输吧，用字节流跨语言总感觉怪怪的
byte[]先转成Base64码

[lijianli9]

VC端已经不能修改了，现在是要在java端做类似的通讯机制。
我觉得socket通讯都是二进制流的形式，通讯应该是不存在问题，只是我刚接触java。

[阳明 to life]

经这两个函数一转一般会出问题，你又不能保证java和c处理object to byte[]一定是一致的
getObjectFromBytes
getBytesFromObject
如果不想组件xml或json，直接按顺序from,to ,ntype,nlength输出过去也行吧

[阳明 to life]

[Quote=引用 8 楼 lijianli9 的回复:]

VC端已经不能修改了，现在是要在java端做类似的通讯机制。
我觉得socket通讯都是二进制流的形式，通讯应该是不存在问题，只是我刚接触java。
[/Quote]
那你C端是如何处理的 从对象转到Byte[]?

[xiazdong]

楼主其实不用这么麻烦。直接用ObjectOutputStream 和ObjectInputStream的readObject和writeObject方法即可。很方便
代码如下：
Client：

import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.net.Socket;

public class Client {

	public static void main(String[] args) throws Exception {
		Socket s = new Socket("localhost", 8189);
		OutputStream out = s.getOutputStream();
		ObjectOutputStream objectout = new ObjectOutputStream(out);
		packhead headheart = new packhead();
		String strHeadFrom = "javaserver";
		headheart.from = strHeadFrom.getBytes();
		strHeadFrom = "vcclient";
		headheart.to = strHeadFrom.getBytes();
		headheart.nlength = 40;
		headheart.ntype = 90;
		objectout.writeObject(headheart);
		System.out.println("发送完毕"); 
		Thread.sleep(5000);
		s.close();
	}
}

class packhead implements Serializable {
	byte[] from = new byte[16];
	byte[] to = new byte[16];
	int ntype;
	int nlength;
}

Server：

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {

	public static void main(String[] args) throws Exception{
		ServerSocket server = new ServerSocket(8189);
		Socket s = server.accept();
		InputStream in = s.getInputStream();
		ObjectInputStream objectin = new ObjectInputStream(in);
		System.out.println("1"); 
		packhead receive = (packhead)objectin.readObject();
		System.out.println("接收完毕"); 
		byte[] from = receive.from;
		byte[] to = receive.to;
		int ntype = receive.ntype;
		int nlength = receive.nlength;
		String fromString = new String(from);
		String toString = new String(to);
		System.out.println(fromString);
		System.out.println(toString);
		System.out.println(nlength);
		System.out.println(ntype);
		s.close();
	}

}

[lijianli9]

我是java 和vc通讯出现问题，
ls的不一样，

[guaiguailaoda]

LZ问题解决了没？求解答啊

[lijianli9]

解决了。
可以和我QQ联系277823847，包括心跳，封包head，包体都实现了。

[TCH790177486]

楼主，是11楼的方法么？