SpringBoot框架工具类封装

一、封装Application工具类.

import com.boot.skywalk.exception.GlobalException;
import org.springframework.context.ApplicationContext;

import java.util.Objects;

/**
 * ApplicationContext工具类
 */
public final class ApplicationContextUtil {
    /**
     * 获取ApplicationContext
     */
    private static ApplicationContext applicationContext;

    private ApplicationContextUtil(){
        throw new GlobalException("unsupport create instance!");
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static void setApplicationContext(ApplicationContext context) {
        applicationContext = context;
    }

    /**
     * 获取ApplicationContext
     *
     * @return ApplicationContext
     */
    public static ApplicationContext getInstance(){
        if(Objects.isNull(applicationContext)){
             new GlobalException("Spring FrameWork Init Failure");
        }
        return applicationContext;
    }
}

 SpringBoot启动后初始化

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SkywalkApplication.class, args);
        // 初始化ApplicationContext
        ApplicationContextUtil.setApplicationContext(context);
        System.out.println(ApplicationContextUtil.getInstance().getBeanDefinitionCount());
        String[] definitionNames = ApplicationContextUtil.getInstance().getBeanDefinitionNames();
        for(String bean:definitionNames){
            System.out.println(bean);
        }
    }

二、封装Bean的工具类.

import org.apache.commons.collections.MapUtils;
import org.springframework.context.ApplicationContext;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
 * Bean工具获取类,服务初始化以后使用.
 */
public final class CommonBeanUtils {
    private CommonBeanUtils(){
        throw new GlobalException("unsupport create instance");
    }
    /**
     * 获取ApplicationContext
     */
    private static final ApplicationContext context=ApplicationContextUtil.getInstance();
    /**
     * 获取指定类型的Bean
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static  <T> T getBean(Class<T> clazz){
        return context.getBean(clazz);
    }
    /**
     * 获取指定名称的Bean
     *
     * @param name
     * @return
     */
    public static Object getBean(String name) {
        return context.getBean(name);
    }
    /**
     * 获取指定类型Bean列表
     *
     * @param clazz clazz
     * @param <T>
     * @return List<T>
     */
    public static  <T> List<T> getBeanList(Class<T> clazz){
        Map<String, T> beans = context.getBeansOfType(clazz);
        if(MapUtils.isEmpty(beans)){
            return Collections.emptyList();
        }
        List<T> list = beans.values().stream().collect(Collectors.toList());
        return list;
    }
}

 运行获取Bean信息:

 三、Bean后置处理器监控Bean的初始化信息例如最耗时的Bean

package com.boot.skywalk.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * 通用的Bean的后置处理器统计最耗时的Bean
 */
@Component
public class CommonBeanPostProcessor implements BeanPostProcessor {
    /**
     * 初始化前的Map,Bean->时间点
     */
    private static final Map<String,Long> BEGIN_INIT_MAP=new ConcurrentHashMap<>();
    /**
     * 初始化后的Map,Bean->时间点
     */
    private static final Map<String,Long> INIT_COST_MAP=new ConcurrentHashMap<>();
    /**
     * 最耗时的Bean
     */
    private static final int TOP_COST_INIT_BEAN=3;

    /**
     * Bean初始化之前
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        BEGIN_INIT_MAP.putIfAbsent(beanName, System.currentTimeMillis());
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Long initPoint = BEGIN_INIT_MAP.get(beanName);
        INIT_COST_MAP.put(beanName, System.currentTimeMillis()-initPoint);
        return bean;
    }

    /**
     * 流式获取3,List返回Map.collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue())
      * @return
     */
    public Map<String,Long> getTopCostInitBean(){
        Map<String, Long> result = INIT_COST_MAP.entrySet()
                // 降序排列
                .stream().sorted((a,b)-> (int) (b.getValue()-a.getValue()))
                // 转换Map或者是List<Object[]>
                .limit(TOP_COST_INIT_BEAN).collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));
        return result;
    }

或者是List<Object[]>

    /**
     * 返回List<Object[]>来获取
     * @return
     */
    public List<Object[]> getTopCostInitBean(){
       List<Object[]> list= INIT_COST_MAP.entrySet()
                .stream().sorted((a,b)->(int)(b.getValue()-a.getValue()))
                .limit(TOP_COST_INIT_BEAN)
                .map(e->new Object[]{e.getKey(),e.getValue()}).collect(Collectors.toList());
       return list;
    }

        CommonBeanPostProcessor beanPostProcessor= context.getBean(CommonBeanPostProcessor.class);
        Map<String, Long> topCostInitBean = beanPostProcessor.getTopCostInitBean();
        topCostInitBean.forEach((key,value)->{
            System.out.println(key+":"+value+"ms");
        });

运行结果：

四、手动注册Bean.

1、通过注解注册Bean,然后IOC容器自动扫描，如

@Component和@Service等注解，即为JavaBean的注册方式,还有Xml注册Bean的方式.

2、通过ApplicationContext来注册Bean

ConfigurableApplicationContext context = SpringApplication.run(SkywalkApplication.class, args);

通过GenericApplicationContext手动注册,for循环批量注册Bean,手动调用refresh()方法.

// 手动注册Bean.
GenericApplicationContext genericApplicationContext = new GenericApplicationContext();
genericApplicationContext.registerBean("user1",User.class,()-> new User(1,"Tom","Admin"));
genericApplicationContext.refresh();
        System.out.println(genericApplicationContext.getBean("user1").getClass().getSimpleName());

3、通过@ComponentScan({"package1"},{"package2"})来批量注册Bean.

五、根据注入类型查找指定类型的Bean

 BeanFactoryAnnotationUtils

	@Nullable
	protected Executor findQualifiedExecutor(@Nullable BeanFactory beanFactory, String qualifier) {
		if (beanFactory == null) {
			throw new IllegalStateException("BeanFactory must be set on " + getClass().getSimpleName() +
					" to access qualified executor '" + qualifier + "'");
		}
		return BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, Executor.class, qualifier);
	}

	public static <T> T qualifiedBeanOfType(BeanFactory beanFactory, Class<T> beanType, String qualifier)
			throws BeansException {

		Assert.notNull(beanFactory, "BeanFactory must not be null");

		if (beanFactory instanceof ListableBeanFactory) {
			// Full qualifier matching supported.
			return qualifiedBeanOfType((ListableBeanFactory) beanFactory, beanType, qualifier);
		}
		else if (beanFactory.containsBean(qualifier)) {
			// Fallback: target bean at least found by bean name.
			return beanFactory.getBean(qualifier, beanType);
		}
		else {
			throw new NoSuchBeanDefinitionException(qualifier, "No matching " + beanType.getSimpleName() +
					" bean found for bean name '" + qualifier +
					"'! (Note: Qualifier matching not supported because given " +
					"BeanFactory does not implement ConfigurableListableBeanFactory.)");
		}
	}