Java进阶篇详解（八）--->网络编程-阿里云开发者社区

网络基础

简介

网络：两台或多台设备通过一定物理设备连接起来构成了网络
网络通信：将数据通过网络从一台设备传输到另一台设备
TCP协议: 传输控制协议

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

UDP协议: 用户数据协议

1.将数据、源、目的封装成数据包，不需要建立连接
2.因无需连接，故是不可靠的
2.每个数据报的大小限制在64K内，不适合传输大量数据
4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

Java提供的网络功能类

InetAddress：用于标识网络上的硬件资源
Socket和ServerSocket：使用TCP协议实现网络通信的 Socket 相关的类
Datagram：使用UDP协议，将数据保存在数据报中，通过网络进行通信

InetAddress

getLocalHost() 获取本机 InetAddress 对象
getByName() 根据指定主机名/域名获取 ip 地址对象
getHostName() 获取 InetAddress 对象的主机名
getHostAddress() 获取 InetAddress 对象的地址

package com.jwt.network;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        //根据指定主机名/域名获取对象
        InetAddress host2 = InetAddress.getByName("jianjian");
        System.out.println(host2);
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);
        //获取InetAddress对象的主机名
        String host3Name = host3.getHostName();
        System.out.println(host3Name);
        //获取InetAddress对象的地址
        String host3Address = host3.getHostAddress();
        System.out.println(host3Address);
    }
}
/**
jianjian/192.168.50.204
jianjian/192.168.50.204
www.baidu.com/14.215.177.39
www.baidu.com
14.215.177.39
**/

Socket

简介

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

TCP编程

简介

1.基于客户端-服务端的网络通信
2.底层使用的是TCP/IP协议
3.应用场景举例:客户端发送数据，服务端接受并显示控制台

流程

TCP，传输前先开服务端，accept，等客户端接入，然后获得客户端 socket 然后进行 IO 操作

服务端编写

Step 1：创建ServerSocket对象，绑定监听的端口

ServerSocket serverSocket = new ServerSocket(Port);

Step 2：调用accept()方法监听客户端的请求

Socket socket = serverSocket.accept();

step 3：连接建立后，通过输入流读取客户端发送的请求信息

InputStream inputStream = socket.getInputStream();

Step 4：通过输出流向客户端发送响应信息

OutputStream outputStream = socket.getOutputStream();

Step 5：关闭相关资源

outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();

客户端编写

Step 1：创建Socket对象，指明需要链接的服务器的地址和端号

Socket socket = new Socket(“server address”, port);

Step 2：链接建立后，通过输出流向服务器发送请求信息

OutputStream outputStream = socket.getOutputStream();

Step 3：通过输入流获取服务器响应的信息

InputStream inputStream = socket.getInputStream();

Step 4：关闭相关资源

inputStream.close();
outputStream.close();
socket.close();

例子1:使用字节流通信

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

服务端

package com.jwt.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketTCP01Server {
    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. 通过输入流，读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO 读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen=inputStream.read(buf))!= -1) {
            System.out.println(new String(buf,0,readLen));
        }
        //5. 通过输出流，写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("服务端说：你好，客户端！".getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        //6.关闭流和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

客户端

package com.jwt.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1. 连接服务端(ip , 端口）如果连接成功，返回Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回=" + socket.getClass());
        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入数据到数据通道
        outputStream.write("客户端说：你好，服务端!".getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        //4. 获取和socket 关联的输入流. 读取数据(字节)，并显示
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen=inputStream.read(buf))!= -1) {
            System.out.println(new String(buf,0,readLen));
        }
        //5. 关闭流对象和socket, 必须关闭
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

例子2:使用字符流通信

1.编写一个服务端和一个客户端
2.服务端在9999端口监听
3.客户端连接到服务端，发送”你好，服务端！”，并接收服务端回发的”你好，客户端！”，再退出
4.服务端接收到客户端发送的信息，输出，并发送”你好，客户端！”，再退出

服务端

package com.jwt.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketTCP02Server {
    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 inputStream = socket.getInputStream();
        //4. IO 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //5. 通过输出流，写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("服务端说：你好，客户端！");
        // 设置结束标记
        bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

客户端

package com.jwt.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketTCP02Server {
    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 inputStream = socket.getInputStream();
        //4. IO 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //5. 通过输出流，写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("服务端说：你好，客户端！");
        // 设置结束标记
        bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

例子3:文件传输

1.编写一个服务端和一个客户端
2.服务器端在 8888 端口监听
3.客户端连接到服务端，发送一张图片 /Users/jianjian/Downloads/a.jpeg
4.服务器端接收到客户端发送的图片，保存到 src 下，发送”收到图片”再退出
5.客户端接收到服务端发送的”收到图片”，再退出
6.该程序要求使用 StreamUtils.java，我们直接使用

服务端

package com.jwt.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
        //1. 服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端监听8888端口....");
        //2. 等待连接
        Socket socket = serverSocket.accept();
        //3. 读取客户端发送的数据,通过Socket 得到输入流
        System.out.println("服务端开始接收图片");
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "src//a.jpeg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.flush();
        System.out.println("服务端接收图片成功");
        //5.向客户端回复"收到图片"通过socket 获取到输出流(字符)
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("服务端：收到图片");
        bw.flush();//把内容刷新到数据通道
        socket.shutdownOutput();//设置写入结束标记
        //6.关闭其他资源
        bw.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}
/**
服务端监听8888端口....
服务端开始接收图片
服务端接收图片成功
服务端退出.....
**/

客户端

package com.jwt.socket;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
        //1.客户端连接服务端8888，得到Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //2.创建读取磁盘文件的输入流
        System.out.println("客户端开始发送图片");
        String filePath = "/Users/jianjian/Downloads/a.jpeg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //bytes 就是filePath 对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //3.通过socket 获取到输出流, 将bytes 数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();//设置写入数据的结束标记
        System.out.println("客户端发送图片成功");
        //4.接收从服务端回复的消息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils 的方法，直接将inputStream 读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        //5.关闭相关的流
        inputStream.close();
        bos.close();
          bis.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}
/**
客户端开始发送图片
客户端发送图片成功
服务端：收到图片
客户端退出.....
**/

UDP编程

简介

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

流程

UDP，以数据报作为数据的传输载体，在进行传输时首先要把传输的数据定义成数据报(Datagram)，在数据报中指明数据要到达的Socket(主机地址和端口号)，然后再将数据以数据报的形式发送出去，然后就没有然后了，服务端收不收到我就不知道了，除非服务端收到后又给我回一段确认的数据报。

接收端编写

Step 1：创建DatagramSocket，指定端口号

DatagramSocket socket = new DatagramSocket(9999);

Step 2：创建DatagramPacket

DatagramPacket packet = new DatagramPacket(buf,buf.length);

Step 3：接收发送端发送的数据信息

socket.receive(packet);

Step 4：读取数据

packet.getLength();
packet.getData();

Step 5：关闭相关资源

socket.close();

发送端编写

Step 1：定义发送信息

byte[] data = “发送端：hello 明天吃火锅~”.getBytes();

Step 2：创建DatagramPacket，包含将要发送的信息

DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName(“jianjian”), 9999);

Step 3：创建DatagramSocket

DatagramSocket socket = new DatagramSocket(9998);

Step 4：发送数据

socket.send(packet);

Step 5：关闭相关资源

socket.close();

例子：接受端发送端通信

1.编写一个接收端 A 和一个发送端 B
2.接收端 A 在 9999 端口等待接收数据
3.发送端 B 向接收端 A 发送数据”hello ,明天吃火锅~”
4.接收端 A 接收到发送端 B 发送的数据，回复”好的，明天见”，再退出
5.发送端接收回复的数据，再退出

接受端

package com.jwt.socket;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个DatagramSocket 对象，准备在9999 接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个DatagramPacket 对象，准备接收数据
        // 一个UDP数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf,buf.length);
        System.out.println("接收端A等待接收数据..");
        //3. 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
        //当有数据包发送到本机的9999 端口时，就会接收到数据
        // 如果没有数据包发送到本机的9999 端口, 就会阻塞等待.
        socket.receive(packet);
        //4. 把packet进行拆包，取出数据，并显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);
        //5. 回复信息给B端,将需要发送的数据，封装到DatagramPacket 对象
        data = "接收端：好的, 明天见".getBytes();
        //内容字节数组, 数组长度,主机(IP),端口
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9998);
        socket.send(packet);
        //6. 关闭资源
        socket.close();
        System.out.println("A 端退出...");
    }
}
/**
接收端A等待接收数据..
发送端：hello 明天吃火锅~
A 端退出...
**/

发送端

package com.jwt.socket;
import java.io.IOException;
import java.net.*;
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket 对象，准备在9998 端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2. 将需要发送的数据，封装到DatagramPacket 对象
        byte[] data = "发送端：hello 明天吃火锅~".getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9999);
        socket.send(packet);
        //3. 接收从A 端回复的信息
        //(1).构建一个DatagramPacket 对象，准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2) 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
        socket.receive(packet);
        //(3) 可以把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //4. 关闭资源
        socket.close();
        System.out.println("B 端退出");
    }
}
/**
接收端：好的, 明天见
B 端退出
**/

本章练习

1.编程题Homework01.java

(1)使用字符流的方式，编写一个客户端程序和服务器端程序
(2)客户端发送”name”,服务器端接收到后，返回”我是nova”，nova 是你自己的名字
(3)客户端发送”hobby”,服务器端接收到后，返回”编写java程序”
(4)不是这两个问题，回复”你说啥呢”
问题:目前，我们只能问一次，就退出了，怎么可以问多次? ->while ->聊天

服务端

package com.jwt.socket.homework;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Homework01Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("我是服务端，正在监听9999端口，等待连接...");
        Socket socket = serverSocket.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是nova";
        } else if("hobby".equals(s)) {
            answer = "编写java程序";
        } else {
            answer = "你说啥呢";
        }
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(answer);
        bw.flush();
        socket.shutdownOutput();
        bw.close();
        br.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

客户端

package com.jwt.socket.homework;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class Homework01Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getByName("jianjian"),9999);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //从键盘读取用户的问题
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题:");
        String question = scanner.next();
        bw.write(question);
        bw.flush();
        socket.shutdownOutput();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

2.编程题Homework02.java

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

接受端

package com.jwt.socket.homework;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Homework02ReceiverA {
    //- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
    //- (2)接收端在8888端口等待接收数据
    //- (3)发送端向接收端发送数据"四大名著是哪些"
    //- (4)接收端接收到发送端发送的问题后，返回"四大名著是<<红楼梦>> ..”，否则返回what?
    //- (5)接收端和发送端程序退出
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf,0,buf.length);
        System.out.println("接收端A等待接收数据..");
        socket.receive(packet);
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data,0,length);
        System.out.println(s);
        String anser = "";
        if("四大名著是哪些".equals(s)){
            anser = "四大名著是<<红楼梦>>...";
        } else {
            anser = "What?";
        }
        buf = anser.getBytes();
        packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("jianjian"), 9999);
        socket.send(packet);
        socket.close();
        System.out.println("A 端退出");
    }
}

发送端

package com.jwt.socket.homework;
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class Homework02SenderB {
    //- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
    //- (2)接收端在8888端口等待接收数据
    //- (3)发送端向接收端发送数据"四大名著是哪些"
    //- (4)接收端接收到发送端发送的问题后，返回"四大名著是<<红楼梦>> ..”，否则返回what?
    //- (5)接收端和发送端程序退出
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9999);
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题:");
        String question = scanner.next();
        byte[] buf = question.getBytes();
        DatagramPacket packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("jianjian"), 8888);
        socket.send(packet);
        buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);
        socket.close();
        System.out.println("B 端退出");
    }
}

3.编程题Homework03.java

(1)编写客户端程序和服务器端程序
(2)客户端可以输入一个音乐文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可
(3)客户端收到文件后，保存到本地
(4)提示:该程序可以使用StreamUtils.java
本质:其实就是指定下载文件的应用先自己结合老师讲的文件上传来做

服务端

package com.jwt.socket.homework;
import com.jwt.socket.StreamUtils;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Homework03Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端监听9999端口....");
        Socket socket = serverSocket.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        //发送音乐
        System.out.println("服务端开始发送音乐");
        String music = "";
        if ("高山流水".equals(s)){
            music = "高山流水.mp3";
        } else {
            music = "无名.mp3";
        }
        String filePath = "src//" + music;
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();//设置写入数据的结束标记
        System.out.println("客户端发送音乐成功");
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");
    }
}

客户端

package com.jwt.socket.homework;
import com.jwt.socket.StreamUtils;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class Homework03Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入音乐名：");
        String downMusic = scanner.next();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(downMusic);
        bw.flush();
        socket.shutdownOutput();
        //读取客户端发送的数据,通过Socket 得到输入流
        System.out.println("客户端开始接收音乐");
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        // 将得到bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "/Users/jianjian/Downloads/" + downMusic + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.flush();
        System.out.println("客户端接收音乐成功");
        bos.close();
        bis.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java进阶篇详解（八）--->网络编程

网络基础

简介

Java提供的网络功能类

InetAddress

Socket

简介

TCP编程

简介

流程

服务端编写

客户端编写

例子1:使用字节流通信

服务端

客户端

例子2:使用字符流通信

服务端

客户端

例子3:文件传输

服务端

客户端

UDP编程

简介

流程

接收端编写

发送端编写

例子：接受端发送端通信

接受端

发送端

本章练习

1.编程题Homework01.java

服务端

客户端

2.编程题Homework02.java

接受端

发送端

3.编程题Homework03.java

服务端

客户端

热门文章

最新文章

相关课程

相关电子书

相关实验场景