1.文件上传原理（C/S结构：客户端/服务器端）

 客户端代码

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    文件上传客户端

    步骤:
        1.创建客户端Socket对象,指定连接服务器的ip地址和端口号
        2.创建文件字节输入流FileInputStream类对象fis,绑定客户端本地源文件
        3.客户端Socket对象调用getOutputStream方法,获取客户端的字节输出流对象
        4.循环读(客户端本地文件)写(服务器)
        5.客户端Socket对象调用getInputStream方法,获取客户端的字节输入流对象
        6.客户端的字节输入流对象调用read方法,读取服务器发送回来的响应信息
        7.关闭流,释放资源

    解决问题: 客户端没有收到上传成功的响应信息
    java.net.Socket类
        成员方法:
            public void shutdownOutput() :
                关闭客户端的字节输出流,同时通知服务器,文件发送完毕,
                相当于给服务器发送了一个-1
 */
public class UpLoadClient {
    public static void main(String[] args) throws IOException {
        //1.创建客户端Socket对象,指定连接服务器的ip地址和端口号
        Socket client = new Socket("127.0.0.1", 7777);

        //2.创建文件字节输入流FileInputStream类对象fis,绑定客户端本地源文件
        FileInputStream fis = new FileInputStream("day14\\from\\1.jpg");


        //3.客户端Socket对象调用getOutputStream方法,获取客户端的字节输出流对象
        OutputStream netOs = client.getOutputStream();

        //4.循环读(客户端本地文件)写(服务器)
        int len = 0;
        byte[] bs = new byte[1024];
        while((len = fis.read(bs))!=-1) {
            netOs.write(bs,0,len);
        }

        //通知服务器,文件传输完毕,相当于给服务器发送一个-1
        client.shutdownOutput();

        //5.客户端Socket对象调用getInputStream方法,获取客户端的字节输入流对象
        InputStream netIs = client.getInputStream();

        //6.客户端的字节输入流对象调用read方法,读取服务器发送回来的响应信息
        len = netIs.read(bs);
        System.out.println("客户端收到服务器的响应信息: "+new String(bs,0,len));

        //7.关闭流,释放资源
        netIs.close();
        netOs.close();
        client.close();
        fis.close();
    }
}

服务器端代码

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

/*
    文件上传服务器端

    步骤:
        1.创建服务器端ServerSocket对象,指定端口号
        2.服务器端ServerSocket对象调用accept方法,获取连接服务器的Socket对象
        3.创建文件字节输出流FileOutputStream类的对象fos,绑定服务器端本地目标文件
        4.连接服务器的Socket对象调用getInputStream方法,获取服务器端的字节输入流对象
        5.循环读(客户端发送的信息)写(服务器端的本地目标文件)
        6.连接服务器的Socket对象调用getOutputStream方法,获取服务器端的字节输出流对象
        7.服务器端的字节输出流对象调用write方法,给客户端发送响应信息
        8.关闭流,释放资源

        解决问题:
           支持多个客户端上传,多线程版本的
 */
public class UpLoadServer4 {
    public static void main(String[] args) throws IOException {
        //1.创建服务器端ServerSocket对象,指定端口号
        ServerSocket server = new ServerSocket(7777);

        //死循环
        while(true) {
            //2.服务器端ServerSocket对象调用accept方法,获取连接服务器的Socket对象
            Socket client = server.accept();
             /*
                该方法用来控制服务端的被访问权限
                flag: true  表示所有客户端都可以访问
                flag: false 表示只允许本机的客户端访问
             */
             NetUtils.control(client,false);
            //来了一个客户端,就应该给这个客户端单独开启一个线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //创建一个新的文件名称,防止文件同名时,被覆盖
                        String newFileName = System.currentTimeMillis() + "_" + new Random().nextInt() + ".jpg";

                        //3.创建文件字节输出流FileOutputStream类的对象fos,绑定服务器端本地目标文件
                        FileOutputStream fos = new FileOutputStream(new File("day14\\upload",newFileName));

                        //4.连接服务器的Socket对象调用getInputStream方法,获取服务器端的字节输入流对象
                        InputStream netIs = client.getInputStream();

                        //5.循环读(客户端发送的信息)写(服务器端的本地目标文件)
                        int len = 0;
                        byte[] bs = new byte[1024];
                        while((len = netIs.read(bs))!=-1) {
                            fos.write(bs,0,len);
                        }
                        //6.连接服务器的Socket对象调用getOutputStream方法,获取服务器端的字节输出流对象
                        OutputStream netOs = client.getOutputStream();

                        //7.服务器端的字节输出流对象调用write方法,给客户端发送响应信息
                        netOs.write("上传成功".getBytes());

                        //8.关闭流,释放资源
                        fos.close();
                        netIs.close();
                        netOs.close();
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

        }

        //server.close();
    }
}