网络编程实例之文件上传

原理:客户端读取本地的文件,把文件上传到服务器服务器在把上传的文件保存到服务器的硬盘上

步骤

1.客户端使用本地的字节输入流读取要上传的文件
2.客户端使用网络字节输出流,把读取到的文件上传到服务器
3.服务器使用网络字节输入流读取客户端上传的文件
4.服务器使用本地字节输出流把读取到的文件保存到服务器的硬盘上
5.服务器使用网络字节输出流给客户端回写-个" 上传成功"
6.客户端使用网络字节输入流读取服务器回写的数据
7.释放资源

注意: .
客户端和服务器和本地硬盘进行读写，需要使用自己创建的字节流对象(本地流)
客户端和服务器之间进行读写，必须使用Socket中提供的字节流对象(网络流)

服务器部分

文件.上传案例服务器端:读取客户端上传的文件,保存到服务器的硬盘给客户端回写”上传成功”
明确:
数据源:客户端上传的文件
目的地:服务器的硬盘d:upload\1.jpg
实现步骤:
1.创建一个服务器ServerSocket对象，,和系统要指定的端口号
2.使用ServerSocket对象中的方法accept ,获取到请求的客户端Socket对象
3.使用Socket对象中的方法get InputStream,获取到网络字节输入流Inputstream对象
4.判断d: \upload文件夹是否存在,不存在则创建
5.创建一个本地字节输出流FileOutputstream对象,构造方法中绑定要输出的目的地
6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
7.使用本地字节输出流FileoutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
8.使用Socket对象中的方法getoutputStream,获取到网络字节输出流outputstream对象
9.使用网络字节输出流0utputstream对象中的方法write,给客户端回写”上传成功”
10.释放资源(FileOutputStream, Socket , ServerSocket)

优化：
1.自定义一个文件的命名规则:防止同名的文件被覆盖
规则:域名+毫秒值+随机数
String fileName = “MXH” +System. current TimeMillis()+new Random() . nextInt( bound: 999999)+" .jpg";
2.让服务器一直处干监听状态(死循环accept方法),有一个客户端上传文件,就保存一一个文件,这样就不用上传一个文件就启动一次服务器
3.使用多线程技术,提高程序的效率,有一个客户端上传文件,就开启一个线程,完成文件的上传

public static void main(String[] args) throws IOException {

        //1.创建一个服务器ServerSocket对象，,和系统要指定的端口号
        ServerSocket serverSocket = new ServerSocket(8888);
        //优化：让服务器一直处干监听状态
        while(true){
            //2.使用ServerSocket对象中的方法accept ,获取到请求的客户端Socket对象
            Socket socket = serverSocket.accept();

            //优化：使用多线程技术,提高程序的效率,有一个客户端上传文件,就开启一个线程,完成文件的上传
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //3.使用Socket对象中的方法get InputStream,获取到网络字节输入流Inputstream对象
                        InputStream ls = socket.getInputStream();
                        //4.判断d: \\upload文件夹是否存在,不存在则创建
                        File file = new File("F://upload");
                        if(!file.exists()){
                            file.mkdir();
                        }
                        //5.创建一个本地字节输出流FileOutputstream对象,构造方法中绑定要输出的目的地
                        String fileName = "MXH" +System. currentTimeMillis()+new Random().nextInt(999999)+".jpg";
                        FileOutputStream Fos = new FileOutputStream(file+"\\"+fileName);
                        //6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
                        int len;
                        byte[] bytes = new byte[1024];
                        //7.使用本地字节输出流FileoutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
                        while((len=ls.read(bytes)) != -1){
                            System.out.println(len);
                            Fos.write(bytes,0,len);
                        }

                        //8.使用Socket对象中的方法getoutputStream,获取到网络字节输出流outputstream对象
                        OutputStream os = socket.getOutputStream();
                        //9.使用网络字节输出流0utputstream对象中的方法write,给客户端回写”上传成功”
                        os.write("上传成功".getBytes());
                        //10.释放资源(FileOutputStream, Socket , ServerSocket)
                        Fos.close();
                        socket.close();
                    }catch (IOException e){
                        System.out.println(e);
                    }
                }
            }).start();
        }
        //服务器一直运行，不用关闭
        //serverSocket.close();
    }
}

客户端部分

文件，上传案例的客户端:读取本地文件,.上传到服务器,读取服务器回写的数据
明确:
数据源:c:\1.jpg
目的地:服务器
实现步骤:
1.创建一一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
3.使用Socket中的方法getOutputstream ,获取网络字节输出流0utputStream对象
4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
5.使用网络字节输出流OutputStream对象中的方法write ,把读取到的文件上传到服务器
6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
7.使用网络字节输入流InputStream对象中的方法readi读取服务回写的数据
8.释放资源(FiLeInputStream, Socket )

优化:
read方法读取到最后一个字节会返回-1，但是在while循环中当len=-1时就停止循环了,所以服务器收不到-1 就会发生阻塞，会一直等待结束标记，且后面的代码不会执行
//解决方法：在循环结束后加上socket.shutdownOutput();

分析:
byte[] bytes = new byte[1024];
FileInputStream Fis = new FileInputStream(“F:\user.png”);
int len=Fis.read(bytes);
这段代码表示Fis会读取F:\user.png文件,并把它放在bytes 中,一次存放1024个字节,当最后一个字节存完后会返回-1

public class TcpClient {
    public static void main(String[] args) throws IOException {
        // 1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream Fis = new FileInputStream("F:\\user.png");
        //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        //3.使用Socket中的方法getOutputstream ,获取网络字节输出流0utputStream对象
        OutputStream os = socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件

        //int len =Fis.read(bytes)这样不行，这样会导致len成为常量
        int len =0;//read方法读取到最后一个字节会返回-1，但是在while循环中当len=-1时就停止循环了
                                // ，所以服务器收不到-1 就会发生阻塞，会一直等待结束标记，且后面的代码不会执行
                                //解决方法：在循环结束后加上socket.shutdownOutput();
        byte[] bytes = new byte[1024];
       /* for (int i=0;i<3;i++){
            System.out.println('第' +(i+1)+"次读取返回的结果:" +Fis.read(bytes));
            System.out.println("读取后数组b的内容为:"+ Arrays.toString(bytes));
        }*/
        while ((len=Fis.read(bytes)) != -1){
           //5.使用网络字节输出流OutputStream对象中的方法write ,把读取到的文件上传到服务器
            int leng=0;
            os.write(bytes,0,len);
      }

        socket.shutdownOutput();
        System.out.println(Fis.read(bytes));
        //6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        InputStream ls = socket.getInputStream();
        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        int len2 = ls.read(bytes);
        System.out.println(new java.lang.String(bytes,0,len2));
        //8.释放资源(FiLeInputStream, Socket )
        Fis.close();
        socket.close();
    }
}