springboot初始化

springboot初始化例子

/**
 * spring boot初始化
 * 
 * @author
 *
 */
@Component
@Order(1) // 通过order值的大小来决定启动的顺序
@Slf4j
public class InitSpringBoot implements CommandLineRunner {

	private SysBackupScheduledMapper sysBackupScheduledMapper = ManageSpringBeans
			.getBean(SysBackupScheduledMapper.class);

	private ScheduledMapper scheduledMapper = ManageSpringBeans.getBean(ScheduledMapper.class);

	private LdapMapper ldapMapper = ManageSpringBeans.getBean(LdapMapper.class);

	// 定时器工具类
	private ScheduleUtil scheduleUtil = ManageSpringBeans.getBean(ScheduleUtil.class);

	/**
	 * 系统备份定时器初始化
	 */
	private void sysBackupScheduledInit() {
		SysBackupScheduled sysBackupScheduledDb = sysBackupScheduledMapper.getSysBackupScheduled();
		Optional<SysBackupScheduled> sysBackupScheduledDbOpt = Optional.ofNullable(sysBackupScheduledDb);
		Boolean isOpen = sysBackupScheduledDbOpt.map(s -> s.getIsOpen()).orElse(false);
		if (isOpen) {// 如果定时器是打开状态，则进行初始化
			String cron = CommomUtils.timeTocron(sysBackupScheduledDb.getCron());
			if (StringUtils.isNotEmpty(cron)) {
				SysBackupScheduledTask task = new SysBackupScheduledTask("sysBackupScheduledTask");
				scheduleUtil.start(task, cron);
			}
		}
		log.info("系统备份定时器初始化成功");
	}

	/**
	 * 日志清理定时器初始化
	 */
	private void cleanLogScheduledInit() {
		List<Scheduled> scheduledListDb = scheduledMapper.selectLogScheduledList();
		if (CollectionUtils.isNotEmpty(scheduledListDb)) {
			Optional<Scheduled> scheduledOpt = Optional.ofNullable(scheduledListDb.get(0));
			Boolean isOpen = scheduledOpt.map(s -> s.getIsOpen()).orElse(false);
			if (isOpen) {
				String cron = scheduledOpt.map(s -> s.getCron()).orElse(StringUtils.EMPTY);
				cron = CommomUtils.timeTocron(cron);
				if (StringUtils.isEmpty(cron)) {
					cron = Constant.LOG_DEFAULT_CRON;
				}

				// 启动定时任务
				ScheduleTask task = new LogCleanTask("logCleanTask");
				scheduleUtil.start(task, cron);
			}

		}
		log.info("日志清理定时器初始化成功");
	}

	/**
	 * 同步ldap定时器任务初始化
	 */
	private void ldapScheduledInit() {
		Ldap ldapDb = ldapMapper.selectLdap();
		Optional<Ldap> LdapOpt = Optional.ofNullable(ldapDb);
		Boolean isOpen = LdapOpt.map(s -> s.getIsOpen()).orElse(false);
		if (isOpen) {// 如果定时器是打开状态，则进行初始化
			String cron = CommomUtils.frequencyTocron(ldapDb.getFrequency());
			if (StringUtils.isNotEmpty(cron)) {
				LdapScheduledTask task = new LdapScheduledTask("ldapScheduledTask");
				scheduleUtil.start(task, cron);
			}
		}
		log.info("同步ldap数据定时器任务初始化成功");
	}

	@Override
	public void run(String... args) throws Exception {
		// 系统备份定时器初始化
		sysBackupScheduledInit();
		// 日志清理定时器初始化
		cleanLogScheduledInit();
		// 同步ldap数据定时器任务初始化
		ldapScheduledInit();
	}

}

spring bean 管理类

import java.lang.annotation.Annotation;
import java.util.Map;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;

/**
 * springboot bean管理类
 * 
 * @author
 *
 */
@Service
public class ManageSpringBeans implements ApplicationContextAware {
	private static ApplicationContext context;

	public static <T> T getBean(final Class<T> requiredType) {
		return context.getBean(requiredType);
	}

	public static <T> T getBean(final String beanName) {
		@SuppressWarnings("unchecked")
		final T bean = (T) context.getBean(beanName);
		return bean;
	}

	public static <T> Map<String, T> getBeans(final Class<T> requiredType) {
		return context.getBeansOfType(requiredType);
	}

	public static Map<String, Object> getBeansWithAnnotation(final Class<? extends Annotation> annotationType) {
		return context.getBeansWithAnnotation(annotationType);
	}

	@Override
	public void setApplicationContext(final ApplicationContext applicationContext) {
		context = applicationContext;
	}
}