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

Server.java

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();
        }
    }
        
}

Client.java

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();
        }
    }
}

笔记都在代码里面