Springboot企业级开发入门教程

概述

Spring Boot企业级开发入门教程旨在帮助开发者快速掌握Spring Boot框架的核心概念和优势，包括自动配置、嵌入式服务器和外部化配置等功能。文章详细介绍了从开发环境搭建到创建第一个Spring Boot项目，再到数据库集成、RESTful接口开发、安全性配置和日志管理等各个步骤，并提供了详细的配置和代码示例。

Spring Boot 简介

什么是 Spring Boot

Spring Boot是由Pivotal团队提供的基于Spring平台的快速开发框架。它简化了Spring框架的配置，使开发者能够快速构建独立的、生产级别的应用。Spring Boot的主要目标是简化开发、简化配置以及减少开发人员的工作量。它通过“约定优于配置”的理念，极大地方便了开发者。

Spring Boot 的优势

1. 快速启动：Spring Boot提供了一种简单、无需或只需很少配置的基于Spring应用创建方法。
2. 自动配置：根据所添加的jar依赖进行自动配置，例如添加spring-boot-starter-data-jpa后，Spring Boot会自动配置好JPA。
3. 嵌入式服务器：内置了Tomcat、Jetty或者Undertow服务器，可以直接运行应用，无需部署到外部容器。
4. 无需XML配置：在Spring Boot中，大部分配置都采用注解的方式，极大地减少了XML配置。
5. 起步依赖：通过提供许多的spring-boot-starter-*依赖，极大地方便了项目的依赖管理和配置。
6. 命令行工具：Spring Boot包含一个命令行工具Spring Boot CLI，可以在命令行中运行Groovy脚本和Spring Boot应用程序。
7. 外部化配置：支持设置外部化配置，环境变量或properties文件可以轻松地覆盖默认值。
8. 健康检查：内置了Actuator，可以监控应用的健康状态。
9. 集成测试支持：提供对JUnit和Spring Test的支持，简单、轻量级的测试框架。

开发环境搭建

搭建Spring Boot开发环境需要以下步骤：

1. 安装JDK：确保安装了Java开发工具包（JDK）。
2. 安装Maven或Gradle：选择一种构建工具，如Maven或Gradle。
3. 安装IDE：可以选择Eclipse、IntelliJ IDEA或其他支持Java开发的IDE。
4. 创建Spring Boot项目：
   • 使用Spring Initializr服务（https://start.spring.io/）或者通过IDE插件（如IntelliJ IDEA的Spring Boot插件）创建项目。
   • 下面是一个简单的Maven项目的目录结构：

<project>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </build>
</project>

1. 运行应用：在IDE中运行SpringApplication类，或者使用Maven或Gradle命令启动应用。

快速上手 Spring Boot

创建第一个 Spring Boot 项目

1. 使用Spring Initializr创建一个新的Maven项目，选择Spring Web依赖。
2. 创建一个简单的HelloWorld控制器：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {

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

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

1. 在src/main/resources目录下创建application.properties文件，添加一些基本的配置：

# server configuration
server.port=8080
server.servlet.context-path=/api

# database configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# application configuration
spring.application.name=MyApp

1. 运行应用，访问http://localhost:8080。

配置文件详解

Spring Boot支持多种配置文件格式，包括application.properties和application.yml。配置文件可以设置许多Spring Boot的属性，例如：

# server configuration
server.port=8080
server.servlet.context-path=/api

# database configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# application configuration
spring.application.name=MyApp

此外，还可以通过自定义配置类来配置一些特定的属性，例如：

@Configuration
public class CustomConfig {

    @Bean
    public DataSource dataSource() {
        // 自定义数据源配置
        return new DriverManagerDataSource("jdbc:mysql://localhost:3306/mydb", "root", "password");
    }
}

使用 Spring Boot Starter 简化开发

Spring Boot Starter提供了一种非常方便的方式来添加依赖。例如，添加spring-boot-starter-web会自动配置好Servlet容器和基本的Web支持。

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

数据库集成

Spring Boot 与 MyBatis 集成

MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。将MyBatis集成到Spring Boot中可以通过添加spring-boot-starter-mybatis依赖来实现。

1. 添加依赖：

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

1. 配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
mybatis.mapper-locations=classpath*:mapper/*.xml

1. 创建一个MyBatis接口：

package com.example.demo.mapper;

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

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectUserById(Long id);
}

1. 创建一个MyBatis实体类：

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

@TableName("user")
public class User {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;

    // Getters and Setters
}

1. 创建一个MyBatis映射文件：

<?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="selectUserById" resultType="com.example.demo.entity.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

Spring Boot 与 JPA 集成

JPA（Java Persistence API）是Java EE一个强大的持久化层框架，提供了标准的数据访问对象DAO抽象。将JPA集成到Spring Boot中可以通过添加spring-boot-starter-data-jpa依赖来实现。

1. 添加依赖：

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

1. 配置数据库连接信息：

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

1. 创建一个JPA实体类：

package com.example.demo.entity;

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

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;

    // Getters and Setters
}

1. 创建一个JPA仓库接口：

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

数据库连接和配置

数据库连接和配置可以通过Spring Boot的DataSource配置来实现。以下是application.properties文件中的配置示例：

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

RESTful 接口开发

使用 Spring MVC 创建 RESTful 接口

Spring MVC提供了构建RESTful API的强大支持。通过注解，可以非常方便地创建、读取、更新和删除资源。

1. 创建一个REST控制器：

package com.example.demo.controller;

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

import java.util.List;

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

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getUsers(@RequestParam(value = "page", defaultValue = "0") int page,
                               @RequestParam(value = "size", defaultValue = "10") int size) {
        Pageable pageable = PageRequest.of(page, size);
        return userRepository.findAll(pageable);
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userRepository.save(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

1. 配置application.properties：

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

参数绑定和响应返回

参数绑定可以通过@PathVariable、@RequestParam和@RequestBody注解实现。响应返回可以使用@ResponseBody注解，或者直接返回实体对象。

参数绑定示例

@GetMapping("/users")
public List<User> getUsers(@RequestParam(value = "page", defaultValue = "0") int page,
                           @RequestParam(value = "size", defaultValue = "10") int size) {
    Pageable pageable = PageRequest.of(page, size);
    return userRepository.findAll(pageable);
}

响应返回示例

@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
    return userRepository.findById(id).orElse(null);
}

错误处理和异常处理

Spring Boot提供了强大的错误处理功能，可以通过自定义全局异常处理器来处理和响应错误。

1. 创建一个全局异常处理器：

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;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    protected ResponseEntity<ErrorResponse> handleResourceNotFoundException(ResourceNotFoundException ex) {
        return new ResponseEntity<>(new ErrorResponse(HttpStatus.NOT_FOUND, ex.getMessage()), HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    protected ResponseEntity<ErrorResponse> handleException(Exception ex) {
        return new ResponseEntity<>(new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR, ex.getMessage()), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

1. 创建一个错误响应类：

package com.example.demo.exception;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.http.HttpStatus;

import java.util.Date;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ErrorResponse {

    @JsonProperty("timestamp")
    private Date timestamp;

    @JsonProperty("status")
    private int status;

    @JsonProperty("error")
    private String error;

    @JsonProperty("message")
    private String message;

    @JsonProperty("path")
    private String path;

    public ErrorResponse(HttpStatus status, String message) {
        this.status = status.value();
        this.message = message;
        this.timestamp = new Date();
        this.path = "";
    }

    // Getters and Setters
}

1. 配置application.properties：

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

安全性配置

基本的权限控制

Spring Boot提供了@Secured或@PreAuthorize注解来实现基本的权限控制。

1. 创建一个安全配置类：

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/**").permitAll()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("user").password("{noop}password").roles("USER")
                .and()
                .withUser("admin").password("{noop}password").roles("ADMIN");
    }
}

1. 创建一个登录页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login Page</title>
</head>
<body>
    <form action="/login" method="post">
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
        <br>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
        <br>
        <input type="submit" value="Login">
    </form>
</body>
</html>

1. 配置application.properties：

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

使用 Spring Security 实现安全认证

Spring Security是一个强大的安全管理框架，可以用于处理用户认证和授权。

1. 添加依赖：

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

1. 配置安全类：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER")
            .and()
            .withUser("admin").password("{noop}password").roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/**").permitAll()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }
}

1. 创建一个登录页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login Page</title>
</head>
<body>
    <form action="/login" method="post">
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
        <br>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
        <br>
        <input type="submit" value="Login">
    </form>
</body>
</html>

1. 配置application.properties：

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

认证和授权的基础

Spring Security提供了多种认证和授权方式，包括内存认证、数据库认证等。这里使用了内存认证，通过InMemoryUserDetailsManager来管理用户信息。

日志管理和监控

日志管理配置

Spring Boot提供了多种日志管理方式，包括Logback、Log4j2和Java Util Logging。Logback是默认的日志框架。

1. 配置application.properties：

# Logging configuration
logging.level.root=INFO
logging.level.com.example.demo=DEBUG
logging.file.name=springboot.log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

1. 如果需要更详细的日志配置，可以添加一个logback-spring.xml文件：

<configuration>
    <property name="LOG_PATH" value="/logs" />

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>${LOG_PATH}/springboot.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.example.demo" level="DEBUG" />

    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>
</configuration>

应用监控和健康检查

Spring Boot Actuator提供了大量的监控端点，可以帮助开发者监控应用的运行状态。

1. 添加依赖：

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

1. 配置application.properties：

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

1. 访问监控端点，例如http://localhost:8080/actuator，可以查看应用的健康状态、日志文件位置等信息。

使用 Actuator 监控点

Actuator提供了多个监控端点，例如/actuator/health、/actuator/env、/actuator/metrics等。

1. 访问健康状态端点：

GET http://localhost:8080/actuator/health

1. 访问环境信息端点：

GET http://localhost:8080/actuator/env

1. 访问度量指标端点：

GET http://localhost:8080/actuator/metrics