private static String getString(AnnotationAttributes attributes, String attributeName, String defaultValue) { String value = attributes.getString(attributeName); if ("".equals(value)) { value = defaultValue; } return value; }
/** * Construct a new {@link ContextConfigurationAttributes} instance for the * supplied {@link AnnotationAttributes} (parsed from a * {@link ContextConfiguration @ContextConfiguration} annotation) and * the {@linkplain Class test class} that declared them. * @param declaringClass the test class that declared {@code @ContextConfiguration} * @param annAttrs the annotation attributes from which to retrieve the attributes */ @SuppressWarnings("unchecked") public ContextConfigurationAttributes(Class<?> declaringClass, AnnotationAttributes annAttrs) { this(declaringClass, annAttrs.getStringArray("locations"), annAttrs.getClassArray("classes"), annAttrs.getBoolean("inheritLocations"), (Class<? extends ApplicationContextInitializer<?>>[]) annAttrs.getClassArray("initializers"), annAttrs.getBoolean("inheritInitializers"), annAttrs.getString("name"), annAttrs.getClass("loader")); }
private void setupDomain(AnnotationMBeanExporter exporter, AnnotationAttributes enableMBeanExport) { String defaultDomain = enableMBeanExport.getString("defaultDomain"); if (StringUtils.hasLength(defaultDomain) && this.environment != null) { defaultDomain = this.environment.resolvePlaceholders(defaultDomain); } if (StringUtils.hasText(defaultDomain)) { exporter.setDefaultDomain(defaultDomain); } }
@Test public void getAnnotationAttributesWithAttributeAliases() throws Exception { Method method = WebController.class.getMethod("handleMappedWithValueAttribute"); WebMapping webMapping = method.getAnnotation(WebMapping.class); AnnotationAttributes attributes = (AnnotationAttributes) getAnnotationAttributes(webMapping); assertNotNull(attributes); assertEquals(WebMapping.class, attributes.annotationType()); assertEquals("name attribute: ", "foo", attributes.getString("name")); assertArrayEquals("value attribute: ", asArray("/test"), attributes.getStringArray(VALUE)); assertArrayEquals("path attribute: ", asArray("/test"), attributes.getStringArray("path")); method = WebController.class.getMethod("handleMappedWithPathAttribute"); webMapping = method.getAnnotation(WebMapping.class); attributes = (AnnotationAttributes) getAnnotationAttributes(webMapping); assertNotNull(attributes); assertEquals(WebMapping.class, attributes.annotationType()); assertEquals("name attribute: ", "bar", attributes.getString("name")); assertArrayEquals("value attribute: ", asArray("/test"), attributes.getStringArray(VALUE)); assertArrayEquals("path attribute: ", asArray("/test"), attributes.getStringArray("path")); }
private void setupDomain(AnnotationMBeanExporter exporter, AnnotationAttributes enableMBeanExport) { String defaultDomain = enableMBeanExport.getString("defaultDomain"); if (StringUtils.hasLength(defaultDomain) && this.environment != null) { defaultDomain = this.environment.resolvePlaceholders(defaultDomain); } if (StringUtils.hasText(defaultDomain)) { exporter.setDefaultDomain(defaultDomain); } }
private void setupServer(AnnotationMBeanExporter exporter, AnnotationAttributes enableMBeanExport) { String server = enableMBeanExport.getString("server"); if (StringUtils.hasLength(server) && this.environment != null) { server = this.environment.resolvePlaceholders(server); } if (StringUtils.hasText(server)) { Assert.state(this.beanFactory != null, "No BeanFactory set"); exporter.setServer(this.beanFactory.getBean(server, MBeanServer.class)); } else { SpecificPlatform specificPlatform = SpecificPlatform.get(); if (specificPlatform != null) { MBeanServer mbeanServer = specificPlatform.getMBeanServer(); if (mbeanServer != null) { exporter.setServer(mbeanServer); } } } }
@Override public void setImportMetadata(AnnotationMetadata importMetadata) { Map<String, Object> map = importMetadata.getAnnotationAttributes(EnableRedissonHttpSession.class.getName()); AnnotationAttributes attrs = AnnotationAttributes.fromMap(map); keyPrefix = attrs.getString("keyPrefix"); maxInactiveIntervalInSeconds = attrs.getNumber("maxInactiveIntervalInSeconds"); }
@Override public void setImportMetadata(AnnotationMetadata importMetadata) { Map<String, Object> map = importMetadata.getAnnotationAttributes(EnableRedissonHttpSession.class.getName()); AnnotationAttributes attrs = AnnotationAttributes.fromMap(map); keyPrefix = attrs.getString("keyPrefix"); maxInactiveIntervalInSeconds = attrs.getNumber("maxInactiveIntervalInSeconds"); }
protected void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) { String prefix = environment.resolvePlaceholders(attributes.getString("prefix")); Class<? extends AbstractConfig> configClass = attributes.getClass("type"); boolean multiple = attributes.getBoolean("multiple"); registerDubboConfigBeans(prefix, configClass, multiple, registry); }
protected void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) { String prefix = environment.resolvePlaceholders(attributes.getString("prefix")); Class<? extends AbstractConfig> configClass = attributes.getClass("type"); boolean multiple = attributes.getBoolean("multiple"); registerDubboConfigBeans(prefix, configClass, multiple, registry); }
private void assertMultipleAnnotationsWithIdenticalAttributeNames(AnnotationMetadata metadata) { AnnotationAttributes attributes1 = (AnnotationAttributes) metadata.getAnnotationAttributes( NamedAnnotation1.class.getName(), false); String name1 = attributes1.getString("name"); assertThat("name of NamedAnnotation1", name1, is("name 1")); AnnotationAttributes attributes2 = (AnnotationAttributes) metadata.getAnnotationAttributes( NamedAnnotation2.class.getName(), false); String name2 = attributes2.getString("name"); assertThat("name of NamedAnnotation2", name2, is("name 2")); AnnotationAttributes attributes3 = (AnnotationAttributes) metadata.getAnnotationAttributes( NamedAnnotation3.class.getName(), false); String name3 = attributes3.getString("name"); assertThat("name of NamedAnnotation3", name3, is("name 3")); }
@Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(MetaConditional.class.getName())); assertThat(attributes.getString("value"), equalTo("test")); return true; } }
@Test public void indirectlyAnnotatedWithImport() { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(IndirectlyImportingConfig.class); ctx.refresh(); assertNotNull(ctx.getBean("importedConfigBean")); ImportedConfig importAwareConfig = ctx.getBean(ImportedConfig.class); AnnotationMetadata importMetadata = importAwareConfig.importMetadata; assertThat("import metadata was not injected", importMetadata, notNullValue()); assertThat(importMetadata.getClassName(), is(IndirectlyImportingConfig.class.getName())); AnnotationAttributes enableAttribs = AnnotationConfigUtils.attributesFor(importMetadata, EnableImportedConfig.class); String foo = enableAttribs.getString("foo"); assertThat(foo, is("xyz")); }
@Override public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) { ScopeMetadata metadata = new ScopeMetadata(); if (definition instanceof AnnotatedBeanDefinition) { AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition; AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor( annDef.getMetadata(), this.scopeAnnotationType); if (attributes != null) { metadata.setScopeName(attributes.getString("value")); ScopedProxyMode proxyMode = attributes.getEnum("proxyMode"); if (proxyMode == ScopedProxyMode.DEFAULT) { proxyMode = this.defaultProxyMode; } metadata.setScopedProxyMode(proxyMode); } } return metadata; }
@Test public void findMergedAnnotationAttributesOnClassWithMetaAndLocalTxConfig() { AnnotationAttributes attributes = findMergedAnnotationAttributes(MetaAndLocalTxConfigClass.class, Transactional.class); assertNotNull("Should find @Transactional on MetaAndLocalTxConfigClass", attributes); assertEquals("TX qualifier for MetaAndLocalTxConfigClass.", "localTxMgr", attributes.getString("qualifier")); }
@Test public void getAliasedStringWithImplicitAliases() { String value = "metaverse"; List<String> aliases = Arrays.asList("value", "location1", "location2", "location3", "xmlFile", "groovyScript"); attributes = new AnnotationAttributes(ImplicitAliasesContextConfig.class); attributes.put("value", value); AnnotationUtils.postProcessAnnotationAttributes(null, attributes, false); aliases.stream().forEach(alias -> assertEquals(value, attributes.getString(alias))); attributes = new AnnotationAttributes(ImplicitAliasesContextConfig.class); attributes.put("location1", value); AnnotationUtils.postProcessAnnotationAttributes(null, attributes, false); aliases.stream().forEach(alias -> assertEquals(value, attributes.getString(alias))); attributes = new AnnotationAttributes(ImplicitAliasesContextConfig.class); attributes.put("value", value); attributes.put("location1", value); attributes.put("xmlFile", value); attributes.put("groovyScript", value); AnnotationUtils.postProcessAnnotationAttributes(null, attributes, false); aliases.stream().forEach(alias -> assertEquals(value, attributes.getString(alias))); }
@Test public void getAnnotationAttributesWithoutAttributeAliases() { Component component = WebController.class.getAnnotation(Component.class); assertNotNull(component); AnnotationAttributes attributes = (AnnotationAttributes) getAnnotationAttributes(component); assertNotNull(attributes); assertEquals("value attribute: ", "webController", attributes.getString(VALUE)); assertEquals(Component.class, attributes.annotationType()); }
@Test public void getMergedAnnotationAttributesOnClassWithLocalAnnotation() { Class<?> element = TxConfig.class; String name = TX_NAME; AnnotationAttributes attributes = getMergedAnnotationAttributes(element, name); assertNotNull("Annotation attributes for @Transactional on TxConfig", attributes); assertEquals("value for TxConfig.", "TxConfig", attributes.getString("value")); // Verify contracts between utility methods: assertTrue(isAnnotated(element, name)); }
@Test public void getMergedAnnotationAttributesOnClassWithLocalAnnotationThatShadowsAnnotationFromSuperclass() { Class<?> element = DerivedTxConfig.class; String name = TX_NAME; AnnotationAttributes attributes = getMergedAnnotationAttributes(element, name); assertNotNull("Annotation attributes for @Transactional on DerivedTxConfig", attributes); assertEquals("value for DerivedTxConfig.", "DerivedTxConfig", attributes.getString("value")); // Verify contracts between utility methods: assertTrue(isAnnotated(element, name)); }
@Test public void findAndSynthesizeAnnotationAttributesOnClassWithAttributeAliasesInTargetAnnotation() { String qualifier = "aliasForQualifier"; // 1) Find and merge AnnotationAttributes from the annotation hierarchy AnnotationAttributes attributes = findMergedAnnotationAttributes( AliasedTransactionalComponentClass.class, AliasedTransactional.class); assertNotNull("@AliasedTransactional on AliasedTransactionalComponentClass.", attributes); // 2) Synthesize the AnnotationAttributes back into the target annotation AliasedTransactional annotation = AnnotationUtils.synthesizeAnnotation(attributes, AliasedTransactional.class, AliasedTransactionalComponentClass.class); assertNotNull(annotation); // 3) Verify that the AnnotationAttributes and synthesized annotation are equivalent assertEquals("TX value via attributes.", qualifier, attributes.getString("value")); assertEquals("TX value via synthesized annotation.", qualifier, annotation.value()); assertEquals("TX qualifier via attributes.", qualifier, attributes.getString("qualifier")); assertEquals("TX qualifier via synthesized annotation.", qualifier, annotation.qualifier()); }