Java应用结构规范

一 、分层结构

web（前端请求层）：通过调用业务层服务，处理前端的请求。写controller层

biz/service（业务层） ：提供封装好的能力，并通过对能力进行组装、编排，进行业务逻辑处理。

•  普通方法 @Component组件包装给controller层调用
• RPC调用，如HSF方法的实现

dal（数据层）：对底层数据源进行增删改查操作。DML语句，mapper

client（外部请求层）：定义暴露给其他应用的接口。

        HSF类的Interface类，具体实现在biz/service层。

common（外部公共层/通用中间件）：定义暴露给外部的公共类。

facade（外观层）：通过调用业务层服务，处理外部应用的请求。

core层：进行核心模型的转换，如DO层和DTO转换包成manager类，为组件/接口服务提供。

start层：启动类

二 、分层明细

web（前端请求层）：

包	子包	描述
controller		对接前端的控制器
model		前端请求相关的实体类
	request	前端传入的请求
	vo	返回给前端的实体类
convert		controller请求转化为service请求的转化类、 dto转化为vo的转化类

biz（业务层）：

包	子包	描述
service		查询服务和域服务
	query	查询服务
	fulfilOrder	举例：履约单服务
ability		域能力
	fulfilOrder	举例：履约单域能力
manager		对应底层数据模型的通用逻辑处理器
remote		外部服务
message	producer	消息发送器
diamond		动态配置
tair		缓存服务
config		业务层配置项，如：bean配置、hsf配置
common		内部公共类
	constansts	仅内部使用的常量
	convert	dto和do的转化器、service请求转化为manager请求的转化器
	enums	仅内部使用的枚举
	model.dto	用于业务处理的实体类载体
	model.request	service和ability的请求类
	model.option	查询的拓展条件，用于判断返回值的填充内容
	utils	工具类

dal（数据层）：

包	子包	描述
mapper		数据处理器
	adb	adb的数据处理器
	tddl	xdb的数据处理器
model		前端请求相关的实体类
	dataobject	数据实体类
	query	数据查询条件
config		数据层配置项，如：mybatis配置、tddl配置、sequence配置

client（外部请求层）：

包	子包	描述
api		暴露给外部的hsf接口

common（外部公共层）：

包	子包	描述
constansts		暴露给外部的常量
enums		暴露给外部的枚举
exception		暴露给外部的异常
model		暴露给外部的实体类
	dto	暴露给外部的dto
	request	暴露给外部的请求
	result	暴露给外部的返回结果
	to	暴露给外部的消息实体

facade（外观层）：

包	子包	描述
api	impl	hsf的实现类
convert		dto和外部dto的转化器、外部的请求转化为service请求的转化器
message
	listener	消息的监听器
	consumer	消息的处理器

start（启动类）

qatest（测试类）

三 、调用关系

注意点：

• 服务和服务直接可以互相调用；

• 服务可以调用多个域的域能力；

• 域能力是封装好的最小颗粒度的能力，不可互相调用；

• 查询服务直接调用manager，不调用域能力；

四  各层规范

web（前端请求层）

• 定义统一的异常处理切面：处理业务异常和其他运行时异常；

biz（业务层）

• 内部服务不做异常处理和返回result封装类，异常都抛给web层和facade层处理。

• 查询服务和其他服务区分开，单独放在一个包中；

• 能力唯一对应一个域，且是封装好的最小颗粒度的能力。

• 外部服务要在remote中做好异常处理和封装；

• 业务层中的common类为仅在应用内部使用的公共类；

dal（数据层）

• mapper要按不同类型的数据源分开存放，如adb和xdb。

common（外部公共层）

• common只存放暴露给外部的实体类、常量和枚举；

• 暴露给外部的dto只保留外部必要的字段，其他字段如feature等不可存在。

facade（外观层）

• 定义统一的异常处理切面：处理业务异常和其他运行时异常；

• facade层的hsf实现类只做简单的参数校验和转化，不要写业务逻辑。

五、通用代码和工具

web（前端请求层）

• 统一异常处理切面

@RestControllerAdvice
public class RestExceptionHandler {


    @ResponseStatus(HttpStatus.OK)
    @ExceptionHandler(Exception.class)
    public Result system(HttpServletRequest req, Exception e) {
        AllLoggers.EXCEPTION.error("RestExceptionHandler.system|servlet:{}|method:{}|code:{}|msg:{}",
                req.getServletPath(),req.getMethod(), e.getMessage(), e);
        return Result.error(ResultCode.BASE.SYSTEM_ERROR);
    }

    @ResponseStatus(HttpStatus.OK)
    @ExceptionHandler(BusinessException.class)
    public Result business(HttpServletRequest req, BusinessException e) {
        AllLoggers.EXCEPTION.error("RestExceptionHandler.business|servlet:{}|method:{}|code:{}|msg:{}",
                req.getServletPath(),req.getMethod(), e.getMessage(), e);
        return Result.error(e.getErrorCode(), e.getErrorMessage());
    }
}

biz（业务层）

• 统一日志打印工具类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public interface AllLoggers {

    /**
     * 应用日志
     */
    Logger APPLICATION = LoggerFactory.getLogger("APPLICATION");

    /**
     * 异常日志
     */
    Logger EXCEPTION = LoggerFactory.getLogger("EXCEPTION");

    /**
     * 业务日志
     */
    Logger BIZ = LoggerFactory.getLogger("BIZ");

    /**
     * hsf日志
     */
    Logger HSF = LoggerFactory.getLogger("HSF");

    /**
     * 入口日志
     */
    Logger MTOP = LoggerFactory.getLogger("MTOP");

}

    
    

    
    
    
    

    
        ${LOG_FILE}/toms-root.log
        
             
            UTF-8
        
        
            ${LOG_PATH}/logs_saved/toms-root.%d{yyyy-MM-dd}.%i.log
            5
            1GB
            20GB
        
    

    
        
            ${CONSOLE_LOG_PATTERN}
            utf8
        
    

    
    
        ${LOG_PATH}/toms-biz.log
        
            ${LOG_PATH}/logs_saved/toms-biz.%d{yyyy-MM-dd}.%i.log
            5
            2GB
            20GB
        
        
             
            UTF-8
        
    

    
    
        ${LOG_PATH}/toms-hsf.log
        
            ${LOG_PATH}/logs_saved/toms-hsf.%d{yyyy-MM-dd}.%i.log
            5
            2GB
            20GB
        
        
             
            UTF-8
        
    

    
    
        ${LOG_PATH}/toms-error.log
        
            ERROR
            ACCEPT
            DENY
        
        
            ${LOG_PATH}/logs_saved/toms-error.%d{yyyy-MM-dd}.%i.log
            5
            2GB
            10GB
        
        
             
            UTF-8
        
    

    
    
        ${LOG_PATH}/toms-exception.log
        
            ${LOG_PATH}/logs_saved/toms-exception.%d{yyyy-MM-dd}.log
            5
        
        
             
            UTF-8
        
    

    
        
    

    
        
        
    

    
        
        
    

    
        
    

• 单位转化工具类

• 
  public class UnitConvertUtils {
  
      /**
       * 米和千米的进率
       */
      public static final double RATE_OF_METRE_AND_KILOMETRE = 1000d;
      public static final int INT_RATE_OF_METRE_AND_KILOMETRE = 1000;
  
      /**
       * 分和元的进率
       */
      public static final double RATE_OF_FEN_AND_YUAN = 100d;
  
      /**
       * 立方厘米和立方米的进率
       */
      public static final double INT_RATE_OF_CM3_AND_M3 = 1000000d;
  
      /**
       * 米转千米
       *
       * @param toConvert
       * @return 异常返回null
       */
      public static Double convertMetre2Kilometre(Long toConvert) {
          if (toConvert == null) {
              return null;
          }
          return toConvert / RATE_OF_METRE_AND_KILOMETRE;
      }
  
      /**
       * 千米转米
       *
       * @param toConvert
       * @return 异常返回null
       */
      public static Long convertKilometre2Metre(Double toConvert) {
          if (toConvert == null) {
              return null;
          }
  
          BigDecimal bigDecimal = BigDecimal.valueOf(toConvert);
          BigDecimal factorBigDecimal = BigDecimal.valueOf(RATE_OF_METRE_AND_KILOMETRE);
  
          return bigDecimal.multiply(factorBigDecimal).longValue();
      }
  
      /**
       * 元转分
       *
       * @param toConvert
       * @return 异常返回null
       */
      public static Long convertYuan2Fen(Double toConvert) {
          if (toConvert == null) {
              return null;
          }
  
          BigDecimal bigDecimal = BigDecimal.valueOf(toConvert);
          BigDecimal factorBigDecimal = BigDecimal.valueOf(RATE_OF_FEN_AND_YUAN);
  
          return bigDecimal.multiply(factorBigDecimal).longValue();
      }
  
      /**
       * 元转分
       *
       * @param toConvert
       * @return 异常返回null
       */
      public static Long convertYuan2Fen(String toConvert) {
          if (toConvert == null) {
              return null;
          }
  
          BigDecimal bigDecimal = BigDecimal.valueOf(ConvertUtils.convertString2Double(toConvert));
          BigDecimal factorBigDecimal = BigDecimal.valueOf(RATE_OF_FEN_AND_YUAN);
  
          return bigDecimal.multiply(factorBigDecimal).longValue();
      }
  
      /**
       * 分转元
       *
       * @param price
       * @return
       */
      public static String convertFen2Yuan(Long price) {
          if (price == null) {
              return null;
          }
  
          return BigDecimal.valueOf(price).divide(new BigDecimal(RATE_OF_FEN_AND_YUAN)).toString();
      }
  
      /**
       * 里程米转换为千米
       *
       * @param distance
       * @return
       */
      public static Double meter2Kilometer(Long distance) {
          if (distance == null) {
              return null;
          }
  
          BigDecimal meter = BigDecimal.valueOf(distance);
          BigDecimal kilometer = meter.divide(new BigDecimal(INT_RATE_OF_METRE_AND_KILOMETRE));
          return kilometer.doubleValue();
      }
  
      /**
       * 立方厘米转立方米
       *
       * @param volume
       * @return
       */
      public static String convertCm32M3(Long volume) {
          if (volume == null) {
              return null;
          }
  
          return BigDecimal.valueOf(volume).divide(new BigDecimal(INT_RATE_OF_CM3_AND_M3)).toString();
      }
  
  }