Spring Boot资料入门教程

本文全面介绍了Spring Boot框架的核心功能和优势，包括自动配置、嵌入式Web服务器和依赖管理等，旨在帮助开发者快速搭建和开发Spring Boot应用。此外，文章还详细讲解了Spring Boot的开发环境搭建、配置详解和数据访问等内容，提供了丰富的实战案例和优化技巧，帮助读者深入理解Spring Boot资料。

什么是Spring Boot

Spring Boot 是一套用来简化新Spring应用初始搭建以及开发过程的工具，它通过约定大于配置的原则来减少配置文件的编写，使开发过程变得更加简单。Spring Boot旨在简化Spring的配置，不需要再编写大量的配置代码，而是通过注解和默认配置来简化开发流程。

Spring Boot的核心功能包括：

• 自动配置：提供了大量的默认配置，极大简化了开发过程。
• 嵌入式Web服务器：默认支持Tomcat、Jetty和Undertow作为嵌入式Servlet容器。
• 依赖管理：自动管理和引入Spring Boot项目所需的各种依赖。
• 平台无关性：可以运行在各种环境下，如Java SE、Java EE等。
• 命令行接口：提供了一种通过命令行来启动和配置应用的简便方法。

Spring Boot的优势

1. 快速开发：通过约定大于配置，减少了配置文件的编写，简化了开发流程。
2. 无需配置XML：大部分配置通过注解和默认设置实现，无需编写复杂的XML配置文件。
3. 自动配置：自动识别和配置常用的库和依赖，如数据库连接、缓存、消息中间件等。
4. 嵌入式Servlet容器：内置Tomcat、Jetty或Undertow，无需额外部署步骤。
5. 健康检查：提供了一套健康检查的API，方便监控应用的状态。
6. 打包简便：支持打包成可执行的JAR或WAR文件，通过Java命令直接运行。
7. 依赖管理：自动管理项目依赖，避免版本冲突。

开发环境搭建

1. 安装JDK

Spring Boot项目运行需要Java环境。安装JDK后，设置环境变量JAVA_HOME，并将其添加到PATH环境变量中。例如：

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
export PATH=$JAVA_HOME/bin:$PATH

2. 安装Maven或Gradle

Maven和Gradle是两个常用的构建工具，这里以Maven为例。下载并安装Maven后，也需要设置环境变量。例如：

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

3. 创建Spring Boot项目

可以使用IDEA、Eclipse或命令行创建Spring Boot项目。这里以命令行为例：

1. 创建一个空目录，例如spring-boot-demo。

2. 进入该目录，使用Maven命令初始化项目：

   mvn archetype:generate -DgroupId=com.example -DartifactId=spring-boot-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

3. 进入项目目录：

   cd spring-boot-demo

4. 修改pom.xml文件，添加Spring Boot依赖：

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.example</groupId>
      <artifactId>spring-boot-demo</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
   
      <properties>
          <java.version>11</java.version>
          <spring.boot.version>2.6.3</spring.boot.version>
      </properties>
   
      <dependencies>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
              <version>${spring.boot.version}</version>
          </dependency>
      </dependencies>
   
      <build>
          <plugins>
              <plugin>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-maven-plugin</artifactId>
              </plugin>
          </plugins>
      </build>
   </project>

创建Spring Boot项目

在src/main/java目录下创建包结构com.example.demo，并在其中创建主类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);
    }
}

其中，@SpringBootApplication是一个复合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解的功能。

编写基本的Hello World程序

在DemoApplication.java中添加一个简单的REST控制器：

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 hello() {
        return "Hello, World!";
    }
}

运行和调试项目

运行项目：

mvn spring-boot:run

访问http://localhost:8080/，可以看到输出Hello, World!。

调试项目时，可以在IDE中设置断点并启动调试模式，或者在命令行中添加调试参数：

mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005"

配置文件介绍（application.properties与application.yml）

Spring Boot使用配置文件来定义应用的行为，主要有application.properties和application.yml两种格式。配置文件通常位于src/main/resources目录下。

运行时属性

spring.application.name=myapp
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

服务器属性

server.port=8080
server.servlet.context-path=/demo

本地属性

spring.profiles.active=local

YML格式

spring:
  application:
   name: myapp
 datasource:
   url: jdbc:mysql://localhost:3306/mydb
   username: root
   password: root
 server:
   port: 8080
   servlet:
     context-path: /demo

项目配置详解

属性覆盖

可以在application.properties或application.yml文件中定义自定义属性，然后在代码中使用@Value注解读取这些属性：

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
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 {
    @Value("${spring.application.name}")
    private String appName;

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

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

配置文件的优先级

Spring Boot按优先级读取配置文件：

1. application.properties
2. application.yml
3. 命名@ConfigurationProperties的属性
4. @PropertySource标记的属性
5. @Value标记的属性

动态配置

可以通过Environment对象动态读取配置属性：

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
    @Value("${spring.application.name}")
    private String appName;

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

    @GetMapping("/")
    public String hello(Environment env) {
        return env.getProperty("spring.application.name");
    }
}

依赖范围与作用

Spring Boot依赖分为多种范围，常见的有compile、test、runtime和provided。

• compile：依赖于当前项目，并传递到编译依赖项目中。
• test：依赖于测试环境中的项目，不传递到编译依赖项目中。
• runtime：依赖于运行时环境中的项目，不传递到编译依赖项目中。
• provided：依赖于运行时环境中的项目，不传递到编译依赖项目中，也不传递到运行时依赖项目中。

自动配置的原理

Spring Boot的自动配置通过@Configuration、@EnableAutoConfiguration和@ComponentScan注解实现。自动配置会根据项目中的类和配置文件，动态地创建Bean。

项目中常见的依赖

Web应用

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

数据库

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

测试

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

介绍JPA和MyBatis

JPA（Java Persistence API）

JPA是Java EE平台中用于对象关系映射的规范，Spring Data JPA是Spring对JPA的实现。

MyBatis

MyBatis是一个优秀的持久层框架，支持定制化SQL、存储过程以及高级映射。Spring Boot中可以通过MyBatis-Spring-Boot- Starter来使用MyBatis。

使用Spring Data JPA实现数据操作

创建实体类

package com.example.demo;

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;

    // Getter and Setter
}

创建Repository接口

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

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

使用Repository进行数据操作

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 UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public Iterable<User> getUsers() {
        return userRepository.findAll();
    }
}

使用Spring Boot访问数据库

配置数据源

在application.properties中配置数据源：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

创建数据访问层

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<User> getUsers() {
        String sql = "SELECT * FROM users";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    }
}

使用数据访问层进行数据操作

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;

import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserDao userDao;

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

常见的Spring Boot应用案例

REST API应用

创建一个REST API应用，实现用户管理功能，包括增删改查操作。

微服务应用

使用Spring Boot和Spring Cloud构建微服务架构，实现服务发现、负载均衡、断路器等功能。

package com.example.demo;

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

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

静态文件服务器

创建一个Spring Boot应用，作为静态文件服务器，提供文件下载和上传功能。

项目部署与优化技巧

打包部署

将Spring Boot应用打包成可执行的JAR或WAR文件，并使用命令行直接运行：

mvn clean package
java -jar target/*.jar

优化性能

• 使用Spring Boot Actuator进行健康检查和监控。
• 使用Spring Boot DevTools进行开发时的自动重启。
• 使用Spring Boot Profiles进行环境配置的分离。
• 使用Spring Boot Metrics进行应用性能监控。

常见问题与解决方案

热部署问题

使用spring-boot-devtools插件实现热部署：

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

数据库连接问题

确保数据库URL、用户名和密码正确，并且数据库已经启动。

端口占用问题

修改应用的端口号，或者停止占用指定端口的进程。

日志打印问题

通过配置logging.level.root来控制日志级别：

logging.level.root=INFO

模板引擎问题

确保模板引擎的配置正确，并且模板文件路径正确：

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

通过以上步骤，可以更好地理解和应用Spring Boot，构建出高效、可靠的Java应用。