Spring Boot企业级开发入门教程-原创手记-慕课网

概述

Spring Boot企业级开发提供了快速开发框架，简化了配置和开发过程，支持自动配置、内嵌服务器和多种数据库连接，帮助企业高效构建应用。该框架还集成了安全管理、日志管理和监控工具，确保应用的安全和稳定运行。

Spring Boot企业级开发入门教程

Spring Boot简介

Spring Boot是什么

Spring Boot是由Pivotal团队提供的一个基于Spring框架的快速开发框架，它旨在简化新Spring应用的初始搭建以及开发过程。Spring Boot的核心特性之一就是可以快速配置Spring应用程序，使开发人员不需要编写大量的配置代码。

Spring Boot的优势

Spring Boot提供了一系列默认配置，帮助开发者快速上手，同时它还支持任务自动配置、内嵌的服务器、外置的服务器、嵌入式的数据库，以及一系列的实用功能，例如健康检查、性能指标、外部配置、Webflux等。Spring Boot的核心特性可以总结为以下几个方面：

无需编写大量配置代码：通过约定优于配置的原则，Spring Boot提供了一套默认的配置，例如内嵌的Web服务器、日志配置、数据库连接等，开发人员可以直接使用，无需编写大量的配置代码。
自动配置：Spring Boot能够根据类路径中的依赖自动配置应用程序。例如，如果添加了spring-boot-starter-web依赖，Spring Boot会自动配置一个嵌入式的Tomcat，并启用Spring MVC。
起步依赖：Spring Boot提供了一套起步依赖，例如spring-boot-starter-web、spring-boot-starter-data-jpa等，可以快速添加所需的技术栈。
内嵌Web服务器：Spring Boot允许使用spring-boot-starter-web依赖来启动一个内嵌的Web服务器（如Tomcat或Jetty），从而使应用程序更加易于测试和部署。
生产就绪特征：Spring Boot提供了许多生产就绪的特性，例如健康检查、性能指标、外部配置、WebFlux等。

Spring Boot的开发环境搭建

要开始使用Spring Boot，首先需要搭建开发环境，包括安装JDK、Maven或Gradle、IDE等工具。

安装JDK

下载JDK：访问Oracle官网或OpenJDK下载页面下载最新版本的JDK。

安装JDK：安装完成后，设置环境变量：

export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

安装Maven

下载Maven：从Apache Maven下载页面下载。

安装Maven：解压下载的压缩包，设置环境变量：

export MAVEN_HOME=/path/to/maven
export PATH=$MAVEN_HOME/bin:$PATH

安装IDE
可以选择Eclipse、IntelliJ IDEA或Spring Tool Suite等IDE。这里以IntelliJ IDEA为例：

下载IntelliJ IDEA：访问JetBrains官网下载IntelliJ IDEA。
安装IntelliJ IDEA：按照安装向导完成安装。

创建Spring Boot项目

打开IntelliJ IDEA，选择“File -> New -> Project”，选择Spring Initializr以快速创建Spring Boot项目。
输入项目的基本信息，如Group ID、Artifact ID、Name等，并选择合适的Spring Boot版本。
选择所需的功能模块，例如Web、JPA、Security等。
点击“Finish”按钮完成项目创建。

创建Spring Boot项目

创建Spring Boot项目

打开IntelliJ IDEA，选择“File -> New -> Project”菜单。
在打开的窗口中选择“Spring Initializr”，然后点击“Next”。
输入项目的基本信息，如Group ID、Artifact ID、Name等，并选择合适的Spring Boot版本。
选择所需的功能模块，例如Web、JPA、Security等。
点击“Finish”按钮完成项目创建。

生成的项目结构如下：

- src
  - main
    - java
      - com.example.demo
        - DemoApplication.java
    - resources
      - application.properties

编写第一个简单的Spring Boot应用

在DemoApplication.java文件中，编写一个简单的Spring Boot应用程序。首先，创建一个Spring Boot主类，代码如下：

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

运行和测试项目

运行项目：在IDE中右键点击DemoApplication类，选择“Run 'DemoApplication'”来启动应用。
测试项目：默认情况下，Spring Boot会自动配置一个内嵌的Tomcat服务器，并启动一个默认的HTTP端口（通常是8080）。可以使用浏览器访问http://localhost:8080来查看应用是否已经启动成功。

Spring Boot的核心功能详解

自动配置

Spring Boot的自动配置是其核心功能之一。它会根据应用中的依赖自动配置Spring框架。例如，添加了spring-boot-starter-web依赖后，Spring Boot会自动配置一个内嵌的Tomcat服务器并启用Spring MVC。

示例代码

在application.properties中可以配置Tomcat服务器的一些属性，例如端口、最大线程数等：

server.port=8080
server.max-http-header-size=8192

依赖管理和起步依赖

Spring Boot提供了许多起步依赖，这些依赖中包含了实现某一功能所有需要的依赖。例如，spring-boot-starter-web包含了Spring MVC和Tomcat的所有依赖。

示例代码

在pom.xml中添加spring-boot-starter-web依赖：

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

内置的Web服务器

Spring Boot允许我们使用spring-boot-starter-web依赖来启动一个内嵌的Web服务器，例如Tomcat或Jetty。这样可以简化开发和测试过程。

示例代码

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
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

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

运行此应用程序，访问http://localhost:8080将会看到返回的“Hello, Spring Boot!”。

Spring Boot的企业级开发实践

数据库连接与ORM映射

Spring Boot支持多种数据库，包括关系型数据库（如MySQL、PostgreSQL等）和NoSQL数据库（如MongoDB）。这里以关系型数据库为例，介绍如何连接数据库并进行ORM映射。

示例代码

在pom.xml文件中添加数据库驱动依赖：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

在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 Data JPA进行数据操作

Spring Data JPA简化了数据库操作，提供了强大的查询功能、分页等特性。这里以一个简单的用户模型为例，介绍如何使用Spring Data JPA。

示例代码

首先，定义一个简单的用户模型：

package com.example.demo.model;

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;
    // 省略getters和setters
}

然后，创建一个Spring Data JPA的仓库接口：

package com.example.demo.repository;

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

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

最后，编写一个简单的服务类来操作数据库：

package com.example.demo.service;

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

import java.util.List;

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

    public List<User> findAll() {
        return userRepository.findAll();
    }
}

项目日志管理

Spring Boot支持多种日志框架，如Logback、Log4j等。默认情况下，Spring Boot使用Logback作为日志框架。可以通过修改application.properties文件来配置日志级别和其他属性。

示例代码

# 配置日志级别
logging.level.root=INFO
logging.level.com.example.demo=DEBUG

# 配置日志文件位置
logging.file.name=logs/app.log

安全性与认证集成

使用Spring Security进行认证与授权

Spring Security是Spring Boot中用于安全管理的重要组件。它提供了广泛的特性和灵活的配置，可以方便地实现认证和授权功能。

示例代码

首先，添加Spring Security依赖：

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

然后，在配置类中启用Spring Security：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

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

接着，定义一个简单的用户认证配置：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
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;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

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

配置JWT (JSON Web Token) 实现无状态认证

JWT是一种开放标准（RFC 7519），用于在各方之间安全地传输信息。它可以用来实现无状态认证。

示例代码

首先，在pom.xml中添加JWT相关依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

然后，编写一个JWT工具类：

package com.example.demo.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Component
public class JwtTokenUtil {
    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;

    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(secret)
            .parseClaimsJws(token)
            .getBody();
        return claims.getSubject();
    }

    public Date getCreatedDateFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(secret)
            .parseClaimsJws(token)
            .getBody();
        return claims.getIssuedAt();
    }

    public Date getExpirationDateFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(secret)
            .parseClaimsJws(token)
            .getBody();
        return claims.getExpiration();
    }

    public String getJWTToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return Jwts.builder()
            .setClaims(claims)
            .setExpiration(new Date(System.currentTimeMillis() + expiration))
            .signWith(SignatureAlgorithm.HS512, secret)
            .compact();
    }
}

接着，在SecurityConfig类中配置JWT认证：

package com.example.demo.config;

import com.example.demo.util.JwtTokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtRequestFilter extends OncePerRequestFilter {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        final String requestTokenHeader = request.getHeader("Authorization");
        String username = null;
        String jwtToken = null;
        if (requestTokenHeader != null && requestTokenHeader.startsWith("Bearer ")) {
            jwtToken = requestTokenHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(jwtToken);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

部署与监控

打包与部署Spring Boot应用

Spring Boot应用可以通过Maven或Gradle进行打包。打包后的应用可以使用java -jar命令启动。

示例代码

使用Maven打包：

mvn clean package

打包后的应用位于target目录下，使用以下命令启动：

java -jar target/demo-0.0.1-SNAPSHOT.jar

应用监控与日志分析

Spring Boot提供了多种内建的监控特性，如Actuator、Micrometer等。Actuator提供了多种可供选择的端点来监控应用运行状态。

示例代码

启用Actuator：

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

访问端点：http://localhost:8080/actuator，可以查看应用运行时的各种状态信息。

使用Docker部署Spring Boot应用

使用Docker可以简化部署过程，将应用打包成一个Docker镜像，然后在任何支持Docker的环境中运行。

示例代码

编写Dockerfile：

FROM openjdk:8-jre-alpine
VOLUME /tmp
ADD target/demo-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

构建Docker镜像：

docker build -t demo:0.0.1 .

运行Docker容器：

docker run -p 8080:8080 demo:0.0.1