Dew:一站式微服务解决方案

提供微服务架构指南 + 扩展主流微服务框架

git clone https://github.com/dew-ms/devops-example-todo.git
cd devops-example-todo
# 先执行安装
mvn install -Dmaven.test.skip=true
# 打开两个命令窗口分别启动两个组件（各组件的作用后文会说明）
mvn spring-boot:run -pl backend/services/kernel
mvn spring-boot:run -pl backend/services/compute
# 打开新的命令窗口，启动前端
cd frontend && npm install && npm run dev:h5
# 自动打开浏览器，切换到移动模式体验

|- backend                  // 后端服务
|-  |- libraries            // 类库
|-  |-  |- common           // 公共模块，三个服务组件都依赖于此
|-  |- services             // 服务组件
|-  |-  |- kernel           // 核心服务，与前端交互的唯一入口
|-  |-  |- compute          // 公式计算服务，由kernel通过Rest调用
|-  |-  |- notifier         // 通知服务，由kernel通过MQ调用
|- frontend                 // 前端
|- pom.xml                  // 父Pom

<!-- 引用 Dew的 parent-starter -->
<parent>
    <groupId>group.idealworld.dew</groupId>
    <artifactId>parent-starter</artifactId>
    <version>...</version>
</parent>

<!-- ... -->

<!-- ... -->

<dependencies>
    <dependency>
        <groupId>group.idealworld.dew</groupId>
        <artifactId>boot-starter</artifactId>
    </dependency>
    <!-- 添加JPA支持  -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

<!-- ... -->

<!-- ... -->

    <dependencies>
        <dependency>
            <groupId>group.idealworld.dew.devops.it</groupId>
            <artifactId>todo-common</artifactId>
        </dependency>
        <!-- 引用 cluster-spi-redis 实现Dew集群能力的Redis实现 -->
        <dependency>
            <groupId>group.idealworld.dew</groupId>
            <artifactId>cluster-spi-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>group.idealworld.dew</groupId>
            <artifactId>test-starter</artifactId>
            <!--仅用于演示， 启用内嵌的Redis及 H2-->
            <scope>compile</scope>
        </dependency>
    </dependencies>

<!-- ... -->

dew:
  cluster:
    mq: redis # 使用Redis做为Dew集群的MQ实现

# ...

spring:
  redis: # Redis配置
    host: localhost
    port: 6379
    database: 0
  datasource: # DB配置
    url: jdbc:sqlite:sample.db

todo-compute:
  ribbon: # 使用自定义ribbon列表
    listOfServers: localhost:8082

# ...

/**
 * 空实现，做为所有组件启动类的父类
 */
// 启用 Spring Boot 能力
@SpringBootApplication
public class TodoParentApplication {

}

// 继承自TodoParentApplication
public class TodoKernelApplication extends TodoParentApplication {

    // 启动类
    public static void main(String[] args) {
        new SpringApplicationBuilder(TodoKernelApplication.class).run(args);
    }

}

@RestController
// Swagger文档注解
@Api("TODO示例")
@RequestMapping("/api")
public class TodoController {

    @Autowired
    private TodoService todoService;

    /**
     * Add int.
     *
     * @param content the content
     * @return the int
     */
    @PostMapping("")
    @ApiOperation(value = "添加Todo记录")
    public Todo add(@RequestBody String content) {
        return todoService.add(content);
    }

    // ...

}

@Service
public class TodoService {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * Add int.
     *
     * @param content the content
     * @return id int
     */
    public Todo add(String content) {
        if (content.trim().startsWith("=")) {
            // 去掉 = 号
            content = content.trim().substring(1);
            // 此为幂等修改操作，故使用 put 方法
            // restTemplate 的 put 方法没有返回值，只能使用此方式
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.TEXT_PLAIN);
            HttpEntity<String> entity = new HttpEntity<>(content, headers);
            // 使用Spring的 restTemplate 实现服务间 rest 调用
            // computeService 为配置的服务地址，在Kubernetes下为service name + port
            content = restTemplate
                    .exchange(computeService + "/compute", HttpMethod.PUT, entity, String.class)
                    .getBody();
        }
        // ...
        // 使用Dew的集群MQ功能实现消息点对点发送
        Dew.cluster.mq.request(Constants.MQ_NOTIFY_TODO_ADD, $.json.toJsonString(todo));
        return todo;
    }

    // ...
}

@RestController
public class NotifierController {

    private static final Logger LOGGER = LoggerFactory.getLogger(NotifierController.class);

    @PostConstruct
    public void processTodoAddEvent() {
        // 使用Dew的集群MQ功能实现消息点对点接收
        Dew.cluster.mq.response(Constants.MQ_NOTIFY_TODO_ADD, todo -> {
            LOGGER.info("Received add todo event :" + todo);
        });
    }

    // ...
}

此章节关联示例:examples/bone-example

<!--引入Dew父依赖，也可以使用import方式-->
<parent>
    <groupId>group.idealworld.dew</groupId>
    <artifactId>parent-starter</artifactId>
    <!--生产环境请选择合适的版本!-->
    <version>${dew.version}</version>
</parent>
...
<dependencies>
    <!--引入需要的模块-->
    <dependency>
        <groupId>group.idealworld.dew</groupId>
        <artifactId>对应模块名，见下文</artifactId>
    </dependency>
</dependencies>
...
<!--开发者介绍-->
<developers>
    <developer>
        <name>...</name>
        <email>...</email>
    </developer>
</developers>
<!--SCM信息-->
<scm>
    <connection>...</connection>
    <developerConnection>...</developerConnection>
    <url></url>
</scm>
...

// 获取集群操作能力，见下文
Dew.cluster.xx
// 获取通知操作能力，见下文
Dew.notify.xx
// 获取Spring上下文
Dew.applicationContext.xx
// 获取Dew配置，说见 框架配置速查
Dew.dewConfig.xx
// 获取认证处理能力，见下文
Dew.auth.xx

//  ============ 获取请求上下文信息  ============
// 当次请求的ID
Dew.context().getId()
// 请求来源IP
Dew.context().getSourceIP()
// 请求最初的URL
Dew.context().getRequestUri()
// 请求对应的token，详见下文
Dew.context().getToken()
// 请求对应的操作者信息，详见下文
Dew.context().optInfo()

// ============ 获取当前组件基础信息 ============
// 应用名称，对应为 spring.application.name
Dew.Info.name
// 应用环境，对应为 spring.profiles.active
Dew.Info.profile
// 应用主机Web端口，对应为 server.port
Dew.Info.webPort
// 应用主机IP
Dew.Info.ip
// 应用主机Host
Dew.Info.host
// 应用实例，各组件实例唯一
Dew.Info.instance

// ============ 定时任务操作 ============
// 此类下的操作会自动带入Dew.context()
/**
* 设定一个周期性调度任务.
*
* @param initialDelaySec 延迟启动的秒数
* @param periodSec       周期调度秒数
* @param fun             调度方法
*/
Dew.Timer.periodic(long initialDelaySec, long periodSec, VoidExecutor fun)
/**
* 设定一个定时任务.
*
* @param delaySec 延迟启动的秒数
* @param fun      定时任务方法
*/
Dew.Timer.timer(long delaySec, VoidExecutor fun)

// ============ 常用工具 ============
/**
* 获取真实IP.
*
* @param request 请求信息
* @return 真实的IP
*/
Dew.Util.getRealIP(HttpServletRequest request)
**
* 获取真实IP.
*
* @param requestHeader     请求头信息
* @param defaultRemoteAddr 缺省的IP地址
* @return 真实的IP
*/
Dew.Util.getRealIP(Map<String, String> requestHeader, String defaultRemoteAddr)
/**
* 创建一个新的线程.
* <p>
* 自动带入Dew.context()
*
* @param fun 执行的方法
*/
Dew.Util.newThread(Runnable fun)

/**
* 统一异常处理.
* <p>
* 封装任意异常到统一的格式，见下文
*
* @param <E>            上抛的异常类型
* @param code           异常编码
* @param ex             上抛的异常对象
* @param customHttpCode 自定义Http状态码
* @return 上抛的异常对象
*/
Dew.E.e(String code, E ex, int customHttpCode)

// Dew Common 功能均以 $ 开始，如:

//Json转成Java对象:
$.json.toObject(json,JavaModel.class)
//Json字符串转成List对象
$.json.toList(jsonArray, JavaModel.class)
//Bean复制
$.bean.copyProperties(ori, dist)
//获取Class的注解信息
$.bean.getClassAnnotation(IdxController.class, TestAnnotation.RPC.class)
//非对称加密
$.encrypt.Asymmetric.encrypt(d.getBytes("UTF-8"), publicKey, 1024, "RSA")
//Http Get
$.http.get("https://httpbin.org/get")
//验证手机号格式是否合法
$.field.validateMobile("18657120000")
//...

此章节关联示例:cluster-example

{
    "code": "", // 响应编码，与http状态码类似，200表示成功
    "message":"", // 响应附加消息，多有于错误描述
    "body": // 响应正文
}

public Resp<String> test(){
    return Resp.success("enjoy!");
    // OR return Resp.notFound("…")/conflict("…")/badRequest("…")/…
}

/**
* 统一异常处理.
* <p>
* 封装任意异常到统一的格式，见下文
*
* @param <E>            上抛的异常类型
* @param code           异常编码
* @param ex             上抛的异常对象
* @param customHttpCode 自定义Http状态码
* @return 上抛的异常对象
*/
Dew.E.e(String code, E ex, int customHttpCode)

// 业务代码捕获了一个异常
Exception someError = new IOException("xxx不存在")
// 使用统一异常处理封装
throw Dew.E.e("NBE00123",someError,200)
// 请求方得到的结果为 http状态=200，响应体：
{
    "code": "NBE00123",
    "message": "xxx不存在",
    "body": null
}

dew:
  basic:
    error-mapping:
      "[<异常类名>]":
        http-code: # http状态码，不存在时使用实例级http状态码
        business-code: # 业务编码，不存在时使用实例级业务编码
        message: # 错误描述，不存在时使用实例级错误描述

dew:
  basic:
    error-mapping:
      "java.io.IOException":
        http-code: 200
        business-code: "NBE00123"

@RestController
@Api(value = "测试")
@RequestMapping(value = "/test/")
@Validated
public class WebController {

    /**
     * Valid create user dto.
     *
     * @param userDTO the user dto
     * @return the user dto
     */
    @PostMapping(value = "valid-create")
    public UserDTO validCreate(@Validated(CreateGroup.class) @RequestBody UserDTO userDTO) {
        return userDTO;
    }

    /**
     * Valid update user dto.
     *
     * @param userDTO the user dto
     * @return the user dto
     */
    @PostMapping(value = "valid-update")
    public UserDTO validUpdate(@Validated(UpdateGroup.class) @RequestBody UserDTO userDTO) {
        return userDTO;
    }

    /**
     * Valid in method.
     *
     * @param age the age
     * @return the string
     */
    @GetMapping(value = "valid-method-spring/{age}")
    public String validInMethod(@Min(value = 2, message = "age必须大于2") @PathVariable("age") int age) {
        return String.valueOf(age);
    }

    /**
     * Valid in method.
     *
     * @param phone the phone
     * @return the string
     */
    @GetMapping(value = "valid-method-own/{phone}")
    public String validInMethod(@Phone @PathVariable("phone") String phone) {
        return phone;
    }

    public static class UserDTO {

        @NotNull(groups = CreateGroup.class)
        @IdNumber(message = "身份证号错误", groups = {CreateGroup.class, UpdateGroup.class})
        private String idCard;

        @Min(value = 10, groups = {CreateGroup.class, UpdateGroup.class})
        private Integer age;

        @NotNull(groups = CreateGroup.class)
        @Phone(message = "手机号错误", groups = {CreateGroup.class, UpdateGroup.class})
        private String phone;

        // Get & Set ...
    }

}

dew:
  security:
    cors:
      allow-origin: # 允许来源，默认 *
      allow-methods: # 允许方法，默认 POST,GET,OPTIONS,PUT,DELETE,HEAD
      allow-headers: # 允许头信息 x-requested-with,content-type

此章节关联示例:auth-example

dew:
  security:
    token-flag: X-Dew-Token             # Token 标识
    token-kind-flag: X-Dew-Token-Kind   # Token类型 标识
    token-in-header: true               # true：token标识在 header 中，反之在url参数中
    token-hash: false                   # Token值是否需要hash，用于解决token值有特殊字符的情况
    router:                             # 路由功能
      enabled: false                    # 是否启用
      block-uri:                        # URL阻止单，支持ant风格
        <Http Method>: [<URLs>]         # URL阻止单列表，Method = all 表示所有方法
      role-auth:                        # 角色认证
        <Role Code>:                    # 角色编码，角色可以带租户，使用.分隔，e.g. tenant1.admin / tenant2.admin
          <Http Method>: [<URLs>]       # 只有该角色才能访问的URL，支持ant风格，支持继承与重写，Method = all 表示所有方法
    token-kinds:                        # Token类型，可为不同的Token类型设置不同的过期时间、保留的版本
      <Kind>:                           # Token类型名称，比如 PC/Android/... ，默认会创建名为 DEFAULT 的类型
        expire-sec: 86400               # Token 过期时间（秒）
        revision-history-limit: 0       # Token 保留的历史版本数量， 0表示不保留历史版本，即有新的登录时会删除此类型下之前所有的Token

// 添加登录信息，optInfo封装自鉴权系统过来的登录信息
// 一般在登录认证后操作
Dew.auth.setOptInfo(OptInfo optInfo);
// 获取登录信息，要求在http请求加上token信息
Dew.context().optInfo();
// 删除登录信息
// 一般在注销登录OptInfo后操作
Dew.auth.removeOptInfo();

// 登录信息
public class OptInfo {
    // Token
    String token;
    // 账号编码
    String accountCode;
}

/**
 * 模拟用户注册.
 */
@PostMapping(value = "user/register")
public Resp<Void> register(@RequestBody User user) {
    // 实际注册处理
    user.setId($.field.createUUID());
    MOCK_USER_CONTAINER.put(user.getId(), user);
    return Resp.success(null);
}

/**
 * 模拟用户登录.
 */
@PostMapping(value = "auth/login")
public Resp<String> login(@RequestBody LoginDTO loginDTO) {
    // 实际登录处理
    User user = MOCK_USER_CONTAINER.values().stream().filter(u -> u.getIdCard().equals(loginDTO.getIdCard())).findFirst().get();
    String token = $.field.createUUID();
    Dew.auth.setOptInfo(new OptInfoExt()
            .setIdCard(user.getIdCard())
            .setAccountCode($.field.createShortUUID())
            .setToken(token)
            .setName(user.getName())
            .setMobile(user.getPhone())
            .setRoleInfo(new HashSet<>() {
                {
                    add(new OptInfo.RoleInfo()
                            .setCode(userDTO.getRole())
                            .setName("..")
                    );
                }
            }));
    return Resp.success(token);
}

/**
 * 模拟业务操作.
 */
@GetMapping(value = "business/someopt")
public Resp<Void> someOpt() {
    // 获取登录用户信息
    Optional<OptInfoExt> optInfoExtOpt = Dew.auth.getOptInfo();
    if (!optInfoExtOpt.isPresent()) {
        return Resp.unAuthorized("用户认证错误");
    }
    // 登录用户的信息
    optInfoExtOpt.get();
    return Resp.success(null);
}

/**
 * 模拟用户注销.
 */
@DeleteMapping(value = "auth/logout")
public Resp<Void> logout() {
    // 实际注册处理
    Dew.auth.removeOptInfo();
    return Resp.success(null);
}

package group.idealworld.dew.core.auth;

import group.idealworld.dew.Dew;
import group.idealworld.dew.core.auth.dto.OptInfo;

import java.util.Optional;

/**
 * 登录鉴权适配器.
 *
 * @author gudaoxuri
 */
public interface AuthAdapter {

    /**
     * 获取当前登录的操作用户信息.
     *
     * @param <E> 扩展操作用户信息类型
     * @return 操作用户信息
     */
    default <E extends OptInfo> Optional<E> getOptInfo() {
        return Dew.context().optInfo();
    }

    /**
     * 根据Token获取操作用户信息.
     *
     * @param <E>   扩展操作用户信息类型
     * @param token 登录Token
     * @return 操作用户信息
     */
    <E extends OptInfo> Optional<E> getOptInfo(String token);

    /**
     * 设置操作用户信息类型.
     *
     * @param <E>     扩展操作用户信息类型
     * @param optInfo 扩展操作用户信息
     */
    <E extends OptInfo> void setOptInfo(E optInfo);

    /**
     * 删除当前登录的操作用户信息.
     * <p>
     * 对指注销登录
     */
    default void removeOptInfo() {
        getOptInfo().ifPresent(optInfo -> removeOptInfo(optInfo.getToken()));
    }

    /**
     * 根据Token删除操作用户信息.
     *
     * @param token 登录Token
     */
    void removeOptInfo(String token);
}

// 自定义适配器
public class CustomAuthAdapter implements AuthAdapter {

 // ...

}

// 注册为Bean（可选，如果自定义适配器用到Spring功能时必须）
@Bean
public CustomAuthAdapter customAuthAdapter() {
    return new CustomAuthAdapter();
}

// 注册自定义适配器
Dew.auth = new CustomAuthAdapter() // 或 Bean实例

<dependency>
    <groupId>group.idealworld.dew</groupId>
    <artifactId>test-starter</artifactId>
</dependency>

dew:
  cluster: #所有集群操作都使用reids模拟
    cache: redis
    lock: redis
    map: redis
    mq: redis

spring:
  redis:
    host: 127.0.0.1
    port: 6379
  datasource:
    url: jdbc:sqlite:sample.db

此章节关联示例:idempotent-example

<!--引入幂等支持-->
<dependency>
    <groupId>group.idealworld.dew</groupId>
    <artifactId>idempotent-starter</artifactId>
</dependency>

dew:
  cluster:
    cache: redis # 启用Redis支持
  idempotent:
    default-expire-ms: 3600000 # 设置默认过期时间，1小时
    default-strategy: item # 设置默认策略，支持 bloom(Bloom Filter)和item(逐条记录)，目前只支持item
    default-opt-id-flag: __IDEMPOTENT_OPT_ID__ # 指定幂等操作ID标识，可以位于HTTP Header或请求参数中

@GetMapping(xxx)
// 启用幂等支持
// 请求头部或参数加上__IDEMPOTENT_OPT_ID__ = xx
@Idempotent
public void test(xxx) {
    // 业务操作
    // ...
    // 业务失败，在保证业务操作的原子性的情况下，在catch中取消幂等，并抛出异常
    DewIdempotent.cancel();
    // 手工确认
    DewIdempotent.confirm();
}

// 初始化类型为transfer_a的幂等操作，需要手工确认，过期时间为1秒
DewIdempotent.initOptTypeInfo("transfer_a", true, 1000, StrategyEnum.ITEM);
// 第一次请求transfer_a类型下的xxxxxxx这个ID，返回不存在，表示可以下一步操作
Assert.assertEquals(StatusEnum.NOT_EXIST, DewIdempotent.process("transfer_a", "xxxxxxx"));
// 第二次请求transfer_a类型下的xxxxxxx这个ID，返回未确认，表示上次操作还在进行中
Assert.assertEquals(StatusEnum.UN_CONFIRM, DewIdempotent.process("transfer_a", "xxxxxxx"));
// 确认操作完成
DewIdempotent.confirm("transfer_a", "xxxxxxx");
// 第三次请求transfer_a类型下的xxxxxxx这个ID，返回已确认，但未过期，仍不能操作
Assert.assertEquals(StatusEnum.CONFIRMED, DewIdempotent.process("transfer_a", "xxxxxxx"));
// 延时1秒
Thread.sleep(1000);
// 再次请求transfer_a类型下的xxxxxxx这个ID，返回不存在（上次请求已过期），表示可以下一步操作
Assert.assertEquals(StatusEnum.NOT_EXIST, DewIdempotent.process("transfer_a", "xxxxxxx"));

dew:                                    # Dew 参数key前缀
  basic:                                # 基础配置
    name:                               # 服务名称，用于API文档显示等
    version: 1.0                        # 服务版本号，用于API文档显示等
    desc:                               # 服务描述，用于API文档显示等
    webSite:                            # 官网，用于API文档显示等
    doc:                                # 文档配置
      enabled: true                     # 是否启用默认文档配置，关闭后可自定义文档管理，默认为true
      base-package:                     # API文档要扫描的根包，多指定到 Controller 包中
      contact:                          # 联系人信息
        name:                           # 联系人姓名
        url:                            # 联系人URL
        email:                          # 联系人邮箱
    format:                             # 格式化配置
      use-unity-error: true             # 是否启用统一响应
      auto-trim-from-req: false         # 是否自动去掉请求中字符串类型的前后空格
      error-flag: __DEW_ERROR__         # 默认的通知标识
    error-mapping:                      # 自定义错误映射
      "[<>]":                           # 异常类名
        http-code:                      # http状态码，不存在时使用实例级http状态码
        business-code:                  # 业务编码，不存在时使用实例级业务编码
        message:                        # 错误描述，不存在时使用实例级错误描述
  cluster:                              # 集群功能
    cache: redis                        # 缓存实现
    lock: redis                         # 分布式锁实现，可选 redis/hazelcast，默认redis
    map: redis                          # 分布式Map实现，可选 redis/hazelcast，默认redis
    mq: redis                           # MQ实现，可选 redis/hazelcast/rabbit，默认redis
    election: redis                     # 领导者选举实现，可选 redis，默认redis
    config:                             # 集群相关配置
      election-period-sec: 60           # 领导者选举时间区间，默认60秒
      ha-enabled: false                 # 是否启用HA，默认为false
  notifies:                             # 通知功能
    "":                                 # 通知的标识
      type: DD                          # 通知的类型，DD=钉钉 MAIL=邮件，邮件方式需要有配置spring.mail下相关的smtp信息 HTTP=自定义HTTP Hook
      defaultReceivers:                 # 默认接收人列表，钉钉为手机号，邮件为邮箱
      dndTimeReceivers:                 # 免扰时间内的接收人列表，只有该列表中的接收人才能在免扰时间内接收通知
      args:                             # 不同类型的参数，邮件不需要设置
        url:                            # type=DD表示钉钉的推送地址
                                        # 说明详见：https://open-doc.dingtalk.com/microapp/serverapi2/qf2nxq
                                        # type=HTTP表示HTTP Hook的地址
        msgType:                        # 仅用于type=DD，支持 text/markdown
      strategy:                         # 通知策略
        minIntervalSec: 0               # 最小间隔的通知时间，0表示不设置，如为10则表示10s内只会发送一次
        dndTime:                        # 免扰时间，HH:mm-HH:mm 如，18:00-06:00
                                        # HH:mm-HH:mm，如果两个时间相等表示全天免扰，如果后者大于前者表示跨天免扰
        forceSendTimes: 3               # 同一免扰周期间通知调用达到几次后强制发送
  security:                             # 安全功能
    cors:                               # 跨域设置
      allow-origin: *                   # 允许的来源，建议修改
      allow-methods: POST,GET,OPTIONS,PUT,DELETE,HEAD
                                        # 允许的方法
      allow-headers: x-requested-with,content-type
                                        # 允许的头信息
    token-flag: X-Dew-Token             # Token 标识
    token-kind-flag: X-Dew-Token-Kind   # Token类型 标识
    token-in-header: true               # true：token标识在 header 中，反之在url参数中
    token-hash: false                   # Token值是否需要hash，用于解决token值有特殊字符的情况
    un-ident-urls:                      # 不需要认证的URL列表，英文逗号分隔
    router:                             # 路由功能
      enabled: false                    # 是否启用
      block-uri:                        # URL阻止单，支持ant风格
        <Http Method>: [<URLs>]         # URL阻止单列表，Method = all 表示所有方法
      role-auth:                        # 角色认证
        <Role Code>:                    # 角色编码，角色可以带租户，使用.分隔，e.g. tenant1.admin / tenant2.admin
          <Http Method>: [<URLs>]       # 只有该角色才能访问的URL，支持ant风格，支持继承与重写，Method = all 表示所有方法
    token-kinds:                        # Token类型，可为不同的Token类型设置不同的过期时间、保留的版本
      <Kind>:                           # Token类型名称，比如 PC/Android/... ，默认会创建名为 DEFAULT 的类型
        expire-sec: 86400               # Token 过期时间（秒）
        revision-history-limit: 0       # Token 保留的历史版本数量， 0表示不保留历史版本，即有新的登录时会删除此类型下之前所有的Token
    error:                              # 错误配置
      enabled: false                    # 启用降级邮件通知，默认为false
      notify-event-types: FAILURE,SHORT_CIRCUITED,TIMEOUT,THREAD_POOL_REJECTED,SEMAPHORE_REJECTED
                                        # 通知的事件类型
      notify-include-keys:              # 需监控的方法key值，与notify-exclude-keys互斥，client类名+#+方法名，for example:  ExampleClient#deleteExe(int,String)
      notify-exclude-keys:              # 不需要监控的方法key值，与notify-include-keys互斥，client类名+#+方法名，for example:  ExampleClient#deleteExe(int,String)
  idempotent:                           # 需要引入 idempotent-starter 模块
    default-expire-ms: 3600000          # 设置默认过期时间，1小时
    default-strategy: item              # 设置默认策略，目前支持item(逐条记录)
    default-opt-id-flag: __IDEMPOTENT_OPT_ID__
                                        # 指定幂等操作ID标识，可以位于HTTP Header或请求参数中
  mw:                                   # 中间件
    mqtt:                               # MQTT集群实现
      broker:                           # Broker地址，e.g. tcp://127.0.0.1:1883
      clientId: Dew_Cluster_<Cluster.instanceId>
                                        # 连接客户端ID，注意一个集群内客户端ID必须唯一
      persistence:                      # 存储，默认为File，可选 memory
      userName:                         # 用户名
      password:                         # 密码
      timeoutSec:                       # 连接超时时间
      keepAliveIntervalSec:             # 心跳间隔时间
      cleanSession: true                # 是否消除Session

spring:                                 # 常用 Spring 配置
  application:
    name:                               # 项目名称,若使用Dew，请配置
  mail:                               # Mail配置
    host: smtp.163.com
    username:
    password:
    properties:
      mail:
        smtp:
          auth: true
            starttls:
              enable: true
              required: true
  redis:
    host:                           # Redis主机
    port:                           # Redis端口
    database:                       # Redis数据库
    password:                       # Redis密码
    lettuce:
      pool:                         # 连接池配置
    multi:                          # 多实例支持（Dew功能）
      <key>:                        # 实例名称
                                    # 可用 Dew.cluster.caches.instance(<key>) 获取
                                    # 同时可以用 @Autowired <Key>RedisTemplate 获取Bean
        host:                       # Redis主机
        port:                       # Redis端口
        ...
  rabbitmq:
    host:                           # Rabbit主机
    port:                           # Rabbit端口
    username:                       # Rabbit用户名
    password:                       # Rabbit密码
    virtual-host:                   # Rabbit VH
  hazelcast:
    username:
    password:
    addresses: ["127.0.0.1"]

server:
  port: 8081                          # 服务端口

management:
  endpoints:
    web:
      base-path: /management          # 管理路径前缀

logging:
  level:
    ROOT: INFO
    group.idealworld.dew: DEBUG                     # Dew目录日志配置
    org.springframework.jdbc.core: TRACE
                                      # Jdbc目录日志配置

X Build Project                 // 构建工程
|- sources                      // 源码目录
|-  |- basics                   // 基础源码，为各服务工程的依赖，要求deploy到Maven仓库
|-  |-  |- parent               // 父工程，所有服务端应用的根POM
|-  |-  |- common               // 公共工程，所有服务端应用的基础依赖
|-  |-  |- common-service       // 公共服务工程，所有服务工程的根POM，自身依赖于common
|-  |-  |- <...>                // 其它基础工程，比如common-spark，大数据服务的基础依赖
|-  |- services                 // 服务源码，对应于一个个微服务
|-  |-  |- <service 1>          // 服务1工程
|-  |-  |- <service ...>        // 其它服务工程
|-  |- sdk                      // SDK源码，如项目需要提供SDK时建立此目录
|-  |-  |- <java>               // Java版本的SDK工程
|-  |-  |- <js>                 // JS版本的SDK工程
|-  |-  |- <rest>               // REST版本的SDK工程
|-  |-  |- <...>                // 其它语言版本的SDK工程
|-  |- terminals                // 终端源码
|-  |-  |- <android>            // Android APP工程
|-  |-  |- <ios>                // IOS APP工程
|-  |-  |- <wechat>             // Wechat工程
|-  |-  |- <...>                // 其它终端工程
|- docs                         // 文档工程，所有团队共同维护，Asciidoc方案，后文会介绍
|-  |- src
|-  |-  |- main
|-  |-  |-  |- asciidoc
|-  |-  |-  |-  |- book.adoc    // 文档主目录
|-  |-  |-  |-  |- <...>        // 分模块建立不同的文档文件
|-  |-  |- resources            // 文档引用资源目录，如图片、CSS
|-  |-  |-  |- images
|-  |-  |-  |-  |- <...>
|-  |-  |- pom.xml              // 文档工程使用Maven管理
|-  |-  |- .gitignore
|- env                          // 环境配置工程，以Spring Cloud Config为例，配置存放于Git
|-  |- application.yml
|-  |- <...>
|-  |- .gitignore
|- pom.xml                      // 构建工程的POM
|- .gitmodules                  // Git子模块定义，所有工程都注册到此文件中
|- .gitignore
|- README.adoc                  // 构建工程使用说明

|- X service
|-  |- src
|-  |-  |- main
|-  |-  |-  |- java
|-  |-  |-  |-  |- src
|-  |-  |-  |-  |-  |- x.y.z
|-  |-  |-  |-  |-  |-  |- XApplication (1)
|-  |-  |-  |-  |-  |-  |- XConfig (2)
|-  |-  |-  |-  |-  |-  |- XInitiator (3)
|-  |-  |-  |-  |-  |-  |- controller
|-  |-  |-  |-  |-  |-  |-  |- EventController (4)

# 在Maven中配置自定义的 checkstyle 文件的路径
<properties>
    <checkstyle.config.path>../../checkstyle/checkstyle.xml</checkstyle.config.path>
</properties>

# 使用Maven命令
mvn -P qa compile

# 也可以IDE的checkstyle插件实现

@Bean
RedisCacheManager cacheManager() {
    final RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
    redisCacheManager.setUsePrefix(true);
    redisCacheManager.setDefaultExpiration(<过期秒数>);
    return redisCacheManager;
}

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/dew?useUnicode=true&characterEncoding=utf-8&rewriteBatchedStatements=true
    username: root
    password: 123456