Project Practice of Project Structure in SpringBoot

Technical background

The Spring Boot project structure follows the standard directory structure of Maven or Gradle, and incorporates Spring Boot specific conventions. A good project structure not only helps code organization, but also improves development efficiency and project maintainability. Understanding Spring Boot’s project structure is essential to developing high-quality applications.

1. Basic project structure

1.1 Standard directory structure

The basic Spring Boot project structure is as follows:

myproject/
├── src/
│   ├── main/
│   │   ├── java/
│   │   ├── resources/
│   │   └── webapp/
│   └── test/
├── 
└──

1.2 Maven configuration

Standard configuration:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId></groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    
    <parent>
        <groupId></groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId></groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

2. Java source code structure

2.1 Package Structure Organization

Recommended package structure organization method:

/
├── config/          // Configuration class├── controller/      // Controller├── service/         // Service layer│   ├── impl/       // Service implementation├── repository/      // Data access layer├── model/          // Data model│   ├── entity/     // Entity class│   ├── dto/        // Data transfer object└── util/           // Tools

2.2 Startup class configuration

Standard startup class structure:

package ;

@SpringBootApplication
public class Application {
    
    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {
            ("Application started!");
        };
    }
    
    public static void main(String[] args) {
        (, args);
    }
}

3. Resource file organization

3.1 Configuration file structure

Configuration file organization under resources directory:

resources/
├── 
├── 
├── 
├── static/
│   ├── css/
│   ├── js/
│   └── images/
└── templates/
    └── pages/

3.2 Multi-environment configuration

Multi-environment configuration example:

# 
spring:
  profiles:
    active: dev
    
---
# 
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:testdb
    
---
# 
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://production-server/db

4. Test structure

4.1 Unit Test Organization

Test directory structure:

src/test/java/com/example/project/
├── controller/
│   └── 
├── service/
│   └── 
└── repository/
    └──

Test class example:

@SpringBootTest
class UserServiceTest {
    
    @Autowired
    private UserService userService;
    
    @Test
    void testFindById() {
        User user = (1L);
        assertNotNull(user);
        assertEquals("test", ());
    }
}

4.2 Integrated test structure

Integration test example:

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void testGetUser() throws Exception {
        (get("/api/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("test"));
    }
}

5. Project construction and deployment

5.1 Build configuration

Maven build plugin configuration:

<build>
    <plugins>
        <plugin>
            <groupId></groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId></groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

5.2 Docker support

Dockerfile example:

FROM openjdk:11-jdk-slim
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} 
ENTRYPOINT ["java","-jar","/"]

Docker Compose configuration:

version: '3'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
    depends_on:
      - db
  db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=testdb

Through the above, we introduce the standard structure and best practices of Spring Boot projects in detail. A reasonable project structure not only improves the readability and maintainability of the code, but also helps team members collaborate better. Especially in large-scale projects, good project structure design can effectively reduce the coupling of code and improve the scalability of the system. In addition, appropriate testing structure and construction configuration are also important factors in ensuring project quality.

This is the end of this article about Spring Boot's project structure. For more information about Spring Boot's project structure, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!