Java tutorial
/* * Copyright 2009-2012 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 i 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 com.gzj.tulip.jade.context.spring; import java.io.IOException; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; import com.gzj.tulip.jade.annotation.DAO; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.BeanDefinitionStoreException; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.ResourceLoaderAware; import org.springframework.context.annotation.ScannedGenericBeanDefinition; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternUtils; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.core.type.filter.AnnotationTypeFilter; import org.springframework.core.type.filter.TypeFilter; import org.springframework.util.Assert; /** * {@link JadeComponentProvider}jar?JadeDAO? * * @author Mark Fisher * @author Juergen Hoeller * @author Ramnivas Laddad * @author [qieqie.wang@gmail.com] * @author [in355hz@gmail.com] * * @see JadeComponentProvider * @see org.springframework.core.type.classreading.MetadataReaderFactory * @see org.springframework.core.type.AnnotationMetadata * @see ScannedGenericBeanDefinition */ public class JadeComponentProvider implements ResourceLoaderAware { /** * */ private final Log logger = LogFactory.getLog(JadeComponentProvider.class); /** * */ private String resourcePattern = "**/*DAO.class"; /** * */ private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(); /** * */ private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver); /** * */ private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>(); /** * */ private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>(); /** * */ public JadeComponentProvider() { includeFilters.add(new AnnotationTypeFilter(DAO.class)); } /** * Set the ResourceLoader to use for resource locations. This will * typically be a ResourcePatternResolver implementation. * <p> * Default is PathMatchingResourcePatternResolver, also capable of * resource pattern resolving through the ResourcePatternResolver * interface. * * @see org.springframework.core.io.support.ResourcePatternResolver * @see org.springframework.core.io.support.PathMatchingResourcePatternResolver */ public void setResourceLoader(ResourceLoader resourceLoader) { this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader); } /** * Return the ResourceLoader that this component provider uses. */ public final ResourceLoader getResourceLoader() { return this.resourcePatternResolver; } /** * Set the resource pattern to use when scanning the classpath. This * value will be appended to each base package name. * * @see #findCandidateComponents(String) */ public void setResourcePattern(String resourcePattern) { Assert.notNull(resourcePattern, "'resourcePattern' must not be null"); this.resourcePattern = resourcePattern; } /** * Add an exclude type filter to the <i>front</i> of the exclusion * list. */ public void addExcludeFilter(TypeFilter excludeFilter) { this.excludeFilters.add(0, excludeFilter); } /** * jar?JadeDAO? * <p> * ?BeanDefinition?DAO?? * {@link BeanDefinition#getBeanClassName()} DAO??? * <p> * BeanDefinition??Spring??? */ public Set<BeanDefinition> findCandidateComponents(String uriPrefix) { if (!uriPrefix.endsWith("/")) { uriPrefix = uriPrefix + "/"; } Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>(); try { String packageSearchPath = uriPrefix + this.resourcePattern; boolean traceEnabled = logger.isDebugEnabled(); boolean debugEnabled = logger.isDebugEnabled(); Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath); if (debugEnabled) { logger.debug("[jade/find] find " + resources.length + " resources for " + packageSearchPath); } for (int i = 0; i < resources.length; i++) { Resource resource = resources[i]; if (traceEnabled) { logger.trace("[jade/find] scanning " + resource); } // resourcePatternResolver.getResources?classPathResourcesmetadataReadergetInputStreamnull // ???exists if (!resource.exists()) { if (debugEnabled) { logger.debug("Ignored because not exists:" + resource); } } else if (resource.isReadable()) { MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource); if (isCandidateComponent(metadataReader)) { ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); if (sbd.getMetadata().isInterface() && sbd.getMetadata().isIndependent()) { if (debugEnabled) { logger.debug("Identified candidate component class: " + resource); } candidates.add(sbd); } else { if (traceEnabled) { logger.trace("Ignored because not a interface top-level class: " + resource); } } } else { if (traceEnabled) { logger.trace("Ignored because not matching any filter: " + resource); } } } else { if (traceEnabled) { logger.trace("Ignored because not readable: " + resource); } } } } catch (IOException ex) { throw new BeanDefinitionStoreException("I/O failure during jade scanning", ex); } return candidates; } /** * Determine whether the given class does not match any exclude filter * and does match at least one include filter. * * @param metadataReader the ASM ClassReader for the class * @return whether the class qualifies as a candidate component */ protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { for (TypeFilter tf : this.excludeFilters) { if (tf.match(metadataReader, this.metadataReaderFactory)) { return false; } } for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, this.metadataReaderFactory)) { return true; } } return false; } }