【代码笔记】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. 笔记都在代码里面