一、封装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.)");
}
}