java 服务器和客户端之间利用ObjectInputStream ObjectOutputStream成对传输各种类型的数据

已于 2023-06-02 22:28:02 修改
阅读量316 收藏
点赞数 1
文章标签： java 开发语言 jvm
于 2023-04-03 12:11:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59802969/article/details/129926618
版权 

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

public class Fwq {
    static String s1="fwq1";
    static  String s2="fwq2";
    public static void main(String[] args) throws IOException {
        ServerSocket ss1=new ServerSocket(6000);
        ServerSocket ss2=new ServerSocket(6001);
        Dk1 t1=new Dk1(ss1);
        Dk2 t2=new Dk2(ss2);
        t1.start();
        t2.start();
    }
}
class Dk1 extends Thread{

    ServerSocket ss;
    Dk1(ServerSocket ss){
        this.ss=ss;
    }
    public void run(){
       while (true){
          while(true) {
             Socket sc = null;
             try {
               boolean isrun = true;
               System.out.println(8);

               sc = ss.accept();
               while (isrun == true) {


                   OutputStream os = sc.getOutputStream();
                   ObjectOutputStream objectOutputStream=new ObjectOutputStream(os);
                   String sfwq="fwq1:hello client1";
                   objectOutputStream.writeInt(sfwq.length());
                   objectOutputStream.flush();

                   objectOutputStream.write(sfwq.getBytes(StandardCharsets.UTF_8));
                   objectOutputStream.flush();
//------------------------------------------------------------------------------------------------------
                   InputStream is=sc.getInputStream();
                   ObjectInputStream objectInputStream=new ObjectInputStream(is);
//=================================================================================================
                   char c=objectInputStream.readChar();
                   System.out.println(c);

                   String  s10=objectInputStream.readUTF();
                   System.out.println(s10);

                   int t10=objectInputStream.readInt();
                   System.out.println(t10);

                   System.out.println(objectInputStream.readBoolean());

                   System.out.println(objectInputStream.read());

                   int t11=objectInputStream.readInt();
                   byte[] b11=new byte[t11];
                   objectInputStream.readFully(b11);
                   System.out.println(new String(b11));
//===========================================================================================
                   int byteLength=objectInputStream.readInt();
                   byte[] b=new byte[byteLength];

                   objectInputStream.readFully(b);
                   String s=new String(b);
                   System.out.println(s);


//-----------------------------------------------------------------------------------------------------

               }
               sc.close();

           } catch (IOException e) {
               // throw new RuntimeException(e);
               try {
                   sc.close();
               } catch (IOException ex) {
                   throw new RuntimeException(ex);
               }

               break;
           }
          }
      }
    }
}

class Dk2 extends Thread{

    ServerSocket ss;
    Dk2(ServerSocket ss){
        this.ss=ss;
    }
    public void run(){
        while (true){
            while(true) {

                Socket sc = null;
                try {
                    boolean isrun = true;
                    System.out.println(8.1);
                    sc = ss.accept();
                    while (isrun == true) {

                        OutputStream os = sc.getOutputStream();
                        ObjectOutputStream objectOutputStream=new ObjectOutputStream(os);
                        String sfwq="fwq2:hello client2";
                        objectOutputStream.writeInt(sfwq.length());
                        objectOutputStream.flush();

                        objectOutputStream.write(sfwq.getBytes(StandardCharsets.UTF_8));
                        objectOutputStream.flush();
//------------------------------------------------------------------------------------------------------
                        InputStream is=sc.getInputStream();
                        ObjectInputStream objectInputStream=new ObjectInputStream(is);



                        int byteLength=objectInputStream.readInt();
                        byte[] b=new byte[byteLength];

                        objectInputStream.readFully(b);
                        String s=new String(b);
                        System.out.println(s);


//-----------------------------------------------------------------------------------------------------

                    }
                        sc.close();


                } catch (IOException e) {
                    // throw new RuntimeException(e);
                    try {
                        sc.close();
                    } catch (IOException ex) {
                        throw new RuntimeException(ex);
                    }

                    break;
                }
            }
        }
    }
}

import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class Client3000 {
    static String jpin="hello";
    static boolean isrun=true;
    public static void main(String[] args) throws IOException, InterruptedException {
       Jp jp=new Jp();
       jp.start();

        Socket sc=new Socket("192.168.43.61",6000);
        while (isrun==true) {
            InputStream is = sc.getInputStream();
            ObjectInputStream objectInputStream=new ObjectInputStream(is);
            int byteLength=objectInputStream.readInt();
            byte[] b=new byte[byteLength];

            objectInputStream.readFully(b);
            String s=new String(b);
            System.out.println(s);

            OutputStream os = sc.getOutputStream();
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(os);
//================================================================================================
            objectOutputStream.writeChar('~');    // 一个字符
            objectOutputStream.flush();

            objectOutputStream.writeUTF("你好");   //一个字符串
            objectOutputStream.flush();

            objectOutputStream.writeInt(123456);   //一个32字节的整数
            objectOutputStream.flush();

            objectOutputStream.writeBoolean(true);  //一个布尔数
            objectOutputStream.flush();

            objectOutputStream.write(2);     //写一个字节的数据
            objectOutputStream.flush();

            byte[] b11={48,49,50};                     //写一byte数组
            objectOutputStream.writeInt(b11.length);
            objectOutputStream.flush();
            objectOutputStream.write(b11,0,b11.length);
            objectOutputStream.flush();

//===============================================================================================

            if(jpin.equals("~")){
                sc.close();
            }
            objectOutputStream.writeInt(jpin.length());
            objectOutputStream.flush();

            objectOutputStream.write(jpin.getBytes(StandardCharsets.UTF_8));
            objectOutputStream.flush();
           Thread.sleep(1000);
        }
        sc.close();
    }
}
class Jp extends  Thread{
    public synchronized void run(){
        while(true) {
            Scanner scanner = new Scanner(System.in);
            Client3000.jpin = scanner.nextLine();

        }
    }
}

 

在socket长连接中流 read() 非常重要,如果选取read方法不当,上面的服务器程序break就退不回accept()状态.

经验证，很多莫名的错误都是流的读取方法不对造成的。

 

为了解决这个流读取的问题,折腾了一两个星期,终于在一本书中发现了用object的读和写的类方法.

其他的read方法在socket长连接中都会发生问题.

还有 服务器和客户端 objectinputstram   objectoutputstream  是配对出现的.不能单方使用.

 

fwq:

​




import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Fwq {
    static String s1="fwq1";
    static  String s2="fwq2";
    static  boolean isin1=true;
    static  boolean isin2=true;
    static  boolean iszx1;
    static  boolean iszx2;
    static  boolean iscopy1;
    static  boolean iscopy2;
    static  byte[] file1;
    static  byte[]  file2;
    static  String filename1;
    static  String filename2;

    static  int  filelength1;
    static  int filelength2;
    public static void main(String[] args) throws IOException {
        ServerSocket ss1=new ServerSocket(6000);
        ServerSocket ss2=new ServerSocket(6001);
        Dk1 t1=new Dk1(ss1);
        Dk2 t2=new Dk2(ss2);
        t1.start();
        t2.start();
    }
}
class Dk1 extends Thread{

    ServerSocket ss;
    Dk1(ServerSocket ss){
        this.ss=ss;
    }
    public void run(){
        while (true){

            while(true) {
                Socket sc = null;
                try {
                    boolean isrun = true;
                    System.out.println(8);
                    Fwq.iszx1=false;
                    sc = ss.accept();
                    Fwq.iszx1=true;
//------------提示连接上服务器-----------------------------------------------------------------
                    OutputStream os1 = sc.getOutputStream();
                    ObjectOutputStream objectOutputStream1= new ObjectOutputStream(os1);
                    objectOutputStream1.writeUTF("已连接服务器1");
                    objectOutputStream1.flush();
//-----------判断对方客户端是否在线-------------------------------------------------------------
                    if(Fwq.iszx2==true){
                        objectOutputStream1.writeBoolean(true);
                        objectOutputStream1.flush();
                    }else {
                        objectOutputStream1.writeBoolean(false);
                        objectOutputStream1.flush();

                        while (Fwq.iszx2==false) {
                            Thread.sleep(1000);
                            objectOutputStream1.writeBoolean(Fwq.iszx2);
                            objectOutputStream1.flush();
                        }
                    }
 //---------判断id-----------------------------------------------------------------------
                    objectOutputStream1.writeUTF("请输入id:");
                    objectOutputStream1.flush();
                    InputStream isid=sc.getInputStream();
                    ObjectInputStream objectInputStreamid=new ObjectInputStream(isid);
                    if(!objectInputStreamid.readUTF().equals("6000")){
                        objectOutputStream1.writeUTF("id错误");
                        objectOutputStream1.flush();
                        sc.close();
                    }else{
                        objectOutputStream1.writeUTF("id正确");
                        objectOutputStream1.flush();
                    }

//---------------------------------------------------------------------------------------------------
                    while (Fwq.iszx1==true) {

                        OutputStream os = sc.getOutputStream();
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(os);
                        objectOutputStream.writeBoolean(Fwq.iszx2);
                        objectOutputStream.flush();
//-----------发送服务器2的聊天信息-----------------------------------------------------------
                        if(Fwq.isin2==true) {
                            objectOutputStream.writeChar('^');
                            objectOutputStream.flush();
                            objectOutputStream.writeUTF(Fwq.s2);
                            objectOutputStream.flush();
                            Fwq.isin2=false;
//-----------发送服务器2上传 文件---------------------------------------------------------
                        }else if(Fwq.iscopy2==true) {
                            objectOutputStream.writeChar('&');
                            objectOutputStream.flush();

                            objectOutputStream.writeUTF(Fwq.filename2);
                            objectOutputStream.writeInt(Fwq.filelength2);
                            objectOutputStream.flush();
                            objectOutputStream.write(Fwq.file2);
                            objectOutputStream.flush();

                            Fwq.iscopy2=false;
                        }else{
                            objectOutputStream.writeChar('*');
                            objectOutputStream.flush();
                        }

//-----------接收客户端1的聊天信息---------------------------------------------------------------------------
                        InputStream is = sc.getInputStream();
                        ObjectInputStream objectInputStream = new ObjectInputStream(is);
                        char pd=objectInputStream.readChar();

                        if(pd=='^') {
                            String s = objectInputStream.readUTF();
                            Fwq.s1 = s;
                            Fwq.isin1 = true;
                            pd='*';
                        }

//--------------接收客户端1上传文件---------------------------------------------------------------------------

                        if(pd=='&'){
                            Fwq.filename1=objectInputStream.readUTF();
                            Fwq.filelength1=objectInputStream.readInt();
                            Fwq.file1=new byte[Fwq.filelength1];
                            objectInputStream.readFully(Fwq.file1);
                            Fwq.iscopy1=true;
                            pd='*';
                        }

//-----------------------------------------------------------------------------------------------------

                    }
                    sc.close();

                } catch (IOException e) {
                    // throw new RuntimeException(e);
                    try {
                        sc.close();
                    } catch (IOException ex) {
                        throw new RuntimeException(ex);
                    }

                    break;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
//=====================================================================================================
class Dk2 extends Thread{

    ServerSocket ss;
    Dk2(ServerSocket ss){
        this.ss=ss;
    }
    public void run(){
        while (true){

            while(true) {
                Socket sc = null;
                try {
                    boolean isrun = true;
                    System.out.println(8.2);
                    Fwq.iszx2=false;
                    sc = ss.accept();
                    Fwq.iszx2=true;

                    OutputStream os1 = sc.getOutputStream();
                    ObjectOutputStream objectOutputStream1= new ObjectOutputStream(os1);
                    objectOutputStream1.writeUTF("已连接服务器2");
                    objectOutputStream1.flush();

                    if(Fwq.iszx1==true){

                        objectOutputStream1.writeBoolean(true);
                        objectOutputStream1.flush();
                    }else {
                        objectOutputStream1.writeBoolean(false);
                        objectOutputStream1.flush();

                        while (Fwq.iszx1==false) {
                            Thread.sleep(1000);

                            objectOutputStream1.writeBoolean(Fwq.iszx1);
                            objectOutputStream1.flush();
                        }
                    }
 //---------判断id------------------------------------------------------------------------------
                    objectOutputStream1.writeUTF("请输入id:");
                    objectOutputStream1.flush();
                    InputStream isid=sc.getInputStream();
                    ObjectInputStream objectInputStreamid=new ObjectInputStream(isid);
                    if(!objectInputStreamid.readUTF().equals("6000")){
                        objectOutputStream1.writeUTF("id错误");
                        objectOutputStream1.flush();
                        sc.close();
                    }else{
                        objectOutputStream1.writeUTF("id正确");
                        objectOutputStream1.flush();
                    }
//---------------------------------------------------------------------------------------------------
                    while (Fwq.iszx2==true) {


                        OutputStream os = sc.getOutputStream();
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(os);
                        objectOutputStream.writeBoolean(Fwq.iszx1);
                        objectOutputStream.flush();
//-----------发送服务器1的聊天信息-----------------------------------------------------------
                        if(Fwq.isin1==true) {
                            objectOutputStream.writeChar('^');
                            objectOutputStream.flush();
                            objectOutputStream.writeUTF(Fwq.s1);
                            objectOutputStream.flush();
                            Fwq.isin1=false;
//-----------发送服务器1上传 文件---------------------------------------------------------
                        }else if(Fwq.iscopy1==true) {
                            objectOutputStream.writeChar('&');
                            objectOutputStream.flush();

                            objectOutputStream.writeUTF(Fwq.filename1);
                            objectOutputStream.writeInt(Fwq.filelength1);
                            objectOutputStream.flush();
                            objectOutputStream.write(Fwq.file1);
                            objectOutputStream.flush();

                            Fwq.iscopy1=false;
                        }else{
                            objectOutputStream.writeChar('*');
                            objectOutputStream.flush();
                        }

//-----------接收客户端2的聊天信息---------------------------------------------------------------------------
                        InputStream is = sc.getInputStream();
                        ObjectInputStream objectInputStream = new ObjectInputStream(is);
                        char pd=objectInputStream.readChar();


                        if(pd=='^') {
                            String s = objectInputStream.readUTF();
                            Fwq.s2 = s;
                            Fwq.isin2 = true;
                            pd='*';
                        }

//--------------接收客户端2上传文件---------------------------------------------------------------------------

                        if(pd=='&'){
                            Fwq.filename2=objectInputStream.readUTF();
                            Fwq.filelength2=objectInputStream.readInt();
                            Fwq.file2=new byte[Fwq.filelength2];
                            objectInputStream.readFully(Fwq.file2);
                            Fwq.iscopy2=true;
                            pd='*';
                        }

//-----------------------------------------------------------------------------------------------------

                    }
                    sc.close();

                } catch (IOException e) {
                    // throw new RuntimeException(e);
                    try {
                        sc.close();
                    } catch (IOException ex) {
                        throw new RuntimeException(ex);
                    }

                    break;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

[点击并拖拽以移动]
​

3001:

 

//=====================================================================



import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Client3000 {
    static String jpin="hello";
    static boolean isjp=true;
    static boolean isrun=true;
    static  boolean iszx;
    static  String pathfile="";
    static  boolean iscp;
    static String jspath="/Users/wangzhong/1/";
    //-------------------------------------------------------------------------------------------
    // nas 功能: 列出目录全部文件   上传文件  删除文件
    public static String[] dir(String in){
        File file=new File(in);
        String[] out=file.list();
        return  out;
    }





    public static void main(String[] args) {

        try {

            Socket sc = new Socket("192.168.1.14", 6000);
            InputStream is1 = sc.getInputStream();
            //------------接收服务器提示登录信息--------------------------------------------------
            ObjectInputStream objectInputStream1 = new ObjectInputStream(is1);
            System.out.println(objectInputStream1.readUTF());
//----------判断对方服务器是否在线---------------------------------------------------
            boolean isrun=true;
            boolean iszx = objectInputStream1.readBoolean();
            if (iszx== true) {

                System.out.println("对方客户端在线");
            } else {
                System.out.println("对方客户端不在线");
                while (iszx==false){
                    Thread.sleep(1000);
                    iszx=objectInputStream1.readBoolean();
                }
            }
            //-------输入id验证id---------------------------------------------------------------
            System.out.println(objectInputStream1.readUTF());
            OutputStream outputStreamid=sc.getOutputStream();
            ObjectOutputStream objectOutputStreamid=new ObjectOutputStream(outputStreamid);

            Scanner scanner=new Scanner((System.in));
            objectOutputStreamid.writeUTF(scanner.nextLine());
            objectOutputStreamid.flush();
            System.out.println(objectInputStream1.readUTF());

            Jp jp=new Jp();
            jp.start();
//-------------------------------------------------------------------------------------
            while (iszx==true) {

                InputStream is = sc.getInputStream();
                ObjectInputStream objectInputStream = new ObjectInputStream(is);
                boolean isdf=objectInputStream.readBoolean();
                if(isdf==false){
                    System.out.println("对方客户端离线，等待对方连线");
                    Thread.sleep(3000);

                }
                char c = objectInputStream.readChar();
//-----------接收聊天信息---------------------------------------------------------------------
                if (c == '^') {
                    String s = objectInputStream.readUTF();
                    if(s.equals("&")){
                        System.out.println("文件传输开始");
                    }else {
                        System.out.println("客户端1收到:" + s);
                        if(s.equals("dir")){
                       //     String dirpath="/Users/wangzhong/nas/";
                            String[] dirfile=dir(jspath);
                            String  stringout="";
                            for(String x:dirfile){
                                stringout=stringout+x+"    ";
                            }
                            jpin="\n"+stringout+"\n"+jspath;
                            isjp=true;
                            isdf=true;
                        }
                        if(s.length()>4) {
                            String zxml = s.substring(0, 4);

                            if (zxml.equals(("send"))) {
                                pathfile = s.substring(5);
                                pathfile=jspath+pathfile;
                                iscp = true;
                            }
                        }
                    }
                    c='*';
                }

//------------接收对方客户端上传来的文件--------------------------------------------------------

                if(c=='&'){                //上传文件标志符
                    String jsfilename=objectInputStream.readUTF();
                    int jsfilelength=objectInputStream.readInt();
                    byte[] jsfile=new byte[jsfilelength];
                    objectInputStream.readFully(jsfile);

                    FileOutputStream fileOutputStream=new FileOutputStream(Client3000.jspath+jsfilename);
                    fileOutputStream.write(jsfile);
                    fileOutputStream.close();
                    System.out.println(jsfilename+"接收完成");
                    c='*';
                }

                OutputStream os = sc.getOutputStream();
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(os);
//-----------关闭程序---------------------------------------------------------------------
                if ((isjp == true)&&(isdf==true)) {
                    if (jpin.equals("~")) {
                        sc.close();
                        break;
                    }
                    //        if(!jpin.equals("&")) {
//---------发送聊天信息---------------------------------------------------------------------
                    objectOutputStream.writeChar('^');
                    objectOutputStream.flush();
                    objectOutputStream.writeUTF(jpin);
                    objectOutputStream.flush();
                    System.out.println("客户端1发送:" + jpin);
                    isjp = false;
                    iscp = false;
                    //          }
//-----------发送上传文件------------------------------------------------------------------
                }
                else if(iscp==true){
                    objectOutputStream.writeChar('&');    //发送上传文件标志符
                    objectOutputStream.flush();
                    try {
                        File file = new File(Client3000.pathfile);
                        String filename = file.getName();
                        int filelength = (int) file.length();
                        objectOutputStream.writeUTF(filename);
                        objectOutputStream.writeInt(filelength);
                        objectOutputStream.flush();

                        byte[] fsfile = new byte[filelength];
                        FileInputStream fileInputStream = new FileInputStream(file);
                        fileInputStream.read(fsfile);

                        objectOutputStream.write(fsfile);
                        objectOutputStream.flush();
                        System.out.println(filename + "发送完成");
                        iscp = false;
                        isjp = false;
                    }catch (FileNotFoundException e){
                        System.out.println("复制文件路径错误");
                        break;
                    }

                }else{
//----------发送防阻塞符------------------------------------------------------------------
                    objectOutputStream.writeChar('*');
                    objectOutputStream.flush();

                }
                Thread.sleep(200);
            }
            sc.close();
            System.out.println("客户端与服务器连接中断,重新连接");

        }catch (IOException | InterruptedException e){
            System.out.println("连接中断.重新启动程序");
            //    throw new RuntimeException(e);
        }
    }
}

//============键盘输入类==========================================================
class Jp extends  Thread{
    public synchronized void run(){
        while(true) {
            Scanner scanner = new Scanner(System.in);
            Client3000.jpin = scanner.nextLine();
            Client3000.isjp=true;

            if(Client3000.jpin.equals("&")){       //上传文件
                Client3000.pathfile=scanner.nextLine();
                Client3000.iscp=true;

            }
        }
    }
}

 

 

乐山劲松
关注
两个服务器之间互相传输数据
weixin_43434961的博客
05-20 4140
服务器获取另一个服务器上的文件和上传文件到服务器 纯属工作笔记，写的不好，请看过的留下评论，多多指教！ 获取服务器数据 import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; public class PdfConvertUtil {
Java ObjectOutputStream flush（）方法与示例
cumtb2002的博客
07-07 1447
ObjectOutputStream类flush()方法 (ObjectOutputStream Class flush() method) flush() method is available in java.io package. flush()方法在java.io包中可用。 flush() method is used to flush this stream and write b...
IO流 InputStream 字节输入流和OutputStream 字节输出流 以及实例
一个小小的码农
05-31 5365
IO流字节输入输出流IO流java IO流原理流的分类InputStream 字节输入流InputStream 应用实例OutputStream 字节输出流OutputStream 应用实例 IO流 java IO流原理 1、I/O是input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。 2、java程序中，对于数据的输入/输出操作以"流（stream）"的方式进行 3、java.io包下提供了各种”流“类的接口，用以获取不同种类的数据，并通过方法输
Java中序列化流（读取对象）（ObjectOutputStream：writeObject）、反序列化流（ObjectInputStream：readObject）
最新发布
Jackmat的博客
03-16 272
当我们利用反序列化流将数据写出文件中时，此时改变JavaBean的成员变量的数量时，在利用序列化流写入时，会出现序列化号不同的情况，从而代码会报错。利用反序列化流读取数据（注意读取时需要让JavaBean类实现Serializable接口）那么我们如何解决这种问题呢？利用序列化流写出数据。
java.io.EOFException java.io.ObjectInputStream$PeekInputStream.readFully 错误
dly120219891208的专栏
07-16 8101
omcat 启动时   java.io.EOFException at java.io.ObjectInputStream$PeekInputStream.readFully 错误     这个错误 碰到好几次了，我的tomcat使用非常频繁，而且部署项目比较多，经常会出一些自己看不懂的问题， 今天解决了这个错误 at java.io.ObjectInputStream$PeekInp
Java服务器与客户端的通信中对象流的使用
08-18
本文将详细解析如何利用对象流（ObjectInputStream和ObjectOutputStream）来完成Java服务器与客户端之间的通信，并具体探讨其中涉及到的关键知识点。 #### 一、对象序列化基础 对象序列化是指将程序中的对象状态...
【java】网络编程实例 UDP协议编写客户端和服务器端间的对象的数据传输
intsum的博客
04-22 1202
import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.net.DatagramPacket; import java.net.DatagramSocket; public class ReceiveDemo { public static void main(String[] args) throws IOException, C.
java 模拟服务器与客户端之间的通信
06-21
在Java编程语言中，模拟服务器与客户端之间的通信是一项基本任务，尤其在开发网络应用程序时。这一过程涉及到Socket编程，它是TCP/IP协议栈的一部分，允许两个应用程序通过网络进行数据交换。以下将详细介绍Java如何...
java 客户端和服务器 代码 eclipse
08-28
7. **文件传输**：如果需要在客户端和服务器之间传输文件，可以使用Socket的`FileInputStream`和`FileOutputStream`，或者使用`ObjectInputStream`和`ObjectOutputStream`来序列化和反序列化对象，包括文件对象。...
Java服务器与客户端之间传输对象流
dai_ma_dong的博客
12-05 1579
客户端User对象 package com.common; /** * 用户 */ public class User implements java.io.Serializable{ private String name; private String password; public User() { } public String ge...
Java IO流--对象流ObjectInputStream和ObjectOutputStream及对象序列化机制的理解
路宇的博客
07-01 2573
对象序列化机制： 允许把内存中的java对象转换成平台无关的二进制流，从而允许把这种二进制流永久的保存到磁盘上，或通过网络将这种二进制流传输到另一个网络节点。(序列化) 当其他程序获取了这种二进制流，就可以恢复成原来的java对象。(反序列化) 序列化 用ObjectOutputStream类保存基本数据类型或对象的机制 反序列化 用ObjectInputStream类读取基本数据类型或对象的机制 对象流的使用：ObjectOutputStream和ObjectInputStream /**
Java 文件上传案例到客户端
weixin_50158551的博客
01-02 368
Java文件上传案例到客户端
java序列化：ObjectInputStream读取、ObjectOutputStream写入
qx020814的博客
07-09 1551
java序列化的作用是：方便持久化存储到磁盘，避免程序运行结束后对象就从内存里消失，另外变换成字节序列也更便于网络运输和传播。 在java中，可以利用ObjectOutputStream类把对象写入文件中，方便存储写入的方法也很简单，只需要创建好对象，利用writeObject()方法写入文件中即可。 取出的时候也只需要利用一个对应的对象存储。外加一个打印输出流： 它可以将所有的类型写入到文件中...
JAVA IO - 一文搞懂 对象流 ObjectInputStream+ObjectOutputStream
northcastle的博客
01-19 1056
1.由一个需求引入对象流 1.1 需求描述 1.将【基本数据类型 int a = 10】, 保存到文件中，并能够从文件中恢复； 2.将 【对象类型 new Dog("旺财"，3)】,保存到文件中，并能够从文件中恢复。 1.2 需求分析 上面的两个需求可做如下分析： 1.需要将数据保存到文件中，（这个可以通过文件的写操作实现） 2.保存数据的同时，需要将 数据的类型也一起保存起来？（这个使用普通的流无法实现） 3.读取文件的时候，也要把 数据的类型读取出来？（这个使用普通的流无法实现） 1.3 需求解决
使用字节输入流(InputStream)与输出流(OutputStream)实现文件拷贝操作
小滕的Java学习旅途
12-18 3247
实现思路：1.先确定需要复制文件的路径和粘贴文件地路径，创建File对象。 2.然后创建InputStream字节输入流对象逐一依次将指定复制的文件内容一一输入程序中来。 3.最后将程序接收到的数据一一用OutputStream字节输出流输出到指定粘贴的文件中。
ObjectOutputStream/ObjectInputStream多个类输入输出总结
qq_62845325的博客
11-26 805
ObjectOutputStream/ObjectInputStream多个类输入输出总结
Java Socket文件系统传输深度解析
在Java中，Socket主要用于实现客户端与服务器之间的连接，进行数据交换。文件系统在此场景下指的是在发送方和接收方之间传输文件或对象时所涉及的存储和读取操作。 当使用Java Socket传输数据时，通常需要将数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值