Creation is not easy, reprint please note the author: nuggets @ small xizi + source link ~
If you want to learn more about Spring source code, click on the rest of the Spring series to parse line by line
What is a custom tag?
Last time we looked at the default tag -bean tag parsing, today we will look at the custom tag parsing.
1. Customize the label definition
In the Spring XML configuration file, we can divide all tags into two categories: custom tags and default tags. The differences are as follows
<! -- It's on the front of the labelxxx:For spring's custom tag, we can also define a tag of xiaozize: - we'll talk about that later ->
<context:component-scan base-package="com.xiaoxizi.spring"/>
<! The corresponding namespace of this tag is declared in the beans tag in the XML file header.
<beans xmlns:context="http://www.springframework.org/schema/context" . />
<! -- Default tag without xx: prefix -->
<bean class="com.xiaoxizi.spring.service.AccountServiceImpl"
id="accountService" scope="singleton" primary="true"/>
<! The corresponding namespace is also declared in the beans tag in the XML file header.
<beans xmlns="http://www.springframework.org/schema/beans" . />
Copy the codeIt is important to note that the concept of custom tags does not refer entirely to tags defined by us during development, but rather to extension points reserved by spring developers for future extensions that we can use and spring developers can use when adding new features to Spring.
About 2.springBuilt-in custom tagscontext:component-scan
More often than not, we use @Configuration, @Component, @Service annotations to declare beans rather than XML bean tags.
So why should a class with these annotations be managed by Spring?
These extensions are actually extended by Spring’s own custom tag extension points, using the Context: Component-scan tag.
Context: Component-scan Context: Component-scan Context: Component-scan Context: Component-scan Context: Component-scan Take a look at how tags like @Component work.
Two, source code analysis
1. Customize the label parsing process
Since I followed the XML source code in the previous article, This issue between our positioning to the corresponding code org. Springframework. Beans. Factory. XML. DefaultBeanDefinitionDocumentReader# parseBeanDefinitions
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// Check if it is the default namespace
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
// Parse the default tags
parseDefaultElement(ele, delegate);
}
else {
// You can see that the proxy mainly does custom tag parsingdelegate.parseCustomElement(ele); }}}}else {
// You can see that the proxy mainly does custom tag parsingdelegate.parseCustomElement(root); }}@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// Get the tags for the namespaceUrl, that is, XMLNS: XXX =www.xxx.com in the beans tag in the header of the configuration file
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
// Get the NamespaceHandler for the custom tag. There should be a unique NamespaceHandler for each namespaceUri
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
// Delegate custom tags to the corresponding NamespaceHandler for parsing
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
Copy the codeLet’s first look at the structure of NamespaceHandler, the parser interface for custom tags:
public interface NamespaceHandler {
We can reasonably guess that this method will be called after NamespaceHandler is instantiated but before it is used
void init(a);
// XML parsing entry
@Nullable
BeanDefinition parse(Element element, ParserContext parserContext);
After the default bean tag is parsed, it gives you an opportunity to decorate the parsed beanDefinition, which is rarely used in development
/ / interested students will be able to see the source code, source code in the org. Springframework. Beans. Factory. XML. DefaultBeanDefinitionDocumentReader# processBeanDefinition
@Nullable
BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder definition, ParserContext parserContext);
}
Copy the codeNext, of course, we need to look at the process of obtaining NamespaceHandler:
public NamespaceHandler resolve(String namespaceUri) {
// Get a handlerMapping
Map<String, Object> handlerMappings = getHandlerMappings();
// Get an object with namespaceUri
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
// If handlerOrClassName is a NamespaceHandler object, return the corresponding handler
else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler) handlerOrClassName;
}
else {
// If handlerOrClassName is not a NamespaceHandler, it is a String
String className = (String) handlerOrClassName;
// Get a Class object from a String, then the String must be the fully qualified name of a ClassClass<? > handlerClass = ClassUtils.forName(className,this.classLoader);
// handlerClass must inherit from NamespaceHandler, which makes sense, since it is an extension point provided by Spring and needs to conform to the rules it defines
if(! NamespaceHandler.class.isAssignableFrom(handlerClass)) {throw new FatalBeanException("...");
}
// Create an instance directly through reflection, click on it to see that it is called without arguments constructor
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
/ /!!!!!! The init() method is called, as we guessed earlier
namespaceHandler.init();
/ /!!!!!! The handler object is inserted back into handlerMappings, so the next time we get it through namespaceUri, we will get a NamespaceHandler object directly
// The namespaceUri handler for each namespaceUri is singleton, and init() is called only once
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
// Remove exception handling}}Copy the code/ / “namespaceUri”; / / “namespaceUri”; / / “namespaceUri”; / / “namespaceUri”; / / “namespaceUri”; / / “namespaceUri”; / / “namespaceUri”; / / getHandlerMappings(
private Map<String, Object> getHandlerMappings(a) {
Map<String, Object> handlerMappings = this.handlerMappings;
if (handlerMappings == null) {
synchronized (this) {
handlerMappings = this.handlerMappings;
// Double check the lock, it looks like our handlerMappings will be loaded once after
if (handlerMappings == null) {
// You can see that the file is loaded
// The file is loaded in the same way as the file is loaded in the same way
/ / this. Where is handlerMappingsLocation
Properties mappings =
PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
handlerMappings = new ConcurrentHashMap<>(mappings.size());
// Then merge all the kev-value attributes in the file into a map
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
this.handlerMappings = handlerMappings;
// The exception handling code is dead}}}return handlerMappings;
}
/ / field definition, need to say the current class is DefaultNamespaceHandlerResolver, like his exploring students can directly airborne
/** Resource location to search for. */
private final String handlerMappingsLocation;
// We can see that this value is set in the Resolver constructor
public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader, String handlerMappingsLocation) {
this.classLoader = (classLoader ! =null ? classLoader : ClassUtils.getDefaultClassLoader());
this.handlerMappingsLocation = handlerMappingsLocation;
}
// The default is DEFAULT_HANDLER_MAPPINGS_LOCATION
public DefaultNamespaceHandlerResolver(a) {
this(null, DEFAULT_HANDLER_MAPPINGS_LOCATION);
}
// Let's look at the value of this constant
public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";
Copy the codeAnd for those of you who are familiar with SPI, you already know what this is, and you’re familiar with the meta-INF directory, so let’s take a look at what’s actually written in this meta-INF/Spring.Handlers file, Take the context: Component-scan tag as an example. We know that this tag is provided in the Spring-Context package. Go to the jar file and look at the contents:
## We can clearly see a key=value structure
http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler
Copy the codeLet’s recall the definition of a custom tag:
<! -- It's on the front of the labelxxx:For spring's custom tag, we can also define a tag of xiaozize: - we'll talk about that later ->
<context:component-scan base-package="com.xiaoxizi.spring"/>
<! The corresponding namespace of this tag is declared in the beans tag in the XML file header.
<beans xmlns:context="http://www.springframework.org/schema/context" . />
Copy the codeYou can see in our meta-INF/Spring. handlers file that the key is the namespaceUri of the custom tag and the value is the fully qualified name of the corresponding NamespaceHandler.
So to summarize, our custom tag parsing process is:
-
Handlers; / / Add handlerMappings to the fully qualified names of namespaceUri and NamespaceHandler in the META-INF/ Spring. handlers file in all jars
-
Get an object from handlerMappings according to namespaceUri
-
Return if the object obtained from handlerMappings is empty
-
If you get a NamespaceHandler object, use it
-
If the object is a string, instantiate NamespaceHandler with the fully qualified name of the string and call init(), Then put the Namespaceuri-NamespaceHandler object relationship back into handlerMappings
-
-
Call parse (if 2 does not get the corresponding NamespaceHandler object, the custom tag cannot be parsed and will be skipped)
2. context:component-scanWorking Principle of labels
The spring-context meta-INF/Spring. handlers file shows how the context: Component-scan tag works.
http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
Copy the codeFind this class directly:
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init(a) {
// Removed some Parser injection code for tags we don't care about...
// We can see that a BeanDefinitionParser is registered, and the first argument to this registration method is obviously
// Delete the prefix from the 'context: Component-scan' tag
registerBeanDefinitionParser("component-scan".new ComponentScanBeanDefinitionParser());
// Removed some Parser injection code for tags we don't care about...}}Copy the codeAs you can see, ContextNamespaceHandler inherits from NamespaceHandlerSupport, which is a typical template method design pattern. Instead of extending it, let’s go straight to NamespaceHandlerSupport:
// Here we save only the parse-related code and adjust the source order
// The decoration-related code is removed. It's not that it doesn't exist in NamespaceHandlerSupport, but the logic and parsing are basically the same
// If you still remember where the beanDefinition is decorated and are interested, you can learn about it by yourself (*￣))
public abstract class NamespaceHandlerSupport implements NamespaceHandler {
// The container that holds the tag name-parser relationship
private final Map<String, BeanDefinitionParser> parsers = new HashMap<>();
// Save the container for the label name-decorator relationship
private final Map<String, BeanDefinitionDecorator> decorators = new HashMap<>();
// Save the container for the attribute name-decorator relationship
private final Map<String, BeanDefinitionDecorator> attributeDecorators = new HashMap<>();
// Register in init() simply puts the elementname-parser object into the map
protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
this.parsers.put(elementName, parser);
}
public BeanDefinition parse(Element element, ParserContext parserContext) {
/ / get the Parser
BeanDefinitionParser parser = findParserForElement(element, parserContext);
// Delegate to Parser
return(parser ! =null ? parser.parse(element, parserContext) : null);
}
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
Context :component-scan --> component-scan context:component-scan --> component-scan
String localName = parserContext.getDelegate().getLocalName(element);
// Get the corresponding Parser from map
return this.parsers.get(localName); }}Copy the codeSo far is really quite simple, we gave the corresponding labels entrust Parser to handle, so we now look at some of the component – scan the corresponding ComponentScanBeanDefinitionParser logic, we look at the parse method, Also our entry method:
public BeanDefinition parse(Element element, ParserContext parserContext) {
// Get the base-package attribute configured and processed on the tag
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
// Handle placeholders
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
// We get an array - we can configure multiple arrays
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
// Get a scanner - this is very important, as we will see later
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
// Well, the scanner scans, so it looks like this method will scan the annotations
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
// Register some components
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
Copy the codeLet’s take a look at how the scanner was created:
// Get rid of some exception handling
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
// Parse whether to use the default filter -> as explained here, this filter actually refers to our @service annotations.
// This is to define the annotations that we will put into IOC management after we scan them. The specific code will be seen later when parsing
boolean useDefaultFilters = true;
if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
useDefaultFilters = Boolean.parseBoolean(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
}
// Create a scanner directly
ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
// The default beanDefinition configuration obtained from parserContext, that is, the default configuration of the beanDefinition that is parsed later
scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
// Get the default autowiring mode from parserContext, byType, byName, etc
scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
// Scan the resource path, generally we do not configure
if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
}
// It doesn't work... It is also not customizable, even if the strategy for generating the bean's name is customizable when using annotations
parseBeanNameGenerator(element, scanner);
// The bean will exist in any scope
parseScope(element, scanner);
Parsing type filters - this is important because we can customize which annotations need to be scanned
parseTypeFilters(element, scanner, parserContext);
return scanner;
}
Copy the codeIf useDefaultFilters=true, createScanner calls the constructor directly. Let’s look at the constructor logic: useDefaultFilters= True
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,
boolean useDefaultFilters,
Environment environment,
@Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
if (useDefaultFilters) {
// Register the default filter
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}
protected void registerDefaultFilters(a) {
// includeFilters add an AnnotationTypeFilter. The filter constructor passes in the Component Class object
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
/ / two JSR specification omitted registration code annotated, we usually use less than, @ javax.mail. The annotation. ManagedBean and @ javax.mail inject. Named
}
Copy the codeSince the Filter matching process is not the main process, I will not write more here, but I will write a piece of source code parsing at the end of this section, interested students can also have a look.
Let’s look at the type filter tag parsing:
protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) {
// ...
NodeList nodeList = element.getChildNodes();
for (int i = 0; i < nodeList.getLength(); i++) {
Node node = nodeList.item(i);
// Find each child node
if (node.getNodeType() == Node.ELEMENT_NODE) {
String localName = parserContext.getDelegate().getLocalName(node);
if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
// If it is the
So let’s see what createTypeFilter does:
// The logic is straightforward
protected TypeFilter createTypeFilter(Element element, @Nullable ClassLoader classLoader,
ParserContext parserContext) {
String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
if ("annotation".equals(filterType)) {
// If we want to scan for custom annotations, we can use the annotation type, expression, to specify the fully qualified name of the annotation
return new AnnotationTypeFilter((Class<Annotation>) ClassUtils.forName(expression, classLoader));
}
else if ("assignable".equals(filterType)) {
// Scan configured classes and their subclasses. Expression fills in the fully qualified name of the class. This is also used occasionally to specify beans that can be scanned for some binary libraries
return new AssignableTypeFilter(ClassUtils.forName(expression, classLoader));
}
else if ("aspectj".equals(filterType)) {
// Scan the class that the section expression matches
return new AspectJTypeFilter(expression, classLoader);
}
else if ("regex".equals(filterType)) {
// Scans the classes that the regular expression matches
return new RegexPatternTypeFilter(Pattern.compile(expression));
}
else if ("custom".equals(filterType)) {
// Custom filter, corresponding to the class needs to implement TypeFilter interfaceClass<? > filterClass = ClassUtils.forName(expression, classLoader);if(! TypeFilter.class.isAssignableFrom(filterClass)) {throw new IllegalArgumentException(
"Class is not assignable to [" + TypeFilter.class.getName() + "]." + expression);
}
return (TypeFilter) BeanUtils.instantiateClass(filterClass);
}
else {
throw new IllegalArgumentException("Unsupported filter type: "+ filterType); }}Copy the codeContext: Component-scan {context:component-scan}} Context :component-scan {context:component-scan}} context: Component-scan {context:component-scan}} context: Component-scan {context:component-scan}} So we then look at the back, what is the scanner to scan logic, students can airborne ComponentScanBeanDefinitionParser# parse, and then we look at the access to the scanner, Scanner. DoScan (basePackages) logic:
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
for (String basePackage : basePackages) {
// Find all scanned BeanDefinitions
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
// Get beanName. Remember that when we use annotations, there is no such thing as an XML tag attribute to get a name
// The beanNameGenerator is used to obtain the beanName. The default is the corresponding attribute or class name in the annotation. Will anyone interested in can see AnnotationBeanNameGenerator
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
// Delete the assignment of unimportant attributes
if (candidate instanceof AnnotatedBeanDefinition) {
// This is where public annotations on the class are handled, such as @primary, @lazy, etc
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
// It is the first time that beanDifinition has been registered
// If it is not registered for the first time, it will not be registered again
if (checkCandidate(beanName, candidate)) {
// ...
// Register the beanDefinition in the beanDefinition
// beanDefinitionMap and beanDefinitionNames
registerBeanDefinition(definitionHolder, this.registry); }}}return beanDefinitions;
}
Copy the code. Let’s look at how AnnotationConfigUtils processCommonDefinitionAnnotations () is how to deal with the annotation on the class:
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
if(lazy ! =null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
else if(abd.getMetadata() ! = metadata) { lazy = attributesFor(abd.getMetadata(), Lazy.class);if(lazy ! =null) {
abd.setLazyInit(lazy.getBoolean("value")); }}if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if(dependsOn ! =null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}
AnnotationAttributes role = attributesFor(metadata, Role.class);
if(role ! =null) {
abd.setRole(role.getNumber("value").intValue());
}
AnnotationAttributes description = attributesFor(metadata, Description.class);
if(description ! =null) {
abd.setDescription(description.getString("value")); }}Copy the codeI’m sure the smart guys have figured it out, which is to look at the class and see if it has an annotation on it, and then stuff that attribute into the beanDefinition object. Isn’t this exactly the same process as when XML parses to get a beanDefinition?
Yes, in fact, whether annotation-based or XML-based, some information describing the bean is gathered and summarized into the appropriate beanDefinition. The beanDefinition property determines how the bean will be instantiated, what properties need to be injected, and so on.
There are many ways to gather information to annotate a beanDefinition — it’s even possible to write your own component that parses json files, but the results are all the same.
This also shows the power of Spring’s design, its modular approach to design and its commitment to the single responsibility principle (intuitively delegating to specialized classes) and the open/close principle (to where we are now: The design of custom tags, in the case of not touching the original core logic, we can very simple to do some custom extension of Spring) practice, we can also use for reference in daily development?
Now, back to the source code, let’s look at how the scanner scans for classes that are annotated (which is the application of a previously registered filter). In findCandidateComponents(), we call scanCandidateComponents(), Between us look at scanCandidateComponents() :
// Remove exception handling and log printing
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// This section of logic is extremely complex, and it is not necessary to understand the main process.
// We can find all the class files
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
for (Resource resource : resources) {
// Parses the file information, loading it into memory, which is complicated by some bytecode parsing techniques
// We just need to know that after doing this, the MetadataReader gets all the information about our class
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// This is where our filter comes into play. Beandefinitions are generated only if the class meets the criteria
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
// The class we matched is a qualified bean
For example, if we annotated the interface, we would not add the beanDefinition to the returned container
if(isCandidateComponent(sbd)) { candidates.add(sbd); }}}return candidates;
}
// Filter to determine if it is the class we care about, logic is straightforward
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
// First judge excludeFilters
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false; }}// Determine the includeFilters
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
// If it is the class we care about, we also need to deal with the @Conditional annotation on the class
// I'm not going to go any further here, but I'll give you a brief logic:
// 1. Find annotations for all @Conditional clusters above the class
// 2. Instantiate all corresponding Conditional classes and sort them
// 3. Call all conditions.matches () in order to return true
// You can take a look at the details for yourself
returnisConditionMatch(metadataReader); }}return false;
}
// Check if it is not the interface
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return (metadata.isIndependent() // Not an instance inner class and
&& (metadata.isConcrete() // Not an interface or abstract class or
||
(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
// is an abstract class, but some of the methods are marked by the @lookup annotation, which I mentioned a little earlier. The xmltag has the same meaning as the lookup-method tag, which is equivalent to delegating the method to another bean. So even an abstract class can become a bean -> Spring dynamic proxy generates a subclass
}
Copy the code3. Filter Matching process
I didn’t want to write the Filter matching process, because it’s not really the main process, but I think I’ll write it, otherwise some students might struggle.
AnnotationTypeFilter constructor (AnnotationTypeFilter)
// Let's take a quick look at AnnotationTypeFilter's constructor
public AnnotationTypeFilter(Class<? extends Annotation> annotationType) {
this(annotationType, true.false);
}
// As you can see, when we scan @Component annotations, we consider the source annotations, not the interface annotations
public AnnotationTypeFilter// Annotation type Class<? Extends Annotation> annotationType, // Whether source annotations are consideredbooleanAnnotations, let metaannotations, // Consider the interfaceboolean considerInterfaces) {
// The first argument is whether to consider inherited annotations
super(annotationType.isAnnotationPresent(Inherited.class), considerInterfaces);
this.annotationType = annotationType;
this.considerMetaAnnotations = considerMetaAnnotations;
}
Copy the codeTaking a look at the core match method, here is also a template method pattern:
// Start with the top-level class
public abstract class AbstractTypeHierarchyTraversingFilter implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
The template method, implemented by subclasses, returns false by default
if (matchSelf(metadataReader)) {
return true;
}
// Provide a hook that checks for a match by className
ClassMetadata metadata = metadataReader.getClassMetadata();
if (matchClassName(metadata.getClassName())) {
return true;
}
if (this.considerInherited) {
// If you consider inherited annotations, find the corresponding parent class
String superClassName = metadata.getSuperClassName();
if(superClassName ! =null) {
// See if the subclass has the logic to determine whether the parent class matches
Boolean superClassMatch = matchSuperClass(superClassName);
if(superClassMatch ! =null) {
// Write this logic directly to return the result
if (superClassMatch.booleanValue()) {
return true; }}else {
// If there is no logic to determine whether the parent class matches, the current matching logic is used directly
if (match(metadata.getSuperClassName(), metadataReaderFactory)) {
return true; }}}}if (this.considerInterfaces) {
// If you consider the annotation of the interface, find the corresponding interface, because there are multiple interfaces, so loop
// The logic is similar to that of the parent class
for (String ifc : metadata.getInterfaceNames()) {
Boolean interfaceMatch = matchInterface(ifc);
if(interfaceMatch ! =null) {
if (interfaceMatch.booleanValue()) {
return true; }}else {
if (match(ifc, metadataReaderFactory)) {
return true; }}}}return false; }}Copy the codeLook again at the core methods of AnnotationTypeFilter:
public class AnnotationTypeFilter extends AbstractTypeHierarchyTraversingFilter {
protected boolean matchSelf(MetadataReader metadataReader) {
AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
// Class has target annotations
return metadata.hasAnnotation(this.annotationType.getName()) ||
// If you can get it from the source annotation, then check to see if the class has the same source annotation as the target annotation
(this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName()));
}
protected Boolean matchSuperClass(String superClassName) {
return hasAnnotation(superClassName);
}
protected Boolean matchInterface(String interfaceName) {
return hasAnnotation(interfaceName);
}
@Nullable
protected Boolean hasAnnotation(String typeName) {
if (Object.class.getName().equals(typeName)) {
return false;
}
// The matching logic of the parent class and interface can only match JDK built-in classes (starting with Java)
// It seems that the default implementation should be used to support the annotations of the JSR standard
else if (typeName.startsWith("java")) {
/ /... Don't focus on
}
return null; }}Copy the codeAs you can see, our default AnnotationTypeFilter takes source annotations into account, so what exactly is a source annotation?
public @interface Controller {
@AliasFor(annotation = Component.class)
String value(a) default "";
}
public @interface Service {
@AliasFor(annotation = Component.class)
String value(a) default "";
}
public @interface Repository {
@AliasFor(annotation = Component.class)
String value(a) default "";
}
Copy the code@aliasfor (Annotation = component.class), which is why our default includeFilters only register an AnnotationTypeFilter of @Component, But we @service etc can also be scanned for the reason! The AnnotationTypeFilter we constructed takes source annotations into account!
4. Register public components
We’ve already seen how the context: Component-scan tag scans and supports the @Component annotation, but those of you who are paying attention may have noticed that now we can actually scan the @Component annotation. But how are those properties in our bean injected? How do @autowrite and @Resource annotations work? And what about @Configuration and @Bean?
These functions are actually done in the corresponding BeanPostProcessor, whose registration is injected during the parsing of our Context: Component-scan tag. If students have impression, should remember ComponentScanBeanDefinitionParser parse method, we create a scanner and scan again, also do some common components registered:
public BeanDefinition parse(Element element, ParserContext parserContext) {
// ...
// Get a scanner - this is very important, as we will see later
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
// Well, the scanner scans, so it looks like this method will scan the annotations
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
// Register some components
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
Copy the codeLet’s look at the registerComponents method:
protected void registerComponents( XmlReaderContext readerContext, Set
beanDefinitions, Element element)
{
// ...
// Register annotation config processors, if necessary.
boolean annotationConfig = true;
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
// Look at the annotation-config configuration, which is true by default
if (annotationConfig) {
Set<BeanDefinitionHolder> processorDefinitions =
// Register some Processors that support annotations
AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
// ...
}
// ...
}
Copy the codeSo which processors are registered?
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
// ...
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
/ / registered a ConfigurationClassPostProcessor here, as the name implies, this should be a support @ Configuration related annotation
if(! registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
// Register the logic registerPostProcessor
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
/ / register a AutowiredAnnotationBeanPostProcessor, used to handle @ Autowire, @ Value of annotation
if(! registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
// Here are the @resource, @postConstruct, @predestroy annotations supporting the JSR-250 specification
if(jsr250Present && ! registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
// Here is the BeanPostProcessor of JPA that supports annotation form
if(jpaPresent && ! registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Support the processor for spring-event related annotations, support for @eventListener
if(! registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// Support the processor for spring-event related annotations, support for @eventListener
if(! registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { RootBeanDefinition def =new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
Copy the codeAt this point, everything the context: Component-scan tag does is done. It basically creates a scanner to scan our basic beans that need to be registered, and then registers some processors that support the corresponding annotation functions. For these processors, I won’t go into the details of when each Processor is called and how it implements its functions. Those of you who are interested can find their own classes to see the implementation logic.
Later, when I talk about bean initialization logic and life cycle, I will talk about some of the Processor calls and internal logic in specific extension points. Hopefully, you will remember where these processors are registered.
Three, practice
All say that practice is the real knowledge, we follow the source analysis of such a big wave, but the fact is not as we analyze? To verify this, I’ll briefly use spring’s reserved extension points here.
1. Usecontext:component-scanScan custom annotations
We first need to define a custom annotation:
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyService {
}
Copy the codeThen configure the context: Component-scan tag:
<context:component-scan base-package="com.xiaoxizi.spring">
<context:include-filter type="annotation" expression="com.xiaoxizi.spring.annotation.MyService"/>
</context:component-scan>
Copy the codeAnnotate our business class:
@Data
@MyService
public class MyAnnoClass {
public String username = "xiaoxizi";
}
Copy the codeRun:
public void test1(a) {
applicationContext = new ClassPathXmlApplicationContext("spring.xml");
MyAnnoClass myAnnoClass = applicationContext.getBean(MyAnnoClass.class);
System.out.println(myAnnoClass);
}
Copy the codeOutput result:
MyAnnoClass(username=xiaoxizi)
Copy the codeOur custom annotations have been scanned and have successfully generated the beanDefinition and instantiated the bean!
2. Customize labels
Create a parser class for a specific tag. Let’s make it simple and inherit a class from spring:
public class SimpleBeanDefinitionParse extends AbstractSingleBeanDefinitionParser {
@Override
protected String getBeanClassName(final Element element) {
System.out.println("SimpleBeanDefinitionParse ... getBeanClassName()");
return element.getAttribute("className"); }}Copy the codeThen create a SimpleNamespaceHandler:
public class SimpleNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init(a) {
System.out.println("SimpleNamespaceHandler ... init()");
this.registerBeanDefinitionParser("simpleBean".newSimpleBeanDefinitionParse()); }}Copy the codeHandlers write to the meta-INF /spring.handlers file:
http\://www.xiaoxize.com/schema/simple=com.xiaoxizi.spring.tag.SimpleNamespaceHandler
Copy the codeXML configuration uses:
<xiaoxizi:simple className="com.xiaoxizi.spring.bean.MyAnnoClass"/>
<! The corresponding namespace of this tag is declared in the beans tag in the XML file header.
<beans xmlns:xiaoxizi="http://www.xiaoxize.com/schema/simple" . />
Copy the codeThe target class:
@Data
// @MyService
public class MyAnnoClass {
public String username = "xiaoxizi";
}
Copy the codeRun:
public void test1(a) {
applicationContext = new ClassPathXmlApplicationContext("spring.xml");
MyAnnoClass myAnnoClass = applicationContext.getBean(MyAnnoClass.class);
System.out.println(myAnnoClass);
}
Copy the codeOutput results – various errors, hahaha:
Caused by: org.xml.sax.SAXParseException; lineNumber: 21; columnNumber: 91; Cvc-complex-type.2.4.c: wildcard matching is complete, but cannot find declaration of element 'xiaoxizi:simple'.Copy the codeWhen we declare a namespace, we need to declare and define the corresponding XSD file (here I wrote an XSD file and introduced the workspace through the configuration of IDEA) like this:
<xiaoxizi:simple className="com.xiaoxizi.spring.bean.MyAnnoClass"/>
<! The corresponding namespace of this tag is declared in the beans tag in the XML file header.
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xiaoxizi="http://www.xiaoxize.com/schema/simple"
xsi:schemaLocation=" http://www.xiaoxize.com/schema/simple http://www.xiaoxize.com/schema/simple.xsd"
. />
Copy the codeAnd then it doesn’t work:
java.net.UnknownHostException: www.xiaoxize.com org.xml.sax.SAXParseException: schema_reference.4: Can't read the documents' http://www.xiaoxize.com/schema/simple.xsd ', the reason for 1) couldn't find the document; 2) Unable to read the document; The root element of the document is not < XSD :schema>. Caused by: org.xml.sax.SAXParseException; lineNumber: 21; columnNumber: 91; Cvc-complex-type.2.4.c: wildcard matching is complete, but cannot find declaration of element 'xiaoxizi:simple'.Copy the codeXSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file: XSD file Finally, I threw the XSD file to my server and adjusted the domain name. Finally, IT was ok:
SimpleNamespaceHandler ... init()
SimpleBeanDefinitionParse ... getBeanClassName()
MyAnnoClass(username=xiaoxizi)
Copy the codeYou’re done, so it’s pretty easy to customize tags.
Four,
1. Customize the label parsing process
- The first custom tag starts parsing, will be fromall
jarThe packageMETA-INF/spring.handlersFile load custom label namespace – correspondingNamespaceHandlerFully qualified name into memoryDefaultNamespaceHandlerResolver.handlerMappings - The same prefixCustom tags forFirst parsingIs instantiated
NamespaceHandlerAnd call itinit()Method and then put the custom tag namespace – correspondingNamespaceHandlerInstance in thehandlerMappings, the next time the same tag comes to parse, you can directly get the correspondingNamespaceHandlerThe instance - Use found
NamespaceHandlerThe instanceparseMethod parses custom tags springIt was very kind of you to prepare it for usNamespaceHandlerAssociated template classesNamespaceHandlerSupportIf our custom processor inherits the template, it only needs to be in theinitMethod to inject corresponding values for specific tagsBeanDefinitionParserorBeanDefinitionDecoratorYou can implement the function
2. context:component-scanWhat did
- Custom labels
context:component-scanThe corresponding parser isComponentScanBeanDefinitionParser(We won’t bore you with the process). - The parser’s
parseMethod, we create one from the attribute configured for the tagThe scannerClassPathBeanDefinitionScanner - By default, we register one
@ComponentannotationsAnnotationTypeFilterAnd registered to the scannerincludeFiltersIn the - Then the scanner begins to scan
basePackageUnder all thejavaClass, and find all that do not need to be excluded (excludeFilters) candidate class (includeFilters), and generate one for itbeanDefinitionIf the class is a validbeanDefinition(non-interface those judgments), then these will bebeanDefinitionCollect and return - For all the candidates
beanDefinition, the scanner will scan further on the class@Lazy,@Primary,@DependsOnAnd then set the value tobeanDefinitionIn the corresponding property of - And the last step, all the legitimate ones that we’ve scanned
beanDefinitionRegistered toIOCThe container - Due to the
@Componentis@Service,@ControllerAnd so on the source annotations, so@ServiceThe classes marked by these annotations will also beincludeFiltersScan to - Register a series of pairs
@Configuration,@Autowired,@ResourceSuch as annotations to supportProcessor
Five, the other
Simple XSD files used in practice
<xsd:attribute name="className" type="xsd:string"></xsd:attribute>
<xsd:schema xmlns="Http://your IP address or domain name /simple"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="Http://your IP address or domain name /simple"
elementFormDefault="qualified">
<xsd:element name="simple">
<xsd:complexType>
<xsd:attribute name="className" type="xsd:string"></xsd:attribute>
<xsd:attribute name="id" type="xsd:string"></xsd:attribute>
</xsd:complexType>
</xsd:element>
</xsd:schema>
Copy the codeAfter writing this article, I feel I have to squeeze myself dry. It is difficult to write a lot of words… And there is no copy saved, the update will be slower
Creation is not easy, reprint please note the author: nuggets @ small xizi + source link ~
If you want to learn more about Spring source code, click on the rest of the Spring series to parse line by line
٩(* ఠO ఠ)=3⁼³ milk ₃ ³ ₃ ₃ tellurab…
This is the new blogger Xiao Xizi, big guys have seen this, the top left corner of the “like” before you go ~~