Java初始化代码

初始化数据库实体

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.time.LocalDateTime;

/**
 * @author yangliwei
 */
@Getter
@Setter
@Table(name = "init_data_record")
@Entity
@ToString
public class InitDataRecord {
    /**
     * 主键ID
     */
    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * 业务唯一键
     */
    private String businessKey;

    /**
     * 初始化数据唯一Key，系统启动升级一次，第二次将不再升级
     */
    private String initDataKey;


    /**
     * 初始化数据时间
     */
    private LocalDateTime initDataTime;

}

初始化接口

public interface Initializer {

    /**
     * 初始化
     *
     * @param
     * @return void
     * @throws Exception
     */
    void init() throws Exception;

    /**
     * 执行顺序
     *
     * @return
     */
    default int getOrder() {
        return 0;
    }
}

初始化抽象类

@Slf4j
public abstract class AbstractDataUpgradeInitializer implements Initializer {

    private final InitDataRecordMapper initDataRecordMapper;

    protected AbstractDataUpgradeInitializer(InitDataRecordMapper initDataRecordMapper) {
        this.initDataRecordMapper = initDataRecordMapper;
    }


    /**
     * 初始化数据业务唯一标识
     *
     * @return 业务唯一标识
     */
    protected abstract String getBusinessKey();

    /**
     * 初始化数据唯一key
     *
     * @return 唯一key
     */
    protected abstract String getInitDataKey();

    /**
     * 业务处理
     */
    protected abstract void process();

    @Override
    public void init() {
        try {
            initDataUpdate();
        } catch (Exception e) {
            log.error("数据初始化异常", e);
        }
    }

    /**
     * 初始化数据升级
     */
    private void initDataUpdate() {

        InitDataRecord initDataRecord = new InitDataRecord();
        initDataRecord.setBusinessKey(getBusinessKey());
        initDataRecord.setInitDataKey(getInitDataKey());
        // 查询数据初始化记录
        InitDataRecord byBusinessKeyAndInitDataKey = initDataRecordMapper.queryInitDataRecord(initDataRecord);
        if (Objects.nonNull(byBusinessKeyAndInitDataKey)) {
            // 如有记录说明已经做过数据初始化
            return;
        }
        // 业务处理
        process();

        // 本次启动已升级，保存升级记录，下次服务启动将不再升级
        saveInitDataRecord();
    }

    /**
     * 保存数据升级记录
     */
    private void saveInitDataRecord() {
        InitDataRecord initDataRecord = new InitDataRecord();
        initDataRecord.setBusinessKey(getBusinessKey());
        initDataRecord.setInitDataKey(getInitDataKey());
        initDataRecordMapper.insertInitDataRecord(initDataRecord);
    }
}

初始化业务主体实现类

@Slf4j
@Component
public class UpgradeProject extends AbstractDataUpgradeInitializer {

    private PpmProjectMapper ppmProjectMapper;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public UpgradeProject(InitDataRecordMapper initDataRecordMappe,
                          PpmProjectMapper ppmProjectMapper) {
        super(initDataRecordMappe);
        this.ppmProjectMapper = ppmProjectMapper;
    }

    @Override
    protected String getBusinessKey() {
        return "UPGRADE_PROJECT";
    }

    @Override
    protected String getInitDataKey() {
        return Calendar.getInstance().getTimeInMillis()+"";
    }

    @Override
    protected void process() {
        //数据升级
        Long id = ppmProjectMapper.findIdByParentId(-1L);
        ppmProjectMapper.updatePpmProjectParentId(id);
        ppmProjectMapper.updatePpmProjectNodeType();
    }
}

初始化器的容器

@Component
@Slf4j
public class SystemInitialization implements ApplicationRunner {

    /**
     * 初始化器的容器
     */
    @Autowired
    Map<String, Initializer> initializerMap;


    @Override
    public void run(ApplicationArguments args) throws Exception {
        List<Map.Entry<String, Initializer>> list = new ArrayList<Map.Entry<String, Initializer>>(initializerMap.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Initializer>>() {
            @Override
            public int compare(Map.Entry<String, Initializer> o1, Map.Entry<String, Initializer> o2) {
                return o1.getValue().getOrder() - o2.getValue().getOrder();
            }
        });
        log.info("系统启动开始初始化！,共{}条", initializerMap.size());
        int num = 0;
        // 遍历各初始化器进行初始化
        for (Map.Entry<String, Initializer> entry : list) {
            log.info("系统启动项:{},开始初始化", entry.getValue().getClass());
            num++;
            log.info("当前执行的第{}条", num);
            entry.getValue().init();
            log.info("系统启动项:{},初始化结束", entry.getValue().getClass());
        }
    }
}