Springboot框架入门：简单教程详解

概述

本文详细介绍了Spring Boot框架入门的相关知识，包括Spring Boot的基本概念、优势、适用场景以及环境搭建过程。文章还提供了创建第一个Spring Boot应用的步骤，并深入讲解了Spring Boot的核心概念和常用功能模块。

Spring Boot框架入门：简单教程详解

Spring Boot简介

Spring Boot是什么

Spring Boot 是一个基于Spring框架的开源微服务框架，旨在简化Spring应用的初始搭建及开发过程。它通过提供一套默认配置和快速启动器来帮助开发者快速构建独立的、生产级别的Spring应用程序。Spring Boot 使用约定优于配置的原则，省去了大量手动配置的繁琐过程，使得开发过程更加简洁和高效。

Spring Boot的优势

1. 快速启动：通过提供一个全面的默认配置，Spring Boot 可以帮助开发者快速启动项目，无需手动配置大量细节。
2. 自动配置：Spring Boot 会根据项目中的依赖自动配置需要的模块，比如数据库连接、Web服务器等。
3. 无需Web容器：Spring Boot 内置了一个基于Tomcat的Web服务器，可以在开发和生产环境中直接运行，无需额外配置。
4. 生产就绪：Spring Boot 内置了许多用于监控、日志记录和生产环境的特性，使得应用更加健壮。
5. 全面的引导支持：Spring Boot 提供了多个依赖的快速启动器，使得引入第三方库变得简单。

Spring Boot的适用场景

1. 快速原型：对于需要快速构建和验证的应用，Spring Boot 提供了便捷的开发环境。
2. 微服务架构：Spring Boot 与Spring Cloud等相关框架集成，可以构建高度可扩展的微服务架构。
3. API开发：Spring Boot 提供了创建RESTful API的简单方式。
4. 后台任务：适用于需要定时任务、邮件发送等后台任务的开发。
5. 生产环境：由于其内置的生产特性，如健康检查、配置刷新、故障恢复等，使得Spring Boot适合于生产环境中的应用部署。

环境搭建

安装Java开发环境

首先安装Java开发环境，确保系统中安装了JDK。这里以JDK 11为例说明安装步骤：

1. 访问Oracle官方网站下载JDK 11版本。
2. 安装JDK。
3. 配置环境变量。在环境变量中添加JDK的安装路径，并设置JAVA_HOME、PATH和CLASSPATH。

   export JAVA_HOME=/usr/lib/jvm/jdk11
   export PATH=$JAVA_HOME/bin:$PATH
   export CLASSPATH=$JAVA_HOME/lib:$CLASSPATH

   确保安装完成后，可以通过命令行执行java -version来验证Java已经正确安装。

安装IDE（如IntelliJ IDEA）

1. 访问IntelliJ IDEA官方网站下载社区版或专业版。
2. 安装IntelliJ IDEA。
3. 配置IntelliJ IDEA。在IDE中配置Java SDK，确保其指向正确的JDK安装路径。

下载Spring Boot Starter项目

Spring Boot Starter项目提供了快速创建Spring Boot应用的基本框架。它包含了常用的依赖和配置，帮助开发者快速搭建应用环境。以下是下载和配置Spring Boot Starter项目的基本步骤：

1. 访问Spring Boot官方网站下载Spring Boot Starter项目。
2. 解压下载的Spring Boot Starter项目文件。
3. 将解压后的Spring Boot Starter项目文件导入到IDE中。

创建Spring Boot项目

创建一个简单的Spring Boot项目：

1. 在IntelliJ IDEA中点击 "File" -> "New" -> "Project"。
2. 选择 "Spring Initializr"，点击 "Next"。
3. 在弹出的界面中选择 "Java" 和 "Spring Boot"。
4. 输入项目名称，选择项目存放路径，选择Java版本。
5. 选择项目依赖，如 "Web"。
6. 点击 "Finish" 完成项目创建。

以下为使用Maven创建Spring Boot项目的示例：

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

第一个Spring Boot应用

创建Hello World应用

创建一个简单的Spring Boot Hello World应用，主要包含一个简单的Controller类和主启动类。

1. 创建Controller类HelloController.java：

   package com.example.demo;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class HelloController {
   
      @GetMapping("/hello")
      public String sayHello() {
          return "Hello World!";
      }
   }

2. 创建主启动类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);
      }
   }

运行Spring Boot应用

在IntelliJ IDEA中，可以通过以下步骤运行Spring Boot应用：

1. 在项目主启动类DemoApplication.java上点击鼠标右键，选择 "Run 'DemoApplication.main()' "。
2. 应用启动后，浏览器中输入http://localhost:8080/hello，可以看到输出结果"Hello World!"。

探索Spring Boot的自动配置功能

Spring Boot的自动配置功能通过@SpringBootApplication注解实现，这个注解包含了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解。

• @SpringBootConfiguration：使当前类成为配置类。
• @EnableAutoConfiguration：启用自动配置。
• @ComponentScan：自动扫描并注册组件。

当应用启动时，Spring Boot会根据依赖关系自动配置相关的组件和服务，简化了配置过程。

Spring Boot核心概念详解

依赖注入和自动配置

依赖注入（Dependency Injection，DI）是Spring核心功能之一，它允许将对象的依赖关系从代码中分离出来，使得代码更加解耦和可测试。

在Spring Boot中，依赖注入通过@Autowired注解实现。以下是一个简单的依赖注入示例：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    private final GreetingService greetingService;

    @Autowired
    public HelloController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @GetMapping("/hello")
    public String sayHello() {
        return greetingService.greet();
    }
}

interface GreetingService {
    String greet();
}

class HelloWorldGreetingService implements GreetingService {
    @Override
    public String greet() {
        return "Hello World!";
    }
}

Starter依赖和自动配置

Spring Boot Starter提供了一系列预定义的starter依赖，帮助快速搭建开发环境。比如spring-boot-starter-web包含了Web开发所需的各种依赖。

使用Starter依赖时，通常只需要在项目的pom.xml或build.gradle文件中添加相应的依赖项：

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

Spring Boot的内置Web服务器

Spring Boot内置了Tomcat Web服务器。当应用启动时，Spring Boot会启动Tomcat服务器，并在指定端口上运行应用。缺省情况下，应用会在8080端口运行。

可以通过spring-boot-maven-plugin或spring-boot-gradle-plugin插件指定端口号：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <executableJarExecutable>true</executableJarExecutable>
                <mainClass>com.example.demo.DemoApplication</mainClass>
                <jvmArguments>-Dserver.port=9090</jvmArguments>
            </configuration>
        </plugin>
    </plugins>
</build>

或者在application.properties中设置：

server.port=9090

常用功能模块介绍

配置文件详解（application.properties和application.yml）

Spring Boot支持两种配置文件格式：application.properties和application.yml。这些配置文件用于配置应用的各项属性。

application.properties 示例

# 端口号
server.port=8080

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

# 日志配置
logging.level.root=INFO

application.yml 示例

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db
    username: root
    password: root

logging:
  level:
    root: INFO

数据库集成（JPA、MyBatis等）

JPA集成

Spring Boot通过spring-boot-starter-data-jpa依赖简化了JPA的集成。

1. 添加依赖：

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

2. 配置数据源：

   spring.datasource.url=jdbc:mysql://localhost:3306/test_db
   spring.datasource.username=root
   spring.datasource.password=root

3. 创建实体类User.java：

   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 and setters
   }

4. 创建Repository接口UserRepository.java：

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

MyBatis集成

Spring Boot通过mybatis-spring-boot-starter依赖简化了MyBatis的集成。

1. 添加依赖：

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

2. 配置数据源：

   spring.datasource.url=jdbc:mysql://localhost:3306/test_db
   spring.datasource.username=root
   spring.datasource.password=root

3. 创建Mapper接口UserMapper.java：

   package com.example.demo.mapper;
   
   import com.example.demo.model.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 findById(Long id);
   }

4. 创建配置类MyBatisConfig.java：

   package com.example.demo.config;
   
   import org.apache.ibatis.session.SqlSessionFactory;
   import org.mybatis.spring.SqlSessionFactoryBean;
   import org.mybatis.spring.annotation.MapperScan;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.jdbc.datasource.DataSourceTransactionManager;
   
   import javax.sql.DataSource;
   
   @Configuration
   @MapperScan("com.example.demo.mapper")
   public class MyBatisConfig {
      @Bean
      public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
          SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
          factoryBean.setDataSource(dataSource);
          return factoryBean.getObject();
      }
   
      @Bean
      public DataSourceTransactionManager transactionManager(DataSource dataSource) {
          return new DataSourceTransactionManager(dataSource);
      }
   }

日志管理

Spring Boot使用Logback作为默认的日志框架。可以通过application.properties或application.yml文件配置日志级别和输出：

application.properties 示例

# 配置日志级别
logging.level.root=INFO

# 配置日志输出路径
logging.file.name=logs/app.log

application.yml 示例

logging:
  level:
  root: INFO
file:
  name: logs/app.log

实战演练

创建RESTful API服务

创建一个简单的RESTful API服务，提供用户信息查询和添加功能。

1. 创建实体类User.java：

   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 and setters
   }

2. 创建Repository接口UserRepository.java：

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

3. 创建Service接口UserService.java和实现类UserServiceImpl.java：

   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 UserServiceImpl implements UserService {
   
      private final UserRepository userRepository;
   
      @Autowired
      public UserServiceImpl(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
   
      @Override
      public List<User> getAllUsers() {
          return userRepository.findAll();
      }
   
      @Override
      public User addUser(User user) {
          return userRepository.save(user);
      }
   }

4. 创建Controller类UserController.java：

   package com.example.demo.controller;
   
   import com.example.demo.model.User;
   import com.example.demo.service.UserService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.*;
   
   import java.util.List;
   
   @RestController
   @RequestMapping("/api/users")
   public class UserController {
   
      private final UserService userService;
   
      @Autowired
      public UserController(UserService userService) {
          this.userService = userService;
      }
   
      @GetMapping
      public List<User> getAllUsers() {
          return userService.getAllUsers();
      }
   
      @PostMapping
      public User addUser(@RequestBody User user) {
          return userService.addUser(user);
      }
   }

单元测试入门

创建单元测试来验证服务类的功能。

1. 添加依赖：

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

2. 创建单元测试类UserServiceTest.java：

   package com.example.demo.service;
   
   import com.example.demo.model.User;
   import com.example.demo.repository.UserRepository;
   import org.junit.jupiter.api.BeforeEach;
   import org.junit.jupiter.api.Test;
   import org.junit.jupiter.api.extension.ExtendWith;
   import org.mockito.InjectMocks;
   import org.mockito.Mock;
   import org.mockito.junit.jupiter.MockitoExtension;
   
   import java.util.Arrays;
   import java.util.List;
   
   import static org.junit.jupiter.api.Assertions.assertEquals;
   import static org.mockito.Mockito.when;
   
   @ExtendWith(MockitoExtension.class)
   public class UserServiceTest {
   
      @Mock
      private UserRepository userRepository;
   
      @InjectMocks
      private UserServiceImpl userService;
   
      @BeforeEach
      public void setUp() {
          User user1 = new User(1L, "John Doe", "[e-mail]");
          User user2 = new User(2L, "Jane Doe", "[e-mail]");
          when(userRepository.findAll()).thenReturn(Arrays.asList(user1, user2));
      }
   
      @Test
      public void testGetAllUsers() {
          List<User> users = userService.getAllUsers();
          assertEquals(2, users.size());
      }
   
      @Test
      public void testAddUser() {
          User newUser = new User();
          newUser.setName("New User");
          newUser.setEmail("[e-mail]");
   
          User savedUser = userService.addUser(newUser);
   
          assertEquals("New User", savedUser.getName());
          assertEquals("[e-mail]", savedUser.getEmail());
      }
   }

部署Spring Boot应用到Tomcat

将Spring Boot应用部署到Tomcat服务器，可以通过打成可执行的JAR包来实现。

1. 打包应用：在Maven或Gradle配置中添加maven-jar-plugin或bootJar插件。

   <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
   </build>

2. 使用命令行打包：

   mvn clean package

3. 在Tomcat服务器上部署：
   • 将生成的JAR文件复制到Tomcat的webapps目录。
   • 配置server.xml或使用Context元素来指定应用路径和端口。
   • 启动Tomcat服务器。

通过以上步骤，Spring Boot应用可以轻松部署到Tomcat服务器上，并通过Tomcat进行管理。