LIMS管理系统框架1.0.0

XiaoRuby

2023-07-05 23603498db6bc186eb7fe1e2757f77dd5419236c

LIMS管理系统框架1.0.0

 framework/src/main/java/com/yuanchu/limslaboratory/config/DruidConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,57 @@
package com.yuanchu.limslaboratory.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DruidConfig {
    //加载application.yaml中的Druid配置
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
        return  new DruidDataSource();
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();

        initParams.put("loginUsername","root");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");//默认就是允许所有访问
//        initParams.put("deny","192.168.15.21"); ç¦æ­¢è¯¥IP访问

        bean.setInitParameters(initParams);
        return bean;
    }

    //2、配置一个web监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");

        bean.setInitParameters(initParams);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return bean;
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/config/MyBatisPlusConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
package com.yuanchu.limslaboratory.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@MapperScan("com.yuanchu.limslaboratory.mapper") // æ‰«æMybatis中的mapper包
@Configuration
public class MyBatisPlusConfig {

//     ä¹è§‚锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/config/MyCorsConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package com.yuanchu.limslaboratory.config;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class MyCorsConfig {

    private CorsConfiguration buildConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        // 1 è®¾ç½®è®¿é—®æºåœ°å€
        corsConfiguration.addAllowedOrigin("*");
        // 2 è®¾ç½®è®¿é—®æºè¯·æ±‚头
        corsConfiguration.addAllowedHeader("*");
        // 3 è®¾ç½®è®¿é—®æºè¯·æ±‚方法
        corsConfiguration.addAllowedMethod("*");
        // 4 æš´éœ²å“ªäº›å¤´éƒ¨ä¿¡æ¯
//        corsConfiguration.addExposedHeader(JwtConstant.HEADER);
        return corsConfiguration;
    }
    @Bean
    public FilterRegistrationBean<CorsFilter> corsFilter() {
//        log.info("跨域设置。。。。");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        // 5 å¯¹æŽ¥å£é…ç½®è·¨åŸŸè®¾ç½®
        source.registerCorsConfiguration("/**", buildConfig());
        //有多个filter时此处设置改CorsFilter的优先执行顺序
        FilterRegistrationBean<CorsFilter> bean = new FilterRegistrationBean<>(new CorsFilter(source));
        bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return bean;
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/config/Swagger3.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
package com.yuanchu.limslaboratory.config;


import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.oas.annotations.EnableOpenApi;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Configuration
@EnableOpenApi
public class Swagger3 {
    // è·¯å¾„http://localhost:8080/doc.html
    @Value("${swagger.enabled}")
    private boolean enable;

    private final String swaggerPackage = "com.yuanchu.limslaboratory";

    /**
     * æ·»åŠ æ‘˜è¦ä¿¡æ¯
     */
    private ApiInfo apiInfo() {
        // ç”¨ApiInfoBuilder进行定制
        return new ApiInfoBuilder()
                // è®¾ç½®æ ‡é¢˜
                .title("江苏鵷雏网络科技有限公司管理系统")
                // æè¿°
                .description("江苏鵷雏网络科技有限公司管理系统")
                // ä½œè€…信息
                .contact(new Contact("Crunchy", null, null))
                // ç‰ˆæœ¬
                .version("版本号:V.1")
                //协议
                .license("The Apache License")
                //协议url
                .licenseUrl("http://www.baidu.com")
                .build();
    }

    /**
     * åˆ›å»ºAPI
     * http:IP:端口号/swagger-ui/index.html åŽŸç”Ÿåœ°å€
     * http:IP:端口号/doc.html bootStrap-UI地址
     */
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.OAS_30).pathMapping("/")
                // ç”¨æ¥åˆ›å»ºè¯¥API的基本信息，展示在文档的页面中（自定义展示的信息）
                .enable(enable)
                .apiInfo(apiInfo())
                // è®¾ç½®å“ªäº›æŽ¥å£æš´éœ²ç»™Swagger展示
                .select()
                // æ‰«ææ‰€æœ‰æœ‰æ³¨è§£çš„api，用这种方式更灵活
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))


                // æ‰«ææŒ‡å®šåŒ…中的swagger注解
                .apis(RequestHandlerSelectors.basePackage(swaggerPackage))
                // æ‰«ææ‰€æœ‰ .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.regex("(?!/ApiError.*).*"))
                .paths(PathSelectors.any())
                .build()
                // æ”¯æŒçš„通讯协议集合
                .protocols(newHashSet("https", "http"))
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }

    /**
     * æ”¯æŒçš„通讯协议集合
     * @param type1
     * @param type2
     * @return
     */
    private Set<String> newHashSet(String type1, String type2){
        Set<String> set = new HashSet<>();
        set.add(type1);
        set.add(type2);
        return set;
    }

    /**
     * è®¤è¯çš„安全上下文
     */
    private List<SecurityScheme> securitySchemes() {
        List<SecurityScheme> securitySchemes = new ArrayList<>();
        securitySchemes.add((SecurityScheme) new ApiKey("token", "token", "header"));
        return securitySchemes;
    }

    /**
     * æŽˆæƒä¿¡æ¯å…¨å±€åº”用
     */
    private List<SecurityContext> securityContexts() {
        List<SecurityContext> securityContexts = new ArrayList<>();
        securityContexts.add(SecurityContext.builder()
                .securityReferences(defaultAuth())
                .forPaths(PathSelectors.any()).build());
        return securityContexts;
    }

    private List<SecurityReference> defaultAuth() {
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        List<SecurityReference> securityReferences = new ArrayList<>();
        securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
        return securityReferences;
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/config/WebMvcConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package com.yuanchu.limslaboratory.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

import java.io.File;

@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        // swagger可视化配置
        registry.addResourceHandler("/systemPictures/**")
                .addResourceLocations("file:" + System.getProperty("user.dir")+ File.separator+"uploadFile"+File.separator+"systemPictures"+File.separator);
        registry.addResourceHandler("/uploadFile/pluginFiles/logo/**")
                .addResourceLocations("file:" + System.getProperty("user.dir")+ File.separator+"uploadFile"+File.separator+"pluginFiles"+File.separator+"logo"+File.separator);

        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");

        //设置文件虚拟路径映射
        registry.addResourceHandler("/img/**").addResourceLocations("file:E:\\webapp\\images\\");
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/handler/GlobalExceptionHandler.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,164 @@
package com.yuanchu.limslaboratory.handler;

import com.yuanchu.limslaboratory.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;


@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(SQLException.class)
    public Result<?> handlerSQLException(SQLException e)
    {
        log.error(e.getMessage().toLowerCase(), e);
        return Result.fail("数据操作失败！请联系管理员");
    }

    /**
     * å”¯ä¸€å€¼åœ¨æ•°æ®åº“中重复
     * Duplicate entry ' ' for key ' '
     * @param e：重复键异常
     * @return 199
     */
    @ExceptionHandler
    public Result<?> DuplicateKeyException(DuplicateKeyException e) {
        log.error(String.valueOf(e));
        String message = e.getCause().getMessage();
        String[] split = message.split("'");
        return Result.fail("重复添加：【" + split[1] + "】操作失败！");
    }

    @ExceptionHandler
    public Result<?> NullPointerException(NullPointerException e){
        log.error(e.getMessage(), e.getCause());
        return Result.fail("部分参数为空，请检查！");
    }

    /** è¿è¡Œæ—¶å¼‚常 */
    @ExceptionHandler(RuntimeException.class)
    public Result<?> runtimeExceptionHandler(RuntimeException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("运行时异常");
    }

    /** ç±»åž‹è½¬æ¢å¼‚常 */
    @ExceptionHandler(ClassCastException.class)
    public Result<?> classCastExceptionHandler(ClassCastException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("类型转换异常");
    }
    /** æ–‡ä»¶æœªæ‰¾åˆ°å¼‚常 */
    @ExceptionHandler(FileNotFoundException.class)
    public Result<?> FileNotFoundException(FileNotFoundException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("文件未找到异常");
    }
    /** æ•°å­—格式异常 */
    @ExceptionHandler(NumberFormatException.class)
    public Result<?> NumberFormatException(NumberFormatException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("数字格式异常");
    }
    /** å®‰å…¨å¼‚常 */
    @ExceptionHandler(SecurityException.class)
    public Result<?> SecurityException(SecurityException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("安全异常");
    }

    /** ç±»åž‹ä¸å­˜åœ¨å¼‚常 */
    @ExceptionHandler(TypeNotPresentException.class)
    public Result<?> TypeNotPresentException(TypeNotPresentException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("类型不存在异常");
    }

    /** IO异常 */
    @ExceptionHandler(IOException.class)
    public Result<?> iOExceptionHandler(IOException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("IO异常");
    }

    /** æœªçŸ¥æ–¹æ³•å¼‚常 */
    @ExceptionHandler(NoSuchMethodException.class)
    public Result<?> noSuchMethodExceptionHandler(NoSuchMethodException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("未知方法异常");
    }

    /** æ•°ç»„越界异常 */
    @ExceptionHandler(IndexOutOfBoundsException.class)
    public Result<?> indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("数组越界异常");
    }
    /** sql语法错误异常 */
    @ExceptionHandler(BadSqlGrammarException.class)
    public Result<?> BadSqlGrammarException(BadSqlGrammarException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("sql语法错误异常");
    }

    /** æ— æ³•æ³¨å…¥bean异常 */
    @ExceptionHandler(NoSuchBeanDefinitionException.class)
    public Result<?> NoSuchBeanDefinitionException(NoSuchBeanDefinitionException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("无法注入bean");
    }

    /** Http消息不可读异常 */
    @ExceptionHandler({HttpMessageNotReadableException.class})
    public Result<?> requestNotReadable(HttpMessageNotReadableException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("Http消息不可读");
    }

    /** 400错误 */
    @ExceptionHandler({TypeMismatchException.class})
    public Result<?> requestTypeMismatch(TypeMismatchException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("服务器异常");
    }

    /** 500错误 */
    @ExceptionHandler({ConversionNotSupportedException.class, HttpMessageNotWritableException.class})
    public Result<?> server500(RuntimeException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("服务器异常");
    }

    /** æ ˆæº¢å‡º */
    @ExceptionHandler({StackOverflowError.class})
    public Result<?> requestStackOverflow(StackOverflowError e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("栈溢出异常");
    }

    /** é™¤æ•°ä¸èƒ½ä¸º0 */
    @ExceptionHandler({ArithmeticException.class})
    public Result<?> arithmeticException(ArithmeticException e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("除数不能为0异常");
    }

    /** å…¶ä»–错误 */
    @ExceptionHandler({Exception.class})
    public Result<?> exception(Exception e) {
        log.error(e.getMessage(), e.getCause());
        return Result.fail("网络连接失败，请退出后再试");
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/handler/MyMetaObjectHandler.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
package com.yuanchu.limslaboratory.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // èµ·å§‹ç‰ˆæœ¬ 3.3.0(推荐使用)
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // èµ·å§‹ç‰ˆæœ¬ 3.3.0(推荐使用)
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        // update的时候使用，更新的时候强制进行填充
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // èµ·å§‹ç‰ˆæœ¬ 3.3.0(推荐)
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/utils/FileSaveUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,60 @@
package com.yuanchu.limslaboratory.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * ä¿å­˜æ–‡ä»¶å·¥å…·
 */
@Slf4j
@Component
public class FileSaveUtils {

    // å–yml中的路径 + /
//    @Value("${file.path}")
    private String FILE_PATH;

    /**
     * å­˜å‚¨æ–‡ä»¶ä¸»å‡½æ•°
     * @param content æ–‡ä»¶äºŒè¿›åˆ¶æµ
     * @param originalFilename æ–‡ä»¶åç§°
     * @return è¿”回文件名称用于存储数据库
     */
    public String StoreFile(byte[] content, String originalFilename) {
        // ç”Ÿæˆéšæœºåç§°ï¼šæ—¶é—´_随机6位数字
        String FileName = System.currentTimeMillis() + "_" + MyUtils.getNumber(6);
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
        // åç§°æ‹¼æŽ¥
        String fileName = FileName + suffix;
        // è¿›è¡Œå­˜å‚¨
        storeFileWithFileName(content, fileName);
        return fileName;
    }

    /**
     * å­˜å‚¨æ–‡ä»¶å‡½æ•°
     * @param content æ–‡ä»¶äºŒè¿›åˆ¶æµ
     * @param fileName æ–‡ä»¶åç§°
     */
    private void storeFileWithFileName(byte[] content, String fileName) {
        // å­˜å‚¨è·¯å¾„
        String path = FILE_PATH + java.io.File.separatorChar;
        // ç›®å½•ä¸å­˜åœ¨åˆ™åˆ›å»º
        java.io.File file = new java.io.File(path);
        if (!file.exists()) {
            file.mkdirs();
        }
        // å¼€å§‹å­˜å‚¨
        try (FileOutputStream os = new FileOutputStream(path + fileName);
             ByteArrayInputStream is = new ByteArrayInputStream(content)) {
             IOUtils.copy(is, os);
        } catch (IOException e) {
            MyUtils.PrintLog("存储文件异常：" + e);
        }
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/utils/JackSonUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,123 @@
package com.yuanchu.limslaboratory.utils;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * JSON解析处理
 *
 * @author å¼ å®¾
 */
@Component
public class JackSonUtil {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    private static final ObjectWriter OBJECT_WRITER = OBJECT_MAPPER.writerWithDefaultPrettyPrinter();

    public static void marshal(File file, Object value) throws Exception {
        try {
            OBJECT_WRITER.writeValue(file, value);
        } catch (JsonGenerationException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static void marshal(OutputStream os, Object value) throws Exception {
        try {
            OBJECT_WRITER.writeValue(os, value);
        } catch (JsonGenerationException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static String marshal(Object value) throws Exception {
        try {
            return OBJECT_WRITER.writeValueAsString(value);
        } catch (JsonGenerationException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static byte[] marshalBytes(Object value) throws Exception {
        try {
            return OBJECT_WRITER.writeValueAsBytes(value);
        } catch (JsonGenerationException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static <T> T unmarshal(File file, Class<T> valueType) throws Exception {
        try {
            return OBJECT_MAPPER.readValue(file, valueType);
        } catch (JsonParseException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static <T> T unmarshal(InputStream is, Class<T> valueType) throws Exception {
        try {
            return OBJECT_MAPPER.readValue(is, valueType);
        } catch (JsonParseException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static <T> T unmarshal(String str, Class<T> valueType) throws Exception {
        try {
            return OBJECT_MAPPER.readValue(str, valueType);
        } catch (JsonParseException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }

    public static <T> T unmarshal(byte[] bytes, Class<T> valueType) throws Exception {
        try {
            if (bytes == null) {
                bytes = new byte[0];
            }
            return OBJECT_MAPPER.readValue(bytes, 0, bytes.length, valueType);
        } catch (JsonParseException e) {
            throw new Exception(e);
        } catch (JsonMappingException e) {
            throw new Exception(e);
        } catch (IOException e) {
            throw new Exception(e);
        }
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/utils/JwtUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package com.yuanchu.limslaboratory.utils;


import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTCreationException;

import java.util.Date;

public class JwtUtils {
    // è¿‡æœŸæ—¶é—´ 2 å°æ—¶
//    private static final long EXPIRE_TIME = 2 * 60 * 60 * 1000;

    private static final long EXPIRE_TIME = 10;
    /**
     * ç”Ÿæˆç­¾å,准确地说是生成token
     * @param secret
     * @return
     */
    public static String sign(String account, String secret){
        try{
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(secret);
            //附带username,nickname信息
            return JWT.create()
                    .withClaim("account",account)
                    .withExpiresAt(date)
                    .sign(algorithm);
        } catch (JWTCreationException e){
            e.printStackTrace();
            return null;
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/utils/MyUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package com.yuanchu.limslaboratory.utils;

import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;

@Component
public class MyUtils<T> {

    /**
     * è‡ªå®šä¹‰è°ƒè¯•å·¥å…·ç±»
     * @return
     */
    public static void PrintLog(String str){
        // ç±»å
        String className = Thread.currentThread().getStackTrace()[2].getClassName();
        // å‡½æ•°å
        String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
        System.out.println("\033[1;94m" + className + "-->" + methodName + "-->"  + str + "\033[0m");
    }

    /**
     * æ—¥æœŸå·¥å…·ç±»
     * @return
     */
    public static String MyDateFormat(){
        //获取日期
        //导 import java.util.Date; ä¸‹çš„包
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        return sdf.format(date);
    }

    /**
     * èŽ·å–随机加密盐
     * @param n ä½æ•°
     * @return è¿”回随机加密盐
     */
    public static String getSalt(int n) {
        char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890!@#$%^&*()+-=/[];~.".toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = chars[new Random().nextInt(chars.length)];
            sb.append(c);
        }
        return sb.toString();
    }

    /**
     * èŽ·å–随机加密盐
     * @param n ä½æ•°
     * @return è¿”回随机值
     */
    public static String getNumber(int n) {
        char[] chars = "1234567890".toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = chars[new Random().nextInt(chars.length)];
            sb.append(c);
        }
        return sb.toString();
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/utils/RedisUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,622 @@
package com.yuanchu.limslaboratory.utils;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {
    private static RedisTemplate<String, Object> redisTemplate;
    public static RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }
    @Autowired
    private RedisUtil(RedisConnectionFactory redisConnectionFactory){
        // redisTemplate模板初始化
        redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // å°†å¯¹è±¡åºåˆ—化
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

        // String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // json序列化配置
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer<>(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String çš„序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //value的序列化方式采用jackson的方式
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
//        //hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
    }

    // =============================common============================
    /**
     * æŒ‡å®šç¼“存失效时间
     * @param key  é”®
     * @param time æ—¶é—´(秒)
     */
    public static boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * æ ¹æ®key èŽ·å–过期时间
     * @param key é”® ä¸èƒ½ä¸ºnull
     * @return æ—¶é—´(秒) è¿”回0代表为永久有效
     */
    public static long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * åˆ¤æ–­key是否存在
     * @param key é”®
     * @return true å­˜åœ¨ false不存在
     */
    public static boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * åˆ é™¤ç¼“å­˜
     * @param key å¯ä»¥ä¼ ä¸€ä¸ªå€¼ æˆ–多个
     */
//    @SuppressWarnings("unchecked")
    public static void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
//                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * èŽ·å–并删除缓存
     * @param key é”®
     * @return å€¼
     */
    public static Object getAndDelete(String key) {
        try{
            return key == null ? null : get(key);
        }finally {
            del(key);
        }
    }

    // ============================String=============================

    /**
     * æ™®é€šç¼“存获取
     * @param key é”®
     * @return å€¼
     */
    public static Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * æ™®é€šç¼“存放入
     * @param key   é”®
     * @param value å€¼
     * @return true成功 false失败
     */

    public static boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * æ™®é€šç¼“存放入并设置时间
     * @param key   é”®
     * @param value å€¼
     * @param time  æ—¶é—´(秒) time要大于0 å¦‚æžœtime小于等于0 å°†è®¾ç½®æ— é™æœŸ
     * @return true成功 false å¤±è´¥
     */

    public static boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.MINUTES);
            } else {
                // åªä¿®æ”¹å‚数不修改ttl
                redisTemplate.opsForValue().set(key, value, 0);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * é€’增
     * @param key   é”®
     * @param delta è¦å¢žåŠ å‡ (大于0)
     */
    public static long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * é€’减
     * @param key   é”®
     * @param delta è¦å‡å°‘几(小于0)
     */
    public static long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     * @param key  é”® ä¸èƒ½ä¸ºnull
     * @param item é¡¹ ä¸èƒ½ä¸ºnull
     */
    public static Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * èŽ·å–hashKey对应的所有键值
     * @param key é”®
     * @return å¯¹åº”的多个键值
     */
    public static Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key é”®
     * @param map å¯¹åº”多个键值
     */
    public static boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet å¹¶è®¾ç½®æ—¶é—´
     * @param key  é”®
     * @param map  å¯¹åº”多个键值
     * @param time æ—¶é—´(秒)
     * @return true成功 false失败
     */
    public static boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForHash().putAll(key, map);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * å‘一张hash表中放入数据,如果不存在将创建
     *
     * @param key   é”®
     * @param item  é¡¹
     * @param value å€¼
     * @return true æˆåŠŸ false失败
     */
    public static boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * å‘一张hash表中放入数据,如果不存在将创建
     *
     * @param key   é”®
     * @param item  é¡¹
     * @param value å€¼
     * @param time  æ—¶é—´(秒) æ³¨æ„:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true æˆåŠŸ false失败
     */
    public static boolean hset(String key, String item, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForHash().put(key, item, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * åˆ é™¤hash表中的值
     *
     * @param key  é”® ä¸èƒ½ä¸ºnull
     * @param item é¡¹ å¯ä»¥ä½¿å¤šä¸ª ä¸èƒ½ä¸ºnull
     */
    public static void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * åˆ¤æ–­hash表中是否有该项的值
     *
     * @param key  é”® ä¸èƒ½ä¸ºnull
     * @param item é¡¹ ä¸èƒ½ä¸ºnull
     * @return true å­˜åœ¨ false不存在
     */
    public static boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 å¦‚果不存在,就会创建一个 å¹¶æŠŠæ–°å¢žåŽçš„值返回
     *
     * @param key  é”®
     * @param item é¡¹
     * @param by   è¦å¢žåŠ å‡ (大于0)
     */
    public static double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  é”®
     * @param item é¡¹
     * @param by   è¦å‡å°‘è®°(小于0)
     */
    public static double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * æ ¹æ®key获取Set中的所有值
     * @param key é”®
     */
    public static Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * æ ¹æ®value从一个set中查询,是否存在
     *
     * @param key   é”®
     * @param value å€¼
     * @return true å­˜åœ¨ false不存在
     */
    public static boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * å°†æ•°æ®æ”¾å…¥set缓存
     *
     * @param key    é”®
     * @param values å€¼ å¯ä»¥æ˜¯å¤šä¸ª
     * @return æˆåŠŸä¸ªæ•°
     */
    public static long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * å°†set数据放入缓存
     *
     * @param key    é”®
     * @param time   æ—¶é—´(秒)
     * @param values å€¼ å¯ä»¥æ˜¯å¤šä¸ª
     * @return æˆåŠŸä¸ªæ•°
     */
    public static long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = (long)values.length;
            if (time > 0) {
                count = redisTemplate.opsForSet().add(key, values);
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * èŽ·å–set缓存的长度
     *
     * @param key é”®
     */
    public static long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * ç§»é™¤å€¼ä¸ºvalue的
     *
     * @param key    é”®
     * @param values å€¼ å¯ä»¥æ˜¯å¤šä¸ª
     * @return ç§»é™¤çš„个数
     */

    public static long setRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * èŽ·å–list缓存的内容
     *
     * @param key   é”®
     * @param start å¼€å§‹
     * @param end   ç»“束 0 åˆ° -1代表所有值
     */
    public static List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * èŽ·å–list缓存的长度
     *
     * @param key é”®
     */
    public static long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * é€šè¿‡ç´¢å¼• èŽ·å–list中的值
     *
     * @param key   é”®
     * @param index ç´¢å¼• index>=0时， 0 è¡¨å¤´ï¼Œ1 ç¬¬äºŒä¸ªå…ƒç´ ï¼Œä¾æ¬¡ç±»æŽ¨ï¼›index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public static Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * å°†list放入缓存
     *
     * @param key   é”®
     * @param value å€¼
     */
    public static boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * å°†list放入缓存
     * @param key   é”®
     * @param value å€¼
     * @param time  æ—¶é—´(秒)
     */
    public static boolean lSet(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForList().rightPush(key, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * å°†list放入缓存
     *
     * @param key   é”®
     * @param value å€¼
     * @return true å­˜æ”¾æˆåŠŸ false存放失败
     */
    public static boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * å°†list放入缓存
     *
     * @param key   é”®
     * @param value å€¼
     * @param time  æ—¶é—´(秒)
     * @return true å­˜æ”¾æˆåŠŸ false存放失败
     */
    public static boolean lSet(String key, List<Object> value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForList().rightPushAll(key, value);
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * æ ¹æ®ç´¢å¼•ä¿®æ”¹list中的某条数据
     *
     * @param key   é”®
     * @param index ç´¢å¼•
     * @param value å€¼
     * @return true å­˜æ”¾æˆåŠŸ false存放失败
     */

    public static boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * ç§»é™¤N个值为value
     *
     * @param key   é”®
     * @param count ç§»é™¤å¤šå°‘个
     * @param value å€¼
     * @return ç§»é™¤çš„个数
     */

    public static long lRemove(String key, long count, Object value) {
        try {
            return redisTemplate.opsForList().remove(key, count, value);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}


 framework/src/main/java/com/yuanchu/limslaboratory/utils/SpringUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,51 @@
package com.yuanchu.limslaboratory.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringUtils implements ApplicationContextAware {
    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }

    public static void set(ApplicationContext applicationContext) {
        context = applicationContext;
    }

    /**
     * é€šè¿‡å­—节码获取
     * @param beanClass
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }

    /**
     * é€šè¿‡BeanName获取
     * @param beanName
     * @param <T>
     * @return
     */
    public static <T> T getBean(String beanName) {
        return (T) context.getBean(beanName);
    }

    /**
     * é€šè¿‡beanName和字节码获取
     * @param name
     * @param beanClass
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name, Class<T> beanClass) {
        return context.getBean(name, beanClass);
    }
}

 framework/src/main/java/com/yuanchu/limslaboratory/vo/Result.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,53 @@
package com.yuanchu.limslaboratory.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {

    @ApiModelProperty(value = "响应码：200成功，201失败")
    private int code;

    @ApiModelProperty(value = "响应消息")
    private String message;

    @ApiModelProperty(value = "响应参数")
    private T data;

    public static <T> Result<T> success(){
        return new Result<>(200, "success",null);
    }

    public static <T> Result<T> success(String message){
        return new Result<>(200, message,null);
    }

    public static <T> Result<T> success(T data){
        return new Result<>(200, "success",data);
    }

    public static <T> Result<T> success(String message, T data){
        return new Result<>(200, message,data);
    }

    public static <T> Result<T> fail(){
        return new Result<>(201, "fail", null);
    }

    public static <T> Result<T> fail(String message){
        return new Result<>(201, message, null);
    }

    public static <T> Result<T> fail(Integer code){
        return new Result<>(code, "fail", null);
    }

    public static <T> Result<T> fail(Integer code, String message){
        return new Result<>(code, message, null);
    }
}

 sys/src/main/java/com/yuanchu/limslaboratory/SysApplication.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,13 @@
package com.yuanchu.limslaboratory;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SysApplication {

    public static void main(String[] args) {
        SpringApplication.run(SysApplication.class, args);
    }

}

 sys/src/test/java/com/yuanchu/limslaboratory/CodeGenerator.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,129 @@
package com.yuanchu.limslaboratory;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// æ¼”示例子，执行 main æ–¹æ³•æŽ§åˆ¶å°è¾“入模块表名回车自动生成对应项目目录中
public class CodeGenerator {

    public static String database_url = "jdbc:mysql://localhost:3306/lims_manage?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
    public static String database_driver_name = "com.mysql.cj.jdbc.Driver";
    public static String database_username = "root";
    public static String database_password= "123456";
    public static String author = "江苏鵷雏网络科技有限公司";
    public static String model_name = "/user-server"; // å¦‚果为分布式填子模块名称，如果不是分布式为空即可
    public static String setParent = "com.yunchu.limslaboratory"; // åŒ…路径
    public static Boolean Override = true; // æ˜¯å¦è¦†ç›–原来的文件？

    public static void main(String[] args) {
        // ä»£ç ç”Ÿæˆå™¨
        AutoGenerator mpg = new AutoGenerator();

        String projectPath = System.getProperty("user.dir");
        System.out.println(projectPath+"===================");

        GlobalConfig gc = new GlobalConfig() // å…¨å±€é…ç½®
                .setOutputDir(projectPath + model_name + "/src/main/java") // è¾“出路径
                .setAuthor(author) // ä½œè€…注释
                .setOpen(false) // æ˜¯å¦æ‰“å¼€
                .setSwagger2(true) //实体属性 Swagger2 æ³¨è§£
                .setServiceName("%sService") // è®¾ç½®serviceName的名称去大写I
                .setFileOverride(Override);// æ˜¯å¦è¦†ç›–已生成文件
        mpg.setGlobalConfig(gc);

        // æ•°æ®æºé…ç½® æ•°æ®åº“名 è´¦å·å¯†ç 
        DataSourceConfig dsc = new DataSourceConfig()
                .setUrl(database_url)
                .setDriverName(database_driver_name)
                .setUsername(database_username)
                .setPassword(database_password);
        mpg.setDataSource(dsc);


        // åŒ…配置
        PackageConfig pc = new PackageConfig()
                .setModuleName(null)
                .setParent(setParent)
                .setEntity("pojo");// åŒ…路径
        mpg.setPackageInfo(pc);

        // è‡ªå®šä¹‰é…ç½®
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };

        // å¦‚果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // å¦‚果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";

        // è‡ªå®šä¹‰è¾“出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // è‡ªå®šä¹‰é…ç½®ä¼šè¢«ä¼˜å…ˆè¾“出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // è‡ªå®šä¹‰è¾“出文件名 ï¼Œ å¦‚果你 Entity è®¾ç½®äº†å‰åŽç¼€ã€æ­¤å¤„注意 xml çš„名称会跟着发生变化！
                return projectPath + model_name + "/src/main/resources/mapper/"
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });

        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // é…ç½®æ¨¡æ¿
        TemplateConfig templateConfig = new TemplateConfig()
                .setXml(null);

        mpg.setTemplate(templateConfig);

        // ç­–略配置
        StrategyConfig strategy = new StrategyConfig()
                .setNaming(NamingStrategy.underline_to_camel)
                .setColumnNaming(NamingStrategy.underline_to_camel)
                .setEntityLombokModel(true)
                .setRestControllerStyle(true)
                .setInclude(scanner("表名，多个空格分割").split(" "))
                .setControllerMappingHyphenStyle(true)
                .setTablePrefix("m_");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        //如果不调用该方法、就会使用MyBatis-Plus默认的文件生成路径和包路径生成文件、但可以使用上面的PackageConfig做一些简单的配置
        mpg.execute();
    }

    /**
     * <p>
     * è¯»å–控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();

            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }
}

 sys/src/test/java/com/yuanchu/limslaboratory/SysApplicationTests.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package com.yuanchu.limslaboratory;

import com.yuanchu.limslaboratory.utils.MyUtils;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SysApplicationTests {

    @Test
    void contextLoads() {
        String number = MyUtils.getNumber(6);
        System.out.println(number);
    }

}

 user-server/src/main/java/com/yuanchu/limslaboratory/clients/UserClient.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package com.yuanchu.limslaboratory.clients;

import com.yuanchu.limslaboratory.vo.Result;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.Map;

@FeignClient(value = "userservice", url = "localhost:6789")
public interface UserClient {

    @PostMapping("/business/login")
    Result<?> BusynessUserLogin(@RequestBody Map<String, Object> mapData);

    @PostMapping("/business/code")
    Result<?> BusynessUserLoginToken(@RequestParam("code") String code);
}

 user-server/src/main/java/com/yuanchu/limslaboratory/clients/UserLoginUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,73 @@
package com.yuanchu.limslaboratory.clients;

import com.yuanchu.limslaboratory.vo.Result;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@Component
public class UserLoginUtils {

    @Resource
    private UserClient userClient;

    @Value("${login.userID}")
    private String LoginUserID;

    @Value("${login.secret}")
    private String LoginSecret;
//    public Result<Map<String, Object>> LoginExamine(User user){
//        Map<String, Object> mapData = new HashMap<>();
//        mapData.put("LoginUserID", LoginUserID);
//        mapData.put("LoginSecret", LoginSecret);
//        Result<?> code = userClient.BusynessUserLogin(mapData);
//        if (code.getCode() == 200){
//            Result<?> result = userClient.BusynessUserLoginToken(code.getData().toString());
//            if (result.getCode() == 200){
//                Map data = (Map) result.getData();
//                String token = data.get("token").toString();
//                data.remove("token");
//                user.setMap(data);
//                //存入redis,二个小时后删除
//                RedisUtil.set(token, user, 2);
//                // å°†ç­¾å‘çš„ JWT token è¿”回给前端
//                HashMap<String, Object> map = new HashMap<>();
//                String refresh = JwtUtils.sign(user.getAccount());
//                map.put("token", token);
//                map.put("refresh", refresh);
//                RedisUtil.set(user.getAccount(), map, 168);
//                return Result.success(map);
//            } else {
//                return Result.fail(result.getMessage());
//            }
//        } else {
//            return Result.fail(code.getMessage());
//        }
//    }

    public Result<Map<String, Object>> LoginExamine(){
        Map<String, Object> mapData = new HashMap<>();
        mapData.put("LoginUserID", LoginUserID);
        mapData.put("LoginSecret", LoginSecret);
        Result<?> code = userClient.BusynessUserLogin(mapData);
        if (code.getCode() == 200){
            Result<?> result = userClient.BusynessUserLoginToken(code.getData().toString());
            if (result.getCode() == 200){
                Map data = (Map) result.getData();
                String token = data.get("token").toString();
                data.remove("token");
                // å°†ç­¾å‘çš„ JWT token è¿”回给前端
                HashMap<String, Object> map = new HashMap<>();
                map.put("token", token);
                return Result.success(map);
            } else {
                return Result.fail(result.getMessage());
            }
        } else {
            return Result.fail(code.getMessage());
        }
    }
}

 user-server/src/main/java/com/yuanchu/limslaboratory/config/FeignConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package com.yuanchu.limslaboratory.config;


import feign.Feign;
import okhttp3.OkHttpClient;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.openfeign.FeignAutoConfiguration;
import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@EnableFeignClients("com.yuanchu.limslaboratory.clients") // æ‰«æfeign接口所在包 é‡è¦
@Configuration
@ConditionalOnClass(Feign.class)
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignConfig {

    private OkHttpClient okHttpClient;


    //注入okhttp
    @Bean
    public OkHttpClient okHttpClient(OkHttpClientFactory okHttpClientFactory,
                                             FeignHttpClientProperties httpClientProperties) {
        this.okHttpClient = okHttpClientFactory.createBuilder(httpClientProperties.isDisableSslValidation()).connectTimeout(httpClientProperties.getConnectionTimeout(),TimeUnit.SECONDS)
                .followRedirects(httpClientProperties.isFollowRedirects())
                .build();
        return this.okHttpClient;
    }

}


 user-server/src/main/java/com/yuanchu/limslaboratory/controller/AdminController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,70 @@
package com.yuanchu.limslaboratory.controller;


import com.yuanchu.limslaboratory.clients.UserLoginUtils;
import com.yuanchu.limslaboratory.pojo.Admin;
import com.yuanchu.limslaboratory.service.AdminService;
import com.yuanchu.limslaboratory.utils.SpringUtils;
import com.yuanchu.limslaboratory.vo.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * <p>
 *  å‰ç«¯æŽ§åˆ¶å™¨
 * </p>
 *
 * @author æ±Ÿè‹éµ·é›ç½‘络科技有限公司
 * @since 2023-07-04
 */
@Api(tags = "管理员操作接口")
@RestController
@RequestMapping("/admin")
public class AdminController {

    @Autowired
    private AdminService service;

    @ApiOperation("Post接口")
    @PostMapping("/post")
    public Result<Map<String, Object>> post(Admin admin) {
        UserLoginUtils bean = SpringUtils.getBean(UserLoginUtils.class);
        return bean.LoginExamine();
    }

    @ApiOperation("删除接口")
    @ApiImplicitParams(value = {
            @ApiImplicitParam(name = "id", value = "需要删除的ID", dataTypeClass = String.class, required = true)
    })
    @PostMapping("/delete")
    public Result<?> delete(Integer id) {
        service.removeById(id);
        return Result.success("登录成功");
    }

    @ApiOperation("查询接口")
    @GetMapping("/get")
    public Result<?> get() {
        List<Admin> list = service.list();
        return Result.success(list);
    }

    @GetMapping("/更新接口")
    @ApiOperation("Crunchy")
    @ApiImplicitParams(value = {
            @ApiImplicitParam(name = "id", value = "需要的ID", dataTypeClass = String.class, required = true)
    })
    public Result<?> put(String id) {
        Admin systest2 = service.getById(id);
        systest2.setId(1);
        service.updateById(systest2);
        return Result.success();
    }
}

 user-server/src/main/java/com/yuanchu/limslaboratory/mapper/AdminMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package com.yuanchu.limslaboratory.mapper;

import com.yuanchu.limslaboratory.pojo.Admin;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper æŽ¥å£
 * </p>
 *
 * @author æ±Ÿè‹éµ·é›ç½‘络科技有限公司
 * @since 2023-07-04
 */
public interface AdminMapper extends BaseMapper<Admin> {

}

 user-server/src/main/java/com/yuanchu/limslaboratory/pojo/Admin.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,52 @@
package com.yuanchu.limslaboratory.pojo;

import com.baomidou.mybatisplus.annotation.*;

import java.time.LocalDateTime;
import java.io.Serializable;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author æ±Ÿè‹éµ·é›ç½‘络科技有限公司
 * @since 2023-07-04
 */
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="Admin对象", description="")
public class Admin implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "主键ID", hidden = true)
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    @ApiModelProperty(value = "创建时间", hidden = true)
    @TableField(fill = FieldFill.INSERT)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone="GMT+8") // åŽå°ç»™å‰ç«¯åšæ—¶é—´æ ¼å¼åŒ–
    private LocalDateTime createTime;

    @ApiModelProperty(value = "更新时间", hidden = true)
    @TableField(fill = FieldFill.INSERT_UPDATE, update = "now()")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone="GMT+8") // åŽå°ç»™å‰ç«¯åšæ—¶é—´æ ¼å¼åŒ–
    private LocalDateTime updateTime;

    @TableLogic(value = "0", delval = "1")
    @ApiModelProperty(value = "逻辑删除", hidden = true)
    private Integer isDelete;

    @ApiModelProperty(value = "乐观锁", hidden = true)
//    @Version
    private Integer version;


}

 user-server/src/main/java/com/yuanchu/limslaboratory/service/AdminService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package com.yuanchu.limslaboratory.service;

import com.yuanchu.limslaboratory.pojo.Admin;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  æœåŠ¡ç±»
 * </p>
 *
 * @author æ±Ÿè‹éµ·é›ç½‘络科技有限公司
 * @since 2023-07-04
 */
public interface AdminService extends IService<Admin> {

}

 user-server/src/main/java/com/yuanchu/limslaboratory/service/impl/AdminServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package com.yuanchu.limslaboratory.service.impl;

import com.yuanchu.limslaboratory.pojo.Admin;
import com.yuanchu.limslaboratory.mapper.AdminMapper;
import com.yuanchu.limslaboratory.service.AdminService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  æœåŠ¡å®žçŽ°ç±»
 * </p>
 *
 * @author æ±Ÿè‹éµ·é›ç½‘络科技有限公司
 * @since 2023-07-04
 */
@Service
public class AdminServiceImpl extends ServiceImpl<AdminMapper, Admin> implements AdminService {

}