下面列出了怎么用org.springframework.boot.autoconfigure.SpringBootApplication的API类实例代码及写法,或者点击链接到github查看源代码。
public static java.util.function.Supplier<ModuleTestExecution> of(Class<?> type) {
return () -> {
ModuleTest annotation = AnnotatedElementUtils.findMergedAnnotation(type, ModuleTest.class);
String packageName = type.getPackage().getName();
Class<?> modulithType = MODULITH_TYPES.computeIfAbsent(type,
it -> new AnnotatedClassFinder(SpringBootApplication.class).findFromPackage(packageName));
Modules modules = Modules.of(modulithType);
Module module = modules.getModuleForPackage(packageName) //
.orElseThrow(
() -> new IllegalStateException(String.format("Package %s is not part of any module!", packageName)));
return EXECUTIONS.computeIfAbsent(Key.of(module.getBasePackage().getName(), annotation),
it -> new ModuleTestExecution(annotation, modules, module));
};
}
/**
* 获取数据模型
*
* @param scheme
* @return
*/
public static Map<String, Object> getDataModel(SchemeDto scheme) {
Map<String, Object> model = Maps.newHashMap();
String applicationName = SpringContextHolder.getApplicationContext().getBeansWithAnnotation(SpringBootApplication.class).keySet().iterator().next();
model.put("applicationName", SpringContextHolder.getApplicationContext().getBean(applicationName).getClass().getPackage().getName() + StringUtil.DOT + StringUtil.upperFirst(applicationName));
model.put("packageName", StringUtil.lowerCase(scheme.getPackageName()));
model.put("lastPackageName", StringUtil.subAfter((String) model.get("packageName"), StringUtil.DOT, true));
model.put("moduleName", StringUtil.lowerCase(scheme.getModuleName()));
model.put("subModuleName", StringUtil.lowerCase(StringUtil.isEmpty(scheme.getSubModuleName()) ? "" : scheme.getSubModuleName()));
model.put("className", StringUtil.lowerFirst(scheme.getTableDto().getClassName()));
model.put("classNameUrl", StringUtil.toRevertCamelCase(StringUtil.toStrString(model.get("className")), CharUtil.DASHED));
model.put("ClassName", StringUtil.upperFirst(scheme.getTableDto().getClassName()));
model.put("functionName", scheme.getFunctionName());
model.put("functionNameSimple", scheme.getFunctionNameSimple());
model.put("functionAuthor", StringUtil.isNotBlank(scheme.getFunctionAuthor()) ? scheme.getFunctionAuthor() : "");
model.put("functionVersion", DateUtil.now());
model.put("urlPrefix", model.get("moduleName") + (StringUtil.isNotBlank(scheme.getSubModuleName()) ? StringUtil.SLASH +
StringUtil.lowerCase(scheme.getSubModuleName()) : "") + StringUtil.SLASH + model.get("classNameUrl")
);
model.put("viewPrefix", model.get("urlPrefix"));
model.put("permissionPrefix", model.get("moduleName") + (StringUtil.isNotBlank(scheme.getSubModuleName()) ? "_" + StringUtil.lowerCase(scheme.getSubModuleName()) : "") + "_" + model.get("className"));
model.put("table", scheme.getTableDto());
model.put("scheme", scheme);
return model;
}
@Bean
public Docket docket() {
ArrayList<String> basePackage=new ArrayList<>();
if(!StringUtils.isEmpty(swaggerBasePackage)){
basePackage.addAll(Arrays.asList(swaggerBasePackage.split(",")));
}else {
// 从注解中解析basePackage
Map<String, Object> applicationClass = applicationContext.getBeansWithAnnotation(SpringBootApplication.class);
if(applicationClass.size()>1){
log.warn("{} SpringBootApplication : {}",applicationClass.size(),applicationClass);
}
applicationClass.forEach((k,v)->{
SpringBootApplication ann = AnnotationUtils.findAnnotation(v.getClass(), SpringBootApplication.class);
if(ann.scanBasePackages().length==0&&ann.scanBasePackageClasses().length==0){
basePackage.add(v.getClass().getPackage().getName());
}else {
basePackage.addAll(Arrays.asList(ann.scanBasePackages()));
basePackage.addAll(Arrays.asList(ann.scanBasePackageClasses()).stream().map(s->s.getPackage().getName()).collect(Collectors.toList()));
}
});
}
return new Docket(DocumentationType.SWAGGER_2).select().apis(Predicates.or(basePackage.stream().map(RequestHandlerSelectors::basePackage).collect(Collectors.toList())))
.paths(Predicates.not(PathSelectors.regex("/error.*"))).build()
.apiInfo(new ApiInfo(configurableEnvironment.getProperty("spring.application.name"), "",
configurableEnvironment.getProperty("spring.application.version"), "",
new Contact(configurableEnvironment.getProperty("spring.application.contact"), "", ""), "", "",
new ArrayList<>()));
}
@Test // #72
public void rejectsTypeNotAnnotatedWithEitherModulithAnnotationOrSpringBootApplication() {
assertThatExceptionOfType(IllegalArgumentException.class) //
.isThrownBy(() -> ModulithMetadata.of(Unannotated.class)) //
.withMessageContaining(Modulith.class.getSimpleName()) //
.withMessageContaining(Modulithic.class.getSimpleName()) //
.withMessageContaining(SpringBootApplication.class.getSimpleName());
}
@Nullable
@Override
public String resolve(@Nonnull String serviceName) {
Map<String, Object> annotatedBeans =
applicationContext.getBeansWithAnnotation(SpringBootApplication.class);
return annotatedBeans.isEmpty()
? null
: annotatedBeans.values().toArray()[0].getClass().getPackage().getImplementationVersion();
}
private static boolean isSpringBootApplication(Class<?> startClass) {
return startClass.getDeclaredAnnotation(SpringBootApplication.class) != null
|| startClass.getDeclaredAnnotation(SpringBootConfiguration.class) != null;
}
@PostConstruct
public void postConstruct() {
ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
false);
scanner.setEnvironment(this.environment);
scanner.setResourceLoader(this.resourceLoader);
scanner.addIncludeFilter(new AnnotationTypeFilter(SpringBootApplication.class));
scanner.addIncludeFilter(new AnnotationTypeFilter(WicketHomePage.class));
scanner.addIncludeFilter(new AnnotationTypeFilter(WicketSignInPage.class));
scanner.addIncludeFilter(new AnnotationTypeFilter(WicketAccessDeniedPage.class));
scanner.addIncludeFilter(new AnnotationTypeFilter(WicketExpiredPage.class));
scanner.addIncludeFilter(new AnnotationTypeFilter(WicketInternalErrorPage.class));
for (String basePackage : getMappingBasePackages(beanFactory)) {
if (StringUtils.hasText(basePackage)) {
pageCandidates().getBasePackages().add(basePackage);
Set<BeanDefinition> beanDefinitions = scanner.findCandidateComponents(basePackage);
for (BeanDefinition beanDefinition : beanDefinitions) {
Class<?> beanClass;
try {
beanClass = ClassUtils.forName(beanDefinition.getBeanClassName(), classLoader);
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e);
}
if(beanClass.isAnnotationPresent(WicketHomePage.class)){
pageCandidates().getHomePageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
}
if(beanClass.isAnnotationPresent(WicketSignInPage.class)){
pageCandidates().getSignInPageCandidates().add(new WicketClassCandidate<WebPage>((Class<WebPage>) beanClass));
}
if(beanClass.isAnnotationPresent(WicketAccessDeniedPage.class)){
pageCandidates().getAccessDeniedPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
}
if(beanClass.isAnnotationPresent(WicketExpiredPage.class)){
pageCandidates().getExpiredPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
}
if(beanClass.isAnnotationPresent(WicketInternalErrorPage.class)){
pageCandidates().getInternalErrorPageCandidates().add(new WicketClassCandidate<Page>((Class<Page>) beanClass));
}
if(beanClass.isAnnotationPresent(SpringBootApplication.class)){
pageCandidates().setSpringBootMainClass( beanClass );
}
}
}
}
}
@Override
public JaxrsApplicationParser.Result tryParse(SourceType<?> sourceType) {
if (!(sourceType.type instanceof Class<?>)) {
return null;
}
final Class<?> cls = (Class<?>) sourceType.type;
// application
final SpringBootApplication app = AnnotationUtils.findAnnotation(cls, SpringBootApplication.class);
if (app != null) {
if (settings.scanSpringApplication) {
TypeScriptGenerator.getLogger().verbose("Scanning Spring application: " + cls.getName());
final ClassLoader originalContextClassLoader = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(settings.classLoader);
final SpringApplicationHelper springApplicationHelper = new SpringApplicationHelper(settings.classLoader, cls);
final List<Class<?>> restControllers = springApplicationHelper.findRestControllers();
return new JaxrsApplicationParser.Result(restControllers.stream()
.map(controller -> new SourceType<Type>(controller, cls, "<scanned>"))
.collect(Collectors.toList())
);
} finally {
Thread.currentThread().setContextClassLoader(originalContextClassLoader);
}
} else {
return null;
}
}
// controller
final Component component = AnnotationUtils.findAnnotation(cls, Component.class);
if (component != null) {
TypeScriptGenerator.getLogger().verbose("Parsing Spring component: " + cls.getName());
final JaxrsApplicationParser.Result result = new JaxrsApplicationParser.Result();
final RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(cls, RequestMapping.class);
final String path = requestMapping != null && requestMapping.path() != null && requestMapping.path().length != 0 ? requestMapping.path()[0] : null;
final JaxrsApplicationParser.ResourceContext context = new JaxrsApplicationParser.ResourceContext(cls, path);
parseController(result, context, cls);
return result;
}
return null;
}