package org.xujin.halo.extension;

import org.xujin.halo.annotation.extension.Extension;

/**
 * 支付宝支付扩展
 * @author xujin
 */
@Extension(name = "支付包支付扩展", bizCode = "com.pay.alipay",desc = "支付宝支付扩展") (1)
public class AliPayExtension implements PayExtPt {

    @Override
    public String pay(Object object) {
        return "支付包支付扩展";
    }

    @Override
    public void pay() {
    }
}

package org.xujin.halo.extension;

import org.xujin.halo.annotation.extension.Extension;

package org.xujin.halo.extension;

import org.xujin.halo.annotation.extension.Extension;

@Extension(name = "微信支付扩展", bizCode = "com.pay.weixinPay",desc = "微信支付扩展")
public class WeiXinPayExtension implements PayExtPt {

    @Override
    public String pay(Object object) {
        return "微信支付扩展";
    }

    @Override
    public void pay() {
    }

}

@PreInterceptor(
cmdFilterList = DeleteAppCmd.class (2)
)
public class LoggerPreInterceptor implements CommandInterceptorI<Command> { (1)

    @Override
    public void preIntercept(Command command) {
        log.info("before process  DeleteAppCmd");
    }

}

public abstract class Command extends DTO{

	private static final long serialVersionUID = 1L;

	private Context context;

	public Context getContext() {
		return context;
	}

	public void setContext(Context context) {
		this.context = context;
	}
}

public class CommonCommand extends Command {

    private String operater;
    private boolean needsOperator;

    public String getOperater() {
        return this.operater;
    }

    public void setOperater(String operater) {
        this.operater = operater;
        needsOperator = true;
    }

    public boolean isNeedsOperator(){
        return needsOperator;
    }
}

@RestController
@RequestMapping("/admin/app")
@Api(description = "应用管理")
public class AppController {

    @Autowired
    private CommandBus commandBus; (1)

    @PostMapping("")
    @ApiOperation(value = "增加应用")
    public ResultData<Long> addApp(@RequestBody AddAppCmd addAppCmd) {
        return commandBus.send(addAppCmd); (2)
    }
}

/**
  * 查询域树型结构
  * @return
 */
@GetMapping("/domain/queryAllDomain")
public ResultData<List<DomainCO>> getAllDomain() {
    return commandBus.send(QueryIdeaDomainListCmdExe.class);  (1)
}

public class AddAppCmdExe implements CommandExecutorI<ResultData<Long>, AddAppCmd>{ (1)

    @Autowired
    AppService appService; (2)

    @Autowired
    AppClientConvertor appClientConvertor; (3)

    @Override
    public ResultData<Long> execute(AddAppCmd addAppCmd) {
        AppE appE = appClientConvertor.clientToEntity(addAppCmd);(4)
        ResultData<Long> resultData = ResultData.builder(null);
        if (!check(appE, resultData)) {
            return resultData;
        }
        try {
            appE.save();
            resultData.setData(appE.getId());
        } catch (Exception ex) {
            log.error(String.format("add app failed, appE=%s", appE), ex);
            resultData.setSuccess(false);
            resultData.setCode(500);
            resultData.setMsgContent("添加失败");
        }
        return resultData;
    }

    protected boolean check(AppE appE, ResultData<Long> resultData) { (5)
        try {
            Preconditions.checkNotNull(appE, "appE不能为null");
            Preconditions.checkArgument(!appService.containsAppId(appE.getAppId()), "appId不能重复");
            Preconditions.checkArgument(StringUtils.isNotEmpty(appE.getAppId()), "appId不能为空");
            Preconditions.checkArgument(StringUtils.isNotEmpty(appE.getName()), "name不能为空");
            Preconditions.checkArgument(StringUtils.isNotEmpty(appE.getOwnerName()), "ownerName不能为空");
            Preconditions.checkNotNull(appE.getOwnerId(), "ownerId不能为空");
            Preconditions.checkArgument(StringUtils.isNotEmpty(appE.getDescription()), "description不能为空");
            Preconditions.checkArgument(StringUtils.isNotEmpty(appE.getSpringApplicationName()), "springApplicationName不能为空");
        } catch (Exception ex) {
            resultData.setSuccess(false);
            resultData.setMsgContent(ex.getMessage());
            return false;
        }
        return true;
    }
}

@CmdHandler
public class QueryAllMenuCmdExe implements CommandExecutorWithoutInputI<ResultData<List<UserMenuCO>>> {  (1)

    @Autowired
    private MenuMapper menuMapper;

    @Autowired
    private MenuClientConverter menuClientConverter;

    @Override
    public ResultData<List<UserMenuCO>> execute() {
        List<MenuDO> allMenu = menuMapper.getAllMenu();
        List<UserMenuCO> allMenus = menuClientConverter.dataToClient(allMenu);
        return ResultData.success(allMenus);
    }

}

public interface EventBus {

    /**
     * Send event to EventBus to publish all corresponding handlers synchronously
     * 同步：发送事件到事件总线，触发相应的事件处理器
     *
     * @param event 事件
     */
    public void publishEvent(Event event); (1)


    /**
     * Send event to EventBus to publish all corresponding handlers asynchronously
     * 异步：发送事件到事件总线，触发相应的事件处理器
     *
     * @param event 事件
     */
    public void asyncPublishEvent(Event event); (2)

}

@PostConstruct
public void init() {
    defaultHandlerExeThreadPoll = new ThreadPoolExecutor(0,
            Runtime.getRuntime().availableProcessors() + 1,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(1000), (1)
            new ThreadFactoryBuilder().setNameFormat("event-bus-pool-%d").build());
}

 public interface EventHandlerI<R extends Response, E extends Event> {

    /**
     * 使用方可以根据自己的业务使用场景，可定制线程池来处理
     * @return
     */
    default public ExecutorService getExecutor(){
        return null;
    }

    public R execute(E e);
}

@Data
@Accessors(chain = true)
public class CreateUserRoleEvent extends Event { (1)

    private String userName;

    private String role;

}

@EventHandler
public class CreateUserRoleEventHandler implements EventHandlerI<Response, CreateUserRoleEvent> {

    @Autowired
    private UserRoleService userRoleService;

    @Override
    public Response execute(CreateUserRoleEvent event) {
        if (StringUtils.isNotEmpty(event.getRole()) && StringUtils.isNotEmpty(event.getUserName())) {
            userRoleService.createUserRole(event.getUserName(), event.getRole());
        }
        return Response.buildSuccess();
    }

}

default public ExecutorService getExecutor(){
    return null;
}

@Autowired
private EventBus eventBus; (1)

CreateUserRoleEvent event = new CreateUserRoleEvent(); (2)
event.setRole("USER");
event.setUserName(userName);
eventBus.asyncPublishEvent(event); (3)

@Entity
public class CampaignE {

    /**
     * 营销渠道ID
     */
    private String channelId;

    /**
     * 渠道类型
     */
    private String channelType;

    /**
     * 活动名字
     */
    private String name;

    /**
     * 活动描述
     */
    private String description;

    /**
     * 活动开始时间
     */
    private CampaignTimerV startTime;


    /**
     * 活动选择的模板Id
     */
    private String templateId;

    /**
     * 活动反馈
     */
    private CampaignFeedbackE campaignFeedback;


    private CampaignRepository campaignRepository;

    private MailChannelRepository mailChannelRepository;

    /**
     * 做营销活动
     */
    @DomainAbility
    public void doCampaign() {
        //代码省略
    }

    /**
     * 活动开始
     */
    @DomainAbility
    public void start(){
        if(!isEnabled){
            return;
        }
        this.campaignState = CampaignState.RUNNING;
        this.setModifier("message");
        campaignRepository.save(this);
        //更新定时器
        startTime.setFire(true);
        startTime.setFireTime(new Date());
        campaignRepository.updateTimerMsgStatus(this.id, startTime);
    }

    /**
     * 活动结束
     */
    @DomainAbility
    public void finish(){
         //省略代码
    }

    /**
     * 活动生效
     */
    @DomainAbility
    public void enable(){
         //省略代码
    }

    /**
     * 取消活动
     */
    @DomainAbility
    public void disable(){
        //省略代码
    }

    /**
     * 移除活动
     */
    @DomainAbility
    public void remove(){
        //省略代码
    }

    /**
     * 更新活动
     */
    @DomainAbility
    public void update(){
        //省略其它
        campaignRepository.save(this);
    }
}

/**
 *  统一的应用服务层服务编写接口
 *  I是input  输入参数
 *  O是OutPut 输出参数
 *  @author xujin
 * @param <I>
 */
public interface BaseAppService<I,O> {

    /**
     *  唯一的方法
     * @param input
     * @return
     */
    O execute(I input);
}

package org.xujin.halo.admin.phase;

import org.xujin.halo.annotation.app.Phase;
import org.xujin.halo.command.BaseAppService;

@Phase
public class OnSaleContextInitPhase implements BaseAppService<String,String> {

    @Override
    public String execute(String input) {
        return null;
    }
}

package org.xujin.halo.admin.phase.step;

import org.xujin.halo.annotation.app.Step;
import org.xujin.halo.command.BaseAppService;

@Step
public class PublishOfferStep implements BaseAppService<String,String> {

    @Override
    public String execute(String input) {
        return null;
    }
}

package org.xujin.halo.admin.appservice;

import org.xujin.halo.annotation.app.AppService;
import org.xujin.halo.command.BaseAppService;

@AppService
public class UploadFileService implements BaseAppService<String,String> {

    @Override
    public String execute(String input) {
        return null;
    }
}

public void process(OrderDTO orderDTO) {
    int serviceType = orderDTO.getServiceType();
    if (1 == serviceType) {
        System.out.println("取消即时订单");
    } else if (2 == serviceType) {
            System.out.println("取消预约订单");
    } else if (3 == serviceType) {
            System.out.println("取消拼车订单");
    }
}

if(A类型) {
    if(A1类型) {
        doSomething1();
    }else if(A2类型) {
        doSomething2();
    }
} else if(B类型) {
    doSomething3();
} else if(C类型) {
    if(C1类型) {
        doSomething4();
    }else if(C2类型) {
        doSomething5();
    }
}

/**
 *  扩展点注解
 *  @author xujin
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExtensionPoint {

    /**
     * 扩展点id
     * @return
     */
    String id() default "";

    /**
     * 扩展点名称
     * @return
     */
    String name();

    /**
     * 扩展点描述
     * @return
     */
    String desc();

}

/**
 *  扩展的注解
 * @author xujin
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target({ElementType.TYPE})
@Component
public @interface Extension {

    /**
     * 扩展的Id
     * @return
     */
    String id() default "";

    /**
     * 扩展的名称
     * @return
     */
    String name();

    /**
     * 对应的扩展点Id
     * @return
     */
    String extensionPointId() default "";

    /**
     * 扩展对应的描述
     * @return
     */
    String desc() default "";

    /**
     * 业务身份
     * @return
     */
    String bizCode()  default CoreConstant.DEFAULT_BIZ_CODE;

}

package org.xujin.halo.extension;

import org.xujin.halo.annotation.extension.Extension;

/**
 * 支付宝支付扩展
 * @author xujin
 */
@Extension(name = "支付包支付扩展", bizCode = "com.pay.alipay",desc = "支付宝支付扩展") (1)
public class AliPayExtension implements PayExtPt {

    @Override
    public String pay(Object object) {
        return "支付包支付扩展";
    }

    @Override
    public void pay() {
    }
}

@GetMapping("/extensionExe")
public String exeExtension(String bizCode) {
  Context context = new Context();
  //bizCode可以是前端传递过来的com.pay.alipay
  context.setBizCode(bizCode);
  String result = extensionExecutor.exeReturnValue(PayExtPt.class, context, extension -> extension.pay(null));
  return result;
}

@Component
public class PayMethodBizParser implements BizCodeParser<String> {

    @Override
    public Context bizCodeParser(String object) {

        Context<String> context = new Context<String>();
        context.setBizCode("com.pay.alipay");
        return context;
    }
}

@Autowired PayMethodBizParser payMethodBizParser

Context context=payMethodBizParser.bizCodeParser("提前业务身份需要传递的参数");

extensionExecutor.exeReturnValue(PayExtPt.class, context, extension -> extension.pay(null));

/**
 * B2C出库流程
 * @author xujin
 */
@Flow(name = "b2cOutPutFlow", desc = "B2C出库流程") (1)
public class B2cOutPutFlow {

    /**
     * 开始节点，
     * 一个流程必须得有一个开始节点
     *
     * @return
     */
    @StartNode(nextNodeRoute = {@NextNodeRoute(key = "succes", nodeName = "generateBatch")}) (2)
    public String start() {
        return "succes";
    }


    /**
     * 生成批次
     *
     * @param processResult
     * @return
     */
    @ProcessNode(nextNodeRoute = {@NextNodeRoute(key = "succes", nodeName = "generateWave")},
            name = "generateBatch", handler = "generateBatchProcessor", desc = "该节点用于生成批次")
    public String generateBatch(Boolean processResult) {
        return "succes";
    }

    /**
     * 生成波次
     *
     * @param processResult
     * @return
     */
    @ProcessNode(nextNodeRoute = {
            @NextNodeRoute(key = "succes", nodeName = "createPicking"), (3)
            @NextNodeRoute(key = "fail", nodeName = "end")}, (4)
            name = "generateWave", (5)
            handler = "generateWaveProcessor", (6)
            desc = "该节点用于生成波次"  (7)
            )
    public String generateWave(Boolean processResult) {  (8)
        String nextNodeRouteKey = null;
        if (processResult) {
            nextNodeRouteKey = "succes"; (9)
        } else {
            nextNodeRouteKey = "fail";  (10)
        }
        return nextNodeRouteKey;
    }

    /**
     * 创建拣货单
     *
     * @param processResult
     * @return
     */
    @ProcessNode(nextNodeRoute = {@NextNodeRoute(key = "end", nodeName = "end")},
            name = "createPicking", handler = "createPickingProcessor", desc = "该节点用于创建拣货单")
    public String createPicking(Boolean processResult) {
        return "end";
    }

    /**
     * 结束节点
     */
    @EndNode
    public void end() {  (11)
    }
}

halo:
  flow:
    persistence: true

public interface FlowEngine {

    /**
     * 默认从Start节点执行流程
     * @param flowName  流程名称
     * @param inputData 流程执行入参
     * @return FlowHandleContext<T> 流程执行的结果
     */
    public <T> FlowHandleContext<T> start(String flowName, T inputData); (1)


    /**
     * 从指定节点执行流程
     *
     * @param flowName          流程名称
     * @param flowHandleContext 流程执行上下文
     * @param nodeName          指定节点名称
     * @return FlowHandleContext<T> 流程执行的结果
     */
    public <T> FlowHandleContext<T> start(String flowName, FlowHandleContext<T> flowHandleContext, String nodeName); (2)

}

@Autowired
private FlowEngine flowEngine;

/**
* flowName是流程名称，
**/
flowEngine.start("flowName", inputData);

public class FlowExecutionException extends Exception {

        private static final String MSG_FORMAT = "Halo流程引擎执行流程%s的%s节点时失败";

        /**
         * 流程名称
         */
        private String flowName;

        /**
         * 当前执行节点名称
         */
        private String nodeName;

        /**
         * 流程执行失败时的上下文信息
         */
        private FlowHandleContext context;


        public FlowExecutionException(String flowName, String nodeName, FlowHandleContext context) {
            super(getMsg(flowName, nodeName));
            this.flowName = flowName;
            this.nodeName = nodeName;
            this.context = context;
        }

        private static String getMsg(String flowName, String nodeName) {
            return String.format(MSG_FORMAT, flowName, nodeName);
        }
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface Flow {

    /**
     * 流程名称（默认使用被注解的类名，首字母小写）
     */
    String name(); (1)

    /**
     * 是否开启流程事务（默认开启）
     */
    boolean enableFlowTx() default true;

    /**
     * 指定事务管理器的bean name
     * 用于多个数据源情况下，不指定则使用默认事务管理器
     */
    String txManager() default "";

    /**
     * 当前流程的描述
     *
     * @return
     */
    String desc(); (2)

    /**
     * 流程的唯一Id
     *
     * @return
     */
    String id() default "";

}

tradition-demo
├── README.md
├── pom.xml
├── src
│   └── main
│       ├── java
│       │   └── org
│       │       └── xujin
│       │           └── tradition
│       │               └── demo
│       │                   ├── Application.java    //Spring Boot主入口程序类
│       │                   ├── command             //命令包
│       │                   │   ├── AddUserCmdExe.java  //写命令
│       │                   │   ├── cmo
│       │                   │   │   └── AddUserCmd.java  //命令对象
│       │                   │   ├── co
│       │                   │   │   └── UserCO.java      //客户端对象
│       │                   │   └── query
│       │                   │       └── QueryUserCmdExe.java  //查询命令
│       │                   ├── config
│       │                   │   └── AutoConfig.java    //自己定制的Spring Boot的AutoConfig
│       │                   ├── controller
│       │                   │   └── UserController.java  //Controller
│       │                   ├── converter
│       │                   │   └── UserConverter.java   //整个应用的转换防腐层，比如命令对象转为数据对象，数据对象转为客户端对象
│       │                   ├── dao
│       │                   │   └── UserMapper.java    //MyBatis的Mapper
│       │                   ├── dataobject
│       │                   │   └── UserDO.java       //数据对象
│       │                   ├── service
│       │                   │   ├── UserService.java  //Service层的接口定义
│       │                   │   └── impl
│       │                   │       └── UserServiceImpl.java   //Service层的接口实现，里面注入Mapper
│       │                   └── utils
│       │                       └── Iputil.java        //自己写的工具类
│       └── resources
│           ├── META-INF
│           │   └── app.properties   //Apollo的配置文件
│           ├── application.yml
│           ├── bootstrap.yml
│           ├── logback-spring.xml
│           └── static
│               └── index.html

├-halo-demo
├── halo-demo-app  //应用层
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── xujin
│                       └── halo
│                           └── demo
│                               └── app
│                                   ├── appservice  //应用层服务
│                                   │   └── UploadFileAS.java
│                                   ├── command //命令
│                                   │   ├── AddCustomerCmdExe.java
│                                   │   ├── AddUserCmdExe.java
│                                   │   ├── TestFlowCmdExe.java
│                                   │   ├── cmo //命令对象
│                                   │   │   ├── AddAddressCmd.java
│                                   │   │   ├── AddContactInfoCmd.java
│                                   │   │   ├── AddCustomerCmd.java
│                                   │   │   └── AddUserCmd.java
│                                   │   └── co  //客户端对象
│                                   │       └── UserCO.java
│                                   ├── converter  //转换层
│                                   │   ├── CustomerClientConverter.java
│                                   │   └── UserClientConverter.java
│                                   ├── ext  //扩展点
│                                   │   ├── AlipayExt.java
│                                   │   └── PayExtPt.java
│                                   ├── flow //流程编排
│                                   │   ├── DemoFlow.java
│                                   │   └── node
│                                   │       ├── FirstNodeProcessor.java
│                                   │       └── SecondNodeProcessor.java
│                                   └── interceptor
│                                       └── PhenixContextPreInterceptor.java
├── halo-demo-client  //二方包
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── xujin
│                       └── halo
│                           └── demo
│                               └── client
│                                   └── co
│                                       └── UserCO.java
├── halo-demo-domain //领域层
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── xujin
│                       └── halo
│                           └── demo
│                               └── domain
│                                   ├── customer // A领域
│                                   │   ├── converter //转换层
│                                   │   │   └── CustomerConverter.java
│                                   │   ├── entity  //实体
│                                   │   │   └── CustomerE.java
│                                   │   ├── factory //工厂
│                                   │   │   └── CustomerFactory.java
│                                   │   ├── ports  //端口
│                                   │   │   └── CustomerPort.java
│                                   │   ├── repository //资源库
│                                   │   │   └── CustomerRepository.java
│                                   │   ├── service  //领域服务
│                                   │   │   ├── CustomerSevice.java
│                                   │   │   └── impl
│                                   │   │       └── CustomerServiceImpl.java
│                                   │   └── valueobject
│                                   │       ├── AddressVO.java
│                                   │       └── ContactInfoVO.java
│                                   └── user
│                                       ├── converter
│                                       │   └── UserConverter.java
│                                       ├── entity
│                                       │   └── UserE.java
│                                       ├── factory
│                                       │   └── UserFactory.java
│                                       ├── ports
│                                       │   └── UserPort.java
│                                       ├── repository
│                                       │   └── UserRepository.java
│                                       └── service
│                                           ├── UserService.java
│                                           └── impl
│                                               └── UserServiceImpl.java
├── halo-demo-infrastructure  //基础设施层
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── xujin
│                       └── halo
│                           └── demo
│                               └── infrastructure
│                                   ├── adapters //适配器
│                                   │   ├── CustomerAdapter.java
│                                   │   └── UserAdapter.java
│                                   └── tunnel //数据通道
│                                       └── db
│                                           ├── dao  //Mapper
│                                           │   ├── AddressMapper.java
│                                           │   ├── ContactinfoMapper.java
│                                           │   ├── CustomerMapper.java
│                                           │   └── UserMapper.java
│                                           └── dataobject  //数据对象
│                                               ├── AddressDO.java
│                                               ├── ContactinfoDO.java
│                                               ├── CustomerDO.java
│                                               └── UserDO.java
├── halo-demo-start  //应用入口
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── org
│           │       └── xujin
│           │           └── halo
│           │               └── demo
│           │                   ├── Application.java  //主程序入口
│           │                   └── start
│           │                       └── controller  //Controller
│           │                           ├── CustomerController.java
│           │                           ├── TestFlowController.java
│           │                           └── UserController.java
│           └── resources
│               ├── application.yml
│               ├── bootstrap.yml
│               ├── logback-spring.xml
│               └── static
│                   └── index.html
├── pom.xml

├── ddd-demo-client   //二方包
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── xujin
│                       └── ddd
│                           └── demo
│                               └── client
│                                   ├── api  //接口定义
│                                   ├── cmo  //命令对象
│                                   └── co
│                                       └── UserCO.java  //客户端对象
├── ddd-demo-core //应用的核心层，包含了ddd中的app层，domain层和基础设施层
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── org
│           │       └── xujin
│           │           └── ddd
│           │               └── demo
│           │                   ├── app
│           │                   │   ├── command
│           │                   │   │   ├── AddUserCmdExe.java // 写命令
│           │                   │   │   ├── cmo
│           │                   │   │   │   └── AddUserCmd.java //命令对象
│           │                   │   │   ├── co
│           │                   │   │   │   └── UserCO.java    //客户端对象
│           │                   │   │   └── query              //查询命令
│           │                   │   └── converter
│           │                   │       └── UserClientConverter.java  //转换防腐层
│           │                   ├── domain
│           │                   │   ├── aggregate01    //聚合1
│           │                   │   │   ├── converter
│           │                   │   │   │   └── UserConverter.java  // app进domain的转换层
│           │                   │   │   ├── entity
│           │                   │   │   │   └── UserE.java    //实体
│           │                   │   │   ├── factory
│           │                   │   │   │   └── UserFactory.java   //工厂
│           │                   │   │   ├── ports
│           │                   │   │   │   └── UserPort.java    //端口
│           │                   │   │   ├── repository
│           │                   │   │   │   └── UserRepository.java  //资源库
│           │                   │   │   └── service
│           │                   │   │       ├── UserService.java    //域服务接口
│           │                   │   │       └── impl
│           │                   │   │           └── UserServiceImpl.java   //域服务接口实现
│           │                   │   └── aggregate02  //聚合2
│           │                   │       └── test.java
│           │                   └── infrastructure
│           │                       ├── adapters
│           │                       │   └── UserAdapter.java  //基础设施层-适配层
│           │                       └── tunnel                //数据通道
│           │                           └── db
│           │                               ├── dao
│           │                               │   └── UserMapper.java  //MyBatis对应的Mapper
│           │                               └── dataobject
│           │                                   └── UserDO.java     //数据对象
│           └── resources
│               ├── META-INF
│               │   └── app.properties
│               ├── application.yml
│               ├── bootstrap.yml
│               ├── logback-spring.xml
│               └── static
│                   └── index.html
├── ddd-demo-start  //应用启动入口，只允许放Controller和自己开发的Spring Boot Starter
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── org
│           │       └── xujin
│           │           └── ddd
│           │               └── demo
│           │                   ├── Application.java  //主入口程序启动类
│           │                   └── start
│           │                       └── controller   // controller所在包
│           │                           └── UserController.java
│           └── resources
│               ├── META-INF
│               │   └── app.properties
│               ├── application.yml
│               ├── bootstrap.yml
│               ├── logback-spring.xml
│               └── static
│                   └── index.html
├── ddd-demo.iml
├── pom.xml

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-mybatis</artifactId>
</dependency>

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    platform: mysql
    url: jdbc:mysql://localhost:3306/test?useSSL=false&characterEncoding=utf8
    username: root
    password: root

@TableName("city")
@Data
public class City implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableId(type=AUTO)
    private Long id;

    private String name;

    @TableField("state")
    private EncryptedColumn state;

    @TableField("country")
    private String country;

 }

@Mapper
public interface CityMapper extends MyBaseMapper<City> {

    @Select("select count(0) from city")
    int test();
}

@Service
public class CityService {

    @Autowired
    private CityMapper cityMapper;

    /***
     * @Description: 创建新城市。并返回插入数据的条数
     * @Param: [name]
     * @Return: int
     */
    public int createCity(String name) {
        City newCity = new City();
        newCity.setName(name);
        return cityMapper.insert(newCity);
    }


    /***
     * @Description: 创建新城市。返回city实体
     * @Param: [name]
     * @Return: boolean
     */
    public City createCity2(String name) {
        City newCity = new City();
        newCity.setName(name);
        if (cityMapper.insert(newCity)>0) {
            return newCity;
        } else {
            return null;
        }
    }

    /***
     * @Description: 根据id更新城市名称，返回更新成功的条数
     * @Param: [id, newName]
     * @Return: int
     */
    public int updateCity(long id, String newName) {
        City cityUpdate = new City();
        cityUpdate.setId(id);
        cityUpdate.setName(newName);
        return cityMapper.updateById(cityUpdate);
    }


    /***
     * @Description: 根据名称查询城市
     * @Param: [name]
     */
    public City findCityByName(String name) {
        return cityMapper.selectOne(Wrappers.<City>query().eq(getFieldName(City::getName), name));
    }

    /***
     * @Description: 根据名称模糊查询
     * @Param: [name]
     */
    public List<City> findManyCityByNameLike(String name) {
        return cityMapper.selectList(Wrappers.<City>query().like(getFieldName(City::getName), name));
    }
    /***
     * @Description: 根据名称做分页排序查询，ascs是升序排列的字段。page=1 size=10 表示查询第一页，每页10条数据
     * @Param: [name, page, size, ascs]
     * @Return: com.baomidou.mybatisplus.extension.plugins.pagination.Page
     */
    public Page findPagedCityByNameAsc(String name, int page, int size, List<String> ascs) {
        Page pageRequest = new Page(page, size);
        pageRequest.setAscs(ascs);
        Map<String, Object> param=new HashMap<>();
        param.put(getFieldName(City::getName),name);
        return cityMapper.selectPageAccurate(pageRequest,param);
    }

    /***
     * @Description: 根据名称做分页排序查询(用like做模糊查询)，ascs是升序排列的字段。page=1 size=10 表示查询第一页，每页10条数据
     * @Param: [name, page, size, ascs]
     * @Return: com.baomidou.mybatisplus.extension.plugins.pagination.Page
     */
    public Page findPagedCityByNameLikeAsc(String name, int page, int size, List<String> ascs) {
        Page pageRequest = new Page(page, size);
        pageRequest.setAscs(ascs);
        Map<String, Object> param=new HashMap<>();
        param.put(getFieldName(City::getName),name);
        return cityMapper.selectPageBlurry(pageRequest,param);
    }

    /***
     * @Description: 根据ID删除
     * @Param: [id]
     * @Return: int
     */
    public int deleteById(long id) {
        return cityMapper.deleteById(id);
    }

    /***
     * @Description: 根据id批量删除
     * @Param: [ids]
     * @Return: int
     */
    public int deleteByIds(List<Long> ids) {
        return cityMapper.deleteBatchIds(ids);
    }

    /***
     * @Description: 根据名称删除 ，返回删除的条数
     * @Param: [name]
     * @Return: int
     */
    public int deleteByName(String name) {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put(getFieldName(City::getName), name);
        return cityMapper.deleteByMap(columnMap);
    }

    /***
    * @Description: 根据name更新country，先查询出ID，然后根据ID进行更新
    * @Param: [name, country]
    * @Return: boolean
    */
    public int updateCountryByName(String name, String country) {
        Map<String,Object> param=new HashMap<>();
        param.put(getFieldName(City::getName),name);
        return cityMapper.updateBatchById(cityMapper
                .selectByMap(param)
                .stream()
                .map(city -> {
                    City updateCity = new City();
                    updateCity.setId(city.getId());
                    updateCity.setCountry(country);
                    return updateCity;
                })
                .collect(Collectors.toList()));
    }

}

halo:
 mybatis:
  encrypt:
    password: password
    salt: salt

@TableField("state")
private EncryptedColumn state; // 加密字段

@Test
public void testEncrypted(){
        City city = new City();
        city.setName("成都");
        city.setState(EncryptedColumn.create("四川"));
        city.setCountry("中国");
        service.save(city);
        System.out.println(cityMapper.selectById(city.getId()));

        Assert.assertEquals("四川",cityMapper.selectById(city.getId()).getState().getValue());
}

INSERT INTO city  ( name, state, country)  VALUES  ( '成都', '45ffd17bf74bad972a6bc45dc5c949fedacd773b5d4205f9888129d597fa6b47ae9c01054d4f', '中国')

City{id=56, name='成都', state=EncryptedColumn{value='四川'}, country='中国'}

@Data
public class AddressInfo implements Serializable {

    private String province;

    private String city;

    private String street;

    private String houseNum;
}

@Data
@TableName("t_user") //MyBatis Plus提供
public class UserDO {

    @TableId(value = "id", type = AUTO)
    private Long id;

    @TableField(value = "name")
    private String name;

    @TableField(value = "address") //MyBatis Plus提供
    @TableJSONField // Halo扩展
    private AddressInfo address;

}

// 使用
public void addUser() {
    UserDO userDO = new UserDO();
    userDO.setName("halo user");

    AddressInfo address = new AddressInfo();
    address.setCity("SH");
    address.setStreet("HaiLun");
    userDO.setAddress(address);

    userMapper.insert(userDO);
}

halo.mybatis.enable-table-json-field: true
halo.mybatis.table-json-field-package: org.xujin.halo.admin.db.dataobject

public enum UserStatus {

    VALID((byte) 1, "有效"),
    INVALID((byte) -1, "无效");

    UserStatus(Byte value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    @Getter
    @EnumValue // 由MyBatis Plus提供
    private Byte value;

    @Getter
    private String desc;

}

@Data
@TableName("t_user")
public class UserDO {

    @TableId(value = "id", type = AUTO)
    private Long id;

    @TableField(value = "name")
    private String name;

    @TableField(value = "`status`")
    private UserStatus status;

}

// 使用
public void addUser() {
    UserDO userDO = new UserDO();
    userDO.setName("halo user");

    userDO.setStatus(UserStatus.VALID);

    userMapper.insert(userDO);
}

halo.mybatis.enable-table-enum-field: true
mybatis-plus.type-enums-package: org.xujin.halo.admin

 <parent>
<groupId>org.xujin.halo</groupId>
<artifactId>halo-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
 </parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-web</artifactId>
</dependency>

halo:
  web:
    logMark: defensor-web
    dingTalkWebHook: https://oapi.dingtalk.com/robot/send?access_token=xxx
    dingTalkMessageErrorMsgCodes: 400,500
    dingTalkAtMobiles: 1992113xxxx
    paramValidErrorMsgCode: 400
    paramValidErrorMsgContent: 参数校验失败
    bindErrorMsgCode: 400
    bindErrorMsgContent: 参数绑定错误
    sqlErrorMsgCode: 500
    sqlErrorMsgContent: sql错误
    systemErrorMsgCode: 500
    systemErrorMsgContent: 系统错误
    logDesensitizationEnabled: true
    logMobileRegularDesensitizationEnabled: true
    corsEnabled: true

@RestPathController("/admin/app")
@Api("应用管理")
public class AppController {

    @Autowired
    private CommandBus commandBus;
}

@RestController
@RequestMapping("/admin/app")
@Api("应用管理")
public class AppController {

    @Autowired
    private CommandBus commandBus;
}

@PostMapping("/write-log")
public ResultData<UserOutVO> writeLog(@Valid @RequestBody TestInVO testInVO) {
    UserOutVO user = new UserOutVO();
    user.setUsername("张三");
    user.setPassword("123xxx");
    user.setEmail("123@qq.com");
    return ResultData.success(user);
}

{
    "code": 200,
    "msgCode": "200",
    "msgContent": "success",
    "data": {
        "username": "张三",
        "password": "123xxx",
        "email": "123@qq.com"
    }
}

halo:
   web:
     # CORS跨域配置，默认允许跨域
    cors:
      # 是否启用跨域，默认启用
      enable: true

@ConfigurationProperties(prefix = "halo.web.cros")
public class HaloWebCorsProperties {

    /**
     * 是否启用跨域，默认启用
     */
    private boolean enable = true;

    /**
     * CORS过滤的路径，默认：/**
     */
    private String path = "/**";

    /**
     * 允许访问的源
     */
    private List<String> allowedOrigins = Collections.singletonList(CorsConfiguration.ALL);

    /**
     * 允许访问的请求头
     */
    private List<String> allowedHeaders = Collections.singletonList(CorsConfiguration.ALL);

    /**
     * 是否允许发送cookie
     */
    private boolean allowCredentials = true;

    /**
     * 允许访问的请求方式
     */
    private List<String> allowedMethods = Collections.singletonList(CorsConfiguration.ALL);

    /**
     * 允许响应的头
     */
    private List<String> exposedHeaders =  Arrays.asList("Content-Type",
            "X-Requested-With", "accept", "Origin", "Access-Control-Request-Method", "Access-Control-Request-Headers","token");

    /**
     * 该响应的有效时间默认为30分钟，在有效时间内，浏览器无须为同一请求再次发起预检请求
     */
    private Long maxAge = 1800L;

}

halo:
   web:
     # CORS跨域配置，默认允许跨域
    cors:
      # 是否启用跨域，默认启用
      enable: true
      # CORS过滤的路径，默认：/**
      path: /**
      # 允许访问的源
      allowed-origins: '*'
      # 允许访问的请求头
      allowed-headers: x-requested-with,content-type,token
      # 是否允许发送cookie
      allow-credentials: true
      # 允许访问的请求方式
      allowed-methods: OPTION,GET,POST
      # 允许响应的头
      exposed-headers: token
      # 该响应的有效时间默认为30分钟，在有效时间内，浏览器无须为同一请求再次发起预检请求
      max-age: 1800

@ExceptionHandler(MethodArgumentNotValidException.class)

@ExceptionHandler(BindException.class)

@ExceptionHandler(SQLException.class)

@ExceptionHandler(BusinessException.class)

@ExceptionHandler(Throwable.class)

@Data
public class TestInVO {

    @NotNull(message = "name不能为空")
    private String name;
}

环境为pro
{
    "code": 200,
    "msgCode": "400",
    "msgContent": "参数校验失败",
    "data": null
}

环境为dev\fat\uat，会显示具体的参数错误message，方便定位问题
{
    "code": 200,
    "msgCode": "400",
    "msgContent": "parameter error：name不能为空;",
    "data": null
}

{
    "code": 200,
    "msgCode": "400",
    "msgContent": "参数绑定错误",
    "data": null
}

{
    "code": 200,
    "msgCode": "500",
    "msgContent": "sql错误",
    "data": null
}

public enum ResultCodeEnum implements IResultCode {
    LESSON_CLOSED("211","课堂已关闭");

    private final String msgCode;
    private final String msgContent;
    ...
}

throw new BusinessException(ResultCodeEnum.LESSON_CLOSED);

{
    "code": 200,
    "msgCode": "211",
    "msgContent": "课堂已关闭",
    "data": null
}

{
    "code": 200,
    "msgCode": "500",
    "msgContent": "系统错误",
    "data": null
}

spring:
  mvc: # mvc.throw-exception-if-no-handler-found 和 resources.add-mappings设置 系统统一异常处理
    throw-exception-if-no-handler-found: true
  resources:
    add-mappings: false

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

System.setProperty("spring.mvc.throw-exception-if-no-handler-found", "true");
System.setProperty("spring.resources.add-mappings", "false");

halo:
  web:
    resource-handlers: |
      /static/**=classpath:/static/static/
      /index.html=classpath:/static/index.html

halo:
  web:
    resource-handlers: |
      /static/**=classpath:/static/static/
      /index.html=classpath:/static/index.html
      /swagger-ui.html=classpath:/META-INF/resources/
      /webjars/**=classpath:/META-INF/resources/webjars/

@Configuration
public class ResourceConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
        registry.addResourceHandler("/index.html").addResourceLocations("classpath:/static/index.html");
    }
}

@LogInfo
@PostMapping("/write-log")
public Result<UserOutVO> writeLog(@Valid @RequestBody TestInVO testInVO) {
    UserOutVO user = new UserOutVO();
    user.setUsername("脱敏君");
    user.setPassword("123456");
    user.setEmail("12345@qq.com");
    user.setIdCard("19921137705");
    user.setPhone("18888888888");
    return Result.create(ResultCodeEnum.SUCCESS,user);
}

@Data
public class UserOutVO {
    private String username;

    @Desensitization
    private String idCard;

    @Desensitization(strategy = PasswordStrategy.class)
    private String password;

    private String email;

    @Desensitization(strategy = MobileStrategy.class)
    private String phone;
}

+-------defensor-web----------
|			userId:null;执行方法:public org.xujin.halo.dto.ResultData<org.xujin.halo.web.vo.UserOutVO> org.xujin.halo.web.controller.LogController.writeLog(org.xujin.halo.web.vo.TestInVO)
|			参数依次为:
|					0:{"name":"*******7706"}
|			返回值:{"code":200,"data":{"email":"12345@qq.com","idCard":"","password":"****","phone":"*******8888","username":"脱敏君"},"msgCode":"200","msgContent":"success"}
|			耗时(毫秒):93
\__________________

public class PasswordStrategy implements IDesensitizationStrategy {

    @Override
    public Object handleDesensitization(Object value) {
        return "****";
    }
}

@Desensitization(strategy = PasswordStrategy.class)
private String password;

UserOutVO user = new UserOutVO();
user.set...
LOGGER.info(JsonUtils.toJSONStringWithDesensitize(user));

@RestController
@RequestMapping("/version/{version}")
public class Version1Controller {

    @ApiVersion(1)
    @RequestMapping("/test")
    public String test1(){
        return "v1";
    }

    @ApiVersion(4)
    @RequestMapping("/test")
    public String test4(){
        return "v4";
    }
}

@ApiVersion(2)
@RestController
@RequestMapping("/version/{version}")
public class Version2Controller {

    @RequestMapping("/test")
    public String test2(){
        return "v2";
    }
}

/version/v0/test
不存在

/version/v1/test
返回v1

/version/v2/test
返回v2

/version/v3/test
返回v2

/version/v4/test
返回v4

/version/v6/test
返回v4

@Getter
@AllArgsConstructor
public enum CommonResponseEnum implements BusinessExceptionAssert {

    /**
     *
     */
    CMD_NOT_NULL("7001", "cmd不能为null"),
    /**
     *
     */
    LICENCE_NOT_FOUND("7002", "Licence not found.")

    ;

    /**
     * 返回码
     */
    private String code;
    /**
     * 返回消息
     */
    private String message;

    @Override
    public String getMsgCode() {
        return String.valueOf(code);
    }

    @Override
    public String getMsgContent() {
        return message;
    }
}

private void checkNotNull(Licence licence) {
    if (licence == null) {
        throw new LicenceNotFoundException();
        // 或者这样
        throw new BusinessException(7001, "Bad licence type.");
    }
}

/**
    * 校验{@link Licence}存在
    * @param licence
    */
private void checkNotNull(Licence licence) {
       ResponseEnum.LICENCE_NOT_FOUND.assertNotNull(licence);
}

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

CommonResponseEnum.CMD_NOT_NULL.assertNotNull(cmd);

@Getter
@AllArgsConstructor
public enum CommonResponseEnum implements BusinessExceptionAssert {

    /**
     *
     */
    CMD_NOT_NULL("7001", "cmd不能为null"),
    /**
     *
     */
    LICENCE_NOT_FOUND("7002", "Licence not found.")

    ;

    /**
     * 返回码
     */
    private String code;
    /**
     * 返回消息
     */
    private String message;

    @Override
    public String getMsgCode() {
        return String.valueOf(code);
    }

    @Override
    public String getMsgContent() {
        return message;
    }
}

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-swagger</artifactId>
</dependency>

halo:
  swagger:
    enabled: true
    api:
      name: Halo Admin
      title: Halo Admin
      description: 中台管控平台
      version: 2.0.8
      conractUser: jin.xu
      conractUrl: http://xujin.org
      conractEmail: Software_King@qq.com
      basePackages: org.xujin.halo.admin.controller

halo:
  swagger:
    enabled: true
    api:
      name: Halo Admin
      title: Halo Admin
      description: 中台管控平台
      version: 2.0.8
      conractUser: jin.xu
      conractUrl: http://xujin.org
      conractEmail: Software_King@qq.com
      basePackages: org.xujin.halo.admin.controller
      globalOperationParameters:
        - name: XAuthorization  #参数名
          description: Token Request Header   #描述信息
          parameterType: header  #指定参数存放位置,参考ParamType:(header,query,path,body,form)
          dataType: String   #数据类型
          required: false
          # 测试接口时，自动填充token的值
          defaultValue:

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-mapstruct</artifactId>
</dependency>

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

 <dependency>
     <groupId>org.xujin.halo</groupId>
     <artifactId>halo-boot-starter-test</artifactId>
     <scope>test</scope>
</dependency>

<dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-test</artifactId>
         <scope>test</scope>
     </dependency>

     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
     </dependency>

     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
         <scope>test</scope>
     </dependency>

@SpringBootTest(classes = HaloBasicApplication.class)
@RunWith(SpringRunner.class)
public abstract class CommonTest {

}

public class CmdTest extends CommonTest {

    @Autowired
    private CommandBus commandBus;

    /**
     * 测试写命令
     */
    @Test
    public void testCmdWrite() {
        AddAppCmd addAppCmd=new AddAppCmd();
        addAppCmd.setAppId("111");
        ResultData<Long> resultData=commandBus.send(addAppCmd);
        Assert.assertEquals((long)resultData.getData(),1L);

    }

    /**
     * 测试读命令
     */
    @Test
    public void testCmdRead() {
        QueryAppCmd queryAppCmd=new QueryAppCmd();
        queryAppCmd.setId(1L);
        ResultData<AppCO>  resultData= commandBus.send(queryAppCmd);
        Assert.assertEquals(resultData.getData().getAppId(),"defensor");

    }
}

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-mongodb</artifactId>
</dependency>

spring:
  application:
    name: defensor-mongodb
  data:
    mongodb:
      host: 10.84.23.71:27017
      database: halo-mongodb
      username: 用户名
      password: 密码
      #uri: mongodb://用户名:密码@ip:端口/数据库 (1)

halo:
  mongodb:
    enabled: true (2)
    heartbeat-connect-timeout: 30000 (3)

halo:
  mongodb:
    multi:
      enabled: true #启用多数据源模式，默认不开启
      dbs:
        customDb1: # 自定义数据源名称示例
          uri: mongodb://127.0.0.1:27017/db1
          connectTimeout: 10000 (3)
        customDb2: # 自定义数据源名称示例
          uri: mongodb://127.0.0.1:27017/db2

halo:
  mongodb:
    enabled: true
    showClass: true

@Autowired
private MongoTemplate mongoTemplate;

@Autowired
@Qualifier("customDb1MongoTemplate")
private MongoTemplate customDb1MongoTemplate;

@Autowired
@Qualifier("customDb2MongoTemplate")
private MongoTemplate customDb2MongoTemplate;

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
    <dependencies>
         <dependency>
             <groupId>org.xujin.halo</groupId>
             <artifactId>halo-dependencies</artifactId>
             <version>2.0.0.RELEASE</version>
             <type>pom</type>
             <scope>import</scope>
          </dependency>
    </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-es6</artifactId>
</dependency>

halo:
  es:
    host: 10.31.53.185
    port: 9300
    cluster-name: zm-elk-test

halo:
  es:
    host: 10.31.53.185 (1)
    port: 9300  (2)
    cluster-name: zm-elk-test  (3)
    transport:
      ignore-cluster-name: false  (4)
      nodes-sampler-interval: 5s (5)
      ping-timeout: 5s (6)
      sniff: true (7)

public abstract class TransportClient extends AbstractClient {

    public static final Setting<TimeValue> CLIENT_TRANSPORT_NODES_SAMPLER_INTERVAL =
        Setting.positiveTimeSetting("client.transport.nodes_sampler_interval", timeValueSeconds(5), Setting.Property.NodeScope);
    public static final Setting<TimeValue> CLIENT_TRANSPORT_PING_TIMEOUT =
        Setting.positiveTimeSetting("client.transport.ping_timeout", timeValueSeconds(5), Setting.Property.NodeScope);
    public static final Setting<Boolean> CLIENT_TRANSPORT_IGNORE_CLUSTER_NAME =
        Setting.boolSetting("client.transport.ignore_cluster_name", false, Setting.Property.NodeScope);
    public static final Setting<Boolean> CLIENT_TRANSPORT_SNIFF =
        Setting.boolSetting("client.transport.sniff", false, Setting.Property.NodeScope);
}

@Autowired
private HaloEsTemplate haloEsTemplate; (1)

@Autowired
private TransportClient transportClient;

/**
 * 批量插入数据
 * @param esBasicInfo
 * @param object
 * @return
 * @throws IOException
 */
public int addBatchData(ESBasicInfo esBasicInfo, Object object) throws IOException;

/**
 * 增加数据
 * @param esBasicInfo
 * @param object
 * @return
 * @throws IOException
 */
public boolean addData(ESBasicInfo esBasicInfo, Object object) throws IOException;

/**
 * 分析搜索
 * @param clazz
 * @param response
 * @param <T>
 * @return
 * @throws IOException
 */
public <T> List<T> analyzeSearchResponse(Class<T> clazz, SearchResponse response) throws IOException;

/**
 * 创建索引
 * @param index
 * @return
 */
public boolean createIndex(String index);

/**
 * 创建Mapping
 * @param index
 * @param type
 * @param mapping
 * @return
 * @throws IOException
 */
public boolean createMapping(String index, String type, XContentBuilder mapping) throws IOException;


/**
 * 批量删除数据
 * @param esBasicInfo
 * @return
 */
public int deleteBatchData(ESBasicInfo esBasicInfo);


/**
 * 删除数据
 * @param esBasicInfo
 * @return
 */
public boolean deleteData(ESBasicInfo esBasicInfo);

/**
 * 删除索引
 * @param index
 * @return
 */
public boolean deleteIndex(String index);

/**
 * 查询
 * @param index
 * @param queryCondition
 * @param type
 * @return
 */
public SearchResponse executeQuery(String index, QueryCondition queryCondition, String... type);

/**
 * 查询所有的Mapping
 * @param index
 * @return
 * @throws IOException
 */
public List<Map<String, Object>> getAllMapping(String index) throws IOException;

/**
 *
 * Mapping 是定义文档及其包含的字段是如何存储和索引的过程
 * @param index
 * @param type
 * @return
 * @throws IOException
 */
public String getMapping(String index, String type) throws IOException;

/**
 * 返回高亮结果
 * @param esBasicInfo
 * @param queryCondition
 * @param highLight
 * @return
 */
public List<Map<String, Object>> highLightResultSet(ESBasicInfo esBasicInfo, QueryCondition queryCondition,
    HighLight highLight);

/**
 * 是否存在索引
 * @param index
 * @return
 */
public boolean isExistedIndex(String index);

/**
 * 查询返回泛型
 * @param esBasicInfo
 * @param clazz
 * @param <T>
 * @return
 * @throws IOException
 */
public <T> T query(ESBasicInfo esBasicInfo, Class<T> clazz) throws IOException;

/**
 * 批量更新数据
 * @param esBasicInfo
 * @param object
 * @return
 * @throws IOException
 */
public int updateBatchData(ESBasicInfo esBasicInfo, Object object) throws IOException;

/**
 * 更新数据
 * @param esBasicInfo
 * @param object
 * @return
 * @throws IOException
 */
public boolean updateData(ESBasicInfo esBasicInfo, Object object) throws IOException;

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
    <artifactId>halo-boot-starter-es7</artifactId>
</dependency>

<!-- 显示引入elasticsearch 7.2.1 --> (1)
<dependency>
	<groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
	<version>7.2.1</version>
</dependency>

halo:
  es:
    hosts:
      - 10.81.164.95:9200  (1)
      - 10.81.164.95:9200  (2)
    #time-out: 1000         (3)
    #socket-timeout: 30000  (4)

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-job</artifactId>
</dependency>

halo.job:
  admin:
    admin-addresses: http://localhost:8080/xxl-job-admin
  executor:
    app-name: xxl-job-spring-boot-starter-example #默认为 xxl-job-executor
    access-token: #默认为空
    log-path: logs/applogs/xxl-job/jobhandler #默认为 logs/applogs/xxl-job/jobhandler
    log-retention-days: 10 #默认为 10
    ip: #默认为空
    port: 9999 #默认为 9999

@JobHandler(value="haloJobHandler")
@Component
public class HaloJobHandler extends IJobHandler {

    @Override
    public ReturnT<String> execute(String param) throws Exception {
        XxlJobLogger.log("XXL-JOB, Hello World.");
        for (int i = 0; i < 5; i++) {
            XxlJobLogger.log("beat at:" + i);
            TimeUnit.SECONDS.sleep(2);
        }
        return SUCCESS;
    }

}

<parent>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.xujin.halo</groupId>
                <artifactId>halo-dependencies</artifactId>
                <version>2.0.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
         </dependencies>
</dependencyManagement>

<dependency>
	<groupId>org.xujin.halo</groupId>
	<artifactId>halo-boot-starter-alimq</artifactId>
</dependency>

halo:
  alimq:
    enabled: true # 启用Halo AliMQ总开关，默认启用
    namesrv-addr: http://onsaddr.xxxx.mq-internal.aliyuncs.com:8080 # 公共配置
    access-key: LTAI4FofsQVbk # 公共配置
    secret-key: EOMlH59FGBHVz # 公共配置
    group-id: GID_PRODUCER_XUJIN_TEST # 公共配置
    producer: # 普通消息、定时和延时消息 生产者
      enabled: true # 普通消息、定时和延时消息 生产者开关，默认不启用
      access-key: LTAI4FofXsQVbk # 配置则覆盖公共配置，未配则用公共配置
      secret-key: EOMlHeFbMm159 # 配置则覆盖公共配置，未配则用公共配置
      group-id: GID_PRODUCER_XUJIN_TEST # 配置则覆盖公共配置，未配则用公共配置
    orderproducer: # 顺序消息生产者
          enabled: true # 顺序消息生产者开关，默认不启用
          access-key: LTAI4Vbk # 配置则覆盖公共配置，未配则用公共配置
          secret-key: EOMl59HVz # 配置则覆盖公共配置，未配则用公共配置
          group-id: GID_PRODUCER_XUJIN_TEST # 配置则覆盖公共配置，未配则用公共配置
    transactionproducer: #事务消息生产者
      enabled: true # 事务消息生产者开关，默认不启用
      access-key: LTAIQVbk # 配置则覆盖公共配置，未配则用公共配置
      secret-key: EOMlHeF3 # 配置则覆盖公共配置，未配则用公共配置
      group-id: GID_PRODUCER_XUJIN_TEST # 配置则覆盖公共配置，未配则用公共配置
      local-transaction-checker: org.xujin.alimq.provider.producer.LocalTransactionCheckerImpl # 回查本地事务接口实现，由Broker回调Producer

halo:
  alimq:
    enabled: true # 启用Halo AliMQ总开关，默认启用
    namesrv-addr: http://onsaddr.xxxxxxxx.aliyuncs.com:8080 # 公共配置
    access-key: LTAI4Fs # 公共配置
    secret-key: f1gpL4 # 公共配置
    group-id: GID_CONSUMER_XUJIN_TEST # 公共配置
    consumer: # 普通消息、定时和延时消息、事务消息 消费者
      enabled: true # 普通消息、定时和延时消息、事务消息 消费者开关，默认不开启
      access-key: LTAI4F # 配置则覆盖公共配置，未配则用公共配置
      secret-key: f1gpL4 # 配置则覆盖公共配置，未配则用公共配置
      group-id: GID_CONSUMER_XUJIN_TEST # 配置则覆盖公共配置，未配则用公共配置
    orderconsumer: # 顺序消息消费者
      enabled: true # 顺序消息消费者开关，默认不开启
      access-key: LTAI4Fs # 配置则覆盖公共配置，未配则用公共配置
      secret-key: f1gpL4U # 配置则覆盖公共配置，未配则用公共配置
      group-id: GID_CONSUMER_XUJIN_TEST # 配置则覆盖公共配置，未配则用公共配置