Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

+ Removed requirement for enhanced subclasses to implement InitializingBean. This was in support of injecting @ExternalValue fields, but is no longer necessary in light of @Value

Browse Source 
+ Added formatting rules
This commit is contained in:
Chris Beams
2009-02-28 06:10:17 +00:00
parent 3dac5d82b1
commit f8270428df
8 changed files with 327 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
org.springframework.config.java/src/main/java/org/springframework/config/java/BeanDefinitionRegistrar.java
View File

@@ -4,12 +4,13 @@ import java.lang.reflect.Method;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
/**
* Registers bean definition(s) for a particular method, usually based on its annotation metadata.
* Registers bean definition(s) for a particular method, usually based on its annotation
* metadata.
*
* <h3>Constraints</h3>
* Implementations must have only a default constructor, or explicitly declare
* a no-arg constructor.
* <h3>Constraints</h3> Implementations must have only a default constructor, or explicitly
* declare a no-arg constructor.
*
* @see Factory
* @see ModelMethod
@@ -21,15 +22,15 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry;
// TODO: SJC-242 document that there must be a no-arg ctor
public interface BeanDefinitionRegistrar {
/**
* Determines whether this registrar is capable of handling <var>method</var>.
*/
// TODO: rename to supports() in alignment with Validator nomenclature
boolean accepts(Method method);
/**
* Determines whether this registrar is capable of handling <var>method</var>.
*/
// TODO: rename to supports() in alignment with Validator nomenclature
boolean accepts(Method method);
/**
* Registers any bean definitions for <var>method</var> with <var>registry</var>.
*/
void register(ModelMethod method, BeanDefinitionRegistry registry);
/**
* Registers any bean definitions for <var>method</var> with <var>registry</var>.
*/
void register(ModelMethod method, BeanDefinitionRegistry registry);
}

13
org.springframework.config.java/src/main/java/org/springframework/config/java/internal/enhancement/ConfigurationEnhancer.java
View File

@@ -37,7 +37,6 @@ import org.objectweb.asm.ClassAdapter;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.config.java.BeanDefinitionRegistrar;
@@ -91,7 +90,7 @@ public class ConfigurationEnhancer {
notNull(beanFactory, "beanFactory must be non-null");
notNull(model, "model must be non-null");
populateHandlersAndCallbacks(beanFactory, model);
populateRegistrarsAndCallbacks(beanFactory, model);
}
@@ -101,7 +100,7 @@ public class ConfigurationEnhancer {
*
* @see #callbackFilter
*/
private void populateHandlersAndCallbacks(DefaultListableBeanFactory beanFactory, ConfigurationModel model) {
private void populateRegistrarsAndCallbacks(DefaultListableBeanFactory beanFactory, ConfigurationModel model) {
for (ConfigurationClass configClass : model.getAllConfigurationClasses()) {
for (ModelMethod method : configClass.getMethods()) {
@@ -116,9 +115,6 @@ public class ConfigurationEnhancer {
}
}
registrars.add(new InitializingBeanRegistrar());
callbackInstances.add(new InitializingBeanCallback(beanFactory));
// register a 'catch-all' registrar
registrars.add(new BeanDefinitionRegistrar() {
@@ -140,6 +136,8 @@ public class ConfigurationEnhancer {
/**
* Loads the specified class and generates a CGLIB subclass of it equipped with container-aware
* callbacks capable of respecting scoping and other bean semantics.
*
* @return fully-qualified name of the enhanced subclass
*/
public String enhance(String configClassName) {
if (log.isInfoEnabled())
@@ -170,7 +168,6 @@ public class ConfigurationEnhancer {
enhancer.setUseCache(false);
enhancer.setSuperclass(superclass);
enhancer.setInterfaces(new Class<?>[]{InitializingBean.class});
enhancer.setUseFactory(false);
enhancer.setCallbackFilter(callbackFilter);
enhancer.setCallbackTypes(callbackTypes.toArray(new Class<?>[]{}));
@@ -185,9 +182,7 @@ public class ConfigurationEnhancer {
private Class<?> createClass(Enhancer enhancer, Class<?> superclass) {
Class<?> subclass = enhancer.createClass();
// see #registerThreadLocalCleanupBeanDefinition
Enhancer.registerCallbacks(subclass, callbackInstances.toArray(new Callback[] {}));
//Enhancer.registerStaticCallbacks(subclass, callbackInstances.toArray(new Callback[] {}));
return subclass;
}

47
org.springframework.config.java/src/main/java/org/springframework/config/java/internal/enhancement/InitializingBeanCallback.java
View File

@@ -1,47 +0,0 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.config.java.internal.enhancement;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
// TODO: should not be necessary to make configurations implement InitializingBean anymore once @Value is in the picture
class InitializingBeanCallback implements MethodInterceptor {
private final DefaultListableBeanFactory beanFactory;
public InitializingBeanCallback(DefaultListableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// TODO: SJC-242 ExternalValueInjector - revisit this line (inline method?)
// TODO: should be handled by @Value
//new ExternalValueInjector(beanFactory).injectExternalValues(obj);
// only call the superclass afterPropertiesSet method if it is actually implemented
if(!InitializingBean.class.equals(method.getDeclaringClass()))
return proxy.invokeSuper(obj, args);
return Void.TYPE;
}
}

33
org.springframework.config.java/src/main/java/org/springframework/config/java/internal/enhancement/InitializingBeanRegistrar.java
View File

@@ -1,33 +0,0 @@
/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.config.java.internal.enhancement;
import java.lang.reflect.Method;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.config.java.BeanDefinitionRegistrar;
import org.springframework.config.java.ModelMethod;
class InitializingBeanRegistrar implements BeanDefinitionRegistrar {
public boolean accepts(Method method) {
return method.getName().equals("afterPropertiesSet")
&& method.getReturnType().equals(void.class);
}
public void register(ModelMethod method, BeanDefinitionRegistry registry) {
// no-op
}
}

65
org.springframework.config.java/src/main/java/org/springframework/config/java/internal/parsing/ConfigurationParser.java
View File

@@ -15,8 +15,6 @@
*/
package org.springframework.config.java.internal.parsing;
import org.objectweb.asm.ClassReader;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.config.java.Configuration;
@@ -31,49 +29,50 @@ import org.springframework.core.io.ClassPathResource;
* This ASM-based implementation avoids reflection and eager classloading in order to
* interoperate effectively with tooling (Spring IDE) and OSGi environments.
* <p>
* This class helps separate the concern of parsing the structure of a Configuration class
* This class helps separate the concern of parsing the structure of a Configuration class
* from the concern of registering {@link BeanDefinition} objects based on the content of
* that model.
*
* @see org.springframework.config.java.ConfigurationModel
* @see org.springframework.config.java.support.ConfigurationModelBeanDefinitionReader
*
*
* @author Chris Beams
*/
public class ConfigurationParser {
/**
* Model to be populated during calls to {@link #parse(Object, String)}
*/
private final ConfigurationModel model;
/**
* Model to be populated during calls to {@link #parse(Object, String)}
*/
private final ConfigurationModel model;
/**
* Creates a new parser instance that will be used to populate <var>model</var>.
*
* @param model model to be populated by each successive call to {@link #parse(Object, String)}
*/
public ConfigurationParser(ConfigurationModel model) {
this.model = model;
}
/**
* Creates a new parser instance that will be used to populate <var>model</var>.
*
* @param model model to be populated by each successive call to
* {@link #parse(Object, String)}
*/
public ConfigurationParser(ConfigurationModel model) {
this.model = model;
}
/**
* Parse the {@link Configuration @Configuration} class encapsulated by
* <var>configurationSource</var>.
*
* @param configurationSource reader for Configuration class being parsed
* @param configurationId may be null, but if populated represents the bean id
* (assumes that this configuration class was configured via XML)
*/
public void parse(ClassPathResource resource, String configurationId) {
String resourcePath = resource.getPath();
ClassReader configClassReader = AsmUtils.newClassReader(Util.getClassAsStream(resourcePath));
ConfigurationClass configClass = new ConfigurationClass();
configClass.setBeanName(configurationId);
/**
* Parse the {@link Configuration @Configuration} class encapsulated by
* <var>configurationSource</var>.
*
* @param configurationSource reader for Configuration class being parsed
* @param configurationId may be null, but if populated represents the bean id (assumes
* that this configuration class was configured via XML)
*/
public void parse(ClassPathResource resource, String configurationId) {
configClassReader.accept(new ConfigurationClassVisitor(configClass, model), false);
String resourcePath = resource.getPath();
ClassReader configClassReader = AsmUtils.newClassReader(Util.getClassAsStream(resourcePath));
ConfigurationClass configClass = new ConfigurationClass();
configClass.setBeanName(configurationId);
configClassReader.accept(new ConfigurationClassVisitor(configClass, model), false);
model.add(configClass);
}
}
}

28
org.springframework.config.java/src/main/java/org/springframework/config/java/internal/parsing/MutableAnnotation.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2008 the original author or authors.
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,22 +15,24 @@
*/
package org.springframework.config.java.internal.parsing;
/**
* Note: the visibility of this interface would be reduced to package-private
* save for an obscure restriction of JDK dynamic proxies.
* {@link MutableAnnotationUtils#createMutableAnnotation(Class)} creates a proxy based on two
* interfaces: this one, and whatever annotation is currently being parsed.
* The restriction is that both interfaces may not be package-private if they
* are in separate packages. In order to avoid unnecessarily restricting the
* visibility options for user-defined annotations, this interface becomes public.
* Because it is in the internal.* package, it won't pollute the public API, but
* developers should take caution not to use this annotation outside the
* internal.parsing.asm package.
*
* {@link MutableAnnotationUtils#createMutableAnnotation(Class)} creates a proxy
* based on two interfaces: this one, and whatever annotation is currently being
* parsed. The restriction is that both interfaces may not be package-private if
* they are in separate packages. In order to avoid unnecessarily restricting
* the visibility options for user-defined annotations, this interface becomes
* public. Because it is in the internal.* package, it won't pollute the public
* API, but developers should take caution not to use this annotation outside
* the internal.parsing package.
*
* @author Chris Beams
*/
public interface MutableAnnotation {
void setAttributeValue(String attribName, Object attribValue);
Class<?> getAttributeType(String attributeName);
void setAttributeValue(String attribName, Object attribValue);
Class<?> getAttributeType(String attributeName);
}