引用
[*]
引用
JAVA中的对象序列化是用来讲java的类对象实例编码成字节流在传输层进行传输【这个过程可以被称作序列化】,并且在服务端接收到序列化之后的对象进行反序列化从字节流编码中重新构建对象【这个过程可以被称为反序列化】。可以这么说JAVA序列化技术为java远程通信提供了标准的线路级对象表示法,也为JAVABEANS组件结构提供了标准的持久化数据格式,【这句话引自effective java】。
[*]
[*]下面的代码例子很简单,就是一个简单的序列化与反序列化的过程。主要是将一个JAVA类对象序列化后传输到服务端,在服务端进行反序列化重构类对象。
持久化类:Persistence.java
package com.test.serializable;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Persistence implements Serializable {
private Person person ;
public Persistence(){
person = new Person();
person.setNameString("Jack");
person.setSex("M");
person.setBirthday("2013");
person.setStreet("shangdi");
person.setAddress("beijing");
}
public byte[] toBytes() {
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
ObjectOutputStream obout = new ObjectOutputStream(out);
obout.writeObject(person);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return out.toByteArray();
}
public Person readBytes(byte[] bs) {
Person person = null;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(bs);
ObjectInputStream in = new ObjectInputStream(byteIn);
person = (Person) in.readObject();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return person;
}
public class Person implements Serializable {
String nameString;
String sex;
String birthday;
String address;
String street;
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
}
}
客户端类:Client.java
package com.test.serializable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
private String ipAddress = "127.0.0.1";
private int port = 9000;
private Persistence persistence ;
Socket socket;
public Client() {
persistence = new Persistence();
try {
socket = new Socket(ipAddress, port);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void outToServer() throws IOException {
System.out.println("-----Client Begin Send Data-----");
OutputStream outputStream = socket.getOutputStream();
byte b[] = new byte[2048];
b = persistence.toBytes();
outputStream.write(b);
outputStream.close();
}
public static void main(String args[]) throws IOException{
Client client = new Client();
client.outToServer();
}
}
服务端类:Server.java
package com.test.serializable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import com.bes.serializable.Persistence.Person;
public class Server {
ServerSocket serverSocket;
BufferedReader bufferedReader = null;
Socket socket;
public Server(){
try {
serverSocket = new ServerSocket(9000);
System.out.println("Waiting For Accept Client ");
socket = serverSocket.accept();
System.out.println("Accepted Client ");
}
catch (IOException e) {
e.printStackTrace();
}
}
public void readFromClient(){
try {
System.out.println("------Begin Received From Client------");
Persistence persistence = new Persistence();
InputStream inputStream = socket.getInputStream();
byte b [] = new byte[2048];
inputStream.read(b);
Person object = persistence.readBytes(b);
System.out.println("Read From Client Data is :" + object.getAddress());
System.out.println("Read From Client Data is :" + object.getBirthday());
System.out.println("Read From Client Data is :" + object.getNameString());
System.out.println("Read From Client Data is :" + object.getStreet());
System.out.println("Read From Client Data is :" + object.getSex());
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String args[]){
Server s = new Server();
s.readFromClient();
}
}
分享到:
相关推荐
本主题“netty传输kryo序列化的对象基于socket传输”探讨的是如何结合Netty和Kryo,实现高效、可靠的网络数据传输。首先,我们需要了解Kryo序列化的基本原理。Kryo通过跟踪对象引用和存储类型信息来优化序列化过程,...
这里`User`类需要实现`Serializable`接口,以便它可以被序列化并安全地通过网络传输。 3. **处理异常和关闭资源** 在编写网络程序时,异常处理和资源管理非常重要。使用try-with-resources语句可以确保所有打开...
在Java编程中,Socket通信是实现网络间进程通信的一种方式,而对象序列化则是将Java对象转换为字节流,以便在网络中传输或存储的重要技术。本教程将深入讲解如何结合Socket通信和对象序列化来实现在不同系统之间传递...
本篇将深入探讨如何通过Socket传递Java对象,重点讲解对象序列化的过程。 首先,让我们理解什么是Socket。Socket在计算机网络中是一种进程间通信机制,它允许两个网络应用程序之间建立连接并交换数据。在Java中,`...
Java对象序列化是一种将对象转换为字节流的过程,以便可以将其存储在磁盘上,或者在网络中进行传输。这是Java平台提供的一种功能,允许程序员将任何Java对象持久化,即将其状态保存到磁盘,或者在网络中进行传输。...
对象序列化是将一个对象的状态转换为可存储或可传输的形式的过程,这在分布式系统、网络通信和持久化存储中非常常见。TCP(Transmission Control Protocol)是一种面向连接的、可靠的、基于字节流的传输层通信协议。...
在这个示例中,我们可以使用`ObjectInputStream`和`ObjectOutputStream`,因为它们可以处理Java对象的序列化和反序列化。 ```java ObjectInputStream input = new ObjectInputStream(clientSocket.getInputStream())...
1. **创建可序列化类**:在Java中,你需要确保要传输的对象类实现了`Serializable`接口。例如,你可能有一个`Message`类,其中包含一些字段,如消息内容、发送者等。 ```java public class Message implements ...
在实际应用中,可能还需要处理网络异常、并发连接、多线程、数据序列化和反序列化等问题。例如,C++中的结构体可以通过`htonl`、`htons`等函数进行字节序转换,以适应网络传输,因为Java和C++可能在不同的机器架构上...
1. 序列化(Serialization):在Java中,对象序列化是将对象的状态转换为字节序列的过程,以便存储或在网络上传输。要使一个类支持序列化,只需要在类定义上添加`implements Serializable`即可。序列化时,Java会...
Java序列化是将对象转换为字节流的过程,以便于存储或在网络上传输。要使一个类可序列化,你需要在类定义上实现`Serializable`接口。例如: ```java public class MyObject implements Serializable { // 类的属性...
Java提供了`java.io.ObjectOutputStream`和`java.io.ObjectInputStream`类,可以实现对象的序列化和反序列化,便于在网络中传输。 8. **异常处理**: 为了确保程序的健壮性,Java的异常处理机制在编写网络和文件操作...
在这个示例中,我们将关注如何在TCP/IP协议下通过序列化技术来传输对象。序列化在网络通信中扮演着至关重要的角色,因为它允许我们将对象转换为字节流,以便在不同系统之间进行数据交换。 首先,我们要理解TCP/IP...
在对象序列化场景中,`ObjectOutputStream`和`ObjectInputStream`用于将对象写入或从文件读取。这些类继承自`OutputStream`和`InputStream`,专门用于处理对象的序列化和反序列化。 #### 结论 对象序列化、网络...
对象序列化是指将对象状态信息转换为可以存储或传输的形式的过程,Java通过ObjectOutputStream和ObjectInputStream实现对象的序列化和反序列化。数字签名是利用公钥密码学原理对电子数据进行的电子签名,通过它能够...
Java的序列化机制允许我们将对象的状态转换为字节流,这样就可以通过Socket进行传输。 为了序列化一个对象,我们需要在类定义上添加`implements Serializable`,然后可以使用`ObjectOutputStream`将对象写入输出流...
在Java编程领域,网络编程是不可或缺的一部分,而Socket通信则是实现网络数据传输的基础。本案例主要探讨了如何使用Java的Socket API进行简单的文件传输。在这个过程中,我们将涉及到以下几个关键知识点: 1. **...
总结,Qt与Java之间的Socket通信涉及了网络编程、JSON序列化和反序列化、多线程处理(特别是在Java中处理并发连接时)、以及错误处理等多个技术点。理解并熟练掌握这些知识点,可以构建可靠的跨平台通信系统。
在Java中,我们可以使用`java.net.Socket`类来创建客户端连接,而`java.net.ServerSocket`用于服务器端监听连接请求。在C++中,我们可以利用套接字接口(如`socket.h`)来实现相同的功能。 标题中的"Java和C++的...
6. **数据序列化与反序列化**:在Socket传输中,对象通常需要转化为字节流进行传输,因此数据序列化和反序列化的技术也至关重要。 7. **套接字选项和属性**:如何配置Socket以满足特定的网络需求,如设置超时、启用...