代码笔记Java深入学习——实现客户端发送文件到服务器的文件传输

Posted 睡醒了没吃饱Java

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了代码笔记Java深入学习——实现客户端发送文件到服务器的文件传输相关的知识,希望对你有一定的参考价值。

  1. Server.java
  2. package com.huaxin.lesson02;
    
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.ObjectInputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    /**
     * @thing 实现客户端发送文件到服务器
     * @thing 客户端发送到客户端(本代码未实现)
     * @author Administrator
     *
     */
    
    public class Severs {
        public static void main(String[] args) {
            new Severs().initServer();
        }
    
        public void initServer() {
            try {
                ServerSocket sSocket = new ServerSocket(9191);
                System.out.println("服务器创建成功!");
                Socket socket = sSocket.accept();
                System.out.println("有客户端链接成功!");
                //准备两个流:文件输出流,socket输入流
                InputStream ins = socket.getInputStream();
                //将客户端上传的文件存到服务器里面
                ObjectInputStream ois = new ObjectInputStream(ins);
                FileOutputStream fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\临时文档\\test\\2016毕晚策划4月19(1).doc");
                System.out.println("开始读取文件……");
                
                //1.读取的数组长度
                int lenght = ois.readInt();
                //2.读取次数
                long times = ois.readLong();
                //3.读取最后一次字节长度
                int lastBytes = ois.readInt();
                byte[] bytes = new byte[lenght];
    //            ois.read(bytes);
                /**和read相比,都是读一个字节数组
                 * read不一定能读完2048个字节里面的全部字节,会继续往下走
                 * readFully是通信里面才用到的函数,将会判断流里面还有没有字节剩余
                 * 有一种情况,会在字节数组里面没有将全部字节传送到位,而阻塞在网络上,或者阻塞到发送端的网卡上
                 * readFully方法,会等大byte数组中所有数据全部读取完毕后,继续往下执行
                 * read方法,会检测流中是否还有剩余字节,如果没有,则会继续往下执行
                 * 
                 **/
                //循环读取文件
                while(times > 1){
                    ois.readFully(bytes);
                    fos.write(bytes);
                    fos.flush();
                    times -- ;
                }
                //处理最后一次字节数组
                bytes = new byte[lastBytes];
                ois.readFully(bytes);
                fos.write(bytes);
                fos.flush();
                
    //            //即将读取的文件字节数
    //            long fileSize = ois.readLong();
    //            System.out.println(fileSize);
    //            
    //            int value = ins.read();
    //            while(fileSize > 0){
    //                fileSize--;
    //                fos.write(value);
    //                fos.flush();
    //                value = ins.read();
    //            }
                System.out.println("文件接收完毕!已保存到服务器。");
                ois.close();
                fos.close();
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
            
    }

     

  3. Client.java
  4. package com.huaxin.lesson02;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    import org.omg.CORBA.portable.InputStream;
    
    public class Client {
        public int val = 2048;
        public static void main(String[] args) {
            new Client().initClient();
        }
    
        public void initClient() {
            try {
                Socket socket = new Socket("localhost",9191);
                //准备两个流,文件输入流,socket输入流
                //本地的输入流
                FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\临时文档\\test\\2016毕晚策划4月19.doc");
                //把本地的输入流发出去
                OutputStream ous = socket.getOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(ous);
                
                System.out.println("开始读发送文件……!");
                //先获取文件大小
                File file = new File("C:\\Users\\Administrator\\Desktop\\临时文档\\test\\2016毕晚策划4月19.doc");
                long fileSize = file.length();
                byte[] bytes = new byte[val];
                
                //算出即将发送字节数组的字数
                long times = fileSize/val+1;
                //算出最后一组字节数组的有效字节数
                int lastBytes = (int)fileSize%2048;
                //1.发送字节数组长度
                oos.writeInt(val);
                //2.发送次数
                oos.writeLong(times);
                oos.flush();
                //3.最后一次字节个数
                oos.writeInt(lastBytes);
                oos.flush();
                
                //读取字节数组长度的字节,返回读取字节数中的数据个数
                int value = fis.read(bytes);
                while(value != -1){
                    //偏移字节数读取
                    oos.write(bytes,0,value);
                    oos.flush();
                    value = fis.read(bytes);
                }
                
                
    //            oos.writeLong(fileSize);
    //            oos.flush();
    //            System.out.println(fileSize);
    ////            ous.write((int)fileSize);
    ////            ous.flush();
    ////            System.out.println(fileSize);
    ////            Thread.sleep(2000);
    //            
    //            //读取文件中的字节数据
    //            int value = fis.read();
    //            while(value != -1){
    //                ous.write(value);
    //                ous.flush();
    //                value = fis.read();
    //            }
                System.out.println("文件发送完毕!");
                Thread.sleep(2000);
                //关闭流
                fis.close();
                ous.close();
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

     

  5. 笔记都在代码里面

以上是关于代码笔记Java深入学习——实现客户端发送文件到服务器的文件传输的主要内容,如果未能解决你的问题,请参考以下文章

学习笔记--Java消息中间件

深入理解JVM学习笔记——-6类文件结构

Java深入学习:Future模式

Java学习笔记——Socket实现文件传输

深入理解 Java 虚拟机之学习笔记

SpringCloud-02 Eureka学习笔记