Java网络通信(含文件上传案例)

java中的Socket类

Socket类：该类实现客户端套接字，套接字指的是两台设备之间的通信端点

在java中，提供了两个类用于实现TCP通信程序:

1. 客户端：java.net.Socket类表示，创建Socket对象，向服务器端发出连接请求，服务器端响应请求，两者建立连接开始通信
2. 服务器端：java.net.ServerSocket类表示，创建ServerSocket对象，相当于开启了一个服务，并等待客户端的连接

构造函数

• public Socket(String host,int port)：创建套接字对象并将其连接到指定主机上的指定端口号，如果指定的host是null，则相当于指定地址为回送地址

  客户端实现步骤

 * 实现步骤：
 *   1、创建一个客户端对象Socket，构造函数绑定服务器IP地址和端口号
 *   2、使用Socket对象中的函数getOutStream()获取网络字节输出流OutputStream对象
 *   3、使用网络字节输出流OutputStream对象中的函数write给服务器发送数据
 *   4、使用Socket对象中的函数getInputStream()获取网络字节输入流InputStream对象
 *   5、使用网络字节输入流InputStream对象中的函数read，读取服务器会写的数据
 *   6、释放客户端的资源
 *  注意：1、客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
 *       2、当我们创建客户端对象Socket的时候，就会去请求服务器和服务器经过三次握手建立连接，
 *       如果服务器没启动就抛出异常

服务器实现步骤

 * 服务器实现步骤：
 *  1、创建服务器ServerSocket对象和系统要定的端口号
 *  2、使用ServerSocket对象中的函数accept，获取到请求的客户端对象Socket
 *  3、使用Socket对象中的函数getInputStream()获取网络字节输入流InputStream
 *  4、使用网络字节输入流InputStream对象中的函数read()，读取客户端发送的数据
 *  5、使用Socket对象中的函数getOutputStream()获取网络字节输出流OutputStream
 *  6、使用网络字节输出流OutputStream对象中的函数write,给客户端会写数据
 *  7、释放客户端、服务器端的资源

TCP简单案例

客户端：

public class TCPClient {
    public static void  main(String[] args){
        Socket socket = null;
        try {
            socket=new Socket("127.0.0.1",8888);
            OutputStream os= socket.getOutputStream();
            os.write("hello world".getBytes());
            InputStream is=socket.getInputStream();
            byte[] bytes=new byte[1024];
            int len=is.read(bytes);
            System.out.println(new String(bytes,0,len));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端：

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket socket=null;
        try {
            serverSocket=new ServerSocket(8888);
            socket= serverSocket.accept();
            InputStream is= socket.getInputStream();
            byte[] bytes=new byte[1024];
            int len=is.read(bytes);
            System.out.println(new String(bytes,0,len));
            OutputStream os=socket.getOutputStream();
            os.write("Service hello world".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(serverSocket!=null&&socket!=null){
                try {
                    socket.close();
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

TCP文件上传案例

步骤

1. 客户端使用本地的字节输入流，读取要上传的文件

2. 客户端使用网络字节输入流，把读取到的文件上传到服务器中

3. 服务器使用网络字节输入流，读取客户端上传的文件

4. 服务器使用本地字节输出流，把读取到的文件，保存到服务器端的硬盘上

5. 服务器使用网络字节输出流，给客户端回写数据提示上传成功

6. 客户端使用网络字节输入流读取服务器回写的数据

7. 释放资源

   注意:

   ​ 客户端和服务器和本地硬盘进行读写，需要使用自己创建的字节流对象(本地流)

   ​ 客户端和服务器之间进行读写，必须使用Socket中提供的字节流对象(网络流)

   Read函数遇到的坑

   FileInputStream、FileOutputStream、InputStream、OutputStream中的read函数读取不到目标数据的结束标记-1，read函数就会进入堵塞状态

   案例:

   客户端:

   /**文件上传客户端
    *  实现步骤：
    *    1、创建一个本地字节输入流FileInputStream对象，构造函数中绑定要读取的数据源
    *    2、创建一个客户端Socket对象，构造函数中绑定服务器的IP地址和端口号
    *    3、使用Socket中的函数getOutputStream，获取网络字节输出流OutputStream对象
    *    4、使用本地字节输入流FileInputStream对象中的函数read，读取本地的文件
    *    5、使用网络字节输出流OutputStream对象中的函数write，把读取到的文件上传到服务器中
    *    6、使用网络字节输入流InputStream,获取到网络字节输入流InputStream对象
    *    7、使用网络字节输入流中InputStream对象中的函数read读取到服务器回写的数据
    *    8、释放FileInputStream、Socket资源
    * */
   

   public class TCPClient {
       public static void  main(String[] args){
           FileInputStream fis=null;
           Socket socket=null;
           try {
               fis=new FileInputStream("E:\\test.txt");
               socket=new Socket("127.0.0.1",8888);
               OutputStream os=socket.getOutputStream();
               int len=0;
               byte[] bytes=new byte[1024];
               while ((len=fis.read(bytes))!=-1){
                   os.write(bytes,0,len);
               }
               InputStream is= socket.getInputStream();
               while((len=is.read(bytes))!=-1){
                   System.out.println(new String(bytes,0,len));
               }
           } catch (IOException e) {
               e.printStackTrace();
           }finally {
               if(fis!=null&&socket!=null){
                   try {
                       fis.close();
                       socket.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   

   注意：该段代码中fis.read(bytes)和is.read(bytes)使用read函数两次，由于第一个wile循环中的判断是等于-1才结束wile循环，所以从这里开始写给服务器的数据就不包含read函数中的终止序列，所以导致服务器的read无法读取到终止序列所以len=is.read(bytes)就永远不等于-1,同样服务器回写到客户端的数据也不包含read的终止序列也会导致同样的问题

   解决方法

   在客户端:

   while ((len=fis.read(bytes))!=-1){
                   os.write(bytes,0,len);
               }
               socket.shutdownOutput();
   

   void shutdownOutput()函数是对于TCP套接字，任何以前写入的数据都会被发送，并且后跟TCP的正常连接终止序列

   服务器：

   /**文件上传服务器端
    * 实现步骤:
    * 1、创建服务器ServerSocket对象，和系统要指定的端口号
    * 2、使用ServerSocket对象中的函数accept，获取到请求的客户端Socket对象
    * 3、使用Socket对象中的函数getInputStream，获取到网络字节输入流InputStream对象
    * 4、判断服务器中存在目标文件夹，不存在则创建
    * 5、创建一个本地字节输出流FileOutputStream对象，构造函数绑定要输出的目标文件夹
    * 6、使用网络字节输入流InputStream对象中的函数read,读取客户端上传的文件
    * 7、使用本地字节输出流FileOutputStream对象中的函数write把读取到的文件保存到服务器的硬盘上
    * 8、使用Socket对象中的函数getOutputStream,获取到网络字节输出流OutputStream对象
    * 9、使用网络字节输出流OutputStream对象中的函数write，给客户端回写数据提示上传成功
    * 10、释放FileOutputStream,Socket,ServerSocket资源
    * */
   

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket server=null;
        Socket socket=null;
        OutputStream os=null;
        FileOutputStream fos=null;
        try {
            server=new ServerSocket(8888);
            socket=server.accept();
            InputStream is=socket.getInputStream();
            File file=new File("E:\\service");
            /**判断是否存在目标文件夹
             * */
            if(!file.exists()){
                file.mkdirs();
            }
            fos=new FileOutputStream(file+"\\1.txt");
            int len=0;
            byte[] bytes=new byte[1024];
            while ((len=is.read(bytes))!=-1){
                fos.write(bytes,0,len);
            }
            os= socket.getOutputStream();
            os.write("上传成功".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(socket!=null&&fos!=null&&os!=null){
                try {
                    fos.close();
                    os.close();
                    socket.close();
                    server.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

注意这里is.read(bytes)使用了read函数一次