SpringBoot实现IPFS文件上传

SpringBoot实现IPFS文件上传

依赖

// https://mvnrepository.com/artifact/com.github.ipfs/java-ipfs-api
implementation group: 'com.github.ipfs', name: 'java-ipfs-api', version: '1.3.3'

// https://mvnrepository.com/artifact/com.aliyun.oss/aliyun-sdk-oss
implementation group: 'com.aliyun.oss', name: 'aliyun-sdk-oss', version: '3.14.0'

配置

com.ipfsPath=/ip4/47.93.14.150/tcp/5009

aliyun.endpoint=https://oss-cn-beijing.aliyuncs.com
aliyun.accessKey.id=xxx
aliyun.accessKey.secret=xxx
aliyun.backet=xxx
aliyun.url=https://xxx.xxx.cn
aliyun.dir=xxxx

工具类

import cn.hutool.json.JSONObject;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.*;
import io.ipfs.api.IPFS;
import io.ipfs.api.MerkleNode;
import io.ipfs.api.NamedStreamable;
import io.ipfs.multihash.Multihash;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.util.UUID;

/** 阿里云 OSS文件类 */
@Slf4j
@Component
public class AliOssCloudUtil {

    @Value(value = "${aliyun.endpoint}")
    private String endpoint;
  
    // 阿里云的accessKeyId
    @Value(value = "${aliyun.accessKey.id}")
    private String accessKeyId;
  
    // 阿里云的accessKeySecret
    @Value(value = "${aliyun.accessKey.secret}")
    private String accessKeySecret;

    // 桶
    @Value(value = "${aliyun.backet}")
    private String bucketName;

    @Value(value = "${aliyun.url}")
    private String aliyunUrl;

    // 文件存储目录
    @Value(value = "${aliyun.dir}")
    private String fileDir;

    private OSS ossClient;

    @Value(value = "${com.ipfsPath}")
    private String ipfsPath;

    /** 销毁 */
    public void destroy() {
        ossClient.shutdown();
    }

    /**
     * 上传到OSS服务器 自定义上传路经
     *
     * @param inStream 文件流
     * @param fileName 文件名称 包括后缀名
     * @param filePath 上传目标文件夹 example ： "file"
     * @return 出错返回""
     */
    public String uploadFile2OSS(InputStream inStream, String fileName, String filePath) {
        ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        String ret = "";
        // 判断bucket是否已经存在,不存在进行创建
        if (!doesBucketExist()) {
            createBucket();
        }
        try {
            // 创建上传Object的Metadata
            ObjectMetadata objectMetadata = new ObjectMetadata();
            objectMetadata.setContentLength(inStream.available());
            objectMetadata.setCacheControl("no-cache");
            objectMetadata.setHeader("Pragma", "no-cache");
            objectMetadata.setContentType(
                    getContentType(fileName.substring(fileName.lastIndexOf("."))));
            objectMetadata.setContentDisposition("inline;filename=" + fileName);

            // 指定上传文件操作时是否覆盖同名Object。
            // 不指定x-oss-forbid-overwrite时，默认覆盖同名Object。
            // 指定x-oss-forbid-overwrite为false时，表示允许覆盖同名Object。
            // 指定x-oss-forbid-overwrite为true时，表示禁止覆盖同名Object，如果同名Object已存在，程序将报错。
            objectMetadata.setHeader("x-oss-forbid-overwrite", "false");
            String objectName = "";
            if (StringUtils.isEmpty(filePath)) {
                objectName = fileDir + "/" + fileName;
            } else {
                objectName = fileDir + "/" + filePath + "/" + fileName;
            }

            // 上传文件
            ossClient.putObject(bucketName, objectName, inStream, objectMetadata);
            // 封装  url 路径
            ret = aliyunUrl + "/" + objectName;
            log.info("ret:" + ret);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        } finally {
            ossClient.shutdown();
            try {
                if (inStream != null) {
                    inStream.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage());
            }
        }
        return ret;
    }

    /**
     * 上传文件到ipfs
     *
     * @param multipartFile 文件
     * @param isWithCache 是否使用缓存
     * @return
     * @throws IOException
     * @throws URISyntaxException
     */
    public JSONObject uploadIpfsFIle(MultipartFile multipartFile, boolean isWithCache)
            throws IOException, URISyntaxException {
        if (multipartFile.isEmpty()) {
            return new JSONObject();
        }
        // 获取文件名
        String fileName = multipartFile.getOriginalFilename();
        // 获取文件后缀
        String suffix = "";
        try {
            suffix = fileName.substring(fileName.lastIndexOf("."));
        } catch (NullPointerException e) {
            log.error(e.getMessage());
            suffix = "";
        }
        if (StringUtils.isEmpty(suffix)) {
            return new JSONObject();
        }
        // 这里文件名用了uuid 防止重复，可以根据自己的需要来写
        String name = UUID.randomUUID() + suffix;
        name = name.replace("-", "");
        InputStream inputStream = null;
        try {
            inputStream = multipartFile.getInputStream();
        } catch (IOException e) {
            log.error(e.getMessage());
            log.error(e.toString());
        }
        String fileUrl = "";
      
        // 通过OSS实现缓存，加快资源拉取速度
        // 不设置缓存，则直接去ipfs拉取资源
        if (isWithCache) {
            // 上传到阿里云对象存储
            fileUrl = uploadFile2OSS(inputStream, name, "ipfs");
            log.info("fileUrl:" + fileUrl);
            // 获取上传文件文件流
            URL url = new URL(fileUrl);
            URLConnection urlConn = url.openConnection();
            inputStream = urlConn.getInputStream();
        }
      
        IPFS ipfs = new IPFS(ipfsPath);
        ipfs.refs.local();
        NamedStreamable.InputStreamWrapper saveFile =
                new NamedStreamable.InputStreamWrapper(inputStream);
        MerkleNode result = ipfs.add(saveFile).get(0);
        Multihash multihash = result.hash;
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("fileUrl", fileUrl);
        jsonObject.put("fileHash", multihash.toString());
        // 返回结果里面获取保存文件的唯一hash，基于文件内容的 hash
        log.info("jsonObject:" + jsonObject.toString());
        return jsonObject;
    }

    /**
     * 判断文件是否存在。doesObjectExist还有一个参数isOnlyInOSS， 如果为true则忽略302重定向或镜像；如果为false，则考虑302重定向或镜像。
     * objectName 表示上传文件到OSS时需要指定包含文件后缀在内的完整路径，例如abc/efg/123.jpg。
     *
     * @return 存在返回true
     */
    public boolean doesObjectExist(String objectName) {
        boolean exists = ossClient.doesObjectExist(bucketName, fileDir + objectName);
        return exists;
    }

    /**
     * 判断Bucket是否存在
     *
     * @return 存在返回true
     */
    public boolean doesBucketExist() {
        boolean exists = ossClient.doesBucketExist(bucketName);
        return exists;
    }

    /** 创建Bucket */
    public void createBucket() {
        CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName);
        // 设置bucket权限为公共读，默认是私有读写
        createBucketRequest.setCannedACL(CannedAccessControlList.PublicRead);
        // 设置bucket存储类型为低频访问类型，默认是标准类型
        createBucketRequest.setStorageClass(StorageClass.IA);
        boolean exists = ossClient.doesBucketExist(bucketName);
        if (!exists) {
            try {
                ossClient.createBucket(createBucketRequest);
                // 关闭client
                ossClient.shutdown();
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
    }
}