前言：虽然AI已经大大方便了我们项目的开发（有段时间我都不去看代码，完全让AI给我改了-捂脸），但我觉得还是要有些基础认识的，后面也会努力的看看AI给我改的代码（之前也有遇到给我乱改的情况，还是要人为检查下好）。

Maven

Maven是由Apache软件基金会（天呐，我已经看到这个基金会很多次了！）开发的跨平台项目管理工具，专门用于Java项目的构建、依赖管理和项目信息管理。

Maven的核心功能

项目构建（Build）

项目构建就是把源代码变成可运行的程序的过程，包括：

  • 清理（clean）→ 删除旧的编译文件
  • 编译（compile）→ 把.java文件变成.class文件
  • 测试（test）→ 运行单元测试
  • 打包（package）→ 生成jar/war文件
  • 部署（deploy）→ 发布到服务器
mvn clean install
JAR包

JAR = Java Archive = Java归档文件

一个典型的JAR包：

my-library.jar
├── META-INF/                    ← 元数据目录（必须有）
│   └── MANIFEST.MF              ← 清单文件（"说明书"）
├── com/
│   └── example/
│       ├── MyClass.class        ← 编译后的Java类文件
│       ├── AnotherClass.class
│       └── utils/
│           └── Helper.class
├── config.properties            ← 配置文件
├── images/                      ← 资源文件
│   ├── logo.png
│   └── icon.jpg
└── templates/                   ← 模板文件
    └── email-template.html

JAR包本质是ZIP压缩文件，特殊之处在于：

  1. 包含元数据：有META-INF/MANIFEST.MF文件
  2. 可执行：可以配置成直接运行的程序
  3. Java专用：JVM可以直接识别和加载
META-INF/MANIFEST.MF（最重要）
Manifest-Version: 1.0
Created-By: Apache Maven
Build-Jdk: 17.0.8
Implementation-Title: My Library
Implementation-Version: 1.0.0
Main-Class: com.example.Main      # 如果是可执行JAR，这里指定入口
Class-Path: lib/dependency1.jar   # 依赖的其他JAR包
 .class文件

是Java源代码（.java）编译后的字节码文件，JVM（Java虚拟机）能直接执行的文件

编译过程：

Java源代码 (.java)
    ↓ 编译（javac）
字节码文件 (.class)
    ↓ 打包（jar）
JAR包 (.jar)
    ↓ 运行（java）
程序执行
核心作用

1.代码复用

在项目中使用MySQL数据库
1. 下载 mysql-connector-java-8.0.33.jar
2. 放到项目的lib目录
3. 代码：Class.forName("com.mysql.cj.jdbc.Driver");

2.打包文件

3.可执行JAR包，可直接运行

WAR包
WAR包 Web Application Archive Web应用程序 JAR + JSP + HTML + 配置文件 
myapp.war
├── WEB-INF/
│   ├── web.xml              ← Web配置
│   ├── classes/             ← .class文件
│   └── lib/                 ← 依赖的JAR包
├── index.jsp
└── static/
    ├── css/
    └── js/

依赖管理（Dependency Management）

统一管理项目需要使用的第三方库（jar包），比如：

  • 数据库驱动（MySQL、Oracle）
  • Web框架（Spring、Hibernate）
  • 工具类库（Apache Commons、Guava）

传统手动管理jar包：

1. 去官网下载jar包
2. 复制到项目的lib目录
3. 发现这个jar包还依赖其他jar包
4. 继续下载依赖的jar包...
5. 版本冲突：A需要commons-logging 1.1，B需要1.2
6. 团队协作：每个人都要重复这个过程

Maven依赖管理：

<!-- 在pom.xml中声明依赖 -->
<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
</dependency>

会自动：从中央仓库下载这个jar包；下载它依赖的所有jar包（传递性依赖）；解决版本冲突；统一管理到本地仓库

项目管理（Project Management）

标准化项目结构：

my-project/
├── src/
│   ├── main/
│   │   ├── java/          # Java源代码
│   │   ├── resources/     # 配置文件
│   │   └── webapp/        # Web资源（如果是Web项目）
│   └── test/
│       ├── java/          # 测试代码
│       └── resources/     # 测试配置
├── target/                # 编译输出目录
└── pom.xml                # Maven配置文件

通过pom.xml文件描述整个项目的信息：

  • 项目名称、版本、描述
  • 开发者信息
  • 依赖的jar包
  • 构建配置
  • 插件配置

Maven的核心概念

项目对象模型POM（Project Object Model）

pom.xml是Maven的核心配置文件

pom.xml示例：

<?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">
    
    <modelVersion>4.0.0</modelVersion>
    
    <!-- 项目基本信息 -->
    <groupId>com.example</groupId>        <!-- 组织ID -->
    <artifactId>my-app</artifactId>       <!-- 项目ID -->
    <version>1.0-SNAPSHOT</version>       <!-- 版本号 -->
    <packaging>jar</packaging>            <!-- 打包方式 -->
    
    <!-- 项目名称和描述 -->
    <name>My Application</name>
    <description>A simple Maven project</description>
    
    <!-- 依赖管理 -->
    <dependencies>
        <!-- 这里声明需要的jar包 -->
    </dependencies>
    
</project>

坐标（Coordinates）- jar包的唯一标识

Maven用三个元素定位一个jar包：

  1. groupId：组织ID，通常是公司域名倒写，如：com.google, org.springframework
  2. artifactId：项目ID，模块名称，如：guava, spring-core
  3. version：版本号，如：31.1-jre, 5.3.23

坐标示例：

com.google.guava:guava:31.1-jre
└─────┬─────┘ └──┬──┘ └───┬───┘
   groupId   artifactId version

仓库（Repository）- jar包的存储位置

有三种仓库：

1.本地仓库（Local Repository）

        缓存下载的jar包，避免重复下载。

        位置：C:\Users\用户名\.m2\repository（Windows）

2.中央仓库（Central Repository）

        官方的jar包仓库，包含几乎所有开源jar包。

        位置：https://repo.maven.apache.org/maven2/

3.私服（Private Repository）

        加速下载、存储公司私有jar包。

        位置：公司内部搭建的仓库（如Nexus、Artifactory）

工作流程：

项目需要jar包
    ↓
检查本地仓库（有？直接使用）
    ↓
没有 → 检查私服（有？下载到本地）
    ↓
没有 → 从中央仓库下载
    ↓
保存到本地仓库，供下次使用

插件

Maven也能通过插件扩展功能，每个构建阶段都由插件完成

常用插件示例：

<build>
    <plugins>
        <!-- 编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>17</source>  <!-- JDK版本 -->
                <target>17</target>
            </configuration>
        </plugin>
        
        <!-- 打包插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
        </plugin>
    </plugins>
</build>

多模块项目管理：

  • 将大型项目拆分为多个子模块

常用命令：

mvn clean          # 清理target目录
mvn compile        # 编译源代码
mvn test           # 运行测试
mvn package        # 打包（生成jar/war）
mvn install        # 安装到本地仓库
mvn deploy         # 部署到远程仓库
mvn clean install  # 清理并重新构建

 官方文档：https://maven.apache.org/guides/

Spring

Spring Framework是一个开源的、轻量级的、分层的企业级Java应用开发框架，提供从Web层到持久层的完整支持

Java EE（Java Platform, Enterprise Edition，中文Java企业版，专门用来做企业级网站、后台管理系统、电商平台、支付系统、APP 服务端的技术集合，是一套标准 + 一堆技术组件）三层架构把后端代码分成 3 个独立层次：

三层分别是：

  1. 表现层（View / Controller），也有叫Web层，接收用户请求，返回结果
  2. 业务逻辑层（Service），处理核心业务规则
  3. 数据访问层（DAO / Repository），也有叫持久层，操作数据库

JDBC（Java Database Connectivity）是Java提供的一套标准接口，让Java程序能够连接和操作各种数据库

两大核心基石

IOC（控制反转 - Inversion of Control）

传统方式：程序主动创建对象（new UserService()）

IOC方式：对象的创建和管理交给Spring容器，程序直接使用

示例对比：

// 传统方式（天呐，就是我JAVA课学的老东西）
public class OrderService {
    private UserService userService = new UserService();
    private OrderDao orderDao = new OrderDao();
    public void createOrder() {
        // 业务逻辑
    }
}

// 使用IOC（容器控制）
@Service
public class OrderService {
    @Autowired
    private UserService userService;
    @Autowired
    private OrderDao orderDao;
    public void createOrder() {
        // 业务逻辑
    }
}

IOC的好处：

  • 解耦：对象之间不直接依赖，通过容器管理
  • 灵活：可以轻松替换实现类
  • 可测试：便于单元测试（可以注入Mock对象）
  • 统一管理：对象的生命周期由容器管理

AOP（面向切面编程 - Aspect-Oriented Programming）

将横切关注点（如日志、事务、权限）从业务逻辑中分离出来，通过"切面"统一处理这些关注点

示例：

// 日志切面
@Aspect
@Component
public class LoggingAspect {
    // 前置通知：方法执行前执行
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 即将执行");
    }
    // 后置通知：方法执行后执行
    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行完毕");
    }
    // 环绕通知：方法执行前后都执行
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed(); // 执行目标方法
        long end = System.currentTimeMillis();
        System.out.println("方法 " + joinPoint.getSignature().getName() + 
                          " 执行耗时: " + (end - start) + "ms");
        return result;
    }
}

AOP的好处：

  • 代码复用：日志、事务等逻辑只需写一次
  • 关注点分离：业务逻辑更清晰
  • 易于维护：修改横切逻辑只需修改切面
  • 非侵入式：业务代码不需要修改

Spring官方指南：https://spring.io/guides

MyBatis

MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

MyBatis是一款半自动化的ORM（对象关系映射）框架，它消除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。通过简单的XML或注解来配置和映射原生信息，将接口和Java的POJOs（Plain Old Java Objects）映射成数据库中的记录。

核心组件详解

SqlSessionFactory

创建SqlSession的工厂，应用启动时创建。整个应用生命周期中只有一个实例

SqlSession

执行SQL命令、获取Mapper接口、管理事务。每次数据库操作都需要创建新的SqlSession

Mapper接口

定义数据库操作方法，对应XML中的SQL语句。无需实现类，MyBatis通过动态代理自动生成实现

Executor

负责SQL语句的执行

核心配置文件（mybatis-config.xml）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <!-- 1. 属性配置 -->
    <properties resource="db.properties">
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    </properties>
    
    <!-- 2. 设置 -->
    <settings>
        <!-- 开启驼峰命名自动映射 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 开启二级缓存 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- 日志实现 -->
        <setting name="logImpl" value="SLF4J"/>
        <!-- 延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    
    <!-- 3. 别名配置 -->
    <typeAliases>
        <!-- 单个别名 -->
        <typeAlias type="com.example.model.User" alias="User"/>
        
        <!-- 批量别名（扫描包） -->
        <package name="com.example.model"/>
    </typeAliases>
    
    <!-- 4. 插件配置 -->
    <plugins>
        <!-- 分页插件 -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="helperDialect" value="mysql"/>
        </plugin>
    </plugins>
    
    <!-- 5. 环境配置 -->
    <environments default="development">
        <environment id="development">
            <!-- 事务管理器 -->
            <transactionManager type="JDBC"/>
            
            <!-- 数据源 -->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    
    <!-- 6. 映射器配置 -->
    <mappers>
        <!-- 单个XML映射文件 -->
        <mapper resource="com/example/mapper/UserMapper.xml"/>
        
        <!-- 批量扫描包 -->
        <package name="com.example.mapper"/>
    </mappers>
    
</configuration>

API = Application Programming Interface = 应用程序编程接口，负责在不同系统之间传递信息和执行操作。

RESTful API = 遵循REST架构风格设计的API

用URL来表示资源，用HTTP方法（GET、POST、PUT、DELETE）来表示操作，通过HTTP协议进行通信的API

HTTP状态码（有没有人经常遇到404的情况，原来这有个统称！）

总共有5大类别

类别 范围 含义
1xx 100-199 信息，请求已接收，继续处理
2xx 200-299 成功，请求被成功接收、理解、接受
3xx 300-399 重定向，需要进一步操作
4xx 400-499 客户端错误，请求有语法错误或无法实现
5xx 500-599 服务器错误，服务器未能实现合法请求

4xx

状态码 含义 使用场景
400 Bad Request 错误的请求 请求参数错误、格式错误
401 Unauthorized 未授权 缺少或无效的认证信息
403 Forbidden 禁止访问 有权限但被拒绝访问
404 Not Found 未找到 资源不存在
405 Method Not Allowed 方法不允许 使用了不支持的HTTP方法
422 Unprocessable Entity 无法处理的实体 语义错误（如字段验证失败）
429 Too Many Requests 请求过多 超过速率限制

Spring Boot

Spring Boot基于Spring框架，通过"约定优于配置"的理念，旨在简化Spring应用的初始搭建和开发过程。

特性 Spring Spring Boot
配置 需要大量XML或Java配置 自动配置，极少配置
依赖管理 手动管理依赖版本 起步依赖，版本统一
服务器 需要外部服务器（Tomcat） 内置服务器
打包 war包 jar包（可执行）

项目结构示例：

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/
│   │   │       ├── MyApplication.java  # 启动类
│   │   │       ├── controller/         # 控制器
│   │   │       ├── service/            # 服务层
│   │   │       ├── repository/         # 数据访问层
│   │   │       └── config/             # 配置类
│   │   └── resources/
│   │       ├── application.properties  # 配置文件
│   │       ├── application-dev.yml     # 开发环境配置
│   │       ├── application-prod.yml    # 生产环境配置
│   │       └── static/                 # 静态资源
│   └── test/
│       └── java/
│           └── com/example/
│               └── MyApplicationTests.java
├── pom.xml                             # Maven配置
└── README.md

技术栈关系总结

技术 角色 与Spring Boot的关系
Maven 构建工具 管理Spring Boot项目的依赖和构建
Spring Boot 快速开发框架 基于Spring的增强框架
Spring Framework 核心框架 Spring Boot的基础
MyBatis 持久层框架 可选组件，可与Spring Boot集成
# spring # spring boot # java # 前端 # 后端
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

C 语言入门第 1 讲：C 语言常见概念（超详细）

avatar AtomGit开源社区
cover

HITL：让人类随时叫停 AI，并且能优雅地继续

avatar AtomGit开源社区

深入底层：从SAR ADC原理到模拟前端设计，解析高精度数据采集卡的硬件架构

从SAR ADC的微伏级建立精度，到三重隔离的电磁兼容设计，打造一块高精度工业数据采集卡，是对硬件工程师综合实力的极限考验。ZLinear开源电子通过开源的胸怀和硬核的技术，将原本高高在上的工业级方案拉下神坛。如果您正在寻找靠谱的数据采集方案，或者希望深入学习工业DAQ的底层设计，欢迎访问ZLinear官网获取全套资料，让我们共同推动工业测控技术的普及与进步！

avatar AtomGit开源社区