Springboot项目开发入门教程

本文介绍了Spring Boot项目开发入门的相关内容，包括Spring Boot的基本概念、优点、特性和开发环境的搭建。文章详细讲解了开发环境配置、创建第一个Spring Boot项目以及核心配置。此外，还涵盖了常用功能实现、项目打包与部署等内容。

Spring Boot 是什么

Spring Boot 是一个用来简化新 Spring 应用初始搭建以及开发过程的框架。Spring Boot 可以让你快速地搭建一个独立的、生产级别的 Spring 应用，你可以专注于应用的开发，而不是框架的复杂配置。

Spring Boot 的优点

1. 无需配置大量XML文件：Spring Boot 通过约定优于配置的原则，使得开发者无需编写大量的配置文件。
2. 自动配置：Spring Boot 可以根据依赖自动配置框架，减少手动配置的工作。
3. 快速集成第三方库：可以快速集成各种第三方库，如数据库驱动、安全框架等。
4. 独立的可执行jar：使用 Spring Boot 构建的应用可以打包为独立的可执行 jar，方便部署。
5. 内置的健康监控：通过 Spring Boot Actuator 提供了生产级别的健康监控和指标收集功能。
6. 强大的起步依赖：通过 Spring Boot Starter 提供了丰富的一站式依赖。

Spring Boot 的特性

1. 自动配置：Spring Boot 会根据依赖自动配置框架。
2. 嵌入式容器：默认使用 Tomcat、Jetty 或 Undertow 作为嵌入式容器。
3. 起步依赖：通过 spring-boot-starter-* 方式引入依赖，简化依赖管理。
4. 内置的健康监控：通过 spring-boot-actuator 提供生产级别的健康监控。
5. 外部化配置：支持 application.properties 和 application.yml 文件配置。
6. 命令行接口：提供 spring-boot-devtools 开发工具，支持热重载等特性。

JDK 安装与配置

1. 访问 Oracle JDK 官方网站 或 OpenJDK 官方网站 下载对应的 JDK 安装包。
2. 按照安装向导进行安装，安装完成后配置环境变量。编辑 ~/.bashrc 或 ~/.zshrc 文件，添加以下内容：

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

3. 使用 java -version 命令验证 JDK 安装是否成功。

IDE 选择与安装

推荐使用 IntelliJ IDEA 或 Spring Tool Suite（STS）进行开发。

IntelliJ IDEA

1. 访问 IntelliJ IDEA 官网 下载并安装。
2. 打开 IntelliJ IDEA，选择 "Open" 打开或者 "Import Project" 导入项目。
3. 如果是新项目，可以选择 "New" -> "Project" 从模板创建项目。

Spring Tool Suite

1. 访问 Spring Tool Suite 官网 下载并安装。
2. 打开 STS，选择 "File" -> "New" -> "Spring Boot" 从模板创建项目。

Maven 或 Gradle 配置

Maven 配置

1. 下载并安装 Maven：访问 Apache Maven 官网。
2. 配置环境变量，编辑 ~/.bashrc 或 ~/.zshrc 文件，添加以下内容：

   export MAVEN_HOME=/usr/local/apache-maven-3.6.3
   export PATH=$MAVEN_HOME/bin:$PATH

3. 使用 mvn -version 命令验证 Maven 安装是否成功。

Gradle 配置

1. 下载并安装 Gradle：访问 Gradle 官网。
2. 配置环境变量，编辑 ~/.bashrc 或 ~/.zshrc 文件，添加以下内容：

   export GRADLE_HOME=/usr/local/gradle-6.8.3
   export PATH=$GRADLE_HOME/bin:$PATH

3. 使用 gradle -v 命令验证 Gradle 安装是否成功。

使用 Spring Initializr 生成项目

访问 Spring Initializr 生成项目。

1. 选择项目类型：Java Project。
2. 选择依赖库：基本选择 Spring Web 和 Spring Data JPA。
3. 选择语言版本：Java 11。
4. 选择打包类型：Jar。
5. 点击 "Generate Project" 生成压缩包，解压后导入到 IDE 中。

项目结构解析

项目结构如下：

src/
└── main
    ├── java
    │   └── com.example.demo
    │       ├── DemoApplication.java
    │       └── controller
    │           └── HelloController.java
    └── resources
        ├── application.properties
        └── static/
        └── templates/

• DemoApplication.java：主程序入口。
• HelloController.java：一个简单的控制器，提供 RESTful API。
• application.properties：项目的配置文件。
• static/：静态资源文件，如 HTML、CSS、JavaScript。
• templates/：Thymeleaf 模板文件。

主类编写与运行

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

在 HelloController.java 中编写一个简单的控制器：

package com.example.demo.controller;

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

@RestController
public class HelloController {

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

运行项目：

1. 在 IntelliJ IDEA 中，点击右上角的绿色运行按钮。
2. 在浏览器中访问 http://localhost:8080，可以看到输出 "Hello World!"。

application.properties 与 application.yml

Spring Boot 的配置文件可以通过 application.properties 或 application.yml 来实现。这些配置文件位于 src/main/resources 目录下。

application.properties 示例

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

# 应用配置
server.port=8080
spring.application.name=my-app

application.yml 示例

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/dbname
  username: root
  password: root
server:
  port: 8080
application:
  name: my-app

配置文件的热刷新

在开发过程中，配置文件的变化通常需要重启应用才能生效。Spring Boot 提供了 spring-boot-devtools 来实现配置文件的热刷新。

在 pom.xml 或 build.gradle 中添加依赖：

Maven

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

Gradle

dependencies {
    runtimeOnly 'org.springframework.boot:spring-boot-devtools'
}

启用热刷新后，更改配置文件会自动重启应用。

Spring Boot Actuator 的使用

Spring Boot Actuator 提供了生产级别的健康监控和指标收集功能。

在 pom.xml 或 build.gradle 中添加依赖：

Maven

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

Gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

启用 Actuator 后，访问 /actuator 可以看到健康状态、JVM 信息等。

RESTful API 开发

使用 Spring Boot 实现 RESTful API 非常简单。我们已经创建了一个简单的 HelloController 示例：

package com.example.demo.controller;

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

@RestController
public class HelloController {

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

可以继续创建其他控制器，例如：

package com.example.demo.controller;

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

import java.util.List;
import java.util.ArrayList;

@RestController
public class UserController {

    @GetMapping("/users")
    public List<String> getAllUsers() {
        List<String> users = new ArrayList<>();
        users.add("user1");
        users.add("user2");
        return users;
    }
}

数据库集成（JPA、MyBatis）

使用 JPA

在 pom.xml 或 build.gradle 中添加 JPA 依赖：

Maven

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

Gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'mysql:mysql-connector-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.AUTO)
    private Long id;

    private String username;
    private String password;

    public User() {}

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

定义 Repository 接口：

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

在 pom.xml 或 build.gradle 中添加 MyBatis 依赖：

Maven

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

Gradle

dependencies {
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.4'
}

定义实体类：

package com.example.demo.model;

public class User {

    private Long id;
    private String username;
    private String password;

    public User() {}

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

定义 Mapper 接口：

package com.example.demo.mapper;

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

@Mapper
public interface UserMapper {

    List<User> getAllUsers();

    User getUserById(Long id);
}

定义 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.demo.mapper.UserMapper">

    <select id="getAllUsers" resultType="com.example.demo.model.User">
        SELECT * FROM users
    </select>

    <select id="getUserById" resultType="com.example.demo.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

</mapper>

安全性配置（Spring Security）

使用 Spring Security 进行安全性配置：

在 pom.xml 或 build.gradle 中添加依赖：

Maven

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

Gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
}

自定义 WebSecurityConfigurerAdapter：

package com.example.demo.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;
import org.springframework.security.crypto.password.PasswordEncoder;

@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")
            .anyRequest().permitAll()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

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

定义用户详情服务：

package com.example.demo.security;

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(
                user.getUsername(), passwordEncoder.encode(user.getPassword()),
                true, true, true, true, new String[] { "ROLE_" + user.getRole().toUpperCase() });
    }
}

打包项目

使用 Maven 或 Gradle 打包项目。

Maven

在项目根目录下运行：

mvn clean package

Gradle

在项目根目录下运行：

./gradlew clean build

部署到 Tomcat 或 Spring Boot 内置容器

将打包后的 jar 文件上传到服务器。

使用 Spring Boot 内置容器

直接运行 jar 文件：

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

部署到 Tomcat

1. 将打包后的 jar 文件放到 Tomcat 的 webapps 目录下。
2. 启动 Tomcat。

常见问题与解决方案

1. 内存溢出：增加 JVM 内存配置，例如：

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

2. 配置文件问题：确保配置文件路径正确，格式正确。

3. 依赖冲突：检查依赖冲突，排除冲突的依赖。

4. Spring Security 配置问题：确保安全性配置正确，没有遗漏任何配置。

5. 数据库连接问题：确保数据库配置正确，数据库服务正常运行。