从零开始一个简单的 Java Spring 项目

阿虎儿
212 阅读8分钟

从零开始一个简单的 Java Spring 项目是一个非常好的学习项目。这篇教程将逐步介绍实现一个简单的 Spring 项目，涵盖了从环境搭建到部署上线的所有步骤。

前置概念

在开始之前，先了解一些基本知识：

  1. Spring 是 Java 最主流的企业开发框架，Spring Boot 是其一套更简化的开发机制。
  2. Maven 是 Java 项目最常用的依赖管理工具。
  3. ORM（Object-Relational Mapping）  框架如 Hibernate、MyBatis、JPA 等，用于简化数据库操作代码。

Step 1: 开发环境搭建

安装 Java JDK

  • 下载 JDK（推荐 Java 8 或更高版本）：

  • 安装后配置环境变量：

    • JAVA_HOME 指向 JDK 的安装目录。
    • 将 %JAVA_HOME%\bin 添加到 PATH 环境变量中。

  • 验证安装：

    java -version

    输出版本信息即成功。

安装 IntelliJ IDEA（推荐）

  • 下载社区版即可：IntelliJ IDEA 官网
  • 安装完成后，选择创建或导入 Maven 项目。

安装 Maven

  • 现代 IDE 如 IntelliJ 通常自带 Maven，如果手动安装请从官网下载：Maven 官网

Step 2: 创建一个 Spring Boot 项目

Spring Boot 初始项目可以通过多种方式创建，我们推荐使用 Spring Initializr。

使用 Spring Initializr

  1. 打开 Spring Initializr。

  2. 填写必要信息：

    • 项目类型：Maven

    • 语言：Java

    • Spring Boot 版本：选择一个稳定版本（例如 2.7.x 或 3.x）。

    • 项目 Metadata：

      • Group: com.example
      • Artifact: demo
      • Name: demo
      • Package name: com.example.demo

    • 依赖：添加以下依赖：

      • Spring Web（用于开发 REST 接口）
      • Spring Data JPA（用于 ORM 框架）
      • MySQL Driver（如果使用 MySQL 数据库）

    • 点击 “Generate”，下载项目压缩包。

  3. 解压并用 IntelliJ 打开项目。

  4. 在 pom.xml 中检查生成的依赖：

    <dependencies>
    <!-- Spring Web (REST API) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- JPA for ORM -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MySQL Database Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>
</dependencies>

设置主类

Spring Boot 项目的主类位于 src/main/java/com.example.demo/DemoApplication.java，代码如下：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringDemoApplication.class, args);
    }
}

Step 3: 启动服务

  1. 在 IntelliJ 的右侧，找到主类 DemoApplication，点击绿色箭头以运行项目。

  2. 如果成功，控制台将输出 Spring Boot started 之类的日志并监听默认端口：

    Tomcat started on port(s): 8080

  3. 打开浏览器访问 http://localhost:8080/ （默认是空页面）。

image.png

Step 4: 如何写一个接口

写一个简单的 GET 接口返回固定字符串。

  1. 创建一个控制器类： 在 src/main/java/com.example.demo/controller/ 下新建 HelloController.java，内容如下：

    package com.example.springdemo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring!";
    }
}

  2. 访问接口： 启动项目后，打开浏览器访问：http://localhost:8080/hello。

image.png

Step 5: 如何连接查询数据库（含使用 ORM 框架）

数据库准备

  1. 安装并启动 MySQL。
  • 访问MySQL官方下载页面
  • 下载完成后，双击安装包文件（.msi格式），开始安装。
  • 类型和网络配置：选择服务器类型和端口号，默认端口号为3306，一般保持默认即可。
  • 账户和角色：设置root用户的密码，这是MySQL的超级管理员账户，密码要牢记。

  1. 创建一个数据库和表：

    CREATE DATABASE spring_demo;
CHARACTER SET utf8mb4
COLLATE utf8mb4_general_ci;

USE spring_demo;

CREATE TABLE user (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL
);

INSERT INTO user (name, email) VALUES 
('Alice', 'alice@example.com'),
('Bob', 'bob@example.com');

配置数据库连接

  1. 修改 src/main/resources/application.properties：

    spring.datasource.url=jdbc:mysql://localhost:3306/spring_demo //这是一个JDBC（Java Database Connectivity）连接字符串，用于指定要连接的MySQL数据库的位置和数据库名。jdbc:mysql:// 是MySQL JDBC连接的协议前缀，localhost 表示数据库服务器位于本地机器，3306 是MySQL服务器默认的端口号，spring_demo 是要连接的数据库名称。
spring.datasource.username=root
spring.datasource.password=your_password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

  2. 创建 User 实体类和 UserRepository 接口：

    • User 类：

      package com.example.demo.model;

import jakarta.persistence.*; // 引入 jakarta.persistence 包下的所有类和接口。jakarta.persistence 是Java Persistence API（JPA）的核心包，JPA 是 Java 中用于管理关系型数据库持久化的标准规范。

@Entity // 该注解用于标记一个类为 JPA 实体类。实体类对应数据库中的一张表，JPA 会将该类的实例与数据库表中的记录进行映射。
@Table(name = "user") // 该注解用于指定实体类对应的数据库表名。如果不使用该注解，默认情况下，JPA 会使用实体类的名称作为表名（将类名转换为小写）。参数：name 属性指定了数据库表的名称，这里将 User 类映射到名为 user 的数据库表。
public class User {
    @Id // 该注解用于标记实体类中的一个字段作为主键。在数据库表中，主键用于唯一标识每一条记录。
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 该注解用于指定主键的生成策略。当插入一条新记录时，JPA 会根据指定的策略自动生成主键值。参数：strategy 属性指定了生成策略，GenerationType.IDENTITY 表示使用数据库的自增特性来生成主键值。在 MySQL 等支持自增主键的数据库中，插入记录时，数据库会自动为 id 字段分配一个唯一的自增值。
    private int id;

    private String name;
    private String email;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

    • UserRepository 接口：

      package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface UserRepository extends JpaRepository<User, Integer> {
    //Spring Data JPA 会根据方法名的规则，把方法解析成对应的 SQL 查询语句，不需要你手写查询语句。
    // 更详细文档参考：https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/JpaRepository.html
    // 下面是示例
    
    // 根据 name 查找用户 
    List<User> findByName(String name); 
    // 根据 email 查找用户 
    User findByEmail(String email); 
    // 查询名字包含某个关键字的用户（支持模糊查询） 
    List<User> findByNameContaining(String keyword); 
    // 根据 name 和 email 查找用户 
    List<User> findByNameAndEmail(String name, String email); 
    // 查询名字以 XXX 开头的用户 
    List<User> findByNameStartsWith(String prefix);
}

      通过继承 JpaRepository，Spring Data JPA 提供了对数据库的常用操作，如：

      • findById(id)：根据 ID 查询记录。
      • save(entity)：保存对象到数据库（新增或更新）。
      • deleteById(id)：根据 ID 删除记录。
      • findAll()：查询所有记录。

  3. 创建一个接口用来获取用户：

    package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired; // 自动装配 Spring 容器中的 bean。它允许 Spring 自动注入需要依赖的对象，从而简化 Bean 的创建和管理。
import org.springframework.web.bind.annotation.*; // 导入了 Spring Web 模块中的所有注解，通常包含 `@RestController`、`@RequestMapping`、`@GetMapping`、`@PostMapping`、`@PutMapping` 等。这些注解用于处理 HTTP 请求和构建 RESTful API。

import java.util.List;

@RestController
@RequestMapping("/users") // 设置基础路径为 /users
public class UserController {

    private final UserRepository userRepository;

    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 1. 查询所有用户
    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    // 2. 根据 ID 查询用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Integer id) {
        return userRepository.findById(id).orElse(null); // 防止找不到用户时返回 null
    }

    // 3. 添加用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user); // 新增用户
    }

    // 4. 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Integer id, @RequestBody User newUser) {
        return userRepository.findById(id).map(user -> {
            user.setName(newUser.getName());
            user.setEmail(newUser.getEmail());
            return userRepository.save(user); // 保存更新
        }).orElse(null); // 如果用户不存在返回 null
    }

    // 5. 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Integer id) {
        userRepository.deleteById(id); // 根据 ID 删除用户
    }

    // 6. 根据 Name 查询用户
    @GetMapping("/name/{name}")
    public List<User> getUsersByName(@PathVariable String name) {
        return userRepository.findByName(name);
    }
}

    注意接口的路径设计：

    • GET /users：查询全部用户。
    • GET /users/{id}：根据 ID 查询用户。
    • POST /users：新增用户。
    • PUT /users/{id}：更新用户。
    • DELETE /users/{id}：删除用户。
    • GET /users/name/{name}：根据用户名模糊查询。

    补充知识点

    • @RestController：用于构建 RESTful 接口，默认返回 JSON 数据。
    • @RequestMapping：映射 URL 路径。
    • @PathVariable：用于从 URL 路径中获取参数。
    • @RequestBody：用于接收 POST 或 PUT 请求的 JSON 对象并解析为实体。
    • 异常处理：可以用 @ControllerAdvice 统一处理异常。

  4. 自定义查询场景

    假如你想根据条件动态查询数据库，可以利用 Spring Data JPA 的 @Query 进行自定义查询：

    import org.springframework.data.jpa.repository.Query;

public interface UserRepository extends JpaRepository<User, Integer> {

    // 自定义原生 SQL 查询：根据邮箱后缀查询用户
    @Query(value = "SELECT * FROM user WHERE email LIKE %?1", nativeQuery = true)
    List<User> findByEmailDomain(String domain);

    // JPQL 查询：根据用户名排序
    @Query("SELECT u FROM User u WHERE u.name = ?1 ORDER BY u.id DESC")
    List<User> findByNameSorted(String name);
}
    • nativeQuery = true 表示直接写原生的 SQL。
    • JPQL（Java Persistence Query Language）用于操作实体对象，类似 SQL。

  5. 测试接口： 启动项目，访问 http://localhost:8080/users，你会看到返回的 JSON 数据。

Step 6: 如何打包

  1. 打包为 JAR 文件： 在文件夹中执行以下命令：

    mvn clean package

    打包完毕后，生成的 JAR 文件位于 target/demo-0.0.1-SNAPSHOT.jar。

Step 7: 如何部署

  1. 上传 JAR 文件到服务器。

  2. 执行运行命令：

    java -jar demo-0.0.1-SNAPSHOT.jar

  3. 服务上线，可以通过服务器的 IP 地址访问。

附完整目录结构

E:.
│  .gitattributes
│  .gitignore
│  HELP.md
│  mvnw
│  mvnw.cmd
│  pom.xml
│  
├─.idea
│  │  .gitignore
│  │  compiler.xml
│  │  dataSources.local.xml
│  │  dataSources.xml
│  │  encodings.xml
│  │  jarRepositories.xml
│  │  MarsCodeWorkspaceAppSettings.xml
│  │  misc.xml
│  │  vcs.xml
│  │  workspace.xml
│  │  
│  └─dataSources
├─.mvn
│  └─wrapper
│          maven-wrapper.properties
│          
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─example
│  │  │          └─demo
│  │  │              │  DemoApplication.java
│  │  │              │  
│  │  │              ├─controller
│  │  │              │      HelloController.java
│  │  │              │      UserController.java
│  │  │              │      
│  │  │              ├─model
│  │  │              │      User.java
│  │  │              │      
│  │  │              └─repository
│  │  │                      UserRepository.java
│  │  │                      
│  │  └─resources
│  │      │  application.properties
│  │      │  
│  │      ├─static
│  │      └─templates
│  └─test
│      └─java
│          └─com
│              └─example
│                  └─demo
│                          DemoApplicationTests.java
│                          
└─target
    │  demo-0.0.1-SNAPSHOT.jar
    │  demo-0.0.1-SNAPSHOT.jar.original
    │  
    ├─classes
    │  │  application.properties
    │  │  
    │  └─com
    │      └─example
    │          └─demo
    │              │  DemoApplication.class
    │              │  
    │              ├─controller
    │              │      HelloController.class
    │              │      UserController.class
    │              │      
    │              ├─model
    │              │      User.class
    │              │      
    │              └─repository
    │                      UserRepository.class
    │                      
    ├─generated-sources
    │  └─annotations
    ├─generated-test-sources
    │  └─test-annotations
    ├─maven-archiver
    │      pom.properties
    │      
    ├─maven-status
    │  └─maven-compiler-plugin
    │      ├─compile
    │      │  └─default-compile
    │      │          createdFiles.lst
    │      │          inputFiles.lst
    │      │          
    │      └─testCompile
    │          └─default-testCompile
    │                  createdFiles.lst
    │                  inputFiles.lst
    │                  
    ├─surefire-reports
    │      2025-02-18T16-31-16_857.dumpstream
    │      2025-02-18T17-42-00_218.dumpstream
    │      com.example.demo.DemoApplicationTests.txt
    │      TEST-com.example.demo.DemoApplicationTests.xml
    │      
    └─test-classes
        └─com
            └─example
                └─demo
                        DemoApplicationTests.class

以上就是从零开始创建一个简单的 Spring 项目的完整流程，后续可以继续更复杂的功能，如日志管理、安全认证、API 文档生成等。

avatar
文章
阅读
粉丝