首页手记 Spring Boot项目实战：新手入门教程

Spring Boot项目实战：新手入门教程

标签：

SpringBoot

概述

本文档介绍了如何使用Spring Boot框架从项目创建到部署的全过程。内容涵盖Spring Boot框架的简介、核心优势、开发环境搭建、创建第一个Spring Boot项目、配置文件的使用、REST API的编写，以及与Spring Data JPA和Spring Security的整合实战案例。每部分内容都配有相应的代码示例，有助于读者更好地理解和掌握Spring Boot的基本用法。

引入Spring Boot

Spring Boot简介

Spring Boot是由Pivotal团队开发的一个基于Spring框架的快速开发框架。它的目标是简化Spring应用的初始配置，并通过约定优于配置的原则使得开发者可以更快地创建独立的、生产级别的应用。

Spring Boot的优势

简化配置：Spring Boot致力于简化Spring应用的配置。它通过约定优于配置的原则，自动配置了许多常见的需求，使得开发者无需编写大量的配置代码。
快速启动：Spring Boot提供了自动配置功能，使得从项目创建到启动非常快速，极大地缩短了开发周期。
独立性和可移植性：Spring Boot应用可以打包成独立的可执行文件（如.jar文件），可以运行在任何Java环境中，无需部署到特定的容器中。
依赖管理：Spring Boot通过其内置的依赖管理，简化了依赖的引入和版本控制，开发者只需添加需要的特性，无需关心依赖的版本问题。
嵌入式服务器：Spring Boot可以内置嵌入式的Servlet容器（如Tomcat、Jetty或Undertow），可以非常方便地直接运行应用，而无需部署到独立的Tomcat或其他服务器中。
健康检查和监控：Spring Boot集成了许多健康检查和监控工具，可以方便地检查应用的运行状态。
外部配置：支持从外部配置文件（如.properties或.yml文件）加载配置，使应用更容易在不同的环境中运行。
对云平台的支持：Spring Boot与各种云平台集成良好，可以方便地部署到云环境中。

第一个Spring Boot项目

创建第一个Spring Boot项目可以遵循以下步骤：

创建一个Spring Boot项目。
添加必要的依赖。
配置应用的基本信息。
编写一个简单的REST API。

1. 创建一个Spring Boot项目

在创建项目之前，需要安装Java环境和Maven或Gradle。接下来使用Spring Initializr或Spring Boot官方网站提供的模板创建项目。这里以使用Spring Initializr为例：

访问Spring Initializr网站。
选择项目的基本信息，如项目名称、语言（Java）、依赖（例如Spring Web）。
点击“Generate”按钮下载项目压缩包。

2. 添加必要的依赖

在项目中，Spring Boot的依赖需要在pom.xml（Maven）或build.gradle（Gradle）中声明。下面是一个示例的pom.xml文件：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 其他依赖 -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </build>
</project>

3. 配置应用的基本信息

在Spring Boot中，应用的基本信息通常放在src/main/resources/application.properties或application.yml文件中。下面是一个简单的application.properties文件：

# application.properties
spring.application.name=demo-app
server.port=8080

4. 编写一个简单的REST API

在src/main/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
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!";
    }
}

此代码创建了一个简单的Spring Boot应用，启动后可以通过http://localhost:8080/访问。

快速搭建Spring Boot环境

安装Java环境

安装Java开发环境是开发Spring Boot应用的第一步。以下是安装步骤：

访问Oracle官方网站或者Adoptium下载Java的安装包。
按照安装向导安装Java。
设置环境变量。将Java的安装目录添加到系统的PATH环境变量中。例如，如果Java安装在C:\Program Files\Java\jdk1.8.0_281，则需要将%JAVA_HOME%设置为C:\Program Files\Java\jdk1.8.0_281，并将%JAVA_HOME%\bin添加到PATH变量中。
验证安装是否成功。打开命令行窗口并输入java -version，应该会看到安装的Java版本信息。

安装Maven或Gradle

Maven和Gradle是两种流行的构建工具，它们可以管理项目的依赖和构建过程。这里展示如何安装Maven。

访问Maven官方网站下载Maven的安装包。
解压下载的文件到一个目录。
设置环境变量。将Maven的安装目录bin目录添加到PATH环境变量中。
验证安装是否成功。打开命令行窗口并输入mvn -version，应该会看到安装的Maven版本信息。

Gradle的安装过程与Maven类似：

访问Gradle官方网站下载Gradle的安装包。
解压下载的文件到一个目录。
设置环境变量。将Gradle的安装目录bin目录添加到PATH环境变量中。
验证安装是否成功。打开命令行窗口并输入gradle -v，应该会看到安装的Gradle版本信息。

创建Spring Boot项目

创建Spring Boot项目的方式有很多种，可以使用Spring Initializr在线生成项目，也可以手动创建项目。这里使用手动创建的方式：

创建一个目录，例如springboot-demo。
初始化项目结构：

mkdir springboot-demo
cd springboot-demo
mkdir -p src/main/java/com/example/demo
mkdir src/main/resources

创建pom.xml或build.gradle文件。这里以pom.xml为例：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </build>
</project>

创建一个简单的Spring Boot应用，例如DemoApplication.java：

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
    public class HelloController {
        @GetMapping("/")
        public String hello() {
            return "Hello, Spring Boot!";
        }
    }
}

创建一个简单的配置文件application.properties：

# application.properties
spring.application.name=demo-app
server.port=8080

现在，已经创建了一个基本的Spring Boot项目。

Spring Boot项目的基本配置

application.properties配置详解

application.properties是Spring Boot应用中常用的配置文件，可以用来定义应用的各种配置信息。以下是一些常用的配置项及其含义：

spring.application.name: 应用的名称。
server.port: 应用的端口号。
spring.datasource.url: 数据源的URL。
spring.datasource.username: 数据源的用户名。
spring.datasource.password: 数据源的密码。
spring.datasource.driver-class-name: 数据源的驱动类名。
spring.jpa.hibernate.ddl-auto: 数据库模式生成策略，如create, update, create-drop等。
spring.jpa.show-sql: 是否显示SQL。
spring.jpa.properties.hibernate.enable_lazy_load_no_trans: 是否允许在没有事务的情况下进行延迟加载。

下面是一个示例的application.properties文件：

# application.properties
spring.application.name=demo-app
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

使用Spring Boot Starter简化配置

Spring Boot Starter是一个简化配置的工具。它通过引入一个特定的依赖来自动配置所需的bean。例如，spring-boot-starter-web是一个常用的starter，它会自动引入Web相关依赖并配置一个嵌入式的Tomcat服务器。

在pom.xml或build.gradle文件中引入相应的starter即可简化配置：

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

Spring Boot Starter列表中包含了很多不同功能的starter，如spring-boot-starter-data-jpa, spring-boot-starter-security等。这些starter简化了开发过程，减少了手动配置的工作量。

实战：Spring Boot整合常见框架

整合Spring Data JPA进行数据库操作

Spring Data JPA是Spring Data的一部分，它简化了JPA的配置和使用，提供了JPA的高级功能，如CRUD操作、事务管理等。下面是如何将Spring Data JPA整合到Spring Boot项目中：

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

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

配置数据源和JPA属性：

spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

创建实体类：

package com.example.demo.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
}

创建Repository接口：

package com.example.demo.repository;

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

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

创建一个控制器来操作数据：

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.boot.CommandLineRunner;
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
    public class UserController {
        private final UserRepository userRepository;

        public UserController(UserRepository userRepository) {
            this.userRepository = userRepository;
        }

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

    public static class ApplicationRunner implements CommandLineRunner {
        private final UserRepository userRepository;

        public ApplicationRunner(UserRepository userRepository) {
            this.userRepository = userRepository;
        }

        @Override
        public void run(String... args) throws Exception {
            userRepository.save(new User("Alice", "alice@example.com"));
            userRepository.save(new User("Bob", "bob@example.com"));
        }
    }
}

现在，你可以通过访问http://localhost:8080/users来查看用户列表。

整合Spring Security实现安全认证

Spring Security是一个用于安全认证的框架，它可以为Spring Boot应用提供认证和授权功能。下面是如何将Spring Security整合到Spring Boot项目中：

添加Spring Security依赖：

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

配置Spring Security：

package com.example.demo;

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.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

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

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();

        return new InMemoryUserDetailsManager(user);
    }
}

创建登录页面：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Spring Security Example</title>
</head>
<body>
    <h1>Login Page</h1>
    <form th:action="@{/login}" method="post">
        <label for="username">Username:</label>
        <input type="text" name="username" id="username">
        <label for="password">Password:</label>
        <input type="password" name="password" id="password">
        <button type="submit">Login</button>
    </form>
</body>
</html>

创建控制器来处理登录和主页：

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {
    @GetMapping("/")
    public String home() {
        return "home";
    }

    @GetMapping("/login")
    public String login() {
        return "login";
    }
}

创建资源文件src/main/resources/templates/home.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Home Page</title>
</head>
<body>
    <h1>Welcome to Home Page</h1>
</body>
</html>

创建资源文件src/main/resources/templates/login.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login Page</title>
</head>
<body>
    <h1>Login Page</h1>
    <form th:action="@{/login}" method="post">
        <label for="username">Username:</label>
        <input type="text" name="username" id="username">
        <label for="password">Password:</label>
        <input type="password" name="password" id="password">
        <button type="submit">Login</button>
    </form>
</body>
</html>

现在，你可以通过访问http://localhost:8080/来访问主页，并通过http://localhost:8080/login来访问登录页面。

调试与测试

使用IDE进行项目调试

Spring Boot项目可以使用各种IDE进行调试，如IntelliJ IDEA和Eclipse。下面是如何在IntelliJ IDEA中进行调试的步骤：

打开IntelliJ IDEA，导入项目。
在DemoApplication.java的main方法处设置断点。
右键点击DemoApplication.java并选择Debug 'DemoApplication'。
调试器将启动应用并在断点处暂停。

单元测试与集成测试

Spring Boot支持使用JUnit进行单元测试和集成测试。Spring Boot还提供了一个名为spring-boot-starter-test的依赖，它包含了一些测试工具，如JUnit、Mockito等。

单元测试示例

package com.example.demo;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class DemoApplicationTests {
    @Test
    public void contextLoads() {
    }

    @Test
    public void testHelloController() {
        HelloController controller = new HelloController();
        assertEquals("Hello, Spring Boot!", controller.hello());
    }
}

集成测试示例

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

import static org.junit.jupiter.api.Assertions.assertEquals;

@DataJpaTest
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;

    @Test
    public void testUserRepository() {
        User user = new User();
        user.setName("Alice");
        user.setEmail("alice@example.com");

        userRepository.save(user);

        User foundUser = userRepository.findById(user.getId()).orElse(null);
        assertEquals("Alice", foundUser.getName());
        assertEquals("alice@example.com", foundUser.getEmail());
    }
}

部署与运行Spring Boot应用

打包与发布Spring Boot应用

Spring Boot应用可以被打包成一个独立的JAR文件，可以通过mvn package或gradle build命令进行打包：

mvn package

或者使用Gradle：

gradle build

打包后的JAR文件可以在target目录（Maven）或build/libs目录（Gradle）中找到。

在Tomcat或Spring Boot内置服务器上运行应用

运行内置服务器

Spring Boot应用可以通过mvn spring-boot:run或直接运行DemoApplication.java中的main方法来启动应用。

mvn spring-boot:run

或者在IDE中运行DemoApplication类的main方法。

部署到Tomcat

将打包好的JAR文件部署到Tomcat需要手动将应用部署到Tomcat服务器的webapps目录。但是，通常建议使用Spring Boot内置的Web服务器，因为这样可以简化部署过程。

使用Spring Boot内置的Web服务器

Spring Boot内置了Tomcat、Jetty或Undertow等Web服务器，可以通过设置spring-boot.run.jvmArguments属性来启用这些服务器。

spring-boot.run.jvmArguments=-Dserver.port=8080

这样，启动应用时将会启动内置的Web服务器，并监听8080端口。

打包成独立的可执行文件

Spring Boot应用可以被打包成独立的可执行文件，可以通过mvn spring-boot:repackage命令来打包。

mvn spring-boot:repackage

打包后的文件可以像普通的Java应用程序一样运行：

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

通过这种方式，可以将Spring Boot应用打包成一个独立的可执行文件，方便部署和运行。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

UYOU

手记
篇

粉丝

86

获赞与收藏

459

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

Pandas 入门教程

25个小节 18600 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空