Springboot入门详解：从零开始搭建第一个Web应用-原创手记-慕课网

概述

Spring Boot 是由Pivotal团队提供的一款基于Spring框架的开源项目，旨在简化应用开发流程。它通过提供一系列默认配置，使开发者能够快速上手并构建独立的生产级别应用。本文详细介绍了Spring Boot的环境搭建、核心概念、快速入门项目、常见功能实现、项目部署以及调试与测试方法。

Spring Boot简介与环境搭建

什么是Spring Boot

Spring Boot 是由Pivotal团队提供的一个基于Spring框架的开源项目，旨在简化Spring应用的初始搭建及开发过程。通过提供一系列默认配置，使开发者能够快速上手并构建独立的、生产级别的Spring应用。

Spring Boot具有以下主要特点：

独立运行：提供可执行的jar文件，可以独立运行。
内嵌服务器：默认内嵌了Tomcat、Jetty或Undertow等Web服务器。
自动配置：自动配置应用中的Spring Beans，减少了大量的配置工作。
约定优于配置：遵循一系列有效的约定，使开发更加高效。
无代码生成：不需要生成任何XML配置文件。
全面的特性：集成Spring Framework的大部分模块。
Actuator：提供了生产中管理应用端点，如健康状况、信息等。
模板支持：支持Thymeleaf、Mustache、JSP等模板引擎。
嵌入式数据库：支持H2、HSQL等嵌入式数据库。
全新开源的API：Spring Boot具有自己的API，主要是spring-boot-starter-xxx。

开发环境搭建

为了开始使用Spring Boot进行开发，需要安装Java开发工具包（JDK）和一个集成开发环境（IDE）。以下是基本的开发环境搭建步骤：

安装JDK：Java 8及以上版本。
安装IDE：推荐使用IntelliJ IDEA或Eclipse，这里以IntelliJ IDEA为例进行说明。

安装JDK

访问JDK官网，下载最新版本的Java开发工具包。
安装JDK时，确保添加环境变量。

export JAVA_HOME=/usr/local/java/jdk-17.0.1
export PATH=$JAVA_HOME/bin:$PATH

验证安装：

java -version

安装IntelliJ IDEA

访问IntelliJ IDEA官网，下载社区版（Community Edition）。
安装完IDEA后，打开软件，首次启动会提示你选择安装类型，选择默认安装即可。
在IDEA中打开或创建新项目。

快速入门项目

为快速入门，可以使用Spring Initializr（https://start.spring.io/）来创建一个最基本的Spring Boot项目。以下是步骤：

访问Spring Initializr官方网站。
选择项目的基本信息：语言（Java）、Spring Boot版本、项目元数据（项目名、组名、描述）。
选择依赖模块，如Spring Web、JPA、Thymeleaf等。
生成项目。

生成后的项目结构通常如下：

spring-boot-quickstart/
│
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── quickstart/
│   │   │               ├── QuickstartApplication.java
│   │   │               └── controller/
│   │   │                   └── HelloController.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   │           └── index.html
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── quickstart/
│                       └── QuickstartApplicationTests.java
└── pom.xml

Spring Boot核心概念与配置

自动配置简介

Spring Boot的核心概念之一是自动配置。Spring Boot通过扫描项目中的依赖和指定的配置文件，自动配置应用所需的组件。自动配置功能简化了应用开发。

依赖与起步依赖

在Spring Boot应用中，依赖管理使用Maven或Gradle来处理。Spring Boot提供了大量的起步依赖（spring-boot-starter-xxx），每个起步依赖都包含了相应功能所需的模块及其依赖项，从而简化了模块的引入。例如：

spring-boot-starter-web：包含开发Web应用所需的所有依赖。
spring-boot-starter-data-jpa：包含JPA（Java Persistence API）和Hibernate相关依赖。
spring-boot-starter-security：包含Spring Security相关依赖。

配置文件详解

Spring Boot使用application.properties或application.yml文件来进行配置。默认情况下，这些配置文件位于src/main/resources目录下。

application.properties 示例

# 端口号配置
server.port=8080

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

创建第一个Spring Boot应用

创建项目

使用Spring Initializr创建一个新项目，选择Spring Web作为起步依赖。

添加依赖

在pom.xml文件中添加Spring Boot的起步依赖。

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

编写第一个RESTful API

创建一个简单的RESTful API来返回一个JSON对象。

创建一个简单的Spring Boot应用类：

package com.example.quickstart;

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

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

创建一个控制器类，定义API端点：

package com.example.quickstart.controller;

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

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

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

    @GetMapping("/hello")
    public Map<String, String> hello() {
        Map<String, String> response = new HashMap<>();
        response.put("message", "Hello, Spring Boot!");
        return response;
    }
}

Spring Boot常见功能实现

数据库集成（JPA, MyBatis等）

JPA集成

在pom.xml中添加JPA和MySQL的起步依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<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.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

创建实体类：

package com.example.quickstart.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;

   // Getters and Setters
}

创建JPA Repository：

package com.example.quickstart.repository;

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

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

创建一个服务类来使用Repository：

package com.example.quickstart.service;

import com.example.quickstart.entity.User;
import com.example.quickstart.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> getAllUsers() {
       return userRepository.findAll();
   }
}

在控制器中调用服务：

package com.example.quickstart.controller;

import com.example.quickstart.service.UserService;
import com.example.quickstart.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

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

   @Autowired
   private UserService userService;

   @GetMapping("/users")
   public List<User> getUsers() {
       return userService.getAllUsers();
   }
}

MyBatis集成

在pom.xml中添加MyBatis和MySQL的起步依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mybatis</artifactId>
</dependency>
<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

mybatis.mapper-locations=classpath:mapper/*.xml

创建实体类：

package com.example.quickstart.entity;

public class MyBatisUser {
   private Long id;
   private String name;
   private String email;

   // Getters and Setters
}

创建Mapper接口：

package com.example.quickstart.mapper;

import com.example.quickstart.entity.MyBatisUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface MyBatisUserMapper {
   @Select("SELECT * FROM users")
   List<MyBatisUser> getAllUsers();
}

创建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.quickstart.mapper.MyBatisUserMapper">

   <resultMap id="userResultMap" type="com.example.quickstart.entity.MyBatisUser">
       <id column="id" property="id" />
       <result column="name" property="name" />
       <result column="email" property="email" />
   </resultMap>

   <select id="getAllUsers" resultMap="userResultMap">
       SELECT * FROM users
   </select>
</mapper>

创建Service层代码：

package com.example.quickstart.service;

import com.example.quickstart.entity.MyBatisUser;
import com.example.quickstart.mapper.MyBatisUserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class MyBatisUserService {

   @Autowired
   private MyBatisUserMapper myBatisUserMapper;

   public List<MyBatisUser> getAllUsers() {
       return myBatisUserMapper.getAllUsers();
   }
}

在控制器中调用MyBatis服务：

package com.example.quickstart.controller;

import com.example.quickstart.service.MyBatisUserService;
import com.example.quickstart.entity.MyBatisUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

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

   @Autowired
   private MyBatisUserService myBatisUserService;

   @GetMapping("/mybatisUsers")
   public List<MyBatisUser> getMyBatisUsers() {
       return myBatisUserService.getAllUsers();
   }
}

日志管理

Spring Boot的默认日志管理使用SLF4J和Logback。在application.properties中可以配置日志级别：

logging.level.root=WARN
logging.level.com.example=WARN

可以使用@Slf4j注解来在类中引入日志记录工具。

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

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

    public void exampleMethod() {
        logger.info("This is an info message.");
        logger.warn("This is a warning message.");
    }
}

安全认证（Spring Security）

添加Spring Security的起步依赖：

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

创建一个安全配置类：

package com.example.quickstart.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.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@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();
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

Spring Boot项目部署

打包与发布

使用Maven或Gradle打包Spring Boot应用为可执行的JAR文件。

Maven打包

mvn clean package

Gradle打包

./gradlew bootJar

部署到Tomcat

将打包好的JAR文件复制到Tomcat的webapps目录下。
启动Tomcat服务器。

$CATALINA_HOME/bin/startup.sh

使用Docker容器部署

创建一个Dockerfile来构建Spring Boot应用的Docker镜像：

FROM openjdk:11-jre-slim
VOLUME /tmp
COPY target/myapp.jar myapp.jar
ENTRYPOINT ["java","-jar","/myapp.jar"]

构建Docker镜像并启动容器：

docker build -t my-springboot-app .
docker run -d -p 8080:8080 my-springboot-app

Spring Boot调试与测试

单元测试

使用Spring Boot的单元测试框架进行测试。

添加测试起步依赖：

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

编写单元测试类：

package com.example.quickstart;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest
public class QuickstartApplicationTests {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        mockMvc.perform(get("/api/hello"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello, Spring Boot!"));
    }
}

集成测试

集成测试关注组件之间的交互。编写更多的测试类来覆盖更多的功能。

package com.example.quickstart;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.jdbc.Sql;

import java.util.List;

@SpringBootTest
@AutoConfigureTestDatabase
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    @Sql("/data.sql")
    public void shouldGetAllUsers() {
        List<User> users = userService.getAllUsers();
        users.forEach(user -> System.out.println(user.getName()));
    }
}

调试技巧

IDE调试：在IntelliJ IDEA或Eclipse中设置断点，运行应用。
Spring Boot Actuator：使用内置的Actuator端点来监控应用状态。
日志调试：增加日志级别，获取更多运行时信息。