第九章网络编程

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

网络编程

1. Java 中的网络编程

1. InetAddress 类

方法：

由此可以看出，想要获取到 IP 和主机名，首先就要用到这个 InetAddress。需要注意的是函数的返回值是什么。

代码实例：

package codes;

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

public class InternetDemo {
    public static void main(String[] args) throws UnknownHostException {

        // 获取 InetAddress 对象
        InetAddress Ia = InetAddress.getByName("www.baidu.com");
        // 调用 InetAddress 对象中的 getHostAddress() 方法获得 IP
        String Ip = Ia.getHostAddress();
        String toString = Ia.toString();
        // 输出
        System.out.println("www.baidu.com 的 IP 地址为： " + Ip);
        System.out.println("Ia 的 toString() 为：" + toString);

        // 获取 InetAddress 对象
        InetAddress LocalIa = InetAddress.getLocalHost();
        // 获取 IP 地址
        String LocalIP = LocalIa.getHostAddress();
        // 或者写成
//        LocalIP = InetAddress.getLocalHost().getHostAddress();
        // 但是该方法得不到 LAN 网卡的 IP 地址（当电脑上网卡有多个 IP 地址时）
        System.out.println("本机的 IP 地址为：" + LocalIP);
    }
}

结果为：

2. UDP

UDP 的 socket 是 DatagramSocket。DatagramSocket(int port) 创建数据包套接字并将其绑定到本地主机上的指定端口。DatagramSocket(int port, InetAddress laddr) 创建数据包套接字，并将其绑定到指定的本地地址的指定端口上。

由此可知，第一个常用于接收端，绑定到本机的一个接收端口。第二个常用于发送端，发送给指定 IP 的指定端口。
DatagramSocket 常用的一些方法：

总结一下，当需要执行获取 IP 地址、端口以及收发有关的操作时，就涉及到 DatagramSocket 的方法。但实际上，当想要获取到客户端的 IP 地址时，调用的时 DatagramPacket 的方法（下文提到）。
此外还需要一个类 DatagramPacket，该类的作用是将数据进行打包。常用方法如下：

上面那个用来接收，下面这个用来发送。

发送端（客户端）的一般操作：

建立 DatagramSocket 服务。可以指定启动端口，也可以不指定。
将数据转成字节数组进行存储。
创建 DatagramPacket ，对数据打包并指定发送 IP 和端口。
调用 DatagramSocket.send(DatagramPacket DP) 发送数据。
关闭资源。

代码实例如下：

package UDP;

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class UDPClient {
    public static void main(String[] args) throws IOException {
        // 创建 socket 服务，自身的服务创建在 4444 端口
        // 或者在后面指定端口也行
        DatagramSocket DS = new DatagramSocket(4444);
        // 先用字节数组将数据进行存储
        String data = "虎虎生威，虎年大吉";
        byte[] buffer = data.getBytes(StandardCharsets.UTF_8);
        // 创建 IP 地址，要将每个 10 进制 int 数转换成 byte 类型
        byte[] IP = {(byte)192, (byte)168, (byte)43, (byte)110};
        // 数据打包
        DatagramPacket DP = new DatagramPacket(buffer, buffer.length,
                InetAddress.getByAddress(IP), 10000);
        // 发送数据
        DS.send(DP);
        // 关闭资源
        DS.close();

    }
}

接收端（服务端）的步骤：

建立 DatagramSocket 服务，并指定监听的端口
定义一个字节数组（缓冲区）来接收数据
创建 DatagramPacket 来接收数据
通过 DatagramPacket 的方法来获取发送方的 IP 地址。
关闭资源

代码实例：

package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPServer {
    public static void main(String[] args) throws Exception{
        // 创建 Datagram 服务监视端口
        DatagramSocket DS = new DatagramSocket(10000);
        // 定义一个缓冲区来接收数据
        // 可以 1024 * 64。因为一个包最大为 64k
        byte[] buffer = new byte[1024];
        DatagramPacket DP = new DatagramPacket(buffer, buffer.length);
        DS.receive(DP);
        // 获取 IP
        String IP = DP.getAddress().getHostAddress();
        System.out.println("接收到来自" + IP + "的数据是：");
        // 显示数据
        System.out.println(new String(buffer, 0, DP.getLength()));
        // 关闭资源
        DS.close();
    }
}

改进：

为服务端添加一个线程，使其不断地接收数据，并且尽量可以输入命令来停止接收
发送端通过 bufferedReader 来获取键盘输入，通过循环可以多次输入。

实例代码：

发送端（客户端）：

package UDP;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;

public class UDPChatClientThread{
    public static void main(String[] args) {
        // 创建 DatagramSocket
        DatagramSocket DS = null;
        BufferedReader BR = null;
        try{
            if (DS == null) {
                DS = new DatagramSocket(10001);
            }
            // 键盘读取
            if (BR == null) {
                BR = new BufferedReader(new InputStreamReader(System.in));
            }
            // 读取键盘输入
            String inputLine = null;
            byte[] IP = {(byte)192, (byte)168, (byte)43, (byte)110};
            while(!(inputLine = BR.readLine()).equals("quit")){
                // 发送数据，一行一行输入
                byte[] buffer = inputLine.getBytes(StandardCharsets.UTF_8);
                DatagramPacket DP = new DatagramPacket(buffer, buffer.length, InetAddress.getByAddress(IP), 10000);
                DS.send(DP);
            }
        }
        catch (Exception e){
            System.out.println("数据发送失败");
        }
        finally {
            if (DS != null) {
                DS.close();
            }
            if (BR != null) {
                try {
                    BR.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

接收端（服务端）

package UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Scanner;

public class UDPChatServerThread implements Runnable{

    public volatile boolean exit = false;

    @Override
    public void run() {
        while(!exit){
            DatagramSocket DS = null;
            try{
                if (DS == null) {
                    DS = new DatagramSocket(10000);
                }
                // 创建缓冲区
                byte[] buffer = new byte[1024];
                // 将接收到的数据打包
                DatagramPacket DP = new DatagramPacket(buffer, buffer.length);
                DS.receive(DP);
                // 获取 IP
                String IP = DP.getAddress().getHostAddress();
                // 输出数据
                System.out.println(IP + ":" + new String(buffer, 0, DP.getLength()));
            }
            catch (Exception e){
                System.out.println("接收数据错误！");
                e.printStackTrace();
            }
            finally {
                if (DS != null) {
                    DS.close();
                }
            }
        }
    }

    public static void main(String[] args) {
        UDPChatServerThread udpChatServerThread = new UDPChatServerThread();
        Thread chatServerThread = new Thread(udpChatServerThread);
        chatServerThread.start();
        Scanner inputScanner = new Scanner(System.in);
        String quit = "start";
        while(!quit.equals("quit")){
            quit = inputScanner.next();
        }
        // 用标志位来关闭服务
        udpChatServerThread.exit = true;
    }
}

结果：

实际上接收端还需要接收一次数据才能停止服务。

3. TCP

TCP 在创建 Socket 服务时，和 UDP 稍微不同。在 TCP 中，客户端创建 Socket 服务，而服务端创建的服务是 ServerSocket。同时，ServerSocket 会调用 accept() 方法来阻塞式监听连接到自己的 Socket 并且接收。该方法返回一个 Socket。
Socket 的常用方法：

发送端：

创建 Socket 服务，指定其服务端的主机和端口号。（DatagramSocket 是指定本机的使用端口，发送方和接收方都要指定）
将要发送的数据用字节数组保存
获取 Socket 的输出流，利用输出流（调用 OutputStream.write(byte[] buffer) ）将数据发送。
关闭输入流
获取 Socket 的输入流，通过调用 InputStream.read(byte[] buffer) 来获取反馈的信息。
打印，然后关闭 Socket

代码：

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TCPClient {
    public static void main(String[] args) {
        // 创建 socket 服务
        Socket socket = null;
        try{
            if (socket == null) {
                byte[] IP = {(byte)192, (byte)168, (byte)43, (byte)110};
                socket = new Socket(InetAddress.getByAddress(IP), 20000);
            }
            // 把字符串数据转换成字节数组
            byte[] buffer = "虎年大吉，虎虎生威".getBytes(StandardCharsets.UTF_8);

            // 获取 socket 的输出流
            OutputStream outputStream = socket.getOutputStream();
            // 发送数据
            outputStream.write(buffer);
            // 发送完成后关闭输出流
            socket.shutdownOutput();

            // 获取输入流，获得反馈的信息
            InputStream inputStream = socket.getInputStream();
            byte[] feedbackBuffer = new byte[1024];
            // 通过输入流读取反馈信息并将其存储在缓冲区中，然后获取写入的长度
            int length = inputStream.read(feedbackBuffer);
            // 打印反馈信息
            System.out.println(new String(feedbackBuffer, 0, length));
            // 接收完毕后关闭输入流
            socket.shutdownInput();
        }
        catch (Exception e){
            System.out.println("数据传输失败");
            e.printStackTrace();
        }
        finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端（接收端）

创建 ServerSocket 服务并指定端口，调用 ServerSocket.accept() 方法来接收 Socket。
获得对方的 IP 地址
获取输入流，建立缓冲区，通过 InputStream.read(byte[] butter) 来获得输入流的内容。
关闭输入流。
获取输出流，发送反馈信息。
关闭 Socket 和 ServerSocket、

代码实现：

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 创建 ServerSocket 服务
        ServerSocket SS = new ServerSocket(20000);
        // 阻塞式监听端口并接收 socket
        Socket socket = SS.accept();

        // 获取对方的 IP 地址
        String IP = socket.getInetAddress().getHostAddress();
        // 输出对方的信息
        System.out.println(IP + "-----connected.");

        // 获取输入流
        InputStream inputStream = socket.getInputStream();
        // 创建缓冲区
        byte[] buffer = new byte[1024];
        int length = 0;
        // 缓冲区存储输入流内容
        while((length = inputStream.read(buffer)) != -1){
            // 将获取到的内容打印
            System.out.println(new String(buffer, 0, length));
        }
        // 关闭输入流
        socket.shutdownInput();

        // 发送反馈信息
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("服务端收到了您的信息".getBytes(StandardCharsets.UTF_8));

        // 关闭资源
        socket.shutdownOutput();
        socket.close();
        SS.close();
    }

}

结果：
注意

需要注意的是，在本机通过 InetAddress.getByName(String Hostname, int port) 创建 Socket 时。由于主机有多块网卡。所以通过主机名来获取 IP 时，可能会获取到其他网卡（例如虚拟机）。一般的做法是遍历所有的网卡拿到 IP 列表，然后选择。

2. Android 中的网络编程（用 Java 的 Api 写）

1. 使用 Java 的 Api 请求数据并处理

请求样例：

通过 http 协议访问、获取内容并且最后进行数据处理 --- loadJson()：

// shift + ctrl + 回车 自动补全括号或者封号
public void loadJson(View view) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            // ctrl + p 显示函数要求的参数
            try {
                URL url = new URL("http://192.168.43.110:9102/get/text");
                HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                // 超时时间为 10s
                httpURLConnection.setConnectTimeout(10000);
                // 请求方式为 get
                httpURLConnection.setRequestMethod("GET");
                // 设置 http 请求包的请求头的一些参数和值
                httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");
                httpURLConnection.setRequestProperty("Accept", "*/*");
                httpURLConnection.connect();
                // 获取结果码
                int responseCode = httpURLConnection.getResponseCode();
                if (responseCode == 200) {
                    // 将 http 返回包的头部的信息用 Map （键值对）进行存储
                    Map<String, List<String>> headerFields = httpURLConnection.getHeaderFields();
                    Log.d(TAG, headerFields.toString());
                    // 将 Map 中的所有键值对存储到 Set 里面，Set 的每一个元素都是一个 Entry。
                    // Java 中用 Entry 内部类表示一个映射项（类似一个小 Map）。包含 getKey() 和 getValue() 方法
                    Set<Map.Entry<String, List<String>>> entries = headerFields.entrySet();
                    // entries.for 来快捷遍历
                    // 将 http 响应头的所有内容打印出来
                    for (Map.Entry<String, List<String>> entry : entries) {
                        Log.d(TAG, entry.getKey() + " == " + entry.getValue());
                    }
                    
                    // 通过获取返回包内容，可以看出他返回的是一个输入流
                    // 内容为：buffer(com.android.okhttp.internal.http.Http1xStream$ChunkedSource@c6cf62a).inputStream()
                      Object content = httpURLConnection.getContent();
                      Log.d(TAG, "content --> " + content);
                    InputStream inputStream = httpURLConnection.getInputStream();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    // 读取到输入流内容
                    String json = bufferedReader.readLine();
                    //Log.d(TAG, "json --> " + json);
                    Gson gson = new Gson();
                    // fromJson 将指定的 json 格式内容转换成指定类的一个具体对象
                    GetTextItem getTextItem = gson.fromJson(json, GetTextItem.class);
                    updateUI(getTextItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
}
    
/**
 * UI 更新不能在子线程
 *
 * @param getTextItem
 */
private void updateUI(GetTextItem getTextItem) {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mGetResultListAdapter.setData(getTextItem);
        }
    });
}

在 Android Api > 27 以后，对 http 的访问，在 AndroidManifest.xml 的 <application> 中，要么添加字段 android:usesCleartextTraffic="true"。要么添加网络安全配置文件 network_security_config.xml。

根据获取到的 json 内容，右键 --> Generate --> GsonFormatPlus。将 Json 转换成一个大的实体类。

package com.example.androidnetworkdemo.domain;

import java.util.List;

public class GetTextItem {

    private Boolean success;
    private Integer code;
    private String message;
    private List<DataBean> data;

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public List<DataBean> getData() {
        return data;
    }

    public void setData(List<DataBean> data) {
        this.data = data;
    }

    public static class DataBean {
        private String id;
        private String title;
        private Integer viewCount;
        private Integer commentCount;
        private String publishTime;
        private String userName;
        private String cover;

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public Integer getViewCount() {
            return viewCount;
        }

        public void setViewCount(Integer viewCount) {
            this.viewCount = viewCount;
        }

        public Integer getCommentCount() {
            return commentCount;
        }

        public void setCommentCount(Integer commentCount) {
            this.commentCount = commentCount;
        }

        public String getPublishTime() {
            return publishTime;
        }

        public void setPublishTime(String publishTime) {
            this.publishTime = publishTime;
        }

        public String getUserName() {
            return userName;
        }

        public void setUserName(String userName) {
            this.userName = userName;
        }

        public String getCover() {
            return cover;
        }

        public void setCover(String cover) {
            this.cover = cover;
        }
    }
}

用 RecyclerView 将获取到的数据显示出来

item_get_text.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <ImageView
        android:id="@+id/item_image"
        android:layout_width="90dp"
        android:layout_height="90dp"
        android:background="#99ff00"
        android:scaleType="centerCrop" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">

        <!-- lines = "1" 表示只占用一行 -->
        <!-- ellipsize = "end" 表示显示不下的用省略号代替 -->
        <TextView
            android:id="@+id/item_title"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="10dp"
            android:ellipsize="end"
            android:lines="1"
            android:text="我是标题"
            android:textSize="18sp" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="10dp"
            android:orientation="horizontal">

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginLeft="10dp"
                android:text="作者名" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginLeft="10dp"
                android:text="查看数" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginLeft="10dp"
                android:text="评论数" />

        </LinearLayout>

    </LinearLayout>

</LinearLayout>

初始化控件以及设置布局管理器和 adapter：

private void initView() {
    // 利用 RecyclerView 显示 Json 数据
    RecyclerView recyclerView = this.findViewById(R.id.result_list);
    recyclerView.setLayoutManager(new LinearLayoutManager(this));
    // 为 RecyclerView 添加 item 装饰器（这里的目的是增加每个 item 之间的空隙）
    recyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
        
        /**
         * Retrieve any offsets for the given item. Each field of <code>outRect</code> specifies
         * the number of pixels that the item view should be inset by, similar to padding or margin.
         *
         * @param outRect
         * @param view
         * @param parent
         * @param state
         */
        @Override
        public void getItemOffsets(@NonNull @NotNull Rect outRect, @NonNull @NotNull View view, @NonNull @NotNull RecyclerView parent, @NonNull @NotNull RecyclerView.State state) {
            outRect.top = 5;
            outRect.bottom = 5;
        }
    });
    mGetResultListAdapter = new GetResultListAdapter();
    recyclerView.setAdapter(mGetResultListAdapter);
    recyclerView.setItemViewCacheSize(200);
}

创建 adapter --- GetResultListAdapter.java：

package com.example.androidnetworkdemo.adapters;

import android.icu.text.Transliterator;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;

import com.bumptech.glide.Glide;
import com.example.androidnetworkdemo.R;
import com.example.androidnetworkdemo.domain.GetTextItem;

import org.jetbrains.annotations.NotNull;
import org.w3c.dom.Text;

import java.util.ArrayList;
import java.util.List;

public class GetResultListAdapter extends RecyclerView.Adapter<GetResultListAdapter.InnerHolder> {

    private static final String TAG = "GetResultListAdapter";
    // 假设直接获取 GetTextItem.data，当其置空时会这类会容易崩溃
    private List<GetTextItem.DataBean> mData = new ArrayList<>();
    private TextView mTitleTextView;
    private ImageView mImageView;
    private int mPosition;

    @NonNull
    @org.jetbrains.annotations.NotNull
    @Override
    public InnerHolder onCreateViewHolder(@NonNull @org.jetbrains.annotations.NotNull ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_get_text, parent, false);
        return new InnerHolder(itemView);
    }

    @Override
    public void onBindViewHolder(@NonNull @org.jetbrains.annotations.NotNull GetResultListAdapter.InnerHolder holder, int position) {
        // 获取数据列表中的单个元素，这里也就是键 "data" 的其中一个值。
        mPosition = position;
        GetTextItem.DataBean dataBean = mData.get(position);
        mTitleTextView.setText(dataBean.getTitle());
    }

    @Override
    public int getItemCount() {
        return mData.size();
    }

    public void setData(GetTextItem getTextItem) {
        mData.clear();
        // 获取返回的数据
        // 由返回的 json 数据可知，键为 "data" 的值是数据，里面包含图片，标题、作者等各种信息。
        // data 在 getTextItem 类中的类型是 List<JavaBean>
        mData.addAll(getTextItem.getData());
        // 通知数据已经发生改变
        notifyDataSetChanged();
    }

    public class InnerHolder extends RecyclerView.ViewHolder {
        public InnerHolder(@NonNull @NotNull View itemView) {
            super(itemView);
            mTitleTextView = itemView.findViewById(R.id.item_title);
            mImageView = itemView.findViewById(R.id.item_image);
            // 获取到图片的指定路径，然后用 Glide 图片框架
            Glide.with(itemView.getContext()).load("http://192.168.43.110:9102" +
                    mData.get(mPosition).getCover()).into(mImageView);
            Log.d(TAG, "Cover is " + mData.get(mPosition).getCover());
        }
    }
}

结果显示

2. 利用 Java Api 获取网络图片

创建一个按钮控件和一个显示图片的控件 --- activity_pic_load.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".PicLoadActivity"
    android:orientation="vertical">

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="loadPic"
        android:text="loadPic"
        android:textAllCaps="false" />

    <ImageView
        android:id="@+id/result_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

按钮触发方法 --- loadPic() ：

public void loadPic(View view) {
        new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                URL url = new URL("https://imgs.sunofbeaches.com/group1/M00/00/02/rBPLFV1x6Q2AMjxyAADy5tr458c500.jpg");
                HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                // 超时时间为 10s
                httpURLConnection.setConnectTimeout(10000);
                // 请求方式为 get
                httpURLConnection.setRequestMethod("GET");
                // 设置 http 请求包的请求头的一些参数和值
                httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");
                httpURLConnection.setRequestProperty("Accept", "*/*");
                httpURLConnection.connect();
                
                int responseCode = httpURLConnection.getResponseCode();
                Log.d(TAG, "responseCode === " + responseCode);
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    // 获取返回数据的输入流
                    InputStream inputStream = httpURLConnection.getInputStream();
                    // 转成 Bitmap
                    final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                    // 更新 UI，要在主线程里面。或者用 View.post() 方法也行（本质也是使用 Handler.post）
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            ImageView imageView = findViewById(R.id.result_image);
                            // 将获取到的 bitmap 设置到 layout 上显示
                            imageView.setImageBitmap(bitmap);
                        }
                    });
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

3. 对超大图片的简易处理

当获取到的图片很大时（例如 20 MB 的图片），如果手机的性能不行，那么就会导致 OOM(Out Of Memory)的发生。因此，对于获取到的图片，当大于一定的大小时，需要对其进行一些处理。

代码：

public void loadPic(View view) {
    
    // 当图片过大时，加载中如果手机性能不足，会导致应用崩溃
    BitmapFactory.Options options = new BitmapFactory.Options();
    final Bitmap bigImage = BitmapFactory.decodeResource(getResources(), R.mipmap.big_image, options);
    ImageView imageView = findViewById(R.id.result_image);
    // 设置图片的压缩比例，即分辨率原图片的几分之一
    // 实际上，压缩比例不能写死，因此要根据控件的大小动态变化
    options.inSampleSize = 2;
    
    // 值设为 true，内存不加载，那么将不返回实际的 bitmap，也不给其分配内存空间这样就避免内存溢出了。
    // 但是允许我们查询图片的信息这其中就包括图片大小信息
    options.inJustDecodeBounds = true;
    
    // 动态设置 inSampleSize
    // 拿到图片宽度
    int outWidth = options.outWidth;
    // 在涉及数值的地方打 Log 查看
    Log.d(TAG, "outWidth === " + outWidth);
    // 拿到图片高度
    int outHeight = options.outHeight;
    Log.d(TAG, "outHeight === " + outHeight);
    // 拿到控件的尺寸
    int measuredWidth = imageView.getMeasuredWidth();
    Log.d(TAG, "imageView.Width === " + measuredWidth);
    int measuredHeight = imageView.getMeasuredHeight();
    Log.d(TAG, "imageView.Height === " + measuredHeight);
    
    // 图片的宽度 / 控件的宽度
    // 图片的高度 / 控件的高度
    // 然后取两者最大值
    // 如果图片小于控件大小，那默认为 1
    if (outHeight > measuredHeight || outWidth > measuredWidth) {
        int ratioHeight = outHeight / measuredHeight;
        int ratioWeight = outWidth / measuredWidth;
        options.inSampleSize = Math.max(ratioHeight, ratioWeight);
        Log.d(TAG, "inSampleSize === " + options.inSampleSize);
    }
    
    // 或者调用他人算法
    options.inSampleSize = calculateInSampleSize(options, measuredWidth, measuredHeight);
    Log.d(TAG, "inSampleSize === " + options.inSampleSize);
    
    // 设置回来以在内存中进行图片加载
    options.inJustDecodeBounds = false;
    
    // 将获取到的 bitmap 设置到 layout 上显示
    imageView.setImageBitmap(bigImage);
}

/**
 * 处理大图片算法，来自 https://www.sunofbeach.net/a/1201092087920054272
 *
 * @param options
 * @param maxWidth
 * @param maxHeight
 * @return
 */
public static int calculateInSampleSize(BitmapFactory.Options options, int maxWidth, int maxHeight) {
    //这里其实是获取到默认的高度和宽度，也就是图片的实际高度和宽度
    final int height = options.outHeight;
    final int width = options.outWidth;
    //默认采样率为1，也就是不变嘛。
    int inSampleSize = 1;
    //===============核心算法啦====================
    if (width > maxWidth || height > maxHeight) {
        if (width > height) {
            inSampleSize = Math.round((float) height / (float) maxHeight);
        } else {
            inSampleSize = Math.round((float) width / (float) maxWidth);
        }
        final float totalPixels = width * height;
        final float maxTotalPixels = maxWidth * maxHeight * 2;
        while (totalPixels / (inSampleSize * inSampleSize) > maxTotalPixels) {
            inSampleSize++;
        }
    }
    //=============核心算法end================
    return inSampleSize;
}

4. 用 POST 方式提交评论

根据服务器提供的方法。请求的主体部分是一个 json 字段，然后给出了样例。
写一个按钮负责发起提交事件 --- activity_post_comment.xml
大致的思路为：
1. 发起 Post 请求
2. 根据给的例子，将 json 用 GsomFormatPlus 转成 JavaBean 类。
3. 创建该类，实例化这个 JavaBean 类并设置 json 中的值。再将其转回 json 格式，然后让输出流输出它。
4. 获取响应码
请求样例：

PostCommentActivity.java：

package com.example.androidnetworkdemo;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.example.androidnetworkdemo.domain.CommentItem;
import com.google.gson.Gson;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class PostCommentActivity extends AppCompatActivity {

    private static final String TAG = "PostCommentActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_post_comment);
    }

    public void postComment(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 放在外面，防止内存泄露
                OutputStream outputStream = null;
                InputStream inputStream = null;
                BufferedReader bufferedReader;

                try {
                    // 发起 Post 请求
                    URL url = new URL("http://192.168.43.110:9102/post/comment");
                    HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                    httpURLConnection.setRequestMethod("POST");
                    httpURLConnection.setConnectTimeout(10000);
                    // setRequestProperty() 的参数参考抓包软件抓的包
                    httpURLConnection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                    httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");
                    httpURLConnection.setRequestProperty("Accept", "application/json, text/plain, */*");

                    // 实例化提交评论的 json 转实体的类
                    CommentItem commentItem = new CommentItem("123456789", "我是评论的内容");
                    Gson gson = new Gson();
                    // 将对象转成 json 格式传输
                    String jsonStr = gson.toJson(commentItem);
                    byte[] jsonStrBytes = jsonStr.getBytes(StandardCharsets.UTF_8);
                    // valueOf() 将其他类型的数据转成字符串型
                    // Content-Length 指示出报文中主体部分的字节大小，他表示的是字节的数目，因此这里要用 byte[] 的长度而不是 String 的长度
                    Log.d(TAG, "jsonStrByte.length === " + jsonStrBytes.length);
                    httpURLConnection.setRequestProperty("Content-Length", String.valueOf(jsonStrBytes.length));

                    // 连接
                    httpURLConnection.connect();

                    // 把数据写到服务器中（获取输出流）
                    outputStream = httpURLConnection.getOutputStream();
                    // 将数据写入(流的写入是用 byte[]
                    outputStream.write(jsonStrBytes);
                    outputStream.flush();

                    // 写完后要拿结果
                    // 获取返回响应码
                    int responseCode = httpURLConnection.getResponseCode();
                    if (responseCode == HttpURLConnection.HTTP_OK) {
                        inputStream = httpURLConnection.getInputStream();
                        bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                        // 这里只读取了一行（因为他返回的主体内容也就一行）
                        Log.d(TAG, "result is " + bufferedReader.readLine());
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if (outputStream != null) {
                        try {
                            outputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (inputStream != null) {
                        try {
                            inputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }).start();
    }
}

5. URL 带参数的请求

get 和 post 一样。
核心逻辑就是在请求的 URL 上添加参数（键值对）
请求样例

代码：

/**
 * 发起带参数的 get 请求
 * @param view
 */
public void getRequestWithParams(View view) {
    Map<String, String> params = new HashMap<>();
    params.put("keyword", "这是关键字");
    params.put("page", "12");
    params.put("order", "0");
    // 发起请求
    startRequest(params, "GET", "/get/param");
}

/**
 * get 和 post 请求方式大致相同，重构成一个方法
 *
 * @param params        请求的参数（字典形式）
 * @param requestMethod 请求方式，GET 或者 POST
 * @param api           接口值（开头要加 "\" )
 */
private void startRequest(Map<String, String> params, String requestMethod, String api) {
    new Thread(new Runnable() {
        private StringBuilder mStringBuilder = null;
        InputStream inputStream = null;
        BufferedReader bufferedReader = null;
        
        @Override
        public void run() {
            try {
                // 组装参数，请求的时候可以有不带任何参数的 URL
                if (params != null && params.size() > 0) {
                    mStringBuilder = new StringBuilder("?");
                    // 将字典中每一个键值对都变成集合的一个元素，然后用迭代器迭代，或者将 entrySet 取出，用 foreach 遍历
                    Iterator<Map.Entry<String, String>> entryIterator = params.entrySet().iterator();
                    while (entryIterator.hasNext()) {
                        Map.Entry<String, String> next = entryIterator.next();
                        // 将键值对以 "键=值" 的字符串形式保存
                        mStringBuilder.append(next.getKey());
                        mStringBuilder.append("=");
                        mStringBuilder.append(next.getValue());
                        // 如果当前的键值对不是最后一个，那么需要在值的后面添加一个 "&" 用来拼接下一个键值对
                        if (entryIterator.hasNext()) {
                            mStringBuilder.append("&");
                        }
                    }
                    Log.d(TAG, "stringBuilder is " + mStringBuilder.toString());
                }
                URL url;
                if (mStringBuilder != null) {
                    String paramsString = mStringBuilder.toString();
                    url = new URL(BASE_URL + api + "/" + paramsString);
                } else {
                    url = new URL(BASE_URL + api);
                }
                Log.d(TAG, "url is " + url.toString());
                
                HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                httpURLConnection.setRequestMethod(requestMethod);
                httpURLConnection.setConnectTimeout(10000);
                // setRequestProperty() 的参数参考抓包软件抓的包
                httpURLConnection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");
                httpURLConnection.setRequestProperty("Accept", "application/json, text/plain, */*");
                httpURLConnection.connect();
                // 默认为 true
                httpURLConnection.setDoInput(true);
                // 默认为 false，因此需要开启
                httpURLConnection.setDoOutput(true);
                
                // 获取响应结果
                int responseCode = httpURLConnection.getResponseCode();
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    inputStream = httpURLConnection.getInputStream();
                    bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    // 这里只读取了一行（因为他返回的主体内容也就一行）
                    Log.d(TAG, "result is " + bufferedReader.readLine());
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
}

/**
 * 发起带参数的 post 请求
 * @param view
 */
public void postRequestWithParams(View view) {
    Map<String, String> params = new HashMap<>();
    params.put("string", "这是我的字符串内容");
    // 发起请求
    startRequest(params, "POST", "/post/string");
}

6. 单文件上传

单文件上传的关键在于 http 包主体内容的实现。可以用 postman 来实现单文件上传，然后用抓包软件抓包，查看格式。
主体格式：
请求样例：

代码 --- postFile(View view) ：

/**
 * 上传单个文件
 * 注意，上传文件的时候，建议先抓个包查看格式，然后尽量完全仿照格式来写
 *
 * @param view
 */
public void postFile(View view) {
    // TODO: 抽取方法，完成上传多个文件
    new Thread(new Runnable() {
        @Override
        public void run() {
            File file = new File("/storage/emulated/0/Download/904413721286148096.png");
            String fileKey = "file";
            String fileName = file.getName();
            String fileType = null;
            try {
                fileType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(MimeTypeMap.getFileExtensionFromUrl(file.toURI().toURL().toString()));
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
            Log.d(TAG, "fileType is " + fileType);
            String BOUNDARY = "--------------------------481790588201105611341721";
            OutputStream outputStream = null;
            BufferedReader bufferedReader = null;
            BufferedInputStream bufferedInputStream = null;
            InputStream inputStream = null;
            try {
                URL url = new URL(BASE_URL + "/file/upload");
                HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                httpURLConnection.setRequestMethod("POST");
                httpURLConnection.setConnectTimeout(10000);
                httpURLConnection.setRequestProperty("User-Agent", "Android/" + Build.VERSION.SDK_INT);
                httpURLConnection.setRequestProperty("Accept", "*/*");
                // 等同于 httpURLConnection.setUseCaches(false);
                httpURLConnection.setRequestProperty("Cache-Control", "no-cache");
                httpURLConnection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
                httpURLConnection.setRequestProperty("Connection", "keep-alive");
                // 默认为 true
                httpURLConnection.setDoInput(true);
                // 默认为 false，因此需要开启
                httpURLConnection.setDoOutput(true);
                httpURLConnection.connect();
                Log.d(TAG, "connection established");
                
                // 获取输出流
                outputStream = httpURLConnection.getOutputStream();
                
                // 准备发送数据的头部数据（是 http 中主体部分的）
                StringBuilder headerInfoSB = new StringBuilder();
                headerInfoSB.append("--");
                headerInfoSB.append(BOUNDARY);
                // \n 是换到下一行（的相同位置），\r 是回到行首
                // 因此实际上，在 windows 中的回车键（敲一次 enter）就是 \r\n
                headerInfoSB.append("\r\n");
                headerInfoSB.append("Content-Disposition: form-data; name=\"" + fileKey + "\"; filename=\"" + fileName + "\"");
                headerInfoSB.append("\r\n");
                headerInfoSB.append("Content-Type: " + fileType);
                headerInfoSB.append("\r\n");
                headerInfoSB.append("\r\n");
                byte[] headerInfoBytes = headerInfoSB.toString().getBytes(StandardCharsets.UTF_8);
                outputStream.write(headerInfoBytes);
                  Log.d(TAG, "headerInfoSb === " + headerInfoSB.toString());
                
                // 文件内容
                // 文件输入流是以字节的方式读取文件内容（数据），文件输出流是将数据写入到文件中
                FileInputStream fileInputStream = new FileInputStream(file);
                // 字节缓冲流、是高级的流，需要套在底层的流上以增加读写效率和其他方法
                bufferedInputStream = new BufferedInputStream(fileInputStream);
                byte[] buffer = new byte[1024];
                int readLength;
                while ((readLength = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
                    outputStream.write(buffer, 0, readLength);
                }
                
                // 主体的结尾部分
                StringBuilder endingInfoSb = new StringBuilder();
                endingInfoSb.append("\r\n");
                endingInfoSb.append("--");
                endingInfoSb.append(BOUNDARY);
                endingInfoSb.append("--");
                endingInfoSb.append("\r\n");
                outputStream.write(endingInfoSb.toString().getBytes(StandardCharsets.UTF_8));
                outputStream.flush();
                
                // 获取返回的结果
                int responseCode = httpURLConnection.getResponseCode();
                Log.d(TAG, "responseCode === " + responseCode);
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    inputStream = httpURLConnection.getInputStream();
                    // InputStreamReader 是字节流和字符流之间的桥梁。它读取字节，并使用指定的字符集将其解码为字符。
                    bufferedReader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
                    String result = bufferedReader.readLine();
                    Log.d(TAG, "result is " + result);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (bufferedInputStream != null) {
                    try {
                        // 关闭包装流后，被包装的底层流也会自动关闭
                        bufferedInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }).start();
}

权限申请（因为用到了获取存储卡的内容）：

// 这里的权限也可以用 Manifest.permission.READ_EXTERNAL_STORAGE 和 Manifest.permission.WRITE_EXTERNAL_STORAGE
private static String[] PERMISSIONS_STORAGE = {
        "android.permission.READ_EXTERNAL_STORAGE",
        "android.permission.WRITE_EXTERNAL_STORAGE"
};
public static final int PERMISSION_CODE = 1;

/**
 * 动态获取 SD 卡权限
 */
private void verifyStoragePermissions() {
    // 获取当前的权限情况（有还是无）
    int permission = ActivityCompat.checkSelfPermission(this,
            PERMISSIONS_STORAGE[1]);
    if ((permission != PackageManager.PERMISSION_GRANTED)) {
        // 没有写的权限，需要申请，此时弹出对话框
        //
        ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, PERMISSION_CODE);
    }
}

// TODO: 还需要重写 onRequestPermissionsResult() 来对权限情况进行处理
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull @NotNull String[] permissions, @NonNull @NotNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}

7. 多文件上传

根据单文件上传的逻辑，可以将部分代码抽离重构：
1. http 连接的建立抽离出一个方法，然后传入 boundary 的值就行。
2. 上传的多个文件也可以抽离出一个方法，然后返回一个 List<File> 。
3. 多文件上传的 http 请求的主体内容（根据实际情况）是头 + 主体 + 头 + 主体 + ... + 头 + 主体 + 结尾。
4. 头、主体、结尾都可以抽离出方法出来。
主体与主体之间的连接：
请求样例

代码：

public void postFiles(View view) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            String BOUNDARY = "--------------------------448401221482175638146520";
            OutputStream outputStream = null;
            try {
                // 建立连接
                HttpURLConnection httpURLConnection = getHttpURLConnection(BOUNDARY);
                httpURLConnection.connect();
                Log.d(TAG, "connection established");
                
                // 获取输出流
                outputStream = httpURLConnection.getOutputStream();
                
                // 获取 Files
                List<File> fileList = initFiles();
                Iterator<File> fileIterator = fileList.iterator();
                // 用迭代器迭代文件列表
                while (fileIterator.hasNext()) {
                    File file = fileIterator.next();
                    // 获取主体头字符串
                    String bodyHeaderString = getBodyHeaderString(file, BOUNDARY);
                    outputStream.write(bodyHeaderString.getBytes(StandardCharsets.UTF_8));
                    
                      //// 文件内容
                      //// 文件输入流是以字节的方式读取文件内容（数据），文件输出流是将数据写入到文件中
                      //FileInputStream fileInputStream = new FileInputStream(file);
                      //// 字节缓冲流、是高级的流，需要套在底层的流上以增加读写效率和其他方法
                      //bufferedInputStream = new BufferedInputStream(fileInputStream);
                      //byte[] buffer = new byte[1024];
                      //int readLength;
                      //while ((readLength = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
                      //    outputStream.write(buffer, 0, readLength);
                      //}
                      //// 主体结束后再补个换行，这样子下一个文件的头就可以接上
                      //outputStream.write("\r\n".getBytes(), 0, "\r\n".getBytes().length);
                      //bufferedInputStream.close();
                    
                    // 获取文件主体部分的文件输出流，即将上面注释内容的方法重构
                    outputStream = getBodyContentStream(outputStream, file);
                    
                    // 结尾，如果是最后一个文件，就要加
                    if (!fileIterator.hasNext()) {
                        String bodyEndingString = getBodyEndingString(BOUNDARY);
                        outputStream.write(bodyEndingString.getBytes(StandardCharsets.UTF_8));
                    }
                }
                outputStream.flush();
                // 获取连接的返回内容
                String result = getResponseContent(httpURLConnection);
                if (result != null) {
                    Log.d(TAG, "result == " + result);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }).start();
}

public List<File> initFiles() {
    List<File> fileList = new ArrayList<>();
    File file1 = new File("/storage/emulated/0/Download/904413721286148096.png");
    fileList.add(file1);
    File file2 = new File("/storage/emulated/0/Download/936603765992062976.jpg");
    fileList.add(file2);
    return fileList;
}

/**
 * 获取到 HttpURLConnection (多文件上传）
 *
 * @param BOUNDARY 由网页自动计算，也可以通过抓包获取一个
 * @return HttpURLConnection 返回一个 HttpURLConnection 的实例对象
 * @throws IOException
 */
@NotNull
private HttpURLConnection getHttpURLConnection(String BOUNDARY) throws IOException {
    URL url = new URL(BASE_URL + "/files/upload");
    HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
    httpURLConnection.setRequestMethod("POST");
    httpURLConnection.setConnectTimeout(10000);
    httpURLConnection.setRequestProperty("User-Agent", "Android/" + Build.VERSION.SDK_INT);
    httpURLConnection.setRequestProperty("Accept", "*/*");
    // 等同于 httpURLConnection.setUseCaches(false);
    httpURLConnection.setRequestProperty("Cache-Control", "no-cache");
    httpURLConnection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
    httpURLConnection.setRequestProperty("Connection", "keep-alive");
    // 默认为 true
    httpURLConnection.setDoInput(true);
    // 默认为 false，因此需要开启
    httpURLConnection.setDoOutput(true);
    return httpURLConnection;
}

/**
 * 获取主体的头部部分
 *
 * @param file
 * @param BOUNDARY
 * @return
 */
public String getBodyHeaderString(@NotNull File file, String BOUNDARY) {
    StringBuilder headerInfoSb = new StringBuilder();
    String fileKey = "files";
    String fileName = file.getName();
    String fileType = null;
    try {
        fileType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(MimeTypeMap.getFileExtensionFromUrl(file.toURI().toURL().toString()));
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
    // 准备发送数据的头部数据（是 http 中主体部分的）
    headerInfoSb.append("--");
    headerInfoSb.append(BOUNDARY);
    // \n 是换到下一行（的相同位置），\r 是回到行首
    // 因此实际上，在 windows 中的回车键（敲一次 enter）就是 \r\n
    headerInfoSb.append("\r\n");
    headerInfoSb.append("Content-Disposition: form-data; name=\"" + fileKey + "\"; filename=\"" + fileName + "\"");
    headerInfoSb.append("\r\n");
    headerInfoSb.append("Content-Type: " + fileType);
    headerInfoSb.append("\r\n");
    headerInfoSb.append("\r\n");
    Log.d(TAG, "stringBuilder.toString() === " + headerInfoSb.toString());
    return headerInfoSb.toString();
}

/**
 * 获得将文件转换成字节，输入到指定输出流的方法。
 *
 * @param httpURLConnectionOutputStream 从 httpURLConnection 获得的输出流
 * @param file 文件
 * @return 返回写入了文件的输出流
 */
public OutputStream getBodyContentStream(OutputStream httpURLConnectionOutputStream, File file) {
    OutputStream outputStream = httpURLConnectionOutputStream;
    BufferedInputStream bufferedInputStream = null;
    try {
        // 文件内容
        // 文件输入流是以字节的方式读取文件内容（数据），文件输出流是将数据写入到文件中
        FileInputStream fileInputStream = new FileInputStream(file);
        // 字节缓冲流、是高级的流，需要套在底层的流上以增加读写效率和其他方法
        bufferedInputStream = new BufferedInputStream(fileInputStream);
        byte[] buffer = new byte[1024];
        int readLength;
        while ((readLength = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
            outputStream.write(buffer, 0, readLength);
        }
        // 主体结束后再补个换行，这样子下一个文件的头就可以接上
        outputStream.write("\r\n".getBytes(), 0, "\r\n".getBytes().length);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (bufferedInputStream != null) {
            try {
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return outputStream;
}

/**
 * 获取主体的结尾部分
 *
 * @param BOUNDARY
 * @return
 */
public String getBodyEndingString(String BOUNDARY) {
    // 主体的结尾部分
    StringBuilder endingInfoSb = new StringBuilder();
    endingInfoSb.append("--");
    endingInfoSb.append(BOUNDARY);
    endingInfoSb.append("--");
    endingInfoSb.append("\r\n");
    return endingInfoSb.toString();
}

/**
 * 获取连接的返回结果
 *
 * @param httpURLConnection
 * @return result 返回的结果
 */
public String getResponseContent(HttpURLConnection httpURLConnection) {
    String result = null;
    InputStream inputStream = null;
    BufferedReader bufferedReader = null;
    try {
        int responseCode = httpURLConnection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            inputStream = httpURLConnection.getInputStream();
            bufferedReader = new BufferedReader(
                    new InputStreamReader(inputStream, StandardCharsets.UTF_8));
            result = bufferedReader.readLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return result;
}

8. 文件下载

请求样例：
处理思路：
1. 发起 http 请求，获取返回码
2. 获取返回包的 http 头部中的文件名
3. 获取 app 下存放文件的路径以及创建新的文件
4. 将获取到的数据通过流写入到新的文件中

代码：

    public void downloadFile(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Random random = new Random();
                int randomNumber = random.nextInt(17);
                BufferedOutputStream bufferedOutputStream = null;
                BufferedInputStream bufferedInputStream = null;
                // 判断文件的绝对路径是否已经创建
                boolean isDirMked = false;
                // 判断文件是否已经在目录中创建
                boolean IsNewFileCreated = false;
                try {
                    URL url = new URL(BASE_URL + "/download/" + randomNumber);
                    HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                    httpURLConnection.setConnectTimeout(10000);
                    httpURLConnection.setRequestProperty("Accept", "*/*");
                    httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9");
                    httpURLConnection.setRequestMethod("GET");
                    httpURLConnection.connect();

                    // 获取返回码以及返回包的 http 头内容
                    int responseCode = httpURLConnection.getResponseCode();
                    Log.d(TAG, "responseCode === " + responseCode);
                    if (responseCode == HttpURLConnection.HTTP_OK) {
                        Map<String, List<String>> headerFields = httpURLConnection.getHeaderFields();
                        for (Map.Entry<String, List<String>> stringListEntry : headerFields.entrySet()) {
                            Log.d(TAG, stringListEntry.getKey() + " = " + stringListEntry.getValue());
                        }

//                        // 拿到 Content-disposition 的值（以列表的形式）
//                        // 从结果来看，结果的列表就一个值。
//                        List<String> strings = headerFields.get("Content-disposition");
//                        for (String string : strings) {
//                            Log.d(TAG, "string === " + string);
//                        }
                        // 或者用这个方法返回值（以字符串的形式
                        String headerField = httpURLConnection.getHeaderField("Content-disposition");
                        Log.d(TAG, "headerField === " + headerField);

                        // 处理的方式一定要根据后台
                        // 字符串处理
                        int index = headerField.indexOf("filename=");
                        // 从 "=" 号向后切割
//                        String filename = headerField.substring(index + "filename=".length());
//                        Log.d(TAG, "filename === " + filename);
                        // 或者这样处理，将原来字符串的前面所有内容都变成空字符串
                        String filename = headerField.replace("attachment; filename=", "");
                        Log.d(TAG, "filename === " + filename);

                        // 这个方法在 api 29 时已经过时，根据提示，使用 Context 下面的 getExternalFilesDir()
//                        Environment.getExternalStorageDirectory()
                        File picFileDir = RequestTestActivity.this.getExternalFilesDir(Environment.DIRECTORY_PICTURES);
                        // 返回的结果如下：
                        // /storage/emulated/0/Android/data/com.example.androidnetworkdemo/files/Pictures
                        Log.d(TAG, "externalFilesDir is " + picFileDir.toString());
                        // 如果路径不存在，就创建绝对路径（因为获得的时候也是绝对路径
                        if (!picFileDir.exists()) {
                            isDirMked = picFileDir.mkdirs();
                        }
                        if (isDirMked) {
                            Log.d(TAG, "absolute dir was created");
                        }
                        // File.separator 是当前操作系统的文件路径分割符（即 "/" 或者 "\\"）
                        File file = new File(picFileDir + File.separator + filename);
                        // 如果文件不存在（也应该不存在），那就创建文件
                        if (file.exists()) {
                            IsNewFileCreated = file.createNewFile();
                        }
                        if (IsNewFileCreated) {
                            Log.d(TAG, "file was created");
                        }
                        FileOutputStream fileOutputStream = new FileOutputStream(file);
                        bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
                        InputStream httpURLConnectionInputStream = httpURLConnection.getInputStream();
                        bufferedInputStream = new BufferedInputStream(httpURLConnectionInputStream);
                        byte[] buffer = new byte[1024];
                        int length;
                        while ((length = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
                            bufferedOutputStream.write(buffer, 0, length);
                        }
                        bufferedOutputStream.flush();

                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (bufferedInputStream != null) {
//                        try {
//                            bufferedInputStream.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
                        // 使用自己创建的工具类：
                        IOUtils.ioClose(bufferedInputStream);
                    }
                    if (bufferedOutputStream != null) {
//                        try {
//                            bufferedOutputStream.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
                        // 使用自己创建的工具类：
                        IOUtils.ioClose(bufferedOutputStream);
                    }
                }

            }
        }).start();
    }

IOUtils.java：

package com.example.androidnetworkdemo.Utils;

import org.jetbrains.annotations.NotNull;

import java.io.Closeable;
import java.io.IOException;

public class IOUtils {

    // 输入输出流均继承自 Closeable，因此调用他们父类的 close() 即可，就不用分输入流和输出流。
    public static void ioClose(@NotNull Closeable closeable) {
        try {
            closeable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. OkHttp 框架

1. 使用 OkHttp 发起 get 请求

1. 过程

首先要添加 OkHttp 的依赖：

implementation("com.squareup.okhttp3:okhttp:4.9.3")

写一个客户端（OkHttpClient）（也就是 Call 的工厂）
创建请求内容（Request 类），用来完善请求的一些信息
用客户端创建请求任务（也就是 Call 类）（Call 类代表一个请求已经准备就绪，并且其也是用来发起 http 请求的类）
执行同步或者异步请求
通过 Response 类来获取返回码与返回的主体内容

2. 代码

发起请求的函数：

public void getRequestWithOkHttp(View view) {
    // 要现有一个客户端（浏览器）（也就是 Call 的工厂）
    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10000, TimeUnit.MILLISECONDS)
            .build();
    
    // 创建请求内容，用来完善请求的一些信息
    Request request = new Request
            .Builder()
            .get()
            .url(BASE_URL + "/get/text")
            .build();
    
    // 用 client 去创建请求任务，Call 代表一个请求已经准备被执行（类似一个任务已经准备就绪）
    Call task = okHttpClient.newCall(request);
    
    // 异步请求，enqueue 表示排队准备处理
    task.enqueue(new Callback() {
        /**
         * 请求失败时执行
         * @param call 请求任务
         * @param e 报错信息
         */
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            Log.d(TAG, "onFailure --> " + e.toString());
        }
        
        /**
         * 请求成功时执行
         * @param call
         * @param response
         * @throws IOException
         */
        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            // 获得响应码
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            
            if (code == HttpURLConnection.HTTP_OK) {
                // 获取回包的主体内容，ResponseBody 继承自 Closeable，因此是一个流
                ResponseBody body = response.body();
                // ResponseBody.string() 方法表示将回包的主体部分以字符串的形式返回
                if (body != null) {
                    Log.d(TAG, "body --> " + body.string());
                }
            }
        }
    });
}

3. 结果

获取的结果如下：

2. 使用 OkHttp 通过 Post 方式提交评论

1. 过程

服务器接口图：
由 1 可知，要发送的主体内容是一个 json 格式。那么考虑将样式的 json 通过 GsomFormatPlus 生成 JavaBean 类，然后把要评论的文章 id 和评论内容放到一个实例化的 JavaBean 类里面，然后再通过 Gson 的方法将其转换成 json 格式，放到发送包的主体即可。
剩下步骤和使用 OkHttp 发起 get 请求一样。

2. 代码

发起请求的函数：

public void postComment(View view) {
    // 先有 client
    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10000, TimeUnit.MILLISECONDS)
            .build();
    
    // 获取 json（来自 JavaBean，然后这部分可以封装，从 UI 获取评论的内容
    CommentItem commentItem = new CommentItem("123456789", "我是评论的内容");
    Gson gson = new Gson();
    String jsonStr = gson.toJson(commentItem);
    // 设置 MIME
    MediaType mediaType = MediaType.get("application/json; charset=utf-8");
    // 这里 create() 的第一个参数是请求的主体部分的字符串形式，
    RequestBody requestBody = RequestBody.create(jsonStr, mediaType);
    
    // 创建请求内容，用来完善请求的一些信息
    Request request = new Request
            .Builder()
            .post(requestBody)
            .url(BASE_URL + "/post/comment")
            .build();
    
    Call call = okHttpClient.newCall(request);
    call.enqueue(new Callback() {
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            Log.d(TAG, "onFailure --> " + e.toString());
        }
        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            int code = response.code();
            Log.d(TAG, "code === " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                ResponseBody body = response.body();
                if (body != null) {
                    Log.d(TAG, "result --> " + body.string());
                }
            }
        }
    });
}

3. 结果

成功返回的结果如下：

3. OkHttp 为 get 请求添加参数

创建 HttpUrl.Builder 的实例
然后该实例中调用 addQueryParameter(String key, String value) 来添加参数
在 request 中，.url(实例.build())
参考 OKHttp3带参数发送get和post请求工具类_qq243920161的博客-CSDN博客_okhttp3发送get请求

4. 通过 OkHttp 进行单文件上传

1. 过程

创建 client
创建 File 对象，获取该文件的 MIME 类型
在 Request 对象中，.post() 方法里面要传入 RequestBody，然后 MultipartBody.Builder 类里面可以通过 .addFormDataPart() 方法传入主体内容。接着 .addFormDataPart() 又需要一个 RequestBody 类，因此创建一个 Request 的实例，用 create(File file, MediaType contentType) 来创建。
第 3 点往回创建响应的东西即可
创建 Call
异步请求
接口定义：

2. 代码

实现代码：

public void postFile(View view) throws MalformedURLException {
    // 先有 client
    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10000, TimeUnit.MILLISECONDS)
            .build();
    
    File file = new File("/storage/emulated/0/Download/904413721286148096.png");
    // 获取文件的 MIME 类型
    MediaType fileType = MediaType.get(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(file.toURI().toURL().toString())));
    RequestBody fileBody = RequestBody.create(file, fileType);
    // 根据 MultipartBody.Builder().addFormDataPart() 里面的参数要求，逐个创建参数
    // MultipartBody 对应的就是 http 中的 Multipart 字段
    RequestBody requestBody = new MultipartBody.Builder()
            .addFormDataPart("file", file.getName(), fileBody).build();
    Request request = new Request.Builder()
            .url(BASE_URL + "/file/upload")
            .post(requestBody)
            .build();
    
    // 创建 call
    Call task = okHttpClient.newCall(request);
    // 异步请求
    task.enqueue(new Callback() {
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            Log.d(TAG, "onFailure ..." + e.toString());
        }
        
        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            int code = response.code();
            Log.d(TAG, "code === " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                ResponseBody body = response.body();
                if (body != null) {
                    String string = body.string();
                    Log.d(TAG, "result --> " + string);
                }
            }
        }
    });
}

3. 结果

上传结果：

5. 通过 OkHttp 上传多个文件

1. 过程

由上面可知，只需要创建多个 File，多创建 requestBody 和调用 addFormDataPart() 即可。

在 OkHttp 的 Receipes 中，其给出了上传单个文件的其他方法：

 public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.parse("text/x-markdown; charset=utf-8");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    File file = new File("README.md");

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, file))
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

即直接传入一个 RequestBody 即可（和提交评论一样，本质上就是 post 传一个主体）

通过 MultipartBody 来上传文件，可以上传多个文件。
接口定义：

2. 代码

执行函数：

public void postFiles(View view) throws MalformedURLException {
    // 先有 client
    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10000, TimeUnit.MILLISECONDS)
            .build();
    
    File fileOne = new File("/storage/emulated/0/Download/904413721286148096.png");
    File fileTwo = new File("/storage/emulated/0/Download/936603765992062976.jpg");
    
    // 获取文件的 MIME 类型
    MediaType fileOneType = MediaType.get(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(fileOne.toURI().toURL().toString())));
    MediaType fileTwoType = MediaType.get(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(fileOne.toURI().toURL().toString())));
    RequestBody fileOneBody = RequestBody.create(fileOne, fileOneType);
    RequestBody fileTwoBody = RequestBody.create(fileTwo, fileTwoType);
    // 根据 MultipartBody.Builder().addFormDataPart() 里面的参数要求，逐个创建参数
    // MultipartBody 对应的就是 http 中的 Multipart 字段
    // 这里 post 传输的 requestBody 相当于嵌套了多个 requestBody
    RequestBody requestBody = new MultipartBody.Builder()
            .addFormDataPart("files", fileOne.getName(), fileOneBody)
            .addFormDataPart("files", fileTwo.getName(), fileTwoBody)
            .build();
    Request request = new Request.Builder()
            .url(BASE_URL + "/files/upload")
            .post(requestBody)
            .build();
    
    // 创建 call
    Call task = okHttpClient.newCall(request);
    // 异步请求
    task.enqueue(new Callback() {
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            Log.d(TAG, "onFailure ..." + e.toString());
        }
        
        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            int code = response.code();
            Log.d(TAG, "code === " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                ResponseBody body = response.body();
                if (body != null) {
                    String string = body.string();
                    Log.d(TAG, "result --> " + string);
                }
            }
        }
    });
}

3. 结果

结果：

6. 通过 OkHttp 下载文件

1. 过程

接口：
正常发起请求
主要的逻辑处理在返回包上。
首先要拿到返回包的头部，截取出文件的名字
接着创建一个 File 等待写入。
判断文件所在的目录是否创建，没有则需要创建文件夹
判断第 4 点的文件是否存在，不存在就创建
获取返回包的输入流并创建文件的输出流。
字节读取并输入。

2. 代码

public void downloadFile(View view) {
    // 先有 client
    OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10000, TimeUnit.MILLISECONDS)
            .build();
    
    // 用一个随机数来获取不同的图片
    Random random = new Random();
    
    // 构造请求内容
    Request request = new Request.Builder()
            .get()
            .url(BASE_URL + "/download/" + random.nextInt(17))
            .build();
    
    // 获取任务（call）
    final Call call = okHttpClient.newCall(request);
    // 同步执行，需要异常处理，因此可以在子进程中进行
    new Thread(new Runnable() {
        @Override
        public void run() {
            BufferedInputStream bufferedInputStream = null;
            BufferedOutputStream bufferedOutputStream = null;
            try {
                Response execute = call.execute();
                int code = execute.code();
                // 如果返回码是 200
                if (code == HttpURLConnection.HTTP_OK) {
                    Headers headers = execute.headers();
                    // 遍历拿到返回包的头部
                    for (int i = 0; i < headers.size(); i++) {
                        String key = headers.name(i);
                        String value = headers.value(i);
                        Log.d(TAG, key + " === " + value);
                    }
                    
                    // 拿到下载的文件名
                    String fileName = headers.get("Content-disposition").
                            replace("attachment; filename=", "");
                    // 创建文件，加分割符的还有一个目的就是将参数的第一个部分从 file 转换成 String
                    File outFile = new File(OkHttpActivity.this.getExternalFilesDir(Environment.DIRECTORY_PICTURES) + File.separator + fileName);
                    // 如果这个文件所在的上一级目录不存在的话（也就是没有文件夹），那么就一直创建文件夹直到上级
                    if (!Objects.requireNonNull(outFile.getParentFile()).exists()) {
                        outFile.mkdirs();
                    }
                    // 如果文件不存在，就创建文件
                    if (!outFile.exists()) {
                        outFile.createNewFile();
                    }
                    
                    if (execute.body() != null) {
                        // 获取输入流
                        InputStream inputStream = execute.body().byteStream();
                        bufferedInputStream = new BufferedInputStream(inputStream);
                        // 创建文件输出流
                        bufferedOutputStream = new BufferedOutputStream(
                                new FileOutputStream(outFile));
                        byte[] buffer = new byte[1024];
                        int length;
                        // 文件字节写入
                        while ((length = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
                            bufferedOutputStream.write(buffer, 0, length);
                        }
                        bufferedOutputStream.flush();
                    }
                    
                    if (outFile.exists()) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(OkHttpActivity.this, "下载 " + fileName + " 成功", Toast.LENGTH_LONG).show();
                            }
                        });
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (bufferedInputStream != null) {
                    IOUtils.ioClose(bufferedInputStream);
                }
                if (bufferedOutputStream != null) {
                    IOUtils.ioClose(bufferedOutputStream);
                }
            }
        }
    }).start();
}

3. 结果

返回的结果：

7. OkHttp

官网：Overview - OkHttp (square.github.io)
一些常见的运用方法可以查看官网中的 Recipes：Recipes - OkHttp (square.github.io)

4. retrofit 框架封装

retrofit

1. 使用 retrofit 发起 get 请求并将数据在 UI 上显示

1. 过程

新建一个接口，叫 Api.java。
然后创建 Get 注释，里面的参数为相对路径，表示请求的方式是 Get
创建一个方法，返回值为 Call<ResponseBody> 。
在发起请求的方法中，先实例化一个 Retrofit 对象，实例化的过程中，需要调用 .baseUrl(BASE_URL) 来指明基本的 Url。
用 Retrofit 对象创建接口实例，实现接口。
调用第 3 点创建的方法，拿到一个 Call 以发起 http 请求
接下来和用 OkHttp 发起请求一样。
用 RecyclerView 显示获取的 Json 数据

2. 代码

MainActivity.java：

package com.example.retrofitdemo;

import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.ListAdapter;
import androidx.recyclerview.widget.RecyclerView;

import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.example.retrofitdemo.adapters.ListViewAdapter;
import com.example.retrofitdemo.domain.JsonResult;
import com.example.retrofitdemo.interfaces.Api;
import com.google.gson.Gson;

import java.io.IOException;
import java.net.HttpURLConnection;

import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private RecyclerView mResultList;
    private ListViewAdapter mListViewAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    private void initView() {
        mResultList = this.findViewById(R.id.result_list);
        mResultList.setLayoutManager(new LinearLayoutManager(this));
        mListViewAdapter = new ListViewAdapter();
        mResultList.setAdapter(mListViewAdapter);
    }

    public void getRequest(View view) {
        // Retrofit 的本质作用是将对 http 的 api 抽成一个 java 接口
        // 相当于将 OkHttp 中设置 url，设置 multipart 等一系列操作再抽成接口
        // 这里个人认为类似创建 client，但是比 client 更简洁，而且还设置了 baseUrl
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://192.168.43.110:9102")
                .build();

        // 创建接口实例，实现接口
        Api api = retrofit.create(Api.class);
        // 准备执行 http 请求，至于这个请求的 request（也就是具体的请求头内容或者其他内容的设置）取决于其在接口中的定义
        // 这里的 getJson() 在接口中的参数什么也没有指明，因此这里就是单纯的发出一个 http 请求
        Call<ResponseBody> task = api.getJson();
        // 异步发起 http 请求
        task.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                String result;
                int code = response.code();
                Log.d(TAG, "code --> " + code);
                if (code == HttpURLConnection.HTTP_OK) {
                    try {
                        result = response.body().string();
//                        Log.d(TAG, "json --> " + result);

                        Gson gson = new Gson();
                        JsonResult jsonResult = gson.fromJson(result, JsonResult.class);
                        updateList(jsonResult);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            private void updateList(JsonResult jsonResult) {
                mListViewAdapter.setData(jsonResult);
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                Log.d(TAG, "onFailure " + t.toString());
            }
        });
    }
}

ListViewAdapter.java

package com.example.retrofitdemo.adapters;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;

import com.bumptech.glide.Glide;
import com.example.retrofitdemo.R;
import com.example.retrofitdemo.domain.JsonResult;

import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.List;

public class ListViewAdapter extends RecyclerView.Adapter<ListViewAdapter.InnerHolder> {

    private List<JsonResult.DataBean> mDataBeanList = new ArrayList<>();

    @NonNull
    @NotNull
    @Override
    public InnerHolder onCreateViewHolder(@NonNull @NotNull ViewGroup parent, int viewType) {
        // 渲染获得 item 的 view
        View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_json_result, null);
        return new InnerHolder(itemView);
    }

    @Override
    public void onBindViewHolder(@NonNull @NotNull InnerHolder holder, int position) {
        // 绑定数据
        // 获得当前位置的 JavaBean
        JsonResult.DataBean dataBean = mDataBeanList.get(position);
        // 传入的相当于是 data 中的一项
        holder.setItemData(dataBean);
    }

    @Override
    public int getItemCount() {
        return mDataBeanList.size();
    }

    public void setData(JsonResult jsonResult) {
        // 先把数据列表清除一遍
        mDataBeanList.clear();
        // 将 json 中键为 Data 的 JavaBean 写入
        mDataBeanList.addAll(jsonResult.getData());
        notifyDataSetChanged();
    }


    public class InnerHolder extends RecyclerView.ViewHolder {

        private final ImageView mResultIcon;
        private final TextView mResultTitle;
        private final TextView mResultUserName;
        private final TextView mResultViewCount;
        private final TextView mResultCommentCount;

        public InnerHolder(@NonNull @NotNull View itemView) {
            super(itemView);
            mResultIcon = itemView.findViewById(R.id.result_icon_item);
            mResultTitle = itemView.findViewById(R.id.result_title_item);
            mResultUserName = itemView.findViewById(R.id.result_username_item);
            mResultViewCount = itemView.findViewById(R.id.result_ViewCount_item);
            mResultCommentCount = itemView.findViewById(R.id.result_commentCount_item);
        }

        public void setItemData(JsonResult.DataBean dataBean){
            Glide.with(itemView.getContext())
                    .load("http://192.168.43.110:9102" + dataBean.getCover())
                    .into(mResultIcon);
            mResultTitle.setText(dataBean.getTitle());
            mResultUserName.setText(dataBean.getUserName());
            mResultViewCount.setText(dataBean.getViewCount() + "");
            mResultCommentCount.setText(dataBean.getCommentCount() + "");

        }
    }
}

jsonResult.java 由返回获取到的 json 数据使用 GsonFormatPlus 生成。

activity_main.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="getRequest"
        android:text="getRequest"
        android:textAllCaps="false" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/result_list"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

    </androidx.recyclerview.widget.RecyclerView>
    
</LinearLayout>

item_json_result.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">

    <androidx.cardview.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="#fff000"
        app:cardBackgroundColor="#f6fDf0"
        app:cardCornerRadius="5dp"
        app:cardElevation="7dp"
        app:cardUseCompatPadding="true">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal" >

            <ImageView
                android:id="@+id/result_icon_item"
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:scaleType="fitXY"
                android:src="@mipmap/ic_launcher" />

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="vertical">

                <TextView
                    android:id="@+id/result_title_item"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_marginTop="10dp"
                    android:ellipsize="end"
                    android:lines="1"
                    android:text="我是标题"
                    android:layout_marginLeft="10dp"
                    android:textSize="30sp" />

                <LinearLayout
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_marginTop="15dp"
                    android:layout_marginLeft="10dp"
                    android:orientation="horizontal">

                    <TextView
                        android:id="@+id/result_username_item"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="作者："
                        android:textSize="18sp" />

                    <TextView
                        android:id="@+id/result_ViewCount_item"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="50dp"
                        android:text="阅览数："
                        android:textSize="18sp" />

                    <TextView
                        android:id="@+id/result_commentCount_item"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="30dp"
                        android:text="评论数："
                        android:textSize="18sp" />

                </LinearLayout>

            </LinearLayout>

        </LinearLayout>

    </androidx.cardview.widget.CardView>

</LinearLayout>

3. 结果

2. 使用转换器将接收的 json 数据转成对象

1. 过程

这里先将 Retrofit 的创建重构成一个工具类，这样每次直接调用即可。

要将 json 转成对象，首先要添加一下依赖：

implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

然后在创建 Retrofit 对象时，调用 addConverterFactory(GsonConverterFactory.create()) 来添加工厂。
在接口中，原先的接收数据类 --- RequestBody 改成自己定义的 JavaBean 类。这样在获得返回结果（response.body()）就是自己定义的 JavaBean 类。

2. 代码

工具 RetrofitManager.java （接下来创建 Retrofit 对象的时候都会用到）

package com.example.retrofitdemo.Utils;

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitManager {
    // Retrofit 的本质作用是将对 http 的 api 抽成一个 java 接口
    // 相当于将 OkHttp 中设置 url，设置 multipart 等一系列操作再抽成接口
    // 这里个人认为类似创建 client，但是比 client 更简洁，而且还设置了 baseUrl
    private static Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://192.168.43.110:9102")
            .addConverterFactory(GsonConverterFactory.create())
            .build();

    public static Retrofit getRetrofit() {
        return retrofit;
    }
}

接口定义（在接口 Api.java 中）：

// Call<>，<> 中是接收数据的类
@GET("/get/text")
Call<JsonResult> getJson();

逻辑方法（其他的详见上面大点 1）：

public void getRequest(View view) {
    // 创建接口实例，实现接口
    Api api = RetrofitManager.getRetrofit().create(Api.class);
    // 准备执行 http 请求，至于这个请求的 request（也就是具体的请求头内容或者其他内容的设置）取决于其在接口中的定义
    // 这里的 getJson() 在接口中的参数什么也没有指明，因此这里就是单纯的发出一个 http 请求
    Call<JsonResult> task = api.getJson();
    // 异步发起 http 请求
    task.enqueue(new Callback<JsonResult>() {
        @Override
        public void onResponse(@NotNull Call<JsonResult> call, @NotNull Response<JsonResult> response) {
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                // 将接口的接收返回结果的类改成 JsonResult 后，现在 response.body() 返回的类型就是 JsonResult
                // 其自动将 json 转成了 JsonResult 类，前提是需要设置转换工厂和转换器
                JsonResult result = response.body();
                updateList(result);
            }
        }
        
        // 将获得到的 json 数据传入到 adapter 处理
        private void updateList(JsonResult jsonResult) {
            mListViewAdapter.setData(jsonResult);
        }
        
        @Override
        public void onFailure(Call<JsonResult> call, Throwable t) {
            Log.d(TAG, "onFailure " + t.toString());
        }
    });
}

3. 使用 @Query 注解发起带参数的请求

1. 过程

在接口方法的参数中添加 @Query("key") String key，代表调用该方法时传入的值是键 "key" 的值，可以传入多个。

2. 代码

逻辑方法：

public void getWithParams(View view) {
    // 将前面实例化 Retrofit 的代码抽取成一个工具类
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    // 实例化 call，注意用 getWithParams() 方法
    Call<GetWithParamsResult> call = api.getWithParams("我是搜索的关键字...", "5", "0");
    call.enqueue(new Callback<GetWithParamsResult>() {
        @Override
        public void onResponse(@NotNull Call<GetWithParamsResult> call, @NotNull Response<GetWithParamsResult> response) {
            // 因为这里调用的是 .body() 的 toString()，因此 GetWithParamsResult 要重写 toString() 方法
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                // data 是个 JavaBean，如果不重写其 toString()，那么返回的内容为内存地址
                Log.d(TAG, "Response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<GetWithParamsResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

接口中定义的方法：

// 接收数据的类由返回的 json 使用工具生成
// 用 @Query 来添加参数
@GET("/get/param")
Call<GetWithParamsResult> getWithParams(@Query("keyword") String keyword,
                                        @Query("page") String page,
                                        @Query("order") String order);

GetWithParamsResult 类由请求结果返回的 json 使用工具生成。

3. 结果

结果截图：

4. 使用 @QueryMap 注解来往 url 中传入多个参数

1. 过程

在接口方法的参数中添加 @QueryMap Map<String, String> params ，代表传入的 map 就是多个参数（键值对）。

2. 代码

接口方法定义：

// 重载方法，如果参数很多的时候，就传入一个 Map
@GET("/get/param")
Call<GetWithParamsResult> getWithParams(@QueryMap Map<String, Object> params);

逻辑方法：

public void getWithParams_QueryMap(View view) {
    // 将前面实例化 Retrofit 的代码抽取成一个工具类
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    Map<String, Object> params = new HashMap<>();
    params.put("keyword", "我是通过 Map 的关键字");
    params.put("page", "5");
    params.put("order", "0");
    // 实例化 call，注意用 getWithParams() 方法
    Call<GetWithParamsResult> call = api.getWithParams(params);
    call.enqueue(new Callback<GetWithParamsResult>() {
        @Override
        public void onResponse(@NotNull Call<GetWithParamsResult> call, @NotNull Response<GetWithParamsResult> response) {
            // 因为这里调用的是 .body() 的 toString()，因此 GetWithParamsResult 要重写 toString() 方法
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                // data 是个 JavaBean，如果不重写其 toString()，那么返回的内容为内存地址
                Log.d(TAG, "Response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<GetWithParamsResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

4. @Url 注释的使用

1. 代码

接口方法的定义：

// 不指明 url，让 url 传进来
@POST
Call<PostWithParamsResult> postWithUrl(@Url String url);

逻辑方法（基本的 Url 在 retrofit 中已经定义）：

public void postWithUrl(View view) {
    // 将前面实例化 Retrofit 的代码抽取成一个工具类
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    String url = "/post/string?string=测试内容";
    Call<PostWithParamsResult> postWithParamsResultCall = api.postWithUrl(url);
    postWithParamsResultCall.enqueue(new Callback<PostWithParamsResult>() {
        @Override
        public void onResponse(Call<PostWithParamsResult> call, Response<PostWithParamsResult> response) {
            // 因为这里调用的是 .body() 的 toString()，因此 PostWithParamsResult 要重写 toString() 方法
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "Response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<PostWithParamsResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

2. 结果

结果截图：

5. 用 @Body 注解来上传 json 内容

1. 过程

由提交评论的主体内容可知，要提交一个 json 格式的数据来发表评论。
@Body 注解表示直接控制请求的主体内容。主体内容会用指定的 Converter 来序列化。

2. 代码

接口方法定义（PostWithParamsResult 和 PostCommentItem 类需要自己根据 json 来转换定义）：

// 用 post 提交评论（主体部分为 json）
// 注意分辨接收数据的类和提交数据的类
// @Body 注解表示直接控制请求的主体内容。主体内容会用指定的 Converter 来序列化。
@POST("/post/comment")
Call<PostWithParamsResult> postBody(@Body PostCommentItem commentItem);

逻辑方法：

public void postWithBody(View view) {
    PostCommentItem postCommentItem = new PostCommentItem("123456", "点赞");
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    Call<PostWithParamsResult> postWithParamsResultCall = api.postBody(postCommentItem);
    postWithParamsResultCall.enqueue(new Callback<PostWithParamsResult>() {
        @Override
        public void onResponse(@NotNull Call<PostWithParamsResult> call, @NotNull Response<PostWithParamsResult> response) {
            int code = response.code();
            Log.d(TAG, "code === " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "responseBody --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<PostWithParamsResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

3. 结果

结果截图：

6. 使用 @Part 和 @Multipart 注解来上传文件

1. 过程

@Multipart 的 @Target 是 METHOD，因此它需要写在方法上面。
一般 @Part 注释的对象是键的值（当然值也可以是自己的类，但需要 Conventor），或者是 MultipartBody.Part。
在逻辑方法中创建 MultipartBody.Part 的对象，至于创建的方法（偏工厂模式的创建方法）和参数可以根据提示与要求。

2. 代码

接口方法定义：

// 使用 @Part 和 MultipartBody.Part 来上传图片
@POST("/file/upload")
@Multipart
Call<PostFileResult> postFile(@Part MultipartBody.Part part);

逻辑方法：

public void postFile(View view) throws MalformedURLException {
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    File file = new File("/storage/emulated/0/Download/904413721286148096.png");
    MediaType fileType = MediaType.parse(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(file.toURI().toURL().toString())));
    
    RequestBody requestBody = RequestBody.create(file, fileType);
    // 指定键值对和 MultipartBody 的主体内容
    // 偏工厂模式的创建方法
    MultipartBody.Part part = MultipartBody.Part.createFormData("file", file.getName(), requestBody);
    Call<PostFileResult> postFileResultCall = api.postFile(part);
    postFileResultCall.enqueue(new Callback<PostFileResult>() {
        @Override
        public void onResponse(Call<PostFileResult> call, Response<PostFileResult> response) {
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<PostFileResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

动态权限申请：

public class RequestActivity extends AppCompatActivity {

    private static final String TAG = "RequestActivity";
    private static String[] PERMISSIONS_STORAGE = {
            "android.permission.READ_EXTERNAL_STORAGE",
            "android.permission.WRITE_EXTERNAL_STORAGE"
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_request);

        // 动态获取 SD 卡权限
        verifyStoragePermissions();
    }

    /**
     * 在 Android 8.0 以上的版本中，需要对一些权限使用动态获取
     */
    public void verifyStoragePermissions() {
        int permission = ActivityCompat.checkSelfPermission(RequestActivity.this,
                PERMISSIONS_STORAGE[1]);
        if ((permission != PackageManager.PERMISSION_GRANTED)) {
            // 没有写的权限，需要申请，此时弹出对话框
            ActivityCompat.requestPermissions(RequestActivity.this, PERMISSIONS_STORAGE, 1);
        }
    }

    // 处理授予权限后的操作
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull @NotNull String[] permissions, @NonNull @NotNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == 1) {
            // 如果同意授予权限
            // ...
        } else {
            this.finish();
        }
    }

3. 结果

返回结果截图：

7. 上传多个文件

1. 过程

上传多个文件就用这个方法，下文会讲一个不行的方法。

2. 代码

接口定义：

// 上传多个文件
@POST("/files/upload")
@Multipart
Call<PostFileResult> postFiles(@Part List<MultipartBody.Part> parts);

逻辑方法：

public void postFiles(View view) throws MalformedURLException {
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    // 创建列表
    List<MultipartBody.Part> parts = new ArrayList<>();
    
    File file1 = new File("/storage/emulated/0/Download/904413721286148096.png");
    File file2 = new File("/storage/emulated/0/Download/941345164977242112.png");
    MediaType fileType1 = MediaType.parse(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(file1.toURI().toURL().toString())));
    MediaType fileType2 = MediaType.parse(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(file2.toURI().toURL().toString())));
    
    RequestBody requestBody1 = RequestBody.create(file1, fileType1);
    RequestBody requestBody2 = RequestBody.create(file2, fileType2);
    
    MultipartBody.Part part1 = MultipartBody.Part.createFormData("files", file1.getName(), requestBody1);
    MultipartBody.Part part2 = MultipartBody.Part.createFormData("files", file2.getName(), requestBody2);
    
    parts.add(part1);
    parts.add(part2);
    
    Call<PostFileResult> postFileResultCall = api.postFiles(parts);
    postFileResultCall.enqueue(new Callback<PostFileResult>() {
        @Override
        public void onResponse(Call<PostFileResult> call, Response<PostFileResult> response) {
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<PostFileResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

3. 结果

结果截图：

8. 文件上传并通过 POST 上传一些相关信息（例如注释）

1. 过程

详见接口定义的注解
服务器接口方法：

2. 代码

接口方法的定义：

// 上传需要带有额外信息的文件
// 这里的 @PartMap 可以用 Map<String, MultipartBody.Part> 来上传多个文件。
// 可以看出，@Part("键") 或者 @PartMap Map<键, 值>。也就是说，有两种方式来增加。
// 如果用 Map 和 @Part("键") 来指定，那么可以不用 MultipartBody.Part.createFormData
// 其他的情况，例如 @Part 不加任何参数的话，就要调用 MultipartBody.Part.createFormData 来指定值

// 需要注意的是，@PartMap Map 中的 value 不能为 MultipartBody.Part
// 报错信息：@PartMap values cannot be MultipartBody.Part. Use @Part List<Part> or a different value type instead.
// 因此用 @Part List<Part> parts 配合 MultipartBody.Part.createFormData 来进行多文件上传
@POST("/file/params/upload")
@Multipart
Call<PostFileResult> postFileWithParams(@Part MultipartBody.Part part,
                                        @PartMap Map<String, String> params,
                                        @Part("isFree") String isFree);

逻辑方法：

public void postFileWithParams(View view) throws MalformedURLException {
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    // 获得文件和文件的 MIME 类型
    File file = new File("/storage/emulated/0/Download/904413721286148096.png");
    MediaType fileType = MediaType.parse(MimeTypeMap.getSingleton()
            .getMimeTypeFromExtension(MimeTypeMap
                    .getFileExtensionFromUrl(file.toURI().toURL().toString())));
    
    RequestBody requestBody = RequestBody.create(file, fileType);
    MultipartBody.Part part = MultipartBody.Part.createFormData("file", file.getName(), requestBody);
    Map<String, String> params = new HashMap<>();
    
    // 这里可以看出：添加参数有两种办法，一种就是传入 @PartMap，另外一种就是 @Part("键") 值的类型 值
    params.put("description", "这是一张图片");
    
    Call<PostFileResult> postFileResultCall = api.postFileWithParams(part, params, "false");
    postFileResultCall.enqueue(new Callback<PostFileResult>() {
        @Override
        public void onResponse(Call<PostFileResult> call, Response<PostFileResult> response) {
            int code = response.code();
            Log.d(TAG, "code --> " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "response --> " + response.body().toString());
            }
        }
        
        @Override
        public void onFailure(Call<PostFileResult> call, Throwable t) {
            Log.d(TAG, "onFailure --> " + t.toString());
        }
    });
}

3. 结果

结果截图：

9. 用 @FormUrlEncoded 和 @Field 注解来上传表单数据

1. 过程

在接口方法参数中，@Field("key") String value 来定义键和传入值。
@FormUrlEncoded 表示提交的数据是表单数据，这个必不可少。
服务器接口参数：

2. 代码

接口方法定义：

@POST("/login")
@FormUrlEncoded
Call<LoginResult> doLogin(@Field("userName") String userName, @Field("password") String word);

逻辑方法：

public void doLogin(View view) {
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    Call<LoginResult> loginResultCall = api.doLogin("EndlessShw", "123456");
    loginResultCall.enqueue(new Callback<LoginResult>() {
        @Override
        public void onResponse(Call<LoginResult> call, Response<LoginResult> response) {
            int code = response.code();
            Log.d(TAG, "code == " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "result --> " + response.body());
            }
        }
        @Override
        public void onFailure(Call<LoginResult> call, Throwable t) {
            Log.d(TAG, "onFailure... " + t.toString());
        }
    });
}

3. 结果

结果截图：

10. 用 @FieldMap 上传表单数据的 Map（用 Map 来保存多个键值对）

1. 代码

接口方法的定义：

@POST("/login")
@FormUrlEncoded
Call<LoginResult> doLogin(@FieldMap Map<String, String> params);

逻辑方法：

public void doLogin(View view) {
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    Map<String, String> params = new HashMap<>();
    params.put("userName", "Endless");
    params.put("password", "123789");
    
    Call<LoginResult> loginResultCall = api.doLogin(params);
    loginResultCall.enqueue(new Callback<LoginResult>() {
        @Override
        public void onResponse(Call<LoginResult> call, Response<LoginResult> response) {
            int code = response.code();
            Log.d(TAG, "code == " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                Log.d(TAG, "result --> " + response.body());
            }
        }
        
        @Override
        public void onFailure(Call<LoginResult> call, Throwable t) {
            Log.d(TAG, "onFailure... " + t.toString());
        }
    });
}

2. 结果

结果截图：

11. 用 @Streaming 注解来下载文件

1. 过程

这里下载的 Url 是变化的，因此要用 @Url 来指定具体的 Url。
@Streaming 表示返回体可以获得一个输入流

2. 代码

接口方法定义：

@Streaming
@GET
Call<ResponseBody> downloadFile(@Url String url);

逻辑方法：

public void downloadFile(View view) {
    Random random = new Random();
    int nextInt = random.nextInt(17);
    String Url = "/download/" + nextInt;
    Retrofit retrofit = RetrofitManager.getRetrofit();
    Api api = retrofit.create(Api.class);
    
    Call<ResponseBody> responseBodyCall = api.downloadFile(Url);
    responseBodyCall.enqueue(new Callback<ResponseBody>() {
        @Override
        public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
            int code = response.code();
            Log.d(TAG, "code === " + code);
            if (code == HttpURLConnection.HTTP_OK) {
                // 获得文件名称 --- 在 header 中
                Headers headers = response.headers();
                for (int i = 0; i < headers.size(); i++) {
                    String key = headers.name(i);
                    String value = headers.value(i);
                    Log.d(TAG, key+ ":" + value);
                }
                String filenameHeader = headers.get("Content-disposition");
                String filename = null;
                if (filenameHeader != null) {
                    filename = filenameHeader.replace("attachment; filename=", "");
                    Log.d(TAG, "filename == " + filename);
                }
                // 写文件
                if (filename != null) {
                    writeStringToDisk(response, filename);
                }
            }
        }
        @Override
        public void onFailure(Call<ResponseBody> call, Throwable t) {
            Log.d(TAG, "onFailure... " + t.toString());
        }
    });
}

private void writeStringToDisk(Response<ResponseBody> response, String filename) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 获得返回的输入流
            InputStream inputStream = response.body().byteStream();
            File outFileDir = RequestActivity.this.getExternalFilesDir(Environment.DIRECTORY_PICTURES);
            File outFile = new File(outFileDir, filename);
            Log.d(TAG, "outFile --> " + outFileDir);
            try {
                if (!outFileDir.exists()) {
                    outFileDir.mkdirs();
                }
                if (!outFile.exists()) {
                    outFile.createNewFile();
                }
                
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outFile));
                BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
                
                byte[] buffer = new byte[1024];
                int length;
                while ((length = bufferedInputStream.read(buffer, 0, buffer.length)) != -1) {
                    bufferedOutputStream.write(buffer, 0, length);
                }
                
                bufferedOutputStream.close();
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

3. 结果

结果截图：

12. @Headers、@Header 和 @HeaderMap 注解设置请求头

1. 过程

@headers 的 @target 是 method，也就是要放到方法上面。@header 和 @HeaderMap 的 @target 是 parameter，因此是放在方法里面
@Headers({"token:owengongreo", "client:android", "key:value"})
@Header("key") String value
@HeaderMap(Map<String, String> headers)

5. 一些网站学习

OkHttp：Overview - OkHttp (square.github.io)，其 Recipes 以后要好好研读
Retrofit：Retrofit (square.github.io)
大锯哥的笔记地址和服务器地址：https://www.sunofbeach.net/c/1197725454275039232
Multipart：Multipart/form-data - 简书 (jianshu.com)

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

第九章 网络编程

网络编程

1. Java 中的网络编程

1. InetAddress 类

2. UDP

3. TCP

2. Android 中的网络编程（用 Java 的 Api 写）

1. 使用 Java 的 Api 请求数据并处理

2. 利用 Java Api 获取网络图片

3. 对超大图片的简易处理

4. 用 POST 方式提交评论

5. URL 带参数的请求

6. 单文件上传

7. 多文件上传

8. 文件下载

3. OkHttp 框架

1. 使用 OkHttp 发起 get 请求

1. 过程

2. 代码

3. 结果

2. 使用 OkHttp 通过 Post 方式提交评论

1. 过程

2. 代码

3. 结果

3. OkHttp 为 get 请求添加参数

4. 通过 OkHttp 进行单文件上传

1. 过程

2. 代码

3. 结果

5. 通过 OkHttp 上传多个文件

1. 过程

2. 代码

3. 结果

6. 通过 OkHttp 下载文件

1. 过程

2. 代码

3. 结果

7. OkHttp

4. retrofit 框架封装

1. 使用 retrofit 发起 get 请求并将数据在 UI 上显示

1. 过程

2. 代码

3. 结果

2. 使用转换器将接收的 json 数据转成对象

1. 过程

2. 代码

3. 使用 @Query 注解发起带参数的请求

1. 过程

2. 代码

3. 结果

4. 使用 @QueryMap 注解来往 url 中传入多个参数

1. 过程

2. 代码

4. @Url 注释的使用

1. 代码

2. 结果

5. 用 @Body 注解来上传 json 内容

1. 过程

2. 代码

3. 结果

6. 使用 @Part 和 @Multipart 注解来上传文件

1. 过程

2. 代码

3. 结果

7. 上传多个文件

1. 过程

2. 代码

3. 结果

8. 文件上传并通过 POST 上传一些相关信息（例如注释）

1. 过程

2. 代码

3. 结果

9. 用 @FormUrlEncoded 和 @Field 注解来上传表单数据

1. 过程

2. 代码

3. 结果

10. 用 @FieldMap 上传表单数据的 Map（用 Map 来保存多个键值对）

1. 代码

2. 结果

11. 用 @Streaming 注解来下载文件

第九章网络编程