利用URL获取文件数据流、二进制数组

HttpsUtils 工具类（处理SSL证书相关问题）

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;

public class HttpsUtils {

    // 设置 https 请求
    public static void trustAllHttpsCertificates() throws Exception {
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String str, SSLSession session) {
                return true;
            }
        });
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
        javax.net.ssl.TrustManager tm = new miTM();
        trustAllCerts[0] = tm;
        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext
                .getInstance("SSL");
        sc.init(null, trustAllCerts, null);
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc
                .getSocketFactory());
    }

    // 设置 https 请求证书
    static class miTM implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager {

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        public boolean isServerTrusted(
                java.security.cert.X509Certificate[] certs) {
            return true;
        }

        public boolean isClientTrusted(
                java.security.cert.X509Certificate[] certs) {
            return true;
        }

        @Override
        public void checkServerTrusted(
                java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }

        @Override
        public void checkClientTrusted(
                java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }
    }
}

或更为详细的HttpClientExecutor.java工具类。

利用URL获取数据流并转化为二进制数组

    public static byte[] getByteArray(String fileOSSUrl) throws Exception {
        // 创建附件的一个URL对象
        URL url = new URL(fileOSSUrl);
        // 打开链接，并且跳过 SSL 证书验证
        HttpsUtils.trustAllHttpsCertificates();
        HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
        // 设置请求方式
        conn.setRequestMethod("GET");
        // 超时响应时间为5秒
        conn.setConnectTimeout(5 * 1000);
        // 通过输入流获取图片数据
        InputStream inStream = conn.getInputStream();
        // 得到文件的二进制数据，以二进制封装得到数据，具有通用性
        byte[] data = readInputStream(inStream);
        // 关闭流
        inStream.close();
        return data;
    }

将数据流并转化为二进制数组

    private static byte[] readInputStream(InputStream inStream) throws Exception {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        // 创建一个Buffer字符串
        byte[] buffer = new byte[4096];
        // 每次读取的字符串长度，如果为-1，代表全部读取完毕
        int len = 0;
        // 使用一个输入流从buffer里把数据读取出来
        while ((len = inStream.read(buffer)) != -1) {
            // 用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
            outStream.write(buffer, 0, len);
        }
        // 关闭输入流
        inStream.close();
        // 把outStream里的数据写入内存
        return outStream.toByteArray();
    }

二进制数组转字符串

    public static String byte2hex(byte[] b) {
        StringBuilder sb = new StringBuilder();
        String stmp = "";
        for (byte value : b) {
            stmp = Integer.toHexString(value & 0XFF);
            if (stmp.length() == 1) {
                sb.append("0").append(stmp);
            } else {
                sb.append(stmp);
            }
        }
        return sb.toString();
    }

字符串转二进制数组

    public static byte[] hex2byte(String str) {
        if (str == null) {
            return null;
        }
        str = str.trim();
        int len = str.length();
        if (len == 0 || len % 2 == 1) {
            return null;
        }
        byte[] b = new byte[len / 2];
        try {
            for (int i = 0; i < str.length(); i += 2) {
                b[i / 2] = (byte) Integer.decode("0X" + str.substring(i, i + 2)).intValue();
            }
            return b;
        } catch (Exception e) {
            return null;
        }
    }

字符串转换为文件保存

    /**
     * 将接收的字符串转换成图片保存
     *
     * @param imgStr  二进制流转换的字符串  byte[] byteArray
     * @param imgPath 图片的保存路径       forExample："C:\\Users\\Desktop"
     * @param imgName 图片的名称           forExample："test.png"
     */
    public static void saveToImgByStr(String imgStr, String imgPath, String imgName) {
        try {
            log.info("===imgStr.length()====>" + imgStr.length() + "=====imgStr=====>" + imgStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (imgStr != null && imgStr.length() > 0) {
            try {
                // 将字符串转换成二进制，用于显示图片。将上面生成的图片格式字符串 imgStr，还原成图片显示
                byte[] imgByte = hex2byte(imgStr);
                InputStream in = new ByteArrayInputStream(imgByte);
                File file = new File(imgPath, imgName);
                FileOutputStream fos = new FileOutputStream(file);
                byte[] b = new byte[1024];
                int nRead = 0;
                while ((nRead = in.read(b)) != -1) {
                    fos.write(b, 0, nRead);
                }
                fos.flush();
                fos.close();
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

File 转换为 MultipartFile

代码实现：

MultipartFile cMultiFile = new MockMultipartFile("file", file.getName(), null, Files.newInputStream(file.toPath()));

pom文件中添加：

   		<!-- File 转换为 MultipartFile -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>