网络图片转base64

最新推荐文章于 2024-07-03 19:13:37 发布

放驴娃

最新推荐文章于 2024-07-03 19:13:37 发布

阅读量989

点赞数

文章标签： java

本文链接：https://blog.csdn.net/helen_liang/article/details/125990367

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

项目中常把网络图片下载转base64，记录自己用过的2种方式

例1

<dependency>
    <groupId>net.coobird</groupId>
    <artifactId>thumbnailator</artifactId>
    <version>0.4.8</version>
</dependency>




public static String factoryBase(String imgPath) {
    try {
        URL url = new URL(imgPath);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setConnectTimeout(5 * 1000);
        InputStream inStream = conn.getInputStream();
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inStream.read(buffer)) != -1) {
            outStream.write(buffer, 0, len);
        }
        inStream.close();
        byte[] data = outStream.toByteArray();
        BASE64Encoder encoder = new BASE64Encoder();
        String base64 = encoder.encode(data);
        return base64;
    } catch (Exception e) {
        return "";
    }
}

例2

    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.8</version>
        <exclusions>
           <exclusion>
                <artifactId>commons-codec</artifactId>
                <groupId>commons-codec</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpmime</artifactId>
        <version>4.5.8</version>
    </dependency>



/**
 * 获取图片的Get请求
 * @param url
 * @param headers
 * @param queryMap
 * @param socketTimeOut
 * @param connectTimeOut
 */
 public static String base64GetRequest(String url,
                                   Map<String, String> headers,
                                   Map<String, String> queryMap,
                                   int socketTimeOut,
                                   int connectTimeOut) {
        HttpGet httpGet = null;
        CloseableHttpClient client = null;

        //拼接查询参数
        String param = setParam(queryMap);
        if (param != null && param.trim() != "") {
            url = url + "?" + param;
        }
        try {
            System.out.println("请求地址：" + url);
            httpGet = getHttpGet(url, headers, socketTimeOut, connectTimeOut);
            //获取重试client
            client = getRetryCloseableHttpClient();
            HttpResponse resp = client.execute(httpGet);
            HttpEntity entity = resp.getEntity();
            int responseCode = resp.getStatusLine().getStatusCode();
            System.out.println("responseCode=" + responseCode);
            if (responseCode != 200) {
                String str = EntityUtils.toString(entity, "UTF-8").trim();
                System.out.println();
            }
            InputStream inStream = entity.getContent();


            //--------------------------------转base64---------------------------
            //转base64
            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            //每次读取的字符串长度，如果为-1，代表全部读取完毕
            int len = 0;
            //使用一个输入流从buffer里把数据读取出来
            while ((len = inStream.read(buffer)) != -1) {
                //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
                outStream.write(buffer, 0, len);
            }
            //关闭输入流
            inStream.close();
            byte[] data = outStream.toByteArray();
            //对字节数组Base64编码
            BASE64Encoder encoder = new BASE64Encoder();
            String base64 = encoder.encode(data);

//            -----------base64写到文件------------
//            File file = new File("D:\\image\\filename.txt");
//            if (!file.exists()) {
//                file.createNewFile();
//            }
//            FileWriter fw = new FileWriter(file.getAbsoluteFile());
//            BufferedWriter bw = new BufferedWriter(fw);
//            bw.write(base64);
//            bw.close();
            return base64;

        } catch (ConnectTimeoutException e) {
            System.out.println("连接超时异常");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (httpGet != null) {
                httpGet.abort();
            }
            try {
                if (client != null) {
                    client.close();
                }
            } catch (IOException e) {
                System.out.println("调用第三方服务出错");
            }
        }
        return null;
    }

    private static String setParam (Map<String, String> queryMap) {
        String param = "";
        try {
            if (queryMap != null && !queryMap.isEmpty()) {
                StringBuilder queryBuilder = new StringBuilder();
                Iterator iterator = queryMap.entrySet().iterator();

                while (iterator.hasNext()) {
                    Map.Entry<String, Object> queryEntry = (Map.Entry) iterator.next();
                    Object object = queryEntry.getValue();
                    if (object instanceof JSONArray) {
                        JSONArray jsonArray = (JSONArray) object;
                        for (int i = 0; i < jsonArray.size(); i++) {
                            Object value = jsonArray.get(i);
                            value = URLEncoder.encode(String.valueOf(value), "UTF-8");
                            queryBuilder.append(queryEntry.getKey()).append("=").append(value).append("&");
                        }
                    } else {
                        Object value = queryEntry.getValue();
                        value = URLEncoder.encode(String.valueOf(value), "UTF-8");
                        queryBuilder.append(queryEntry.getKey()).append("=").append(value).append("&");
                    }
                }

                param = queryBuilder.toString().substring(0, queryBuilder.toString().length() - 1);
            }
        } catch (Exception e) {
            String msg = "参数encode失败";
            System.out.println("参数encode失败" + e);
        }
        return param;
    }

    private static HttpGet getHttpGet(String url, Map<String, String> headers, int socketTimeOut, int connectTimeOut) {
        //拼接查询参数
        HttpGet httpGet = new HttpGet(url);
        //填充header
        if (headers != null && !headers.isEmpty()) {
            Iterator iterator = headers.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Object> queryEntry = (Map.Entry) iterator.next();
                httpGet.setHeader(queryEntry.getKey(), String.valueOf(queryEntry.getValue()));
            }
        }

        RequestConfig requestConfig = RequestConfig.custom().
                setSocketTimeout(socketTimeOut).setConnectTimeout(connectTimeOut).setCookieSpec(CookieSpecs.STANDARD).build();//设置请求和传输超时时间
        httpGet.setConfig(requestConfig);
        return httpGet;
    }

    public static CloseableHttpClient getRetryCloseableHttpClient() {
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create().setRetryHandler(new HttpRequestRetryHandler() {
            public boolean retryRequest(IOException ioException, int retryTimes, HttpContext httpContext) {
                HttpClientContext clientContext = HttpClientContext.adapt(httpContext);
                HttpRequest request = clientContext.getRequest();

                System.out.println("handleGetRequestWithBodyParam 请求重试次数:" + retryTimes + ",request:" + request);
                if (retryTimes > 2) {
                    return false;
                }
                if (!(ioException instanceof SSLException)) {
                    return true;
                }

                boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
                if (idempotent) {
                    // 如果请求被认为是幂等的，那么就重试。即重复执行不影响程序其他效果的
                    return true;
                }
                return false;
            }
        });
        CloseableHttpClient client = httpClientBuilder.build();
        return client;
    }

生成的base64文件经常很大可以压缩处理下

    public static String base64Image(String url) {
        if (url.indexOf("http") > -1) {
            String base64 = "base64的字符串";
            if (base64 != "") {
                return resizeImageTo40K(base64);
            }
        }
        return "";
    }



    public static BufferedImage base64String2BufferedImage(String base64string) {
        BufferedImage image = null;
        try {
            InputStream stream = BaseToInputStream(base64string);
            image = ImageIO.read(stream);
        } catch (IOException e) {
        }
        return image;
    }
//    BufferedImage转换成base64，在这里需要设置图片格式，如下是jpg格式图片：

    public static String imageToBase64(BufferedImage bufferedImage) {
        Base64 encoder = new Base64();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            ImageIO.write(bufferedImage, "jpg", baos);
        } catch (IOException e) {
        }
        return new String(encoder.encode((baos.toByteArray())));
    }

    private static InputStream BaseToInputStream(String base64string) {
        ByteArrayInputStream stream = null;
        try {
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] bytes1 = decoder.decodeBuffer(base64string);
            stream = new ByteArrayInputStream(bytes1);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return stream;
    }

    /**
     * base64压缩
     * @param base64Img
     * @return
     */
    public static String resizeImageTo40K(String base64Img) {
        try {
            BufferedImage src = base64String2BufferedImage(base64Img);
            BufferedImage output = Thumbnails.of(src).size(src.getWidth() / 3, src.getHeight() / 3).asBufferedImage();
            String base64 = imageToBase64(output);
            if (base64.length() - base64.length() / 8 * 2 > 40000) {
                output = Thumbnails.of(output).scale(1 / (base64.length() / 40000)).asBufferedImage();
                base64 = imageToBase64(output);
            }
            return base64;
        } catch (Exception e) {
            return base64Img;
        }
    }