Infer AnnotationAttributes method return types

cbeams · cbeams · commit e25f1cbca994 · 2012-02-13T15:01:05.000+01:00
- Drop 'expectedType' parameter from #getClass and #getEnum methods and rely on compiler inference based on type of assigned variable, e.g. public @interface Example { Color color(); Class<? extends UserType> userType(); int order() default 0; } AnnotationAttributes example = AnnotationUtils.getAnnotationAttributes(Example.class, true, true); Color color = example.getEnum("color"); Class<? extends UserType> userType = example.getClass("userType"); or in cases where there is no variable assignment (and thus no inference possible), use explicit generic type, e.g. bean.setColor(example.<Color>getEnum("color")); - Rename #get{Int=>Number} and update return type from int to <N extends Number>, allowing invocations such as: int order = example.getNumber("order"); These changes reduce the overall number of methods exposed by AnnotationAttributes, while at the same time providing comprehensive access to all possible annotation attribute types -- that is, instead of requiring explicit #getInt, #getFloat, #getDouble methods, the single #getNumber method is capabable of handling them all, and without any casting required. And the obvious additional benefit is more concise invocation as no redundant 'expectedType' parameters are required.
diff --git a/org.springframework.context/src/main/java/org/springframework/cache/annotation/ProxyCachingConfiguration.java b/org.springframework.context/src/main/java/org/springframework/cache/annotation/ProxyCachingConfiguration.java
@@ -44,7 +44,7 @@ public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor() {
 			new BeanFactoryCacheOperationSourceAdvisor();
 		advisor.setCacheOperationSource(cacheOperationSource());
 		advisor.setAdvice(cacheInterceptor());
-		advisor.setOrder(this.enableCaching.getInt("order"));
+		advisor.setOrder(this.enableCaching.<Integer>getNumber("order"));
 		return advisor;
 	}
 
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/AdviceModeImportSelector.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/AdviceModeImportSelector.java
@@ -73,8 +73,7 @@ public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
 				"@%s is not present on importing class '%s' as expected",
 				annoType.getSimpleName(), importingClassMetadata.getClassName()));
 
-		AdviceMode adviceMode =
-				attributes.getEnum(this.getAdviceModeAttributeName(), AdviceMode.class);
+		AdviceMode adviceMode = attributes.getEnum(this.getAdviceModeAttributeName());
 
 		String[] imports = selectImports(adviceMode);
 		Assert.notNull(imports, String.format("Unknown AdviceMode: '%s'", adviceMode));
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/AnnotationConfigUtils.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/AnnotationConfigUtils.java
@@ -232,8 +232,8 @@ static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
 		}
 		if (abd instanceof AbstractBeanDefinition) {
 			if (metadata.isAnnotated(Role.class.getName())) {
-				((AbstractBeanDefinition)abd).setRole(
-						attributesFor(metadata, Role.class).getInt("value"));
+				int role = attributesFor(metadata, Role.class).getNumber("value");
+				((AbstractBeanDefinition)abd).setRole(role);
 			}
 		}
 	}
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/AnnotationScopeMetadataResolver.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/AnnotationScopeMetadataResolver.java
@@ -81,7 +81,7 @@ public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
 					attributesFor(annDef.getMetadata(), this.scopeAnnotationType);
 			if (attributes != null) {
 				metadata.setScopeName(attributes.getString("value"));
-				ScopedProxyMode proxyMode = attributes.getEnum("proxyMode", ScopedProxyMode.class);
+				ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
 				if (proxyMode == null || proxyMode == ScopedProxyMode.DEFAULT) {
 					proxyMode = this.defaultProxyMode;
 				}
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/ComponentScanAnnotationParser.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/ComponentScanAnnotationParser.java
@@ -70,15 +70,15 @@ public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan) {
 		Assert.notNull(this.resourceLoader, "ResourceLoader must not be null");
 		scanner.setResourceLoader(this.resourceLoader);
 
-		scanner.setBeanNameGenerator(BeanUtils.instantiateClass(
-				componentScan.getClass("nameGenerator", BeanNameGenerator.class)));
+		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
+		scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
 
-		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy", ScopedProxyMode.class);
+		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
 		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
 			scanner.setScopedProxyMode(scopedProxyMode);
 		} else {
-			scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(
-					componentScan.getClass("scopeResolver", ScopeMetadataResolver.class)));
+			Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
+			scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
 		}
 
 		scanner.setResourcePattern(componentScan.getString("resourcePattern"));
@@ -118,7 +118,7 @@ public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan) {
 
 	private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {
 		List<TypeFilter> typeFilters = new ArrayList<TypeFilter>();
-		FilterType filterType = filterAttributes.getEnum("type", FilterType.class);
+		FilterType filterType = filterAttributes.getEnum("type");
 
 		for (Class<?> filterClass : filterAttributes.getClassArray("value")) {
 			switch (filterType) {
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java
@@ -198,7 +198,7 @@ private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
 		// consider role
 		AnnotationAttributes role = attributesFor(metadata, Role.class);
 		if (role != null) {
-			beanDef.setRole(role.getInt("value"));
+			beanDef.setRole(role.<Integer>getNumber("value"));
 		}
 
 		// consider name and any aliases
@@ -246,7 +246,7 @@ else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){
 			}
 		}
 
-		Autowire autowire = bean.getEnum("autowire", Autowire.class);
+		Autowire autowire = bean.getEnum("autowire");
 		if (autowire.isAutowire()) {
 			beanDef.setAutowireMode(autowire.value());
 		}
@@ -266,7 +266,7 @@ else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){
 		AnnotationAttributes scope = attributesFor(metadata, Scope.class);
 		if (scope != null) {
 			beanDef.setScope(scope.getString("value"));
-			proxyMode = scope.getEnum("proxyMode", ScopedProxyMode.class);
+			proxyMode = scope.getEnum("proxyMode");
 			if (proxyMode == ScopedProxyMode.DEFAULT) {
 				proxyMode = ScopedProxyMode.NO;
 			}
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/ConfigurationClassParser.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/ConfigurationClassParser.java
@@ -216,8 +216,7 @@ protected void doProcessConfigurationClass(ConfigurationClass configClass, Annot
 		if (metadata.isAnnotated(ImportResource.class.getName())) {
 			AnnotationAttributes importResource = attributesFor(metadata, ImportResource.class);
 			String[] resources = importResource.getStringArray("value");
-			Class<? extends BeanDefinitionReader> readerClass =
-					importResource.getClass("reader", BeanDefinitionReader.class);
+			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
 			for (String resource : resources) {
 				configClass.addImportedResource(resource, readerClass);
 			}
diff --git a/org.springframework.context/src/main/java/org/springframework/context/annotation/LoadTimeWeavingConfiguration.java b/org.springframework.context/src/main/java/org/springframework/context/annotation/LoadTimeWeavingConfiguration.java
@@ -18,8 +18,6 @@
 
 import static org.springframework.context.weaving.AspectJWeavingEnabler.ASPECTJ_AOP_XML_RESOURCE;
 
-import java.util.Map;
-
 import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -80,7 +78,8 @@ public LoadTimeWeaver loadTimeWeaver() {
 			loadTimeWeaver = new DefaultContextLoadTimeWeaver(this.beanClassLoader);
 		}
 
-		switch (this.enableLTW.getEnum("aspectjWeaving", AspectJWeaving.class)) {
+		AspectJWeaving aspectJWeaving = this.enableLTW.getEnum("aspectjWeaving");
+		switch (aspectJWeaving) {
 			case DISABLED:
 				// AJ weaving is disabled -> do nothing
 				break;
diff --git a/org.springframework.context/src/main/java/org/springframework/scheduling/annotation/ProxyAsyncConfiguration.java b/org.springframework.context/src/main/java/org/springframework/scheduling/annotation/ProxyAsyncConfiguration.java
@@ -46,7 +46,7 @@ public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
 
 		AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
 
-		Class<? extends Annotation> customAsyncAnnotation = enableAsync.getClass("annotation", Annotation.class);
+		Class<? extends Annotation> customAsyncAnnotation = enableAsync.getClass("annotation");
 		if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) {
 			bpp.setAsyncAnnotationType(customAsyncAnnotation);
 		}
@@ -56,8 +56,7 @@ public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
 		}
 
 		bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));
-
-		bpp.setOrder(this.enableAsync.getInt("order"));
+		bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));
 
 		return bpp;
 	}
diff --git a/org.springframework.core/src/main/java/org/springframework/core/annotation/AnnotationAttributes.java b/org.springframework.core/src/main/java/org/springframework/core/annotation/AnnotationAttributes.java
@@ -92,16 +92,18 @@ public boolean getBoolean(String attributeName) {
 		return doGet(attributeName, Boolean.class);
 	}
 
-	public int getInt(String attributeName) {
-		return doGet(attributeName, Integer.class);
+	@SuppressWarnings("unchecked")
+	public <N extends Number> N getNumber(String attributeName) {
+		return (N) doGet(attributeName, Integer.class);
 	}
 
-	public <E extends Enum<?>> E getEnum(String attributeName, Class<E> enumType) {
-		return doGet(attributeName, enumType);
+	@SuppressWarnings("unchecked")
+	public <E extends Enum<?>> E getEnum(String attributeName) {
+		return (E) doGet(attributeName, Enum.class);
 	}
 
 	@SuppressWarnings("unchecked")
-	public <T> Class<? extends T> getClass(String attributeName, Class<T> expectedType) {
+	public <T> Class<? extends T> getClass(String attributeName) {
 		return (Class<T>)doGet(attributeName, Class.class);
 	}
 
diff --git a/org.springframework.core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java b/org.springframework.core/src/test/java/org/springframework/core/annotation/AnnotationAttributesTests.java
@@ -55,11 +55,11 @@ public void testTypeSafeAttributeAccess() {
 		assertThat(a.getStringArray("names"), equalTo(new String[] { "dave", "frank", "hal" }));
 		assertThat(a.getBoolean("bool1"), equalTo(true));
 		assertThat(a.getBoolean("bool2"), equalTo(false));
-		assertThat(a.getEnum("color", Color.class), equalTo(Color.RED));
-		assertTrue(a.getClass("clazz", Number.class).equals(Integer.class));
+		assertThat(a.<Color>getEnum("color"), equalTo(Color.RED));
+		assertTrue(a.getClass("clazz").equals(Integer.class));
 		assertThat(a.getClassArray("classes"), equalTo(new Class[] { Number.class, Short.class, Integer.class }));
-		assertThat(a.getInt("number"), equalTo(42));
-		assertThat(a.getAnnotation("anno").getInt("value"), equalTo(10));
+		assertThat(a.<Integer>getNumber("number"), equalTo(42));
+		assertThat(a.getAnnotation("anno").<Integer>getNumber("value"), equalTo(10));
 		assertThat(a.getAnnotationArray("annoArray")[0].getString("name"), equalTo("algernon"));
 	}
 
@@ -68,13 +68,13 @@ public void getEnum_emptyAttributeName() {
 		AnnotationAttributes a = new AnnotationAttributes();
 		a.put("color", "RED");
 		try {
-			a.getEnum("", Color.class);
+			a.getEnum("");
 			fail();
 		} catch (IllegalArgumentException ex) {
 			assertThat(ex.getMessage(), equalTo("attributeName must not be null or empty"));
 		}
 		try {
-			a.getEnum(null, Color.class);
+			a.getEnum(null);
 			fail();
 		} catch (IllegalArgumentException ex) {
 			assertThat(ex.getMessage(), equalTo("attributeName must not be null or empty"));
@@ -86,7 +86,7 @@ public void getEnum_notFound() {
 		AnnotationAttributes a = new AnnotationAttributes();
 		a.put("color", "RED");
 		try {
-			a.getEnum("colour", Color.class);
+			a.getEnum("colour");
 			fail();
 		} catch (IllegalArgumentException ex) {
 			assertThat(ex.getMessage(), equalTo("Attribute 'colour' not found"));
@@ -98,11 +98,11 @@ public void getEnum_typeMismatch() {
 		AnnotationAttributes a = new AnnotationAttributes();
 		a.put("color", "RED");
 		try {
-			a.getEnum("color", Color.class);
+			a.getEnum("color");
 			fail();
 		} catch (IllegalArgumentException ex) {
 			String expected =
-					"Attribute 'color' is of type [String], but [Color] was expected";
+					"Attribute 'color' is of type [String], but [Enum] was expected";
 			assertThat(ex.getMessage().substring(0, expected.length()), equalTo(expected));
 		}
 	}
diff --git a/org.springframework.core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java b/org.springframework.core/src/test/java/org/springframework/core/type/AnnotationMetadataTests.java
@@ -109,34 +109,34 @@ private void doTestAnnotationInfo(AnnotationMetadata metadata) {
 		{ // perform tests with classValuesAsString = false (the default)
 			AnnotationAttributes specialAttrs = (AnnotationAttributes) metadata.getAnnotationAttributes(SpecialAttr.class.getName());
 			assertThat(specialAttrs.size(), is(6));
-			assertTrue(String.class.isAssignableFrom(specialAttrs.getClass("clazz", Object.class)));
-			assertThat(specialAttrs.getEnum("state", Thread.State.class), is(Thread.State.NEW));
+			assertTrue(String.class.isAssignableFrom(specialAttrs.getClass("clazz")));
+			assertTrue(specialAttrs.getEnum("state").equals(Thread.State.NEW));
 
 			AnnotationAttributes nestedAnno = specialAttrs.getAnnotation("nestedAnno");
 			assertThat("na", is(nestedAnno.getString("value")));
-			assertThat(nestedAnno.getEnum("anEnum", SomeEnum.class), is(SomeEnum.LABEL1));
+			assertTrue(nestedAnno.getEnum("anEnum").equals(SomeEnum.LABEL1));
 			assertArrayEquals(new Class[]{String.class}, (Class[])nestedAnno.get("classArray"));
 
 			AnnotationAttributes[] nestedAnnoArray = specialAttrs.getAnnotationArray("nestedAnnoArray");
 			assertThat(nestedAnnoArray.length, is(2));
 			assertThat(nestedAnnoArray[0].getString("value"), is("default"));
-			assertThat(nestedAnnoArray[0].getEnum("anEnum", SomeEnum.class), is(SomeEnum.DEFAULT));
+			assertTrue(nestedAnnoArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT));
 			assertArrayEquals(new Class[]{Void.class}, (Class[])nestedAnnoArray[0].get("classArray"));
 			assertThat(nestedAnnoArray[1].getString("value"), is("na1"));
-			assertThat(nestedAnnoArray[1].getEnum("anEnum", SomeEnum.class), is(SomeEnum.LABEL2));
+			assertTrue(nestedAnnoArray[1].getEnum("anEnum").equals(SomeEnum.LABEL2));
 			assertArrayEquals(new Class[]{Number.class}, (Class[])nestedAnnoArray[1].get("classArray"));
 			assertArrayEquals(new Class[]{Number.class}, nestedAnnoArray[1].getClassArray("classArray"));
 
 			AnnotationAttributes optional = specialAttrs.getAnnotation("optional");
 			assertThat(optional.getString("value"), is("optional"));
-			assertThat(optional.getEnum("anEnum", SomeEnum.class), is(SomeEnum.DEFAULT));
+			assertTrue(optional.getEnum("anEnum").equals(SomeEnum.DEFAULT));
 			assertArrayEquals(new Class[]{Void.class}, (Class[])optional.get("classArray"));
 			assertArrayEquals(new Class[]{Void.class}, optional.getClassArray("classArray"));
 
 			AnnotationAttributes[] optionalArray = specialAttrs.getAnnotationArray("optionalArray");
 			assertThat(optionalArray.length, is(1));
 			assertThat(optionalArray[0].getString("value"), is("optional"));
-			assertThat(optionalArray[0].getEnum("anEnum", SomeEnum.class), is(SomeEnum.DEFAULT));
+			assertTrue(optionalArray[0].getEnum("anEnum").equals(SomeEnum.DEFAULT));
 			assertArrayEquals(new Class[]{Void.class}, (Class[])optionalArray[0].get("classArray"));
 			assertArrayEquals(new Class[]{Void.class}, optionalArray[0].getClassArray("classArray"));
 		}
diff --git a/org.springframework.transaction/src/main/java/org/springframework/transaction/annotation/ProxyTransactionManagementConfiguration.java b/org.springframework.transaction/src/main/java/org/springframework/transaction/annotation/ProxyTransactionManagementConfiguration.java
@@ -44,7 +44,7 @@ public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
 			new BeanFactoryTransactionAttributeSourceAdvisor();
 		advisor.setTransactionAttributeSource(transactionAttributeSource());
 		advisor.setAdvice(transactionInterceptor());
-		advisor.setOrder(this.enableTx.getInt("order"));
+		advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
 		return advisor;
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor() {`
`44`	`44`	`new BeanFactoryCacheOperationSourceAdvisor();`
`45`	`45`	`advisor.setCacheOperationSource(cacheOperationSource());`
`46`	`46`	`advisor.setAdvice(cacheInterceptor());`
`47`		`- advisor.setOrder(this.enableCaching.getInt("order"));`
	`47`	`+ advisor.setOrder(this.enableCaching.<Integer>getNumber("order"));`
`48`	`48`	`return advisor;`
`49`	`49`	`}`
`50`	`50`
Original file line number	Diff line number	Diff line change
`@@ -232,8 +232,8 @@ static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {`
`232`	`232`	`}`
`233`	`233`	`if (abd instanceof AbstractBeanDefinition) {`
`234`	`234`	`if (metadata.isAnnotated(Role.class.getName())) {`
`235`		`- ((AbstractBeanDefinition)abd).setRole(`
`236`		`- attributesFor(metadata, Role.class).getInt("value"));`
	`235`	`+ int role = attributesFor(metadata, Role.class).getNumber("value");`
	`236`	`+ ((AbstractBeanDefinition)abd).setRole(role);`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {`
`81`	`81`	`attributesFor(annDef.getMetadata(), this.scopeAnnotationType);`
`82`	`82`	`if (attributes != null) {`
`83`	`83`	`metadata.setScopeName(attributes.getString("value"));`
`84`		`- ScopedProxyMode proxyMode = attributes.getEnum("proxyMode", ScopedProxyMode.class);`
	`84`	`+ ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");`
`85`	`85`	`if (proxyMode == null \|\| proxyMode == ScopedProxyMode.DEFAULT) {`
`86`	`86`	`proxyMode = this.defaultProxyMode;`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {`
`198`	`198`	`// consider role`
`199`	`199`	`AnnotationAttributes role = attributesFor(metadata, Role.class);`
`200`	`200`	`if (role != null) {`
`201`		`- beanDef.setRole(role.getInt("value"));`
	`201`	`+ beanDef.setRole(role.<Integer>getNumber("value"));`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`// consider name and any aliases`
`@@ -246,7 +246,7 @@ else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`
`249`		`- Autowire autowire = bean.getEnum("autowire", Autowire.class);`
	`249`	`+ Autowire autowire = bean.getEnum("autowire");`
`250`	`250`	`if (autowire.isAutowire()) {`
`251`	`251`	`beanDef.setAutowireMode(autowire.value());`
`252`	`252`	`}`
`@@ -266,7 +266,7 @@ else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){`
`266`	`266`	`AnnotationAttributes scope = attributesFor(metadata, Scope.class);`
`267`	`267`	`if (scope != null) {`
`268`	`268`	`beanDef.setScope(scope.getString("value"));`
`269`		`- proxyMode = scope.getEnum("proxyMode", ScopedProxyMode.class);`
	`269`	`+ proxyMode = scope.getEnum("proxyMode");`
`270`	`270`	`if (proxyMode == ScopedProxyMode.DEFAULT) {`
`271`	`271`	`proxyMode = ScopedProxyMode.NO;`
`272`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public AsyncAnnotationBeanPostProcessor asyncAdvisor() {`
`46`	`46`
`47`	`47`	`AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();`
`48`	`48`
`49`		`- Class<? extends Annotation> customAsyncAnnotation = enableAsync.getClass("annotation", Annotation.class);`
	`49`	`+ Class<? extends Annotation> customAsyncAnnotation = enableAsync.getClass("annotation");`
`50`	`50`	`if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) {`
`51`	`51`	`bpp.setAsyncAnnotationType(customAsyncAnnotation);`
`52`	`52`	`}`
`@@ -56,8 +56,7 @@ public AsyncAnnotationBeanPostProcessor asyncAdvisor() {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));`
`59`		`-`
`60`		`- bpp.setOrder(this.enableAsync.getInt("order"));`
	`59`	`+ bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));`
`61`	`60`
`62`	`61`	`return bpp;`
`63`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,16 +92,18 @@ public boolean getBoolean(String attributeName) {`
`92`	`92`	`return doGet(attributeName, Boolean.class);`
`93`	`93`	`}`
`94`	`94`
`95`		`- public int getInt(String attributeName) {`
`96`		`- return doGet(attributeName, Integer.class);`
	`95`	`+ @SuppressWarnings("unchecked")`
	`96`	`+ public <N extends Number> N getNumber(String attributeName) {`
	`97`	`+ return (N) doGet(attributeName, Integer.class);`
`97`	`98`	`}`
`98`	`99`
`99`		`- public <E extends Enum<?>> E getEnum(String attributeName, Class<E> enumType) {`
`100`		`- return doGet(attributeName, enumType);`
	`100`	`+ @SuppressWarnings("unchecked")`
	`101`	`+ public <E extends Enum<?>> E getEnum(String attributeName) {`
	`102`	`+ return (E) doGet(attributeName, Enum.class);`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`@SuppressWarnings("unchecked")`
`104`		`- public <T> Class<? extends T> getClass(String attributeName, Class<T> expectedType) {`
	`106`	`+ public <T> Class<? extends T> getClass(String attributeName) {`
`105`	`107`	`return (Class<T>)doGet(attributeName, Class.class);`
`106`	`108`	`}`
`107`	`109`