Springboot项目开发学习：初学者入门指南

概述

本文提供了Spring Boot项目开发学习的全面指南，涵盖了Spring Boot的基本概念、环境搭建、常用注解和配置文件详解等内容。通过详细步骤，帮助初学者快速上手Spring Boot项目开发。文中还包括了数据库连接与JPA集成的详细说明，以及如何创建RESTful服务的具体方法。

Springboot项目开发学习：初学者入门指南 Spring Boot简介

什么是Spring Boot

Spring Boot是由Pivotal团队提供的框架，旨在简化新Spring应用的初始搭建以及开发过程。它通过提供一系列开箱即用的特性简化了Spring应用的开发，例如自动配置、内嵌web服务器、starter依赖管理等。

Spring Boot的优势

1. 简化项目搭建：提供多种Spring应用的初始搭建以及开发过程，减少了大量配置文件。
2. 自动配置：通过@SpringBootApplication注解，Spring Boot能够自动配置大多数Spring应用，减少了大量的配置工作。
3. 内嵌web服务器：Spring Boot提供内嵌的Tomcat或Jetty等Web服务器，可以直接运行，无需部署到外部服务器。
4. 起步依赖：通过一系列的Spring Boot Starter依赖，可以快速引入所需的库，比如spring-boot-starter-web、spring-boot-starter-data-jpa等。
5. 生产就绪特性：提供一系列的生产就绪特性，如Actuator、AOP、Security等。

Spring Boot的核心概念

1. Starter依赖：Spring Boot通过一系列的Starter依赖，简化了开发过程。每个Starter依赖都包含了一组常见的依赖。
2. 自动配置：Spring Boot能够自动配置大多数Spring应用，但开发者也可以通过配置文件覆盖这些默认配置。
3. Actuator：Spring Boot Actuator提供了生产就绪特性，包括健康检查、指标收集、审计功能等。
4. Web应用：Spring Boot允许开发者轻松创建Web应用，支持多种视图技术，如Thymeleaf、FreeMarker等。
5. 外部化配置：Spring Boot支持外部化配置，可以通过环境变量、命令行参数、系统属性等方式引入配置。

环境搭建

安装Java开发环境

首先，确保安装了Java开发环境。可以通过以下步骤下载和安装Java SE Development Kit (JDK)：

1. 访问Oracle官网下载JDK。
2. 双击下载的安装包，按照安装向导完成安装。
3. 打开命令行工具，输入以下命令检查Java版本：

   java -version

安装并配置IDE（如IntelliJ IDEA或Eclipse）

选择一个合适的IDE进行开发，例如IntelliJ IDEA或Eclipse。安装完毕后，按照以下步骤配置IDE：

1. IntelliJ IDEA

   • 打开IntelliJ IDEA，选择File -> New -> Project。
   • 选择Spring Initializr，点击Next。
   • 选择Project SDK为已安装的Java版本，确保Language level为11或更高。
   • 在Project Metadata中，填写Group（如com.example）和Artifact（如demo）。
   • 在Project SDK中选择已安装的JDK版本。
   • 在Dependencies中，选择所需的技术栈，例如Spring Web、Spring Data JPA等。
   • 完成配置后，点击Finish，IDE将创建项目并自动下载所需的依赖。

2. Eclipse

   • 打开Eclipse，选择File -> New -> Dynamic Web Project。
   • 选择Web Application Framework为Spring Web，点击Next。
   • 在Project Name中填写项目名称（如demo）。
   • 选择Use Project References，点击Next。
   • 在Targeted Runtime中选择已安装的Tomcat或Jetty。
   • 点击Finish，Eclipse将创建项目并自动下载所需的依赖。

下载Spring Boot Starter项目

访问Spring Initializr，选择所需的技术栈，例如Spring Web、Spring Data JPA等，生成项目依赖文件（如pom.xml或build.gradle）。

<!-- pom.xml 示例 -->
<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>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
  </dependencies>
</project>

创建第一个Spring Boot项目

1. 创建一个Java类，标注@SpringBootApplication注解。

package com.example.demo;

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

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

1. 在IDE中运行DemoApplication类，启动Spring Boot应用。

Spring Boot常用注解

@SpringBootApplication

@SpringBootApplication注解是一个复合注解，包含以下三个注解：@Configuration、@EnableAutoConfiguration和@ComponentScan。

• @Configuration：表示配置类，可以用来配置Bean。
• @EnableAutoConfiguration：启用自动配置。
• @ComponentScan：扫描并注册组件，扫描当前类所在包及其子包下的所有标注有@Component、@Service、@Repository、@Controller等注解的类。

package com.example.demo;

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

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

@Controller, @Service, @Repository, @Component

• @Controller：标记一个类为控制器，用于处理HTTP请求。
• @Service：标记一个类为服务类，负责业务逻辑处理。
• @Repository：标记一个类为数据访问层，负责数据库访问。
• @Component：通用组件注解，作为其他注解的基类。

package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    // 业务逻辑代码
}

package com.example.demo.controller;

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

@RestController
public class UserController {
    @RequestMapping("/users")
    public String getUsers() {
        return "Hello, Users!";
    }
}

@RequestMapping及其子注解（@GetMapping, @PostMapping等）

@RequestMapping用于映射处理请求，可以指定请求的方法和路径。其子注解分别映射GET和POST请求。

• @GetMapping：映射GET请求。
• @PostMapping：映射POST请求。

package com.example.demo.controller;

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

@RestController
public class UserController {
    @GetMapping("/users")
    public String getUsers() {
        return "Hello, Users!";
    }

    @PostMapping("/users")
    public String createUser() {
        return "User created!";
    }
}

配置文件详解

application.properties与application.yml的区别

Spring Boot支持两种配置文件：application.properties和application.yml。

• application.properties：属性文件，使用键值对的方式定义配置。
• application.yml：YAML文件，采用键值对和嵌套的方式定义配置。

# application.properties 示例
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# application.yml 示例
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

常用配置参数说明

• spring.datasource.url：数据库连接URL。
• spring.datasource.username：数据库用户名。
• spring.datasource.password：数据库密码。
• server.port：应用服务器端口。
• server.servlet.context-path：应用服务器上下文路径。

# application.properties 示例
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
server.port=8080
server.servlet.context-path=/api

外部化配置

Spring Boot支持外部化配置，可以通过环境变量、命令行参数、系统属性等方式引入配置。

环境变量

在环境变量中设置数据库连接信息：

export DB_URL=jdbc:mysql://localhost:3306/mydb
export DB_USERNAME=root
export DB_PASSWORD=root

命令行参数

在命令行中设置数据库连接信息：

mvn spring-boot:run -Dspring.datasource.url=jdbc:mysql://localhost:3306/mydb -Dspring.datasource.username=root -Dspring.datasource.password=root

系统属性

在IDE中设置系统属性，例如通过IDE的运行配置界面设置属性。

# .properties 文件中引入外部化配置
spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

# .yml 文件中引入外部化配置
spring:
  datasource:
    url: ${DB_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

数据库连接与JPA集成

如何连接MySQL数据库

在application.properties或application.yml中配置MySQL数据库连接信息。

# application.properties 示例
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# application.yml 示例
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

配置JPA实体类

创建JPA实体类，标注@Entity注解。

package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // 构造函数、getter和setter省略
}

创建数据库模型

创建数据库模型，例如在MySQL数据库中创建一个users表：

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL
);

查询数据

创建JPA仓库接口，继承JpaRepository。

package com.example.demo.repository;

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

public interface UserRepository extends JpaRepository<User, Long> {
}

创建服务类，注入仓库接口。

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

创建控制器，调用服务类方法。

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.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;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

测试数据库操作

使用Postman或浏览器测试数据库操作。

# 获取用户
GET http://localhost:8080/api/users/1

# 插入用户
POST http://localhost:8080/api/users
Content-Type: application/json

{
    "name": "John Doe",
    "email": "john.doe@example.com"
}

创建RESTful服务

创建Controller

创建一个控制器类，标注@RestController注解。

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.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.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

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

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

RESTful接口设计

设计RESTful接口，使用HTTP方法和URL路径进行资源操作。

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

测试RESTful接口

使用Postman或浏览器测试RESTful接口。

# 获取用户
GET http://localhost:8080/api/users/1

# 创建用户
POST http://localhost:8080/api/users
Content-Type: application/json

{
    "name": "John Doe",
   .
    .
    .
}