dao method comments and useless code modify (#1214)

* add ConnectionFactoryTest and ConnectionFactory read datasource from appliction.yml

* .escheduler_env.sh to dolphinscheduler_env.sh

* dao yml assembly to conf directory

* table name modify

* entity title table  name modify

* logback log name modify

* running through the big process

* running through the big process error modify

* logback log name modify

* data_source.properties rename

* logback log name modify

* install.sh optimization

* install.sh optimization

* command count modify

* command state update

* countCommandState sql update

* countCommandState sql update

* remove application.yml file

* master.properties modify

* install.sh modify

* install.sh modify

* api server startup modify

* the current user quits and the session is completely emptied. bug fix

* remove pom package resources

* checkQueueNameExist method update

* checkQueueExist

* install.sh error output update

* signOut error update

* ProcessDao is null bug fix

* install.sh add mail.user

* request url variables replace

* process define import bug fix

* process define import export bug fix

* processdefine import export bug fix

* down log suffix format modify

* import export process define contains crontab error bug fix

* add Flink local mode

* ProcessDao is null bug fix

* loadAverage display problem bug fix

* MasterServer rename Server

* rollback .env

* rollback .env

* MasterServer rename Server

* the task is abnormal and task is running bug fix

* owners and administrators can delete

* dockerfile optimization

* dockerfile optimization

* dockerfile optimization

* remove application-alert.properties

* task log print worker log bug fix

* remove .escheduler_env.sh

* change dockerfile email address

* dockerfile dao application.properties and install.sh modify

* application.properties modify

* application.properties modify

* dockerfile startup.sh modify

* remove docs

* nginx conf modify

* dockerfile application.properties modify

* dockerfile email address change

* the alert module is modified in English.

* alert server comment and chinese modify

* api server useless code and chinese modify

* common，dao，server useless code and chinese modify

* change chinese to english

* dao method comments and useless code modify

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/AbstractBaseDao.java

@@ -21,7 +21,9 @@ package org.apache.dolphinscheduler.dao;
  */
 public abstract class AbstractBaseDao {
 
+  /**
+   * init
+   */
   protected abstract void init();
 
-
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/AlertDao.java

@@ -16,6 +16,9 @@
  */
 package org.apache.dolphinscheduler.dao;
 
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.dolphinscheduler.common.enums.AlertStatus;
 import org.apache.dolphinscheduler.common.enums.AlertType;
@@ -29,8 +32,7 @@ import org.apache.dolphinscheduler.dao.mapper.AlertMapper;
 import org.apache.dolphinscheduler.dao.mapper.UserAlertGroupMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
+
 
 import java.util.Date;
 import java.util.List;
@@ -54,8 +56,8 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * insert alert
-     * @param alert
-     * @return
+     * @param alert alert
+     * @return add alert result
      */
     public int addAlert(Alert alert){
         return alertMapper.insert(alert);
@@ -63,10 +65,10 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * update alert
-     * @param alertStatus
-     * @param log
-     * @param id
-     * @return
+     * @param alertStatus alertStatus
+     * @param log log
+     * @param id id
+     * @return update alert result
      */
     public int updateAlert(AlertStatus alertStatus,String log,int id){
         Alert alert = alertMapper.selectById(id);
@@ -78,15 +80,19 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * query user list by alert group id
-     * @param alerGroupId
-     * @return
+     * @param alerGroupId alerGroupId
+     * @return user list
      */
     public List<User> queryUserByAlertGroupId(int alerGroupId){
 
         return userAlertGroupMapper.listUserByAlertgroupId(alerGroupId);
     }
+
     /**
      * MasterServer or WorkerServer stoped
+     * @param alertgroupId alertgroupId
+     * @param host host
+     * @param serverType serverType
      */
     public void sendServerStopedAlert(int alertgroupId,String host,String serverType){
         Alert alert = new Alert();
@@ -104,8 +110,8 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * process time out alert
-     * @param processInstance
-     * @param processDefinition
+     * @param processInstance processInstance
+     * @param processDefinition processDefinition
      */
     public void sendProcessTimeoutAlert(ProcessInstance processInstance, ProcessDefinition processDefinition){
         int alertgroupId = processInstance.getWarningGroupId();
@@ -132,6 +138,11 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * task timeout warn
+     * @param alertgroupId alertgroupId
+     * @param receivers receivers
+     * @param receiversCc receiversCc
+     * @param taskId taskId
+     * @param taskName taskName
      */
     public void sendTaskTimeoutAlert(int alertgroupId,String receivers,String receiversCc,int taskId,String taskName){
         Alert alert = new Alert();
@@ -154,7 +165,7 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * list the alert information of waiting to be executed
-     * @return
+     * @return alert list
      */
     public List<Alert> listWaitExecutionAlert(){
         return alertMapper.listAlertByStatus(AlertStatus.WAIT_EXECUTION);
@@ -162,8 +173,8 @@ public class AlertDao extends AbstractBaseDao {
 
     /**
      * list user information by alert group id
-     * @param alertgroupId
-     * @return
+     * @param alertgroupId alertgroupId
+     * @return user list
      */
     public List<User> listUserByAlertgroupId(int alertgroupId){
         return userAlertGroupMapper.listUserByAlertgroupId(alertgroupId);

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/App.java

@@ -1,27 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.dolphinscheduler.dao;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-
-@SpringBootApplication
-public class App {
-    public static void main(String[] args){
-        SpringApplication.run(App.class);
-    }
-}

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/DaoFactory.java

@@ -37,9 +37,9 @@ public class DaoFactory {
 
   /**
    * get dao instance
-   *
-   * @param clazz
-   * @return  dao instance
+   * @param clazz clazz
+   * @param <T> T
+   * @return T object
    */
   @SuppressWarnings("unchecked")
   public static <T extends AbstractBaseDao> T getDaoInstance(Class<T> clazz) {

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/MonitorDBDao.java

@@ -56,6 +56,10 @@ public class MonitorDBDao {
         }
     }
 
+    /**
+     * get current db performance
+     * @return MonitorRecord
+     */
     public static MonitorRecord getCurrentDbPerformance(){
         MonitorRecord monitorRecord = null;
         Connection conn = null;
@@ -93,7 +97,7 @@ public class MonitorDBDao {
 
     /**
      * query database state
-     * @return
+     * @return MonitorRecord list
      */
     public static List<MonitorRecord> queryDatabaseState() {
         List<MonitorRecord> list = new ArrayList<>(1);

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/TaskRecordDao.java

@@ -58,14 +58,14 @@ public class TaskRecordDao {
 
     /**
      *  get task record flag
-     * @return
+     * @return whether startup taskrecord
      */
     public static boolean getTaskRecordFlag(){
        return conf.getBoolean(Constants.TASK_RECORD_FLAG);
     }
     /**
      * create connection
-     * @return
+     * @return connection
      */
     private static Connection getConn() {
         if(!getTaskRecordFlag()){
@@ -90,8 +90,8 @@ public class TaskRecordDao {
 
     /**
      * generate where sql string
-     * @param filterMap
-     * @return
+     * @param filterMap filterMap
+     * @return sql string
      */
     private static String getWhereString(Map<String, String> filterMap)
     {
@@ -140,8 +140,9 @@ public class TaskRecordDao {
 
     /**
      * count task record
-     * @param filterMap
-     * @return
+     * @param filterMap filterMap
+     * @param table table
+     * @return task record count
      */
     public static int countTaskRecord(Map<String, String> filterMap, String table){
 
@@ -180,8 +181,9 @@ public class TaskRecordDao {
 
     /**
      * query task record by filter map paging
-     * @param filterMap
-     * @return
+     * @param filterMap filterMap
+     * @param table table
+     * @return task record list
      */
     public static List<TaskRecord> queryAllTaskRecord(Map<String,String> filterMap , String table) {
 
@@ -203,9 +205,9 @@ public class TaskRecordDao {
 
     /**
      * convert result set to task record
-     * @param resultSet
-     * @return
-     * @throws SQLException
+     * @param resultSet resultSet
+     * @return task record
+     * @throws SQLException if error throws SQLException
      */
     private static TaskRecord convertToTaskRecord(ResultSet resultSet) throws SQLException {
 
@@ -231,8 +233,8 @@ public class TaskRecordDao {
 
     /**
      * query task list by select sql
-     * @param selectSql
-     * @return
+     * @param selectSql select sql
+     * @return task record list
      */
     private static List<TaskRecord> getQueryResult(String selectSql) {
         List<TaskRecord> recordList = new ArrayList<>();
@@ -269,9 +271,9 @@ public class TaskRecordDao {
 
     /**
      * according to procname and procdate query task record
-     * @param procName
-     * @param procDate
-     * @return
+     * @param procName procName
+     * @param procDate procDate
+     * @return task record status
      */
     public static TaskRecordStatus getTaskRecordState(String procName,String procDate){
         String sql = String.format("SELECT * FROM eamp_hive_log_hd WHERE PROC_NAME='%s' and PROC_DATE like '%s'"

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/config/MybatisPlusConfig.java

@@ -22,9 +22,16 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 
+/**
+ * mybatis plus config
+ */
 @Configuration
 @MapperScan("org.apache.dolphinscheduler.*.mapper")
 public class MybatisPlusConfig {
+    /**
+     *  pagination interceptor
+     * @return pagination interceptor
+     */
     @Bean
     public PaginationInterceptor paginationInterceptor() {
         return new PaginationInterceptor();

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/datasource/ConnectionFactory.java

@@ -40,8 +40,14 @@ import javax.sql.DataSource;
 public class ConnectionFactory {
     private static final Logger logger = LoggerFactory.getLogger(ConnectionFactory.class);
 
+    /**
+     * sql session factory
+     */
     private static SqlSessionFactory sqlSessionFactory;
 
+    /**
+     * sql session template
+     */
     private static SqlSessionTemplate sqlSessionTemplate;
 
     /**
@@ -60,6 +66,7 @@ public class ConnectionFactory {
 
     /**
      * get the data source
+     * @return druid dataSource
      */
     public static DruidDataSource getDataSource() {
 
@@ -94,6 +101,8 @@ public class ConnectionFactory {
 
     /**
      * get sql session factory
+     * @return sqlSessionFactory
+     * @throws Exception sqlSessionFactory exception
      */
     public static SqlSessionFactory getSqlSessionFactory() throws Exception {
         if (sqlSessionFactory == null) {
@@ -125,6 +134,7 @@ public class ConnectionFactory {
 
     /**
      * get sql session
+     * @return sqlSession
      */
     public static SqlSession getSqlSession() {
         if (sqlSessionTemplate == null) {
@@ -143,12 +153,18 @@ public class ConnectionFactory {
         return sqlSessionTemplate;
     }
 
+    /**
+     * get mapper
+     * @param type target class
+     * @param <T> generic
+     * @return target object
+     */
     public static <T> T getMapper(Class<T> type) {
         try {
             return getSqlSession().getMapper(type);
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
-            throw new RuntimeException("get mapper failed!");
+            throw new RuntimeException("get mapper failed");
         }
     }
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/entity/ProcessData.java

@@ -47,8 +47,8 @@ public class ProcessData {
 
   /**
    *
-   * @param tasks
-   * @param globalParams
+   * @param tasks tasks
+   * @param globalParams globalParams
    */
   public ProcessData(List<TaskNode> tasks, List<Property> globalParams) {
     this.tasks = tasks;

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/entity/ProcessInstance.java

@@ -228,7 +228,7 @@ public class ProcessInstance {
 
     /**
      * set the process name with process define version and timestamp
-     * @param processDefinition
+     * @param processDefinition processDefinition
      */
     public ProcessInstance(ProcessDefinition processDefinition){
         this.processDefinition = processDefinition;
@@ -479,7 +479,7 @@ public class ProcessInstance {
 
     /**
      * add command to history
-     * @param cmd
+     * @param cmd cmd
      */
     public void addHistoryCmd(CommandType cmd){
         if(StringUtils.isNotEmpty(this.historyCmd)){
@@ -491,6 +491,7 @@ public class ProcessInstance {
 
     /**
      * check this process is start complement data
+     * @return whether complement data
      */
     public Boolean isComplementData(){
         if(!StringUtils.isNotEmpty(this.historyCmd)){
@@ -502,6 +503,7 @@ public class ProcessInstance {
     /**
      * get current command type,
      * if start with complement data,return complement
+     * @return CommandType
      */
     public CommandType getCmdTypeIfComplement(){
         if(isComplementData()){

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/entity/TaskInstance.java

@@ -425,8 +425,8 @@ public class TaskInstance {
                 || (this.getState().typeIsFailure() && !taskCanRetry());
     }
     /**
-     * 判断是否可以重试
-     * @return
+     * determine if you can try again
+     * @return can try result
      */
     public boolean taskCanRetry() {
         if(this.isSubProcess()){

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/AccessTokenMapper.java

@@ -22,14 +22,18 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import org.apache.ibatis.annotations.Param;
 
+/**
+ * accesstoken mapper interface
+ */
 public interface AccessTokenMapper extends BaseMapper<AccessToken> {
 
+
     /**
-     *
-     * @param page
-     * @param userName
-     * @param userId
-     * @return
+     * access token page
+     * @param page page
+     * @param userName userName
+     * @param userId userId
+     * @return access token Ipage
      */
     IPage<AccessToken> selectAccessTokenPage(Page page,
                                              @Param("userName") String userName,

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/AlertGroupMapper.java

@@ -25,21 +25,47 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
-
+/**
+ * alertgroup mapper interface
+ */
 public interface AlertGroupMapper extends BaseMapper<AlertGroup> {
 
 
+    /**
+     * alertgroup page
+     * @param page page
+     * @param groupName groupName
+     * @return alertgroup Ipage
+     */
     IPage<AlertGroup> queryAlertGroupPage(Page page,
                                           @Param("groupName") String groupName);
 
 
+    /**
+     * query by group name
+     * @param groupName groupName
+     * @return alertgroup list
+     */
     List<AlertGroup> queryByGroupName(@Param("groupName") String groupName);
 
-
+    /**
+     * query by userId
+     * @param userId userId
+     * @return alertgroup list
+     */
     List<AlertGroup> queryByUserId(@Param("userId") int userId);
 
 
+    /**
+     * query by alert type
+     * @param alertType alertType
+     * @return alertgroup list
+     */
     List<AlertGroup> queryByAlertType(@Param("alertType") AlertType alertType);
 
+    /**
+     * query all group list
+     * @return alertgroup list
+     */
     List<AlertGroup> queryAllGroupList();
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/AlertMapper.java

@@ -23,9 +23,16 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * alert mapper interface
+ */
 public interface AlertMapper extends BaseMapper<Alert> {
 
-
+    /**
+     * list alert by status
+     * @param alertStatus alertStatus
+     * @return alert list
+     */
     List<Alert> listAlertByStatus(@Param("alertStatus") AlertStatus alertStatus);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/CommandMapper.java

@@ -27,11 +27,26 @@ import org.apache.ibatis.annotations.Select;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * command mapper interface
+ */
 public interface CommandMapper extends BaseMapper<Command> {
 
 
+    /**
+     * get one command
+     * @return command
+     */
     Command getOneToRun();
 
+    /**
+     * count command state
+     * @param userId userId
+     * @param startTime startTime
+     * @param endTime endTime
+     * @param projectIdArray projectIdArray
+     * @return CommandCount list
+     */
     List<CommandCount> countCommandState(
             @Param("userId") int userId,
             @Param("startTime") Date startTime,

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/DataSourceMapper.java

@@ -23,21 +23,57 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * datasource mapper interface
+ */
 public interface DataSourceMapper extends BaseMapper<DataSource> {
 
+    /**
+     * query datasource by type
+     * @param userId userId
+     * @param type type
+     * @return datasource list
+     */
     List<DataSource> queryDataSourceByType(@Param("userId") int userId, @Param("type") Integer type);
 
+    /**
+     * datasource page
+     * @param page page
+     * @param userId userId
+     * @param name name
+     * @return datasource IPage
+     */
     IPage<DataSource> selectPaging(IPage<DataSource> page,
                                    @Param("userId") int userId,
                                    @Param("name") String name);
 
+    /**
+     * query datasource by name
+     * @param name name
+     * @return datasource list
+     */
     List<DataSource> queryDataSourceByName(@Param("name") String name);
 
 
+    /**
+     * query authed datasource
+     * @param userId userId
+     * @return datasource list
+     */
     List<DataSource> queryAuthedDatasource(@Param("userId") int userId);
 
+    /**
+     * query datasource except userId
+     * @param userId userId
+     * @return datasource list
+     */
     List<DataSource> queryDatasourceExceptUserId(@Param("userId") int userId);
 
+    /**
+     * list all datasource by type
+     * @param type datasource type
+     * @return datasource list
+     */
     List<DataSource> listAllDataSourceByType(@Param("type") Integer type);
 
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/DataSourceUserMapper.java

@@ -20,11 +20,24 @@ import org.apache.dolphinscheduler.dao.entity.DatasourceUser;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
+/**
+ * datasource user realtion mapper interface
+ */
 public interface DataSourceUserMapper extends BaseMapper<DatasourceUser> {
 
 
+    /**
+     * delete datasource by userId
+     * @param userId userId
+     * @return delete result
+     */
     int deleteByUserId(@Param("userId") int userId);
 
+    /**
+     * delete datasource by id
+     * @param datasourceId datasourceId
+     * @return delete result
+     */
     int deleteByDatasourceId(@Param("datasourceId") int datasourceId);
 
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ErrorCommandMapper.java

@@ -24,8 +24,18 @@ import org.apache.ibatis.annotations.Param;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * error command mapper interface
+ */
 public interface ErrorCommandMapper extends BaseMapper<ErrorCommand> {
 
+    /**
+     * count command state
+     * @param startTime startTime
+     * @param endTime endTime
+     * @param projectIdArray projectIdArray
+     * @return CommandCount list
+     */
     List<CommandCount> countCommandState(
             @Param("startTime") Date startTime,
             @Param("endTime") Date endTime,

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ProcessDefinitionMapper.java

@@ -24,26 +24,71 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * process definition mapper interface
+ */
 public interface ProcessDefinitionMapper extends BaseMapper<ProcessDefinition> {
 
 
+    /**
+     * query process definition by name
+     * @param projectId projectId
+     * @param name name
+     * @return process definition
+     */
     ProcessDefinition queryByDefineName(@Param("projectId") int projectId,
                                         @Param("processDefinitionName") String name);
 
+    /**
+     * query process definition by id
+     * @param processDefineId processDefineId
+     * @return process definition
+     */
     ProcessDefinition queryByDefineId(@Param("processDefineId") int processDefineId);
 
+    /**
+     * process definition page
+     * @param page page
+     * @param searchVal searchVal
+     * @param userId userId
+     * @param projectId projectId
+     * @param isAdmin isAdmin
+     * @return process definition IPage
+     */
     IPage<ProcessDefinition> queryDefineListPaging(IPage<ProcessDefinition> page,
                                                    @Param("searchVal") String searchVal,
                                                    @Param("userId") int userId,
                                                    @Param("projectId") int projectId,
                                                    @Param("isAdmin") boolean isAdmin);
 
+    /**
+     * query all process definition list
+     * @param projectId projectId
+     * @return process definition list
+     */
     List<ProcessDefinition> queryAllDefinitionList(@Param("projectId") int projectId);
 
+    /**
+     * query process definition by ids
+     * @param ids ids
+     * @return process definition list
+     */
     List<ProcessDefinition> queryDefinitionListByIdList(@Param("ids") Integer[] ids);
 
+    /**
+     * query process definition by tenant
+     * @param tenantId tenantId
+     * @return process definition list
+     */
     List<ProcessDefinition> queryDefinitionListByTenant(@Param("tenantId") int tenantId);
 
+    /**
+     *  count process definition group by user
+     * @param userId userId
+     * @param projectIds projectIds
+     * @param isAdmin isAdmin
+     * @return process definition list
+     */
     List<DefinitionGroupByUser> countDefinitionGroupByUser(
             @Param("userId") Integer userId,
             @Param("projectIds") Integer[] projectIds,

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ProcessInstanceMapMapper.java

@@ -22,17 +22,40 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * process instance map mapper interface
+ */
 public interface ProcessInstanceMapMapper extends BaseMapper<ProcessInstanceMap> {
 
-
-
-    ProcessInstanceMap queryByParentId(@Param("parentProcessId") int parentProcessId, @Param("parentTaskId") int parentTaskId);
-
-
+    /**
+     * query process instance by parentId
+     * @param parentProcessId parentProcessId
+     * @param parentTaskId parentTaskId
+     * @return process instance map
+     */
+    ProcessInstanceMap queryByParentId(@Param("parentProcessId") int parentProcessId,
+                                       @Param("parentTaskId") int parentTaskId);
+
+
+    /**
+     * query by sub process id
+     * @param subProcessId subProcessId
+     * @return process instance map
+     */
     ProcessInstanceMap queryBySubProcessId(@Param("subProcessId") Integer subProcessId);
 
+    /**
+     * delete by parent process id
+     * @param parentProcessId parentProcessId
+     * @return delete result
+     */
     int deleteByParentProcessId(@Param("parentProcessId") int parentProcessId);
 
+    /**
+     *  query sub process instance  ids by parent instance id
+     * @param parentInstanceId parentInstanceId
+     * @return sub process instance ids
+     */
     List<Integer> querySubIdListByParentId(@Param("parentInstanceId") int parentInstanceId);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ProcessInstanceMapper.java

@@ -27,19 +27,57 @@ import org.apache.ibatis.annotations.Param;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * process instance mapper interface
+ */
 public interface ProcessInstanceMapper extends BaseMapper<ProcessInstance> {
 
+    /**
+     * query process instance detail info by id
+     * @param processId processId
+     * @return process instance
+     */
     ProcessInstance queryDetailById(@Param("processId") int processId);
 
+    /**
+     * query process instance by host and stateArray
+     * @param host host
+     * @param stateArray stateArray
+     * @return process instance list
+     */
     List<ProcessInstance> queryByHostAndStatus(@Param("host") String host,
                                                @Param("states") int[] stateArray);
 
+    /**
+     * query process instance by tenantId and stateArray
+     * @param tenantId tenantId
+     * @param states states array
+     * @return process instance list
+     */
     List<ProcessInstance> queryByTenantIdAndStatus(@Param("tenantId") int tenantId,
                                                @Param("states") int[] states);
 
+    /**
+     * query process instance by worker group and stateArray
+     * @param workerGroupId workerGroupId
+     * @param states states array
+     * @return process instance list
+     */
     List<ProcessInstance> queryByWorkerGroupIdAndStatus(@Param("workerGroupId") int workerGroupId,
                                                    @Param("states") int[] states);
 
+    /**
+     * process instance page
+     * @param page page
+     * @param projectId projectId
+     * @param processDefinitionId processDefinitionId
+     * @param searchVal searchVal
+     * @param statusArray statusArray
+     * @param host host
+     * @param startTime startTime
+     * @param endTime endTime
+     * @return process instance IPage
+     */
     IPage<ProcessInstance> queryProcessInstanceListPaging(Page<ProcessInstance> page,
                                                           @Param("projectId") int projectId,
                                                           @Param("processDefinitionId") Integer processDefinitionId,
@@ -47,37 +85,96 @@ public interface ProcessInstanceMapper extends BaseMapper<ProcessInstance> {
                                                           @Param("states") int[] statusArray,
                                                           @Param("host") String host,
                                                           @Param("startTime") Date startTime,
-                                                          @Param("endTime") Date endTime
-    );
-
+                                                          @Param("endTime") Date endTime);
+
+    /**
+     * set failover by host and state array
+     * @param host host
+     * @param stateArray stateArray
+     * @return set result
+     */
     int setFailoverByHostAndStateArray(@Param("host") String host,
                                        @Param("states") int[] stateArray);
 
+    /**
+     * update process instance by state
+     * @param originState  originState
+     * @param destState destState
+     * @return update result
+     */
     int updateProcessInstanceByState(@Param("originState") ExecutionStatus originState,
                                      @Param("destState") ExecutionStatus destState);
 
-    int updateProcessInstanceByTenantId(@Param("originTenantId") int originTenantId, @Param("destTenantId") int destTenantId);
-
+    /**
+     *  update process instance by tenantId
+     * @param originTenantId originTenantId
+     * @param destTenantId destTenantId
+     * @return update result
+     */
+    int updateProcessInstanceByTenantId(@Param("originTenantId") int originTenantId,
+                                        @Param("destTenantId") int destTenantId);
+
+    /**
+     * update process instance by worker groupId
+     * @param originWorkerGroupId originWorkerGroupId
+     * @param destWorkerGroupId destWorkerGroupId
+     * @return update result
+     */
     int updateProcessInstanceByWorkerGroupId(@Param("originWorkerGroupId") int originWorkerGroupId, @Param("destWorkerGroupId") int destWorkerGroupId);
 
+    /**
+     * count process instance state by user
+     * @param startTime startTime
+     * @param endTime endTime
+     * @param projectIds projectIds
+     * @return ExecuteStatusCount list
+     */
     List<ExecuteStatusCount> countInstanceStateByUser(
             @Param("startTime") Date startTime,
             @Param("endTime") Date endTime,
             @Param("projectIds") Integer[] projectIds);
 
+    /**
+     * query process instance by processDefinitionId
+     * @param processDefinitionId processDefinitionId
+     * @param size size
+     * @return process instance list
+     */
     List<ProcessInstance> queryByProcessDefineId(
             @Param("processDefinitionId") int processDefinitionId,
             @Param("size") int size);
 
+    /**
+     * query last scheduler process instance
+     * @param definitionId processDefinitionId
+     * @param startTime startTime
+     * @param endTime endTime
+     * @return process instance
+     */
     ProcessInstance queryLastSchedulerProcess(@Param("processDefinitionId") int definitionId,
                                               @Param("startTime") String startTime,
                                               @Param("endTime") String endTime);
 
+    /**
+     * query last running process instance
+     * @param definitionId definitionId
+     * @param startTime startTime
+     * @param endTime endTime
+     * @param stateArray stateArray
+     * @return process instance
+     */
     ProcessInstance queryLastRunningProcess(@Param("processDefinitionId") int definitionId,
                                             @Param("startTime") String startTime,
                                             @Param("endTime") String endTime,
                                             @Param("states") int[] stateArray);
 
+    /**
+     * query last manual process instance
+     * @param definitionId definitionId
+     * @param startTime startTime
+     * @param endTime endTime
+     * @return process instance
+     */
     ProcessInstance queryLastManualProcess(@Param("processDefinitionId") int definitionId,
                                            @Param("startTime") Date startTime,
                                            @Param("endTime") Date endTime);

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ProjectMapper.java

@@ -23,20 +23,55 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * project mapper interface
+ */
 public interface ProjectMapper extends BaseMapper<Project> {
 
+    /**
+     * query project detail by id
+     * @param projectId projectId
+     * @return project
+     */
     Project queryDetailById(@Param("projectId") int projectId);
 
+    /**
+     * query project by name
+     * @param projectName projectName
+     * @return project
+     */
     Project queryByName(@Param("projectName") String projectName);
 
+    /**
+     * project page
+     * @param page page
+     * @param userId userId
+     * @param searchName searchName
+     * @return project Ipage
+     */
     IPage<Project> queryProjectListPaging(IPage<Project> page,
                                           @Param("userId") int userId,
                                           @Param("searchName") String searchName);
 
+    /**
+     *  query create project user
+     * @param userId userId
+     * @return project list
+     */
     List<Project> queryProjectCreatedByUser(@Param("userId") int userId);
 
+    /**
+     * query authed project list by userId
+     * @param userId userId
+     * @return project list
+     */
     List<Project> queryAuthedProjectListByUserId(@Param("userId") int userId);
 
+    /**
+     * query project except userId
+     * @param userId userId
+     * @return project list
+     */
     List<Project> queryProjectExceptUserId(@Param("userId") int userId);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ProjectUserMapper.java

@@ -20,11 +20,26 @@ import org.apache.dolphinscheduler.dao.entity.ProjectUser;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
+/**
+ * project user mapper interface
+ */
 public interface ProjectUserMapper extends BaseMapper<ProjectUser> {
 
+    /**
+     * delte prject user relation
+     * @param projectId projectId
+     * @param userId userId
+     * @return delete result
+     */
     int deleteProjectRelation(@Param("projectId") int projectId,
                               @Param("userId") int userId);
 
+    /**
+     * query project relation
+     * @param projectId projectId
+     * @param userId userId
+     * @return project user relation
+     */
     ProjectUser queryProjectRelation(@Param("projectId") int projectId,
                                      @Param("userId") int userId);
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/QueueMapper.java

@@ -24,13 +24,25 @@ import org.apache.ibatis.annotations.Param;
 import java.util.List;
 
 /**
- *
+ * queue mapper interface
  */
 public interface QueueMapper extends BaseMapper<Queue> {
 
+    /**
+     * queue page
+     * @param page page
+     * @param searchVal searchVal
+     * @return queue IPage
+     */
     IPage<Queue> queryQueuePaging(IPage<Queue> page,
                                   @Param("searchVal") String searchVal);
 
+    /**
+     *  query all queue list
+     * @param queue queue
+     * @param queueName queueName
+     * @return queue list
+     */
     List<Queue> queryAllQueueList(@Param("queue") String queue,
                              @Param("queueName") String queueName);
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ResourceMapper.java

@@ -23,14 +23,17 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * resource mapper interface
+ */
 public interface ResourceMapper extends BaseMapper<Resource> {
 
     /**
-     *
-     * @param alias query all if null
-     * @param userId query all if -1
-     * @param type query all type if -1
-     * @return
+     * query resource list
+     * @param alias alias
+     * @param userId userId
+     * @param type type
+     * @return resource list
      */
     List<Resource> queryResourceList(@Param("alias") String alias,
                                      @Param("userId") int userId,
@@ -38,12 +41,12 @@ public interface ResourceMapper extends BaseMapper<Resource> {
 
 
     /**
-     *
-     * @param page
+     * resource page
+     * @param page page
      * @param userId query all if 0, then query the authed resources
-     * @param type
-     * @param searchVal
-     * @return
+     * @param type type
+     * @param searchVal searchVal
+     * @return resource list
      */
     IPage<Resource> queryResourcePaging(IPage<Resource> page,
                                         @Param("userId") int userId,
@@ -51,22 +54,24 @@ public interface ResourceMapper extends BaseMapper<Resource> {
                                         @Param("searchVal") String searchVal);
 
     /**
-     *
-     * @param userId
-     * @param type query all if -1
-     * @return
+     * query Authed resource list
+     * @param userId userId
+     * @return resource list
      */
-    List<Resource> queryResourceListAuthored(@Param("userId") int userId, @Param("type") int type);
+    List<Resource> queryAuthorizedResourceList(@Param("userId") int userId);
 
     /**
-     *
-     * @param userId
-     * @return
+     *  query resource except userId
+     * @param userId userId
+     * @return resource list
      */
-    List<Resource> queryAuthorizedResourceList(@Param("userId") int userId);
-
     List<Resource> queryResourceExceptUserId(@Param("userId") int userId);
 
 
+    /**
+     * query tenant code by name
+     * @param resName resource name
+     * @return tenant code
+     */
     String queryTenantCodeByResourceName(@Param("resName") String resName);
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ResourceUserMapper.java

@@ -20,8 +20,17 @@ import org.apache.dolphinscheduler.dao.entity.ResourcesUser;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
+/**
+ * resource user relation mapper interface
+ */
 public interface ResourceUserMapper extends BaseMapper<ResourcesUser> {
 
+    /**
+     * delete resource user relation
+     * @param userId userId
+     * @param resourceId resourceId
+     * @return delete result
+     */
     int deleteResourceUser(@Param("userId") int userId,
                            @Param("resourceId") int resourceId);
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/ScheduleMapper.java

@@ -23,17 +23,41 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * scheduler mapper interface
+ */
 public interface ScheduleMapper extends BaseMapper<Schedule> {
 
-
+    /**
+     * scheduler page
+     * @param page page
+     * @param processDefinitionId processDefinitionId
+     * @param searchVal searchVal
+     * @return scheduler IPage
+     */
     IPage<Schedule> queryByProcessDefineIdPaging(IPage<Schedule> page,
                                                  @Param("processDefinitionId") int processDefinitionId,
                                                  @Param("searchVal") String searchVal);
-    List<Schedule> querySchedulerListByProjectName(@Param("projectName") String projectName);
 
+    /**
+     * query schedule list by project name
+     * @param projectName projectName
+     * @return schedule list
+     */
+    List<Schedule> querySchedulerListByProjectName(@Param("projectName") String projectName);
 
+    /**
+     * query schedule list by process definition ids
+     * @param processDefineIds processDefineIds
+     * @return schedule list
+     */
     List<Schedule> selectAllByProcessDefineArray(@Param("processDefineIds") int[] processDefineIds);
 
+    /**
+     * query schedule list by process definition id
+     * @param processDefinitionId processDefinitionId
+     * @return schedule list
+     */
     List<Schedule> queryByProcessDefinitionId(@Param("processDefinitionId") int processDefinitionId);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/SessionMapper.java

@@ -22,10 +22,24 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * session mapper interface
+ */
 public interface SessionMapper extends BaseMapper<Session> {
 
+    /**
+     * query session list by userId
+     * @param userId userId
+     * @return session list
+     */
     List<Session> queryByUserId(@Param("userId") int userId);
 
+    /**
+     * query session by userId and Ip
+     * @param userId userId
+     * @param ip ip
+     * @return session
+     */
     Session queryByUserIdAndIp(@Param("userId") int userId,@Param("ip") String ip);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/TaskInstanceMapper.java

@@ -28,6 +28,9 @@ import org.apache.ibatis.annotations.Param;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * task instance mapper interface
+ */
 public interface TaskInstanceMapper extends BaseMapper<TaskInstance> {
 
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/TenantMapper.java

@@ -23,12 +23,31 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * tenant mapper interface
+ */
 public interface TenantMapper extends BaseMapper<Tenant> {
 
+    /**
+     * query tenant by id
+     * @param tenantId tenantId
+     * @return tenant
+     */
     Tenant queryById(@Param("tenantId") int tenantId);
 
+    /**
+     * query tenant by code
+     * @param tenantCode tenantCode
+     * @return tenant list
+     */
     List<Tenant> queryByTenantCode(@Param("tenantCode") String tenantCode);
 
+    /**
+     * tenant page
+     * @param page page
+     * @param searchVal searchVal
+     * @return tenant IPage
+     */
     IPage<Tenant> queryTenantPaging(IPage<Tenant> page,
                                     @Param("searchVal") String searchVal);
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/UDFUserMapper.java

@@ -20,10 +20,23 @@ import org.apache.dolphinscheduler.dao.entity.UDFUser;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
+/**
+ * udf user realtion mapper interface
+ */
 public interface UDFUserMapper extends BaseMapper<UDFUser> {
 
+    /**
+     * delete udf user realtion by userId
+     * @param userId userId
+     * @return delete result
+     */
     int deleteByUserId(@Param("userId") int userId);
 
+    /**
+     * delete udf user realtion by function id
+     * @param udfFuncId udfFuncId
+     * @return delete result
+     */
     int deleteByUdfFuncId(@Param("udfFuncId") int udfFuncId);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/UdfFuncMapper.java

@@ -23,21 +23,53 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * udf function mapper interface
+ */
 public interface UdfFuncMapper extends BaseMapper<UdfFunc> {
 
 
+    /**
+     * query udf function by ids and function name
+     * @param ids ids
+     * @param funcNames funcNames
+     * @return udf function list
+     */
     List<UdfFunc> queryUdfByIdStr(@Param("ids") int[] ids,
                                   @Param("funcNames") String funcNames);
 
+    /**
+     * udf function page
+     * @param page page
+     * @param userId userId
+     * @param searchVal searchVal
+     * @return udf function IPage
+     */
     IPage<UdfFunc> queryUdfFuncPaging(IPage<UdfFunc> page,
                                       @Param("userId") int userId,
                                       @Param("searchVal") String searchVal);
 
+    /**
+     * query udf function by type
+     * @param userId userId
+     * @param type type
+     * @return udf function list
+     */
     List<UdfFunc> getUdfFuncByType(@Param("userId") int userId,
                                    @Param("type") Integer type);
 
+    /**
+     * query udf function except userId
+     * @param userId userId
+     * @return udf function list
+     */
     List<UdfFunc> queryUdfFuncExceptUserId(@Param("userId") int userId);
 
+    /**
+     *  query authed udf function
+     * @param userId userId
+     * @return udf function list
+     */
     List<UdfFunc> queryAuthedUdfFunc(@Param("userId") int userId);
 
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/UserAlertGroupMapper.java

@@ -23,10 +23,23 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * user alertgroup relation mapper interface
+ */
 public interface UserAlertGroupMapper extends BaseMapper<UserAlertGroup> {
 
+    /**
+     * delete user alertgroup relation by alertgroupId
+     * @param alertgroupId alertgroupId
+     * @return delete result
+     */
     int deleteByAlertgroupId(@Param("alertgroupId") int alertgroupId);
 
+    /**
+     *  list user by alertgroupId
+     * @param alertgroupId alertgroupId
+     * @return user list
+     */
     List<User> listUserByAlertgroupId(@Param("alertgroupId") int alertgroupId);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/UserMapper.java

@@ -24,26 +24,75 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * user mapper interface
+ */
 public interface UserMapper extends BaseMapper<User> {
 
+    /**
+     * query all general user
+     * @return user list
+     */
     List<User> queryAllGeneralUser();
 
+    /**
+     * query user by name
+     * @param userName userName
+     * @return user
+     */
     User queryByUserNameAccurately(@Param("userName") String userName);
 
+    /**
+     * query user by userName and password
+     * @param userName userName
+     * @param password password
+     * @return user
+     */
     User queryUserByNamePassword(@Param("userName") String userName, @Param("password") String password);
 
 
+    /**
+     * user page
+     * @param page page
+     * @param userName userName
+     * @return user IPage
+     */
     IPage<User> queryUserPaging(Page page,
                                 @Param("userName") String userName);
 
+    /**
+     * query user detail by id
+     * @param userId userId
+     * @return user
+     */
     User queryDetailsById(@Param("userId") int userId);
 
+    /**
+     * query user list by alertgroupId
+     * @param alertgroupId alertgroupId
+     * @return user list
+     */
     List<User> queryUserListByAlertGroupId(@Param("alertgroupId") int alertgroupId);
 
+    /**
+     * query user list by tenantId
+     * @param tenantId tenantId
+     * @return user list
+     */
     List<User> queryUserListByTenant(@Param("tenantId") int tenantId);
 
+    /**
+     * query user by userId
+     * @param userId userId
+     * @return user
+     */
     User queryTenantCodeByUserId(@Param("userId") int userId);
 
+    /**
+     * query user by token
+     * @param token token
+     * @return user
+     */
     User queryUserByToken(@Param("token") String token);
 
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/WorkerGroupMapper.java

@@ -23,12 +23,30 @@ import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
+/**
+ * worker group mapper interface
+ */
 public interface WorkerGroupMapper extends BaseMapper<WorkerGroup> {
 
+    /**
+     * query all worker group
+     * @return worker group list
+     */
     List<WorkerGroup> queryAllWorkerGroup();
 
+    /**
+     * query worer grouop by name
+     * @param name name
+     * @return worker group list
+     */
     List<WorkerGroup> queryWorkerGroupByName(@Param("name") String name);
 
+    /**
+     * worker group page
+     * @param page page
+     * @param searchVal searchVal
+     * @return worker group IPage
+     */
     IPage<WorkerGroup> queryListPaging(IPage<WorkerGroup> page,
                                        @Param("searchVal") String searchVal);
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/DolphinSchedulerManager.java

@@ -30,6 +30,9 @@ public class DolphinSchedulerManager {
     private static final Logger logger = LoggerFactory.getLogger(DolphinSchedulerManager.class);
     UpgradeDao upgradeDao;
 
+    /**
+     * init upgrade dao
+     */
     private void initUpgradeDao() {
         DbType dbType = UpgradeDao.getDbType();
         if (dbType != null) {
@@ -47,10 +50,16 @@ public class DolphinSchedulerManager {
         }
     }
 
+    /**
+     * constructor init
+     */
     public DolphinSchedulerManager() {
         initUpgradeDao();
     }
 
+    /**
+     * init DolphinScheduler
+     */
     public void initDolphinScheduler() {
         // Determines whether the dolphinscheduler table structure has been init
         if (upgradeDao.isExistsTable("t_escheduler_version") ||
@@ -62,6 +71,9 @@ public class DolphinSchedulerManager {
         this.initDolphinSchedulerSchema();
     }
 
+    /**
+     * init DolphinScheduler Schema
+     */
     public void initDolphinSchedulerSchema() {
 
         logger.info("Start initializing the DolphinScheduler manager table structure");
@@ -71,6 +83,7 @@ public class DolphinSchedulerManager {
 
     /**
      * upgrade DolphinScheduler
+     * @throws Exception if error throws Exception
      */
     public void upgradeDolphinScheduler() throws Exception{
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/MysqlUpgradeDao.java

@@ -25,19 +25,31 @@ import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
+/**
+ * mysql upgrade dao
+ */
 public class MysqlUpgradeDao extends UpgradeDao {
 
     public static final Logger logger = LoggerFactory.getLogger(UpgradeDao.class);
 
+    /**
+     * init
+     */
     @Override
     protected void init() {
 
     }
 
+    /**
+     * mysql upgrade dao holder
+     */
     private static class MysqlUpgradeDaoHolder {
         private static final MysqlUpgradeDao INSTANCE = new MysqlUpgradeDao();
     }
 
+    /**
+     * mysql upgrade dao constructor
+     */
     private MysqlUpgradeDao() {
     }
 
@@ -47,10 +59,11 @@ public class MysqlUpgradeDao extends UpgradeDao {
 
 
     /**
-     * Determines whether a table exists
-     * @param tableName
-     * @return
+     * determines whether a table exists
+     * @param tableName tableName
+     * @return if table exist return true，else return false
      */
+    @Override
     public boolean isExistsTable(String tableName) {
         ResultSet rs = null;
         Connection conn = null;
@@ -73,11 +86,12 @@ public class MysqlUpgradeDao extends UpgradeDao {
     }
 
     /**
-     * Determines whether a field exists in the specified table
-     * @param tableName
-     * @param columnName
-     * @return
+     * determines whether a field exists in the specified table
+     * @param tableName tableName
+     * @param columnName columnName
+     * @return  if column name exist return true，else return false
      */
+    @Override
     public boolean isExistsColumn(String tableName,String columnName) {
         Connection conn = null;
         try {

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/PostgresqlUpgradeDao.java

@@ -26,20 +26,32 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
+/**
+ * postgresql upgrade dao
+ */
 public class PostgresqlUpgradeDao extends UpgradeDao {
 
     public static final Logger logger = LoggerFactory.getLogger(UpgradeDao.class);
     private static final String schema = getSchema();
 
+    /**
+     * init
+     */
     @Override
     protected void init() {
 
     }
 
+    /**
+     * postgresql upgrade dao holder
+     */
     private static class PostgresqlUpgradeDaoHolder {
         private static final PostgresqlUpgradeDao INSTANCE = new PostgresqlUpgradeDao();
     }
 
+    /**
+     * PostgresqlUpgradeDao Constructor
+     */
     private PostgresqlUpgradeDao() {
     }
 
@@ -48,11 +60,19 @@ public class PostgresqlUpgradeDao extends UpgradeDao {
     }
 
 
+    /**
+     * init schema
+     * @param initSqlPath initSqlPath
+     */
     @Override
     public void initSchema(String initSqlPath) {
         super.initSchema(initSqlPath);
     }
 
+    /**
+     * getSchema
+     * @return schema
+     */
     public static String getSchema(){
         Connection conn = null;
         PreparedStatement pstmt = null;
@@ -75,11 +95,13 @@ public class PostgresqlUpgradeDao extends UpgradeDao {
         return "";
     }
 
+
     /**
-     * Determines whether a table exists
-     * @param tableName
-     * @return
+     * determines whether a table exists
+     * @param tableName tableName
+     * @return if table exist return true，else return false
      */
+    @Override
     public boolean isExistsTable(String tableName) {
         Connection conn = null;
         ResultSet rs = null;
@@ -103,11 +125,12 @@ public class PostgresqlUpgradeDao extends UpgradeDao {
     }
 
     /**
-     * Determines whether a field exists in the specified table
-     * @param tableName
-     * @param columnName
-     * @return
+     * determines whether a field exists in the specified table
+     * @param tableName tableName
+     * @param columnName columnName
+     * @return  if column name exist return true，else return false
      */
+    @Override
     public boolean isExistsColumn(String tableName,String columnName) {
         Connection conn = null;
         ResultSet rs = null;

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/UpgradeDao.java

@@ -50,8 +50,8 @@ public abstract class UpgradeDao extends AbstractBaseDao {
     }
 
     /**
-     * get db type
-     * @return
+     * get datasource
+     * @return DruidDataSource
      */
     public static DruidDataSource getDataSource(){
         DruidDataSource dataSource = ConnectionFactory.getDataSource();
@@ -64,14 +64,14 @@ public abstract class UpgradeDao extends AbstractBaseDao {
 
     /**
      * get db type
-     * @return
+     * @return dbType
      */
     public static DbType getDbType(){
         return dbType;
     }
 
     /**
-     * get db type
+     * get current dbType
      * @return
      */
     private static DbType getCurrentDbType(){
@@ -88,6 +88,9 @@ public abstract class UpgradeDao extends AbstractBaseDao {
         }
     }
 
+    /**
+     * init schema
+     */
     public void initSchema(){
         DbType dbType = getDbType();
         String initSqlPath = "";
@@ -109,6 +112,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
     }
 
 
+    /**
+     * init scheam
+     * @param initSqlPath initSqlPath
+     */
     public void initSchema(String initSqlPath) {
 
         // Execute the dolphinscheduler DDL, it cannot be rolled back
@@ -119,6 +126,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
 
     }
 
+    /**
+     * run DML
+     * @param initSqlPath initSqlPath
+     */
     private void runInitDML(String initSqlPath) {
         Connection conn = null;
         if (StringUtils.isEmpty(rootDir)) {
@@ -158,6 +169,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
 
     }
 
+    /**
+     * run DDL
+     * @param initSqlPath initSqlPath
+     */
     private void runInitDDL(String initSqlPath) {
         Connection conn = null;
         if (StringUtils.isEmpty(rootDir)) {
@@ -188,21 +203,26 @@ public abstract class UpgradeDao extends AbstractBaseDao {
     }
 
     /**
-     * Determines whether a table exists
-     * @param tableName
-     * @return
+     * determines whether a table exists
+     * @param tableName tableName
+     * @return if table exist return true，else return false
      */
     public abstract boolean isExistsTable(String tableName);
 
     /**
-     * Determines whether a field exists in the specified table
-     * @param tableName
-     * @param columnName
-     * @return
+     * determines whether a field exists in the specified table
+     * @param tableName tableName
+     * @param columnName columnName
+     * @return  if column name exist return true，else return false
      */
     public abstract boolean isExistsColumn(String tableName,String columnName);
 
 
+    /**
+     * get current version
+     * @param versionName versionName
+     * @return version
+     */
     public String getCurrentVersion(String versionName) {
         String sql = String.format("select version from %s",versionName);
         Connection conn = null;
@@ -229,6 +249,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
     }
 
 
+    /**
+     * upgrade DolphinScheduler
+     * @param schemaDir schema dir
+     */
     public void upgradeDolphinScheduler(String schemaDir) {
 
         upgradeDolphinSchedulerDDL(schemaDir);
@@ -237,6 +261,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
 
     }
 
+    /**
+     * upgradeDolphinScheduler DML
+     * @param schemaDir schemaDir
+     */
     private void upgradeDolphinSchedulerDML(String schemaDir) {
         String schemaVersion = schemaDir.split("_")[0];
         if (StringUtils.isEmpty(rootDir)) {
@@ -305,6 +333,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
 
     }
 
+    /**
+     * upgradeDolphinScheduler DDL
+     * @param schemaDir schemaDir
+     */
     private void upgradeDolphinSchedulerDDL(String schemaDir) {
         if (StringUtils.isEmpty(rootDir)) {
             throw new RuntimeException("Environment variable user.dir not found");
@@ -345,7 +377,10 @@ public abstract class UpgradeDao extends AbstractBaseDao {
     }
 
 
-
+    /**
+     * update version
+     * @param version version
+     */
     public void updateVersion(String version) {
         // Change version in the version table to the new version
         String versionName = T_VERSION_NAME;

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/shell/CreateDolphinScheduler.java

@@ -21,16 +21,19 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * init DolphinScheduler
+ * create DolphinScheduler
  *
  */
 public class CreateDolphinScheduler {
 
 	private static final Logger logger = LoggerFactory.getLogger(CreateDolphinScheduler.class);
 
+	/**
+	 * create dolphin scheduler db
+	 * @param args args
+	 */
 	public static void main(String[] args) {
 		DolphinSchedulerManager dolphinSchedulerManager = new DolphinSchedulerManager();
-
 		try {
 			dolphinSchedulerManager.initDolphinScheduler();
 			logger.info("init DolphinScheduler finished");

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/shell/InitDolphinScheduler.java

@@ -28,6 +28,10 @@ public class InitDolphinScheduler {
 
 	private static final Logger logger = LoggerFactory.getLogger(InitDolphinScheduler.class);
 
+	/**
+	 * init dolphin scheduler db
+	 * @param args args
+	 */
 	public static void main(String[] args) {
 		Thread.currentThread().setName("manager-InitDolphinScheduler");
 		DolphinSchedulerManager dolphinSchedulerManager = new DolphinSchedulerManager();

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/upgrade/shell/UpgradeDolphinScheduler.java

@@ -21,11 +21,15 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * upgrade DolphinScheduler database
+ * upgrade DolphinScheduler
  */
 public class UpgradeDolphinScheduler {
 	private static final Logger logger = LoggerFactory.getLogger(UpgradeDolphinScheduler.class);
 
+	/**
+	 * upgrade dolphin scheduler db
+	 * @param args args
+	 */
 	public static void main(String[] args) {
 		DolphinSchedulerManager dolphinSchedulerManager = new DolphinSchedulerManager();
 		try {

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/BaseDBPerformance.java

@@ -21,14 +21,15 @@ import org.apache.dolphinscheduler.dao.entity.MonitorRecord;
 import java.sql.Connection;
 
 /**
- *
+ * db performance abstract class
  */
 public abstract class BaseDBPerformance {
 
 
     /**
      * return the current database performance
-     * @return
+     * @param conn connection
+     * @return MonitorRecord
      */
     protected abstract MonitorRecord getMonitorRecord(Connection conn);
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/BeanContext.java

@@ -33,17 +33,35 @@ import org.springframework.stereotype.Component;
         return applicationContext;
     }
 
+    /**
+     * get bean
+     * @param name class name
+     * @param <T> generic
+     * @return target object
+     * @throws BeansException if error throws BeansException
+     */
     @SuppressWarnings("unchecked")
     public static <T> T getBean(String name) throws BeansException {
         return (T)applicationContext.getBean(name);
     }
 
-    public static <T> T getBean(Class<T> clz) throws BeansException {
-        return applicationContext.getBean(clz);
+    /**
+     * get bean
+     * @param clazz clazz
+     * @param <T> generic
+     * @return target object
+     * @throws BeansException if error throws BeansException
+     */
+    public static <T> T getBean(Class<T> clazz) throws BeansException {
+        return applicationContext.getBean(clazz);
     }
 
 
-
+    /**
+     * set applicationcontext
+     * @param applicationContext applicationContext
+     * @throws BeansException if error throws BeansException
+     */
     @Override
     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
         BeanContext.applicationContext = applicationContext;

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/DagHelper.java

@@ -41,12 +41,12 @@ public class DagHelper {
 
     private static final Logger logger = LoggerFactory.getLogger(DagHelper.class);
 
+
     /**
      * generate flow node relation list by task node list;
      * Edges that are not in the task Node List will not be added to the result
-     *
-     * @param taskNodeList
-     * @return
+     * @param taskNodeList taskNodeList
+     * @return task node relation list
      */
     public static List<TaskNodeRelation> generateRelationListByFlowNodes(List<TaskNode> taskNodeList) {
         List<TaskNodeRelation> nodeRelationList = new ArrayList<>();
@@ -66,10 +66,11 @@ public class DagHelper {
 
     /**
      * generate task nodes needed by dag
-     *
-     * @param taskNodeList
-     * @param taskDependType
-     * @return
+     * @param taskNodeList taskNodeList
+     * @param startNodeNameList startNodeNameList
+     * @param recoveryNodeNameList recoveryNodeNameList
+     * @param taskDependType taskDependType
+     * @return task node list
      */
     public static List<TaskNode> generateFlowNodeListByStartNode(List<TaskNode> taskNodeList, List<String> startNodeNameList,
                                                                  List<String> recoveryNodeNameList, TaskDependType taskDependType) {
@@ -88,10 +89,10 @@ public class DagHelper {
             startNodeList = recoveryNodeNameList;
         }
         if (startNodeList == null || startNodeList.size() == 0) {
-            // 没有特殊的指定start nodes
+            // no special designation start nodes
             tmpTaskNodeList = taskNodeList;
         } else {
-            // 指定了start nodes or 恢复执行
+            // specified start nodes or resume execution
             for (String startNodeName : startNodeList) {
                 TaskNode startNode = findNodeByName(taskNodeList, startNodeName);
                 List<TaskNode> childNodeList = new ArrayList<>();
@@ -117,10 +118,9 @@ public class DagHelper {
 
     /**
      * find all the nodes that depended on the start node
-     *
-     * @param startNode
-     * @param taskNodeList
-     * @return
+     * @param startNode startNode
+     * @param taskNodeList taskNodeList
+     * @return task node list
      */
     private static List<TaskNode> getFlowNodeListPost(TaskNode startNode, List<TaskNode> taskNodeList) {
         List<TaskNode> resultList = new ArrayList<>();
@@ -137,12 +137,13 @@ public class DagHelper {
         return resultList;
     }
 
+
     /**
      * find all nodes that start nodes depend on.
-     *
-     * @param startNode
-     * @param taskNodeList
-     * @return
+     * @param startNode startNode
+     * @param recoveryNodeNameList recoveryNodeNameList
+     * @param taskNodeList taskNodeList
+     * @return task node list
      */
     private static List<TaskNode> getFlowNodeListPre(TaskNode startNode, List<String> recoveryNodeNameList, List<TaskNode> taskNodeList) {
 
@@ -166,12 +167,12 @@ public class DagHelper {
 
     /**
      * generate dag by start nodes and recovery nodes
-     * @param processDefinitionJson
-     * @param startNodeNameList
-     * @param recoveryNodeNameList
-     * @param depNodeType
-     * @return
-     * @throws Exception
+     * @param processDefinitionJson processDefinitionJson
+     * @param startNodeNameList startNodeNameList
+     * @param recoveryNodeNameList recoveryNodeNameList
+     * @param depNodeType depNodeType
+     * @return process dag
+     * @throws Exception if error throws Exception
      */
     public static ProcessDag generateFlowDag(String processDefinitionJson,
                                              List<String> startNodeNameList,
@@ -193,8 +194,8 @@ public class DagHelper {
 
     /**
      * parse the forbidden task nodes in process definition.
-     * @param processDefinitionJson
-     * @return
+     * @param processDefinitionJson processDefinitionJson
+     * @return task node map
      */
     public static Map<String, TaskNode> getForbiddenTaskNodeMaps(String processDefinitionJson){
         Map<String, TaskNode> forbidTaskNodeMap = new ConcurrentHashMap<>();
@@ -212,10 +213,9 @@ public class DagHelper {
 
     /**
      * find node by node name
-     * @param nodeDetails
-     * @param nodeName
-     * @return
-     * @see TaskNode
+     * @param nodeDetails nodeDetails
+     * @param nodeName nodeName
+     * @return task node
      */
     public static TaskNode findNodeByName(List<TaskNode> nodeDetails, String nodeName) {
         for (TaskNode taskNode : nodeDetails) {
@@ -230,10 +230,10 @@ public class DagHelper {
     /**
      * get start vertex in one dag
      * it would find the post node if the start vertex is forbidden running
-     * @param parentNodeName the previous node
-     * @param dag
-     * @param completeTaskList
-     * @return
+     * @param parentNodeName previous node
+     * @param dag dag
+     * @param completeTaskList completeTaskList
+     * @return start Vertex list
      */
     public static Collection<String> getStartVertex(String parentNodeName, DAG<String, TaskNode, TaskNodeRelation> dag,
                                                     Map<String, TaskInstance> completeTaskList){
@@ -274,10 +274,10 @@ public class DagHelper {
 
     /**
      * the task can be submit when  all the depends nodes are forbidden or complete
-     * @param taskNode
-     * @param dag
-     * @param completeTaskList
-     * @return
+     * @param taskNode taskNode
+     * @param dag dag
+     * @param completeTaskList completeTaskList
+     * @return can submit
      */
     public static boolean taskNodeCanSubmit(TaskNode taskNode,
                                             DAG<String, TaskNode, TaskNodeRelation> dag,
@@ -299,9 +299,9 @@ public class DagHelper {
 
 
     /***
-     * generate dag graph
-     * @param processDag
-     * @return
+     * build dag graph
+     * @param processDag processDag
+     * @return dag
      */
     public static DAG<String, TaskNode, TaskNodeRelation> buildDagGraph(ProcessDag processDag) {
 

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/MysqlPerformance.java

@@ -32,11 +32,19 @@ import java.util.Date;
 
 import static org.apache.dolphinscheduler.dao.MonitorDBDao.VARIABLE_NAME;
 
+/**
+ * mysql performance
+ */
 public class MysqlPerformance extends BaseDBPerformance{
 
     private static Logger logger = LoggerFactory.getLogger(MonitorDBDao.class);
 
 
+    /**
+     * get monitor record
+     * @param conn connection
+     * @return MonitorRecord
+     */
     @Override
     public MonitorRecord getMonitorRecord(Connection conn) {
         MonitorRecord monitorRecord = new MonitorRecord();

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/PostgrePerformance.java

@@ -29,10 +29,18 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Date;
 
+/**
+ * postgresql performance
+ */
 public class PostgrePerformance extends BaseDBPerformance {
 
     private static Logger logger = LoggerFactory.getLogger(MonitorDBDao.class);
 
+    /**
+     * get monitor record
+     * @param conn connection
+     * @return MonitorRecord
+     */
     @Override
     public MonitorRecord getMonitorRecord(Connection conn) {
         MonitorRecord monitorRecord = new MonitorRecord();

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/PropertyUtils.java

@@ -45,6 +45,9 @@ public class PropertyUtils {
         init();
     }
 
+    /**
+     * init
+     */
     private void init(){
         String[] propertyFiles = new String[]{Constants.DAO_PROPERTIES_PATH};
         for (String fileName : propertyFiles) {
@@ -65,25 +68,18 @@ public class PropertyUtils {
         }
     }
 
-/*
-    public static PropertyUtils getInstance(){
-        return propertyUtils;
-    }
-*/
-
     /**
      * get property value
-     *
      * @param key property name
-     * @return
+     * @return get string value
      */
     public static String getString(String key) {
         return properties.getProperty(key);
     }
 
+
     /**
      * get property value
-     *
      * @param key property name
      * @return  get property int value , if key == null, then return -1
      */
@@ -92,10 +88,10 @@ public class PropertyUtils {
     }
 
     /**
-     *
-     * @param key
-     * @param defaultValue
-     * @return
+     * get property value
+     * @param key key
+     * @param defaultValue defaultValue
+     * @return get property int value，if key == null ，then return  defaultValue
      */
     public static int getInt(String key, int defaultValue) {
         String value = getString(key);
@@ -110,86 +106,4 @@ public class PropertyUtils {
         }
         return defaultValue;
     }
-
-    /**
-     * get property value
-     *
-     * @param key property name
-     * @return
-     */
-    public static Boolean getBoolean(String key) {
-        String value = properties.getProperty(key.trim());
-        if(null != value){
-            return Boolean.parseBoolean(value);
-        }
-
-        return false;
-    }
-
-    /**
-     *
-     * @param key
-     * @return
-     */
-    public static long getLong(String key) {
-        return getLong(key,-1);
-    }
-
-    /**
-     *
-     * @param key
-     * @param defaultVal
-     * @return
-     */
-    public static long getLong(String key, long defaultVal) {
-        String val = getString(key);
-        return val == null ? defaultVal : Long.parseLong(val);
-    }
-
-
-    /**
-     *
-     * @param key
-     * @param defaultVal
-     * @return
-     */
-    public double getDouble(String key, double defaultVal) {
-        String val = getString(key);
-        return val == null ? defaultVal : Double.parseDouble(val);
-    }
-
-
-    /**
-     *  get array
-     * @param key       property name
-     * @param splitStr  separator
-     * @return
-     */
-    public static String[] getArray(String key, String splitStr) {
-        String value = getString(key);
-        if (value == null) {
-            return null;
-        }
-        try {
-            String[] propertyArray = value.split(splitStr);
-            return propertyArray;
-        } catch (NumberFormatException e) {
-            logger.info(e.getMessage(),e);
-        }
-        return null;
-    }
-
-    /**
-     *
-     * @param key
-     * @param type
-     * @param defaultValue
-     * @param <T>
-     * @return  get enum value
-     */
-    public <T extends Enum<T>> T getEnum(String key, Class<T> type,
-                                         T defaultValue) {
-        String val = getString(key);
-        return val == null ? defaultValue : Enum.valueOf(type, val);
-    }
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/cron/AbstractCycle.java

@@ -40,6 +40,10 @@ public abstract class AbstractCycle {
     return new CycleLinks(this.cron).addCycle(this).addCycle(cycle);
   }
 
+  /**
+   * cycle constructor
+   * @param cron cron
+   */
   public AbstractCycle(Cron cron) {
     if (cron == null) {
       throw new IllegalArgumentException("cron must not be null!");
@@ -55,8 +59,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the minute field has a value
-   * @return
+   * whether the minute field has a value
+   * @return if minute field has a value return true，else return false
    */
   protected boolean minFiledIsSetAll(){
     FieldExpression minFieldExpression = minField.getExpression();
@@ -67,8 +71,8 @@ public abstract class AbstractCycle {
 
 
   /**
-   * Whether the minute field has a value of every or always
-   * @return
+   * whether the minute field has a value of every or always
+   * @return if minute field has a value of every or always return true，else return false
    */
   protected boolean minFiledIsEvery(){
     FieldExpression minFieldExpression = minField.getExpression();
@@ -76,8 +80,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the hour field has a value
-   * @return
+   * whether the hour field has a value
+   * @return if hour field has a value return true，else return false
    */
   protected boolean hourFiledIsSetAll(){
     FieldExpression hourFieldExpression = hourField.getExpression();
@@ -87,8 +91,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the hour field has a value of every or always
-   * @return
+   * whether the hour field has a value of every or always
+   * @return if hour field has a value of every or always return true，else return false
    */
   protected boolean hourFiledIsEvery(){
     FieldExpression hourFieldExpression = hourField.getExpression();
@@ -96,8 +100,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the day Of month field has a value
-   * @return
+   * whether the day Of month field has a value
+   * @return if day Of month field has a value return true，else return false
    */
   protected boolean dayOfMonthFieldIsSetAll(){
     return (dayOfMonthField.getExpression() instanceof Every || dayOfMonthField.getExpression() instanceof Always
@@ -107,16 +111,16 @@ public abstract class AbstractCycle {
 
 
   /**
-   * Whether the day Of Month field has a value of every or always
-   * @return
+   * whether the day Of Month field has a value of every or always
+   * @return if day Of Month field has a value of every or always return true，else return false
    */
   protected boolean dayOfMonthFieldIsEvery(){
     return (dayOfMonthField.getExpression() instanceof Every || dayOfMonthField.getExpression() instanceof Always);
   }
 
   /**
-   * Whether month field has a value
-   * @return
+   * whether month field has a value
+   * @return if month field has a value return true，else return false
    */
   protected boolean monthFieldIsSetAll(){
     FieldExpression monthFieldExpression = monthField.getExpression();
@@ -126,8 +130,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the month field has a value of every or always
-   * @return
+   * whether the month field has a value of every or always
+   * @return if  month field has a value of every or always return true，else return false
    */
   protected boolean monthFieldIsEvery(){
     FieldExpression monthFieldExpression = monthField.getExpression();
@@ -135,8 +139,8 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the day Of week field has a value
-   * @return
+   * whether the day Of week field has a value
+   * @return if day Of week field has a value return true，else return false
    */
   protected boolean dayofWeekFieldIsSetAll(){
     FieldExpression dayOfWeekFieldExpression = dayOfWeekField.getExpression();
@@ -146,24 +150,23 @@ public abstract class AbstractCycle {
   }
 
   /**
-   * Whether the day Of week field has a value of every or always
-   * @return
+   * whether the day Of week field has a value of every or always
+   * @return if day Of week field has a value of every or always return true，else return false
    */
   protected boolean dayofWeekFieldIsEvery(){
     FieldExpression dayOfWeekFieldExpression = dayOfWeekField.getExpression();
     return (dayOfWeekFieldExpression instanceof Every || dayOfWeekFieldExpression instanceof Always);
   }
+
   /**
    * get cycle enum
-   *
-   * @return
+   * @return CycleEnum
    */
   protected abstract CycleEnum getCycle();
 
   /**
    * get mini level cycle enum
-   *
-   * @return
+   * @return CycleEnum
    */
   protected abstract CycleEnum getMiniCycle();
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/cron/CronUtils.java

@@ -45,64 +45,47 @@ public class CronUtils {
   private static final CronParser QUARTZ_CRON_PARSER = new CronParser(CronDefinitionBuilder.instanceDefinitionFor(QUARTZ));
 
   /**
-   * Parse string with cron expression to Cron
-   *
-   * @param cronExpression
-   *            - cron expression, never null
+   * parse to cron
+   * @param cronExpression cron expression, never null
    * @return Cron instance, corresponding to cron expression received
-   * @throws java.lang.IllegalArgumentException
-   *             if expression does not match cron definition
    */
   public static Cron parse2Cron(String cronExpression) {
     return QUARTZ_CRON_PARSER.parse(cronExpression);
   }
 
+
   /**
-   * build a new <CODE>CronExpression</CODE> based on the string cronExpression.
-   *
-   * @param cronExpression String representation of the cron expression the
-   *                       new object should represent
-   * @throws java.text.ParseException
-   *         if the string expression cannot be parsed into a valid
-   *         <CODE>CronExpression</CODE>
+   * build a new CronExpression based on the string cronExpression
+   * @param cronExpression String representation of the cron expression the new object should represent
+   * @return CronExpression
+   * @throws ParseException if the string expression cannot be parsed into a valid
    */
   public static CronExpression parse2CronExpression(String cronExpression) throws ParseException {
     return new CronExpression(cronExpression);
   }
 
   /**
-   * get cycle enum
-   * @param cron
-   * @return
+   * get max cycle
+   * @param cron cron
+   * @return CycleEnum
    */
   public static CycleEnum getMaxCycle(Cron cron) {
     return min(cron).addCycle(hour(cron)).addCycle(day(cron)).addCycle(week(cron)).addCycle(month(cron)).getCycle();
   }
 
   /**
-   * get cycle enum
-   * @param cron
-   * @return
+   * get min cycle
+   * @param cron cron
+   * @return CycleEnum
    */
   public static CycleEnum getMiniCycle(Cron cron) {
     return min(cron).addCycle(hour(cron)).addCycle(day(cron)).addCycle(week(cron)).addCycle(month(cron)).getMiniCycle();
   }
 
   /**
-   * get mini level of cycle enum
-   *
-   * @param crontab
-   * @return
-   */
-  public static CycleEnum getMiniCycle(String crontab) {
-    return getMiniCycle(parse2Cron(crontab));
-  }
-
-  /**
-   * get cycle enum
-   *
-   * @param crontab
-   * @return
+   * get max cycle
+   * @param crontab crontab
+   * @return CycleEnum
    */
   public static CycleEnum getMaxCycle(String crontab) {
     return getMaxCycle(parse2Cron(crontab));
@@ -110,10 +93,10 @@ public class CronUtils {
 
   /**
    * gets all scheduled times for a period of time based on not self dependency
-   * @param startTime
-   * @param endTime
-   * @param cronExpression
-   * @return
+   * @param startTime startTime
+   * @param endTime endTime
+   * @param cronExpression cronExpression
+   * @return date list
    */
   public static List<Date> getFireDateList(Date startTime, Date endTime, CronExpression cronExpression) {
     List<Date> dateList = new ArrayList<>();
@@ -131,11 +114,11 @@ public class CronUtils {
 
   /**
    * gets expect scheduled times for a period of time based on self dependency
-   * @param startTime
-   * @param endTime
-   * @param cronExpression
-   * @param fireTimes
-   * @return
+   * @param startTime startTime
+   * @param endTime endTime
+   * @param cronExpression cronExpression
+   * @param fireTimes fireTimes
+   * @return date list
    */
   public static List<Date> getSelfFireDateList(Date startTime, Date endTime, CronExpression cronExpression,int fireTimes) {
     List<Date> dateList = new ArrayList<>();
@@ -154,10 +137,10 @@ public class CronUtils {
 
   /**
    * gets all scheduled times for a period of time based on self dependency
-   * @param startTime
-   * @param endTime
-   * @param cronExpression
-   * @return
+   * @param startTime startTime
+   * @param endTime endTime
+   * @param cronExpression cronExpression
+   * @return date list
    */
   public static List<Date> getSelfFireDateList(Date startTime, Date endTime, CronExpression cronExpression) {
     List<Date> dateList = new ArrayList<>();
@@ -176,9 +159,9 @@ public class CronUtils {
 
   /**
    * get expiration time
-   * @param startTime
-   * @param cycleEnum
-   * @return
+   * @param startTime startTime
+   * @param cycleEnum cycleEnum
+   * @return date
    */
   public static Date getExpirationTime(Date startTime, CycleEnum cycleEnum) {
     Date maxExpirationTime = null;
@@ -215,7 +198,7 @@ public class CronUtils {
   /**
    * get the end time of the day by value of date
    * @param date
-   * @return
+   * @return date
    */
   private static Date getEndTime(Date date) {
     Calendar end = new GregorianCalendar();

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/cron/CycleFactory.java

@@ -26,25 +26,50 @@ import com.cronutils.model.field.expression.QuestionMark;
  */
 public class CycleFactory {
 
-  public static AbstractCycle min(Cron cron) {
-    return new MinCycle(cron);
-  }
+    /**
+     * min
+     * @param cron cron
+     * @return AbstractCycle
+     */
+    public static AbstractCycle min(Cron cron) {
+      return new MinCycle(cron);
+    }
 
-  public static AbstractCycle hour(Cron cron) {
-    return new HourCycle(cron);
-  }
+    /**
+     * hour
+     * @param cron cron
+     * @return AbstractCycle
+     */
+    public static AbstractCycle hour(Cron cron) {
+      return new HourCycle(cron);
+    }
 
-  public static AbstractCycle day(Cron cron) {
-    return new DayCycle(cron);
-  }
+    /**
+     * day
+     * @param cron cron
+     * @return AbstractCycle
+     */
+    public static AbstractCycle day(Cron cron) {
+      return new DayCycle(cron);
+    }
 
-  public static AbstractCycle week(Cron cron) {
-    return new WeekCycle(cron);
-  }
+    /**
+     * week
+     * @param cron cron
+     * @return AbstractCycle
+     */
+    public static AbstractCycle week(Cron cron) {
+      return new WeekCycle(cron);
+    }
 
-  public static AbstractCycle month(Cron cron) {
-    return new MonthCycle(cron);
-  }
+    /**
+     * month
+     * @param cron cron
+     * @return AbstractCycle
+     */
+    public static AbstractCycle month(Cron cron) {
+      return new MonthCycle(cron);
+    }
 
   /**
    * day cycle
@@ -55,28 +80,36 @@ public class CycleFactory {
       super(cron);
     }
 
-    @Override
-    protected CycleEnum getCycle() {
+      /**
+       * get cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getCycle() {
 
-      if (minFiledIsSetAll()
-          && hourFiledIsSetAll()
-          && dayOfMonthFieldIsEvery()
-          && dayOfWeekField.getExpression() instanceof QuestionMark
-          && monthField.getExpression() instanceof Always) {
-        return CycleEnum.DAY;
-      }
-
-      return null;
-    }
+          if (minFiledIsSetAll()
+              && hourFiledIsSetAll()
+              && dayOfMonthFieldIsEvery()
+              && dayOfWeekField.getExpression() instanceof QuestionMark
+              && monthField.getExpression() instanceof Always) {
+            return CycleEnum.DAY;
+          }
 
-    @Override
-    protected CycleEnum getMiniCycle() {
-      if (dayOfMonthFieldIsEvery()) {
-        return CycleEnum.DAY;
-      }
+          return null;
+        }
+
+      /**
+       * get min cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getMiniCycle() {
+          if (dayOfMonthFieldIsEvery()) {
+            return CycleEnum.DAY;
+          }
 
-      return null;
-    }
+          return null;
+        }
   }
 
   /**
@@ -88,26 +121,34 @@ public class CycleFactory {
       super(cron);
     }
 
-    @Override
-    protected CycleEnum getCycle() {
-      if (minFiledIsSetAll()
-          && hourFiledIsEvery()
-          && dayOfMonthField.getExpression() instanceof Always
-          && dayOfWeekField.getExpression() instanceof QuestionMark
-          && monthField.getExpression() instanceof Always) {
-        return CycleEnum.HOUR;
-      }
-
-      return null;
-    }
+      /**
+       * get cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getCycle() {
+          if (minFiledIsSetAll()
+              && hourFiledIsEvery()
+              && dayOfMonthField.getExpression() instanceof Always
+              && dayOfWeekField.getExpression() instanceof QuestionMark
+              && monthField.getExpression() instanceof Always) {
+            return CycleEnum.HOUR;
+          }
 
-    @Override
-    protected CycleEnum getMiniCycle() {
-      if(hourFiledIsEvery()){
-        return CycleEnum.HOUR;
-      }
-      return null;
-    }
+          return null;
+        }
+
+      /**
+       * get mini cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getMiniCycle() {
+          if(hourFiledIsEvery()){
+            return CycleEnum.HOUR;
+          }
+          return null;
+        }
   }
 
   /**
@@ -119,6 +160,10 @@ public class CycleFactory {
           super(cron);
       }
 
+      /**
+       * get cycle
+       * @return CycleEnum
+       */
       @Override
       protected CycleEnum getCycle() {
           if (minFiledIsEvery()
@@ -131,6 +176,10 @@ public class CycleFactory {
           return null;
       }
 
+      /**
+       * get min cycle
+       * @return CycleEnum
+       */
       @Override
       protected CycleEnum getMiniCycle() {
           if(minFiledIsEvery()){
@@ -149,33 +198,41 @@ public class CycleFactory {
       super(cron);
     }
 
-    @Override
-    protected CycleEnum getCycle() {
-      boolean flag = (minFiledIsSetAll()
-              && hourFiledIsSetAll()
-              && dayOfMonthFieldIsSetAll()
-              && dayOfWeekField.getExpression() instanceof QuestionMark
-              && monthFieldIsEvery()) ||
-              (minFiledIsSetAll()
-                      && hourFiledIsSetAll()
-                      && dayOfMonthField.getExpression() instanceof QuestionMark
-                      && dayofWeekFieldIsSetAll()
-                      && monthFieldIsEvery());
-      if (flag) {
-        return CycleEnum.MONTH;
-      }
-
-      return null;
-    }
+      /**
+       * get cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getCycle() {
+          boolean flag = (minFiledIsSetAll()
+                  && hourFiledIsSetAll()
+                  && dayOfMonthFieldIsSetAll()
+                  && dayOfWeekField.getExpression() instanceof QuestionMark
+                  && monthFieldIsEvery()) ||
+                  (minFiledIsSetAll()
+                          && hourFiledIsSetAll()
+                          && dayOfMonthField.getExpression() instanceof QuestionMark
+                          && dayofWeekFieldIsSetAll()
+                          && monthFieldIsEvery());
+          if (flag) {
+            return CycleEnum.MONTH;
+          }
 
-    @Override
-    protected CycleEnum getMiniCycle() {
-      if (monthFieldIsEvery()) {
-        return CycleEnum.MONTH;
-      }
+          return null;
+        }
+
+      /**
+       * get mini cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getMiniCycle() {
+          if (monthFieldIsEvery()) {
+            return CycleEnum.MONTH;
+          }
 
-      return null;
-    }
+          return null;
+        }
   }
 
   /**
@@ -186,26 +243,34 @@ public class CycleFactory {
       super(cron);
     }
 
-    @Override
-    protected CycleEnum getCycle() {
-      if (minFiledIsSetAll()
-          && hourFiledIsSetAll()
-          && dayOfMonthField.getExpression() instanceof QuestionMark
-          && dayofWeekFieldIsEvery()
-          && monthField.getExpression() instanceof Always) {
-        return CycleEnum.WEEK;
-      }
-
-      return null;
-    }
+      /**
+       * get cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getCycle() {
+          if (minFiledIsSetAll()
+              && hourFiledIsSetAll()
+              && dayOfMonthField.getExpression() instanceof QuestionMark
+              && dayofWeekFieldIsEvery()
+              && monthField.getExpression() instanceof Always) {
+            return CycleEnum.WEEK;
+          }
 
-    @Override
-    protected CycleEnum getMiniCycle() {
-      if (dayofWeekFieldIsEvery()) {
-        return CycleEnum.WEEK;
-      }
+          return null;
+        }
+
+      /**
+       * get mini cycle
+       * @return CycleEnum
+       */
+        @Override
+        protected CycleEnum getMiniCycle() {
+          if (dayofWeekFieldIsEvery()) {
+            return CycleEnum.WEEK;
+          }
 
-      return null;
-    }
+          return null;
+        }
   }
 }

dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/utils/cron/CycleLinks.java

@@ -32,12 +32,21 @@ public class CycleLinks extends AbstractCycle {
     super(cron);
   }
 
+  /**
+   * add cycle
+   * @param cycle cycle
+   * @return CycleLinks
+   */
   @Override
   public CycleLinks addCycle(AbstractCycle cycle) {
     cycleList.add(cycle);
     return this;
   }
 
+  /**
+   * get cycle
+   * @return CycleEnum
+   */
   @Override
   protected CycleEnum getCycle() {
     for (AbstractCycle abstractCycle : cycleList) {
@@ -50,6 +59,10 @@ public class CycleLinks extends AbstractCycle {
     return null;
   }
 
+  /**
+   * get mini cycle
+   * @return CycleEnum
+   */
   @Override
   protected CycleEnum getMiniCycle() {
     for (AbstractCycle cycleHelper : cycleList) {

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/cron/CronUtilsTest.java

@@ -40,8 +40,11 @@ public class CronUtilsTest {
 
     private static final Logger logger = LoggerFactory.getLogger(CronUtilsTest.class);
 
+    /**
+     * cron as string test
+     */
     @Test
-    public void cronAsStringTest() {
+    public void testCronAsString() {
         Cron cron = CronBuilder.cron(CronDefinitionBuilder.instanceDefinitionFor(CronType.QUARTZ))
                 .withYear(always())
                 .withDoW(questionMark())
@@ -55,13 +58,20 @@ public class CronUtilsTest {
         String cronAsString = cron.asString(); // 0 */5 * * * ? *  Every five minutes(once every 5 minutes)
 
         Assert.assertEquals(cronAsString, "0 */5 * * * ? *");
-
     }
 
 
+    /**
+     * cron parse test
+     * @throws ParseException if error throws ParseException
+     */
     @Test
-    public void testParse() throws ParseException {
+    public void testCronParse() throws ParseException {
         String strCrontab = "0 1 2 3 * ? *";
+        strCrontab = "0/50 0/59 * * * ? *";
+        strCrontab = "3/5 * 0/5 * * ? *";
+        strCrontab = "1/5 3/5 1/5 3/30 * ? *";
+
         Cron depCron = CronUtils.parse2Cron(strCrontab);
         Assert.assertEquals(depCron.retrieve(CronFieldName.SECOND).getExpression().asString(), "0");
         Assert.assertEquals(depCron.retrieve(CronFieldName.MINUTE).getExpression().asString(), "1");
@@ -71,18 +81,12 @@ public class CronUtilsTest {
         Assert.assertEquals(depCron.retrieve(CronFieldName.YEAR).getExpression().asString(), "*");
     }
 
+    /**
+     * schedule type test
+     * @throws ParseException if error throws ParseException
+     */
     @Test
-    public void testParse1() throws ParseException {
-        String strCrontab = "* * 0/1 * * ? *";
-        strCrontab = "0/50 0/59 * * * ? *";
-        strCrontab = "3/5 * 0/5 * * ? *";
-        strCrontab = "1/5 3/5 1/5 3/30 * ? *";
-        Cron depCron = CronUtils.parse2Cron(strCrontab);
-        logger.info(depCron.validate().asString());
-    }
-
-    @Test
-    public void scheduleTypeTest() throws ParseException {
+    public void testScheduleType() throws ParseException {
 
         CycleEnum cycleEnum = CronUtils.getMaxCycle("0 */1 * * * ? *");
         Assert.assertEquals(cycleEnum.name(), "MINUTE");
@@ -91,6 +95,9 @@ public class CronUtilsTest {
         Assert.assertEquals(cycleEnum2.name(), "MINUTE");
     }
 
+    /**
+     * test
+     */
     @Test
     public void test2(){
         Cron cron1 = CronBuilder.cron(CronDefinitionBuilder.instanceDefinitionFor(CronType.QUARTZ))
@@ -172,8 +179,5 @@ public class CronUtilsTest {
                 logger.info("can't get scheduleType");
             }
         }
-
-
-
     }
 }

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/AccessTokenMapperTest.java

@@ -39,6 +39,10 @@ public class AccessTokenMapperTest {
     AccessTokenMapper accessTokenMapper;
 
 
+    /**
+     * insert
+     * @return AccessToken
+     */
     private AccessToken insertOne(){
         //insertOne
         AccessToken accessToken = new AccessToken();
@@ -51,6 +55,9 @@ public class AccessTokenMapperTest {
         return accessToken;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -62,6 +69,9 @@ public class AccessTokenMapperTest {
         Assert.assertEquals(update, 1);
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -70,6 +80,9 @@ public class AccessTokenMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery(){
 
@@ -80,8 +93,11 @@ public class AccessTokenMapperTest {
         accessTokenMapper.deleteById(accessToken.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
-    public void selectAccessTokenPage() {
+    public void testSelectAccessTokenPage() {
         AccessToken accessToken = insertOne();
         Page page = new Page(1, 3);
         String userName = "";

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/AlertGroupMapperTest.java

@@ -43,6 +43,10 @@ public class AlertGroupMapperTest {
     @Autowired
     UserAlertGroupMapper userAlertGroupMapper;
 
+    /**
+     * insert
+     * @return AlertGroup
+     */
     private AlertGroup insertOne(){
         //insertOne
         AlertGroup alertGroup = new AlertGroup();
@@ -56,6 +60,9 @@ public class AlertGroupMapperTest {
         return alertGroup;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -67,6 +74,9 @@ public class AlertGroupMapperTest {
         alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -75,6 +85,9 @@ public class AlertGroupMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         AlertGroup alertGroup = insertOne();
@@ -85,7 +98,10 @@ public class AlertGroupMapperTest {
     }
 
 
-        @Test
+    /**
+     * test page
+     */
+    @Test
     public void testQueryAlertGroupPage() {
             AlertGroup alertGroup = insertOne();
             Page page = new Page(1, 3);
@@ -95,6 +111,9 @@ public class AlertGroupMapperTest {
             alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test query by groupname
+     */
     @Test
     public void testQueryByGroupName() {
 
@@ -104,6 +123,9 @@ public class AlertGroupMapperTest {
         alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test query by userId
+     */
     @Test
     public void testQueryByUserId() {
         AlertGroup alertGroup = insertOne();
@@ -117,6 +139,9 @@ public class AlertGroupMapperTest {
         userAlertGroupMapper.deleteById(userAlertGroup.getId());
     }
 
+    /**
+     * test query by alert type
+     */
     @Test
     public void testQueryByAlertType() {
         AlertGroup alertGroup = insertOne();
@@ -125,6 +150,9 @@ public class AlertGroupMapperTest {
         alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test query all group list
+     */
     @Test
     public void testQueryAllGroupList() {
         AlertGroup alertGroup = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/AlertMapperTest.java

@@ -39,6 +39,10 @@ public class AlertMapperTest {
     @Autowired
     AlertMapper alertMapper;
 
+    /**
+     * insert
+     * @return Alert
+     */
     private Alert insertOne(){
         //insertOne
         Alert alert = new Alert();
@@ -55,6 +59,9 @@ public class AlertMapperTest {
         return alert;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -66,6 +73,9 @@ public class AlertMapperTest {
         alertMapper.deleteById(alert.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -74,6 +84,9 @@ public class AlertMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Alert alert = insertOne();
@@ -83,6 +96,9 @@ public class AlertMapperTest {
         alertMapper.deleteById(alert.getId());
     }
 
+    /**
+     * test list alert by status
+     */
     @Test
     public void testListAlertByStatus() {
         Alert alert = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java

@@ -41,6 +41,10 @@ public class CommandMapperTest {
     @Autowired
     ProcessDefinitionMapper processDefinitionMapper;
 
+    /**
+     * insert
+     * @return Command
+     */
     private Command insertOne(){
         //insertOne
         Command command = new Command();
@@ -56,6 +60,9 @@ public class CommandMapperTest {
         return command;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -67,6 +74,9 @@ public class CommandMapperTest {
         commandMapper.deleteById(command.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -75,6 +85,9 @@ public class CommandMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Command command = insertOne();
@@ -83,6 +96,10 @@ public class CommandMapperTest {
         Assert.assertNotEquals(commands.size(), 0);
         commandMapper.deleteById(command.getId());
     }
+
+    /**
+     * test query all
+     */
     @Test
     public void testGetAll() {
         Command command = insertOne();
@@ -91,6 +108,9 @@ public class CommandMapperTest {
         commandMapper.deleteById(command.getId());
     }
 
+    /**
+     * test get on command to run
+     */
     @Test
     public void testGetOneToRun() {
         ProcessDefinition processDefinition = new ProcessDefinition();
@@ -117,6 +137,9 @@ public class CommandMapperTest {
         processDefinitionMapper.deleteById(processDefinition.getId());
     }
 
+    /**
+     * test count command state
+     */
     @Test
     public void testCountCommandState() {
         Command command = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ConnectionFactoryTest.java

@@ -25,6 +25,10 @@ import java.sql.Connection;
 
 public class ConnectionFactoryTest {
 
+    /**
+     * test connection
+     * @throws Exception if error throws Exception
+     */
     @Test
     public void testConnection()throws Exception{
         Connection connection = ConnectionFactory.getDataSource().getPooledConnection().getConnection();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/DataSourceMapperTest.java

@@ -42,6 +42,10 @@ public class DataSourceMapperTest {
     @Autowired
     DataSourceUserMapper dataSourceUserMapper;
 
+    /**
+     * insert
+     * @return DataSource
+     */
     private DataSource insertOne(){
         //insertOne
         DataSource dataSource = new DataSource();
@@ -56,6 +60,9 @@ public class DataSourceMapperTest {
         return dataSource;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -67,6 +74,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -75,6 +85,9 @@ public class DataSourceMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         DataSource dataSource = insertOne();
@@ -84,6 +97,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test query datasource by type
+     */
     @Test
     public void testQueryDataSourceByType() {
         DataSource dataSource = insertOne();
@@ -95,6 +111,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testSelectPaging() {
         DataSource dataSource = insertOne();
@@ -105,6 +124,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test query datasource by name
+     */
     @Test
     public void testQueryDataSourceByName() {
         DataSource dataSource = insertOne();
@@ -113,6 +135,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test query authed datasource
+     */
     @Test
     public void testQueryAuthedDatasource() {
 
@@ -128,6 +153,9 @@ public class DataSourceMapperTest {
         dataSourceUserMapper.deleteById(datasourceUser.getId());
     }
 
+    /**
+     * test query datasource except userId
+     */
     @Test
     public void testQueryDatasourceExceptUserId() {
         DataSource dataSource = insertOne();
@@ -136,6 +164,9 @@ public class DataSourceMapperTest {
         dataSourceMapper.deleteById(dataSource.getId());
     }
 
+    /**
+     * test list all datasource by type
+     */
     @Test
     public void testListAllDataSourceByType() {
 

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/DataSourceUserMapperTest.java

@@ -36,6 +36,10 @@ public class DataSourceUserMapperTest {
     DataSourceUserMapper dataSourceUserMapper;
 
 
+    /**
+     * insert
+     * @return DatasourceUser
+     */
     private DatasourceUser insertOne(){
         //insertOne
         DatasourceUser dataSourceUser = new DatasourceUser();
@@ -48,6 +52,9 @@ public class DataSourceUserMapperTest {
         return dataSourceUser;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -59,6 +66,9 @@ public class DataSourceUserMapperTest {
         dataSourceUserMapper.deleteById(dataSourceUser.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -67,6 +77,9 @@ public class DataSourceUserMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         DatasourceUser dataSourceUser = insertOne();
@@ -76,6 +89,9 @@ public class DataSourceUserMapperTest {
         dataSourceUserMapper.deleteById(dataSourceUser.getId());
     }
 
+    /**
+     * test delete by userId
+     */
     @Test
     public void testDeleteByUserId() {
         DatasourceUser dataSourceUser = insertOne();
@@ -83,6 +99,9 @@ public class DataSourceUserMapperTest {
         Assert.assertNotEquals(delete, 0);
     }
 
+    /**
+     * test delete by datasource id
+     */
     @Test
     public void testDeleteByDatasourceId() {
         DatasourceUser dataSourceUser = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ErrorCommandMapperTest.java

@@ -42,6 +42,10 @@ public class ErrorCommandMapperTest {
     ProcessDefinitionMapper processDefinitionMapper;
 
 
+    /**
+     * insert
+     * @return ErrorCommand
+     */
     private ErrorCommand insertOne(){
         //insertOne
         ErrorCommand errorCommand = new ErrorCommand();
@@ -53,6 +57,9 @@ public class ErrorCommandMapperTest {
         return errorCommand;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -64,6 +71,9 @@ public class ErrorCommandMapperTest {
         errorCommandMapper.deleteById(errorCommand.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
 
@@ -72,6 +82,9 @@ public class ErrorCommandMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ErrorCommand errorCommand = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ProcessDefinitionMapperTest.java

@@ -51,6 +51,10 @@ public class ProcessDefinitionMapperTest {
     @Autowired
     ProjectMapper projectMapper;
 
+    /**
+     * insert
+     * @return ProcessDefinition
+     */
     private ProcessDefinition insertOne(){
         //insertOne
         ProcessDefinition processDefinition = new ProcessDefinition();
@@ -63,6 +67,9 @@ public class ProcessDefinitionMapperTest {
         return processDefinition;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -74,6 +81,9 @@ public class ProcessDefinitionMapperTest {
         processDefinitionMapper.deleteById(processDefinition.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         ProcessDefinition processDefinition = insertOne();
@@ -81,6 +91,9 @@ public class ProcessDefinitionMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ProcessDefinition processDefinition = insertOne();
@@ -90,6 +103,9 @@ public class ProcessDefinitionMapperTest {
         processDefinitionMapper.deleteById(processDefinition.getId());
     }
 
+    /**
+     * test query by definition name
+     */
     @Test
     public void testQueryByDefineName() {
         Project project = new Project();
@@ -134,6 +150,9 @@ public class ProcessDefinitionMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryDefineListPaging() {
         ProcessDefinition processDefinition = insertOne();
@@ -143,6 +162,9 @@ public class ProcessDefinitionMapperTest {
         processDefinitionMapper.deleteById(processDefinition.getId());
     }
 
+    /**
+     * test query all process definition
+     */
     @Test
     public void testQueryAllDefinitionList() {
         ProcessDefinition processDefinition = insertOne();
@@ -151,6 +173,9 @@ public class ProcessDefinitionMapperTest {
         processDefinitionMapper.deleteById(processDefinition.getId());
     }
 
+    /**
+     * test query process definition by ids
+     */
     @Test
     public void testQueryDefinitionListByIdList() {
 
@@ -168,6 +193,9 @@ public class ProcessDefinitionMapperTest {
 
     }
 
+    /**
+     * test count process definition group by user
+     */
     @Test
     public void testCountDefinitionGroupByUser() {
 

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ProcessInstanceMapMapperTest.java

@@ -36,6 +36,10 @@ public class ProcessInstanceMapMapperTest {
     ProcessInstanceMapMapper processInstanceMapMapper;
 
 
+    /**
+     * insert
+     * @return ProcessInstanceMap
+     */
     private ProcessInstanceMap insertOne(){
         //insertOne
         ProcessInstanceMap processInstanceMap = new ProcessInstanceMap();
@@ -46,6 +50,9 @@ public class ProcessInstanceMapMapperTest {
         return processInstanceMap;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -57,6 +64,9 @@ public class ProcessInstanceMapMapperTest {
         processInstanceMapMapper.deleteById(processInstanceMap.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         ProcessInstanceMap processInstanceMap = insertOne();
@@ -64,6 +74,9 @@ public class ProcessInstanceMapMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ProcessInstanceMap processInstanceMap = insertOne();
@@ -73,6 +86,9 @@ public class ProcessInstanceMapMapperTest {
         processInstanceMapMapper.deleteById(processInstanceMap.getId());
     }
 
+    /**
+     * test query by process instance parentId
+     */
     @Test
     public void testQueryByParentId() {
         ProcessInstanceMap processInstanceMap = insertOne();
@@ -87,6 +103,9 @@ public class ProcessInstanceMapMapperTest {
         processInstanceMapMapper.deleteById(processInstanceMap.getId());
     }
 
+    /**
+     * test query by sub process instance id
+     */
     @Test
     public void testQueryBySubProcessId() {
         ProcessInstanceMap processInstanceMap = insertOne();
@@ -101,6 +120,9 @@ public class ProcessInstanceMapMapperTest {
         processInstanceMapMapper.deleteById(processInstanceMap.getId());
     }
 
+    /**
+     * test delete by parent process instance id
+     */
     @Test
     public void testDeleteByParentProcessId() {
         ProcessInstanceMap processInstanceMap = insertOne();
@@ -113,6 +135,9 @@ public class ProcessInstanceMapMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query sub ids by process instance parentId
+     */
     @Test
     public void querySubIdListByParentId() {
         ProcessInstanceMap processInstanceMap = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ProcessInstanceMapperTest.java

@@ -48,6 +48,10 @@ public class ProcessInstanceMapperTest {
     ProjectMapper projectMapper;
 
 
+    /**
+     * insert
+     * @return ProcessInstance
+     */
     private ProcessInstance insertOne(){
         //insertOne
         ProcessInstance processInstance = new ProcessInstance();
@@ -61,6 +65,9 @@ public class ProcessInstanceMapperTest {
         return processInstance;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -71,6 +78,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstanceMap.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         ProcessInstance processInstanceMap = insertOne();
@@ -78,6 +88,9 @@ public class ProcessInstanceMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ProcessInstance processInstance = insertOne();
@@ -87,6 +100,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test query detail by id
+     */
     @Test
     public void testQueryDetailById() {
         ProcessInstance processInstance = insertOne();
@@ -97,8 +113,11 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test query by host and states
+     */
     @Test
-    public void testQueryByHostAndStatus() {
+    public void testQueryByHostAndStates() {
         ProcessInstance processInstance = insertOne();
         processInstance.setHost("192.168.2.155");
         processInstance.setState(ExecutionStatus.RUNNING_EXEUTION);
@@ -114,6 +133,9 @@ public class ProcessInstanceMapperTest {
         Assert.assertNotEquals(processInstances.size(), 0);
     }
 
+    /**
+     * test query process instance page
+     */
     @Test
     public void testQueryProcessInstanceListPaging() {
 
@@ -154,6 +176,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test set failover by host and state
+     */
     @Test
     public void testSetFailoverByHostAndStateArray() {
 
@@ -175,6 +200,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test update process instance by state
+     */
     @Test
     public void testUpdateProcessInstanceByState() {
 
@@ -192,6 +220,9 @@ public class ProcessInstanceMapperTest {
 
     }
 
+    /**
+     * test count process instance state by user
+     */
     @Test
     public void testCountInstanceStateByUser() {
 
@@ -219,6 +250,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test query process instance by process definition id
+     */
     @Test
     public void testQueryByProcessDefineId() {
         ProcessInstance processInstance = insertOne();
@@ -235,6 +269,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance1.getId());
     }
 
+    /**
+     * test query last schedule process instance
+     */
     @Test
     public void testQueryLastSchedulerProcess() {
         ProcessInstance processInstance = insertOne();
@@ -246,6 +283,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test query last running process instance
+     */
     @Test
     public void testQueryLastRunningProcess() {
         ProcessInstance processInstance = insertOne();
@@ -262,6 +302,9 @@ public class ProcessInstanceMapperTest {
         processInstanceMapper.deleteById(processInstance.getId());
     }
 
+    /**
+     * test query last manual process instance
+     */
     @Test
     public void testQueryLastManualProcess() {
         ProcessInstance processInstance = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ProjectMapperTest.java

@@ -42,6 +42,10 @@ public class ProjectMapperTest {
     UserMapper userMapper;
 
 
+    /**
+     * insert
+     * @return Project
+     */
     private Project insertOne(){
         //insertOne
         Project project = new Project();
@@ -51,6 +55,9 @@ public class ProjectMapperTest {
         return project;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -62,6 +69,9 @@ public class ProjectMapperTest {
         projectMapper.deleteById(project.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Project projectMap = insertOne();
@@ -69,6 +79,9 @@ public class ProjectMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Project project = insertOne();
@@ -78,6 +91,9 @@ public class ProjectMapperTest {
         projectMapper.deleteById(project.getId());
     }
 
+    /**
+     * test query detail by id
+     */
     @Test
     public void testQueryDetailById() {
 
@@ -96,6 +112,9 @@ public class ProjectMapperTest {
         Assert.assertEquals(project1.getUserName(), user.getUserName());
     }
 
+    /**
+     * test query project by name
+     */
     @Test
     public void testQueryProjectByName() {
         User user = new User();
@@ -113,6 +132,9 @@ public class ProjectMapperTest {
         Assert.assertEquals(project1.getUserName(), user.getUserName());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryProjectListPaging() {
         Project project = insertOne();
@@ -142,6 +164,9 @@ public class ProjectMapperTest {
         Assert.assertNotEquals(projectIPage1.getTotal(), 0);
     }
 
+    /**
+     * test query project create user
+     */
     @Test
     public void testQueryProjectCreatedByUser() {
         Project project = insertOne();
@@ -153,6 +178,9 @@ public class ProjectMapperTest {
 
     }
 
+    /**
+     * test query authed prject list by userId
+     */
     @Test
     public void testQueryAuthedProjectListByUserId() {
         Project project = insertOne();
@@ -163,6 +191,9 @@ public class ProjectMapperTest {
         Assert.assertNotEquals(projects.size(), 0);
     }
 
+    /**
+     * test query project expect userId
+     */
     @Test
     public void testQueryProjectExceptUserId() {
         Project project = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ProjectUserMapperTest.java

@@ -38,6 +38,10 @@ public class ProjectUserMapperTest {
     @Autowired
     ProjectUserMapper projectUserMapper;
 
+    /**
+     * insert
+     * @return ProjectUser
+     */
     private ProjectUser insertOne(){
         //insertOne
         ProjectUser projectUser = new ProjectUser();
@@ -47,6 +51,9 @@ public class ProjectUserMapperTest {
         return projectUser;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -58,6 +65,9 @@ public class ProjectUserMapperTest {
         projectUserMapper.deleteById(projectUser.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         ProjectUser projectUserMap = insertOne();
@@ -65,6 +75,9 @@ public class ProjectUserMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ProjectUser projectUser = insertOne();
@@ -74,6 +87,9 @@ public class ProjectUserMapperTest {
         projectUserMapper.deleteById(projectUser.getId());
     }
 
+    /**
+     * test delete project relation
+     */
     @Test
     public void testDeleteProjectRelation() {
 
@@ -84,6 +100,9 @@ public class ProjectUserMapperTest {
 
     }
 
+    /**
+     * test query project relation
+     */
     @Test
     public void testQueryProjectRelation() {
         ProjectUser projectUser = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/QueueMapperTest.java

@@ -40,6 +40,10 @@ public class QueueMapperTest {
     QueueMapper queueMapper;
 
 
+    /**
+     * insert
+     * @return Queue
+     */
     private Queue insertOne(){
         //insertOne
         Queue queue = new Queue();
@@ -51,6 +55,9 @@ public class QueueMapperTest {
         return queue;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -62,6 +69,9 @@ public class QueueMapperTest {
         queueMapper.deleteById(queue.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Queue queue = insertOne();
@@ -69,6 +79,9 @@ public class QueueMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Queue queue = insertOne();
@@ -76,8 +89,11 @@ public class QueueMapperTest {
         List<Queue> queues = queueMapper.selectList(null);
         Assert.assertNotEquals(queues.size(), 0);
         queueMapper.deleteById(queue.getId());
-    } 
-    
+    }
+
+    /**
+     * test page
+     */
     @Test
     public void testQueryQueuePaging() {
 
@@ -94,6 +110,9 @@ public class QueueMapperTest {
         queueMapper.deleteById(queue.getId());
     }
 
+    /**
+     * test query all list
+     */
     @Test
     public void queryAllQueueList() {
         Queue queue = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ResourceMapperTest.java

@@ -47,6 +47,10 @@ public class ResourceMapperTest {
     @Autowired
     UserMapper userMapper;
 
+    /**
+     * insert
+     * @return Resource
+     */
     private Resource insertOne(){
         //insertOne
         Resource resource = new Resource();
@@ -57,6 +61,9 @@ public class ResourceMapperTest {
         return resource;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -68,6 +75,9 @@ public class ResourceMapperTest {
         resourceMapper.deleteById(resource.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Resource resourceMap = insertOne();
@@ -75,6 +85,9 @@ public class ResourceMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Resource resource = insertOne();
@@ -84,6 +97,9 @@ public class ResourceMapperTest {
         resourceMapper.deleteById(resource.getId());
     }
 
+    /**
+     * test query resource list
+     */
     @Test
     public void testQueryResourceList() {
 
@@ -102,6 +118,9 @@ public class ResourceMapperTest {
         resourceMapper.deleteById(resource.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryResourcePaging() {
         Resource resource = insertOne();
@@ -131,6 +150,9 @@ public class ResourceMapperTest {
 
     }
 
+    /**
+     * test authed resource list
+     */
     @Test
     public void testQueryResourceListAuthored() {
         Resource resource = insertOne();
@@ -152,6 +174,9 @@ public class ResourceMapperTest {
 
     }
 
+    /**
+     * test authed resource list
+     */
     @Test
     public void testQueryAuthorizedResourceList() {
         Resource resource = insertOne();
@@ -162,6 +187,9 @@ public class ResourceMapperTest {
         Assert.assertEquals(resources.size(), 0);
     }
 
+    /**
+     * test query resource expect userId
+     */
     @Test
     public void testQueryResourceExceptUserId() {
         Resource resource = insertOne();
@@ -172,6 +200,9 @@ public class ResourceMapperTest {
         resourceMapper.deleteById(resource.getId());
     }
 
+    /**
+     * test query tenant code by resource name
+     */
     @Test
     public void testQueryTenantCodeByResourceName() {
 

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ResourceUserMapperTest.java

@@ -37,6 +37,10 @@ public class ResourceUserMapperTest {
     @Autowired
     ResourceUserMapper resourceUserMapper;
 
+    /**
+     * insert
+     * @return ResourcesUser
+     */
     private ResourcesUser insertOne(){
         //insertOne
         ResourcesUser queue = new ResourcesUser();
@@ -48,6 +52,9 @@ public class ResourceUserMapperTest {
         return queue;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -59,6 +66,9 @@ public class ResourceUserMapperTest {
         resourceUserMapper.deleteById(queue.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         ResourcesUser queue = insertOne();
@@ -66,6 +76,9 @@ public class ResourceUserMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         ResourcesUser queue = insertOne();
@@ -75,6 +88,9 @@ public class ResourceUserMapperTest {
         resourceUserMapper.deleteById(queue.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDeleteResourceUser() {
 

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/ScheduleMapperTest.java

@@ -53,6 +53,10 @@ public class ScheduleMapperTest {
     @Autowired
     ProcessDefinitionMapper processDefinitionMapper;
 
+    /**
+     * insert
+     * @return Schedule
+     */
     private Schedule insertOne(){
         //insertOne
         Schedule schedule = new Schedule();
@@ -68,6 +72,9 @@ public class ScheduleMapperTest {
         return schedule;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -79,6 +86,9 @@ public class ScheduleMapperTest {
         scheduleMapper.deleteById(schedule.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Schedule schedule = insertOne();
@@ -86,6 +96,9 @@ public class ScheduleMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Schedule schedule = insertOne();
@@ -95,6 +108,9 @@ public class ScheduleMapperTest {
         scheduleMapper.deleteById(schedule.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryByProcessDefineIdPaging() {
 
@@ -131,6 +147,9 @@ public class ScheduleMapperTest {
         scheduleMapper.deleteById(schedule.getId());
     }
 
+    /**
+     * test query schedule list by project name
+     */
     @Test
     public void testQuerySchedulerListByProjectName() {
 
@@ -167,6 +186,9 @@ public class ScheduleMapperTest {
         Assert.assertNotEquals(schedules.size(), 0);
     }
 
+    /**
+     * test query by process definition ids
+     */
     @Test
     public void testSelectAllByProcessDefineArray() {
 
@@ -180,6 +202,9 @@ public class ScheduleMapperTest {
         Assert.assertNotEquals(schedules.size(), 0);
     }
 
+    /**
+     * test query by process definition id
+     */
     @Test
     public void queryByProcessDefinitionId() {
         Schedule schedule = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/SessionMapperTest.java

@@ -35,6 +35,10 @@ public class SessionMapperTest {
     @Autowired
     SessionMapper sessionMapper;
 
+    /**
+     * insert
+     * @return Session
+     */
     private Session insertOne(){
         //insertOne
         Session session = new Session();
@@ -44,6 +48,9 @@ public class SessionMapperTest {
         return session;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -55,6 +62,9 @@ public class SessionMapperTest {
         sessionMapper.deleteById(session.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Session session = insertOne();
@@ -62,6 +72,9 @@ public class SessionMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Session session = insertOne();
@@ -71,6 +84,9 @@ public class SessionMapperTest {
         sessionMapper.deleteById(session.getId());
     }
 
+    /**
+     * test query by userId
+     */
     @Test
     public void testQueryByUserId() {
         Session session = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/TaskInstanceMapperTest.java

@@ -51,6 +51,10 @@ public class TaskInstanceMapperTest {
     @Autowired
     ProcessInstanceMapper processInstanceMapper;
 
+    /**
+     * insert
+     * @return TaskInstance
+     */
     private TaskInstance insertOne(){
         //insertOne
         TaskInstance taskInstance = new TaskInstance();
@@ -65,6 +69,9 @@ public class TaskInstanceMapperTest {
         return taskInstance;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -75,6 +82,9 @@ public class TaskInstanceMapperTest {
         taskInstanceMapper.deleteById(taskInstance.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         TaskInstance taskInstance = insertOne();
@@ -82,6 +92,9 @@ public class TaskInstanceMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         TaskInstance taskInstance = insertOne();
@@ -91,6 +104,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(taskInstances.size(), 0);
     }
 
+    /**
+     * test query task instance by process instance id and state
+     */
     @Test
     public void testQueryTaskByProcessIdAndState() {
         TaskInstance task = insertOne();
@@ -104,6 +120,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(taskInstances.size(), 0);
     }
 
+    /**
+     * test find vaild task list by process instance id
+     */
     @Test
     public void testFindValidTaskListByProcessId() {
         TaskInstance task = insertOne();
@@ -129,6 +148,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(taskInstances1.size(), 0 );
     }
 
+    /**
+     * test query by host and status
+     */
     @Test
     public void testQueryByHostAndStatus() {
         TaskInstance task = insertOne();
@@ -142,6 +164,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(taskInstances.size(), 0);
     }
 
+    /**
+     * test set failover by host and state array
+     */
     @Test
     public void testSetFailoverByHostAndStateArray() {
         TaskInstance task = insertOne();
@@ -157,6 +182,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(setResult, 0);
     }
 
+    /**
+     * test query by task instance id and name
+     */
     @Test
     public void testQueryByInstanceIdAndName() {
         TaskInstance task = insertOne();
@@ -171,6 +199,9 @@ public class TaskInstanceMapperTest {
         Assert.assertNotEquals(taskInstance, null);
     }
 
+    /**
+     * test count task instance
+     */
     @Test
     public void testCountTask() {
         TaskInstance task = insertOne();
@@ -197,6 +228,9 @@ public class TaskInstanceMapperTest {
 
     }
 
+    /**
+     * test count task instance state by user
+     */
     @Test
     public void testCountTaskInstanceStateByUser() {
 
@@ -217,6 +251,9 @@ public class TaskInstanceMapperTest {
         taskInstanceMapper.deleteById(task.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryTaskInstanceListPaging() {
         TaskInstance task = insertOne();

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/TenantMapperTest.java

@@ -41,6 +41,10 @@ public class TenantMapperTest {
     @Autowired
     QueueMapper queueMapper;
 
+    /**
+     * insert
+     * @return Tenant
+     */
     private Tenant insertOne(){
         //insertOne
         Tenant tenant = new Tenant();
@@ -50,6 +54,9 @@ public class TenantMapperTest {
         return tenant;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -61,6 +68,9 @@ public class TenantMapperTest {
         tenantMapper.deleteById(tenant.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         Tenant tenant = insertOne();
@@ -68,6 +78,9 @@ public class TenantMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         Tenant tenant = insertOne();
@@ -77,6 +90,9 @@ public class TenantMapperTest {
         tenantMapper.deleteById(tenant.getId());
     }
 
+    /**
+     * test query by id
+     */
     @Test
     public void testQueryById() {
 
@@ -96,19 +112,21 @@ public class TenantMapperTest {
         Assert.assertNotEquals(tenant1, null);
     }
 
+    /**
+     * test query tenant by tenant code
+     */
     @Test
     public void testQueryByTenantCode() {
 
         Tenant tenant = insertOne();
         tenant.setTenantCode("ut code");
         tenantMapper.updateById(tenant);
-
-//        List<Tenant> tenant1 = tenantMapper.queryByTenantCode(tenant.getTenantCode());
-
         tenantMapper.deleteById(tenant.getId());
-//        Assert.assertNotEquals(tenant1.size(), 0);
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryTenantPaging() {
 

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/UDFUserMapperTest.java

@@ -45,6 +45,10 @@ public class UDFUserMapperTest {
     @Autowired
     UdfFuncMapper udfFuncMapper;
 
+    /**
+     * insert
+     * @return UDFUser
+     */
     private UDFUser insertOne(){
         UDFUser udfUser = new UDFUser();
         udfUser.setUdfId(1);
@@ -55,6 +59,12 @@ public class UDFUserMapperTest {
         return udfUser;
     }
 
+    /**
+     * insert UDFUser
+     * @param user user
+     * @param udfFunc  udfFunc
+     * @return UDFUser
+     */
     private UDFUser insertOne(User user,UdfFunc udfFunc){
         UDFUser udfUser = new UDFUser();
         udfUser.setUdfId(udfFunc.getId());
@@ -68,7 +78,7 @@ public class UDFUserMapperTest {
 
     /**
      * insert one user
-     * @return
+     * @return User
      */
     private User insertOneUser(){
         User user = new User();
@@ -86,7 +96,7 @@ public class UDFUserMapperTest {
 
     /**
      * insert one udf
-     * @return
+     * @return UdfFunc
      */
     private UdfFunc insertOneUdfFunc(){
         UdfFunc udfFunc = new UdfFunc();
@@ -101,6 +111,9 @@ public class UDFUserMapperTest {
         return udfFunc;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOneUser
@@ -119,6 +132,9 @@ public class UDFUserMapperTest {
 
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         //insertOneUser
@@ -133,6 +149,9 @@ public class UDFUserMapperTest {
         udfFuncMapper.deleteById(udfFunc.getId());
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery(){
         //insertOne
@@ -143,6 +162,9 @@ public class UDFUserMapperTest {
         userMapper.deleteById(udfUser.getId());
     }
 
+    /**
+     * test delete by userId
+     */
     @Test
     public void testDeleteByUserId() {
         //insertOneUser
@@ -158,6 +180,9 @@ public class UDFUserMapperTest {
 
     }
 
+    /**
+     * test delete by udffuncId
+     */
     @Test
     public void testDeleteByUdfFuncId() {
         //insertOneUser

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/UdfFuncMapperTest.java

@@ -49,7 +49,7 @@ public class UdfFuncMapperTest {
 
     /**
      * insert one udf
-     * @return
+     * @return UdfFunc
      */
     private UdfFunc insertOne(){
         UdfFunc udfFunc = new UdfFunc();
@@ -85,7 +85,7 @@ public class UdfFuncMapperTest {
 
     /**
      * insert one user
-     * @return
+     * @return User
      */
     private User insertOneUser(){
         User user = new User();
@@ -102,7 +102,7 @@ public class UdfFuncMapperTest {
 
     /**
      * insert one user
-     * @return
+     * @return User
      */
     private User insertOneUser(String userName){
         User user = new User();
@@ -117,6 +117,12 @@ public class UdfFuncMapperTest {
         return user;
     }
 
+    /**
+     * insert UDFUser
+     * @param user user
+     * @param udfFunc udf func
+     * @return UDFUser
+     */
     private UDFUser insertOneUDFUser(User user,UdfFunc udfFunc){
         UDFUser udfUser = new UDFUser();
         udfUser.setUdfId(udfFunc.getId());
@@ -127,6 +133,9 @@ public class UdfFuncMapperTest {
         return udfUser;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -142,6 +151,9 @@ public class UdfFuncMapperTest {
 
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         //insertOne
@@ -151,6 +163,9 @@ public class UdfFuncMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery(){
         //insertOne
@@ -161,6 +176,9 @@ public class UdfFuncMapperTest {
         udfFuncMapper.deleteById(udfFunc.getId());
     }
 
+    /**
+     * test query udf by ids
+     */
     @Test
     public void testQueryUdfByIdStr() {
         //insertOne
@@ -175,6 +193,9 @@ public class UdfFuncMapperTest {
         udfFuncMapper.deleteById(udfFunc1.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryUdfFuncPaging() {
         //insertOneUser
@@ -190,6 +211,9 @@ public class UdfFuncMapperTest {
 
     }
 
+    /**
+     * test get udffunc by type
+     */
     @Test
     public void testGetUdfFuncByType() {
         //insertOneUser
@@ -204,6 +228,9 @@ public class UdfFuncMapperTest {
 
     }
 
+    /**
+     * test query udffunc expect userId
+     */
     @Test
     public void testQueryUdfFuncExceptUserId() {
         //insertOneUser
@@ -221,6 +248,9 @@ public class UdfFuncMapperTest {
 
     }
 
+    /**
+     * test query authed udffunc
+     */
     @Test
     public void testQueryAuthedUdfFunc() {
         //insertOneUser

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/UserAlertGroupMapperTest.java

@@ -47,9 +47,9 @@ public class UserAlertGroupMapperTest {
 
     /**
      * insert one UserAlertGroup
-     * @param user
-     * @param alertGroup
-     * @return
+     * @param user user
+     * @param alertGroup alertGroup
+     * @return UserAlertGroup
      */
     private UserAlertGroup insertOne(User user,AlertGroup alertGroup){
         UserAlertGroup userAlertGroup = new UserAlertGroup();
@@ -64,7 +64,7 @@ public class UserAlertGroupMapperTest {
 
     /**
      * insert one UserAlertGroup
-     * @return
+     * @return UserAlertGroup
      */
     private UserAlertGroup insertOne(){
         UserAlertGroup userAlertGroup = new UserAlertGroup();
@@ -79,7 +79,7 @@ public class UserAlertGroupMapperTest {
 
     /**
      * insert one user
-     * @return
+     * @return User
      */
     private User insertOneUser(){
         User user = new User();
@@ -97,7 +97,7 @@ public class UserAlertGroupMapperTest {
 
     /**
      * insert one AlertGroup
-     * @return
+     * @return AlertGroup
      */
     private AlertGroup insertOneAlertGroup(){
         //insertOne
@@ -112,6 +112,9 @@ public class UserAlertGroupMapperTest {
         return alertGroup;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOneUser
@@ -133,6 +136,9 @@ public class UserAlertGroupMapperTest {
         alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         //insertOne
@@ -142,6 +148,9 @@ public class UserAlertGroupMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         //insertOne
@@ -152,6 +161,9 @@ public class UserAlertGroupMapperTest {
         userAlertGroupMapper.deleteById(userAlertGroup.getId());
     }
 
+    /**
+     * test delete by alertgroupId
+     */
     @Test
     public void testDeleteByAlertgroupId() {
         //insertOneUser
@@ -167,6 +179,9 @@ public class UserAlertGroupMapperTest {
         alertGroupMapper.deleteById(alertGroup.getId());
     }
 
+    /**
+     * test list user by alertgroupId
+     */
     @Test
     public void testListUserByAlertgroupId() {
         //insertOneUser

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/UserMapperTest.java

@@ -55,7 +55,7 @@ public class UserMapperTest {
 
     /**
      * insert one user
-     * @return
+     * @return User
      */
     private User insertOne(){
         User user = new User();
@@ -72,8 +72,8 @@ public class UserMapperTest {
 
     /**
      * insert one user
-     * @param tenant
-     * @return
+     * @param tenant tenant
+     * @return User
      */
     private User insertOne(Tenant tenant){
         User user = new User();
@@ -90,9 +90,9 @@ public class UserMapperTest {
 
     /**
      * insert one user
-     * @param queue
-     * @param tenant
-     * @return
+     * @param queue queue
+     * @param tenant tenant
+     * @return User
      */
     private User insertOne(Queue queue,Tenant tenant){
         User user = new User();
@@ -110,7 +110,7 @@ public class UserMapperTest {
 
     /**
      * insert one AlertGroup
-     * @return
+     * @return AlertGroup
      */
     private AlertGroup insertOneAlertGroup(){
         //insertOne
@@ -127,9 +127,9 @@ public class UserMapperTest {
 
     /**
      * insert one UserAlertGroup
-     * @param user
-     * @param alertGroup
-     * @return
+     * @param user user
+     * @param alertGroup alertGroup
+     * @return UserAlertGroup
      */
     private UserAlertGroup insertOneUserAlertGroup(User user,AlertGroup alertGroup){
         UserAlertGroup userAlertGroup = new UserAlertGroup();
@@ -144,8 +144,8 @@ public class UserMapperTest {
 
     /**
      * insert one AccessToken
-     * @param user
-     * @return
+     * @param user user
+     * @return AccessToken
      */
     private AccessToken insertOneAccessToken(User user){
         //insertOne
@@ -161,7 +161,7 @@ public class UserMapperTest {
 
     /**
      * insert one Tenant
-     * @return
+     * @return Tenant
      */
     private Tenant insertOneTenant(){
         Tenant tenant = new Tenant();
@@ -177,7 +177,7 @@ public class UserMapperTest {
 
     /**
      * insert one Queue
-     * @return
+     * @return Queue
      */
     private Queue insertOneQueue(){
         Queue queue = new Queue();
@@ -189,6 +189,9 @@ public class UserMapperTest {
         return queue;
     }
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -202,6 +205,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         //insertOne
@@ -212,6 +218,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         //insertOne
@@ -222,6 +231,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query all general user
+     */
     @Test
     public void testQueryAllGeneralUser() {
         //insertOne
@@ -232,6 +244,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query by username
+     */
     @Test
     public void testQueryByUserNameAccurately() {
         //insertOne
@@ -242,6 +257,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query by username and password
+     */
     @Test
     public void testQueryUserByNamePassword() {
         //insertOne
@@ -253,6 +271,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryUserPaging() {
         //insertOneQueue
@@ -270,6 +291,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query detail by id
+     */
     @Test
     public void testQueryDetailsById() {
         //insertOne
@@ -280,6 +304,9 @@ public class UserMapperTest {
         userMapper.deleteById(user.getId());
     }
 
+    /**
+     * test query user list by alertgroupId
+     */
     @Test
     public void testQueryUserListByAlertGroupId() {
         //insertOne
@@ -297,6 +324,9 @@ public class UserMapperTest {
 
     }
 
+    /**
+     * test query tenant code by userId
+     */
     @Test
     public void testQueryTenantCodeByUserId() {
         //insertOneTenant
@@ -310,6 +340,9 @@ public class UserMapperTest {
         tenantMapper.deleteById(tenant.getId());
     }
 
+    /**
+     * test query user by token
+     */
     @Test
     public void testQueryUserByToken() {
         //insertOne

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/WorkerGroupMapperTest.java

@@ -36,6 +36,10 @@ public class WorkerGroupMapperTest {
     @Autowired
     WorkerGroupMapper workerGroupMapper;
 
+    /**
+     * insert
+     * @return WorkerGroup
+     */
     private WorkerGroup insertOne(){
         //insertOne
         WorkerGroup workerGroup = new WorkerGroup();
@@ -50,6 +54,9 @@ public class WorkerGroupMapperTest {
     }
 
 
+    /**
+     * test update
+     */
     @Test
     public void testUpdate(){
         //insertOne
@@ -61,6 +68,9 @@ public class WorkerGroupMapperTest {
         Assert.assertEquals(update, 1);
     }
 
+    /**
+     * test delete
+     */
     @Test
     public void testDelete(){
         //insertOne
@@ -70,6 +80,9 @@ public class WorkerGroupMapperTest {
         Assert.assertEquals(delete, 1);
     }
 
+    /**
+     * test query
+     */
     @Test
     public void testQuery() {
         //insertOne
@@ -80,6 +93,9 @@ public class WorkerGroupMapperTest {
         workerGroupMapper.deleteById(workerGroup.getId());
     }
 
+    /**
+     * test query all worker group
+     */
     @Test
     public void testQueryAllWorkerGroup() {
         //insertOne
@@ -90,6 +106,9 @@ public class WorkerGroupMapperTest {
         workerGroupMapper.deleteById(workerGroup.getId());
     }
 
+    /**
+     * test query work group by name
+     */
     @Test
     public void testQueryWorkerGroupByName() {
         //insertOne
@@ -100,6 +119,9 @@ public class WorkerGroupMapperTest {
         workerGroupMapper.deleteById(workerGroup.getId());
     }
 
+    /**
+     * test page
+     */
     @Test
     public void testQueryListPaging() {
         //insertOne

dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/utils/DagHelperTest.java

@@ -33,13 +33,17 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+/**
+ * dag helper test
+ */
 public class DagHelperTest {
 
-
+    /**
+     * test task node can submit
+     * @throws JsonProcessingException if error throws JsonProcessingException
+     */
     @Test
     public void testTaskNodeCanSubmit() throws JsonProcessingException {
-
-
         //1->2->3->5
         //4->3
         DAG<String, TaskNode, TaskNodeRelation> dag = generateDag();
@@ -74,8 +78,8 @@ public class DagHelperTest {
     /**
      * 1->2->3->5
      * 4->3
-     * @return
-     * @throws JsonProcessingException
+     * @return dag
+     * @throws JsonProcessingException if error throws JsonProcessingException
      */
     private DAG<String, TaskNode, TaskNodeRelation> generateDag() throws JsonProcessingException {
         List<TaskNode> taskNodeList = new ArrayList<>();