Maven项目的架构（Spring Boot 实战版）

标准、可直接复用的 Maven 项目架构（基于 Spring Boot，贴合企业开发规范），包含完整的目录结构、核心配置文件和分层代码示例

简要Maven项目架构

复制代码

项目名字
	src：写所有代码的位置
		main：核心代码，要交付给公司，给客户的代码
			java：写java代码的文件夹。理论上可以写配置文件。不推荐写配置文件，
               包，类，接口等
			resources：写项目需要的配置文件的文件夹。直接创建maven项目，自带，不需要单独创建
		test：开发者用于测试main中编写代码是否正确的测试位置
			java：写java测试代码
			resourses：测试代码需要的配置文件，不需要可以不写
	pom.xml：和src文件夹平行的，是maven项目的配置文件。用于导入jar文件

完整项目目录结构（Maven 标准）

复制代码

my-maven-project/          # 项目根目录（artifactId）
├── pom.xml                 # Maven 核心配置文件（依赖、打包方式等）
├── src/
│   ├── main/
│   │   ├── java/           # 核心业务代码（所有分层代码）
│   │   │   └── com/
│   │   │       └── example/
│   │   │           ├── MyMavenApplication.java  # 项目启动类
│   │   │           ├── controller/              # 控制层（接收请求）
│   │   │           │   └── UserController.java
│   │   │           ├── service/                 # 服务层（业务逻辑）
│   │   │           │   ├── UserService.java
│   │   │           │   └── impl/                # 服务层实现类
│   │   │           │       └── UserServiceImpl.java
│   │   │           ├── mapper/                  # 持久层（数据库映射，MyBatis）
│   │   │           │   └── UserMapper.java
│   │   │           ├── entity/                  # 实体类（数据库表映射）
│   │   │           │   └── User.java
│   │   │           └── config/                  # 配置类（MyBatis、数据库等）
│   │   │               └── MyBatisConfig.java
│   │   └── resources/      # 配置文件目录
│   │       ├── application.yml  # Spring Boot 核心配置
│   │       ├── mybatis/         # MyBatis 映射文件
│   │       │   └── UserMapper.xml
│   │       └── static/          # 静态资源（前端页面、JS/CSS）
│   └── test/                # 测试代码目录（Maven 测试专用）
│       └── java/
│           └── com/
│               └── example/
│                   └── UserServiceTest.java
└── target/                  # Maven 构建输出目录（编译后的class、打包的jar/war）

核心配置文件：pom.xml

这是 Maven 项目的 "灵魂"，定义了项目依赖、打包方式、JDK 版本等，直接复制即可使用：

复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 1. 基础配置 -->
    <modelVersion>4.0.0</modelVersion>
    <!-- 集团ID（一般是公司/组织域名反写） -->
    <groupId>com.example</groupId>
    <!-- 项目ID（项目名称） -->
    <artifactId>my-maven-project</artifactId>
    <!-- 项目版本 -->
    <version>1.0.0</version>
    <!-- 打包方式：Spring Boot 推荐 jar -->
    <packaging>jar</packaging>
    <name>my-maven-project</name>
    <description>Maven 架构示例项目</description>

    <!-- 2. 父工程（Spring Boot 起步依赖） -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.3</version>
        <relativePath/> <!-- 从Maven仓库找，不本地找 -->
    </parent>

    <!-- 3. 核心依赖（Maven自动下载） -->
    <dependencies>
        <!-- Spring Boot Web（包含Spring MVC、Tomcat等） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- MyBatis + MySQL 驱动（持久层） -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 测试依赖（仅测试环境生效） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!-- 4. 构建配置（编译、打包） -->
    <build>
        <!-- 最终打包的jar名称 -->
        <finalName>my-maven-app</finalName>
        <plugins>
            <!-- Spring Boot 打包插件（可执行jar） -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- JDK 编译版本（指定17） -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

核心代码示例（分层实现）

1. 实体类（entity/User.java）

复制代码

package com.example.entity;

// 数据库user表对应的实体类
public class User {
    private Long id;
    private String username;
    private String password;
    private Integer age;

    // 省略getter/setter/toString（实际开发用Lombok注解简化）
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", username='" + username + '\'' + ", age=" + age + '}';
    }
}

2. 持久层（mapper/UserMapper.java）

复制代码

package com.example.mapper;

import com.example.entity.User;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper {
    // 根据ID查询用户（MyBatis注解方式，也可写XML）
    @Select("SELECT id, username, password, age FROM user WHERE id = #{id}")
    User selectUserById(Long id);
}

3. 服务层（service/UserService.java + impl/UserServiceImpl.java）

复制代码

// 接口
package com.example.service;
import com.example.entity.User;
public interface UserService {
    User getUserById(Long id);
}

// 实现类
package com.example.service.impl;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public User getUserById(Long id) {
        // 业务逻辑：调用持久层查询
        return userMapper.selectUserById(id);
    }
}

4. 控制层（controller/UserController.java）

复制代码

package com.example.controller;

import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    // 接口地址：http://localhost:8080/user/1
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        // 接收前端请求，调用服务层
        return userService.getUserById(id);
    }
}

5. 启动类（MyMavenApplication.java）

复制代码

package com.example;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// 扫描Mapper接口包
@MapperScan("com.example.mapper")
// Spring Boot 核心注解（扫描当前包及子包）
@SpringBootApplication
public class MyMavenApplication {
    public static void main(String[] args) {
        // 启动Spring Boot项目
        SpringApplication.run(MyMavenApplication.class, args);
    }
}

6. 配置文件（resources/application.yml）

复制代码

# 服务器端口
server:
  port: 8080

# 数据库配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root  # 你的MySQL用户名
    password: 123456  # 你的MySQL密码
    driver-class-name: com.mysql.cj.jdbc.Driver

# MyBatis配置
mybatis:
  configuration:
    map-underscore-to-camel-case: true  # 下划线转驼峰（如user_name → userName）
  mapper-locations: classpath:mybatis/*.xml  # 映射文件路径

Maven 核心命令（实战常用）

在项目根目录（pom.xml 所在目录）执行以下命令：

复制代码

# 1. 清理编译产物（删除target目录）
mvn clean

# 2. 编译代码（生成target/classes目录）
mvn compile

# 3. 运行测试用例
mvn test

# 4. 打包（生成target/my-maven-app.jar）
mvn package

# 5. 打包并跳过测试（开发常用）
mvn package -DskipTests

# 6. 运行打包后的Spring Boot项目
java -jar target/my-maven-app.jar

总结

Maven 架构核心 ：以 pom.xml 为配置中心，遵循 "src/main/java（业务代码）+ src/main/resources（配置）+ src/test/java（测试）" 的标准目录结构
分层与 Maven 的关系 ：业务分层（Controller/Service/Mapper）的代码都放在 src/main/java 下，Maven 负责通过 pom.xml 管理各层依赖（如 Spring MVC、MyBatis）
实战关键 ：通过 mvn clean package 完成打包，java -jar 运行项目，这是 Maven 管理 Spring Boot 项目的核心流程