class AutoDDLProcessor implements InitializingBean {

    private Set<EntityInfo> entities = new HashSet<>();

    @Autowired
    private DatabaseOperator operator;

    @Autowired
    private EasyormProperties properties;

    @Autowired
    private EntityTableMetadataResolver resolver;

    @Autowired
    private EntityFactory entityFactory;

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    private boolean reactive;

    @Override
    @SneakyThrows
    public void afterPropertiesSet() {<FILL_FUNCTION_BODY>}
}


        List<Class<?>> readyToDDL = new ArrayList<>(this.entities.size());
        List<Class<?>> nonDDL = new ArrayList<>();

        for (EntityInfo entity : this.entities) {
            Class<?> type = entityFactory.getInstanceType(entity.getRealType(), true);
            DDL ddl = AnnotatedElementUtils.findMergedAnnotation(type, DDL.class);
            if (properties.isAutoDdl() && (ddl == null || ddl.value())) {
                readyToDDL.add(type);
            } else {
                nonDDL.add(type);
            }
        }

        if (!readyToDDL.isEmpty()) {
            //加载全部表信息
            if (reactive) {
                Flux.fromIterable(readyToDDL)
                    .doOnNext(type -> log.trace("auto ddl for {}", type))
                    .map(type -> {
                        RDBTableMetadata metadata = resolver.resolve(type);
                        EntityDDLEvent<?> event = new EntityDDLEvent<>(this, type, metadata);
                        eventPublisher.publishEvent(new GenericsPayloadApplicationEvent<>(this, event, type));
                        return metadata;
                    })
                    .flatMap(meta -> operator
                                     .ddl()
                                     .createOrAlter(meta)
                                     .autoLoad(false)
                                     .commit()
                                     .reactive()
                                     .subscribeOn(Schedulers.boundedElastic()),
                             8)
                    .doOnError((err) -> log.error(err.getMessage(), err))
                    .then()
                    .block(Duration.ofMinutes(5));
            } else {
                for (Class<?> type : readyToDDL) {
                    log.trace("auto ddl for {}", type);
                    try {
                        RDBTableMetadata metadata = resolver.resolve(type);
                        EntityDDLEvent<?> event = new EntityDDLEvent<>(this, type, metadata);
                        eventPublisher.publishEvent(new GenericsPayloadApplicationEvent<>(this, event, type));
                        operator.ddl()
                                .createOrAlter(metadata)
                                .autoLoad(false)
                                .commit()
                                .sync();
                    } catch (Exception e) {
                        log.error(e.getLocalizedMessage(), e);
                        throw e;
                    }
                }
            }
        }

        for (Class<?> entity : nonDDL) {
            RDBTableMetadata metadata = resolver.resolve(entity);
            operator
                    .getMetadata()
                    .getCurrentSchema()
                    .addTable(metadata);
        }
    
<no_super_class>