首页手记 SpringBoot入门教程：轻松搭建第一个Web应用

SpringBoot入门教程：轻松搭建第一个Web应用

标签：

SpringBoot

概述

SpringBoot是一个基于Spring框架的新型框架，简化了应用的开发和配置过程。通过提供自动配置和内置服务器等功能，SpringBoot使得开发者可以快速搭建独立的、功能丰富的应用。本文详细介绍了SpringBoot的核心特性、优势以及如何搭建第一个Web应用，包括环境配置、项目创建和运行等步骤。

SpringBoot入门教程：轻松搭建第一个Web应用

SpringBoot简介

什么是SpringBoot

SpringBoot 是一个基于Spring框架的新型框架，旨在简化Spring应用的初始搭建以及开发过程。SpringBoot通过提供一组默认配置，使得开发者可以快速地配置一个独立的、功能丰富的应用，而无需进行繁琐的配置。

SpringBoot的核心特性

自动配置：SpringBoot通过约定优于配置的原则，自动配置Spring应用，简化了开发人员的工作量。
起步依赖：引入SpringBoot的起步依赖，可以自动引入所有需要的依赖，简化了项目的依赖管理。
内置服务器：SpringBoot内置了Tomcat、Jetty等Web服务器，可以方便地启动和部署应用。
命令行接口：SpringBoot提供了命令行接口，可以方便地运行应用和执行一些管理任务。
嵌入式数据库：SpringBoot内置了一些常用的嵌入式数据库，可以快速搭建开发环境。
外部化配置：SpringBoot支持从配置文件、环境变量、命令行参数等多种来源获取配置。
Actuator监控：SpringBoot Actuator提供了详细的度量、健康检测、审计日志等功能，帮助开发者更好地监控和管理应用。

SpringBoot的优势

简化配置：大量自动化的配置使得开发者无需手动配置大量的XML或注解。
快速启动：开发人员可以快速搭建一个完整的Spring应用，无需复杂的配置。
功能丰富：内置了丰富的功能模块，如数据访问、安全、缓存等。
全面的文档：SpringBoot提供了详尽的文档和示例，帮助开发者快速上手。
独立运行：SpringBoot可以将应用打包成一个独立的可执行的JAR文件，方便部署。

环境搭建

安装Java开发环境

安装Java开发环境是使用SpringBoot的前提条件。在开始之前，请确保已经安装了Java开发环境，这里我们以Java 11为例进行说明。

下载Java JDK：访问Oracle官网或其他Java网站，下载Java JDK的安装包。
安装Java JDK：运行下载的安装包，按照提示完成安装。
配置环境变量：安装完成后，需要配置环境变量。

配置环境变量的步骤如下：

打开环境变量设置：右键点击“此电脑”，选择“属性” -> “高级系统设置” -> “环境变量” -> “系统变量”。
编辑系统变量：在“系统变量”中找到“Path”变量，点击“编辑”。
添加Java路径：将Java的安装路径（例如C:\Program Files\Java\jdk-11.0.1）添加到“变量值”中。
验证安装：在命令行中输入java -version，如果能正确显示Java版本信息，则表示安装成功。

下载SpringBoot开发工具

SpringBoot项目的开发需要一个集成开发环境（IDE），常用的IDE有Eclipse、IntelliJ IDEA等。这里我们以IntelliJ IDEA为例进行说明。

下载IntelliJ IDEA：访问JetBrains官网下载IntelliJ IDEA的安装包。
安装IntelliJ IDEA：运行下载的安装包，按照提示完成安装。
配置IDE：打开IntelliJ IDEA，按照提示进行基本配置。

配置开发环境

配置开发环境包括配置IDE、创建项目目录等步骤。

打开IntelliJ IDEA：启动IntelliJ IDEA。
创建项目：选择“File” -> “New” -> “Project”，选择Maven或Gradle项目类型，点击“Next”，选择Spring Boot项目模板，填写项目名称和项目位置，点击“Finish”完成创建。

创建第一个SpringBoot项目

使用Spring Initializr创建项目

Spring Initializr是一个Spring Boot项目的在线初始化工具，可以帮助我们快速创建一个Spring Boot项目。

访问Spring Initializr：打开浏览器，访问https://start.spring.io/。
选择项目信息：选择项目的基本信息，如项目名称、语言、依赖等。
生成项目：点击“Generate”按钮，下载生成的项目压缩包。
解压项目：将下载的压缩包解压到本地目录。
导入项目：在IntelliJ IDEA中打开项目。

项目目录结构解析

创建项目后，项目的目录结构如下：

my-spring-boot-app/
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.example
│   │   │       └── mySpringBootApp
│   │   │           ├── Application.java
│   │   │           └── controller
│   │   │               └── HelloController.java
│   │   ├── resources
│   │   │   ├── application.properties
│   │   │   └── static
│   │   │       └── index.html
│   └── test
│       └── java
│           └── com.example
│               └── mySpringBootApp
│                   └── MySpringBootAppApplicationTests.java
└── pom.xml

主要目录说明：

src/main/java：存放项目的Java源代码。
src/main/resources：存放项目的资源文件，如配置文件、静态文件等。
src/test/java：存放项目的测试代码。
pom.xml：Maven项目的配置文件。

运行第一个SpringBoot应用

启动应用：在IntelliJ IDEA中，右键点击Application类，选择“Run”运行应用。
访问应用：在浏览器中访问http://localhost:8080/，可以看到默认的欢迎页面。

测试应用

验证应用启动：在运行日志中，可以看到Spring Boot启动成功的日志信息。
验证应用访问：在浏览器中访问http://localhost:8080/，可以看到默认的欢迎页面。

添加基本功能

添加控制器

控制器是Spring Boot应用的核心组件之一，负责处理HTTP请求。下面我们将添加一个简单的控制器，返回一个简单的JSON响应。

创建控制器：在src/main/java目录下创建一个新的Java文件，例如HelloController.java。

package com.example.mySpringBootApp.controller;

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

@RestController
public class HelloController {

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

运行应用：重新运行应用，然后在浏览器中访问http://localhost:8080/，可以看到返回的JSON响应，内容为“Hello, Spring Boot!”。

创建简单的REST服务

除了处理HTTP请求，Spring Boot还可以通过REST服务来处理HTTP请求。下面我们创建一个简单的REST服务，返回一个JSON对象。

创建REST服务：在src/main/java目录下创建一个新的Java文件，例如UserService.java。

package com.example.mySpringBootApp.service;

import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;

@Service
public class UserService {

    public List<String> getUsers() {
        return Collections.singletonList("user1");
    }
}

创建REST控制器：在src/main/java目录下创建一个新的Java文件，例如UserController.java。

package com.example.mySpringBootApp.controller;

import com.example.mySpringBootApp.service.UserService;
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("/users")
public class UserController {

    @Autowired
    private UserService userService;

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

测试REST服务：重新运行应用，然后在浏览器中访问http://localhost:8080/users/，可以看到返回的JSON对象，内容为["user1"]。

使用SpringBoot的内置服务器

Spring Boot内置了Tomcat、Jetty等Web服务器，可以方便地启动和部署应用。这里我们将使用内置的Tomcat服务器启动应用。

配置内置服务器：在pom.xml文件中，我们已经引入了Spring Boot的起步依赖，它包含了Tomcat服务器。

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

启动内置服务器：在IntelliJ IDEA中，右键点击Application类，选择“Run”运行应用。Spring Boot会自动启动内置的Tomcat服务器，并监听8080端口。

测试启动

验证启动成功：在运行日志中，可以看到Spring Boot启动成功的日志信息。
验证服务启动：在浏览器中访问http://localhost:8080/users/，可以看到返回的JSON对象，内容为["user1"]。

配置SpringBoot应用

配置文件的使用

Spring Boot提供了多种配置文件，可以用来配置应用的各种属性。常用的配置文件有application.properties和application.yml。

创建配置文件：在src/main/resources目录下创建application.properties文件。

# 配置服务器端口
server.port=8080

# 配置应用名称
spring.application.name=mySpringBootApp

读取配置文件：我们可以通过@Value注解或Environment对象来读取配置文件中的属性。

package com.example.mySpringBootApp;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class Application implements CommandLineRunner {

    @Value("${server.port}")
    private String serverPort;

    @Autowired
    private Environment env;

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Server port: " + serverPort);
        System.out.println("Application name: " + env.getProperty("spring.application.name"));
    }
}

使用外部配置文件

Spring Boot支持从外部配置文件中读取配置属性。我们可以将配置文件放在类路径之外，然后通过Spring Boot的配置文件加载机制来读取。

创建外部配置文件：在项目的根目录下创建一个external.properties文件。

# 配置文件名称
spring.config.name=external

# 配置服务器端口
server.port=8090

修改配置文件加载机制：在application.properties文件中，添加配置文件加载机制。

# 配置文件加载机制
spring.config.location=file:./
spring.config.name=external

读取外部配置文件：重新运行应用，可以看到Spring Boot已经从外部配置文件中读取了配置属性。

应用配置详解

Spring Boot提供了丰富的配置选项，可以通过配置文件来控制应用的行为。以下是一些常用的配置选项：

服务器配置：

# 配置服务器端口
server.port=8080

# 配置服务器地址
server.address=127.0.0.1

# 配置服务器上下文路径
server.context-path=/myapp

应用配置：

# 配置应用名称
spring.application.name=mySpringBootApp

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

数据库配置：

# 配置数据库驱动
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

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

# 配置数据库用户名
spring.datasource.username=root

# 配置数据库密码
spring.datasource.password=root

缓存配置：

# 配置缓存类型
spring.cache.type=simple

# 配置缓存过期时间
spring.cache.cache-names=users
spring.cache.time-to-live=60s

测试配置文件

验证配置文件读取：在输出日志中，可以看到配置文件中属性的读取结果。
验证配置文件应用：在浏览器中访问http://localhost:8080/users/，可以看到配置文件中端口等设置的正确应用。

整合第三方库

引入MyBatis连接数据库

MyBatis是一个优秀的持久层框架，可以方便地进行数据库操作。下面我们将在Spring Boot项目中整合MyBatis。

添加MyBatis依赖：在pom.xml文件中添加MyBatis的依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>
</dependencies>

配置数据源：在application.properties文件中配置数据源。

# 配置数据库驱动
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

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

# 配置数据库用户名
spring.datasource.username=root

# 配置数据库密码
spring.datasource.password=root

配置MyBatis：在application.properties文件中配置MyBatis。

# 配置MyBatis配置文件位置
mybatis.config-location=classpath:mybatis-config.xml

# 配置MyBatis映射文件位置
mybatis.mapper-locations=classpath:mapper/*.xml

创建MyBatis配置文件：在src/main/resources目录下创建mybatis-config.xml文件。

<configuration>
    <typeAliases>
        <typeAlias type="com.example.mySpringBootApp.model.User" alias="User"/>
    </typeAliases>
</configuration>

创建映射文件：在src/main/resources/mapper目录下创建UserMapper.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.mySpringBootApp.mapper.UserMapper">

    <select id="selectUser" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <insert id="insertUser" parameterType="User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>

</mapper>

创建Mapper接口：在src/main/java目录下创建UserMapper.java文件。

package com.example.mySpringBootApp.mapper;

import com.example.mySpringBootApp.model.User;

public interface UserMapper {

    User selectUser(Integer id);

    void insertUser(User user);

}

创建模型类：在src/main/java目录下创建User.java文件。

package com.example.mySpringBootApp.model;

import lombok.Data;

@Data
public class User {

    private Integer id;
    private String name;
    private String email;

}

创建服务类：在src/main/java目录下创建UserService.java文件。

package com.example.mySpringBootApp.service;

import com.example.mySpringBootApp.mapper.UserMapper;
import com.example.mySpringBootApp.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Integer id) {
        return userMapper.selectUser(id);
    }

    public void insertUser(User user) {
        userMapper.insertUser(user);
    }

}

创建控制器类：在src/main/java目录下创建UserController.java文件。

package com.example.mySpringBootApp.controller;

import com.example.mySpringBootApp.model.User;
import com.example.mySpringBootApp.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Integer id) {
        return userService.getUserById(id);
    }

    @PostMapping("/")
    public void insertUser(@RequestBody User user) {
        userService.insertUser(user);
    }

}

测试数据库操作：重新运行应用，然后在Postman或浏览器中访问http://localhost:8080/users/1，可以看到返回的用户信息。

使用SpringBoot集成Thymeleaf

Thymeleaf是一个强大的模板引擎，可以方便地生成HTML、XML等静态文档。下面我们将在Spring Boot项目中集成Thymeleaf。

添加Thymeleaf依赖：在pom.xml文件中添加Thymeleaf的依赖。

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

创建HTML模板：在src/main/resources/templates目录下创建一个test.html文件。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Test Page</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'"></h1>
</body>
</html>

创建控制器类：在src/main/java目录下创建HomeController.java文件。

package com.example.mySpringBootApp.controller;

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

@Controller
public class HomeController {

    @GetMapping("/")
    public String index(Model model) {
        model.addAttribute("name", "World");
        return "test";
    }

}

测试模板渲染：重新运行应用，然后在浏览器中访问http://localhost:8080/，可以看到渲染后的HTML页面，显示“Hello, World!”。

整合其他常用库

除了MyBatis和Thymeleaf，Spring Boot还可以与许多其他库进行整合。这里我们将介绍如何在Spring Boot项目中整合Redis和Swagger。

整合Redis

Redis是一个高性能的键值存储系统，可以作为缓存和消息队列等场景使用。下面我们将在Spring Boot项目中整合Redis。

添加Redis依赖：在pom.xml文件中添加Redis的依赖。

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

配置Redis：在application.properties文件中配置Redis。

# 配置Redis地址
spring.redis.host=localhost

# 配置Redis端口
spring.redis.port=6379

创建Redis服务类：在src/main/java目录下创建RedisService.java文件。

package com.example.mySpringBootApp.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setKey(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getKey(String key) {
        return (String) redisTemplate.opsForValue().get(key);
    }

    public void expireKey(String key, long timeout, TimeUnit unit) {
        redisTemplate.expire(key, timeout, unit);
    }

}

测试Redis操作：重新运行应用，然后在Redis客户端中访问set key value，可以看到Redis中已经存储了相应的键值对。

整合Swagger

Swagger是一个流行的API文档生成工具，可以自动生成API文档和交互式测试界面。下面我们将在Spring Boot项目中整合Swagger。

添加Swagger依赖：在pom.xml文件中添加Swagger的依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>3.0.0</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

配置Swagger：创建一个配置类来配置Swagger。

package com.example.mySpringBootApp.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }

}

测试Swagger：重新运行应用，然后在浏览器中访问http://localhost:8080/swagger-ui.html，可以看到Swagger生成的API文档和交互式测试界面。

总结

通过本教程，我们学习了如何使用Spring Boot快速搭建一个Web应用，包括环境搭建、创建项目、添加功能、配置应用和整合第三方库等。Spring Boot简化了开发过程，使得开发者可以更加专注于业务逻辑的实现，而无需处理繁琐的配置。希望本教程能够帮助你快速上手Spring Boot，开发出优秀的Spring Boot应用。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕标5832272

全栈工程师

手记
篇

粉丝

229

获赞与收藏

1001

关注作者，订阅最新文章

相关文章推荐

用SpringBoot创建web项目（一）

react入门教程01 - 简介、开发环境搭建、创建第一个React应用

轻松搭建基于 SpringBoot + Vue 的 Web 商城应用

SpringBoot | 第一章：第一个SpringBoot应用

SpringBoot | 第一章：第一个SpringBoot应用

阅读免费教程

后端通用面试教程

41个小节 30273 342

网络编程入门教程

20个小节 12461 235

Pandas 入门教程

25个小节 18362 330

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空