图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下

1.效果图

1.1图片展示

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载_第1张图片

1.2图片上传

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载_第2张图片

1.3图片下载

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载_第3张图片

1.4图片右键删除

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载_第4张图片

2. 使用技术说明

2.1 前台
2.1.1 布局div+css+jquery
2.1.2 webupload/diyupload.js 图片进行批量上传
2.1.3 swiper.min.js 图片组滚动展示
2.2后台
2.2.1 springboot、华为云obs/服务器存储

3.前台主要代码说明

3.1 图片预览
//download.html



	
		
		图片分页预览
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	

	
		
//download.js
var trId=window.parent.trId;
$(function() {
	if(trId!=null&&trId!=""){
		initImg();
	}else{
		var arr=null;
		appendImgList(arr);
	}
	initSwiper();
})

//初始化img
function initImg() {
	var result = [];
	$.ajax({
		type: "get",
		async: false,
		url: $GATEWAY_URL + "/upImgController/downloadImage/" + trId,
		success: function(data, status) {
			if(data != null && data.length > 0) {
				for(var i = 0; i < data.length; i++) {
					result[i] = data[i];
				}
				appendImgList(result);
			} else {
				appendImgList(result);
			}
		},
		error: function(data) {
			appendImgList(result);
		}
	});
}

//文件删除
function over(param) {

	layer.confirm('您确定要删除该图片吗?', {
		btn: ['确定', '取消'] //按钮 
	}, function() {
		$.ajax({
			type: "get",
			async: false,
			//图片删除
			//url: $GATEWAY_URL + "/upImgController/removeImage/" + trId+"/"+param,
			url: $GATEWAY_URL + "/upImgController/removeImage/"+param,
			success: function(data, status) {
				layer.msg(data.msg);
				window.location.reload(); 
			},
			error: function(data) {
				layer.msg(data.msg);
				//appendImgList(result);
			}
		});
	}, function() {

	});
	
	return false;
}

//导出全部
function exportAll() {
	window.location.href = $GATEWAY_URL + "/upImgController/fileDownLoad/?trId=" + trId;
}

function appendImgList(result) {
	//华为云改造
	//var imgUrl = $GATEWAY_URL + "/upImgController/IoReadImage/" + trId + "/";
	var imgUrl = $GATEWAY_URL + "/upImgController/IoReadImage/";
	if(result != null && result.length > 0) {
		$(".swiper-wrapper").empty();
		//当图片数量小于3时 补充空白图片
		if(result.length < 3) {
			for(var i = 0; i < 3; i++) {
				if(i < result.length) {
					$(".swiper-wrapper").append("
"); } else { $(".swiper-wrapper").append("
"); } } } else { for(var i = 0; i < result.length; i++) { $(".swiper-wrapper").append("
"); } } } else { $(".swiper-wrapper").append("
"); $(".swiper-wrapper").append("
"); $(".swiper-wrapper").append("
"); } $(".pic").bind("contextmenu",function(e){ return false; }); } //初始化swiper function initSwiper() { var swiper = new Swiper('.swiper-container', { slidesPerView: 3, spaceBetween: 30, centeredSlides: true, loop: true, pagination: { el: '.swiper-pagination', clickable: true, }, }); }
3.2 图片上传
//upload.html


	
		
		webupload多张图片批量上传插件 
		
		
		
		
		
		
		
		
		
		
		
	
	

	
		
最多上传8张图片(单张小于25M)格式:(*.gif,*.jpg,*.jpeg,*.png)
var fileArr = [];
var trId;
$(function() {
	var getUrl = encodeURI(window.location.search).split("&");
	trId = getUrl[0].split("=")[1];
	var imgFile = new ImgUploadeFiles('.imgupBox', function(e) {
		this.init({
			MAX: 10, //限制个数
			MH: 5800, //像素限制高度
			MW: 5900, //像素限制宽度
			callback: function(arr) {
				console.log(arr)
			}
		});
	});
})

/*
 * 上传图片
 * */
function multipleFiles() {
	//补充说明:因为我们给input标签设置multiple属性,因此一次可以上传多个文件
	//获取选择图片数组
	var files = fileArr;
	//获取选择图片的个数
	var length = files.length;

	if(length == 0) {
		alert("请选择需要上传的图片!");
		return;
	}

	var fu = new FormData();

	for(var i = 0; i < files.length; i++) { //循环获取多个文件
		fu.append("file", files[i]);
	}

	fu.append("trId", trId);
	$.ajax({
		type: "post",
		url: $GATEWAY_URL+"/upImgController/uploadimgs",
		data: fu,
		cache: false,
		contentType: false, //不可缺参数
		processData: false, //不可缺参数
		success: function(data, status) {
			window.top.layer.msg(data.msg);
			parent.location.reload();//刷新父页面
		    var index = parent.layer.getFrameIndex(window.name); //先得到当前iframe层的索引
		    parent.layer.close(index); //再执行关闭
		},
		error: function(data) {
			window.top.layer.msg("图片上传失败:"+data.msg);
		},
		complete: function() {}
	});

}
3.1 图片下载
//导出全部
function exportAll() {
	window.location.href = $GATEWAY_URL + "/upImgController/fileDownLoad/?trId=" + trId;
}

4. 后台主要代码说明

4.1 华为云引入依赖

可以百度或者华为云官网 搜索 “华为云 obs SDK springboot 集成”

 
            com.huaweicloud
            esdk-obs-java
            3.20.6.1
        
4.2 华为云工具类
package com.nari.osp.upload.util;

import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author xxx
 * @createTime 2021/12/6 16:31
 * @description 华为OBS工具类
 */
@Slf4j @Component @RefreshScope public class HuaweiOBSUtil {
    private static String endPoint;
    private static String ak;
    private static String sk;
    private static String bucketName;

    @Value("${obs.endPoint}") public void setEndPoint(String endPoint) {
        HuaweiOBSUtil.endPoint = endPoint;
    }

    @Value("${obs.ak}") public void setAk(String ak) {
        HuaweiOBSUtil.ak = ak;
    }

    @Value("${obs.sk}") public void setSk(String sk) {
        HuaweiOBSUtil.sk = sk;
    }

    @Value("${obs.bucketName}") public void setBucketName(String bucketName) {
        HuaweiOBSUtil.bucketName = bucketName;
    }

    /**
     * 上传File类型文件
     *
     * @param file
     * @return
     */
    public static String uploadFile(File file, String trId) {
        return getUploadFileUrl(file, trId);
    }

    /**
     * 上传MultipartFile类型文件
     *
     * @param multipartFile
     * @return
     */
    public static String uploadFile(MultipartFile multipartFile, String trId) throws IOException {
        return getUploadFileUrl(FileUtils.MultipartFileToFile(multipartFile), trId);
    }

    private static String getUploadFileUrl(File file, String trId) {
        //判断文件是否为空
        if (FileUtils.checkFileNotNull(file)) {
            //获取文件名称
            String fileName = FileUtils.getName(file);
            log.info("上传图片名称:" + fileName + "ak:" + ak + "sk:" + sk + "endPoint:" + endPoint);
            //创建华为云obs对象
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            try {
                //判断桶是否存在,不存在则创建
                if (!obsClient.headBucket(bucketName)) {
                    obsClient.createBucket(bucketName);
                }
                //拼接前缀对象  形成目录  380xxx/a.jpeg
                PutObjectRequest request = new PutObjectRequest();
                request.setBucketName(bucketName);
                request.setObjectKey(trId + "/" + fileName);
                request.setFile(file);
                request.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
                PutObjectResult result = obsClient.putObject(request);
                String url = result.getObjectUrl();
                log.info("图片路径:" + url);
                return url;
            } catch (Exception e) {
                log.error("图片上传错误:{}", e);
            }/* finally {
                删除本地临时文件
                HuaweiOBSUtil.deleteTempFile(file);
            }*/
        }
        return null;
    }

    /**
     * 根据文件夹 地址获取文件夹 IO流
     *
     * @param localPath 本地临时存储下载文件路径
     * @param trId      配变编号 对应 obs平台 文件夹名称
     * @return
     */
    public static void downloadDirIOByUrl(String localPath, String trId) {
        try {
            //String fileLocatePrefix = localPath;
            // 创建ObsClient实例
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            ListObjectsRequest request = new ListObjectsRequest(bucketName);
            // 指定下载"FunctionGraphDemo-VideoConvert/"文件夹
            request.setPrefix(trId);
            request.setMaxKeys(500);
            ObjectListing result;
            log.info("本地文件临时存储路径fileLocatePrefix:" + localPath);
            do {
                result = obsClient.listObjects(request);
                for (ObsObject obsObject : result.getObjects()) {
                    log.info("获取obs图片:" + obsObject.getObjectKey());
                    DownloadFileRequest requestDownload = new DownloadFileRequest(bucketName, obsObject.getObjectKey());
                    String objectKey = getFilenameByUrlV2(obsObject.getObjectKey());
                    requestDownload.setDownloadFile(localPath + "//" + objectKey);
                    // 设置分段下载时的最大并发数
                    requestDownload.setTaskNum(10);
                    // 设置分段大小为10MB
                    requestDownload.setPartSize(10 * 1024 * 1024);
                    // 开启断点续传模式
                    requestDownload.setEnableCheckpoint(true);
                    try {
                        // 进行断点续传下载
                        obsClient.downloadFile(requestDownload);
                    } catch (ObsException e) {
                        log.info("Response Code: " + e.getResponseCode());
                        log.info("Error Message: " + e.getErrorMessage());
                        log.info("Error Code:       " + e.getErrorCode());
                        log.info("Request ID:      " + e.getErrorRequestId());
                        log.info("Host ID:           " + e.getErrorHostId());
                    }
                }
                log.info("------------------------------");
                request.setMarker(result.getNextMarker());
            } while (result.isTruncated());
        } catch (ObsException e) {
            log.error("文件下载失败:{}", e.getMessage());
        }
    }

    /**
     * 根据文件地址获取桶对象
     *
     * @param trId
     * @return
     */
    public static List getBucketObjectList(String trId) {
        List result = new ArrayList<>();
        try {
            //创建ObsClient实例
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            /*
             * String bucketName, 桶
             *  String prefix, 前缀   abcd abcde bbced  prefix 为a 则  abcd abcde 一组 bbced为一组
             *  String marker,
             * String delimiter,
             *  int maxKeys 返回最大列表数量
             * */
            ObjectListing objectListing = obsClient.listObjects(new ListObjectsRequest(bucketName, trId, "", "", 1000));
            //列举桶内所有对象
            //ObjectListing objectListing = obsClient.listObjects(bucketName);
            List objects = objectListing.getObjects();
            log.info("获取桶内所有对象集合大小为:" + objects.size());
            for (ObsObject obj : objects) {
                String objectKey = obj.getObjectKey();
                if (objectKey.contains(trId)) {
                    result.add(objectKey);
                }
            }
            return result;
        } catch (ObsException e) {
            log.error("文件下载失败:{}", e.getMessage());
        }
        return null;
    }

    /**
     * 根据文件地址获取文件IO流
     *
     * @param fileUrl
     * @return
     */
    public static InputStream downloadFileIOByUrl(String fileUrl) {
        try {
            //获取文件名称
            String fileName = getFilenameByUrl(fileUrl);
            // 创建ObsClient实例
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            ObsObject obsObject = obsClient.getObject(bucketName, fileName);
            InputStream inputStream = obsObject.getObjectContent();
            //转成MultipartFile
            //MultipartFile multipartFile = InputStreamConvertMultipartFileUtil.getMultipartFile(inputStream, fileName);
            //File file = com.xxx.util.FileUtil.MultipartFileToFile(multipartFile);
            return inputStream;
        } catch (ObsException e) {
            log.error("文件下载失败:{}", e.getMessage());
        }
        return null;
    }

    /**
     * 删除单个对象
     *
     * @param objectKey
     * @return
     */
    public static boolean deleteFile(String objectKey) {
        ObsClient obsClient = new ObsClient(ak, sk, endPoint);
        DeleteObjectResult deleteObjectResult = obsClient.deleteObject(bucketName, objectKey);
        boolean deleteMarker = deleteObjectResult.isDeleteMarker();
        try {
            obsClient.close();
        } catch (IOException e) {
            log.error("华为OBS关闭客户端失败", e);
        }
        return deleteMarker;
    }

    /**
     * 上传图片自定义code
     *
     * @param ak
     * @param sk
     * @param endPoint
     * @param file
     * @return
     */
    public static String uploadFileByCode(String ak, String sk, String endPoint, String bucket, File file) {
        //String pathname = objectName;
        try {
            String fileName = FileUtils.getName(file);
            log.info("上传图片:" + fileName);
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            //判断桶是否存在,不存在则创建
            if (!obsClient.headBucket(bucket)) {
                obsClient.createBucket(bucket);
            }
            PutObjectRequest request = new PutObjectRequest();
            request.setBucketName(bucket);
            request.setObjectKey(fileName);
            request.setFile(file);
            request.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
            PutObjectResult result = obsClient.putObject(request);
            String url = result.getObjectUrl();
            log.info("文件名称:" + fileName + "图片路径:" + url);
            return url;
        } catch (Exception e) {
            log.error("图片上传错误:{}", e);
        } /*finally {
            HuaweiOBSUtil.deleteTempFile(file);
        }*/
        return null;
    }

    /**
     * 删除本地临时文件
     *
     * @param file
     */
    public static void deleteTempFile(File file) {
        if (file != null) {
            File del = new File(file.toURI());
            del.delete();
        }
    }

    /**
     * 根据文件地址获取名称下载File类型的文件
     *
     * @param fileUrl
     * @return
     */
    public static MultipartFile downloadFileByUrl(String fileUrl) {
        try {
            String fileName = getFilenameByUrl(fileUrl);
            // 创建ObsClient实例
            ObsClient obsClient = new ObsClient(ak, sk, endPoint);
            ObsObject obsObject = obsClient.getObject(bucketName, fileName);
            InputStream inputStream = obsObject.getObjectContent();
            //转成MultipartFile
            MultipartFile multipartFile = InputStreamConvertMultipartFileUtil.getMultipartFile(inputStream, fileName);
            //File file = com.xxx.util.FileUtil.MultipartFileToFile(multipartFile);
            return multipartFile;

        } catch (ObsException e) {
            log.error("文件下载失败:{}", e.getMessage());
        }
        return null;
    }

    /**
     * 批量n天删除之前的文件
     *
     * @param ak
     * @param sk
     * @param endPoint
     * @param bucket
     * @param requireHours
     */
    public static void batchDeleteForHoursago(String ak, String sk, String endPoint, String bucket, int requireHours) {
        ObsClient obsClient = new ObsClient(ak, sk, endPoint);
        long currentTime = new Date().getTime();
        try {
            ListObjectsRequest listRequest = new ListObjectsRequest(bucket);
            listRequest.setMaxKeys(1000); // 每次至多返回1000个对象
            ObjectListing listResult;
            Date lastModified;
            long hourMillisecond = 1000 * 3600 * 1;
            // 分页查询
            do {
                List toDelete = new ArrayList<>();
                listResult = obsClient.listObjects(listRequest);
                for (ObsObject obsObject : listResult.getObjects()) {
                    lastModified = obsObject.getMetadata().getLastModified();
                    long diffs = (currentTime - lastModified.getTime()) / hourMillisecond; // 当前时间减去文件修改时间
                    if (diffs > requireHours && (obsObject.getObjectKey().endsWith(".ts") || obsObject.getObjectKey()
                        .endsWith(".mp4"))) {
                        log.info("文件距现在{}小时,对象更改日期:{},文件对象:{}", diffs, lastModified, obsObject.getObjectKey());
                        toDelete.add(new KeyAndVersion(obsObject.getObjectKey()));
                    }
                }
                // 设置下次列举的起始位置
                listRequest.setMarker(listResult.getNextMarker());

                //批量删除文件
                log.info("待删除的OBS对象数量:{}", toDelete.size());
                if (!CollectionUtils.isEmpty(toDelete)) {
                    DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest(bucket);
                    deleteRequest.setQuiet(true); // 设置为quiet模式,只返回删除失败的对象
                    deleteRequest.setKeyAndVersions(toDelete.toArray(new KeyAndVersion[toDelete.size()]));
                    DeleteObjectsResult deleteResult = obsClient.deleteObjects(deleteRequest);
                    if (!CollectionUtils.isEmpty(deleteResult.getErrorResults())) {
                        log.error("删除失败的OBS对象数量:{}", deleteResult.getErrorResults().size());
                    }
                }
            } while (listResult.isTruncated());
        } catch (Exception e) {
            log.error("华为OBS批量删除异常", e);
        } finally {
            try {
                obsClient.close();
            } catch (IOException e) {
                log.error("华为OBS关闭客户端失败", e);
            }
        }
    }

    /**
     * 查询桶内已使用空间大小
     *
     * @param ak
     * @param sk
     * @param endPoint
     * @param bucket
     * @return 单位字节
     */
    public static long getBucketUseSize(String ak, String sk, String endPoint, String bucket) {
        ObsClient obsClient = new ObsClient(ak, sk, endPoint);
        BucketStorageInfo storageInfo = obsClient.getBucketStorageInfo(bucket);
        log.info("{} 桶内对象数:{}  已使用的空间大小B:{} GB:{}", bucket, storageInfo.getObjectNumber(), storageInfo.getSize(),
            storageInfo.getSize() / 1024 / 1024 / 1024);
        try {
            obsClient.close();
        } catch (IOException e) {
            log.error("华为OBS关闭客户端失败", e);
        }
        return storageInfo.getSize();
    }

    public static String readFileContent(String fileName) {
        File file = new File(fileName);
        BufferedReader reader = null;
        StringBuffer sbf = new StringBuffer();
        try {
            reader = new BufferedReader(new FileReader(file));
            String tempStr;
            while ((tempStr = reader.readLine()) != null) {
                sbf.append(tempStr);
            }
            reader.close();
            return sbf.toString();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
        return sbf.toString();
    }

    /**
     * 根据下载地址url获取文件名称
     *
     * @param url
     * @throws IOException
     */
    public static String getFilenameByUrl(String url) {
        String fileName = null;
        try {
            //url编码处理,中文名称会变成百分号编码
            //String decode = URLDecoder.decode(url, "utf-8");
            fileName = URLDecoder.decode(url, "utf-8");
            //fileName = decode.substring(decode.lastIndexOf("/") + 1);
            log.info("fileName :" + fileName);
        } catch (UnsupportedEncodingException e) {
            log.error("getFilenameByUrl() called with exception => 【url = {}】", url, e);
            e.printStackTrace();
        }
        return fileName;
    }

    /**
     * 根据下载地址url获取文件名称
     *
     * @param url
     * @throws IOException
     */
    public static String getFilenameByUrlV2(String url) {
        String fileName = null;
        try {
            //url编码处理,中文名称会变成百分号编码
            String decode = URLDecoder.decode(url, "utf-8");
            fileName = decode.substring(decode.lastIndexOf("/") + 1);
            log.info("fileName :" + fileName);
        } catch (UnsupportedEncodingException e) {
            log.error("getFilenameByUrl() called with exception => 【url = {}】", url, e);
            e.printStackTrace();
        }
        return fileName;
    }

}

4.3 controller
package com.nari.osp.upload.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSchException;
import com.nari.osp.upload.entity.ApolloConfig;
import com.nari.osp.upload.entity.QueryCondition;
import com.nari.osp.upload.entity.TrBaseEntity;
import com.nari.osp.upload.service.impl.ObsUpImgServiceImpl;
import com.nari.osp.upload.service.impl.UpImgServiceImp;
import com.nari.osp.upload.util.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.*;

@CrossOrigin(origins = "*", maxAge = 3600) @Controller @RequestMapping("/upImgController")
@SuppressWarnings(value = "all") public class UpImgController {
    Log log = LogFactory.getLog(getClass());
    @Autowired private ApolloConfig apolloConfig;
    @Autowired private UpImgServiceImp upImgService;
    @Autowired private ObsUpImgServiceImpl cbsUpImgService;
    //图片流(废弃)
    //Map imgIO = new HashMap<>();
    ChannelSftp ftpClient = null;

    /*
     * 查询配变台账 判断此配变是否上传图片
     * @param files
     * @return
     * */
    //负载率统计
    @ResponseBody @RequestMapping("/getTrBaseList") public JSONObject getTrBaseList(QueryCondition queryParam) {
        return upImgService.getTrBaseList(queryParam);
    }

    /*
     * 查询配变台账
     * @param files
     * @return
     * */
    //负载率统计
    @ResponseBody @RequestMapping("/getTrBase") public TrBaseEntity getTrBase(QueryCondition queryParam) {
        return upImgService.getTrBase(queryParam);
    }

    /**
     * 图片保存至服务器(无ftp传输)
     *
     * @param
     * @return
     */
    @RequestMapping("/imgUpload/{trId}") public @ResponseBody void imgUpload(HttpServletRequest request,
        HttpServletResponse response, @PathVariable String trId) throws Exception {
        //是否华为云cbs存储
        if (apolloConfig.isObs()) {
            cbsUpImgService.imgUpload(request, response, trId);
        } else {
            upImgService.imgUpload(request, response, trId);
        }
    }

    /**
     * IO流读取图片集合
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/downloadImage/{trid}", method = RequestMethod.GET) @ResponseBody
    public List downloadImage(@PathVariable String trid) throws Exception {
        List imgName;
        //是否华为云cbs存储
        if (apolloConfig.isObs()) {
            imgName = cbsUpImgService.downloadImage(trid);
        } else {
            imgName = upImgService.downloadImage(trid);
        }
        return imgName;
    }

    /*
     * 图片访问地址
     * */
    @RequestMapping(value = "/IoReadImage/{trid}/{imgId}", method = RequestMethod.GET) public void IoReadImage(
        @PathVariable String trid, @PathVariable String imgId, HttpServletResponse response) throws Exception {
        //是否华为云cbs存储
        if (apolloConfig.isObs()) {
            cbsUpImgService.IoReadImage(trid, imgId, response);
        } else {
            upImgService.IoReadImage(trid, imgId, response);
        }
    }

    /*
     * 图片删除
     * */
    @ResponseBody @RequestMapping(value = "/removeImage/{trid}/{imgId}", method = RequestMethod.GET)
    public ResponseData removeImage(@PathVariable String trid, @PathVariable String imgId, HttpServletResponse response)
        throws Exception {
        //是否华为云cbs存储
        ResponseData responseData;
        if (apolloConfig.isObs()) {
            responseData = cbsUpImgService.removeImage(trid, imgId, response);
        } else {
            responseData = upImgService.removeImage(trid, imgId, response);
        }
        return responseData;
    }

    /*
     * 文件下载  zip 图片 文档
     * */
    @ResponseBody @RequestMapping("/fileDownLoad") public void fileDownload(@RequestParam("trId") String trId,
        HttpServletRequest request, HttpServletResponse response) throws IOException {
        //是否华为云cbs存储
        if (apolloConfig.isObs()) {
            cbsUpImgService.fileDownload(trId, request, response);
        } else {
            upImgService.fileDownload(trId, request, response);
        }
    }

    @ResponseBody @RequestMapping("/exportExcel")
    public void exportExcel(@RequestParam("param") String param, HttpServletResponse response) {
        QueryCondition queryParam = JSON.parseObject(param, QueryCondition.class);
        queryParam.setPage(0);
        queryParam.setRows(65000);
        //QueryCondition queryParam =new QueryCondition();
        // "CT变比", "配变容量(KVA)", "可靠性"};
        String[] headers = {"地市公司", "区县公司", "所属馈线", "所属厂站", "配变编号", "配变名称", "PMS编码", "是否上传图片"};
        //  “0,2,0,0”  ===>  “起始行,截止行,起始列,截止列”
        String fileName = "电压负载率明细" + ".xls";
        //String version = pbqxCondition.getVersion();
        JSONObject jsonObject = upImgService.getTrBaseList(queryParam);
        JSONArray list = jsonObject.getJSONArray("rows");
        int rowIndex = 0;
        HSSFWorkbook wb = null;  //03
        XSSFWorkbook xwb = null; //07
        // 第一步,创建一个webbook,对应一个Excel文件
        xwb = new XSSFWorkbook();
        XSSFSheet xsheet = xwb.createSheet("图片列表");
        XSSFRow row = xsheet.createRow(rowIndex++);
        // 简单表头
        for (int i = 0; i < headers.length; i++) {
            xsheet.autoSizeColumn(i, true);
            row.createCell(i).setCellValue(headers[i]);
        }
        //加载数据
        for (int i = 0; i < list.size(); i++) {
            JSONObject json = list.getJSONObject(i);
            row = xsheet.createRow(rowIndex++);
            //row =  sheet.createRow(rowIndex++);
            //String[] str=list.get(i).split(",");
            row.createCell(0).setCellValue(json.getString("orgname03").equals("") ? "-" : json.getString("orgname03"));
            row.createCell(1).setCellValue(json.getString("orgname04").equals("") ? "-" : json.getString("orgname04"));
            row.createCell(2).setCellValue(json.getString("lineName").equals("") ? "-" : json.getString("lineName"));
            row.createCell(3).setCellValue(json.getString("subName").equals("") ? "-" : json.getString("subName"));
            row.createCell(4).setCellValue(json.getString("trNo").equals("") ? "-" : json.getString("trNo"));
            row.createCell(5).setCellValue(json.getString("trName").equals("") ? "-" : json.getString("trName"));
            row.createCell(6).setCellValue(json.getString("pmsId").equals("") ? "-" : json.getString("pmsId"));
            String isUpload = json.getString("isUpload");
            if (!"".equals(isUpload) && "true".equals(isUpload)) {
                row.createCell(7).setCellValue("是");
            } else {
                row.createCell(7).setCellValue("否");
            }
            //String kykxTemp = !"可信".equals(list.get(i).getKeyFlag()) ? "可疑" : "可信";
            //row.createCell(9).setCellValue(list.get(i).getKeyFlag() != "可信" ? "可疑" : "可信");
            //row.createCell(9).setCellValue(kykxTemp);
        }
        try {
            //导出数据
            response.setHeader("Content-Disposition",
                "attachment;filename=" + new String(fileName.getBytes("utf-8"), "iso8859-1"));
            response.setContentType("application/ynd.ms-excel;charset=UTF-8");
            OutputStream out = response.getOutputStream();
            xwb.write(out);

            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * IO流读取图片集合 并发送至前端 imgTemp文件夹(废弃)
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/downloadImageV2/{trid}", method = RequestMethod.GET) @ResponseBody
    public List downloadImageV2(@PathVariable String trid) throws Exception {
        List imgName = new ArrayList<>();
        //服务器文件
        String ftpPath = apolloConfig.getFilePath();
        //本地临时文件 前台代码吧 imgTemp
        String localPath = apolloConfig.getLFilePath();
        try {
            //连接远程sftp
            ftpClient = JcraftTools.getConnect(apolloConfig.getIp(), apolloConfig.getPort(), apolloConfig.getUsername(),
                apolloConfig.getPassword());
            Vector ftpFiles = ftpClient.ls(ftpPath + trid);
            if (ftpFiles != null && ftpFiles.size() > 0) {
                for (ChannelSftp.LsEntry lsEntry : ftpFiles) {
                    //临时e文件名称
                    String fileTemp = lsEntry.getFilename();
                    if (fileTemp.contains(".png") || fileTemp.contains(".jpg") || fileTemp.contains(".jpeg")) {
                        imgName.add(fileTemp);
                        JcraftTools.download(ftpPath + trid, localPath, fileTemp, fileTemp);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //记得关闭连接
            if (ftpClient != null) {
                ftpClient.quit();
                ftpClient.disconnect();
                try {
                    if (ftpClient.getSession() != null)
                        ftpClient.getSession().disconnect();
                } catch (JSchException e) {
                    log.error("channel getSession error:", e);
                }
            }
        }
        return imgName;
    }

    /**
     * 删除前台临时存放图片(废弃)
     *
     * @param
     * @return
     */
    public void removeWebDir() throws Exception {
        //E文件解析工具类
        ChannelSftp ftpClient = null;
        try {
            //连接远程sftp
            ftpClient = JcraftTools
                .getConnect(apolloConfig.getLIp(), apolloConfig.getLPort(), apolloConfig.getLUsername(),
                    apolloConfig.getLPassword());
            log.info("清除定时任务------已连接远程服务器!");
            // 删除指定文件下的所有文件
            Vector ftpFiles = ftpClient.ls(apolloConfig.getLFilePath());
            if (ftpFiles != null && ftpFiles.size() > 0) {
                for (ChannelSftp.LsEntry lsEntry : ftpFiles) {
                    //临时e文件名称
                    String fileTemp = lsEntry.getFilename();
                    if (fileTemp.contains(".png") || fileTemp.contains(".jpg")) {
                        ftpClient.rm(apolloConfig.getLFilePath() + "/" + fileTemp);
                        log.info("文件已删除:" + apolloConfig.getLFilePath() + "/" + fileTemp);
                    }
                }
            }
        } catch (Exception e) {
        } finally {
            //记得关闭连接
            if (ftpClient != null) {
                ftpClient.quit();
                ftpClient.disconnect();
                try {
                    if (ftpClient.getSession() != null)
                        ftpClient.getSession().disconnect();
                } catch (JSchException e) {
                    log.error("channel getSession error:", e);
                }
            }
        }
    }

    /**
     * 删除服务器端配变的图片(废弃)
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/removeImage", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
    @ResponseBody public Map removeImage(HttpServletRequest request) {
        String filePath = apolloConfig.getFilePath();
        //删除数据库返回结果
        Map result = new HashMap<>();
        //获取请求的参数 jsonStr {"3801....@img1&img2&img3"}
        String jsonStr = request.getParameter("jsonStr");
        String trId = jsonStr.split("@")[0];
        String imgIds = jsonStr.split("@")[1];
        Map imgMap = new HashMap<>();
        String[] s = imgIds.split("&");
        for (String obj : s) {
            imgMap.put(obj + ".png", obj);
        }
        //E文件解析工具类
        ChannelSftp ftpClient = null;
        try {
            //连接远程sftp
            ftpClient = JcraftTools.getConnect(apolloConfig.getIp(), apolloConfig.getPort(), apolloConfig.getUsername(),
                apolloConfig.getPassword());
            log.info("删除服务器指定图片------已连接远程服务器!");
            // 删除指定文件下的所有文件
            Vector ftpFiles = ftpClient.ls(filePath + trId);
            if (ftpFiles != null && ftpFiles.size() > 0) {
                for (ChannelSftp.LsEntry lsEntry : ftpFiles) {
                    //临时e文件名称
                    String fileTemp = lsEntry.getFilename();
                    if (fileTemp.contains(".png") || fileTemp.contains(".jpg")) {
                        if (imgMap.containsKey(fileTemp)) {
                            ftpClient.rm(filePath + trId + "/" + fileTemp);
                            log.info("文件已删除:" + filePath + trId + "/" + fileTemp);
                        }
                    }
                }
            }
        } catch (Exception e) {
        } finally {
            //记得关闭连接
            if (ftpClient != null) {
                ftpClient.quit();
                ftpClient.disconnect();
                try {
                    if (ftpClient.getSession() != null)
                        ftpClient.getSession().disconnect();
                } catch (JSchException e) {
                    log.error("channel getSession error:", e);
                }
            }
        }
        return result;
    }

    /**
     * IO流读取图片集合(废弃)
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/IoReadImageList/{trid}", method = RequestMethod.GET) @ResponseBody
    public List IoReadImageList(@PathVariable String trid) throws Exception {
        List imgName = new ArrayList<>();
        String ftpPath = apolloConfig.getFilePath();
        InputStream is = null;
        try {
            //连接远程sftp
            ftpClient = JcraftTools.getConnect(apolloConfig.getIp(), apolloConfig.getPort(), apolloConfig.getUsername(),
                apolloConfig.getPassword());
            Vector ftpFiles = ftpClient.ls(ftpPath + trid);
            if (ftpFiles != null && ftpFiles.size() > 0) {
                for (ChannelSftp.LsEntry lsEntry : ftpFiles) {
                    //临时e文件名称
                    String fileTemp = lsEntry.getFilename();
                    if (fileTemp.contains(".png") || fileTemp.contains(".jpg")) {
                        String imgIoKey = trid + "_" + fileTemp.split("\\.")[0];
                        //配变下文件名返回给前台
                        imgName.add(fileTemp.split("\\.")[0]);
                        is = ftpClient.get(ftpPath + trid + "/" + fileTemp);
                        //imgIO.put(imgIoKey, is);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            is.close();
            //记得关闭连接
            if (ftpClient != null) {
                ftpClient.quit();
                ftpClient.disconnect();
                try {
                    if (ftpClient.getSession() != null)
                        ftpClient.getSession().disconnect();
                } catch (JSchException e) {
                    log.error("channel getSession error:", e);
                }
            }
        }
        return imgName;
    }

    /**
     * IO流读取图片 by:long(废弃)
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/IoReadImageV1/{trid}/{imgId}", method = RequestMethod.GET) public void IoReadImageV1(
        @PathVariable String trid, @PathVariable String imgId, HttpServletResponse response) throws Exception {
        ServletOutputStream out = null;
        String ftpPath = apolloConfig.getFilePath();
        InputStream is = null;
        //E文件解析工具类
        ChannelSftp ftpClient = null;
        try {
            //连接远程sftp
            ftpClient = JcraftTools.getConnect(apolloConfig.getIp(), apolloConfig.getPort(), apolloConfig.getUsername(),
                apolloConfig.getPassword());
            log.info("IoReadImage------已连接远程服务器!");
            is = ftpClient.get(ftpPath + trid + "/" + imgId + ".png");
            response.setContentType("image/png");
            out = response.getOutputStream();
            //读取文件流
            int len = 0;
            byte[] buffer = new byte[1024 * 10];
            while ((len = is.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            out.close();
            is.close();
            //记得关闭连接
            if (ftpClient != null) {
                ftpClient.quit();
                ftpClient.disconnect();
                try {
                    if (ftpClient.getSession() != null)
                        ftpClient.getSession().disconnect();
                } catch (JSchException e) {
                    log.error("channel getSession error:", e);
                }
            }
        }
    }

    /*
     * (废弃)
     * */
    @RequestMapping(value = "/IoReadImageV2/{trid}/{imgId}", method = RequestMethod.GET) public void IoReadImageV2(
        @PathVariable String trid, @PathVariable String imgId, HttpServletResponse response) throws Exception {
        ServletOutputStream out = null;
        InputStream is = null;
        String keyImg = trid + "_" + imgId;
        Map mapTemp = new HashMap<>();
       /* for (Map.Entry io : imgIO.entrySet()) {
            String key = io.getKey();
            InputStream value = io.getValue();
            mapTemp.put(key, value);
        }*/
        try {
            if (mapTemp.containsKey(keyImg)) {
                is = mapTemp.get(keyImg);
                response.setContentType("image/png");
                out = response.getOutputStream();
                //读取文件流
                int len = 0;
                byte[] buffer = new byte[1024 * 10];
                while ((len = is.read(buffer)) != -1) {
                    out.write(buffer, 0, len);
                }
                out.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            out.close();
            is.close();
        }
    }

    /*
     * 文件批量上传(废弃)
     * @param files
     * @return
     * */
    @ResponseBody @RequestMapping("/uploadimgs") public ResponseData defectAddUploadImgs(
        @RequestParam("file") MultipartFile[] files, @RequestParam("trId") String trId) throws Exception {
        ResponseData responseData = null;
        //存放图片 服务器ip 端口 用户名 密码
        String hostIp = apolloConfig.getIp();
        int portNo = apolloConfig.getPort();
        String username = apolloConfig.getUsername();
        String password = apolloConfig.getPassword();
        //服务器存放图片的路径
        String filePath = apolloConfig.getFilePath() + trId;
        String fileName = null;

        if (files != null) {
            //JcraftTools连接远程机器
            JcraftTools.getConnect(hostIp, portNo, username, password);
            //判断目录是否存在 并创建
            boolean flag = JcraftTools.createDir(filePath);
            if (flag) {
                responseData = new ResponseData("500", "存储配变图片目录创建成功!");
                log.info("图片上传配变目录创建成功!目录如下:");
                for (MultipartFile multipartFile : files) {
                    //文件名称
                    fileName = multipartFile.getOriginalFilename();
                    //江MultipartFile文件转换为File对象
                    File newFile = FileUtils.MultipartFileToFile(multipartFile);
                    //转换成IO流
                    FileInputStream stream = new FileInputStream(newFile);
                    //取出files[i],进行你的业务逻辑,上传oss或本地服务器
                    //文件操作 1 判断文件是否存在 存在不动 不存在新建
                    log.info("图片上传连接服务器成功!");
                    //JcraftTools上传文件
                    JcraftTools.uploadIOFile(filePath, stream, fileName);
                    log.info("传输图片成功 图片:" + fileName);
                }
                //JcraftTools关闭远程连接
                JcraftTools.close();
                responseData = new ResponseData("200", "图片上传成功!");
            } else {
                responseData = new ResponseData("500", "error:请检查服务器存储文件目录是否正确及目录权限、账号是否正确!");
                log.info("图片上传配变目录创建成功!目录如下:");
            }
        }
        return responseData;
    }

}

4.4 service
//华为云bos存储接口
package com.nari.osp.upload.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.nari.osp.upload.entity.ApolloConfig;
import com.nari.osp.upload.entity.QueryCondition;
import com.nari.osp.upload.entity.TrBaseEntity;
import com.nari.osp.upload.service.UpImgService;
import com.nari.osp.upload.util.FileReadWriteUtils;
import com.nari.osp.upload.util.HuaweiOBSUtil;
import com.nari.osp.upload.util.ResponseData;
import com.nari.osp.upload.util.ZipUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SuppressWarnings(value = "all") @Service public class ObsUpImgServiceImpl implements UpImgService {
    Log log = LogFactory.getLog(getClass());
    @Autowired private ApolloConfig apolloConfig;
    //图片流(废弃)
    Map imgIO = new HashMap<>();

    @Override public JSONObject getTrBaseList(QueryCondition queryParam) {
        return null;
    }

    @Override public TrBaseEntity getTrBase(QueryCondition queryParam) {
        return null;
    }

    @Override public void imgUpload(HttpServletRequest request, HttpServletResponse response, String trId)
        throws IOException {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest)request;
        //获取图片上传的批量列表
        Map fileMap = multipartRequest.getFileMap();
        for (Map.Entry set : fileMap.entrySet()) {
            String result = HuaweiOBSUtil.uploadFile(set.getValue(), trId);
            if (result.isEmpty()) {
                log.info("文件上传失败;上传返回结果为:" + result);
                response.sendError(500, "文件上传失败具体参考后台日志");
            }
        }
    }

    @Override public List downloadImage(String trid) {
        //获取该配变华为云所有已上传文件名称 和 io流
        List imgName = HuaweiOBSUtil.getBucketObjectList(trid);
        //获取文件io流
        for (String obj : imgName) {
            InputStream inputStream = HuaweiOBSUtil.downloadFileIOByUrl(obj);
            imgIO.put(obj, inputStream);
        }
        return imgName;
    }

    @Override public void IoReadImage(String trid, String imgId, HttpServletResponse response) throws IOException {
        String keyObs = trid + "/" + imgId;
        ServletOutputStream out = null;
        InputStream is = null;
        Map mapTemp = new HashMap<>();
        for (Map.Entry io : imgIO.entrySet()) {
            String key = io.getKey();
            InputStream value = io.getValue();
            mapTemp.put(key, value);
        }
        try {
            if (mapTemp.containsKey(keyObs)) {
                is = mapTemp.get(keyObs);
                String fileType = FileReadWriteUtils.judgeFileType(keyObs);
                if (!"".equals(fileType) && "png".equals(fileType)) {
                    response.setContentType("application/x-png");
                } else if (!"".equals(fileType) && "jpeg".equals(fileType)) {
                    response.setContentType("image/jpeg");
                } else if (!"".equals(fileType) && "jpg".equals(fileType)) {
                    response.setContentType("image/jpg");
                } else {
                    response.setContentType("image/gif");
                }
                out = response.getOutputStream();
                //读取文件流
                int len = 0;
                byte[] buffer = new byte[1024 * 10];
                while ((len = is.read(buffer)) != -1) {
                    out.write(buffer, 0, len);
                }
                out.flush();
                out.close();
                is.close();
                //图片取出后就删除imgIO
                imgIO.remove(keyObs);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            out.close();
            is.close();
        }
    }

    @Override public ResponseData removeImage(String trid, String imgId, HttpServletResponse response) {
        ResponseData responseData = null;
        boolean delFile = HuaweiOBSUtil.deleteFile(trid + "/" + imgId);
        //存在直接删除
        if (delFile) {
            responseData = new ResponseData("200", "图片删除成功!");
        } else {
            responseData = new ResponseData("500", "图片删除失败!");
        }
        return responseData;
    }

    @Override public void fileDownload(String trId, HttpServletRequest request, HttpServletResponse response)
        throws IOException {
        //本地配变图片存放路径
        String localPath = apolloConfig.getLFilePath() + trId;
        //String localPath = "C://Users//zhang102594//Desktop//img//" + trId;
        //压缩文件路径
        String zipPath = apolloConfig.getZipFilePath() + trId + ".zip";
        //String zipPath = "C://Users//zhang102594//Desktop//img//" + trId + ".zip";
        //判断文件夹 是否存在 存在删除内容 不存在 mkdir
        FileReadWriteUtils.dirIsExistOperate(localPath);
        //从华为云下载图片至本地服务器
        HuaweiOBSUtil.downloadDirIOByUrl(localPath, trId);
        FileOutputStream fileOutputStream = new FileOutputStream(new File(zipPath));
        //将文件打包到  压缩包目录
        boolean isSuccess = ZipUtils.toZip(localPath, fileOutputStream, true);
        //如果生成zip成功
        if (isSuccess) {
            // 保存在本地磁盘中的文件
            File file = new File(zipPath);
            BufferedInputStream bis = null;
            FileInputStream fileInputStream = null;
            try {
                response.setHeader("content-type", "application/octet-stream");
                //我们将文件以流的方式返回前端,但是流无法保存文件名称,因此我们将问文件名称放响应头中返回到前端,前端就可以获取到下载的文件名称了
                //在响应头中设置文件名,通过URLEncoder.encode()进行文件编码防止文件名乱码
                response.setHeader("Content-disposition",
                    "attachment;filename=" + URLEncoder.encode(file.getName(), "UTF-8"));
                // 设置响应类型
                response.setContentType("application/x-download");
                // 读取本地的文件
                fileInputStream = new FileInputStream(file);
                // 根据输入流构造一个输入缓冲流对象
                bis = new BufferedInputStream(fileInputStream);
                byte[] buffer = new byte[1024];
                int i = bis.read(buffer);
                // 根据response对象构造一个输出流对象,然后将输入流的对象写入输出流
                OutputStream os = response.getOutputStream();
                while (i != -1) {
                    os.write(buffer, 0, i);
                    i = bis.read(buffer);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (bis != null) {
                    bis.close();
                }
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            }
        }
    }
}
//服务器存储图片代码
package com.nari.osp.upload.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.nari.osp.upload.dao.UpImgDao;
import com.nari.osp.upload.entity.ApolloConfig;
import com.nari.osp.upload.entity.QueryCondition;
import com.nari.osp.upload.entity.TrBaseEntity;
import com.nari.osp.upload.service.UpImgService;
import com.nari.osp.upload.util.FileReadWriteUtils;
import com.nari.osp.upload.util.ResponseData;
import com.nari.osp.upload.util.ZipUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@SuppressWarnings(value = "all")
@Service public class UpImgServiceImp implements UpImgService {
    Log log = LogFactory.getLog(getClass());
    @Autowired private ApolloConfig apolloConfig;
    @Autowired private UpImgDao upImgDao;
    //图片流(废弃)
    Map imgIO = new HashMap<>();

    @Override public JSONObject getTrBaseList(QueryCondition queryParam) {
        //最终返回结果
        JSONArray result = new JSONArray();
        //前台筛选条件是否上传图片
        String isUpload = queryParam.getIsUpload();
        int page = queryParam.getPage();
        int rows = queryParam.getRows();
        List trListTemp = new ArrayList<>();
        List listImgTemp = new ArrayList();
        final CountDownLatch latch = new CountDownLatch(2);
        ExecutorService es1 = Executors.newFixedThreadPool(2);
        //查询配变台账信息
        String whereParam = getWhereCondition(queryParam);
        es1.execute(new Runnable() {
            @Override public void run() {
                JSONArray jsonArray = upImgDao.getTrBaseList(whereParam);
                for (Object obj : jsonArray) {
                    TrBaseEntity trBaseEntity = new TrBaseEntity();
                    // ORGNAME03,ORGNAME04,ORGNAME05,TRID,TRNAME,SNAME,FNAME,PMS_ID PMSID
                    JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
                    String orgName03 = jsonObject.get("ORGNAME03") != null ? jsonObject.getString("ORGNAME03") : "-";
                    String orgName04 = jsonObject.get("ORGNAME04") != null ? jsonObject.getString("ORGNAME04") : "-";
                    String orgName05 = jsonObject.get("ORGNAME05") != null ? jsonObject.getString("ORGNAME05") : "-";
                    String trId = jsonObject.get("TRID") != null ? jsonObject.getString("TRID") : "-";
                    String trName = jsonObject.get("TRNAME") != null ? jsonObject.getString("TRNAME") : "-";
                    String sName = jsonObject.get("SNAME") != null ? jsonObject.getString("SNAME") : "-";
                    String fName = jsonObject.get("FNAME") != null ? jsonObject.getString("FNAME") : "-";
                    String pmsId = jsonObject.get("PMSID") != null ? jsonObject.getString("PMSID") : "-";
                    trBaseEntity.setOrgname03(orgName03);
                    trBaseEntity.setOrgname04(orgName04);
                    trBaseEntity.setOrgname05(orgName05);
                    trBaseEntity.setTrNo(trId);
                    trBaseEntity.setTrName(trName);
                    trBaseEntity.setSubName(sName);
                    trBaseEntity.setLineName(fName);
                    trBaseEntity.setPmsId(pmsId);
                    trListTemp.add(trBaseEntity);
                }
                latch.countDown();
            }
        });
        es1.shutdown();

        //第二个子线程执行
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override public void run() {
                //获取服务器 已上传的配变目录集
                List imgNameList = FileReadWriteUtils.getAllFileName(apolloConfig.getLFilePath());
                for (String obj : imgNameList) {
                    listImgTemp.add(obj);
                }
                latch.countDown();
            }
        });

        es2.shutdown();
        try {
            latch.await();
            //如果是查询全部
            if ("00".equals(isUpload)) {
                for (TrBaseEntity trBaseEntity : trListTemp) {
                    if (listImgTemp.contains(trBaseEntity.getTrNo())) {
                        trBaseEntity.setIsUpload(true);
                    } else {
                        trBaseEntity.setIsUpload(false);
                    }
                    result.add(trBaseEntity);
                }
            }
            //判断是否上传图片
            if ("1".equals(isUpload)) {
                for (TrBaseEntity trBaseEntity : trListTemp) {
                    if (listImgTemp.contains(trBaseEntity.getTrNo())) {
                        trBaseEntity.setIsUpload(true);
                        result.add(trBaseEntity);
                    } else {
                        continue;
                    }
                }
            }

            if ("0".equals(isUpload)) {
                for (TrBaseEntity trBaseEntity : trListTemp) {
                    if (listImgTemp.contains(trBaseEntity.getTrNo())) {
                        continue;
                    } else {
                        trBaseEntity.setIsUpload(false);
                        result.add(trBaseEntity);
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getresultJson(result, page, rows);
    }

    @Override public TrBaseEntity getTrBase(QueryCondition queryParam) {
        String whereParam = getWhereCondition(queryParam);
        JSONArray jsonArray = upImgDao.getTrBase(whereParam);
        TrBaseEntity trBaseEntity = new TrBaseEntity();
        for (Object obj : jsonArray) {
            // ORGNAME03,ORGNAME04,ORGNAME05,TRID,TRNAME,SNAME,FNAME,PMS_ID PMSID
            JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(obj));
            String orgName03 = jsonObject.get("ORGNAME03") != null ? jsonObject.getString("ORGNAME03") : "-";
            String orgName04 = jsonObject.get("ORGNAME04") != null ? jsonObject.getString("ORGNAME04") : "-";
            String orgName05 = jsonObject.get("ORGNAME05") != null ? jsonObject.getString("ORGNAME05") : "-";
            String trId = jsonObject.get("TRID") != null ? jsonObject.getString("TRID") : "-";
            String trName = jsonObject.get("TRNAME") != null ? jsonObject.getString("TRNAME") : "-";
            String sName = jsonObject.get("SNAME") != null ? jsonObject.getString("SNAME") : "-";
            String fName = jsonObject.get("FNAME") != null ? jsonObject.getString("FNAME") : "-";
            String pmsId = jsonObject.get("PMSID") != null ? jsonObject.getString("PMSID") : "-";
            trBaseEntity.setOrgname03(orgName03);
            trBaseEntity.setOrgname04(orgName04);
            trBaseEntity.setOrgname05(orgName05);
            trBaseEntity.setTrNo(trId);
            trBaseEntity.setTrName(trName);
            trBaseEntity.setSubName(sName);
            trBaseEntity.setLineName(fName);
            trBaseEntity.setPmsId(pmsId);
        }
        return trBaseEntity;
    }

    @Override public void imgUpload(HttpServletRequest request, HttpServletResponse response, String trId)
        throws IOException {
        response.setContentType("text/html;charset=UTF-8");
        //本地存放图片的路径
        String filePath = apolloConfig.getLFilePath() + trId;
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest)request;
        Map fileMap = multipartRequest.getFileMap();
        MultipartFile multipartFile = null;
        for (Map.Entry set : fileMap.entrySet()) {
            //判断是否有此配变目录 没有创建
            FileReadWriteUtils.dirIsExist(filePath);
            multipartFile = set.getValue();// 文件名
            String fileName = multipartFile.getOriginalFilename();
            File file = new File(filePath + "/" + fileName);
            log.info("图片上传配变目录创建成功!目录如下:" + fileName);
            multipartFile.transferTo(file);
        }
    }

    @Override public List downloadImage(String trid) {
        List imgName = new ArrayList<>();
        //本地临时文件 前台代码吧 imgTemp
        String localPath = apolloConfig.getLFilePath() + trid;
        Map allFilePath = FileReadWriteUtils.getAllFilePath(localPath);
        for (Map.Entry map : allFilePath.entrySet()) {
            String key = map.getKey();
            InputStream value = map.getValue();
            imgName.add(key);
            imgIO.put(trid + "_" + key, value);
        }
        return imgName;
    }

    @Override public void IoReadImage(String trid, String imgId, HttpServletResponse response) throws IOException {
        String lFilePath = apolloConfig.getLFilePath();
        ServletOutputStream out = null;
        InputStream is = null;
        String keyImg = trid + "_" + imgId;
        Map mapTemp = new HashMap<>();
        for (Map.Entry io : imgIO.entrySet()) {
            String key = io.getKey();
            InputStream value = io.getValue();
            mapTemp.put(key, value);
        }
        try {
            if (mapTemp.containsKey(keyImg)) {
                is = mapTemp.get(keyImg);
                String fileType = FileReadWriteUtils.judgeFileType(lFilePath + trid, imgId);
                if (!"".equals(fileType) && "png".equals(fileType)) {
                    response.setContentType("application/x-png");
                } else if (!"".equals(fileType) && "jpeg".equals(fileType)) {
                    response.setContentType("image/jpeg");
                } else if (!"".equals(fileType) && "jpg".equals(fileType)) {
                    response.setContentType("image/jpg");
                } else {
                    response.setContentType("image/gif");
                }
                out = response.getOutputStream();
                //读取文件流
                int len = 0;
                byte[] buffer = new byte[1024 * 10];
                while ((len = is.read(buffer)) != -1) {
                    out.write(buffer, 0, len);
                }
                out.flush();
                out.close();
                is.close();
                //图片取出后就删除imgIO
                imgIO.remove(keyImg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            out.close();
            is.close();
        }
    }

    @Override public ResponseData removeImage(String trid, String imgId, HttpServletResponse response) {
        ResponseData responseData = null;
        String lFilePath = apolloConfig.getLFilePath() + trid;
        //获取文件类型
        String fileType = FileReadWriteUtils.judgeFileType(lFilePath, imgId);
        //判断文件是否存在
        boolean fileIsExist = FileReadWriteUtils.fileIsExist(lFilePath + "/" + imgId + "." + fileType);
        //存在直接删除
        if (fileIsExist) {
            boolean delFile = FileReadWriteUtils.delFile(lFilePath + "/" + imgId + "." + fileType);
            //imgIO.remove(trid+"_"+imgId);
            if (delFile) {
                responseData = new ResponseData("200", "图片删除成功!");
            } else {
                responseData = new ResponseData("500", "图片删除失败!");
            }
        } else {
            responseData = new ResponseData("500", "图片不存在!");
        }
        return responseData;
    }

    @Override public void fileDownload(String trId, HttpServletRequest request, HttpServletResponse response)
        throws IOException {
        //本地配变图片存放路径
        String localPath = apolloConfig.getLFilePath() + trId;
        //压缩文件路径
        String zipPath = apolloConfig.getZipFilePath() + trId + ".zip";
        FileOutputStream fileOutputStream = new FileOutputStream(new File(zipPath));
        //将文件打包到  压缩包目录
        boolean isSuccess = ZipUtils.toZip(localPath, fileOutputStream, true);
        //如果生成zip成功
        if (isSuccess) {
            // 保存在本地磁盘中的文件
            File file = new File(zipPath);
            BufferedInputStream bis = null;
            FileInputStream fileInputStream = null;
            try {
                response.setHeader("content-type", "application/octet-stream");
                //我们将文件以流的方式返回前端,但是流无法保存文件名称,因此我们将问文件名称放响应头中返回到前端,前端就可以获取到下载的文件名称了
                //在响应头中设置文件名,通过URLEncoder.encode()进行文件编码防止文件名乱码
                response.setHeader("Content-disposition",
                    "attachment;filename=" + URLEncoder.encode(file.getName(), "UTF-8"));
                // 设置响应类型
                response.setContentType("application/x-download");
                // 读取本地的文件
                fileInputStream = new FileInputStream(file);
                // 根据输入流构造一个输入缓冲流对象
                bis = new BufferedInputStream(fileInputStream);
                byte[] buffer = new byte[1024];
                int i = bis.read(buffer);
                // 根据response对象构造一个输出流对象,然后将输入流的对象写入输出流
                OutputStream os = response.getOutputStream();
                while (i != -1) {
                    os.write(buffer, 0, i);
                    i = bis.read(buffer);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (bis != null) {
                    bis.close();
                }
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            }
        }
    }

    public String getWhereCondition(QueryCondition queryParam) {
        String result = "";
        String orgId = queryParam.getOrgId();
        String funcType = queryParam.getFuncType();
        String pmsId = queryParam.getPmsId();
        String trName = queryParam.getTrName();
        String trNo = queryParam.getTrNo();
        if (orgId != null && !"".equals(orgId)) {
            if (funcType != null && !"".equals(funcType)) {
                if ("02".equals(funcType)) { //省
                    result += " and t1.orgid02='" + orgId + "'";
                }
                if ("03".equals(funcType)) { //市
                    result += " and t1.orgid03='" + orgId + "'";
                }
                if ("04".equals(funcType)) { //县
                    result += " and t1.orgid04='" + orgId + "'";
                }
                if ("05".equals(funcType)) { //供电所
                    result += " and t1.orgid05='" + orgId + "'";
                }
                if ("sub".equals(funcType)) { //厂站
                    result += " and t1.sid='" + orgId + "'";
                }
                if ("feeder".equals(funcType)) { //线路
                    result += " and t1.fid='" + orgId + "'";
                }
                if ("tr".equals(funcType)) { //配变
                    result += " and t1.trid='" + orgId + "'";
                }
            }
        }

        if (pmsId != null && !"".equals(pmsId)) {
            result += " and t1.pms_id='" + pmsId + "'";
        }

        if (trName != null && !"".equals(trName)) {
            result += " and t1.trname='" + trName + "'";
        }

        if (trNo != null && !"".equals(trNo)) {
            result += " and t1.trid='" + trNo + "'";
        }

        return result;
    }

    /**
     * 将JSONArray进行分页转化
     *
     * @param jar
     * @param page
     * @param rows
     * @return
     */
    public static JSONObject getresultJson(JSONArray jar, int page, int rows) {
        JSONObject json = new JSONObject();
        JSONArray array = new JSONArray();
        JSONArray page_jar = new JSONArray();
        int pages = jar.size() / rows;
        int ys = jar.size() % rows;
        if (pages != 0) {
            if (ys == 0) {
                int index = (page - 1) * rows;
                int end = index + rows;
                for (int l = index; l < end; l++) {
                    page_jar.add(jar.getJSONObject(l));
                }
            } else {
                if (page <= pages) {
                    int index = (page - 1) * rows;
                    int end = index + rows;
                    for (int l = index; l < end; l++) {
                        page_jar.add(jar.getJSONObject(l));
                    }
                } else {
                    int index = pages * rows;
                    int end = index + ys;
                    for (int l = index; l < end; l++) {
                        page_jar.add(jar.getJSONObject(l));
                    }
                }
            }
        } else {
            for (int l = 0; l < ys; l++) {
                page_jar.add(jar.getJSONObject(l));
            }
        }
        for (int k = 0; k < page_jar.size(); k++) {
            JSONObject jj = page_jar.getJSONObject(k);
            JSONObject jor = new JSONObject();
            for (String key : jj.keySet()) {
                jor.put(key, jj.getString(key) == null ? "" : jj.getString(key).toString());
            }
            array.add(jor);
        }
        json.put("total", jar.size());
        json.put("rows", array);
        return json;
    }

}

5.前后台代码获取方式:[email protected]

6.温馨提示(实际开发代码 编写不易 金额随意 核心代码应该都已经放上去了 希望各位读者参考 参考 参考 源码也可以给 支持向日葵远程调试 邮箱会定期看)

图片批量上传至服务器/华为云obs 前台采用webuploader.js div+css布局 图片.zip华为云obs浏览器下载_第5张图片

你可能感兴趣的:(华为云,spring,boot,java)