Spring Boot项目入门：简单教程详解-原创手记-慕课网

概述

本文详细介绍了如何入门Spring Boot项目，涵盖了项目的创建、环境配置、核心配置以及数据库集成等内容。通过本教程，读者可以快速掌握Spring Boot项目的开发方法和技巧，轻松开发出功能丰富的应用。Spring Boot项目入门不仅简化了开发流程，还提高了开发效率。

Spring Boot项目入门：简单教程详解

1. Spring Boot简介

1.1 什么是Spring Boot

Spring Boot是由Pivotal团队提供的基于Spring框架的创建独立运行的（独立的可执行的）Spring项目的一种新的方式。其主要目的是简化Spring应用的初始搭建以及开发过程，通过约定大于配置的原则，让开发人员能够快速地编写出独立的、功能丰富的应用。

1.2 Spring Boot的优势

简化配置：Spring Boot通过约定大于配置的原则，极大地简化了Spring应用的配置。它提供了默认配置，使得开发人员可以专注于应用程序的业务逻辑。
快速启动：Spring Boot支持嵌入式的Tomcat、Jetty和Undertow服务器，可以直接运行，无需部署到外部容器。
自动配置：Spring Boot会根据应用的依赖自动配置所需的内容，例如数据库连接、缓存、日志等。
嵌入式Web服务器：Spring Boot可以通过嵌入式Web服务器（如Tomcat）直接运行，无需部署到外部容器。
生产就绪功能：诸如指标、健康检查、外部配置等特性使得应用可以直接部署到生产环境。

1.3 环境准备与安装

1.3.1 安装JDK

确保你的机器上安装了Java Development Kit (JDK)。你可以在Oracle官网或OpenJDK获取JDK安装包。

1.3.2 安装IDE

推荐使用IntelliJ IDEA或Spring Tool Suite (STS)等IDE进行开发。这些IDE提供了丰富的支持，使得Spring Boot项目的开发更加高效。

1.3.3 安装Maven或Gradle

Spring Boot项目通常使用Maven或Gradle进行依赖管理。确保安装了相应的构建工具。

1.3.4 安装Spring Boot插件

如果使用IDEA或STS，可以安装相应的Spring Boot插件，以便更好地支持Spring Boot项目。

2. 创建第一个Spring Boot项目

2.1 使用IDE创建项目

以IntelliJ IDEA为例，创建一个Spring Boot项目：

打开IDEA，选择“File” -> “New” -> “Project”。
在打开的对话框中，选择“Spring Initializr”，然后点击“Next”。
输入项目的基本信息，如Group ID、Artifact ID、Name等。选择版本为2.x或3.x的Spring Boot。
在“Dependencies”选项卡中选择所需的功能模块，如Web、JPA等。
点击“Finish”完成项目创建。

2.2 使用Spring Initializr快速搭建项目

Spring Initializr提供了在线的项目生成工具，可以通过访问https://start.spring.io/来快速创建Spring Boot项目。

访问Spring Initializr网站。
配置项目的基本信息，如Project、Language、Spring Boot版本等。
在“Dependencies”选项卡中选择所需的功能模块，如Web、JPA等。
点击“Generate”下载项目压缩包。
解压下载的压缩包，导入到IDE中。

2.3 项目目录结构解析

一个典型的Spring Boot项目的结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               └── controller
│   │                   └── HelloController.java
│   ├── resources
│   │   ├── application.properties
│   │   ├── static
│   │   ├── templates
│   │   └── application.yml
└── test
    └── java
        └── com
            └── example
                └── demo
                    └── DemoApplicationTests.java

DemoApplication.java：主程序入口，启动整个应用。

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);
    }
}

HelloController.java：一个简单的Controller，用于处理HTTP请求。

package com.example.demo.controller;

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

@RestController
@RequestMapping("/api")
public class HelloController {

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

application.properties和application.yml：应用配置文件。
static：静态资源目录，存放如CSS、JavaScript、图片等静态文件。
templates：存放Thymeleaf模板文件。
DemoApplicationTests.java：测试类，用于测试应用的功能。

package com.example.demo;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {

    private TestRestTemplate restTemplate = new TestRestTemplate();

    public void contextLoads() {
        ResponseEntity<String> entity = restTemplate.getForEntity("/api/hello", String.class);
        assertEquals("Hello, World!", entity.getBody());
    }
}

3. Spring Boot核心配置

3.1 application.properties与application.yml配置详解

Spring Boot配置文件主要有两种格式：application.properties和application.yml。两种格式都可以，但通常推荐使用application.yml，因为它更简洁。

3.1.1 属性配置

配置文件中的属性可以分为以下几种类型：

基本属性：

服务器端口：

# application.properties
server.port=8080

# application.yml
server:
port: 8080

日志配置：

设置日志级别：

# application.properties
logging.level.root=INFO

# application.yml
logging:
level:
 root: INFO

数据源配置：

配置MySQL数据源：

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# application.yml
spring:
datasource:
 url: jdbc:mysql://localhost:3306/testdb
 username: root
 password: root
 driver-class-name: com.mysql.cj.jdbc.Driver

3.1.2 文件配置

配置文件还可以用于配置其他文件的路径：

# application.properties
spring.messages.basename=i18n/messages

# application.yml
spring:
  messages:
  basename: i18n/messages

3.2 自动配置原理

Spring Boot通过@EnableAutoConfiguration注解实现了自动配置。当Spring Boot启动时，会扫描META-INF/spring.factories文件中的配置类，并根据类名加载配置。

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

3.3 简单配置示例

以下是一个简单的配置示例，配置应用的端口号和日志级别：

# application.properties
server.port=8080
logging.level.root=INFO

# application.yml
server:
  port: 8080
logging:
  level:
    root: INFO

在Java代码中可以通过@Value注解来读取配置文件中的属性：

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Value("${server.port}")
    private String serverPort;

    @Value("${logging.level.root}")
    private String logLevel;

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Server port: " + serverPort);
        System.out.println("Log level: " + logLevel);
    }
}

4. 使用Spring Boot开发RESTful API

4.1 创建Controller

在Spring Boot中，Controller负责处理HTTP请求。创建一个简单的Controller类，实现RESTful API。

package com.example.demo.controller;

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

@RestController
@RequestMapping("/api")
public class HelloController {

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

4.2 使用注解开发RESTful风格API

使用@GetMapping、@PostMapping等注解可以快速开发RESTful风格的API。

package com.example.demo.controller;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/users")
    public List<User> getAllUsers() {
        // 返回所有用户列表
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        // 创建新的用户
    }

    @PutMapping("/users")
    public User updateUser(@RequestBody User user) {
        // 更新用户信息
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable int id) {
        // 删除指定ID的用户
    }
}

4.3 测试API

可以使用Postman等工具测试API，或者使用Spring Boot的内置测试功能。

package com.example.demo;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {

    private TestRestTemplate restTemplate = new TestRestTemplate();

    public void contextLoads() {
        ResponseEntity<String> entity = restTemplate.getForEntity("/api/hello", String.class);
        assertEquals("Hello, World!", entity.getBody());
    }
}

5. 数据库集成与操作

5.1 Spring Boot整合MyBatis及JPA

5.1.1 MyBatis

引入依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mybatis</artifactId>
</dependency>

配置MyBatis：

mybatis:
 mapper-locations: classpath:mapper/*.xml
 type-aliases-package: com.example.demo.entity

编写Mapper接口：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {
   User getUserById(int id);
}

编写Mapper XML文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
   <select id="getUserById" resultType="com.example.demo.entity.User">
       SELECT * FROM users WHERE id = #{id}
   </select>
</mapper>

5.1.2 JPA

引入依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

配置数据库连接：

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/testdb
   username: root
   password: root
   driver-class-name: com.mysql.cj.jdbc.Driver
 jpa:
   hibernate:
     ddl-auto: update

编写实体类：

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.AUTO)
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

编写Repository接口：

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> {
}

5.2 数据库连接配置

根据不同的数据库选择不同的连接配置。以下是一个MySQL数据库连接配置示例：

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/testdb
  username: root
  password: root
  driver-class-name: com.mysql.cj.jdbc.Driver

5.3 CRUD操作示例

5.3.1 使用MyBatis

package com.example.demo.service;

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

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }
}

5.3.2 使用JPA

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(int id) {
        return userRepository.findById(id).orElse(null);
    }
}

6. 其他常用功能介绍

6.1 日志管理

Spring Boot集成了多种日志框架，如SLF4J、Logback、Log4j等。默认使用Logback进行日志记录。

6.1.1 配置日志级别

logging:
  level:
  root: INFO
  com.example.demo: DEBUG

6.1.2 自定义日志文件路径

logging:
  file: /path/to/logfile.log

在Java代码中，可以通过Logger来控制日志输出：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExampleService {
    private static final Logger logger = LoggerFactory.getLogger(ExampleService.class);

    public void doSomething() {
        logger.info("Doing something...");
    }
}

6.2 异常处理

Spring Boot可以通过全局异常处理器来统一处理应用中的异常。

package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(value = {Exception.class})
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        ErrorResponse error = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage());
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

class ErrorResponse {
    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
    }

    int status;
    String message;
}

6.3 安全认证简介

Spring Boot集成了Spring Security，可以方便地实现安全认证功能。

6.3.1 引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

6.3.2 配置安全认证

spring:
  security:
  basic:
    enabled: true
  user:
    name: admin
    password: admin

6.3.3 自定义认证处理

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/hello").permitAll()
            .anyRequest().authenticated()
            .and()
            .httpBasic();
    }

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build());
        return manager;
    }
}

以上是Spring Boot项目入门的详细教程，涵盖了从项目创建、配置到数据库集成和安全认证等多个方面。通过本教程的学习，你将能够快速上手并开发出功能丰富的Spring Boot应用。