cesiumBackend/src/main/java/com/fd/thread/AsyncTask.java

package com.fd.thread;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.fd.constant.Command;
import com.fd.constant.MsgCode;
import com.fd.constant.TypeCode;
import com.fd.dto.MyQueue;
import com.fd.entity.OutputFileEntity;
import com.fd.server.ModelServer;
import com.fd.server.RasterServer;
import com.fd.server.VectorServer;
import com.fd.util.FileUtils;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.io.File;
import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * Created by Owen on 2019/12/11 0011 10:49
 */
@Log4j2
@Component
public class AsyncTask {

    @Async("taskExecutor")
    public void modelDelete(Long id, ModelServer modelServer){
        log.info("run modelDelete");
        modelServer.deleteById(id);
        log.info("end modelDelete id: {}", id);
    }


    @Async("taskExecutor")
    public void rasterDelete(Long fileId, RasterServer rasterServer) {
        log.info("run RasterDeleteThread");
        rasterServer.deleteById(fileId);
        log.info("end RasterDeleteThread: {}", fileId);
    }

    @Async("taskExecutor")
    public void vectorDelete(Long fileId, VectorServer vectorServer){
        log.info("run vectorDelete");
        vectorServer.deleteById(fileId);
        log.info("end vectorDelete id : {}", fileId);
    }

    @Async("taskExecutor")
    public void modelSlice(BlockingQueue<MyQueue> queue, ModelServer modelServer){
        try {
            MyQueue data = queue.poll(2, TimeUnit.SECONDS);
            if (data != null) {
                log.warn("run ModelSliceConsumerThread");
                log.info("cmd: {}", data.getStr());
                Integer integer = modelServer.cmdSlice(data.getStr());
                OutputFileEntity entity = data.getOutputFile();

                if (integer != 0) {
                    log.info("error command sliceThread");
                    // 如果命令运行失败，删除刚才创建的实体类
                    // o:代表切片失败
                    entity.setStatus(0);
                    entity.setUpdateTime(new Date());
                    modelServer.save(entity);
                    return;
                }

                entity.setStatus(5);
                entity.setUpdateTime(new Date());
                modelServer.save(entity);
                log.warn("end ModelSliceConsumerThread id {}", entity.getId());
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }

    }


    @Async("taskExecutor")
    public void rasterSliceThread(BlockingQueue<MyQueue> queue, RasterServer rasterServer) {
        try {
            MyQueue data = queue.poll(2, TimeUnit.SECONDS);
            if (data != null) {
                log.warn("run rasterSliceThread");
                OutputFileEntity  entity = data.getOutputFile();
                log.info("raster cmd: {}", data.getStr());
                Integer integer = rasterServer.cmdSlice(data.getStr(), entity);
                if (integer != 0) {
                    log.info("error command exeCmdRasterSlice");
                    // 如果命令运行失败，状态改为0
                    entity.setStatus(0);
                    entity.setUpdateTime(new Date());
                    rasterServer.save(entity);
                    return;
                }
                // 切片完成，修改完成状态
                entity.setStatus(5);
                entity.setUpdateTime(new Date());
                rasterServer.save(entity);
                log.warn("end rasterSliceThread id： {}", entity.getId());
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }


    }

    @Async("taskExecutor")
    public void vectorSliceThread(BlockingQueue<MyQueue> queue, VectorServer vectorServer){
        try {
            MyQueue data = queue.poll(4, TimeUnit.SECONDS);
            if (data != null) {
                log.warn("run vectorSliceThread");

                OutputFileEntity entity = data.getOutputFile();
                log.info("slice cmd: {}", data.getStr());
                Integer integer =  vectorServer.cmdSlice(data.getStr(), entity);
                if (integer != 0) {
                    log.info("error command exeCmdVectorSlice");
                    // 如果命令运行失败，状态改为0
                    entity.setStatus(0);
                    entity.setUpdateTime(new Date());
                    vectorServer.save(entity);
                    return;
                }
                // 切片完成，修改完成状态
                entity.setStatus(5);
                entity.setUpdateTime(new Date());
                vectorServer.save(entity);
                log.warn("end vectorSliceThread id: {}", entity.getId());
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
            log.error("error  consume queue vector SliceConsumerThread： {}", e);
            e.printStackTrace();
        }
    }



    @Async("taskExecutor")
    public void rasterJudgeCoordConsumerThread(BlockingQueue<MyQueue> queue, RasterServer rasterServer, String baseOutputPath){
        MyQueue data = null;
        try {
            data = queue.poll(3, TimeUnit.SECONDS);

            if (data != null) {
                log.warn("run rasterJudgeCoordConsumerThread");

                // 先让它等一秒
                log.info("start time: {}", new Date());
                Thread.sleep(2000);
                log.info("end time: {}", new Date());

                OutputFileEntity  entity = data.getOutputFile();

                log.info("CoordType: {}", entity.getCoordType());

                if (TypeCode.COORD_XIAN_1980.equals(entity.getCoordType())){
                    log.info("need to transform");
                    // 严格坐标转换
                    entity = cmdTansformGdalwarpStrict(entity, rasterServer, baseOutputPath);
                } else if (TypeCode.COORD_WGS84.equals(entity.getCoordType())){
                    log.info("not to transform");
                    // 4:未切片
                    entity.setStatus(4);
                    // 不需要转，就把上传文件路径复制到严格坐标路径上
                    entity.setCoordStrictPath(entity.getUploadPath());
                    entity.setUpdateTime(new Date());
                    entity = rasterServer.save(entity);
                    log.info("coord Consumer update time: {}", entity.getUpdateTime());
                    log.info("JudgeCoordConsumerThread update entity: {}", entity);
                } else {
                    log.info("error exeCmd");
                    entity.setStatus(0);
                    entity.setUpdateTime(new Date());
                    rasterServer.save(entity);
                }
                log.warn("end rasterJudgeCoordConsumerThread id: {}", entity.getId());

            }

        } catch (Exception e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }

    }

    /**
     * 坐标判断消费队列
     * 矢量数据转坐标只转一次就成功了。
     * 所以转换的成功的路径都放到strictCoordTransform 路径
     * 文件都放transform 目录
     */
    @Async("taskExecutor")
    public void vectorConvertCoordThread (BlockingQueue<MyQueue> queue, VectorServer vectorServer, String baseOutputPath){
        try {
            MyQueue data = queue.poll(2, TimeUnit.SECONDS);
            if (data != null) {
                log.info("run convertCoordThread 出队");
                Thread.sleep(2000);
                OutputFileEntity entity = data.getOutputFile();
                // 坐标处理
                String coord = entity.getCoord();
                log.info("convert coord: {}", coord);
                JSONArray arrayCoord = JSON.parseArray(coord);


                // 转换坐标 普通坐标转换
                if (TypeCode.COORD_SYSTEM_2000.equals(entity.getCoordType())) {
                    // 普通坐标转换
                    log.info("need to general transform");
                    if (arrayCoord.size() == 0) {
                        // 没有坐标参数，执行普通坐标转换（ogrinfo)
                        log.info("run generalCoordTransform");
                        entity = generalCoordTransform(entity, Command.VECTOR_TRANSFORM_GENERAL, vectorServer, baseOutputPath);

                    } else {
                        // 有坐标参数，执行严格坐标转换（CGCS2000转wgs80)
                        log.info("run strictCoordTransform");
                        entity = strictCoordTransform(entity, Command.VECTOR_TRANSFORM_STRICT_WGS80, vectorServer, baseOutputPath);
                    }

                } else if (TypeCode.COORD_XIAN_1980.equals(entity.getCoordType())) {

                    // 严格坐标转换 （西安80转wgs84），需要参数
                    log.info("need to strict transform, CoordType: {}", entity.getCoordType());
                    if (arrayCoord.size() == 0) {
                        log.info("error： {}", MsgCode.E50009);
                        entity.setStatus(7);
                        entity.setUpdateTime(new Date());
                        vectorServer.save(entity);
                    } else {
                        log.info("run strictCoordTransform");
                        entity = strictCoordTransform(entity, Command.VECTOR_TRANSFORM_STRICT_WGS84, vectorServer, baseOutputPath);
                    }

                } else if (TypeCode.COORD_WGS84.equals(entity.getCoordType())) {
                    // 不转换坐标 把文件信息移动到CoordStrictPath 这路径下
                    log.info("not to transform");

                    entity.setCoordStrictPath(entity.getUploadPath());
                    entity.setUpdateTime(new Date());
                    entity.setStatus(3);
                    entity.setCoordType(TypeCode.COORD_WGS84);
                    vectorServer.save(entity);
                } else {
                    log.info("error exeCmd");
                    entity.setStatus(7);
                    entity.setUpdateTime(new Date());
                    vectorServer.save(entity);
                }
                log.info("end convertCoordThread id: {}", entity.getId());
            }
        } catch (Exception e) {
            Thread.currentThread().interrupt();
            log.error("error vector consume queue VectorJudgeCoordConsumerThread： {}", e);
            throw new RuntimeException(e);


        }
    }


    /**
     * raster 严格坐标转换
     */
    private OutputFileEntity cmdTansformGdalwarpStrict(OutputFileEntity entity, RasterServer rasterServer, String baseOutputPath){
        log.info("run cmdTansformGdalwarpStrict");

        String OUTPUT_FILE_PATH = baseOutputPath;

        String fileName = StringUtils.substringBeforeLast(entity.getFileName(), ".");

        String outFileStep1 = OUTPUT_FILE_PATH + "transform";
        FileUtils.createDir(outFileStep1);
        outFileStep1 = outFileStep1 + File.separator + entity.getFileName();

        // 坐标处理
        String coord = entity.getCoord();
        log.info("convert coord: {}", coord);
        JSONArray array = JSON.parseArray(coord);

        String step_1 = Command.RASTER_TRANSFORM_GDALWARP_STRICT_1;
        step_1 = step_1.replace("@inputFile", entity.getUploadPath());
        step_1 = step_1.replace("@outputFile", outFileStep1);


        // 3位数坐标
        if (array.size() == 3) {
            step_1 = step_1.replace("@x", array.getString(0));
            step_1 = step_1.replace("@y", array.getString(1));
            step_1 = step_1.replace("@z", array.getString(2));
            step_1 = step_1.replace("@rx","0");
            step_1 = step_1.replace("@ry","0");
            step_1 = step_1.replace("@rz","0");

            // 坐标为空时
        } else if (array.size() == 0) {
            step_1 = step_1.replace("@x","0");
            step_1 = step_1.replace("@y","0");
            step_1 = step_1.replace("@z","0");
            step_1 = step_1.replace("@rx","0");
            step_1 = step_1.replace("@ry","0");
            step_1 = step_1.replace("@rz","0");

            // 6位数坐标
        }else  {
            step_1 = step_1.replace("@x", array.getString(0));
            step_1 = step_1.replace("@y", array.getString(1));
            step_1 = step_1.replace("@z", array.getString(2));
            step_1 = step_1.replace("@rx",array.getString(3));
            step_1 = step_1.replace("@ry",array.getString(4));
            step_1 = step_1.replace("@rz",array.getString(5));
        }


        String step_2 = Command.RASTER_TRANSFORM_GDALWARP_STRICT_2;


        String outFileStep2 = OUTPUT_FILE_PATH + "transform_strict";
        FileUtils.createDir(outFileStep2);
        outFileStep2 = outFileStep2 + File.separator + entity.getFileName();

        step_2 = step_2.replace("@inputFile", outFileStep1);
        step_2 = step_2.replace("@outputFile", outFileStep2);
        log.info("cmd1: {}", step_1);
        log.info("cmd2: {}", step_2);

        Integer integer = rasterServer.exeCmd(step_1, step_2);

        if (integer != 0) {
            log.info("error command transform");
            return null;
        }

        entity.setStatus(4);
        entity.setUpdateTime(new Date());
        entity.setCoordGeneralPath(outFileStep1);
        entity.setCoordStrictPath(outFileStep2);

        entity = rasterServer.save(entity);

        return entity;
    }

    /**
     * 普通坐标转换
     */
    private OutputFileEntity generalCoordTransform(OutputFileEntity entity, String cmd, VectorServer vectorServer, String baseOutputPath) {

        String directory = createDirectory(entity, baseOutputPath);
        directory = directory + File.separator + entity.getFileName();

        cmd = cmd.replace("@inputFile", entity.getUploadPath());
        cmd = cmd.replace("@outputFile", directory);
        log.info("cmd: {}", cmd);
        return runCmd(cmd, entity, null, directory, vectorServer);
    }


    // 严格坐标转换
    private OutputFileEntity strictCoordTransform(OutputFileEntity entity, String cmd, VectorServer vectorServer, String baseOutputPath) {

        String directory = createDirectory(entity, baseOutputPath);
        directory = directory + File.separator + entity.getFileName();
        String coord = entity.getCoord();
        coord = coord.replace("[", "");
        coord = coord.replace("]", "");
        // 去空格
        coord = StringUtils.deleteWhitespace(coord);

        cmd = cmd.replace("@coord", coord);
        cmd = cmd.replace("@inputFile", entity.getUploadPath());
        cmd = cmd.replace("@outputFile", directory);
        log.info("cmd: {}", cmd);

        return runCmd(cmd, entity, null, directory, vectorServer);
    }

    // 创建目录
    private String createDirectory(OutputFileEntity entity, String baseOutputPath) {
        String OUTPUT_FILE_PATH = baseOutputPath;
        String directory = OUTPUT_FILE_PATH + "transform" + File.separator + entity.getDirectory();
        FileUtils.createDir(directory);
        return directory;
    }

    // 执行命令，创建对象， 坐标转换使用
    private OutputFileEntity runCmd(String cmd, OutputFileEntity entity, String generalPath, String strictPath, VectorServer vectorServer) {
        Integer integer = vectorServer.exeCmd(cmd);
        // 转换坐标失败, 修改状态
        if (integer != 0) {
            entity.setUpdateTime(new Date());
            entity.setStatus(7);
            entity = vectorServer.save(entity);
            return null;
        }

        entity.setFileName(entity.getFileName());
        entity.setCoordGeneralPath(generalPath);
        entity.setCoordStrictPath(strictPath);
        entity.setUpdateTime(new Date());
        entity.setStatus(3);

        entity = vectorServer.save(entity);

        return entity;

    }

}