SoFunction
Updated on 2025-04-05

In-depth exploration of the Resources directory of Java engineering from basic to advanced applications

introduction

In Java development,resourcesDirectories are a crucial part, and they are used to store various resource files, such as configuration files, pictures, audio, template files, etc. understandresourcesHow directories work and how to use them is crucial to building efficient and maintainable Java applications. This article will take you to explore Java engineering in depthresourcesTable of contents, from basic concepts to advanced applications, allows you to easily master this important tool in Java development.

What is the Resources directory?

Basic concepts

resourcesDirectory is a special directory in Java project, which is used to store resource files required for the application to run. These resource files can be text files, configuration files, pictures, audio, template files, etc.resourcesThe directory is usually located insrc/main/resourcesorsrc/test/resourcesNext, the specific location depends on the project structure.

Advantages of Resources Directory

  • Centralized management of resources: Store all resource files in a centralized mannerresourcesIn the directory, it is easy to manage and maintain.
  • Simplify resource loading: Java provides multiple ways to loadresourcesFiles in the directory simplify the process of resource loading.
  • Cross-platform compatibility：resourcesFiles in the directory will be automatically included when packaged into JAR or WAR files to ensure cross-platform compatibility.

Create and use Resources Directory

Pre-knowledge: Java project structure

Before you start, you need to understand the basic structure of a Java project. A typical Maven or Gradle project structure is as follows:

my-project
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── 
│   │   └── resources
│   │       └── 
│   └── test
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── 
│       └── resources
│           └── 
└──  (or )

In this structure,src/main/resourcesResource files used to store the main application,src/test/resourcesUsed to store test-related resource files.

Create Resources Directory

Create in IDEresourcesThe directory is very simple. Take IntelliJ IDEA as an example:

  • Right-clicksrc/mainDirectory, selectNew -> Directory。
  • Enter the directory nameresources, clickOK。

Using the Resources directory

1. Load text file

Assume you areresourcesThere is a directory calledText file:

# 
username=admin
password=secret

You can load and read the file using the following code:

import ;
import ;

public class ResourceLoader {
    public static void main(String[] args) {
        // Get the input stream of resource files        InputStream inputStream = ().getResourceAsStream("");
        
        // Use Scanner to read file content        Scanner scanner = new Scanner(inputStream);
        while (()) {
            (());
        }
        ();
    }
}

2. Load the configuration file

Assume you areresourcesThere is a directory calledConfiguration file:

# 
=MyApp
=1.0.0

You can usePropertiesThe class loads and reads the file:

import ;
import ;

public class PropertiesLoader {
    public static void main(String[] args) {
        Properties properties = new Properties();
        try (InputStream inputStream = ().getResourceAsStream("")) {
            (inputStream);
            ("App Name: " + (""));
            ("App Version: " + (""));
        } catch (Exception e) {
            ();
        }
    }
}

3. Load the picture file

Assume you areresourcesThere is a directory calledPicture files:

import ;
import ;
import ;

public class ImageLoader {
    public static void main(String[] args) {
        try (InputStream inputStream = ().getResourceAsStream("")) {
            BufferedImage image = (inputStream);
            ("Image Width: " + ());
            ("Image Height: " + ());
        } catch (Exception e) {
            ();
        }
    }
}

Advanced applications for the Resources directory

1. Resources directory in multi-module project

In a multi-module project, each module can have its ownresourcesTable of contents. For example, a typical multi-module Maven project structure is as follows:

my-project
├── module-a
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   └── resources
│   │   │       └── 
│   └── 
├── module-b
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   └── resources
│   │   │       └── 
│   └── 
└──

In a multi-module project, you can load resource files for specific modules through the module's class loader:

InputStream inputStream = ().getResourceAsStream("");

2. Dynamically load resource files

In some cases, you may need to load resource files dynamically at runtime. For example, load different configuration files according to user's choice:

import ;
import ;

public class DynamicResourceLoader {
    public static void main(String[] args) {
        String configFileName = "";
        Properties properties = new Properties();
        try (InputStream inputStream = ().getResourceAsStream(configFileName)) {
            (inputStream);
            ("User Config: " + (""));
        } catch (Exception e) {
            ();
        }
    }
}

3. Use the template engine

resourcesDirectories are also often used to store template files, such as template files of template engines such as Thymeleaf and Freemarker. Assume you areresourcesThere is a directory calledThymeleaf template file:

<!--  -->
<!DOCTYPE html>
<html xmlns:th="">
<head>
    <title>Template Example</title>
</head>
<body>
    <h1 th:text="${message}"></h1>
</body>
</html>

You can use Thymeleaf to load and render the template file:

import ;
import ;
import ;

public class TemplateLoader {
    public static void main(String[] args) {
        TemplateEngine templateEngine = new TemplateEngine();
        ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver();
        ("templates/");
        (".html");
        (templateResolver);

        Context context = new Context();
        ("message", "Hello, Thymeleaf!");

        String renderedHtml = ("template", context);
        (renderedHtml);
    }
}

Summarize

resourcesDirectories are an integral part of Java engineering. They are used to store various resource files, simplify the process of resource loading, and provide cross-platform compatibility. Through this article, you should have mastered itresourcesBasic concepts, creation methods and advanced applications of directories. Whether you are a beginner or a senior developer, understand and be proficient in using itresourcesDirectories will greatly improve your Java development efficiency.

References

  • Maven official documentation: resource files
  • Gradle official documentation: resource files
  • Thymeleaf official documentation

I hope this article can help you better understand and use Java engineeringresourcesTable of contents to make your Java development journey smoother!

This is what this article about the Resources directory of Java engineering from basic to advanced applications. For more information about Resources directory of Java engineering, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!