Automatic scanning of spring configuration files and resource in Web. XML classpath*: The difference from classpath:

Source: Internet
Author: User
Tags naming convention

Ext.: http://blog.sina.com.cn/s/blog_a2f090ae0101e18d.html

http://blog.csdn.net/kkdelta/article/details/5507799

First, configure the listener listener in Web. XML to get spring to get it automatically. The following code is added:

<listener> <listener-class>org.springframework.web.context.contextloaderlistener</listener-class > </listener>
As long as it starts the service this configuration will default to load our configuration file, automatically initializes the beans inside. By default it will go to the/web-inf/applicationcontext.xml file. If you want to put the configuration file under Classpath, that is, the SRC directory, you need to specify the path, the specific code is as follows:
<!--Context Configuration locations for Spring XML files---
<context-param> <param-name> Contextconfiglocation</param-name>
<!--<param-value>/web-inf/applicationcontext-*.xml, Classpath*:applicationcontext-*.xml</param-value>
-<!--add your config file under SRC, The naming convention is: Applicationcontext-*.xml form, you can configure it in the following ways-
<param-value>classpath:applicationcontext-*.xml </param-value>
</context-param>

This way, when the server starts, it will automatically go to Classpa, which is the SRC directory, to find all the following: Applicationcontext-*.xml files and initialize them.

Spring Load Resource classpath*: Difference from classpath:

Spring can load files from classpath, such as the bean's definition file, by specifying classpath*: With the classpath: prefix plus path. classpath*: Appears to load the same file from multiple jar files. Classpath: Only the first file found is loaded.

For example, the package ' com.test.rs ' in Resource1.jar has a ' jarappcontext.xml ' file that reads as follows:

<bean name= "Processorimpla" class= "Com.test.spring.di.ProcessorImplA"/>

The package ' com.test.rs ' in Resource2.jar also has a ' jarappcontext.xml ' file that reads as follows:

<bean id= "PROCESSORIMPLB" class= "Com.test.spring.di.ProcessorImplB"/>

You can load the files in the two jar packages by using the following code

ApplicationContext CTX = new Classpathxmlapplicationcontext ("Classpath*:com/test/rs/jarappcontext.xml");

If you write the following code, you can only find one of the XML files (the order depends on the load order of the jar packages)

ApplicationContext CTX = new Classpathxmlapplicationcontext ("Classpath:com/test/rs/jarappcontext.xml");

classpath*: is used for multiple component (eventually released into different jar packages) in parallel development, the respective bean definition files according to certain rules: Package+filename, The callers who use these component can load the files in.

classpath*: The load uses the ClassLoader getresources () method, if it is run on a different Java EE server, because the application server provides its own ClassLoader implementation, They may behave differently when working with jar files. To test classpath*: valid, you can test it with ClassLoader from the jar file in Classpath: GetClass (). getClassLoader (). Getresources ("< Somefileinsidethejar> "). (The example above is the state running in Sun's JRE)

From spring's source code, in the Pathmatchingresourcepatternresolver class, we can better understand its handling: if it starts with classpath*, it will traverse classpath.

    Protected resource[] Findallclasspathresources (string location) throws IOException {
        string path = location;
        if (Path.startswith ("/")) {
            path = path.substring (1);
        }
        Enumeration resourceurls = getClassLoader (). getresources (path);
        set<resource> result = new linkedhashset<resource> (+);
        while (Resourceurls.hasmoreelements ()) {
            url url = (URL) resourceurls.nextelement ();
            Result.add (Convertclassloaderurl (URL));
        }
        Return Result.toarray (New Resource[result.size ()));
    

http://blog.csdn.net/kkdelta/article/details/5560210, introduces all the matching names found in Java traversal classpath.

In addition, when loading resource, the meanings of the other prefixes are as follows: Note that classpath* can only be used with the path specified by the configuration file and cannot be used in parameters used for getresource. such as Appcontext.getresource (" Classpath*:conf/bfactoryctx.xml ") will be abnormal.

prefix Example Description

Classpath

Classpath:com/myapp/config.xml

Loaded from the classpath.

File

File:/data/config.xml

Loaded as a URL from the file system.

http

Http://myserver/logo.png

Loaded as a URL.

(none)

/data/config.xml

Judge according to ApplicationContext.

From the source of spring can see the reason: if it is classpath: Start, load from classpath, otherwise try the URL, if failed, call Getresourcebypath

Public Resource getresource (String location) {
        assert.notnull (location, ' location must not ' be null ');
        if (Location.startswith (Classpath_url_prefix)) {
            return new Classpathresource (Location.substring (classpath_url _prefix.length ()), getClassLoader ());
        }
        else {
            try {
                //try to parse the location as a URL ...
                URL url = new URL (location);
                return new Urlresource (URL);
            }
            catch (Malformedurlexception ex) {
                //No URL, resolve as resource path.
                return Getresourcebypath (location);}}
    }

Getresourcebypath will be covered by different applicationcontext implementations.

If the genericwebapplicationcontext is covered as follows:

Protected Resource Getresourcebypath (String path) {
        return new Servletcontextresource (This.servletcontext, path);
    }

The Filesystemxmlapplicationcontext overrides are as follows:

protected Resource Getresourcebypath (String path) {
        if (path! = null & amp;& Path.startswith ("/")) {
            path = path.substring (1);
        }
        return new Filesystemresource (path);
    

It is still common in Java to read files when loading from a file:

The way to get InputStream as Classpathresource is to use class loader.

    Public InputStream getInputStream () throws IOException {
        inputstream are;
        if (this.clazz! = null) {is
            = This.clazz.getResourceAsStream (This.path);
        }

The way to get InputStream, as Filesystemresource, is to use FileInputStream.

Public InputStream getInputStream () throws IOException {
return new FileInputStream (This.file);
}

The way to get InputStream, as Servletcontextresource, is to use Servletcontext.getresourceasstream.

    Public InputStream getInputStream () throws IOException {
        InputStream are = This.servletContext.getResourceAsStream ( This.path);
        if (is = = null) {
            throw new FileNotFoundException ("Could not open" + getdescription ());
        }
        return is;
    }


Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.