init-cpdm

.gitignore

@@ -12,3 +12,9 @@
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 
+/.gradle/
+/build/
+/src/main/resources/static/
+/logs/
+/gradle/
+/.idea/

.local-browser/win64-722234/chrome-win/80.0.3987.0.manifest

@@ -0,0 +1,8 @@
+<assembly
+  xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
+  <assemblyIdentity
+      name='80.0.3987.0'
+      version='80.0.3987.0'
+      type='win32'/>
+  <file name='chrome_elf.dll'/>
+</assembly>

src/main/java/com/rf/psychological/base/model/BaseEntity.java

@@ -0,0 +1,37 @@
+package com.rf.psychological.base.model;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.GenericGenerator;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+import java.io.Serializable;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:13
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@EntityListeners({AuditingEntityListener.class})
+@MappedSuperclass
+public class BaseEntity implements Serializable {
+    @Getter
+    @Id
+    @GenericGenerator(name = "jpa-uuid", strategy = "uuid")
+    @GeneratedValue(generator = "jpa-uuid")
+    @Column(name = "id", columnDefinition = "varchar(36) COMMENT '数据ID'")
+    @NotNull(groups = Update.class)
+    private String id;
+
+    public @interface Update {
+    }
+}

src/main/java/com/rf/psychological/base/repository/BaseRepository.java

@@ -0,0 +1,19 @@
+package com.rf.psychological.base.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.querydsl.QuerydslPredicateExecutor;
+import org.springframework.data.repository.NoRepositoryBean;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.Serializable;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:17
+ */
+@NoRepositoryBean
+public interface BaseRepository<T, PK extends Serializable> extends JpaRepository<T, PK>, JpaSpecificationExecutor, QuerydslPredicateExecutor<T> {
+
+}

src/main/java/com/rf/psychological/base/rest/BaseController.java

@@ -0,0 +1,77 @@
+package com.rf.psychological.base.rest;
+
+import com.rf.psychological.utils.HttpStatus;
+import com.rf.psychological.utils.Result;
+import com.rf.psychological.utils.ScaleResultBusinessMap;
+
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:20
+ */
+public class BaseController {
+    protected static final String PAGE_NUM = "pageNum";
+
+    protected static final String PAGE_SIZE = "pageSize";
+
+    protected Result success() {
+        return success(null, "成功");
+    }
+
+    protected static <T> Result<T> success(T data) {
+        return success(data, "成功");
+    }
+
+    protected static <T> Result<T> success(T data, String message) {
+        if (null == data) {
+            return new Result<>(HttpStatus.SUCCESS, message);
+        }
+        return new Result<>(HttpStatus.SUCCESS, message, data);
+    }
+
+    protected static <T> Result<T> success(String code,T data, String message) {
+        if (null == data) {
+            return new Result<>(code, message);
+        }
+        return new Result<>(code, message, data);
+    }
+
+    protected Result fail() {
+        return fail(null, "失败");
+    }
+
+    protected static <T> Result<T> fail(T data) {
+        return fail(data, "失败");
+    }
+
+    protected static <T> Result<T> fail(String message) {
+        return new Result<>(HttpStatus.RUNTIME_EXCEPTION, message);
+    }
+
+    protected static <T> Result<T> fail(String code ,T data ,String message){
+        if(data == null)
+            return new Result<>(code,message);
+        else
+            return new Result<>(code,message,data);
+    }
+
+    protected static <T> Result<T> fail(T data, String message) {
+        if (null == data) {
+            return new Result<>(HttpStatus.RUNTIME_EXCEPTION, message);
+        }
+        return new Result<>(HttpStatus.RUNTIME_EXCEPTION, message, data);
+    }
+
+    protected Result failBadRequest() {
+        return failBadRequest(null, "参数异常");
+    }
+
+    protected static <T> Result<T> failBadRequest(T data) {
+        return failBadRequest(null, "参数异常");
+    }
+
+    protected static <T> Result<T> failBadRequest(T data, String message) {
+        return new Result<>(org.springframework.http.HttpStatus.BAD_REQUEST.value() + "", message, data);
+    }
+}

src/main/java/com/rf/psychological/dao/model/ANTEntity.java

@@ -0,0 +1,50 @@
+package com.rf.psychological.dao.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * @author zSY
+ * @description:ANT测试实体对象
+ * @date 2021/3/4 16:54
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ANTEntity {
+
+    /**
+     * 序号
+     */
+    private String index;
+
+    /**
+     * 展示类型，+/其他
+     */
+    private String type;
+
+    /**
+     * 当前展示箭头的方向，L-左/R右
+     */
+    private String currentDir;
+
+    /**
+     * 用户反馈的方向，L-左/R右
+     */
+    private String userClickDir;
+
+    /**
+     * 反应时间
+     */
+    private String responseTime;
+
+    /**
+     * 是否为一致性
+     */
+    private String consistency;
+
+
+}

src/main/java/com/rf/psychological/dao/model/ASKEntity.java

@@ -0,0 +1,55 @@
+package com.rf.psychological.dao.model;
+
+import com.rf.psychological.base.model.BaseEntity;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:38
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_ask_info")
+@org.hibernate.annotations.Table(appliesTo = "t_ask_info", comment = "艾森克人格量表")
+@DynamicUpdate
+public class ASKEntity extends BaseEntity {
+
+    /**
+     * 编号
+     */
+    @Column(name = "no", columnDefinition = "int(10) comment '编号'")
+    private int no;
+
+    /**
+     * 内容
+     */
+    @Column(name = "content", columnDefinition = "text comment '内容'")
+    private String content;
+
+    /**
+     * 选项
+     */
+    @Column(name = "check_items", columnDefinition = "text comment '选项'")
+    private String checkItems;
+
+    /**
+     * 类型
+     * 1：是记1分
+     * 0：否记1分
+     */
+    @Column(name = "type", columnDefinition = "varchar(2) comment '类型：1正向，0反向'")
+    private String type;
+
+    @Column(name = "scale", columnDefinition = "varchar(2) comment '量表'")
+    private String scale;
+}

src/main/java/com/rf/psychological/dao/model/AnswerEntity.java

@@ -0,0 +1,68 @@
+package com.rf.psychological.dao.model;
+
+import com.rf.psychological.base.model.BaseEntity;
+import com.rf.psychological.security.EncryptDecodeConverter;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:答案选项实体类
+ * @date 2021/5/13 11:02
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_answer_info")
+@org.hibernate.annotations.Table(appliesTo = "t_answer_info", comment = "答案选项表")
+@DynamicUpdate
+public class AnswerEntity extends BaseEntity {
+
+    @Column(name = "question_no", columnDefinition = "varchar(10) comment '所属题号'")
+    private String questionNo;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "name", columnDefinition = "varchar(500) comment '答案内容'")
+    private String name;
+
+    @Column(name = "options", columnDefinition = "varchar(10) comment '选项值'")
+    private String options;
+
+    @Column(name = "question_type", columnDefinition = "varchar(10) comment '类型：0-单选 1-多选 2-填空'")
+    private String questionType;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "score", columnDefinition = "varchar(100) comment '分值'")
+    private String score;
+
+    @Column(name = "score_direction", columnDefinition = "varchar(10) comment '计分方向：1-正向；0-反向'")
+    private String scoreDirection;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+    ///**
+    // * 加密
+    // */
+    //public void encrypt() {
+    //    this.score = DESede.encryptString(this.score);
+    //    this.name = DESede.encryptString(this.name);
+    //}
+    //
+    ///**
+    // * 进行解密
+    // */
+    //public void decrypt() {
+    //    this.score = DESede.decryptString(this.score);
+    //    this.name = DESede.decryptString(this.name);
+    //}
+
+}

src/main/java/com/rf/psychological/dao/model/AviationEntity.java

@@ -0,0 +1,40 @@
+package com.rf.psychological.dao.model;
+
+import com.rf.psychological.base.model.BaseEntity;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:汉化版美国航空航天局任务负荷指数量表
+ * @date 2021/1/20 17:47
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_aviation_info")
+@org.hibernate.annotations.Table(appliesTo = "t_aviation_info", comment = "汉化版美国航空航天局任务负荷指数量表")
+@DynamicUpdate
+public class AviationEntity extends BaseEntity {
+    /**
+     * 编号
+     */
+    @Column(name = "no", columnDefinition = "int(10) comment '编号'")
+    private int no;
+
+    /**
+     * 内容
+     */
+    @Column(name = "content", columnDefinition = "text comment '内容'")
+    private String content;
+
+    @Column(name = "checked", columnDefinition = "varchar(10) comment '得分'")
+    private String checked;
+}

src/main/java/com/rf/psychological/dao/repository/ASKRepository.java

@@ -0,0 +1,13 @@
+package com.rf.psychological.dao.repository;
+
+import com.rf.psychological.base.repository.BaseRepository;
+import com.rf.psychological.dao.model.ASKEntity;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:40
+ */
+public interface ASKRepository extends BaseRepository<ASKEntity,String> {
+
+}

src/main/java/com/rf/psychological/dao/repository/AviationRepository.java

@@ -0,0 +1,12 @@
+package com.rf.psychological.dao.repository;
+
+import com.rf.psychological.base.repository.BaseRepository;
+import com.rf.psychological.dao.model.AviationEntity;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:49
+ */
+public interface AviationRepository extends BaseRepository<AviationEntity,String> {
+}

src/main/java/com/rf/psychological/file/ApkDownloadController.java

@@ -0,0 +1,114 @@
+package com.rf.psychological.file;
+
+import com.rf.psychological.base.rest.BaseController;
+import com.rf.psychological.utils.OSUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+
+/**
+ * @author zsy
+ * @description:download APK 下载安装包
+ * @date 2021/5/11 10:57
+ */
+@Slf4j
+@RestController
+@RequestMapping("/apk")
+@Api(tags = "下载安装包")
+public class ApkDownloadController extends BaseController {
+
+    @ApiOperation(value = "下载安装包")
+    @GetMapping("")
+    public String downloadFile(HttpServletResponse response) throws Exception {
+        String fileName = "pluse_app_2.1.apk";
+        if (fileName != null) {
+//            fileName = fileName.replace('_','-')+""
+            File file = null;
+            //设置文件路径
+            if(OSUtil.isLinux()){
+
+                /*if("scale".equals(flag)){
+                    file = new File("./scales/"+fileName);
+                }else{
+                    file = new File("./"+fileName);
+                }*/
+            }else{
+
+                String filepath = ApkDownloadController.txt2String(new File("C:/DataPilot/file-apk.txt"));
+                file = new File(filepath);
+            }
+            if (file.exists()) {
+               /* response.setContentType("application/force-download");// 设置强制下载不打开
+                response.addHeader("Content-Disposition", "attachment;fileName=" + fileName);// 设置文件名
+                response.setContentType("application/binary;charset=ISO8859-1");*/
+                response.reset();
+                response.setContentType("application/octet-stream");
+                response.setCharacterEncoding("utf-8");
+                response.setContentLength((int) file.length());
+                response.setHeader("Content-Disposition", "attachment;filename="+ java.net.URLEncoder.encode(fileName, "UTF-8"));
+
+                byte[] buffer = new byte[1024];
+                FileInputStream fis = null;
+                BufferedInputStream bis = null;
+                try {
+                    fis = new FileInputStream(file);
+                    bis = new BufferedInputStream(fis);
+                    OutputStream os = response.getOutputStream();
+                    int i = bis.read(buffer);
+                    while (i != -1) {
+                        os.write(buffer, 0, i);
+                        i = bis.read(buffer);
+                    }
+                    return "下载成功";
+                } catch (Exception e) {
+                    e.printStackTrace();
+                } finally {
+                    if (bis != null) {
+                        try {
+                            bis.close();
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    if (fis != null) {
+                        try {
+                            fis.close();
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            }
+        }
+        return "下载失败";
+    }
+
+    /**
+     * 读取txt文件的内容
+     * @param file 想要读取的文件对象
+     * @return 返回文件内容
+     */
+    public static String txt2String(File file){
+        StringBuilder result = new StringBuilder();
+        try{
+            BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
+            String s = null;
+            while((s = br.readLine())!=null){//使用readLine方法，一次读一行
+                //result.append(System.lineSeparator()+s);换行
+                result.append(s);
+            }
+            br.close();
+        }catch(Exception e){
+            e.printStackTrace();
+        }
+        return result.toString();
+    }
+
+
+}
+
+

src/main/java/com/rf/psychological/scale/dao/repository/AnswerRepository.java

@@ -0,0 +1,48 @@
+package com.rf.psychological.scale.dao.repository;
+
+import com.rf.psychological.base.repository.BaseRepository;
+import com.rf.psychological.dao.model.AnswerEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:54
+ */
+public interface AnswerRepository extends BaseRepository<AnswerEntity, String> {
+
+
+    /**
+     * 根据flag获取全部答案
+     *
+     * @param flag
+     * @return
+     */
+    @Query(value = "select id,question_no,name,options,question_type,score,score,score_direction,flag from t_answer_info where flag = :flag", nativeQuery = true)
+    List<AnswerEntity> getAnswerByFlag(@Param("flag") String flag);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_answer_info", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_answer_info SET name = :name, score = :score WHERE id = :id ", nativeQuery = true)
+    void updateAnswer(@Param("name") String name, @Param("score") String score, @Param("id") String id);
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_answer_info where flag=:flag  ", nativeQuery = true)
+    void deleteAnswerByFlag(@Param("flag")String flag);
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/AASScale.java

@@ -0,0 +1,326 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.dao.dto.scale.NewResultDto;
+import com.rf.psychological.dao.model.AnswerEntity;
+import com.rf.psychological.dao.model.DimensionEntity;
+import com.rf.psychological.scale.dao.model.ScaleMarksEntity;
+import com.rf.psychological.scale.scaleresult.ScaleConstant;
+import com.rf.psychological.utils.Constant;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description 成人依恋量表
+ */
+public class AASScale extends BaseScale {
+    public AASScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("AASSCALE.dll");
+        System.out.println("JSONArray:"+jsonArray);
+        System.out.println("resultJson:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.AASScale(jsonArray.toString(), resultJson.toString());
+        //System.out.println("dllresult:"+result);
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("jsonObject:"+jsonObject);
+        return jsonObject;*/
+
+        //亲近分量表总分
+        int score1 = 0;
+        //依赖分量表总分
+        int score2 = 0;
+        //焦虑分量表总分
+        int score3 = 0;
+        //亲近依赖均分
+        double scoreA = 0;
+        //焦虑均分
+        double scoreB = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if ((i + 1) == 1 || (i + 1) == 6 || (i + 1) == 8 || (i + 1) == 12 || (i + 1) == 13 || (i + 1) == 17) {
+                if (jsonObject1.getString("scoreDirection").equals("1")) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 5;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 1;
+                    }
+                }
+            } else if ((i + 1) == 2 || (i + 1) == 5 || (i + 1) == 7 || (i + 1) == 14 || (i + 1) == 16 || (i + 1) == 18) {
+                if (jsonObject1.getString("scoreDirection").equals("1")) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 5;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 1;
+                    }
+                }
+            } else {
+                if (jsonObject1.getString("scoreDirection").equals("1")) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 5;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 1;
+                    }
+                }
+            }
+        }
+
+        DecimalFormat df = new DecimalFormat("######0.00");
+
+        scoreA = Double.parseDouble(df.format((score1 + score2) / 12.0));
+        scoreB = Double.parseDouble(df.format(score3 / 6.0));
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("亲近依赖均分", String.valueOf(scoreA));
+        resultMap.put("焦虑均分", String.valueOf(scoreB));
+
+        resultJson.put("亲近依赖均分", String.valueOf(scoreA));
+        resultJson.put("焦虑均分", String.valueOf(scoreB));
+
+
+        if (scoreA > 3 && scoreB < 3) {
+            resultMap.put("解读", "安全型");
+            resultJson.put("解读", "安全型");
+        } else if (scoreA > 3 && scoreB > 3) {
+            resultMap.put("解读", "先占型");
+            resultJson.put("解读", "先占型");
+        } else if (scoreA < 3 && scoreB < 3) {
+            resultMap.put("解读", "拒绝型");
+            resultJson.put("解读", "拒绝型");
+        } else if (scoreA < 3 && scoreB > 3) {
+            resultMap.put("解读", "恐惧型");
+            resultJson.put("解读", "恐惧型");
+        }
+
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_AAS);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+
+    public JSONObject scaleCalculateV2() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+        //亲近分量表总分
+        int score1 = 0;
+        //依赖分量表总分
+        int score2 = 0;
+        //焦虑分量表总分
+        int score3 = 0;
+        //亲近依赖均分
+        double scoreA = 0;
+        //焦虑均分
+        double scoreB = 0;
+
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (jsonArray.size() > 0) {
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                if ((i + 1) == 1 || (i + 1) == 6 || (i + 1) == 8 || (i + 1) == 12 || (i + 1) == 13 || (i + 1) == 17) {
+                    if (jsonObject1.getString("scoreDirection").equals("1")) {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score1 += 1;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score1 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score1 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score1 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score1 += 5;
+                        }
+                    } else {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score1 += 5;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score1 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score1 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score1 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score1 += 1;
+                        }
+                    }
+                } else if ((i + 1) == 2 || (i + 1) == 5 || (i + 1) == 7 || (i + 1) == 14 || (i + 1) == 16 || (i + 1) == 18) {
+                    if (jsonObject1.getString("scoreDirection").equals("1")) {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score2 += 1;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score2 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score2 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score2 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score2 += 5;
+                        }
+                    } else {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score2 += 5;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score2 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score2 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score2 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score2 += 1;
+                        }
+                    }
+                } else {
+                    if (jsonObject1.getString("scoreDirection").equals("1")) {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score3 += 1;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score3 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score3 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score3 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score3 += 5;
+                        }
+                    } else {
+                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                            score3 += 5;
+                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
+                            score3 += 4;
+                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
+                            score3 += 3;
+                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
+                            score3 += 2;
+                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                            score3 += 1;
+                        }
+                    }
+                }
+            }
+
+            DecimalFormat df = new DecimalFormat("######0.00");
+
+            scoreA = Double.parseDouble(df.format((score1 + score2) / 12.0));
+            scoreB = Double.parseDouble(df.format(score3 / 6.0));
+            if (scoreA > 3 && scoreB < 3) {
+                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "安全型", "亲密关系和相互依赖安心，乐观、好交际。在感情上很容易接近他人。不管是依赖他人还是被人依赖都感觉心安。不会担忧独处和不为人接纳。", "无",
+                        "无", "无", "无", "是"));
+            } else if (scoreA > 3 && scoreB > 3) {
+                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "先占型", "对有损亲密关系的任何威胁都不安和警惕，贪婪、妒忌。希望在亲密关系中投入全部的感情，但经常发现他人并不乐意杷关系发展到如自己期望的那般亲密。没有亲密关系让我不安，有时还担心伴侣不会像我看重他一样看重我。", "无",
+                        "无", "无", "无", "是"));
+            } else if (scoreA < 3 && scoreB < 3) {
+                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "拒绝型", "自立，漠视亲密关系，冷淡、独立。即使没有亲密关系也安心。对我而言，独立和自给自足更加重要，我不喜欢依赖别人或让人依赖。", "无",
+                        "无", "无", "无", "是"));
+            } else if (scoreA < 3 && scoreB > 3) {
+                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "恐惧型", "害怕被遗弃，不信任他人，猜忌多疑、害羞。和他人发生亲密接触使我不安。感情上我渴望亲密关系，但很难完全相信他人或依赖他人。担心自己和他人变得太亲密会受到伤害。", "无",
+                        "无", "无", "无", "是"));
+            }
+            resultMap0.put("总分", String.valueOf(score));
+            resultJson.put("总分", String.valueOf(score));
+
+            resultMapList.add(resultMap0);
+        }
+
+
+        //需要图表展示的
+        newResult.put("iconInfo", "");
+        newResult.put("result", newResultDtos);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ABCScale.java

@@ -0,0 +1,56 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description 孤独症儿童行为量表
+ */
+public class ABCScale extends BaseScale {
+    public ABCScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+        //总分
+        int score = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("checkItems").equals("轻微")) {
+                score += 1;
+            } else if (jsonObject1.getString("checkItems").equals("明显")) {
+                score += 2;
+            } else if (jsonObject1.getString("checkItems").equals("比较重")) {
+                score += 3;
+            } else if (jsonObject1.getString("checkItems").equals("严重")) {
+                score += 4;
+            }else if (jsonObject1.getString("checkItems").equals("无")) {
+                score += 0;
+            }
+        }
+
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_ABC);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ABEScale.java

@@ -0,0 +1,72 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.dao.model.AnswerEntity;
+import com.rf.psychological.dao.model.DimensionEntity;
+import com.rf.psychological.scale.dao.model.ScaleMarksEntity;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+/**
+ * @author xbw
+ * @description:少年儿童身体自尊量表
+ * @date 2021/11/4 21:30
+ */
+public class ABEScale extends BaseScale{
+    public ABEScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        double sum = 0;
+        DecimalFormat df = new DecimalFormat("######0.00");
+        if (dimensionEntities.size() > 0){
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                sum = 0;
+                String questionNos = dimensionEntity.getQuestionNo();
+                String[] questionNo = questionNos.split("；");
+                for (String question:questionNo){
+                    JSONObject jsonObject1 = jsonArray.getJSONObject(Integer.valueOf(question)-1);
+                    for (AnswerEntity answerEntity:answerEntities){
+                        if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                            sum = sum + 1;
+                        }
+                    }
+                }
+                //计算当前维度平均分
+                dimensionScore[y] = Double.parseDouble(df.format(dimensionScore[y]/sum));
+                String dimensionSName1 = dimensionEntity.getName().concat("平均分");
+                resultMap0.put(dimensionSName1, String.valueOf(dimensionScore[y]));
+                resultJson.put(dimensionSName1, String.valueOf(dimensionScore[y]));
+            }
+
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ABTScale.java

@@ -0,0 +1,63 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description A型、B型性格测试
+ */
+public class ABTScale extends BaseScale {
+    public ABTScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+        //是总分
+        int scoreA = 0;
+        //否总分
+        int scoreB = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("checkItems").equals("是")) {
+                scoreA += 1;
+            } else if (jsonObject1.getString("checkItems").equals("否")) {
+                scoreB += 1;
+            }
+        }
+
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("A总分", String.valueOf(scoreA));
+        resultMap.put("B总分", String.valueOf(scoreB));
+        resultJson.put("A总分", String.valueOf(scoreA));
+        resultJson.put("B总分", String.valueOf(scoreB));
+
+
+        if (scoreA > scoreB) {
+            resultMap.put("解读", "A性性格倾向");
+            resultJson.put("解读", "A性性格倾向");
+        } else {
+            resultMap.put("解读", "B性性格倾向");
+            resultJson.put("解读", "B性性格倾向");
+        }
+
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_ABT);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ADSCScale.java

@@ -0,0 +1,60 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description 青少年忧郁情绪自我检视表
+ */
+public class ADSCScale extends BaseScale {
+    public ADSCScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+        //总分
+        int score = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("checkItems").equals("是")) {
+                score += 1;
+            } else if (jsonObject1.getString("checkItems").equals("否")) {
+                score += 0;
+            }
+        }
+
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        if (score <= 5) {
+            resultMap.put("总分解读", "你真的不错喔 !忧郁程度满低的，平时就知道要如何调整情绪及纾解压力吧。继续保持下去，别让忧郁情绪发酵 !");
+            resultJson.put("总分解读", "你真的不错喔 !忧郁程度满低的，平时就知道要如何调整情绪及纾解压力吧。继续保持下去，别让忧郁情绪发酵 !");
+        } else if (score <= 11) {
+            resultMap.put("总分解读", "最近的心情是不是起起伏伏，有些令人烦恼的事 ?要不要试着把问题及感受向自己信任的人(例如朋友、父母或师长)说出来，一起讨论解决的方法。他们的经验会带给你不同的想法 !你也可以做些愉快的事，多做腹式深呼吸，每天运动，保持活动的习惯，让自己有活力 !或是和朋友一起做些愉快放松的事，转移注意力，冷静一下重新出发，忧郁情绪不再有。");
+            resultJson.put("总分解读", "最近的心情是不是起起伏伏，有些令人烦恼的事 ?要不要试着把问题及感受向自己信任的人(例如朋友、父母或师长)说出来，一起讨论解决的方法。他们的经验会带给你不同的想法 !你也可以做些愉快的事，多做腹式深呼吸，每天运动，保持活动的习惯，让自己有活力 !或是和朋友一起做些愉快放松的事，转移注意力，冷静一下重新出发，忧郁情绪不再有。");
+        } else {
+            resultMap.put("总分解读", "是不是已持续一阵子都闷闷的 ?觉得步伐、肩膀很沉重，或是常常担心很多事，很焦虑 ?你的忧郁程度已经颇高了，需要好好注意了。赶快把自己的情况告诉学校的辅导老师或专业机构，请他们给予协助，求助不代表你不行，反而表示你聪明得善用资源呢 !");
+            resultJson.put("总分解读", "是不是已持续一阵子都闷闷的 ?觉得步伐、肩膀很沉重，或是常常担心很多事，很焦虑 ?你的忧郁程度已经颇高了，需要好好注意了。赶快把自己的情况告诉学校的辅导老师或专业机构，请他们给予协助，求助不代表你不行，反而表示你聪明得善用资源呢 !");
+        }
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_ADSC);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ADSScale.java

@@ -0,0 +1,153 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:饮酒问卷
+ * @date 2021/7/20 15:55
+ */
+public class ADSScale extends BaseScale{
+
+    public ADSScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*String fileUrl;
+        //设置文件路径
+        if(OSUtil.isLinux()){
+            fileUrl = "./scalesDll/ADSScale.dll";
+        }else{
+            fileUrl = "D:\\softWare\\ideaWorkspace\\psychological\\src\\main\\resources\\scalesDll\\ADSScale.dll";
+        }
+        //System.load("D:\\softWare\\ideaWorkspace\\psychological\\src\\main\\resources\\scalesDll\\FESCVSCALE.dll");
+        System.load(fileUrl);
+        System.out.println("JSONArray:"+jsonArray);
+        System.out.println("JSONObject:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.ADSScale(jsonArray.toString(), resultJson.toString());
+
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("jsonObjectc:"+jsonObject);
+        return jsonObject;*/
+
+
+        //得分
+        int score = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (i == 0){
+                if (jsonObject1.getString("checkItems").equals("喝醉了喝得烂醉")) {
+                    score += 1;
+                }
+            }else if (i == 1){
+                if (jsonObject1.getString("checkItems").equals("是的")) {
+                    score += 1;
+                }
+            }else if (i == 2 || i == 3 || i == 4 || i == 5 || i == 10 || i ==11){
+                if (jsonObject1.getString("checkItems").equals("有时")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("几乎每次都有")) {
+                    score += 2;
+                }
+            }else if (i == 6 || i == 7){
+                if (jsonObject1.getString("checkItems").equals("仅有一次")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("一次以上")) {
+                    score += 2;
+                }
+            }else if (i == 8){
+                if (jsonObject1.getString("checkItems").equals("是的")) {
+                    score += 1;
+                }
+            }else if (i == 9){
+                if (jsonObject1.getString("checkItems").equals("有时")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("经常")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("几乎每次喝酒以后")) {
+                    score += 3;
+                }
+            }else if (i == 12 || i == 13){
+                if (jsonObject1.getString("checkItems").equals("一次")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("一次以上")) {
+                    score += 2;
+                }
+            }else if (i == 14 || i == 16 || i == 17 || i == 23 || i == 24){
+                if (jsonObject1.getString("checkItems").equals("是")) {
+                    score += 1;
+                }
+            }else if (i == 15){
+                if (jsonObject1.getString("checkItems").equals("是但仅有几小时是")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("有一两天是")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("有好几天")) {
+                    score += 3;
+                }
+            }else if (i == 18 || i == 20){
+                if (jsonObject1.getString("checkItems").equals("仅一次")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("一次以上")) {
+                    score += 2;
+                }
+            }else if (i == 19 || i == 21){
+                if (jsonObject1.getString("checkItems").equals("一两次")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("经常有")) {
+                    score += 2;
+                }
+            }else if (i == 22){
+                if (jsonObject1.getString("checkItems").equals("有，丧失记忆的时间超过一小时")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("有，丧失记忆的时间超过几个小时")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("有，丧失记忆的时间一天以上")) {
+                    score += 3;
+                }
+            }
+        }
+
+        Map<String, String> resultMap1 = new LinkedHashMap<>();
+        resultMap1.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        if (score == 0){
+            resultMap1.put("解读", "无酒依赖的表现");
+            resultJson.put("解读", "无酒依赖的表现");
+        }else if (score >= 1 && score <= 13){
+            resultMap1.put("解读", "对酒依赖的水平较低，主要表现为心理的依赖，而非躯体的。此类受试者多愿限制饮酒量，而非欲断酒");
+            resultJson.put("解读", "对酒依赖的水平较低，主要表现为心理的依赖，而非躯体的。此类受试者多愿限制饮酒量，而非欲断酒");
+        }else if (score >= 14 && score <= 21){
+            resultMap1.put("解读", "中等水平的酒依赖，可能有与饮酒有关的社会心理问题，但以心理依赖为主，继续发展可能出现躯体依赖，戒断症状。受试者可能愿意减少饮酒量，而非彻底戒酒");
+            resultJson.put("解读", "中等水平的酒依赖，可能有与饮酒有关的社会心理问题，但以心理依赖为主，继续发展可能出现躯体依赖，戒断症状。受试者可能愿意减少饮酒量，而非彻底戒酒");
+        }else if (score >= 22 && score <= 30){
+            resultMap1.put("解读", "酒依赖发展到相当的程度。可能出现了躯体依赖可能存在与饮酒有关的躯体障碍和社会心理间题，告诉受试者应该认真考虑彻底戒酒，这是唯一解决间题的办法");
+            resultJson.put("解读", "酒依赖发展到相当的程度。可能出现了躯体依赖可能存在与饮酒有关的躯体障碍和社会心理间题，告诉受试者应该认真考虑彻底戒酒，这是唯一解决间题的办法");
+        }else if (score >= 31 && score <= 47){
+            resultMap1.put("解读", "酒依赖发展到了严重的程度，躯体依赖可能性很大，并可能出现了与饮酒有关的躯体障碍，如肝脏疾病，应告诫病人彻底戒酒是唯一的治疗方案");
+            resultJson.put("解读", "酒依赖发展到了严重的程度，躯体依赖可能性很大，并可能出现了与饮酒有关的躯体障碍，如肝脏疾病，应告诫病人彻底戒酒是唯一的治疗方案");
+        }
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap1);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/AHDSCScale.java

@@ -0,0 +1,62 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.dao.model.AnswerEntity;
+import com.rf.psychological.dao.model.DimensionEntity;
+import com.rf.psychological.scale.dao.model.ScaleMarksEntity;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+/**
+ * @author xbw
+ * @description:儿童注意多动缺陷筛查量表
+ * @date 2021/10/29 15:00
+ */
+public class AHDSCScale extends BaseScale{
+    public AHDSCScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (jsonArray.size() > 0){
+            //计算总分
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for(AnswerEntity answerEntity:answerEntities){
+                    if (answerEntity.getQuestionNo().equals(String.valueOf(i+1)) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                        score += Double.valueOf(answerEntity.getScore());
+                    }
+                }
+            }
+
+            DecimalFormat df = new DecimalFormat("######0.00");
+            score = Double.parseDouble(df.format(score / jsonArray.size()));
+            resultMap0.put("AHDSC平均分", String.valueOf(score));
+            resultJson.put("AHDSC平均分", String.valueOf(score));
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/AISScale.java

@@ -0,0 +1,116 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:阿森斯失眠量表
+ * @date 2021/7/20 15:55
+ */
+public class AISScale extends BaseScale{
+
+    public AISScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+        JSONObject jsonObject0 = jsonArray.getJSONObject(0);
+        if (jsonObject0.getString("checkItems").equals("轻微延迟")) {
+            score += 1;
+        } else if (jsonObject0.getString("checkItems").equals("显著延迟")) {
+            score += 2;
+        } else if (jsonObject0.getString("checkItems").equals("延迟严重或没有睡觉")) {
+            score += 3;
+        }
+        JSONObject jsonObject1 = jsonArray.getJSONObject(1);
+        if (jsonObject1.getString("checkItems").equals("轻微影响")) {
+            score += 1;
+        } else if (jsonObject1.getString("checkItems").equals("显著影响")) {
+            score += 2;
+        } else if (jsonObject1.getString("checkItems").equals("严重影响或没有睡觉")) {
+            score += 3;
+        }
+        JSONObject jsonObject2 = jsonArray.getJSONObject(2);
+        if (jsonObject2.getString("checkItems").equals("轻微提早")) {
+            score += 1;
+        } else if (jsonObject2.getString("checkItems").equals("显著提早")) {
+            score += 2;
+        } else if (jsonObject2.getString("checkItems").equals("严重提早或没有睡觉")) {
+            score += 3;
+        }
+        JSONObject jsonObject3 = jsonArray.getJSONObject(3);
+        if (jsonObject3.getString("checkItems").equals("轻微不足")) {
+            score += 1;
+        } else if (jsonObject3.getString("checkItems").equals("显著不足")) {
+            score += 2;
+        } else if (jsonObject3.getString("checkItems").equals("严重不足或没有睡觉")) {
+            score += 3;
+        }
+        JSONObject jsonObject4 = jsonArray.getJSONObject(4);
+        if (jsonObject4.getString("checkItems").equals("轻微不满")) {
+            score += 1;
+        } else if (jsonObject4.getString("checkItems").equals("显著不满")) {
+            score += 2;
+        } else if (jsonObject4.getString("checkItems").equals("严重不满或没有睡觉")) {
+            score += 3;
+        }
+        JSONObject jsonObject5 = jsonArray.getJSONObject(5);
+        if (jsonObject5.getString("checkItems").equals("轻微低落")) {
+            score += 1;
+        } else if (jsonObject5.getString("checkItems").equals("显著低落")) {
+            score += 2;
+        } else if (jsonObject5.getString("checkItems").equals("严重低落")) {
+            score += 3;
+        }
+        JSONObject jsonObject6 = jsonArray.getJSONObject(6);
+        if (jsonObject6.getString("checkItems").equals("轻微影响")) {
+            score += 1;
+        } else if (jsonObject6.getString("checkItems").equals("显著影响")) {
+            score += 2;
+        } else if (jsonObject6.getString("checkItems").equals("严重影响")) {
+            score += 3;
+        }
+        JSONObject jsonObject7 = jsonArray.getJSONObject(7);
+        if (jsonObject7.getString("checkItems").equals("轻微思睡")) {
+            score += 1;
+        } else if (jsonObject7.getString("checkItems").equals("显著思睡")) {
+            score += 2;
+        } else if (jsonObject7.getString("checkItems").equals("严重思睡")) {
+            score += 3;
+        }
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        if (score < 4){
+            resultMap.put("解读", "无睡眠障碍");
+            resultJson.put("解读", "无睡眠障碍");
+        }else if (score >= 4 && score <= 6){
+            resultMap.put("解读", "可疑失眠");
+            resultJson.put("解读", "可疑失眠");
+        }else {
+            resultMap.put("解读", "失眠");
+            resultJson.put("解读", "失眠");
+        }
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName",Constant.SHEET_NAME_AIS);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/AOOScale.java

@@ -0,0 +1,69 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description 容纳他人量表
+ */
+public class AOOScale extends BaseScale {
+    public AOOScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        int score = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (jsonObject1.getString("checkItems").equals("几乎总是")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("大多数总是")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("大多数没有")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("几乎没有")) {
+                    score += 5;
+                }
+            } else {
+                if (jsonObject1.getString("checkItems").equals("几乎总是")) {
+                    score += 5;
+                } else if (jsonObject1.getString("checkItems").equals("大多数总是")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("大多数没有")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("几乎没有")) {
+                    score += 1;
+                }
+            }
+        }
+
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_AOO);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/APIScale.java

@@ -0,0 +1,70 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:Aitken拖延问卷
+ * @date 2021/7/20 15:55
+ */
+public class APIScale extends BaseScale{
+
+    public APIScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score += 5;
+                }
+            } else {
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score += 5;
+                } else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score += 1;
+                }
+            }
+        }
+
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName",Constant.SHEET_NAME_API);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/APIUSScale.java

@@ -0,0 +1,167 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:青少年病理性互联网使用量表
+ * @date 2021/7/20 15:55
+ */
+public class APIUSScale extends BaseScale{
+
+    public APIUSScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("APIUSScale.dll");
+        System.out.println("dllJSONArray:"+jsonArray);
+        System.out.println("dllJSONObject:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.APIUSScale(jsonArray.toString(), resultJson.toString());
+        System.out.println("dllresult:"+result);
+
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("dlljsonObjectc:"+jsonObject);
+        return jsonObject;*/
+
+        //总分
+        double score = 0;
+        //突显性维度得分
+        int score1 = 0;
+        //耐受性维度得分
+        int score2 = 0;
+        //强迫性上网/戒断症状维度得分
+        int score3 = 0;
+        //心境改变维度得分
+        int score4 = 0;
+        //社交抚慰维度得分
+        int score5 = 0;
+        //消极后果维度得分
+        int score6 = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (i == 0 || i == 2 || i == 21){
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score1 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score1 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score1 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score1 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score1 += 5;
+                }
+            }else if (i == 5 || i == 7 || i == 9 || i == 28 || i == 34){
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score2 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score2 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score2 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score2 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score2 += 5;
+                }
+            }else if (i == 16 || i == 19 || i == 22 || i == 23 || i == 25){
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score4 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score4 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score4 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score4 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score4 += 5;
+                }
+            }else if (i == 11 || i == 13 || i == 15 || i == 17 || i == 24 || i == 36){
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score5 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score5 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score5 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score5 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score5 += 5;
+                }
+            }else if (i == 1 || i == 4 || i == 6 || i == 8 || i == 10 || i == 30 || i == 33 || i == 35){
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score6 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score6 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score6 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score6 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score6 += 5;
+                }
+            }else {
+                if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                    score3 += 1;
+                }else if (jsonObject1.getString("checkItems").equals("基本不符合")) {
+                    score3 += 2;
+                }else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                    score3 += 3;
+                }else if (jsonObject1.getString("checkItems").equals("基本符合")) {
+                    score3 += 4;
+                }else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                    score3 += 5;
+                }
+            }
+        }
+        score = score1 + score2 + score3 + score4 + score5 + score6;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        resultMap0.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        if(score/38 < 3){
+            resultMap0.put("解读", "正常群体");
+            resultJson.put("解读", "正常群体");
+        }else if (score/38 < 3.15 && score/38 >= 3 ){
+            resultMap0.put("解读", "PIU边缘群体");
+            resultJson.put("解读", "PIU边缘群体");
+        }else {
+            resultMap0.put("解读", "PIU群体（也可以理解为网络成痛群体）");
+            resultJson.put("解读", "PIU群体（也可以理解为网络成痛群体）");
+        }
+        resultMap0.put("突显性维度分", String.valueOf(score1));
+        resultJson.put("突显性维度分", String.valueOf(score1));
+        resultMap0.put("耐受性维度分", String.valueOf(score2));
+        resultJson.put("耐受性维度分", String.valueOf(score2));
+        resultMap0.put("强迫性上网/戒断症状维度分", String.valueOf(score3));
+        resultJson.put("强迫性上网/戒断症状维度分", String.valueOf(score3));
+        resultMap0.put("心境改变维度分", String.valueOf(score4));
+        resultJson.put("心境改变维度分", String.valueOf(score4));
+        resultMap0.put("社交抚慰维度分", String.valueOf(score5));
+        resultJson.put("社交抚慰维度分", String.valueOf(score5));
+        resultMap0.put("消极后果维度分", String.valueOf(score6));
+        resultJson.put("消极后果维度分", String.valueOf(score6));
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_APIUS);
+        returnJson.put("resultJson",resultJson);
+        System.out.println("resultJson：" + returnJson);
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ARQScale.java

@@ -0,0 +1,58 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+/**
+ * @author zsy
+ * @description:事故风险问卷
+ * @date 2021/11/03 15:55
+ */
+public class ARQScale extends BaseScale {
+    public ARQScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //总得分
+        double score = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("checkItems").equals("非常高")) {
+                score += 1;
+            } else if (jsonObject1.getString("checkItems").equals("高")) {
+                score += 2;
+            } else if (jsonObject1.getString("checkItems").equals("相同")) {
+                score += 3;
+            } else if (jsonObject1.getString("checkItems").equals("低")) {
+                score += 4;
+            } else if (jsonObject1.getString("checkItems").equals("非常低")) {
+                score += 5;
+            }
+        }
+        DecimalFormat df = new DecimalFormat("######0.00");
+        score=Double.parseDouble(df.format(score/10.0));
+            Map<String, String> resultMap = new LinkedHashMap<>();
+            resultMap.put("事故风险问卷总分", String.valueOf(score));
+        resultMap.put("事故风险问卷总分解释", "问卷总分越高，代表驾驶员卷入事故的可能性越低；总分越低，代表驾驶员卷入事故的可能性越高。");
+            resultJson.put("事故风险问卷总分", String.valueOf(score));
+        resultJson.put("事故风险问卷总分解释","问卷总分越高，代表驾驶员卷入事故的可能性越低；总分越低，代表驾驶员卷入事故的可能性越高。");
+            List<Map<String,String>> resultMapList = new ArrayList<>();
+            resultMapList.add(resultMap);
+
+            JSONObject returnJson = new JSONObject(true);
+            returnJson.put("resultMapList",resultMapList);
+            returnJson.put("scaleName", Constant.SHEET_NAME_TSI);
+            returnJson.put("resultJson",resultJson);
+
+            return returnJson;
+
+
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ASASScale.java

@@ -0,0 +1,912 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.dao.dto.scale.NewResultDto;
+import com.rf.psychological.dao.model.DimensionEntity;
+import com.rf.psychological.scale.dao.model.ScaleMarksEntity;
+import com.rf.psychological.scale.scaleresult.ScaleConstant;
+import com.rf.psychological.utils.Constant;
+
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author zsy
+ * @description:青少年学生疏离感量表
+ * @date 2021/7/20 15:55
+ */
+public class ASASScale extends BaseScale {
+
+    public ASASScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("ASASSCALE.dll");
+        System.out.println("JSONArray:"+jsonArray);
+        System.out.println("resultJson:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.ASASScale(jsonArray.toString(), resultJson.toString());
+        //System.out.println("dllresult:"+result);
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("jsonObject:"+jsonObject);
+        return jsonObject;*/
+
+
+        if (!jsonArray.getJSONObject(7).getString("checkItems").equals(jsonArray.getJSONObject(44).getString("checkItems"))
+                || !jsonArray.getJSONObject(11).getString("checkItems").equals(jsonArray.getJSONObject(46).getString("checkItems"))
+                || !jsonArray.getJSONObject(12).getString("checkItems").equals(jsonArray.getJSONObject(16).getString("checkItems"))) {
+            resultJson.put("测试结果指导", "请认真按照实际情况如实回答");
+            JSONObject returnJson = new JSONObject(true);
+            returnJson.put("resultJson", resultJson);
+            return returnJson;
+        }
+        //总得分
+        int score = 0;
+        //总平均分
+        double GPA = 0;
+        //无意义感维度得分
+        int score1 = 0;
+        //自我疏离感维度得分
+        int score2 = 0;
+        //孤独感维度得分
+        int score3 = 0;
+        //自然疏离感维度得分
+        int score4 = 0;
+        //亲人疏离感维度得分
+        int score5 = 0;
+        //生活环境疏离感维度得分
+        int score6 = 0;
+        //社会孤立感得分
+        int score7 = 0;
+        //压迫拘束感维度得分
+        int score8 = 0;
+        //不可控制感维度得分
+        int score9 = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (i == 5 || i == 10 || i == 15 || i == 39 || i == 42 || i == 49) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score1 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score1 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 7;
+                    }
+                } else if (i == 6 || i == 13 || i == 19 || i == 24 || i == 33 || i == 40) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score2 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score2 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 7;
+                    }
+                } else if (i == 2 || i == 8 || i == 22 || i == 38) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score4 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score4 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score4 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score4 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score4 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score4 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score4 += 7;
+                    }
+                } else if (i == 21 || i == 47 || i == 50 || i == 51) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score5 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score5 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score5 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score5 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score5 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score5 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score5 += 7;
+                    }
+                } else if (i == 41 || i == 45 || i == 48) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score6 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score6 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score6 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score6 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score6 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score6 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score6 += 7;
+                    }
+                } else if (i == 1 || i == 18 || i == 26 || i == 29 || i == 34 || i == 43) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score7 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score7 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score7 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score7 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score7 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score7 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score7 += 7;
+                    }
+                } else if (i == 20 || i == 28 || i == 30 || i == 31 || i == 36 || i == 37) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score8 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score8 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score8 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score8 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score8 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score8 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score8 += 7;
+                    }
+                } else if (i == 3 || i == 4 || i == 9 || i == 25) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score9 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score9 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score9 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score9 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score9 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score9 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score9 += 7;
+                    }
+                } else if (i == 7 || i == 44 || i == 11 || i == 46 || i == 12 || i == 16) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score += 7;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score3 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score3 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 7;
+                    }
+                }
+            } else if (jsonObject1.getString("scoreDirection").equals("0")) {
+                if (i == 5 || i == 10 || i == 15 || i == 39 || i == 42 || i == 49) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score1 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score1 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 1;
+                    }
+                } else if (i == 6 || i == 13 || i == 19 || i == 24 || i == 33 || i == 40) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score2 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score2 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 1;
+                    }
+                } else if (i == 2 || i == 8 || i == 22 || i == 38) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score4 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score4 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score4 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score4 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score4 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score4 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score4 += 1;
+                    }
+                } else if (i == 21 || i == 47 || i == 50 || i == 51) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score5 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score5 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score5 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score5 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score5 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score5 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score5 += 1;
+                    }
+                } else if (i == 41 || i == 45 || i == 48) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score6 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score6 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score6 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score6 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score6 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score6 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score6 += 1;
+                    }
+                } else if (i == 1 || i == 18 || i == 26 || i == 29 || i == 34 || i == 43) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score7 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score7 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score7 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score7 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score7 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score7 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score7 += 1;
+                    }
+                } else if (i == 20 || i == 28 || i == 30 || i == 31 || i == 36 || i == 37) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score8 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score8 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score8 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score8 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score8 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score8 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score8 += 1;
+                    }
+                } else if (i == 3 || i == 4 || i == 9 || i == 25) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score9 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score9 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score9 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score9 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score9 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score9 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score9 += 1;
+                    }
+                } else if (i == 7 || i == 44 || i == 11 || i == 46 || i == 12 || i == 16) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score += 1;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score3 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score3 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 1;
+                    }
+                }
+            }
+        }
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        score = score1 + score2 + score3 + score4 + score5 + score6 + score7 + score8 + score9;
+        DecimalFormat df = new DecimalFormat("######0.00");
+        GPA = Double.parseDouble(df.format(score / 52));
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("疏离感总分", String.valueOf(score));
+        resultJson.put("疏离感总分", String.valueOf(score));
+        resultMap.put("疏离感平均分", String.valueOf(GPA));
+        resultJson.put("疏离感平均分", String.valueOf(GPA));
+        if (GPA >= 4) {
+            resultMap.put("解读", "有一定程度的疏离感");
+            resultJson.put("解读", "有一定程度的疏离感");
+        } else {
+            resultMap.put("解读", "疏离感不明显");
+            resultJson.put("解读", "疏离感不明显");
+        }
+        resultMapList.add(resultMap);
+        //得分列表
+        Map<String, String> resultMap1 = new LinkedHashMap<>();
+        resultMap1.put("无意义感维度得分", String.valueOf(score1));
+        resultJson.put("无意义感维度得分", String.valueOf(score1));
+        resultMapList.add(resultMap1);
+        Map<String, String> resultMap2 = new LinkedHashMap<>();
+        resultMap2.put("自我疏离感维度得分", String.valueOf(score2));
+        resultJson.put("自我疏离感维度得分", String.valueOf(score2));
+        resultMapList.add(resultMap2);
+        Map<String, String> resultMap3 = new LinkedHashMap<>();
+        resultMap3.put("孤独感维度得分", String.valueOf(score3));
+        resultJson.put("孤独感维度得分", String.valueOf(score3));
+        resultMapList.add(resultMap3);
+        Map<String, String> resultMap4 = new LinkedHashMap<>();
+        resultMap4.put("自然疏离感维度得分", String.valueOf(score4));
+        resultJson.put("自然疏离感维度得分", String.valueOf(score4));
+        resultMapList.add(resultMap4);
+        Map<String, String> resultMap5 = new LinkedHashMap<>();
+        resultMap5.put("亲人疏离感维度得分", String.valueOf(score5));
+        resultJson.put("亲人疏离感维度得分", String.valueOf(score5));
+        resultMapList.add(resultMap5);
+        Map<String, String> resultMap6 = new LinkedHashMap<>();
+        resultMap6.put("生活环境疏离感维度得分", String.valueOf(score6));
+        resultJson.put("生活环境疏离感维度得分", String.valueOf(score6));
+        resultMapList.add(resultMap6);
+        Map<String, String> resultMap7 = new LinkedHashMap<>();
+        resultMap7.put("社会孤立感得分", String.valueOf(score7));
+        resultJson.put("社会孤立感得分", String.valueOf(score7));
+        resultMapList.add(resultMap7);
+        Map<String, String> resultMap8 = new LinkedHashMap<>();
+        resultMap8.put("压迫拘束感维度得分", String.valueOf(score8));
+        resultJson.put("压迫拘束感维度得分", String.valueOf(score8));
+        resultMapList.add(resultMap8);
+        Map<String, String> resultMap9 = new LinkedHashMap<>();
+        resultMap9.put("不可控制感维度得分", String.valueOf(score9));
+        resultJson.put("不可控制感维度得分", String.valueOf(score9));
+        resultMapList.add(resultMap9);
+        Map<String, String> resultMap10 = new LinkedHashMap<>();
+        resultMap10.put("社会疏离感得分", String.valueOf(score1 + score2 + score7 + score8));
+        resultJson.put("社会疏离感得分", String.valueOf(score1 + score2 + score7 + score8));
+        resultMapList.add(resultMap10);
+        Map<String, String> resultMap11 = new LinkedHashMap<>();
+        resultMap11.put("人际疏离感得分", String.valueOf(score3 + score5 + score9));
+        resultJson.put("人际疏离感得分", String.valueOf(score3 + score5 + score9));
+        resultMapList.add(resultMap11);
+        Map<String, String> resultMap12 = new LinkedHashMap<>();
+        resultMap12.put("环境疏离感得分", String.valueOf(score4 + score6));
+        resultJson.put("环境疏离感得分", String.valueOf(score4 + score6));
+        resultMapList.add(resultMap12);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_ASAS);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+
+    public JSONObject scaleCalculateV2() throws Exception {
+
+        if (!jsonArray.getJSONObject(7).getString("checkItems").equals(jsonArray.getJSONObject(44).getString("checkItems"))
+                || !jsonArray.getJSONObject(11).getString("checkItems").equals(jsonArray.getJSONObject(46).getString("checkItems"))
+                || !jsonArray.getJSONObject(12).getString("checkItems").equals(jsonArray.getJSONObject(16).getString("checkItems"))) {
+            resultJson.put("测试结果指导", "请认真按照实际情况如实回答");
+            JSONObject returnJson = new JSONObject(true);
+            returnJson.put("resultJson", resultJson);
+            return returnJson;
+        }
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //总得分
+        int score = 0;
+        //总平均分
+        double GPA = 0;
+        //无意义感维度得分
+        int score1 = 0;
+        //自我疏离感维度得分
+        int score2 = 0;
+        //孤独感维度得分
+        int score3 = 0;
+        //自然疏离感维度得分
+        int score4 = 0;
+        //亲人疏离感维度得分
+        int score5 = 0;
+        //生活环境疏离感维度得分
+        int score6 = 0;
+        //社会孤立感得分
+        int score7 = 0;
+        //压迫拘束感维度得分
+        int score8 = 0;
+        //不可控制感维度得分
+        int score9 = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (i == 5 || i == 10 || i == 15 || i == 39 || i == 42 || i == 49) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score1 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score1 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 7;
+                    }
+                } else if (i == 6 || i == 13 || i == 19 || i == 24 || i == 33 || i == 40) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score2 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score2 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 7;
+                    }
+                } else if (i == 2 || i == 8 || i == 22 || i == 38) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score4 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score4 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score4 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score4 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score4 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score4 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score4 += 7;
+                    }
+                } else if (i == 21 || i == 47 || i == 50 || i == 51) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score5 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score5 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score5 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score5 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score5 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score5 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score5 += 7;
+                    }
+                } else if (i == 41 || i == 45 || i == 48) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score6 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score6 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score6 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score6 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score6 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score6 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score6 += 7;
+                    }
+                } else if (i == 1 || i == 18 || i == 26 || i == 29 || i == 34 || i == 43) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score7 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score7 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score7 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score7 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score7 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score7 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score7 += 7;
+                    }
+                } else if (i == 20 || i == 28 || i == 30 || i == 31 || i == 36 || i == 37) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score8 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score8 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score8 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score8 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score8 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score8 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score8 += 7;
+                    }
+                } else if (i == 3 || i == 4 || i == 9 || i == 25) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score9 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score9 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score9 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score9 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score9 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score9 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score9 += 7;
+                    }
+                } else if (i == 7 || i == 44 || i == 11 || i == 46 || i == 12 || i == 16) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score += 7;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score3 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score3 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 7;
+                    }
+                }
+            } else if (jsonObject1.getString("scoreDirection").equals("0")) {
+                if (i == 5 || i == 10 || i == 15 || i == 39 || i == 42 || i == 49) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score1 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score1 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score1 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score1 += 1;
+                    }
+                } else if (i == 6 || i == 13 || i == 19 || i == 24 || i == 33 || i == 40) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score2 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score2 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score2 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score2 += 1;
+                    }
+                } else if (i == 2 || i == 8 || i == 22 || i == 38) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score4 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score4 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score4 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score4 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score4 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score4 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score4 += 1;
+                    }
+                } else if (i == 21 || i == 47 || i == 50 || i == 51) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score5 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score5 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score5 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score5 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score5 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score5 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score5 += 1;
+                    }
+                } else if (i == 41 || i == 45 || i == 48) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score6 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score6 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score6 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score6 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score6 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score6 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score6 += 1;
+                    }
+                } else if (i == 1 || i == 18 || i == 26 || i == 29 || i == 34 || i == 43) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score7 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score7 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score7 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score7 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score7 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score7 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score7 += 1;
+                    }
+                } else if (i == 20 || i == 28 || i == 30 || i == 31 || i == 36 || i == 37) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score8 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score8 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score8 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score8 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score8 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score8 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score8 += 1;
+                    }
+                } else if (i == 3 || i == 4 || i == 9 || i == 25) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score9 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score9 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score9 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score9 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score9 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score9 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score9 += 1;
+                    }
+                } else if (i == 7 || i == 44 || i == 11 || i == 46 || i == 12 || i == 16) {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score += 1;
+                    }
+                } else {
+                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
+                        score3 += 7;
+                    } else if (jsonObject1.getString("checkItems").equals("比较不符合")) {
+                        score3 += 6;
+                    } else if (jsonObject1.getString("checkItems").equals("有点不符合")) {
+                        score3 += 5;
+                    } else if (jsonObject1.getString("checkItems").equals("不确定")) {
+                        score3 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                        score3 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                        score3 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
+                        score3 += 1;
+                    }
+                }
+            }
+        }
+
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        score = score1 + score2 + score3 + score4 + score5 + score6 + score7 + score8 + score9;
+        DecimalFormat df = new DecimalFormat("######0.00");
+        GPA = Double.parseDouble(df.format(score / 52));
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("疏离感总分", String.valueOf(score));
+        resultJson.put("疏离感总分", String.valueOf(score));
+        resultMap.put("疏离感平均分", String.valueOf(GPA));
+        resultJson.put("疏离感平均分", String.valueOf(GPA));
+        newResultDtos.add(new NewResultDto("总分", String.valueOf(score), "无", "无", "无",
+                "无", "无", "无", "是"));
+        newResultDtos.add(new NewResultDto("平均分", String.valueOf(GPA), "无", "无", "无",
+                "无", "无", "无", "否"));
+        if (GPA >= 4) {
+            resultMap.put("解读", "有一定程度的疏离感");
+            resultJson.put("解读", "有一定程度的疏离感");
+        } else {
+            resultMap.put("解读", "疏离感不明显");
+            resultJson.put("解读", "疏离感不明显");
+        }
+
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "无意义感维度", score1, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "自我疏离感维度", score2, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "孤独感维度", score3, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "自然疏离感维度", score4, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "亲人疏离感维度", score5, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "生活环境疏离感维度", score6, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "社会孤立感维度", score7, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "压迫拘束感维度", score8, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        NEWCOMMONScale.commonComputeDimensionScore(null, resultMap, resultJson, "不可控制感维度", score9, true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+        if (!reference.stream().allMatch("0"::equals)) {
+            iconInfo.put("reference", reference);
+        }
+        iconInfo.put("scoreList", scoreList);
+        if (indicator.size() == 0 && reference.size() == 0) {
+            newResult.put("iconInfo", "");
+        } else {
+            newResult.put("iconInfo", iconInfo);
+        }
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_ASAS);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+
+
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ASScale.java

@@ -0,0 +1,89 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:情感量表
+ * @date 2021/7/20 15:55
+ */
+public class ASScale extends BaseScale{
+
+    public ASScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("ASScale.dll");
+        System.out.println("dllJSONArray:"+jsonArray);
+        System.out.println("dllJSONObject:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.ASScale(jsonArray.toString(), resultJson.toString());
+        System.out.println("dllresult:"+result);
+
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("dlljsonObjectc:"+jsonObject);
+        return jsonObject;*/
+
+        //情感平衡得分
+        int score = 0;
+        //正向情感得分
+        int score1 = 0;
+        //负向情感得分
+        int score2 = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (i % 2 == 0){
+                if (jsonObject1.getString("scoreDirection").equals("1")) {
+                    if (jsonObject1.getString("checkItems").equals("是")) {
+                        score1 += 1;
+                    }
+                } else if (jsonObject1.getString("scoreDirection").equals("0")){
+                    if (jsonObject1.getString("checkItems").equals("否")) {
+                        score1 += 1;
+                    }
+                }
+            }else {
+                if (jsonObject1.getString("scoreDirection").equals("1")) {
+                    if (jsonObject1.getString("checkItems").equals("是")) {
+                        score2 += 1;
+                    }
+                } else if (jsonObject1.getString("scoreDirection").equals("0")){
+                    if (jsonObject1.getString("checkItems").equals("否")) {
+                        score2 += 1;
+                    }
+                }
+            }
+        }
+        score = score1 - score2 + 5;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        resultMap0.put("情感平衡得分", String.valueOf(score));
+        resultJson.put("情感平衡得分", String.valueOf(score));
+        resultMap0.put("正向情感得分", String.valueOf(score1));
+        resultJson.put("正向情感得分", String.valueOf(score1));
+        resultMap0.put("负向情感得分", String.valueOf(score2));
+        resultJson.put("负向情感得分", String.valueOf(score2));
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_AS);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/ATOScale.java

@@ -0,0 +1,70 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:自动思维量表
+ * @date 2021/7/20 15:55
+ */
+public class ATOScale extends BaseScale{
+
+    public ATOScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (jsonObject1.getString("checkItems").equals("无")) {
+                    score += 1;
+                } else if (jsonObject1.getString("checkItems").equals("偶尔出现")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("有时出现")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("经常出现")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("持续存在")) {
+                    score += 5;
+                }
+            } else if (jsonObject1.getString("scoreDirection").equals("0")){
+                if (jsonObject1.getString("checkItems").equals("无")) {
+                    score += 5;
+                } else if (jsonObject1.getString("checkItems").equals("偶尔出现")) {
+                    score += 4;
+                } else if (jsonObject1.getString("checkItems").equals("有时出现")) {
+                    score += 3;
+                } else if (jsonObject1.getString("checkItems").equals("经常出现")) {
+                    score += 2;
+                } else if (jsonObject1.getString("checkItems").equals("持续存在")) {
+                    score += 1;
+                }
+
+            }
+        }
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName",Constant.SHEET_NAME_ATO);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/AUDITScale.java

@@ -0,0 +1,135 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:酒精依赖疾患识别测验
+ * @date 2021/7/20 15:55
+ */
+public class AUDITScale extends BaseScale{
+
+    public AUDITScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("AUDITScale.dll");
+        System.out.println("JSONArray:"+jsonArray);
+        System.out.println("resultJson:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.AUDITScale(jsonArray.toString(), resultJson.toString());
+        //System.out.println("dllresult:"+result);
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("jsonObject:"+jsonObject);
+        return jsonObject;*/
+
+        //得分
+        int score = 0;
+        int [] scores = {0,0,0,0,0,0,0,0,0,0};
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (i == 0){
+                if (jsonObject1.getString("checkItems").equals("每月约一次")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("每月2-4次")) {
+                    scores[i] = 2;
+                } else if (jsonObject1.getString("checkItems").equals("每周2-3次")) {
+                    scores[i] = 3;
+                } else if (jsonObject1.getString("checkItems").equals("每周4次以上")) {
+                    scores[i] = 4;
+                }
+            }else if (i == 1){
+                if (jsonObject1.getString("checkItems").equals("3或4")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("5或6")) {
+                    scores[i] = 2;
+                } else if (jsonObject1.getString("checkItems").equals("7到9")) {
+                    scores[i] = 3;
+                } else if (jsonObject1.getString("checkItems").equals("10以上")) {
+                    scores[i] = 4;
+                }
+            }else if (i == 2){
+                if (jsonObject1.getString("checkItems").equals("每月不到一次")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("每月一次")) {
+                    scores[i] = 2;
+                } else if (jsonObject1.getString("checkItems").equals("几乎每周一次")) {
+                    scores[i] = 3;
+                } else if (jsonObject1.getString("checkItems").equals("每天或几乎每天")) {
+                    scores[i] = 4;
+                }
+            }else if (i == 3 || i == 4){
+                if (jsonObject1.getString("checkItems").equals("每月不到一次")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("每月一次")) {
+                    scores[i] = 2;
+                } else if (jsonObject1.getString("checkItems").equals("几乎每周一次")) {
+                    scores[i] = 3;
+                } else if (jsonObject1.getString("checkItems").equals("每天或几乎每天一次")) {
+                    scores[i] = 4;
+                }
+            }else if (i == 5 || i == 6 || i == 7){
+                if (jsonObject1.getString("checkItems").equals("每月不到一次")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("每月一次")) {
+                    scores[i] = 2;
+                } else if (jsonObject1.getString("checkItems").equals("每周一次")) {
+                    scores[i] = 3;
+                } else if (jsonObject1.getString("checkItems").equals("每天或几乎每天一次")) {
+                    scores[i] = 4;
+                }
+            }else if (i == 8){
+                if (jsonObject1.getString("checkItems").equals("有，但不在过去一年")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("有，是在过去的一年中")) {
+                    scores[i] = 2;
+                }
+            }else if (i == 9){
+                if (jsonObject1.getString("checkItems").equals("有，但不在过去的一年")) {
+                    scores[i] = 1;
+                } else if (jsonObject1.getString("checkItems").equals("有，是在过去的一年中")) {
+                    scores[i] = 2;
+                }
+            }
+        }
+
+        score = scores[0] + scores[1] +scores[2] +scores[3] +scores[4] +scores[5] +scores[6] +scores[7] +scores[8] +scores[9];
+        Map<String, String> resultMap1 = new LinkedHashMap<>();
+        resultMap1.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        if (score >= 8){
+            resultMap1.put("解读", "酒精依赖阳性患者");
+            resultJson.put("解读", "酒精依赖阳性患者");
+        }
+        if (scores[0] > 3 && scores[1] > 3 && scores[2] > 3 && scores[3] <= 3 && scores[4] <= 3 && scores[5] <= 3 && scores[6] <= 3 && scores[7]<= 3){
+            resultMap1.put("提示", "严重危害性饮酒");
+            resultJson.put("提示", "严重危害性饮酒");
+        }else if (scores[0] <= 3 && scores[1] <= 3 && scores[2] <= 3 && scores[3] > 3 && scores[4] > 3 && scores[5] > 3 && scores[6] <= 3 && scores[7]<= 3){
+            resultMap1.put("提示", "酒精依赖");
+            resultJson.put("提示", "酒精依赖");
+        }
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap1);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_AUDIT);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/BDIScale.java

@@ -0,0 +1,95 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.scale.dao.model.ScaleEntity;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:贝克抑郁自评量表
+ * @date 2021/7/20 15:55
+ */
+public class BDIScale extends BaseScale{
+
+    public BDIScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+        List<ScaleEntity> scaleEntities = (List<ScaleEntity>) resultJson.get("scaleEntities");
+        //答题结果列表
+        List<ScaleEntity> dataList = new ArrayList<>();
+        List<ScaleEntity> resultDataList = jsonArray.toJavaList(ScaleEntity.class);
+        int x = 0;
+        for (ScaleEntity scaleEntity:resultDataList){
+            scaleEntity.setAnswer(scaleEntities.get(x).getCheckItems());
+            dataList.add(scaleEntity);
+            x ++;
+        }
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            String[] split = scaleEntities.get(i).getCheckItems().split("；");
+            if (jsonObject1.getString("scoreDirection").equals("1")){
+                for (int y = 0; y < split.length; y++){
+                    if (jsonObject1.getString("checkItems").equals(split[y])){
+                        switch (y){
+                            case 1:{
+                                score += 1;
+                                break;
+                            }
+                            case 2:{
+                                score += 2;
+                                break;
+                            }
+                            case 3:{
+                                score += 3;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }else {
+                for (int y = 0; y < split.length; y++){
+                    if (jsonObject1.getString("checkItems").equals(split[y])){
+                        switch (y){
+                            case 0:{
+                                score += 3;
+                                break;
+                            }
+                            case 1:{
+                                score += 2;
+                                break;
+                            }
+                            case 2:{
+                                score += 1;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName",Constant.SHEET_NAME_BDI);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/BDQScale.java

@@ -0,0 +1,67 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.psychological.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description 双相情感障碍自评量表
+ */
+public class BDQScale extends BaseScale {
+    public BDQScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+
+            if (jsonObject1.getString("checkItems").equals("完全不符或几乎不符")) {
+                score += 0;
+            } else if (jsonObject1.getString("checkItems").equals("稍微符合")) {
+                score += 1;
+            } else if (jsonObject1.getString("checkItems").equals("有点符合")) {
+                score += 2;
+            } else if (jsonObject1.getString("checkItems").equals("比较符合")) {
+                score += 3;
+            } else if (jsonObject1.getString("checkItems").equals("较多符合")) {
+                score += 4;
+            } else if (jsonObject1.getString("checkItems").equals("非常符合或完全符合")) {
+                score += 5;
+            }
+        }
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+
+        if (score <= 15 && score >= 0) {
+            resultMap.put("解读", "经过检测您为【单相抑郁】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+            resultJson.put("解读", "经过检测您为【单相抑郁】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+        } else if (score <= 24 && score >= 16) {
+            resultMap.put("解读", "经过检测您为【重抑郁轻躁狂】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+            resultJson.put("解读", "经过检测您为【重抑郁轻躁狂】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+        } else if (score <= 60 && score >= 25) {
+            resultMap.put("解读", "经过检测您为【双相情感障碍】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+            resultJson.put("解读", "经过检测您为【双相情感障碍】，为了您和家人的幸福，建议您联系我们，进行更专业的检测。（以上测试结果仅供参考）");
+        }
+
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_BDQ);
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/psychological/scale/resultBusiness/scaleResult/BaseScale.java

@@ -0,0 +1,19 @@
+package com.rf.psychological.scale.resultBusiness.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/7/20 15:55
+ */
+public class BaseScale {
+    public JSONArray jsonArray;
+    public JSONObject resultJson;
+
+    public BaseScale(JSONArray jsonArray, JSONObject resultJson){
+        this.jsonArray = jsonArray;
+        this.resultJson = resultJson;
+    }
+}

src/main/java/com/rf/psychological/scale/service/AnswerService.java

@@ -0,0 +1,32 @@
+package com.rf.psychological.scale.service;
+
+import com.rf.psychological.dao.model.AnswerEntity;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:49
+ */
+public interface AnswerService {
+    /**
+     * 根据flag获取全部答案
+     * @param flag
+     */
+    List<AnswerEntity> getAnswerByFlag(String flag);
+
+    /**
+     * 保存
+     * @param answerEntity
+     */
+    void saveAnswer(AnswerEntity answerEntity);
+
+    void saveBatchAnswer(List<AnswerEntity> answerEntity);
+
+    List<AnswerEntity> findAll();
+
+    void updateAnswer(AnswerEntity answerEntity);
+
+    void deleteAnswerByFlag(String flag);
+}

src/main/java/com/rf/psychological/scale/service/impl/AnswerServiceImpl.java

@@ -0,0 +1,67 @@
+package com.rf.psychological.scale.service.impl;
+
+import com.rf.psychological.dao.model.AnswerEntity;
+import com.rf.psychological.scale.dao.repository.AnswerRepository;
+import com.rf.psychological.scale.service.AnswerService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:51
+ */
+@Service
+@Slf4j
+public class AnswerServiceImpl implements AnswerService {
+    @Autowired
+    private AnswerRepository answerRepository;
+
+
+    /**
+     * 根据flag获取全部答案
+     *
+     * @param flag
+     */
+    @Override
+    public List<AnswerEntity> getAnswerByFlag(String flag) {
+        return this.answerRepository.getAnswerByFlag(flag);
+    }
+
+
+    /**
+     * 保存
+     *
+     * @param answerEntity
+     */
+    @Override
+    public void saveAnswer(AnswerEntity answerEntity) {
+        //数据加密
+        //answerEntity.encrypt();
+        this.answerRepository.save(answerEntity);
+    }
+
+    @Override
+    public void saveBatchAnswer(List<AnswerEntity> answerEntity) {
+
+        this.answerRepository.saveAll(answerEntity);
+    }
+
+    @Override
+    public List<AnswerEntity> findAll() {
+        return answerRepository.findAll();
+    }
+
+    @Override
+    public void updateAnswer(AnswerEntity answerEntity) {
+        answerRepository.updateAnswer(answerEntity.getName(),answerEntity.getScore(),answerEntity.getId());
+    }
+
+    @Override
+    public void deleteAnswerByFlag(String flag) {
+        this.answerRepository.deleteAnswerByFlag(flag);
+    }
+
+}

src/main/java/com/rf/psychological/security/AesEncryptUtils.java

@@ -0,0 +1,92 @@
+package com.rf.psychological.security;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.codec.binary.Hex;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/8/4 15:27
+ */
+public class AesEncryptUtils {
+
+
+    private static final String KEY = "Sp5biS+gX+#CqAFF";
+
+    private static final String OFFSET = "ud2E8l6wchltwIDA";
+
+    //参数分别代表 算法名称/加密模式/数据填充方式
+    private static final String ALGORITHMSTR = "AES/CBC/PKCS5Padding";
+
+    /**
+     * 加密
+     * @param content 加密的字符串
+     * @param encryptKey key值
+     * @return
+     * @throws Exception
+     */
+    public static String encrypt(String content, String encryptKey) throws Exception {
+
+        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
+        SecretKeySpec secretKeySpec =  new SecretKeySpec(encryptKey.getBytes(), "AES");
+        IvParameterSpec iv = new IvParameterSpec(OFFSET.getBytes());
+        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec,iv);
+        byte[] b = cipher.doFinal(content.getBytes("utf-8"));
+        // 采用base64算法进行转码,避免出现中文乱码
+//        return Base64.encodeBase64String(b);
+//        HEX转码
+        return Hex.encodeHexString(b);
+
+
+    }
+
+    /**
+     * 解密
+     * @param encryptStr 解密的字符串
+     * @param decryptKey 解密的key值
+     * @return
+     * @throws Exception
+     */
+    public static String decrypt(String encryptStr, String decryptKey) throws Exception {
+
+        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
+        SecretKeySpec skeySpec = new SecretKeySpec(KEY.getBytes("ASCII"), "AES");
+        IvParameterSpec iv = new IvParameterSpec(OFFSET.getBytes());
+        cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
+        // 采用base64算法进行转码,避免出现中文乱码
+        // byte[] encryptBytes = Base64.decodeBase64(encryptStr);
+        //        HEX转码
+        byte [] encryptBytes =  Hex.decodeHex(encryptStr);
+        byte[] decryptBytes = cipher.doFinal(encryptBytes);
+        return new String(decryptBytes);
+    }
+
+    public static String encrypt(String content) throws Exception {
+        return encrypt(content, KEY);
+    }
+    public static String decrypt(String encryptStr) throws Exception {
+        return decrypt(encryptStr, KEY);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Map map=new HashMap<String,String>();
+        map.put("key","value");
+        map.put("中文","汉字");
+        String content = JSONObject.toJSONString(map);
+        System.out.println("加密前：" + content);
+
+        String encrypt = encrypt(content, KEY);
+        System.out.println("加密后：" + encrypt);
+
+        String decrypt = decrypt(encrypt, KEY);
+        System.out.println("解密后：" + decrypt);
+    }
+}

src/main/java/com/rf/psychological/service/ASKService.java

@@ -0,0 +1,18 @@
+package com.rf.psychological.service;
+
+import com.rf.psychological.dao.model.ASKEntity;
+
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:41
+ */
+public interface ASKService {
+    /**
+     * 全量查询
+     * @return
+     */
+    List<ASKEntity> findAll();
+}

src/main/java/com/rf/psychological/service/AviationService.java

@@ -0,0 +1,18 @@
+package com.rf.psychological.service;
+
+import com.rf.psychological.dao.model.AviationEntity;
+
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:50
+ */
+public interface AviationService {
+    /**
+     * 全量查询
+     * @return
+     */
+    List<AviationEntity> findAll();
+}

src/main/java/com/rf/psychological/service/impl/ASKServiceImpl.java

@@ -0,0 +1,30 @@
+package com.rf.psychological.service.impl;
+
+import com.rf.psychological.dao.model.ASKEntity;
+import com.rf.psychological.dao.repository.ASKRepository;
+import com.rf.psychological.service.ASKService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:41
+ */
+@Service
+public class ASKServiceImpl implements ASKService {
+    @Autowired
+    private ASKRepository askRepository;
+    /**
+     * 全量查询
+     *
+     * @return
+     */
+    @Override
+    public List<ASKEntity> findAll() {
+        return this.askRepository.findAll(Sort.by("no"));
+    }
+}

src/main/java/com/rf/psychological/service/impl/AviationServiceImpl.java

@@ -0,0 +1,30 @@
+package com.rf.psychological.service.impl;
+
+import com.rf.psychological.dao.model.AviationEntity;
+import com.rf.psychological.dao.repository.AviationRepository;
+import com.rf.psychological.service.AviationService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/20 17:50
+ */
+@Service
+
+public class AviationServiceImpl implements AviationService {
+    @Autowired
+    private AviationRepository aviationRepository;
+    /**
+     * 全量查询
+     *
+     * @return
+     */
+    @Override
+    public List<AviationEntity> findAll() {
+        return this.aviationRepository.findAll();
+    }
+}

src/main/java/com/rf/psychological/utils/AgeUtil.java

@@ -0,0 +1,58 @@
+package com.rf.psychological.utils;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+public class AgeUtil {
+
+    public static  Date parse(String strDate) throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        return sdf.parse(strDate);
+    }
+    //由出生日期获得年龄
+    public static  double getAge(String Birthday) throws Exception {
+        Date birthDay = parse(Birthday);
+        Calendar cal = Calendar.getInstance();
+        if (cal.before(birthDay)) { //出生日期晚于当前时间，无法计算
+            throw new IllegalArgumentException(
+                    "The birthDay is before Now.It's unbelievable!");
+        }
+        int yearNow = cal.get(Calendar.YEAR);  //当前年份
+        int monthNow = cal.get(Calendar.MONTH);  //当前月份
+        int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH); //当前日期
+        cal.setTime(birthDay);
+        int yearBirth = cal.get(Calendar.YEAR);
+        int monthBirth = cal.get(Calendar.MONTH);
+        int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
+        double age = yearNow - yearBirth;   //计算整岁数
+        if (monthNow < monthBirth) {
+            age -= 0.5;
+        }else if (monthNow > monthBirth){
+            age += 0.5;
+        }
+        /*if (monthNow <= monthBirth) {
+            if (monthNow == monthBirth) {
+                if (dayOfMonthNow < dayOfMonthBirth) age--;//当前日期在生日之前，年龄减一
+            }else{
+                age -= 0.5;//当前月份在生日之前，年龄减一
+            }
+        }*/
+        return age;
+    }
+
+    public static void main(String args[]) {
+        try {
+            double  age = getAge("2001-07-21");
+            System.out.println("age=="+age);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+
+    }
+}
+

src/main/java/com/rf/psychological/utils/AssertUtils.java

@@ -0,0 +1,324 @@
+package com.rf.psychological.utils;
+
+import java.util.*;
+
+/**
+ * @Author:zzf
+ * @Date:2022/6/15:10:58
+ * @Description:断言，取代代码中错综复杂的if-else条件控制语句
+ */
+
+public class AssertUtils {
+    /**
+     * 功能描述:
+     * 〈判断数组是否为空〉
+     */
+    public static <T> boolean isEmpty(T[] obj) {
+        return null == obj || 0 == obj.length;
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断数组是否不为空〉
+     */
+    public static <T> boolean isNotEmpty(T[] obj) {
+        return !isEmpty(obj);
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断对象是否为空〉
+     */
+    public static boolean isEmpty(Object obj) {
+        return null == obj;
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断对象是否不为空〉
+     */
+    public static boolean isNotEmpty(Object obj) {
+        return !isEmpty(obj);
+    }
+
+    /**
+     * 功能描述:
+     * 〈字符串是否为空〉
+     */
+    public static boolean isEmpty(String str) {
+        return null == str || "".equals(str);
+    }
+
+    /**
+     * 功能描述:
+     * 〈字符串是否不为空〉
+     */
+    public static boolean isNotEmpty(String str) {
+        return !isEmpty(str);
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断集合是否为空〉
+     */
+    public static boolean isEmpty(Collection obj) {
+        return null == obj || obj.isEmpty();
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断集合是否不为空〉
+     */
+    public static boolean isNotEmpty(Collection obj) {
+        return !isEmpty(obj);
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断map集合是否为空〉
+     */
+    public static boolean isEmpty(Map obj) {
+        return null == obj || obj.isEmpty();
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断map集合是否不为空〉
+     */
+    public static boolean isNotEmpty(Map obj) {
+        return !isEmpty(obj);
+    }
+
+    /**
+     * 功能描述:
+     * 〈char数值是否是数字〉
+     */
+    public static boolean charIsNumb(int charValue) {
+        return charValue >= 48 && charValue <= 57 || charValue >= 96 && charValue <= 105;
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断字符串是否是纯数字浮点类型〉
+     */
+    public static boolean isFloat(String s) {
+        if(!(s.indexOf(".") > -1)){
+            return false;
+        }
+        char[] chars = s.toCharArray();
+        boolean flag = true;
+        for (char aChar : chars) {
+            if(aChar != 46){
+                if(!(aChar >= 48 && aChar <= 57 || aChar >= 96 && aChar <= 105)){
+                    flag = false;
+                    break;
+                }
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * 功能描述:
+     * 〈非纯数字浮点类型〉
+     */
+    public static boolean isNotFloat(String s) {
+        return !isFloat(s);
+    }
+    /**
+     * 功能描述:
+     * 〈字符串是否是数字〉
+     */
+    public static boolean isNumb(String str) {
+        if (isEmpty((Object)str)) {
+            return false;
+        } else {
+            char[] chr = str.toCharArray();
+
+            for(int i = 0; i < chr.length; ++i) {
+                if (chr[i] < '0' || chr[i] > '9') {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断字符串是否不是数字〉
+     */
+    public static boolean isNotNumb(String str) {
+        return !isNumb(str);
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断字符串是否有长度,并自定义异常信息〉
+     */
+    public static void hasLength(String str, String msg) {
+        if (str == null || str.length() < 1) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    /**
+     * 功能描述:
+     * 〈自定义参数校验异常〉
+     */
+    public static void paramCheck(String msg,Object...obj) {
+        for (Object o : obj) {
+            // 参数异常
+            if(isEmpty(o)){
+                throw new RuntimeException(msg);
+            }
+        }
+    }
+
+    /**
+     * 功能描述:
+     * 〈可变参数,判断是否所有对象都为空〉
+     */
+    public static boolean isAllEmpty(Object... obj) {
+        Object[] var1 = obj;
+        int var2 = obj.length;
+
+        for(int var3 = 0; var3 < var2; ++var3) {
+            Object o = var1[var3];
+            if (!isEmpty(o)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 功能描述:
+     * 〈可变参数-判断只要有任意一个对象为空,则为true〉
+     */
+    public static boolean isAnyEmpty(Object... obj) {
+        Object[] var1 = obj;
+        int var2 = obj.length;
+
+        for(int var3 = 0; var3 < var2; ++var3) {
+            Object o = var1[var3];
+            if (isEmpty(o)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 功能描述:
+     * 〈可变参数 -判断是否所有参数都不为空〉
+     */
+    public static boolean isAllNotEmpty(Object... obj) {
+        Object[] var1 = obj;
+        int var2 = obj.length;
+
+        for(int var3 = 0; var3 < var2; ++var3) {
+            Object o = var1[var3];
+            if (isEmpty(o)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断是否两个对象相等〉
+     */
+    public static boolean isEqual(Object o1, Object o2) {
+        if (o1 == null) {
+            return o2 == null;
+        } else if (o2 == null) {
+            return false;
+        } else if (o1.getClass().isArray()) {
+            for(int i = 0; i < ((Object[])((Object[])o1)).length; ++i) {
+                if (!isEqual(((Object[])((Object[])o1))[i], ((Object[])((Object[])o2))[i])) {
+                    return false;
+                }
+            }
+            return true;
+        } else if (Collection.class.isAssignableFrom(o1.getClass())) {
+            Iterator i1 = ((Collection)o1).iterator();
+            Iterator i2 = ((Collection)o2).iterator();
+            if (((Collection)o1).size() != ((Collection)o2).size()) {
+                return false;
+            } else {
+                for(int i = 0; i < ((Collection)o1).size(); ++i) {
+                    if (!isEqual(i1.next(), i2.next())) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        } else if (!Map.class.isAssignableFrom(o1.getClass())) {
+            return o1.equals(o2);
+        } else {
+            Map<Object, Object> m1 = (Map)o1;
+            Map<Object, Object> m2 = (Map)o2;
+            if (m1.size() != m2.size()) {
+                return false;
+            } else if (!isEqual(m1.keySet(), m2.keySet())) {
+                return false;
+            } else {
+                Iterator var4 = m1.entrySet().iterator();
+
+                Map.Entry o;
+                do {
+                    if (!var4.hasNext()) {
+                        return true;
+                    }
+
+                    o = (Map.Entry)var4.next();
+                } while(m2.containsKey(o.getKey()) && isEqual(o.getValue(), m2.get(o.getKey())));
+
+                return false;
+            }
+        }
+    }
+
+    /**
+     * 功能描述:
+     * 〈判断两个对象是否不相等〉
+     */
+    public static boolean isNotEqual(Object o1, Object o2) {
+        return !isEqual(o1,o2);
+    }
+
+    /**
+     * 功能描述:
+     * 〈比较两个集合是否相等〉
+     */
+    public static boolean compare(List<Comparable> l1, List<Comparable> l2) {
+        if (l1 != null && !l1.isEmpty()) {
+            if (l2 != null && !l2.isEmpty()) {
+                Collections.sort(l1);
+                Collections.sort(l2);
+                if (l1.size() != l2.size()) {
+                    return false;
+                } else {
+                    for(int i = 0; i < l1.size(); ++i) {
+                        if (((Comparable)l1.get(i)).compareTo(l2.get(i)) != 0) {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        } else {
+            return l2 == null || l2.isEmpty();
+        }
+    }
+
+
+
+}
+
+

src/main/resources/apiclient_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC6U1RL+Msu0oUi
+lIH5as0MAtb9wUtbgZI4Lqa4p5XwsAUFXcCJob5RnZEStHH2TK4W0VEENp0psp8F
+FntmIJsyMAODu4Wt97OZ29mn9/qVYnPC4QGVfor5t9oPo5UtMa/KLqCMZbMhC0kT
+iq2q7uvmR6D9mV3VmOqi7KKeX65aYgo1VPH5EjzO4okpk3yes1KkDGQfYubPoZot
+v//7Ca07ZnFX8/NKY3a8d/VTIuUW1DzPMwplt6H/oN5+H04xfLxe5MZvq+YEPx2U
+zHMO1of1WWPUAotbgMO4CwqbVHoX+9H4LlTP3hhxtORO3p0qE4txXMBvrHWuqf3h
+rZnA5pPrAgMBAAECggEASpIRGbq/7sRYfkd7YUwqNlVon/RdaYkI8S1SknKX4tU/
+nS8xYKP4HIf4SMkpFw8HWaB6UTpeWhLf69RcnLoOAt8OeQly7fZFzh0cFkp74o+d
+jvAohyE3E8xOHJY2nPjWxw80OBx3vZDbtVN6QAARL3+ZYgWgdV0XAw+74bCfghIt
+3kDX+85Fgp4TE0B23hrVeuwUVZQgA2UmfqejYj0+58rHkDetONLB7S4ylN7qtH5K
+hnRs1z2mrGM0U31dHlQqCzqTd/dNIvHmp9OTF5pkLvXKGVQLtQzWsyH+8uJhdleU
+z7KOkDTK/4oZX6I//s4akBTP+me6uXqm0WuEikRRGQKBgQDih/n3ET/jOoUgyVAu
+1hDBC70J+5SC/Ky6ZWIMqXu036af7tMeOO/ldgtwOOHrQ3JMGQsoIgm0TjzIvrr6
+AYt00rJM7RRAJzi5oNqYxvAMiVu/ic5sFqj8jPa4Kbb6HLbgLj4jsbE6i9Wc7t1y
+NJYk4leA4Q0muGgCzfDHutQjrwKBgQDSkGjT1sSkvmzy7bFKTbVXdLWHbjQiVn41
++hCIQqAGbCZEaj0S8WExBU1+nwHNZLE7XCXXURNJ9KPNYPmQ4452tH2uCz89NlSQ
+Tk1k7q/+OXZp7DsorUMGgJ7i+855IfBSeHTji9PXlHElS4gHKHTi2lYSYoTT6cfR
+wHNbGREWhQKBgBNcLafI6J3h5XjM27Z1Aw+MkkZlIuci8xwnB/8vCOyHZLUscwyV
+LyN8ODQKGHzD0ePhDAwNBKlNOnKpok81jJaaXzSl2mI1N+rdbXE7J07a+mVfQK4K
+Lb0PyxIoNoQfqh10tkjUqeHoC4STAYf+KIrUcUgJc9dIUVNUCGz5caHvAoGAendd
+UOBX7M2Ihl4ywFmkACK0Nfmlvtb5fyFbHjVJ55JdS2tS7EKR2bYQ1XVb0f8fibvV
+kn7oLhpobtpZLKj9QhNGCcUm2c5QrsGsB+k/WShIs+Ceo9Dp681BHBmChDd2FDFV
+Isc/xeHjUOK2Uht4qDx+1SCRysLs4hUBwtk4dBUCgYEAgULAZGfnWBjI4nQP0RYK
+Wpn7nDZ1G1eeh2lBx9/3YRe7w5jpB2gR0fh2S5beCzoQqQuSiDHRBWdyLtn1sZa+
+1lexq67VV2TOrUT/rCaU/31odKbSWtDJIkpw5Sp+36sp29eoKsus4mhBY/JDNcUg
+PIfpyiV3t4CNpA2wo7GoFYs=
+-----END PRIVATE KEY-----

src/main/resources/config/application-dev.yml

@@ -0,0 +1,60 @@
+# 本地数据库
+server:
+  port: 8090
+  address: 0.0.0.0
+spring:
+  datasource:
+    type: com.alibaba.druid.pool.DruidDataSource
+    druid:
+      # 使用druid连接池
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      url: jdbc:mysql://120.55.54.207:3306/psychological_admin?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+      username: psyuser
+      password: psyuser
+      # 初始化连接大小
+      initial-size: 5
+      # 最小空闲连接数
+      min-idle: 5
+      max-active: 20
+      max-wait: 30000
+      # 可关闭的空闲连接间隔时间
+      time-between-eviction-runs-millis: 60000
+      # 配置连接在池中的最小生存时间
+      min-evictable-idle-time-millis: 300000
+      validation-query: select '1' from dual
+      test-while-idle: true
+      test-on-borrow: false
+      test-on-return: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      pool-prepared-statements: true
+      max-open-prepared-statements: 20
+      max-pool-prepared-statement-per-connection-size: 20
+      # 配置监控统计拦截的filters
+      filters: stat,wall
+      # 自己配置监控统计拦截的filter
+      filter:
+        # 开启druid datasource的状态监控
+        stat:
+          enabled: true
+          db-type: mysql
+          # 开启慢sql监控，超过2s 就认为是慢sql，记录到日志中
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      ########## 配置StatViewServlet（监控页面），用于展示Druid的统计信息 ##########
+      stat-view-servlet:
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: testAdmin
+        login-password: asdcjiafh^&912834
+        enabled: true
+        allow:
+      ########## 配置WebStatFilter，用于采集web关联监控的数据 ##########
+      web-stat-filter:
+        url-pattern: /*
+        exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
+        enabled: true
+        session-stat-enable: true
+
+
+
+

src/main/resources/config/application-hospital.yml

@@ -0,0 +1,102 @@
+# 机构版44测试服务器
+server:
+  port: 8090
+  address: 0.0.0.0
+spring:
+  datasource:
+    type: com.alibaba.druid.pool.DruidDataSource
+    druid:
+      # 使用druid连接池
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      url: jdbc:mysql://localhost:3306/hospital?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+      username: root
+      #112/44
+      password: 123456
+      # 初始化连接大小
+      initial-size: 5
+      # 最小空闲连接数
+      min-idle: 5
+      max-active: 20
+      max-wait: 30000
+      # 可关闭的空闲连接间隔时间
+      time-between-eviction-runs-millis: 60000
+      # 配置连接在池中的最小生存时间
+      min-evictable-idle-time-millis: 300000
+      validation-query: select '1' from dual
+      test-while-idle: true
+      test-on-borrow: false
+      test-on-return: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      pool-prepared-statements: true
+      max-open-prepared-statements: 20
+      max-pool-prepared-statement-per-connection-size: 20
+      # 配置监控统计拦截的filters
+      filters: stat,wall
+      # 自己配置监控统计拦截的filter
+      filter:
+        # 开启druid datasource的状态监控
+        stat:
+          enabled: true
+          db-type: mysql
+          # 开启慢sql监控，超过2s 就认为是慢sql，记录到日志中
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      ########## 配置StatViewServlet（监控页面），用于展示Druid的统计信息 ##########
+      stat-view-servlet:
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: testAdmin
+        login-password: asdcjiafh^&912834
+        enabled: true
+        allow:
+      ########## 配置WebStatFilter，用于采集web关联监控的数据 ##########
+      web-stat-filter:
+        url-pattern: /*
+        exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
+        enabled: true
+        session-stat-enable: true
+  data:
+    redis:
+      repositories:
+        enabled: false
+  redis:
+    host: 49.232.26.44
+    port: 6379
+    password: bjjmtech&jsyx
+    timeout: 5000
+    jedis:
+      pool:
+        max-wait: -1
+        max-idle: 8
+        max-active: 8
+        min-idle: 0
+#微信支付
+wx.pay:
+  # 商户号
+  mch-id: 1627594233
+  #商户api证书序列号
+  mch-serial-no: 25BB4D9C58F3D9FFCBC0F882B57F7E842CBE5A23
+  # 商户私钥文件
+  private-key-path: apiclient_key.pem
+  # API秘钥
+  api-v3-key: MentalHealth20191025JuemingTest1
+  # APPID
+  app-id: wxfee6e2d1588e3f7f
+  # 微信服务器地址
+  domain: https://api.mch.weixin.qq.com
+  # 接受结果回调地址
+  #notify-domain: http://49.232.26.44:8090
+  # 小程序秘钥
+  ASPI_SECRET: b4edc4638f9182a1684dffdf7a1fa4c0
+  #小程序code2session
+  ASPI_URL: https://api.weixin.qq.com/sns/jscode2session
+  #小程序appid
+  ASPI_APPID: wx2f422a2a1cb24c3c
+  is_lan: true
+#swagger 显示隐藏配置
+swagger:
+  show: true
+
+
+
+

src/main/resources/config/application-lan.yml

@@ -0,0 +1,10 @@
+#局域网版
+server:
+  port: 8083
+  address: 0.0.0.0
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://localhost:54031/psychological_pz?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+    username: root
+    password: Mysql@.2020

src/main/resources/config/application-prod.yml

@@ -0,0 +1,48 @@
+#112正式版
+server:
+  port: 8848
+  address: 0.0.0.0
+  ssl:
+    key-store: classpath:server.jks
+    key-store-password: ppru022o8rag9
+    key-store-type: JKS
+  tomcat:
+    accept-count: 1000
+    max-connections: 10000
+    threads:
+      min-spare: 100
+      max: 1600
+
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://49.232.79.112:3306/psychological_admin2?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+
+    #url: jdbc:mysql://localhost:54027/psychological_admin?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+    username: root
+    #112/44
+    password: Mysql@.2020
+    #username: root
+    #password: QazMysql@1921.Wsx
+    hikari:
+      max-lifetime: 30000
+
+  #redisson:
+    #address: redis://49.232.79.112:6379
+    #address: redis://49.232.26.44:6379
+    #password: bjjmtech&jsyx
+  data:
+    redis:
+      repositories:
+        enabled: false
+  redis:
+    host: 49.232.79.112
+    port: 6379
+    password: bjjmtech&jsyx
+    timeout: 5000
+    jedis:
+      pool:
+        max-wait: -1
+        max-idle: 8
+        max-active: 8
+        min-idle: 0

src/main/resources/config/application-public.yml

@@ -0,0 +1,50 @@
+#公网版
+server:
+  port: 8443
+  address: 0.0.0.0
+  ssl:
+    key-store: classpath:testjuemingcom.jks
+    key-store-password: 1628xp3s4owz5s9
+    key-store-type: JKS
+
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://152.136.24.101:3306/psychological_web?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+    username: root
+    password: Mysql@.2020
+    hikari:
+      max-lifetime: 30000
+  data:
+    redis:
+      repositories:
+        enabled: false
+  redis:
+    host: 127.0.0.1
+    port: 6379
+    password: bjjmtech&jsyx
+    timeout: 5000
+    jedis:
+      pool:
+        max-wait: -1
+        max-idle: 8
+        max-active: 8
+        min-idle: 0
+
+#微信支付
+wx.pay:
+  # 商户号
+  mch-id: 1627594233
+  #商户api证书序列号
+  mch-serial-no: 25BB4D9C58F3D9FFCBC0F882B57F7E842CBE5A23
+  # 商户私钥文件
+  private-key-path: apiclient_key.pem
+  # API秘钥
+  api-v3-key: MentalHealth20191025JuemingTest1
+  # APPID
+  app-id: wxfee6e2d1588e3f7f
+  # 微信服务器地址
+  domain: https://api.mch.weixin.qq.com
+  # 接受结果回调地址
+  notify-domain: https://152.136.24.101:8443
+  is_lan: false

src/main/resources/config/application-test.yml

@@ -0,0 +1,97 @@
+# 机构版44测试服务器
+server:
+  port: 8090
+  address: 0.0.0.0
+spring:
+  datasource:
+    type: com.alibaba.druid.pool.DruidDataSource
+    druid:
+      # 使用druid连接池
+      driver-class-name: com.mysql.cj.jdbc.Driver
+      url: jdbc:mysql://49.232.26.44:3306/psychological_cpdm?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
+      username: root
+      #112/44
+      password: Mysql@.2020
+      # 初始化连接大小
+      initial-size: 5
+      # 最小空闲连接数
+      min-idle: 5
+      max-active: 20
+      max-wait: 30000
+      # 可关闭的空闲连接间隔时间
+      time-between-eviction-runs-millis: 60000
+      # 配置连接在池中的最小生存时间
+      min-evictable-idle-time-millis: 300000
+      validation-query: select '1' from dual
+      test-while-idle: true
+      test-on-borrow: false
+      test-on-return: false
+      # 打开PSCache，并且指定每个连接上PSCache的大小
+      pool-prepared-statements: true
+      max-open-prepared-statements: 20
+      max-pool-prepared-statement-per-connection-size: 20
+      # 配置监控统计拦截的filters
+      filters: stat,wall
+      # 自己配置监控统计拦截的filter
+      filter:
+        # 开启druid datasource的状态监控
+        stat:
+          enabled: true
+          db-type: mysql
+          # 开启慢sql监控，超过2s 就认为是慢sql，记录到日志中
+          log-slow-sql: true
+          slow-sql-millis: 2000
+      ########## 配置StatViewServlet（监控页面），用于展示Druid的统计信息 ##########
+      stat-view-servlet:
+        url-pattern: /druid/*
+        reset-enable: false
+        login-username: testAdmin
+        login-password: asdcjiafh^&912834
+        enabled: true
+        allow:
+      ########## 配置WebStatFilter，用于采集web关联监控的数据 ##########
+      web-stat-filter:
+        url-pattern: /*
+        exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
+        enabled: true
+        session-stat-enable: true
+  data:
+    redis:
+      repositories:
+        enabled: false
+  redis:
+    host: 49.232.26.44
+    port: 6379
+    password: bjjmtech&jsyx
+    timeout: 5000
+    jedis:
+      pool:
+        max-wait: -1
+        max-idle: 8
+        max-active: 8
+        min-idle: 0
+#微信支付
+wx.pay:
+  # 商户号
+  mch-id: 1627594233
+  #商户api证书序列号
+  mch-serial-no: 25BB4D9C58F3D9FFCBC0F882B57F7E842CBE5A23
+  # 商户私钥文件
+  private-key-path: apiclient_key.pem
+  # API秘钥
+  api-v3-key: MentalHealth20191025JuemingTest1
+  # APPID
+  app-id: wxfee6e2d1588e3f7f
+  # 微信服务器地址
+  domain: https://api.mch.weixin.qq.com
+  # 接受结果回调地址
+  #notify-domain: http://49.232.26.44:8090
+
+  is_lan: true
+#swagger 显示隐藏配置
+swagger:
+  show: true
+
+
+
+