下面列出了怎么用org.springframework.context.annotation.AnnotationConfigApplicationContext的API类实例代码及写法,或者点击链接到github查看源代码。
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(DIConfiguration.class);
SoftwareCatalogService softwareCatalogService = ctx.getBean(SoftwareCatalogService.class);
DSLContext dsl = ctx.getBean(DSLContext.class);
EntityReference ref = ImmutableEntityReference.builder()
.kind(EntityKind.ORG_UNIT)
.id(20L)
.build();
IdSelectionOptions options = IdSelectionOptions.mkOpts(ref, HierarchyQueryScope.CHILDREN);
SoftwareSummaryStatistics stats = softwareCatalogService.calculateStatisticsForAppIdSelector(options);
System.out.println("stats:"+stats);
}
@Test
public void testChildContexts() {
AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();
parent.refresh();
FeignContext context = new FeignContext();
context.setApplicationContext(parent);
context.setConfigurations(Arrays.asList(getSpec("foo", FooConfig.class),
getSpec("bar", BarConfig.class)));
Foo foo = context.getInstance("foo", Foo.class);
assertThat(foo).as("foo was null").isNotNull();
Bar bar = context.getInstance("bar", Bar.class);
assertThat(bar).as("bar was null").isNotNull();
Bar foobar = context.getInstance("foo", Bar.class);
assertThat(foobar).as("bar was not null").isNull();
}
@Test
public void registerOuterConfig_withBeanNameGenerator() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.setBeanNameGenerator(new AnnotationBeanNameGenerator() {
@Override
public String generateBeanName(
BeanDefinition definition, BeanDefinitionRegistry registry) {
return "custom-" + super.generateBeanName(definition, registry);
}
});
ctx.register(A.class);
ctx.refresh();
assertThat(ctx.containsBean("custom-outer"), is(true));
assertThat(ctx.containsBean("custom-imported"), is(true));
assertThat(ctx.containsBean("custom-nested"), is(true));
assertThat(ctx.containsBean("nestedBean"), is(true));
}
private ConfigurableApplicationContext createContext(int levels, boolean listenersAsBean) {
if (levels < 1) {
return null;
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
if (listenersAsBean) {
context.register(MyContextEventListener.class);
} else {
context.addApplicationListener(new MyContextEventListener(context));
}
context.setParent(createContext(levels - 1, listenersAsBean));
context.refresh();
return context;
}
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(DIConfiguration.class);
appGroupDao_findRelatedByApplicationId(ctx);
appGroupDao_search(ctx);
appIdSelectorFactory_mkForActor(ctx);
appIdSelectorFactory_mkForAppGroup(ctx);
appIdSelectorFactory_mkForDataType(ctx);
appIdSelectorFactory_mkForFlowDiagram(ctx);
connectionComplexityDao_findCounts(ctx);
dataTypeUsageDao_recalculateForAllApplications(ctx);
entityNameResolver_resolve(ctx);
entityRelationshipDao_tallyRelationshipsInvolving(ctx);
involvementDao_findAllApplicationsByEmployeeId(ctx);
licenceDao_countApplications(ctx);
logicalDataElementSearch_search(ctx);
measurableIdSelectorFactory_mkForFlowDiagram(ctx);
organisationalUnitDao_findImmediateHierarchy(ctx);
physicalFlowDao_findByEntityRef(ctx);
}
@BeforeClass
@SuppressWarnings("ConstantConditions")
public static void setupOnce() {
context = new AnnotationConfigApplicationContext(ServerConfig.class);
server = RSocketFactory.receive()
.addServerPlugin(interceptor)
.frameDecoder(PayloadDecoder.ZERO_COPY)
.acceptor(context.getBean(MessageHandlerAcceptor.class))
.transport(TcpServerTransport.create("localhost", 7000))
.start()
.block();
requester = RSocketRequester.builder()
.rsocketFactory(factory -> factory.frameDecoder(PayloadDecoder.ZERO_COPY))
.rsocketStrategies(context.getBean(RSocketStrategies.class))
.connectTcp("localhost", 7000)
.block();
}
@Test
void createResourceLoader_withoutExecutorSettings_executorConfigured() {
// Arrange
this.context = new AnnotationConfigApplicationContext();
this.context.register(ContextResourceLoaderAutoConfiguration.class);
// Act
this.context.refresh();
// Assert
SimpleStorageProtocolResolver simpleStorageProtocolResolver = (SimpleStorageProtocolResolver) this.context
.getProtocolResolvers().iterator().next();
SyncTaskExecutor taskExecutor = (SyncTaskExecutor) ReflectionTestUtils
.getField(simpleStorageProtocolResolver, "taskExecutor");
assertThat(taskExecutor).isNotNull();
}
@Test
public void testApplicationPropertySourceWithValueInjectedAsConstructorArgs() throws Exception {
int someTimeout = 1000;
int someBatch = 2000;
Config config = mock(Config.class);
when(config.getProperty(eq(TIMEOUT_PROPERTY), anyString())).thenReturn(String.valueOf(someTimeout));
when(config.getProperty(eq(BATCH_PROPERTY), anyString())).thenReturn(String.valueOf(someBatch));
mockConfig(ConfigConsts.NAMESPACE_APPLICATION, config);
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig7.class);
TestJavaConfigBean3 bean = context.getBean(TestJavaConfigBean3.class);
assertEquals(someTimeout, bean.getTimeout());
assertEquals(someBatch, bean.getBatch());
}
public static void main(final String[] args) {
// Spring Java config
final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(SpringbatchPartitionConfig.class);
context.refresh();
final JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
final Job job = (Job) context.getBean("partitionerJob");
LOGGER.info("Starting the batch job");
try {
final JobExecution execution = jobLauncher.run(job, new JobParameters());
LOGGER.info("Job Status : {}", execution.getStatus());
} catch (final Exception e) {
e.printStackTrace();
LOGGER.error("Job failed {}", e.getMessage());
}
}
public static void load(Object ...args) {
log.info("panama server loading");
Class mainClass = deduceMainApplicationClass();
List<String> basePackageList = new ArrayList<>();
ComponentScan componentScan = (ComponentScan)mainClass.getAnnotation(ComponentScan.class);
if (null != componentScan) {
for (String basePackage : componentScan.basePackages()) {
if (basePackage.length() > 0) {
basePackageList.add(basePackage);
}
}
}
if (basePackageList.size() == 0) {
basePackageList.add(mainClass.getPackage().getName() + ".*");
}
basePackageList.add(PANAMA_SPRING_SCAN_PACKAGE);
applicationContext = new AnnotationConfigApplicationContext(basePackageList.toArray(new String[basePackageList.size()]));
log.info("panama server loading success");
}
@Test
public void spr14230AdaptsToOptional() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spr14230Config.class);
Spr14230Service bean = context.getBean(Spr14230Service.class);
Cache cache = context.getBean(CacheManager.class).getCache("itemCache");
TestBean tb = new TestBean("tb1");
bean.insertItem(tb);
assertSame(tb, bean.findById("tb1").get());
assertSame(tb, cache.get("tb1").get());
cache.clear();
TestBean tb2 = bean.findById("tb1").get();
assertNotSame(tb, tb2);
assertSame(tb2, cache.get("tb1").get());
}
@Test
void configureBean_withDefaultClientSpecifiedAndNoReadReplicaWithExpressions_configuresFactoryBeanWithoutReadReplicaAndResolvedExpressions()
throws Exception {
// @checkstyle:on
// Arrange
this.context = new AnnotationConfigApplicationContext();
HashMap<String, Object> propertySourceProperties = new HashMap<>();
propertySourceProperties.put("dbInstanceIdentifier", "test");
propertySourceProperties.put("password", "secret");
propertySourceProperties.put("username", "admin");
this.context.getEnvironment().getPropertySources()
.addLast(new MapPropertySource("test", propertySourceProperties));
// Act
this.context
.register(ApplicationConfigurationWithoutReadReplicaAndExpressions.class);
this.context.refresh();
// Assert
assertThat(this.context.getBean(DataSource.class)).isNotNull();
assertThat(this.context.getBean(AmazonRdsDataSourceFactoryBean.class))
.isNotNull();
}
@Test
public void usingUserWithAllRoles() throws Exception {
final ResourceOwnerPasswordResourceDetails resourceDetails = new ResourceOwnerPasswordResourceDetails();
resourceDetails.setClientId("myclient");
resourceDetails.setClientSecret("mysecret");
resourceDetails.setUsername("user");
resourceDetails.setPassword("secret10");
resourceDetails
.setAccessTokenUri("http://localhost:" + oAuth2ServerResource.getOauth2ServerPort() + "/oauth/token");
final OAuth2RestTemplate oAuth2RestTemplate = new OAuth2RestTemplate(resourceDetails);
final OAuth2AccessToken accessToken = oAuth2RestTemplate.getAccessToken();
System.setProperty("accessTokenAsString", accessToken.getValue());
context = new AnnotationConfigApplicationContext(TestApplication.class);
final DataFlowOperations dataFlowOperations = context.getBean(DataFlowOperations.class);
final AboutResource about = dataFlowOperations.aboutOperation().get();
assertNotNull(about);
assertEquals("user", about.getSecurityInfo().getUsername());
assertEquals(7, about.getSecurityInfo().getRoles().size());
}
@Test
public void overridingCompositeEnvRepo_contextLoads() {
try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
context.register(OverrideCompositeConfig.class, CompositeConfiguration.class,
ConfigServerHealthIndicator.class);
context.refresh();
}
}
@Before
public void setUp() throws Exception {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(WebConfig.class);
context.refresh();
this.client = WebTestClient.bindToApplicationContext(context).build();
}
@Override
protected ApplicationContext initApplicationContext() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(WebConfig.class);
Properties props = new Properties();
props.setProperty("myOrigin", "http://site1.com");
context.getEnvironment().getPropertySources().addFirst(new PropertiesPropertySource("ps", props));
context.register(PropertySourcesPlaceholderConfigurer.class);
context.refresh();
return context;
}
@Test(expected = IllegalStateException.class)
public void multipleCachingConfigurers() throws Throwable {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(MultiCacheManagerConfigurer.class, EnableCachingConfig.class);
try {
ctx.refresh();
}
catch (BeanCreationException ex) {
Throwable root = ex.getRootCause();
assertTrue(root.getMessage().contains("implementations of CachingConfigurer"));
throw root;
}
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
// 注册当前类作为 Configuration Class
context.register(InjectingResourceLoaderDemo.class);
// 启动 Spring 应用上下文
context.refresh();
// 关闭 Spring 应用上下文
context.close();
}
private OasSpecDiffValidator createOasSpecDiffValidator() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
DefaultOasSpecDiffValidatorFactory.class.getPackage().getName());
try {
OasSpecDiffValidatorFactory diffValidatorFactory = ctx.getBean(OasSpecDiffValidatorFactory.class);
return diffValidatorFactory.create();
} finally {
ctx.close();
}
}
@Test
public void fileNameCanBeCustomized() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
EnvironmentTestUtils.addEnvironment(context, "hdfs.fileName:mydata");
context.register(Conf.class);
context.refresh();
HdfsSinkProperties properties = context.getBean(HdfsSinkProperties.class);
assertThat(properties.getFileName(), equalTo("mydata"));
}
@Test
public void spr14322FindsOnInterfaceWithCglibProxy() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Spr14322ConfigB.class);
TransactionalTestInterface bean = ctx.getBean(TransactionalTestInterface.class);
CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
bean.saveFoo();
bean.saveBar();
assertThat(txManager.begun, equalTo(2));
assertThat(txManager.commits, equalTo(2));
assertThat(txManager.rollbacks, equalTo(0));
ctx.close();
}
@Test
public void nonAnnotatedService_PTC_true() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(PTCTrue.class, AnnotatedServiceImpl.class);
ctx.refresh();
NonAnnotatedService s = ctx.getBean(NonAnnotatedService.class);
assertTrue("expected a subclass proxy", AopUtils.isCglibProxy(s));
assertThat(s, instanceOf(AnnotatedServiceImpl.class));
}
@Override
public void run(CommandLine cmdLine, OutputStream out, OutputStream err)
throws Exception {
Preconditions.checkNotNull(cmdLine);
Preconditions.checkNotNull(out);
Preconditions.checkNotNull(err);
Writer writer = new OutputStreamWriter(out, "UTF-8");
try {
ApplicationContext ctx = new AnnotationConfigApplicationContext(
DefaultValidatorConfiguration.class);
@SuppressWarnings("unchecked")
Parser<ServiceMonitoringDefinitionsDescriptor> parser =
ctx.getBean("mdlParser", Parser.class);
@SuppressWarnings("unchecked")
DescriptorValidator<ServiceMonitoringDefinitionsDescriptor> validator =
ctx.getBean("serviceMonitoringDefinitionsDescriptorValidator",
DescriptorValidator.class);
ValidationRunner runner =
new DescriptorRunner<ServiceMonitoringDefinitionsDescriptor>(
parser, validator);
if (!runner.run(cmdLine.getOptionValue(OPT_MDL.getLongOpt()), writer)) {
throw new RuntimeException("Validation failed.");
}
} catch (Exception ex) {
LOG.error("Could not run validation tool.", ex);
IOUtils.write(ex.getMessage() + "\n", err);
throw ex;
} finally {
writer.close();
}
}
private static void surveyTempateHarness(AnnotationConfigApplicationContext ctx) {
SurveyTemplateService surveyTemplateService = ctx.getBean(SurveyTemplateService.class);
SurveyQuestionService surveyQuestionService = ctx.getBean(SurveyQuestionService.class);
SurveyTemplateChangeCommand surveyTemplateChangeCommand = ImmutableSurveyTemplateChangeCommand.builder()
.name("AAA")
.description("BBB")
.targetEntityKind(EntityKind.CHANGE_INITIATIVE)
.build();
long templateId = surveyTemplateService.create("admin", surveyTemplateChangeCommand);
System.out.println("Created: template create with ID = " + templateId);
SurveyQuestion surveyQuestion = ImmutableSurveyQuestion.builder()
.surveyTemplateId(templateId)
.sectionName("SSS")
.questionText("QQQ")
.helpText("HHH")
.fieldType(SurveyQuestionFieldType.TEXTAREA)
.position(1)
.isMandatory(false)
.allowComment(true)
.build();
long questionId = surveyQuestionService.create(surveyQuestion);
System.out.println("Created: question create with ID = " + questionId);
}
@Test
public void contextLoads() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(TestConfig.class);
context.refresh();
MatcherAssert.assertThat(context.getBean(TestEntityContentRepository.class),
CoreMatchers.is(CoreMatchers.not(CoreMatchers.nullValue())));
context.close();
}
@Test
@SuppressWarnings("resource")
public void withConfigurationClassWithPlainFactoryBean() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(ConfigWithPlainFactoryBean.class);
context.refresh();
MyBean myBean = context.getBean("myBean", MyBean.class);
assertSame(context.getBean("myService"), myBean.myService);
myBean.myService.handle();
myBean.myService.handleAsync();
}
void load(Class<?> config, String... environment) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
TestPropertyValues.of(environment).applyTo(applicationContext);
applicationContext.register(config);
applicationContext.register(configClass, JmsAutoConfiguration.class);
applicationContext.refresh();
this.context = applicationContext;
}
@Test
public void multipleCachingConfigurers() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(MultiCacheManagerConfigurer.class, EnableCachingConfig.class);
try {
ctx.refresh();
}
catch (BeanCreationException ex) {
Throwable root = ex.getRootCause();
assertTrue(root instanceof IllegalStateException);
assertTrue(root.getMessage().contains("implementations of CachingConfigurer"));
}
}
public static ApplicationContext spring(boolean scan) {
if (scan) {
return new AnnotationConfigApplicationContext("com.greenlaw110.di_benchmark.objects");
} else {
return new AnnotationConfigApplicationContext(SpringConfig.class);
}
}
@Test
void shouldFindBeanDefinitionByNameIfNoPrimaryBeanAvailable() {
final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(DoubleTracerConfiguration.class);
context.refresh();
final ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
final DefaultRiptideConfigurer configurer = new DefaultRiptideConfigurer(beanFactory, null);
final BeanReference bd = configurer.getBeanRef(Tracer.class, "tracer");
assertThat(bd.getBeanName()).isEqualTo("tracer");
}