springboot平常的一些配置

1.mybaits配置

server:
    tomcat:
        uri-encoding: UTF-8
        max-threads: 1000
        min-spare-threads: 30
    port: 8080
    servlet:
      context-path: /test
spring:
    profiles:
      #运行环境
      active: dev
    http:
      encoding:
        force: true
        charset: UTF-8
        enabled: true
      converters.preferred-json-mapper: jackson
    jackson:
        date-format: yyyy-MM-dd HH:mm:ss
        time-zone: GMT+8
        default-property-inclusion: non_null
    servlet:
        multipart:
          max-file-size: 20MB
          max-request-size: 20MB
          enabled: true
    main:
      allow-bean-definition-overriding: true
    mvc:
      throw-exception-if-no-handler-found: true
      servlet:
        load-on-startup: 1
mybatis-plus:
    mapper-locations: classpath*:/mapper/*/*Mapper.xml
    typeAliasesPackage: com.guangray.traffic.**.entity
    type-enums-package: com.guangray.traffic.**.enums
    global-config:
      db-config:
        id-type: assign_id
        logic-delete-field: is_delete
        logic-delete-value: 1
        logic-not-delete-value: 0
      banner: false
    configuration:
      map-underscore-to-camel-case: true
      cache-enabled: false
      log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl

配置 config



import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.util.StrUtil;
import com.guangray.traffic.component.quartz.annotation.QuartzCronScheduled;
import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.util.stream.Collectors;

@Slf4j
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
@QuartzCronScheduled(jobName = "taskCreateTable", description = "创建记录表", cronExpression = "0 0 2 * * ? *")
public class TaskCreateTable extends QuartzJobBean {

    /**
     * 创建玩玩测试记录表模板语句
     */
    private static final String CREATE_AUTH_TABLE_SQL = "sql/create_auth_table.sql";

    /**
     * 创建小天每天比对记录表模板语句
     */
    private static final String CREATE_COMPARE_TABLE_SQL = "sql/create_compare_table.sql";

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("创建记录表定时任务开始,时间:{}", DateUtil.now());
        LocalDate now = LocalDate.now();
        LocalDate lastDay = now.with(TemporalAdjusters.lastDayOfMonth());
        //执行日期为本月最后一天
        if (now.isEqual(lastDay)) {
            log.info("当前日期为本月最后一天,确认创建分月表");
            LocalDate nextMonthFirstDay = now.plusDays(1L);
            ClassPathResource authClassPathResource = new ClassPathResource(CREATE_AUTH_TABLE_SQL);
            ClassPathResource compareClassPathResource = new ClassPathResource(CREATE_COMPARE_TABLE_SQL);
            String authSql = new BufferedReader(new InputStreamReader(authClassPathResource.getStream()))
                    .lines()
                    .collect(Collectors.joining(System.lineSeparator()));
            String compareSql = new BufferedReader(new InputStreamReader(compareClassPathResource.getStream()))
                    .lines()
                    .collect(Collectors.joining(System.lineSeparator()));
            String tableSuffix = StrUtil.concat(
                    true,
                    String.valueOf(nextMonthFirstDay.getYear()),
                    String.valueOf(nextMonthFirstDay.getMonthValue())
            );
            try {
                jdbcTemplate.execute(StrUtil.format(authSql, tableSuffix));
            } catch (Exception e) {
                log.error("玩玩测试记录表创建失败,原因:{}", e.getMessage(), e);
            }
            try {
                jdbcTemplate.execute(StrUtil.format(compareSql, tableSuffix));
            } catch (Exception e) {
                log.error("小天每天比对记录表创建失败,原因:{}", e.getMessage(), e);
            }
        }
        log.info("创建记录表定时任务结束,时间:{}", DateUtil.now());
    }
}








 


mybaits plus 




/**
 * @author ww
 * @version v1.0.0
 */
@Configuration
public class MybatisPlusConfiguration {

    /**
     * mybatis-plus分页插件
     */
    @Bean
    @ConditionalOnMissingBean(PaginationInterceptor.class)
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor page = new PaginationInterceptor();
        page.setDialectType("mysql");
        return page;
    }
}






 


异常validate配置




public class ValidatorConfiguration {
    @Bean
    public Validator validator() {
        return Validation.byProvider(HibernateValidator.class).configure().failFast(true).buildValidatorFactory().getValidator();
    }
}




 


 


异常处理类




@RestControllerAdvice(value = "cn.gakm.place")
@Slf4j
public class GlobalExceptionHandler {


    /**
     * 请求方式不被支持异常
     * @param e
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Result httpRequestMethodNotSupportedException(Exception e) {
        log.error("请求方式不被支持异常:{}", e);
        return Result.fail(DefaultResultCode.HTTP_METHOD_NOT_ALLOWED);
    }


    /**
     * 参数校验异常，如果是hibernate validate的话，只包含实体类异常
     * @param e
     * @return
     */
    @ExceptionHandler({BindException.class, MethodArgumentNotValidException.class})
    public Result objectValidExceptionHandler(Exception e) {
        BindingResult bindResult = null;
        Result result = Result.fail(DefaultResultCode.PARAM_ERROR);
        //参数绑定异常
        if (e instanceof BindException) {
            bindResult = ((BindException) e).getBindingResult();
        } else if (e instanceof MethodArgumentNotValidException) {
            bindResult = ((MethodArgumentNotValidException) e).getBindingResult();
        }
        List<FieldError> fieldErrors = bindResult != null ? bindResult.getFieldErrors() : null;
        LinkedList<String> errorInfo = CollUtil.newLinkedList();
        if (CollUtil.isNotEmpty(fieldErrors)) {
            fieldErrors.forEach(fieldError -> errorInfo.add(fieldError.getField() + ":" + fieldError.getDefaultMessage()));
            //result.put(Result.KEY_MESSAGE, errorInfo.toString());
            result.setMsg(errorInfo.toString());
        }
        log.error("实体接参校验异常:{}", errorInfo.toString());
        return result;
    }

    /**
     * 参数校验异常，validate单参数校验异常（@RequestParam, @PathVariable）
     * 使用方式: 使用类上添加@validate 校验字段使用validator 定义规范 eg:@NotBlank
     *
     * @param e
     * @return
     */
    @ExceptionHandler(ConstraintViolationException.class)
    public Result paramValidExceptionHandler(ConstraintViolationException e) {
        Result result = Result.fail(DefaultResultCode.PARAM_ERROR);
        List<String> errorList = e.getConstraintViolations().stream().map(ConstraintViolation::getMessage).collect(Collectors.toList());
        String errorInfo = errorList.toString();
        log.error("单参数校验异常:{}", errorInfo);
        result.setMsg(errorInfo);
        return result;
    }
    /**
     * 其他异常
     *
     * @param e
     * @return
     */
    @ExceptionHandler(Exception.class)
    public Result globalException(Exception e) {
        log.error("其他异常:{}", e);
        return Result.fail(DefaultResultCode.SYSTEM_ERROR);
    }

    /**
     * 自定义异常
     * @param e
     * @return
     */
    @ExceptionHandler(ApiException.class)
    public Result customerException(ApiException e) {
        log.error("自定义异常:{}", e);
        return e.getResult();
    }

}




 


 




@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public Result eitEntryException(CustomException e) {
        log.error("自定义异常:{}", e.getMessage());
        return Result.fail(e.getCode(), e.getMessage());
    }

    @ExceptionHandler({BindException.class, MethodArgumentNotValidException.class})
    public Result objectValidExceptionHandler(Exception e) {
        BindingResult bindResult = null;
        Result result = Result.error(CommonResultEnum.ERROR_PARAM_VALIDATOR);
        if (e instanceof BindException) {
            bindResult = ((BindException) e).getBindingResult();
        } else if (e instanceof MethodArgumentNotValidException) {
            bindResult = ((MethodArgumentNotValidException) e).getBindingResult();
        }
        List<FieldError> fieldErrors = bindResult != null ? bindResult.getFieldErrors() : null;
        LinkedList<String> errorInfo = CollUtil.newLinkedList();
        if (CollUtil.isNotEmpty(fieldErrors)) {
            fieldErrors.forEach(fieldError -> errorInfo.add(
                    StrUtil.concat(Boolean.TRUE, fieldError.getField(), StrUtil.COLON, fieldError.getDefaultMessage())
            ));
            result.setMessage(errorInfo.toString());
        }
        log.error("实体接参校验异常:{}", errorInfo.toString());
        return result;
    }

    @ExceptionHandler(ConstraintViolationException.class)
    public Result paramValidExceptionHandler(ConstraintViolationException e) {
        Result result = Result.error(CommonResultEnum.ERROR_PARAM_VALIDATOR);
        List<String> errorList = e.getConstraintViolations()
                .stream()
                .map(ConstraintViolation::getMessage)
                .collect(Collectors.toList());
        String errorInfo = errorList.toString();
        result.setMessage(errorInfo);
        log.error("单参数校验异常:{}", errorInfo);
        return result;
    }

    @ExceptionHandler({HttpMessageNotReadableException.class, JsonParseException.class})
    public Result jsonParseException(Exception e) {
        log.error("json解析异常:{}", e.getMessage());
        return Result.error(CommonResultEnum.JSON_PARSE_ERROR);
    }

    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Result httpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
        return Result.error(CommonResultEnum.HTTP_METHOD_NOT_ALLOWED);
    }

    @ExceptionHandler(NoHandlerFoundException.class)
    public Result noHandlerFoundException(Exception e) {
        log.error("方法未找到:{}", e.getMessage());
        return Result.error(CommonResultEnum.NO_HANDLER_FOUND);
    }

    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    public Result httpMediaTypeNotSupportedException(Exception e) {
        log.error("请求头错误:{}", e.getMessage());
        return Result.error(CommonResultEnum.HTTP_MEDIATYPE_NOT_SUPPORTED);
    }

    @ExceptionHandler(AuthenticationException.class)
    public Result authenticationException(AuthenticationException e) {
        log.error("请求头错误:{}", e.getMessage());
        return Result.error(CommonResultEnum.HTTP_MEDIATYPE_NOT_SUPPORTED);
    }

    @ExceptionHandler(Exception.class)
    public Result globalException(Exception e) {
        log.error("其他异常:{}", e.getMessage());
        return resolveException(e);
    }

    public static Result resolveException(Exception e) {
        ResultCode result = CommonResultEnum.ERROR_SERVER;
        String message = e.getMessage();
        String className = e.getClass().getName();
        if (className.contains("UsernameNotFoundException")) {
            result = AuthResultEnum.USERNAME_NOT_FOUND;
        } else if (className.contains("BadCredentialsException")) {
            result = AuthResultEnum.BAD_CREDENTIALS;
        } else if (className.contains("AccountExpiredException")) {
            result = AuthResultEnum.ACCOUNT_EXPIRED;
        } else if (className.contains("LockedException")) {
            result = AuthResultEnum.ACCOUNT_LOCKED;
        } else if (className.contains("DisabledException")) {
            result = AuthResultEnum.ACCOUNT_DISABLED;
        } else if (className.contains("CredentialsExpiredException")) {
            result = AuthResultEnum.CREDENTIALS_EXPIRED;
        } else if (className.contains("InvalidClientException")) {
            result = AuthResultEnum.INVALID_CLIENT;
        } else if (className.contains("UnauthorizedClientException")) {
            result = AuthResultEnum.UNAUTHORIZED_CLIENT;
        } else if (className.contains("InsufficientAuthenticationException")
                || className.contains("AuthenticationCredentialsNotFoundException")) {
            result = AuthResultEnum.UNAUTHORIZED;
        } else if (className.contains("InvalidGrantException")) {
            if (message.contains("Bad credentials")) {
                result = AuthResultEnum.BAD_CREDENTIALS;
            } else if (message.contains("User is disabled")) {
                result = AuthResultEnum.ACCOUNT_DISABLED;
            } else if (message.contains("User account is locked")) {
                result = AuthResultEnum.ACCOUNT_LOCKED;
            } else if (message.contains("Invalid refresh token")) {
                result = AuthResultEnum.INVALID_REFRESH_TOKEN;
            }
        } else if (className.contains("InvalidScopeException")) {
            result = AuthResultEnum.INVALID_SCOPE;
        } else if (className.contains("InvalidTokenException")) {
            result = AuthResultEnum.INVALID_TOKEN;
        } else if (className.contains("InvalidRequestException")) {
            result = AuthResultEnum.INVALID_REQUEST;
        } else if (className.contains("RedirectMismatchException")) {
            result = AuthResultEnum.REDIRECT_URI_MISMATCH;
        } else if (className.contains("UnsupportedGrantTypeException")) {
            result = AuthResultEnum.UNSUPPORTED_GRANT_TYPE;
        } else if (className.contains("UnsupportedResponseTypeException")) {
            result = AuthResultEnum.UNSUPPORTED_RESPONSE_TYPE;
        } else if (className.contains("UserDeniedAuthorizationException")) {
            result = AuthResultEnum.ACCESS_DENIED;
        } else if (className.contains("AccessDeniedException")) {
            result = AuthResultEnum.ACCESS_DENIED;
            if (AuthResultEnum.ACCESS_DENIED_BLACK_LIMITED.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_BLACK_LIMITED;
            } else if (AuthResultEnum.ACCESS_DENIED_WHITE_LIMITED.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_WHITE_LIMITED;
            } else if (AuthResultEnum.ACCESS_DENIED_AUTHORITY_EXPIRED.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_AUTHORITY_EXPIRED;
            } else if (AuthResultEnum.ACCESS_DENIED_UPDATING.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_UPDATING;
            } else if (AuthResultEnum.ACCESS_DENIED_DISABLED.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_DISABLED;
            } else if (AuthResultEnum.ACCESS_DENIED_NOT_OPEN.getMessage().contains(message)) {
                result = AuthResultEnum.ACCESS_DENIED_NOT_OPEN;
            }
        }
        return Result.error(result);
    }

}






@Getter
@Setter
public class CustomException extends RuntimeException {

    private static final long serialVersionUID = 8850249886493567889L;

    private int code = 500;

    private String message;

    public CustomException() {
        super();
    }

    public CustomException(ResultCode resultCode) {
        this.code = resultCode.getCode();
        this.message = resultCode.getMessage();
    }

    public CustomException(String message) {
        this.message = message;
    }

}




 


Thread 线程池设置




/**
 * 线程工厂
 *
 * @author test
 * @date 2020-05-07
 */
public class MyThreadFactory implements ThreadFactory {

    private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    MyThreadFactory() {
        SecurityManager securityManager = System.getSecurityManager();
        group = (securityManager != null) ? securityManager.getThreadGroup() : Thread.currentThread().getThreadGroup();
        namePrefix = StrUtil.concat(true, "MyThreadPool-", String.valueOf(POOL_NUMBER.getAndIncrement()), "-thread-");
    }

    @Override
    public Thread newThread(Runnable runnable) {
        Thread thread = new Thread(group, runnable, namePrefix + threadNumber.getAndIncrement(), 0);
        if (thread.isDaemon()) {
            thread.setDaemon(false);
        }
        if (thread.getPriority() != Thread.NORM_PRIORITY) {
            thread.setPriority(Thread.NORM_PRIORITY);
        }
        return thread;
    }
}






/**
 * 线程池管理
 *
 * @author test
 * @date 2020-02-25
 */
public class ThreadManager {

    private static ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10, new MyThreadFactory());

    private ThreadManager() {
    }

    private static ThreadManager threadManager = new ThreadManager();

    public static ThreadManager getThreadManager() {
        return threadManager;
    }

    public void execute(Callable callable) {
        executor.submit(callable);
    }

    public void execute(FutureTask futureTask) {
        executor.submit(futureTask);
    }

    public void execute(Runnable runnable) {
        executor.submit(runnable);
    }

}




 


常量设置




public class SysConstants {

    /**
     * 验证码
     */
    public  interface VerificationCode{

        /**
         * 验证码 redis key 前缀
         */
        String REDIS_KEY_PREFIX="verification:";
    }
}




 






        

        

            posted on 
2021-07-01 23:32 
王伯当 
阅读(119) 
评论(0) 
 
收藏 
举报

        

    










    
    

    
    

    

        

    

        

            
                
                
            
        

    

    
    

    

    





            

        

        

            

导航