- 浏览: 11710406 次
文章分类
最新评论
-
wahahachuang8:
我觉得这种东西自己开发太麻烦了,就别自己捣鼓了,找个第三方,方 ...
WebSocket和node.js -
xhpscdx:
写的这么详细,全面,对架构师的工作职责,个人能力都进行了梳理。 ...
架构师之路---王泽宾谈架构师的职责 -
xgbzsc:
是http://www.haoservice.com 吗?
android WIFI定位 -
lehehe:
http://www.haoservice.com/docs/ ...
android WIFI定位 -
lehehe:
http://www.haoservice.com/docs/ ...
android WIFI定位
spring2.5开始的新特性:packagesToScan路径解析分析
1. <property name="packagesToScan" value="com.xxx.entity" />, 会解析成"classpath*:com/xxx/entity**/*.class",这个路径可以找出com/xxx/entity根目录下的类文件
2. <property name="packagesToScan" value="com.xxx.entity.*" />, 会解析成"classpath*:com/xxx/entity/***/*.class",这个路径可以找出com/xxx/entity根目录下一级子目录中的类文件,如com/xxx/entity/son/Hi.class ,而不能找出com/xxx/entity目录下的类文件。
再往后:
2. <property name="packagesToScan" value="com.xxx.entity.*" />, 会解析成"classpath*:com/xxx/entity/***/*.class",这个路径可以找出com/xxx/entity根目录下一级子目录中的类文件,如com/xxx/entity/son/Hi.class ,而不能找出com/xxx/entity目录下的类文件。
3. <property name="packagesToScan" value="com.xxx.entity." />(注意最后的点) , 会转换成"classpath*:com/xxx/entity/**/*.class",这个路径可以找出com/xxx/entity根目录下及其子孙目录下所有的类文件. 一般来讲,这些就是我们要的文件。
上面是网友得出的结论,尚未有时间验证。
自己大致了解了一下.看了它的源码我们可以看到。
前缀默认为:"classpath*:"
后缀默认为:"/**/*.class"
PathMatchingResourcePatternResolver类中
if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
把location去掉了前缀:"classpath*:"
关键是中间的解析
ClassUtil类中:
public static String convertClassNameToResourcePath(String className) { Assert.notNull(className, "Class name must not be null"); return className.replace('.', '/'); }
我们可以看到它把.解析成了/
第一种则为:
com/tudou/entity/**/*.class
第二种则为:
com/tudou/entity/*/**/*.class
第三种则为:
com/tudou/entity//**/*.class
接下来就是判断了:
package com.tudou.t2; /** * 测试spring源码内packageToScan的方法 * @author tudou * */ public class packageToScans { public static void main(String[] args) { String path1="classpath*:com/tudou/entity/**/*.class"; String path2="classpath*:com/tudou/entity/*/**/*.class"; String path3="classpath*:com/tudou/entity//**/*.class"; String s1=determineRootDir(path1); String s2=determineRootDir(path2); String s3=determineRootDir(path3); //打印得成s1,s2,s3的值均为:classpath*:下面截取可以得到它的完整包名+类名 String subPattern1 = path1.substring(s1.length()); String subPattern2 = path1.substring(s2.length()); String subPattern3 = path1.substring(s3.length()); System.out.println(subPattern1); System.out.println(subPattern2); System.out.println(subPattern3); } protected static String determineRootDir(String location) { int prefixEnd = location.indexOf(":") + 1; int rootDirEnd = location.length(); while (rootDirEnd > prefixEnd) { rootDirEnd = location.lastIndexOf('/', rootDirEnd - 2) + 1; } if (rootDirEnd == 0) { rootDirEnd = prefixEnd; } return location.substring(0, rootDirEnd); } }
再往后:
我们可以看到它会去jar,zip,路径里面去判断不同的路径。可谓是相当全面了!当然我们只管看路径寻找我们的类即可即可。
取绝对路径。
spring源码如下:
private static final String RESOURCE_PATTERN = "/**/*.class";其中:String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
protected void scanPackages(AnnotationConfiguration config) {if (this.packagesToScan != null) {try {for (String pkg : this.packagesToScan) {String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN;Resource[] resources = this.resourcePatternResolver.getResources(pattern);MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);for (Resource resource : resources) {if (resource.isReadable()) {MetadataReader reader = readerFactory.getMetadataReader(resource);String className = reader.getClassMetadata().getClassName();if (matchesFilter(reader, readerFactory)) {config.addAnnotatedClass(this.resourcePatternResolver.getClassLoader().loadClass(className));}}}}}catch (IOException ex) {throw new MappingException("Failed to scan classpath for unlisted classes", ex);}catch (ClassNotFoundException ex) {throw new MappingException("Failed to load annotated classes from classpath", ex);}}}public static String convertClassNameToResourcePath(String className) { Assert.notNull(className, "Class name must not be null"); return className.replace('.', '/'); }ResourcePatternResolver类中主要代码: package org.springframework.core.io.support; import java.io.File; import java.io.IOException; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.net.JarURLConnection; import java.net.URISyntaxException; import java.net.URL; import java.net.URLConnection; import java.util.Collections; import java.util.Enumeration; import java.util.LinkedHashSet; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.core.io.DefaultResourceLoader; import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.io.UrlResource; import org.springframework.core.io.VfsResource; import org.springframework.util.AntPathMatcher; import org.springframework.util.Assert; import org.springframework.util.PathMatcher; import org.springframework.util.ReflectionUtils; import org.springframework.util.ResourceUtils; import org.springframework.util.StringUtils; public class PathMatchingResourcePatternResolver implements ResourcePatternResolver { private static final Log logger = LogFactory.getLog(PathMatchingResourcePatternResolver.class); private static Method equinoxResolveMethod; static { // Detect Equinox OSGi (e.g. on WebSphere 6.1) try { Class<?> fileLocatorClass = PathMatchingResourcePatternResolver.class.getClassLoader().loadClass( "org.eclipse.core.runtime.FileLocator"); equinoxResolveMethod = fileLocatorClass.getMethod("resolve", URL.class); logger.debug("Found Equinox FileLocator for OSGi bundle URL resolution"); } catch (Throwable ex) { equinoxResolveMethod = null; } } private final ResourceLoader resourceLoader; private PathMatcher pathMatcher = new AntPathMatcher(); /** * Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader. * <p>ClassLoader access will happen via the thread context class loader. * @see org.springframework.core.io.DefaultResourceLoader */ public PathMatchingResourcePatternResolver() { this.resourceLoader = new DefaultResourceLoader(); } /** * Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader. * @param classLoader the ClassLoader to load classpath resources with, * or <code>null</code> for using the thread context class loader * at the time of actual resource access * @see org.springframework.core.io.DefaultResourceLoader */ public PathMatchingResourcePatternResolver(ClassLoader classLoader) { this.resourceLoader = new DefaultResourceLoader(classLoader); } /** * Create a new PathMatchingResourcePatternResolver. * <p>ClassLoader access will happen via the thread context class loader. * @param resourceLoader the ResourceLoader to load root directories and * actual resources with */ public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) { Assert.notNull(resourceLoader, "ResourceLoader must not be null"); this.resourceLoader = resourceLoader; } /** * Return the ResourceLoader that this pattern resolver works with. */ public ResourceLoader getResourceLoader() { return this.resourceLoader; } /** * Return the ClassLoader that this pattern resolver works with * (never <code>null</code>). */ public ClassLoader getClassLoader() { return getResourceLoader().getClassLoader(); } /** * Set the PathMatcher implementation to use for this * resource pattern resolver. Default is AntPathMatcher. * @see org.springframework.util.AntPathMatcher */ public void setPathMatcher(PathMatcher pathMatcher) { Assert.notNull(pathMatcher, "PathMatcher must not be null"); this.pathMatcher = pathMatcher; } /** * Return the PathMatcher that this resource pattern resolver uses. */ public PathMatcher getPathMatcher() { return this.pathMatcher; } public Resource getResource(String location) { return getResourceLoader().getResource(location); } public Resource[] getResources(String locationPattern) throws IOException { Assert.notNull(locationPattern, "Location pattern must not be null"); if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) { // a class path resource (multiple resources for same name possible) if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) { // a class path resource pattern return findPathMatchingResources(locationPattern); } else { // all class path resources with the given name return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length())); } } else { // Only look for a pattern after a prefix here // (to not get fooled by a pattern symbol in a strange prefix). int prefixEnd = locationPattern.indexOf(":") + 1; if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) { // a file pattern return findPathMatchingResources(locationPattern); } else { // a single resource with the given name return new Resource[] {getResourceLoader().getResource(locationPattern)}; } } } /** * Find all class location resources with the given location via the ClassLoader. * @param location the absolute path within the classpath * @return the result as Resource array * @throws IOException in case of I/O errors * @see java.lang.ClassLoader#getResources * @see #convertClassLoaderURL */ protected Resource[] findAllClassPathResources(String location) throws IOException { String path = location; if (path.startsWith("/")) { path = path.substring(1); } Enumeration<URL> resourceUrls = getClassLoader().getResources(path); Set<Resource> result = new LinkedHashSet<Resource>(16); while (resourceUrls.hasMoreElements()) { URL url = resourceUrls.nextElement(); result.add(convertClassLoaderURL(url)); } return result.toArray(new Resource[result.size()]); } /** * Convert the given URL as returned from the ClassLoader into a Resource object. * <p>The default implementation simply creates a UrlResource instance. * @param url a URL as returned from the ClassLoader * @return the corresponding Resource object * @see java.lang.ClassLoader#getResources * @see org.springframework.core.io.Resource */ protected Resource convertClassLoaderURL(URL url) { return new UrlResource(url); } /** * Find all resources that match the given location pattern via the * Ant-style PathMatcher. Supports resources in jar files and zip files * and in the file system. * @param locationPattern the location pattern to match * @return the result as Resource array * @throws IOException in case of I/O errors * @see #doFindPathMatchingJarResources * @see #doFindPathMatchingFileResources * @see org.springframework.util.PathMatcher */ protected Resource[] findPathMatchingResources(String locationPattern) throws IOException { String rootDirPath = determineRootDir(locationPattern); String subPattern = locationPattern.substring(rootDirPath.length()); Resource[] rootDirResources = getResources(rootDirPath); Set<Resource> result = new LinkedHashSet<Resource>(16); for (Resource rootDirResource : rootDirResources) { rootDirResource = resolveRootDirResource(rootDirResource); if (isJarResource(rootDirResource)) { result.addAll(doFindPathMatchingJarResources(rootDirResource, subPattern)); } else if (rootDirResource.getURL().getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) { result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirResource, subPattern, getPathMatcher())); } else { result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern)); } } if (logger.isDebugEnabled()) { logger.debug("Resolved location pattern [" + locationPattern + "] to resources " + result); } return result.toArray(new Resource[result.size()]); } /** * Determine the root directory for the given location. * <p>Used for determining the starting point for file matching, * resolving the root directory location to a <code>java.io.File</code> * and passing it into <code>retrieveMatchingFiles</code>, with the * remainder of the location as pattern. * <p>Will return "/WEB-INF/" for the pattern "/WEB-INF/*.xml", * for example. * @param location the location to check * @return the part of the location that denotes the root directory * @see #retrieveMatchingFiles */ protected String determineRootDir(String location) { int prefixEnd = location.indexOf(":") + 1; int rootDirEnd = location.length(); while (rootDirEnd > prefixEnd && getPathMatcher().isPattern(location.substring(prefixEnd, rootDirEnd))) { rootDirEnd = location.lastIndexOf('/', rootDirEnd - 2) + 1; } if (rootDirEnd == 0) { rootDirEnd = prefixEnd; } return location.substring(0, rootDirEnd); } /** * Resolve the specified resource for path matching. * <p>The default implementation detects an Equinox OSGi "bundleresource:" * / "bundleentry:" URL and resolves it into a standard jar file URL that * can be traversed using Spring's standard jar file traversal algorithm. * @param original the resource to resolve * @return the resolved resource (may be identical to the passed-in resource) * @throws IOException in case of resolution failure */ protected Resource resolveRootDirResource(Resource original) throws IOException { if (equinoxResolveMethod != null) { URL url = original.getURL(); if (url.getProtocol().startsWith("bundle")) { return new UrlResource((URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, url)); } } return original; } /** * Return whether the given resource handle indicates a jar resource * that the <code>doFindPathMatchingJarResources</code> method can handle. * <p>The default implementation checks against the URL protocols * "jar", "zip" and "wsjar" (the latter are used by BEA WebLogic Server * and IBM WebSphere, respectively, but can be treated like jar files). * @param resource the resource handle to check * (usually the root directory to start path matching from) * @see #doFindPathMatchingJarResources * @see org.springframework.util.ResourceUtils#isJarURL */ protected boolean isJarResource(Resource resource) throws IOException { return ResourceUtils.isJarURL(resource.getURL()); } /** * Find all resources in jar files that match the given location pattern * via the Ant-style PathMatcher. * @param rootDirResource the root directory as Resource * @param subPattern the sub pattern to match (below the root directory) * @return the Set of matching Resource instances * @throws IOException in case of I/O errors * @see java.net.JarURLConnection * @see org.springframework.util.PathMatcher */ protected Set<Resource> doFindPathMatchingJarResources(Resource rootDirResource, String subPattern) throws IOException { URLConnection con = rootDirResource.getURL().openConnection(); JarFile jarFile; String jarFileUrl; String rootEntryPath; boolean newJarFile = false; if (con instanceof JarURLConnection) { // Should usually be the case for traditional JAR files. JarURLConnection jarCon = (JarURLConnection) con; jarCon.setUseCaches(false); jarFile = jarCon.getJarFile(); jarFileUrl = jarCon.getJarFileURL().toExternalForm(); JarEntry jarEntry = jarCon.getJarEntry(); rootEntryPath = (jarEntry != null ? jarEntry.getName() : ""); } else { // No JarURLConnection -> need to resort to URL file parsing. // We'll assume URLs of the format "jar:path!/entry", with the protocol // being arbitrary as long as following the entry format. // We'll also handle paths with and without leading "file:" prefix. String urlFile = rootDirResource.getURL().getFile(); int separatorIndex = urlFile.indexOf(ResourceUtils.JAR_URL_SEPARATOR); if (separatorIndex != -1) { jarFileUrl = urlFile.substring(0, separatorIndex); rootEntryPath = urlFile.substring(separatorIndex + ResourceUtils.JAR_URL_SEPARATOR.length()); jarFile = getJarFile(jarFileUrl); } else { jarFile = new JarFile(urlFile); jarFileUrl = urlFile; rootEntryPath = ""; } newJarFile = true; } try { if (logger.isDebugEnabled()) { logger.debug("Looking for matching resources in jar file [" + jarFileUrl + "]"); } if (!"".equals(rootEntryPath) && !rootEntryPath.endsWith("/")) { // Root entry path must end with slash to allow for proper matching. // The Sun JRE does not return a slash here, but BEA JRockit does. rootEntryPath = rootEntryPath + "/"; } Set<Resource> result = new LinkedHashSet<Resource>(8); for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) { JarEntry entry = entries.nextElement(); String entryPath = entry.getName(); if (entryPath.startsWith(rootEntryPath)) { String relativePath = entryPath.substring(rootEntryPath.length()); if (getPathMatcher().match(subPattern, relativePath)) { result.add(rootDirResource.createRelative(relativePath)); } } } return result; } finally { // Close jar file, but only if freshly obtained - // not from JarURLConnection, which might cache the file reference. if (newJarFile) { jarFile.close(); } } } /** * Resolve the given jar file URL into a JarFile object. */ protected JarFile getJarFile(String jarFileUrl) throws IOException { if (jarFileUrl.startsWith(ResourceUtils.FILE_URL_PREFIX)) { try { return new JarFile(ResourceUtils.toURI(jarFileUrl).getSchemeSpecificPart()); } catch (URISyntaxException ex) { // Fallback for URLs that are not valid URIs (should hardly ever happen). return new JarFile(jarFileUrl.substring(ResourceUtils.FILE_URL_PREFIX.length())); } } else { return new JarFile(jarFileUrl); } } /** * Find all resources in the file system that match the given location pattern * via the Ant-style PathMatcher. * @param rootDirResource the root directory as Resource * @param subPattern the sub pattern to match (below the root directory) * @return the Set of matching Resource instances * @throws IOException in case of I/O errors * @see #retrieveMatchingFiles * @see org.springframework.util.PathMatcher */ protected Set<Resource> doFindPathMatchingFileResources(Resource rootDirResource, String subPattern) throws IOException { File rootDir; try { rootDir = rootDirResource.getFile().getAbsoluteFile(); } catch (IOException ex) { if (logger.isWarnEnabled()) { logger.warn("Cannot search for matching files underneath " + rootDirResource + " because it does not correspond to a directory in the file system", ex); } return Collections.emptySet(); } return doFindMatchingFileSystemResources(rootDir, subPattern); } /** * Find all resources in the file system that match the given location pattern * via the Ant-style PathMatcher. * @param rootDir the root directory in the file system * @param subPattern the sub pattern to match (below the root directory) * @return the Set of matching Resource instances * @throws IOException in case of I/O errors * @see #retrieveMatchingFiles * @see org.springframework.util.PathMatcher */ protected Set<Resource> doFindMatchingFileSystemResources(File rootDir, String subPattern) throws IOException { if (logger.isDebugEnabled()) { logger.debug("Looking for matching resources in directory tree [" + rootDir.getPath() + "]"); } Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern); Set<Resource> result = new LinkedHashSet<Resource>(matchingFiles.size()); for (File file : matchingFiles) { result.add(new FileSystemResource(file)); } return result; } /** * Retrieve files that match the given path pattern, * checking the given directory and its subdirectories. * @param rootDir the directory to start from * @param pattern the pattern to match against, * relative to the root directory * @return the Set of matching File instances * @throws IOException if directory contents could not be retrieved */ protected Set<File> retrieveMatchingFiles(File rootDir, String pattern) throws IOException { if (!rootDir.exists()) { // Silently skip non-existing directories. if (logger.isDebugEnabled()) { logger.debug("Skipping [" + rootDir.getAbsolutePath() + "] because it does not exist"); } return Collections.emptySet(); } if (!rootDir.isDirectory()) { // Complain louder if it exists but is no directory. if (logger.isWarnEnabled()) { logger.warn("Skipping [" + rootDir.getAbsolutePath() + "] because it does not denote a directory"); } return Collections.emptySet(); } if (!rootDir.canRead()) { if (logger.isWarnEnabled()) { logger.warn("Cannot search for matching files underneath directory [" + rootDir.getAbsolutePath() + "] because the application is not allowed to read the directory"); } return Collections.emptySet(); } String fullPattern = StringUtils.replace(rootDir.getAbsolutePath(), File.separator, "/"); if (!pattern.startsWith("/")) { fullPattern += "/"; } fullPattern = fullPattern + StringUtils.replace(pattern, File.separator, "/"); Set<File> result = new LinkedHashSet<File>(8); doRetrieveMatchingFiles(fullPattern, rootDir, result); return result; } /** * Recursively retrieve files that match the given pattern, * adding them to the given result list. * @param fullPattern the pattern to match against, * with prepended root directory path * @param dir the current directory * @param result the Set of matching File instances to add to * @throws IOException if directory contents could not be retrieved */ protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) throws IOException { if (logger.isDebugEnabled()) { logger.debug("Searching directory [" + dir.getAbsolutePath() + "] for files matching pattern [" + fullPattern + "]"); } File[] dirContents = dir.listFiles(); if (dirContents == null) { if (logger.isWarnEnabled()) { logger.warn("Could not retrieve contents of directory [" + dir.getAbsolutePath() + "]"); } return; } for (File content : dirContents) { String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/"); if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) { if (!content.canRead()) { if (logger.isDebugEnabled()) { logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() + "] because the application is not allowed to read the directory"); } } else { doRetrieveMatchingFiles(fullPattern, content, result); } } if (getPathMatcher().match(fullPattern, currPath)) { result.add(content); } } } /** * Inner delegate class, avoiding a hard JBoss VFS API dependency at runtime. */ private static class VfsResourceMatchingDelegate { public static Set<Resource> findMatchingResources( Resource rootResource, String locationPattern, PathMatcher pathMatcher) throws IOException { Object root = VfsPatternUtils.findRoot(rootResource.getURL()); PatternVirtualFileVisitor visitor = new PatternVirtualFileVisitor(VfsPatternUtils.getPath(root), locationPattern, pathMatcher); VfsPatternUtils.visit(root, visitor); return visitor.getResources(); } } /** * VFS visitor for path matching purposes. */ private static class PatternVirtualFileVisitor implements InvocationHandler { private final String subPattern; private final PathMatcher pathMatcher; private final String rootPath; private final Set<Resource> resources = new LinkedHashSet<Resource>(); public PatternVirtualFileVisitor(String rootPath, String subPattern, PathMatcher pathMatcher) { this.subPattern = subPattern; this.pathMatcher = pathMatcher; this.rootPath = (rootPath.length() == 0 || rootPath.endsWith("/") ? rootPath : rootPath + "/"); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName(); if (Object.class.equals(method.getDeclaringClass())) { if (methodName.equals("equals")) { // Only consider equal when proxies are identical. return (proxy == args[0]); } else if (methodName.equals("hashCode")) { return System.identityHashCode(proxy); } } else if ("getAttributes".equals(methodName)) { return getAttributes(); } else if ("visit".equals(methodName)) { visit(args[0]); return null; } else if ("toString".equals(methodName)) { return toString(); } throw new IllegalStateException("Unexpected method invocation: " + method); } public void visit(Object vfsResource) { if (this.pathMatcher.match(this.subPattern, VfsPatternUtils.getPath(vfsResource).substring(this.rootPath.length()))) { this.resources.add(new VfsResource(vfsResource)); } } public Object getAttributes() { return VfsPatternUtils.getVisitorAttribute(); } public Set<Resource> getResources() { return this.resources; } @SuppressWarnings("unused") public int size() { return this.resources.size(); } public String toString() { StringBuilder sb = new StringBuilder(); sb.append("sub-pattern: ").append(this.subPattern); sb.append(", resources: ").append(this.resources); return sb.toString(); } } }
CachingMetadataReaderFactory类核心代码:package org.springframework.core.type.classreading; import java.io.IOException; import java.util.LinkedHashMap; import java.util.Map; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; /** * Caching implementation of the {@link MetadataReaderFactory} interface, * caching {@link MetadataReader} per Spring {@link Resource} handle * (i.e. per ".class" file). * * @author Juergen Hoeller * @author Costin Leau * @since 2.5 */ public class CachingMetadataReaderFactory extends SimpleMetadataReaderFactory { /** Default maximum number of entries for the MetadataReader cache: 256 */ public static final int DEFAULT_CACHE_LIMIT = 256; private volatile int cacheLimit = DEFAULT_CACHE_LIMIT; private final Map<Resource, MetadataReader> classReaderCache = new LinkedHashMap<Resource, MetadataReader>(DEFAULT_CACHE_LIMIT, 0.75f, true) { @Override protected boolean removeEldestEntry(Map.Entry<Resource, MetadataReader> eldest) { return size() > getCacheLimit(); } }; /** * Create a new CachingMetadataReaderFactory for the default class loader. */ public CachingMetadataReaderFactory() { super(); } /** * Create a new CachingMetadataReaderFactory for the given resource loader. * @param resourceLoader the Spring ResourceLoader to use * (also determines the ClassLoader to use) */ public CachingMetadataReaderFactory(ResourceLoader resourceLoader) { super(resourceLoader); } /** * Create a new CachingMetadataReaderFactory for the given class loader. * @param classLoader the ClassLoader to use */ public CachingMetadataReaderFactory(ClassLoader classLoader) { super(classLoader); } /** * Specify the maximum number of entries for the MetadataReader cache. * Default is 256. */ public void setCacheLimit(int cacheLimit) { this.cacheLimit = cacheLimit; } /** * Return the maximum number of entries for the MetadataReader cache. */ public int getCacheLimit() { return this.cacheLimit; } @Override public MetadataReader getMetadataReader(Resource resource) throws IOException { if (getCacheLimit() <= 0) { return super.getMetadataReader(resource); } synchronized (this.classReaderCache) { MetadataReader metadataReader = this.classReaderCache.get(resource); if (metadataReader == null) { metadataReader = super.getMetadataReader(resource); this.classReaderCache.put(resource, metadataReader); } return metadataReader; } } }
相关推荐
《Spring2.5集成JPA深度解析》 在Java企业级开发中,Spring框架与Java Persistence API(JPA)的整合已经成为主流的持久层解决方案。本文将深入探讨Spring 2.5版本如何与JPA进行集成,以及在实际项目中的应用和配置...
标题 "Spring2.5 + JPA(Hibernate)实现" 指的是在Spring框架的2.5版本中集成Java Persistence API (JPA),并利用Hibernate作为JPA的实现。这通常是为了在一个基于Spring的应用程序中实现数据持久化,提供一个灵活、...
### Java8 + Tomcat8 + Struts2.5 + Spring4.3 + Hibernate5.2 框架搭建详细过程 #### 一、环境配置与准备 在搭建一个基于Java8 + Tomcat8 + Struts2.5 + Spring4.3 + Hibernate5.2 的项目前,首先需要对开发环境...
文中用的框架版本:spring 3,hibernate 3,没有的,自己上网下。 先说web.xml配置: [java] view plaincopy 01.<?xml version="1.0" encoding="UTF-8"?> 02.<web-app xmlns:xsi=...
### Spring MVC + Hibernate4 整合知识点解析 #### 一、Spring MVC 与 Hibernate 整合概述 在软件开发领域,尤其是Java Web应用开发中,框架间的整合是提高开发效率和系统性能的重要手段之一。本篇文章主要介绍了...
Spring Data JPA 1.1 引入了一些新特性,例如增强的分页支持。使用 `Pageable` 接口可以实现高效的分页查询: ```java Page<User> users = userRepository.findAll(PageRequest.of(page, size, Sort.by(Sort....
Spring框架的核心特性包括依赖注入(DI)、面向切面编程(AOP)以及模块化设计。 - **依赖注入(DI)**:这是一种设计模式,旨在提高代码的可重用性、灵活性和可测试性。通过依赖注入,对象在其创建过程中不会直接...
在实际项目中,结合Spring的IoC(控制反转)和AOP(面向切面编程)特性,可以构建出高效、可维护的企业级应用。通过阅读和研究`Spring4.1-HibernateAnnotation-master`这个项目的源代码,你可以更深入地理解这些概念...
1. **Spring框架**:Spring是一个开源的Java平台,它提供了全面的应用程序开发模型,包括事务管理、数据访问集成、Web应用开发等。核心特性包括依赖注入(DI)和面向切面编程(AOP),这些都旨在减少代码的耦合度,...
4. spring-core.jar:Spring框架的基础,包含核心工具类。 5. spring-expression.jar:用于在运行时解析表达式。 接下来,我们转向Hibernate。Hibernate作为一个ORM框架,它的主要任务是将Java对象与数据库表进行...
- spring-context:Spring的核心模块,提供IoC容器和AOP支持。 - spring-web:Spring的Web支持模块,用于处理Web相关的任务。 **3. 配置Spring容器** 在Spring的配置文件(如`applicationContext.xml`)中,需要...
3. **配置Spring**:在Spring配置文件中,你需要配置数据源(如使用`<bean id="dataSource" ...>`),然后配置实体扫描路径(`packagesToScan`属性)和`LocalContainerEntityManagerFactoryBean`以创建...
然而,当实体类存在于外部jar中时,Spring默认的类路径扫描机制可能无法正确解析这些jar中的类。这是因为Spring的`ClassPathScanningCandidateComponentProvider`类主要针对类路径下的目录和文件进行扫描,而不是...
5. **使用HibernateTemplate或SessionFactoryBean**:Spring提供了HibernateTemplate和HibernateSessionFactoryBean,方便在Service层进行数据库操作。HibernateTemplate封装了一些常用的Hibernate操作,如save、...
2. **配置OpenJPA**:在Spring的配置文件(如`applicationContext.xml`)中,你需要配置OpenJPA的数据源、实体扫描路径以及JPA的属性: ```xml <!-- 数据库连接配置 --> ...
Spring是一个全面的后端开发框架,提供了依赖注入、AOP(面向切面编程)、MVC(模型-视图-控制器)等特性,使得代码更加模块化和易于管理。而Hibernate则是一个强大的ORM(对象关系映射)框架,能够将数据库操作转化...
Spring是一个全面的后端应用程序框架,提供了依赖注入、AOP(面向切面编程)、MVC(模型-视图-控制器)等核心特性,而Hibernate则是一个优秀的对象关系映射(ORM)工具,用于简化数据库操作。本文将深入探讨如何在一...
《Spring配置文件详解》 Spring框架的核心之一就是其配置文件,它是实现依赖注入(Dependency Injection,...此外,不断关注Spring的版本更新,利用新特性如`setPackagesToScan`,能进一步提升开发效率和代码质量。