Introduction to the usage of getResourceAsStream in Java

Using JAVA to obtain files sounds simple, but for many newcomers like me, it is still quite shallow and the experience of using it is quite profound. The most commonly used one is to use JAVA's File class. To obtain the c:/test.txt file, you will use File file = new File("c:/test.txt"); What is the problem with this use? I believe everyone knows that the path is hard-coded. For the JAVA spirit , the application should be formed once and available everywhere, and in terms of practical applications, the final generated application will also be deployed to operating systems other than Windows. For Linux, using the words c:/ in the application means failure. , so we should try to avoid using hard coding, that is, use absolute paths directly.

In the Servlet application, there is a getRealPath(String str) method. Although this method can also dynamically obtain the path of the file without directly handwriting the absolute path, this is also a method that is not recommended. , So, what methods do we have to get the file better?

That is the Class.getResource() and Class.getResourceAsStream() methods, but many people still don’t understand its usage, because many people (For example, me not long ago) didn't know what parameters should be passed to it. Of course, some people have already used it very well, and these people don't need to take care of it. Here I only give you some parameters that don't know how to use it or are not very good at it. Someone familiar with it can explain a little bit.

First of all, there are the following types of getResourceAsStream in Java:

1. Class.getResourceAsStream(String path): When the path does not start with '/', it defaults to the package where this class is located. Resources starting with '/' are obtained from the

　ClassPath root. It just constructs an absolute path through path, and ultimately the resource is obtained by ClassLoader.

　2. Class.getClassLoader.getResourceAsStream(String path): By default, it is obtained from the ClassPath root. The path cannot start with '/'. The resource is ultimately obtained by

　ClassLoader.

　3. ServletContext. getResourceAsStream(String path): By default, resources are fetched from the WebAPP root directory. It does not matter whether the path starts with '/' under Tomcat.

Of course, this is related to the specific container implementation. .

　4. The application built-in object under Jsp is an implementation of the above ServletContext.

By the way, the class loader in JAVA:

There are three loaders in total

bootstrap classloader: Responsible for loading JAVA core classes (jre Contents in the lib and class directories)

extension classloader: Responsible for loading JAVA extension classes (contents in the lib/ext directory under jre)

system classloader: Responsible for loading application-specified classes ( The content configured in the environment variable classpath)

The loading order of a class is also based on the above arrangement, so as to ensure that the system classes can be loaded first.

At the same time, users can also define their own ClassLoader to load special resources.

This involves the difference between Class.getClassLoader() and Thread.currentThread.getContextClassLoader().

Give a simple example:

If one day JAVA provides us with a class called StartCamera to start the standard camera of the computer, and packages this class in a jar.

Under normal circumstances, when we want to start the camera, we only need to configure this jar into the classpath. The system classloader will load this class into the application when the system starts.

But because the camera manufacturers are different, there will be multiple different StartCamera implementations for new devices. In the application, we don’t know which one the actual users will use. So we customized a ClassLoader to load the corresponding StartCamera class for a specific device type.

This will appear: load the classes we defined first, and then load the system ones if they cannot be loaded. Such a demand cannot be met by the system's default parent delegate loading mechanism.

Thread.currentThread.getContextClassLoader() is generated in this way. We use Thread.currentThread.setContextClassLoader() to specify the corresponding ClassLoader for the current thread, and then obtain it using get.

The above is the detailed content of Introduction to the usage of getResourceAsStream in Java. For more information, please follow other related articles on the PHP Chinese website!