本文主要是介绍java网络多线程专题，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 一、网络的相关概念：
• • • • • 网络通信
        • ip地址
        • ipv4地址分类
        • 域名
        • 端口号
        • 网络协议
• TCP和UDP：
• InetAddress类：
• • 相关方法：
  • 代码展示：
• Socket:
• • TCP网络通信编程应用案例（使用字节流）
  • • 服务端代码
    • 客户端代码：
  • TCP网络通信编程应用案例2
  • • 服务端代码：
    • 客户端代码：
  • TCP网络通信编程应用案例3（使用字符流）
  • • 服务端代码：
    • 用户端代码：
  • TCP网络通信编程应用案例4
  • • 服务端代码：
    • 用户端代码：
• netstat指令
• UDP网络通信编程
• • 基本介绍：
  • UDP编程的基本流程
  • UDP网络通信编程
• TCP和UDP综合案例
• • 案例1
  • • 服务端代码：
    • 客户端代码：
  • 案例2
  • • 接收端代码：
    • 发送端代码：
  • 案例3
  • • StreamUtls工具类
    • 服务端代码：
    • 用户端代码：

一、网络的相关概念：

网络的相关概念：

• 网络通信

• 概念：两台设备之间通过网络实现数据传输

• 网络通信：将数据通过网络从一台设备传输到另一台设备

• java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

• ip地址

• 概念：用于唯一标识网络中的每台计算机

• 查看ip地址：ipconfig

• ip地址的表示形式：点分十进制 xx.xx.xx.xx

• 每一个十进制数的范围：0~255

• ip地址的组成=网络地址+主机地址，比如：192.168.16.69，192.168.16为网络地址（例如家庭地址中的北京市海淀区朝阳小区），69为主机地址（相当于门牌号）

• ilPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址

• 由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

• ipv4地址分类

• 域名

1. 举例：www.baidu.com
2. 好处：为了方便记忆，解决记ip的困难
3. 概念：将ip地址映射成域名

• 端口号

1. 概念：用于标识计算机上某个特定的网络程序
2. 表示形式：以整数形式，范围0~65535
3. 0~1024已经被占用，比如ssh 22,ftp 21,smtp 25,http 80
4. 常见的网络程序端口号

• tomcat:8080
• mysql:3306
• oracle:1521
• sqlserver:1433

ip定位主机，端口定位服务，访问要ip+端口

• 网络协议

协议(tcp/ip)

TCP/IP中文译名传输控制协议/因特网互联协议，又叫网络通讯协议，是Internet国际互联网络的基础

TCP和UDP：

• TCP协议：

1. 使用TCP协议前，须先建立TCP连接，形成传输数据通道
2. 传输前，采用三次握手方式，是可靠的
3. TCP协议进行通信的两个应用进程：客户端，服务端
4. 在连接中可进行大数据量的传输
5. 传输完毕，需释放已建立的连接，效率低

• UDP协议：用户数据协议

1. 将数据、源、目的封装成数据包，不需要建立连接
2. 每个数据包的大小限制在64K内
3. 因无需连接，故是不可靠的
4. 发送数据结束时无需释放资源（因为不是面向连接的），速度快
5. 举例：（厕所通知：发短信）

三次握手举例：

UDP举例：

不进行握手确认，直接发送数据,类似于发短信

InetAddress类：

相关方法：

1. 获取本机InetAddress对象 getLocalHost
2. 获取指定主机名/域名获取ip地址对象 getByName
3. 获取InetAddress对象的主机名 getHostName
4. 获取InetAddress对象的地址 getHostAddress

代码展示：

package com.hsp.net;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * Description
 * User:
 * Date:
 * Time:
 * InetAddress类方法的使用
 */
public class test01 {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//LAPTOP-2UERK2QG/192.168.205.1

        //根据指定的主机名获取对象
        InetAddress localhost2 = InetAddress.getByName("LAPTOP-2UERK2QG");

        //根据域名获取对象
        InetAddress localHost3 = InetAddress.getByName("www.baidu.com");

        //通过InetAddress对象获取对应的主机名地址等信息

        //获取主机名
        String hostName = localHost.getHostName();
        System.out.println("主机名:"+hostName);

        //获取ip地址
        String hostAddress = localHost.getHostAddress();
        System.out.println("ip地址："+hostAddress);
    }
}

Socket:

基本介绍：

1. 套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准
2. 通信的两端都要有Socket，是两台机器间通信的端点
3. 网络通信其实就是Socket间的通信
4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输
5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端
   

TCP网络通信编程应用案例（使用字节流）

1. 编写一个服务器端和一个客户端
2. 服务器端在9999端口监听
3. 客户端连接到服务器端，发送hello world然后退出
4. 服务器端接收到客户端发送的信息，输出，并退出

服务端代码

package com.hsp.net.socket;



import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**服务端
 * Description
 * User:
 * Date:
 * Time:
 */
public class SSocketTCP01Server {
    public static void main(String[] args) throws IOException {
        // 1.在本季的9999端口监听，等待连接
        //前提是9999端口没有被占用
        //细节：这个ServerSocket可以通过accept()返回多个Socket[高并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket ="+socket.getClass());
        //3.通过socket.getInputStream()读取客户端写入到数据通道的数据，显示
        InputStream in = socket.getInputStream();
        byte[] bt = new byte[1024];
        int readLen = 0;
        while((readLen= in.read(bt)) != -1){
            System.out.println(new String(bt,0,readLen));
        }
        //关闭流和socket
        in.close();
        socket.close();
        serverSocket.close();

    }
}

客户端代码：

package com.hsp.net.socket;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**客户端
 * Description
 * User:
 * Date:
 * Time:
 */
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1.连接服务器（ip,端口）
        //连接本机的9999端口
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端："+socket.getClass());
        //2.连接上后，生成Socket,通过
        //socket.getOutputStream()
        OutputStream out = socket.getOutputStream();
        //3.通过输出流，写入数据到数据通道
        out.write("hello server".getBytes());
        //4.关闭流对象和socket,必须关闭
        out.close();
        socket.close();
        System.out.println("客户端退出了");
    }
}

TCP网络通信编程应用案例2

1. 编写一个服务器端和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务器端，发送hello server,并接收服务器端返回的hello,client再退出
4. 服务器端接收到客户端发送的信息，输出hello client再退出

服务端代码：

package com.hsp.net.socket;

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

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SSocketTCP02Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端等待连接中...");
        Socket socket = serverSocket.accept();
        System.out.println("服务端 端口号9999 收到连接");
        System.out.println("服务端向用户端发送信息");
        OutputStream out = socket.getOutputStream();
        out.write("hello client".getBytes());

        socket.shutdownOutput();

        InputStream in = socket.getInputStream();
        System.out.println("服务端接收来自用户端的信息");
        byte[] bt = new byte[1024];
        int length = 0;
        while((length=in.read(bt))!=-1){
            System.out.println(new String(bt,0,length));
        }

        socket.shutdownInput();

        in.close();
        out.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出");
    }
}

客户端代码：

package com.hsp.net.socket;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        System.out.println("用户端:"+socket);
        OutputStream out = socket.getOutputStream();
        System.out.println("用户端向服务端发送信息");
        out.write("hello serve".getBytes());

        socket.shutdownOutput();

        InputStream in = socket.getInputStream();
        System.out.println("用户端接收来自服务端的信息");
        byte[] bt = new byte[1024];
        int length = 0;
        while((length=in.read(bt))!=-1){
            System.out.println(new String(bt,0,length));
        }

        socket.shutdownInput();

        in.close();
        out.close();
        socket.close();
        System.out.println("用户端退出");

    }
}

TCP网络通信编程应用案例3（使用字符流）

1. 编写一个服务器端和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务器端，发送hello server,并接收服务器端返回的hello,client再退出
4. 服务器端接收到客户端发送的信息，输出hello client再退出

这里需要现将字节流利用转换流转换成字符流，服务端接收到字节流，在转换成字符流进行输出

服务端代码：

package com.hsp.net.socket;

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

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SSocketTCP03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端等待连接中...");
        Socket socket = serverSocket.accept();
        System.out.println("服务端 端口号9999 收到连接");
        System.out.println("服务端向用户端发送信息");
        OutputStream out = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(out));
        bufferedWriter.write("hello client:字符流");
        bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        bufferedWriter.newLine();//插入一个换行符,表示写入的内容结束，注意，要求对方使用readLine()
        socket.shutdownOutput();

        InputStream in = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
        System.out.println("服务端接收来自用户端的信息");
        String s = bufferedReader.readLine();
        System.out.println(s);

        socket.shutdownInput();

        in.close();
        out.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出");
    }
}

用户端代码：

package com.hsp.net.socket;


import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        System.out.println("用户端:"+socket);
        OutputStream out = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(out));
        bufferedWriter.write("hello serve:字符流");
        bufferedWriter.flush();
        bufferedWriter.newLine();
        System.out.println("用户端向服务端发送信息");

        socket.shutdownOutput();

        InputStream in = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
        System.out.println("用户端接收来自服务端的信息");
        String s = bufferedReader.readLine();
        System.out.println(s);

        socket.shutdownInput();

        in.close();
        out.close();
        socket.close();
        System.out.println("用户端退出");

    }
}

TCP网络通信编程应用案例4

1. 编写一个服务器端和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务器端，发送一张图片e:\qie.png
4. 服务器端接收到客户端发送的图片，保存在src下发送“收到图片”再退出
5. 客户端接收到服务端发送的收到图片再退出
6. 该程序要求使用StreamUtils.java

StreamUtils的作用：将输入流转换成byte[],即可以把文件的内容读入到byte[]

示意图：

使用BufferedInputStream和BufferedOutputStream字节流

服务端代码：

package com.hsp.net.socket;

import com.hsp.net.StreamUtils;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.stream.Stream;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SSocketTCP04Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();

        //接收用户端传递的图片数组，并将其输出在src目录下
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamTobytes(bis);
        socket.shutdownInput();

        String filepath = "src/test.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filepath));
        bos.write(bytes);


        //服务端向用户端发送信息
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("图片发送成功");
        bw.flush();
        bw.newLine();
        socket.shutdownOutput();

        bw.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

用户端代码：

package com.hsp.net.socket;

import com.hsp.net.StreamUtils;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class SocketTCP04Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);

//        //将图片转换成字节数组
        String filepath = "E:\\test.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));
        byte[] bytes = StreamUtils.streamTobytes(bis);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        socket.shutdownOutput();

        //用户端接收服务端发送的消息
//        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        InputStream inputStream = socket.getInputStream();
        System.out.println(StreamUtils.streamToString(inputStream));
        socket.shutdownInput();
//        br.close();
        inputStream.close();
        bos.close();
        bis.close();
        socket.close();


    }
}

netstat指令

1. netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2. netstat -an | more 可以分页显示
3. netstat -anb 查看是端口是由哪个程序占用的
4. 要求在dos控制台下执行
   
   说明：

（1）Listening表示某个端口在监听

（2）如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息

UDP网络通信编程

基本介绍：

1. 类DatagramSocket和DatagramPacket实现了基于UDP协议网络程序
2. UDP数据报通过数据报套接字（socket）DatagramSocket发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
3. DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
4. UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接

UDP编程的基本流程

1. 核心的两个类/对象 DatagramSocket于DatagramPacket
2. 建立发送端，接收端
3. 建立数据包
4. 调用DatagramSocket的发送，接收方法
5. 关闭DatagramSocket

UDP网络通信编程

TCP和UDP综合案例

案例1

1. 使用字符流的方式编写一个客户端程序和服务器端程序
2. 客户端发送"name"，服务器端接收到后，返回“我是nova”,nova是你自己的名字
3. 客户端发送"hobby",服务器端接收到后，返回"编写java程序"
4. 不是这两个问题，回复"你说啥呢"

服务端代码：

package com.hsp.net.homework;

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

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class homework01Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);

        System.out.println("服务端等待接收数据...");
        Socket socket = serverSocket.accept();

        BufferedReader bf = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        String s = bf.readLine();
//        socket.shutdownInput();

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        if("name".equals(s)){
            bw.write("我是novo,是你自己的名字");
            bw.flush();
            bw.newLine();
//            socket.shutdownOutput();
        }else if("hobby".equals(s)){
            bw.write("编写java程序");
            bw.flush();
            bw.newLine();
//            socket.shutdownOutput();
        }else{
            bw.write("不清楚");
            bw.flush();
            bw.newLine();
//            socket.shutdownOutput();
        }

        //关闭资源
        bw.close();
        bf.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务器端退出");

    }
}

客户端代码：

package com.hsp.net.homework;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class homework02Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        //向Server发送数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

        Scanner sc = new Scanner(System.in);
        String next = sc.next();
        bw.write(next);

        bw.newLine();
        bw.flush();

//        socket.shutdownOutput();

        //接收来自服务端的信息
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();

//        socket.shutdownInput();
        System.out.println("服务器说:"+s);

        //关闭资源
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

案例2

1. 编写一个接收端A和一个发送端B，使用UDP协议完成
2. 接收端在8888端口等待接收数据(receive)
3. 发送端向接收端发送数据"四大名著是哪些"
4. 接收端接收到发送端发送的问题后，返回“四大名著是《红楼梦》…”，否则返回what?
5. 接收端和发送端程序退出

接收端代码：

package com.hsp.net.homework;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

/**
 * Description
 * User:
 * Date:
 * Time:接收端
 */
public class homework02Receiver {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9999);

        byte[] bt = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bt,bt.length);
        System.out.println("Receiver等待接收数据...");
        socket.receive(packet);

        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);

        byte[] bytes1 = "红楼梦...".getBytes();
        byte[] bytes2 = "what".getBytes();

        if("四大名著是哪些".equals(s)){
            System.out.println("进入");
            DatagramPacket packet1 = new DatagramPacket(bytes1,bytes1.length, InetAddress.getByName("192.168.10.1"),9998);
            socket.send(packet1);
        }else{
            DatagramPacket packet1 = new DatagramPacket(bytes2,bytes2.length, InetAddress.getByName("192.168.10.1"),9998);
            socket.send(packet1);
        }

        //关闭资源
        socket.close();
        System.out.println("Receiver关闭");
    }
}

发送端代码：

package com.hsp.net.homework;

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class homework02Sender {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9998);

        Scanner sc = new Scanner(System.in);
        String next = sc.next();
        DatagramPacket packet = new DatagramPacket(next.getBytes(),next.getBytes().length, InetAddress.getByName("192.168.10.1"),9999);
        socket.send(packet);

        //接收来自Receiver的数据
        byte[] bt1 = new byte[1024];
        DatagramPacket packet1 = new DatagramPacket(bt1,bt1.length);
        socket.receive(packet1);

        int length = packet1.getLength();
        byte[] data = packet1.getData();
        String s = new String(data, 0, length);
        System.out.println("Receiver说:"+s);

        //关闭资源
        socket.close();
        System.out.println("Sender关闭");
    }
}

案例3

1. 编写客户端程序和服务器端程序
2. 客户端可以输入一个文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的文件
3. 客户端收到文件后，保存到本地e:\
4. 提示：该程序可以使用StreamUtils

StreamUtls工具类

package com.hsp.net;

import java.io.*;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class StreamUtils {

    public static byte[] streamTobytes(InputStream in) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] bt = new byte[1024];
        int l=0;
        while((l=in.read(bt))!=-1){
            bos.write(bt,0,l);
        }
        return bos.toByteArray();
    }
    public static String streamToString(InputStream is) throws Exception{
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder builder = new StringBuilder();
        String line;
        while((line=reader.readLine())!=null){
            builder.append(line+"\r\n");
        }
        return builder.toString();
    }
}

服务端代码：

package com.hsp.net.homework;

import com.hsp.net.StreamUtils;

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

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class homework03Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);

        System.out.println("服务端等待连接...");
        Socket socket = serverSocket.accept();

        //服务端接收客户端传递的文件名
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        socket.shutdownInput();

        String filepath = "src/"+s;
        String defaultpath = "src/aa.txt";
        File file = new File(filepath);
        BufferedInputStream bis = null;
        //将文件发送给客户端(先默认存在)
        if(file.exists()){
            bis = new BufferedInputStream(new FileInputStream(filepath));
        }else{
            bis = new BufferedInputStream(new FileInputStream(defaultpath));
        }
        byte[] bytes = StreamUtils.streamTobytes(bis);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        socket.shutdownOutput();

        //关闭资源
        bis.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端关闭");


    }
}

用户端代码：

package com.hsp.net.homework;

import com.hsp.net.StreamUtils;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class homework03Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);

        //输入文件名，并发给服务端
        Scanner sc = new Scanner(System.in);
        String next = sc.next();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(next);
        bw.newLine();
        bw.flush();
        socket.shutdownOutput();

        //接收服务端传来的数据，并将文件转换成bytes存储在f盘下
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamTobytes(bis);
        String filepath = "F:\\test.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filepath));
        bos.write(bytes);
        System.out.println("文件保存成功");
        socket.shutdownInput();

        //关闭资源
        bos.close();
        socket.close();
        System.out.println("用户端关闭");

    } 
}

这篇关于java网络多线程专题的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！