首页手记 Spring Boot入门教程：快速搭建你的第一个项目

Spring Boot入门教程：快速搭建你的第一个项目

标签：

SpringBoot

概述

Spring Boot是由Pivotal团队提供的快速构建工具，旨在简化新Spring应用的初始搭建及开发过程。它通过约定优于配置的方式，帮助开发者减少配置工作量并快速上手。Spring Boot不仅简化了应用配置，还提供了嵌入式Servlet容器、自动配置和起步依赖等特性，使开发和部署更加便捷。

Spring Boot简介

什么是Spring Boot

Spring Boot是由Pivotal团队提供的基于Spring平台的快速构建工具，它是Spring生态系统的一份子。Spring Boot旨在简化新Spring应用的初始搭建以及开发过程。它通过约定优于配置的方式，帮助开发者快速上手，减少代码中重复的配置工作量。Spring Boot允许开发者快速搭建一个独立的、生产级别的应用。

Spring Boot的优势

简化配置：Spring Boot的核心功能之一就是简化配置。它通过众多默认配置来减少开发者的配置项，使开发者可以将更多精力放在业务开发上。
自动配置：Spring Boot可以自动配置应用程序所需的Spring Bean，大大减少了开发者编写配置文件的工作量。
嵌入式Servlet容器：Spring Boot可以内嵌Tomcat、Jetty等Servlet容器，无需额外配置。
起步依赖：使用Spring Boot的“起步依赖”特性，可以自动配置所需的所有依赖项，简化了依赖管理。
全栈开发框架：Spring Boot集成了许多常用的库和框架，从Web开发到数据库、安全、缓存和任务调度，几乎涵盖了所有常用功能。
生产就绪：Spring Boot提供了监控、日志和外部化配置等功能，使其更加适合生产环境。

Spring Boot的主要特点

基于约定优于配置：Spring Boot采用默认配置，减少了开发者在配置上的工作量。
独立运行的微服务：Spring Boot应用可以独立打包成一个可执行的JAR文件，可以独立运行。
内置的开发和生产特性：支持各种开发和生产特性，包括健康检查、监控、外部化配置等。
自动配置：根据应用的依赖和类路径中的类自动配置应用。
起步依赖：在依赖管理方面，Spring Boot项目中使用起步依赖，可以自动配置和依赖管理。
嵌入式Servlet容器：Spring Boot内置了Tomcat、Jetty或Undertow，可以将应用直接部署为独立的可执行文件。

环境搭建

安装Java环境

在开始使用Spring Boot之前，需要确保已经安装了Java环境。以下是安装步骤：

下载Java：
访问Oracle官方网站或其他Java发行版供应商网站，下载最新版本的JDK。
- Oracle官方网站：https://www.oracle.com/java/technologies/javase-downloads.html
- OpenJDK官方网站：https://openjdk.java.net/install/
安装Java：
根据操作系统下载相应的安装包，然后按照安装向导完成安装。
设置环境变量：
安装完成后，需要设置环境变量。以下是在Windows和Linux中的设置步骤：
- Windows：
  - 打开“系统属性” -> “高级系统设置” -> “环境变量”。
  - 在“系统变量”中，新建“JAVA_HOME”，值为Java的安装路径。
  - 修改“Path”，添加%JAVA_HOME%\bin。
  - 打开命令行窗口，输入java -version，验证是否安装成功。
- Linux：
  - 打开终端，使用文本编辑器编辑/etc/profile或~/.bashrc文件，添加以下内容：
```
export JAVA_HOME=/path/to/java
export PATH=$JAVA_HOME/bin:$PATH
```
  - 保存文件，运行source /etc/profile或source ~/.bashrc，使更改生效。
  - 在终端中输入java -version，验证安装是否成功。

创建Spring Boot项目

Spring Boot本身不需要单独安装，它是一个Maven或Gradle项目，通常通过IDE或构建工具来创建和管理项目。

使用Spring Initializr创建项目：
https://start.spring.io/，这是一个在线工具，可以帮助你快速创建Spring Boot项目。
选择项目信息：
- Project：选择Maven或Gradle项目。
- Language：选择Java。
- Spring Boot：选择最新版本的Spring Boot。
- Packaging：选择JAR或WAR（通常选择JAR）。
- Java Version：选择合适的Java版本。
- Dependencies：选择所需的依赖项，例如Web、JPA等。
下载项目：
点击“Generate”按钮，下载生成的项目压缩包。
导入项目到IDE：
将下载的压缩包解压到本地磁盘，使用IDE导入项目。
- IntelliJ IDEA：
  File -> New -> Project from Existing Sources -> 选择解压后的项目目录。
- Eclipse：
  File -> Import -> Maven -> Existing Maven Projects -> 选择解压后的项目目录。

配置开发工具

安装IDE：
推荐使用IntelliJ IDEA或Eclipse作为开发工具。
- IntelliJ IDEA：
  首先从官网下载并安装最新版本的IntelliJ IDEA。
  - 官网：https://www.jetbrains.com/idea/download/
  - 安装完成后，启动IDEA，创建新的Spring Boot项目。
- Eclipse：
  在Eclipse中安装Spring Tools插件，以便更好地支持Spring项目。
  - 安装插件：Help -> Eclipse Marketplace -> 搜索并安装Spring Tools插件。
安装Maven或Gradle：
- Maven：
  访问Maven官方网站下载并安装Maven。
  - 官网：http://maven.apache.org/download.cgi
  - 设置环境变量：MAVEN_HOME指向Maven安装目录，PATH包含%MAVEN_HOME%\bin。
- Gradle：
  从Gradle官方网站下载并安装Gradle。
  - 官网：https://gradle.org/releases/
  - 设置环境变量：GRADLE_HOME指向Gradle安装目录，PATH包含%GRADLE_HOME%\bin。

创建第一个Spring Boot项目

使用Spring Initializr创建项目

访问Spring Initializr网站：
打开浏览器，访问https://start.spring.io/，这是一个在线工具，可以快速创建Spring Boot项目。
选择项目信息：
- Project：选择Maven或Gradle项目。
- Language：选择Java。
- Spring Boot：选择最新版本的Spring Boot。
- Packaging：选择JAR或WAR（通常选择JAR）。
- Java Version：选择合适的Java版本。
- Dependencies：选择所需的依赖项，例如Web、JPA等。
下载项目：
点击“Generate”按钮，下载生成的项目压缩包。
导入项目到IDE：
将下载的压缩包解压到本地磁盘，使用IDE导入项目。
- IntelliJ IDEA：
  File -> New -> Project from Existing Sources -> 选择解压后的项目目录。
- Eclipse：
  File -> Import -> Maven -> Existing Maven Projects -> 选择解压后的项目目录。

项目结构解析

创建的Spring Boot项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               └── HelloController.java
│   └── resources
│       ├── application.properties
│       └── static
│           └── index.html
└── test
    └── java
        └── com
            └── example
                └── demo
                    └── DemoApplicationTests.java

DemoApplication.java：主类，包含main方法，启动Spring Boot应用。
HelloController.java：一个简单的控制器类，处理HTTP请求。
application.properties：Spring Boot配置文件。
static目录：存放静态资源文件，如HTML、CSS、JS等。
index.html：静态资源示例文件。
DemoApplicationTests.java：测试类，用于编写单元测试。

Spring Boot核心概念讲解

自动配置机制

Spring Boot的自动配置机制是它的一大特色。通过约定优于配置的原则，Spring Boot能够自动配置应用所需的依赖和服务。自动配置机制的实现依赖于ApplicationContext和@Configuration注解。

自动配置原理

自动配置的主要步骤如下：

定义配置类：
在META-INF/spring.factories中定义注解@Conditional，用于确定何时加载配置类。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\ 
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\ 
...

配置类实现：
配置类通常以SpringBootServletInitializer或SpringApplication为入口点，实现自动配置。
条件判断：
使用@Conditional注解判断是否满足条件，例如通过类路径检查是否存在某些类或依赖。
Bean定义：
如果满足条件，则在配置类中定义相应的@Bean。

示例代码

以下是一个简单的自动配置示例：

@Configuration
@ConditionalOnClass(JdbcTemplate.class)
public class MyAutoConfiguration {
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Starter依赖管理

Spring Boot的starter依赖管理是通过项目依赖管理来实现的。Spring Boot提供了各种starter，例如spring-boot-starter-web、spring-boot-starter-data-jpa等，这些starter包含了Spring Boot推荐的所有依赖项，简化了依赖管理。

Starter依赖示例

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

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

在build.gradle中添加spring-boot-starter-web依赖：

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

配置文件详解

Spring Boot支持多种配置文件格式，包括application.properties和application.yml。这些配置文件主要用于配置应用的行为和属性。

配置文件位置

配置文件的位置可以是：

src/main/resources/application.properties
src/main/resources/application.yml
src/main/resources/config/application.properties
系统环境变量中的SPRING_CONFIG_LOCATION或SPRING_PROFILES_ACTIVE

配置文件示例

application.properties文件示例：

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root

application.yml文件示例：

server:
  port: 8080
spring:
  datasource:
  url: jdbc:mysql://localhost:3306/dbname
  username: root
  password: root

实战演练

创建简单的RESTful API

创建一个简单的RESTful API，提供用户信息的增删改查操作。

创建实体类

定义一个简单的User实体类：

package com.example.demo.model;

public class User {
    private String id;
    private String name;
    private String email;

    // getter and setter
    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

创建Repository接口

定义一个UserRepository接口，继承自JpaRepository：

package com.example.demo.repository;

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

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

创建服务层

创建一个UserService接口和实现类：

package com.example.demo.service;

import com.example.demo.model.User;

import java.util.List;

public interface UserService {
    User saveUser(User user);
    User getUserById(String id);
    List<User> getAllUsers();
    void deleteUserById(String id);
}

@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

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

    @Override
    public User saveUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public User getUserById(String id) {
        return userRepository.findById(id).orElse(null);
    }

    @Override
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @Override
    public void deleteUserById(String id) {
        userRepository.deleteById(id);
    }
}

创建控制器

定义一个控制器UserController，提供REST接口：

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("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

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

    @PostMapping
    public User saveUser(@RequestBody User user) {
        return userService.saveUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable String id) {
        userService.deleteUserById(id);
    }
}

测试API

使用Postman或curl命令测试API。

查询所有用户：
```
curl http://localhost:8080/users
```
查询指定用户：
```
curl http://localhost:8080/users/{id}
```

创建用户：

curl -X POST -H "Content-Type: application/json" -d '{"name":"张三","email":"zhangsan@example.com"}' http://localhost:8080/users

删除用户：

curl -X DELETE http://localhost:8080/users/{id}

使用Spring Boot集成数据库

创建数据库

创建一个新的MySQL数据库，例如testdb。

CREATE DATABASE testdb;

配置数据库连接

在application.properties文件中配置数据库连接信息：

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

创建实体类

定义一个实体类Book：

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String author;
    private String isbn;

    // getters and setters
    public Long getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
}

创建Repository接口

定义一个BookRepository接口，继承自JpaRepository：

package com.example.demo.repository;

import com.example.demo.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;

public interface BookRepository extends JpaRepository<Book, Long> {
}

创建服务层

创建一个BookService接口和实现类：

package com.example.demo.service;

import com.example.demo.model.Book;

import java.util.List;

public interface BookService {
    Book saveBook(Book book);
    Book getBookById(Long id);
    List<Book> getAllBooks();
    void deleteBookById(Long id);
}

@Service
public class BookServiceImpl implements BookService {
    private final BookRepository bookRepository;

    public BookServiceImpl(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Override
    public Book saveBook(Book book) {
        return bookRepository.save(book);
    }

    @Override
    public Book getBookById(Long id) {
        return bookRepository.findById(id).orElse(null);
    }

    @Override
    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }

    @Override
    public void deleteBookById(Long id) {
        bookRepository.deleteById(id);
    }
}

创建控制器

定义一个控制器BookController，提供REST接口：

package com.example.demo.controller;

import com.example.demo.model.Book;
import com.example.demo.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @GetMapping
    public List<Book> getAllBooks() {
        return bookService.getAllBooks();
    }

    @GetMapping("/{id}")
    public Book getBookById(@PathVariable Long id) {
        return bookService.getBookById(id);
    }

    @PostMapping
    public Book saveBook(@RequestBody Book book) {
        return bookService.saveBook(book);
    }

    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable Long id) {
        bookService.deleteBookById(id);
    }
}

测试数据库操作

使用Postman或curl命令测试数据库操作。

查询所有书籍：
```
curl http://localhost:8080/books
```
查询指定书籍：
```
curl http://localhost:8080/books/{id}
```

创建书籍：

curl -X POST -H "Content-Type: application/json" -d '{"title":"Java编程思想","author":"Bruce Eckel","isbn":"978-7115321728"}' http://localhost:8080/books

删除书籍：

curl -X DELETE http://localhost:8080/books/{id}

运行和部署

在IDE中运行项目

启动Spring Boot应用：
- 在IntelliJ IDEA中，点击工具栏的绿色“Run”按钮或使用快捷键Ctrl+R。
- 在Eclipse中，右键点击DemoApplication.java，选择Run As -> Spring Boot App。
访问应用：
应用启动后，可以通过浏览器访问应用，默认端口为8080。
```
http://localhost:8080/
```

打包并部署Spring Boot应用

打包应用

使用Maven或Gradle打包应用。打包后的应用是一个独立的可执行JAR文件。

使用Maven打包：
```
mvn clean package
```
使用Gradle打包：
```
gradle build
```

部署应用

使用命令行运行：
使用java -jar命令运行打包后的JAR文件。
```
java -jar target/*.jar
```
部署到Tomcat：
将JAR文件复制到Tomcat的webapps目录，Tomcat会自动解压并启动应用。

部署到Docker：
创建Dockerfile，并使用docker build和docker run命令部署应用。

Dockerfile示例：

FROM openjdk:8-jre-slim
COPY target/*.jar app.jar
EXPOSE 8080
CMD ["java", "-jar", "app.jar"]

构建和运行Docker镜像：

docker build -t my-spring-boot-app .
docker run -d -p 8080:8080 my-spring-boot-app

部署到Kubernetes：
创建Kubernetes配置文件（如deployment.yaml和service.yaml），并使用kubectl命令部署应用。

Deployment示例：

apiVersion: apps/v1
kind: Deployment
metadata:
name: my-spring-boot-app
spec:
replicas: 1
selector:
 matchLabels:
   app: my-spring-boot-app
template:
 metadata:
   labels:
     app: my-spring-boot-app
 spec:
   containers:
   - name: my-spring-boot-app
     image: my-spring-boot-app:latest
     ports:
     - containerPort: 8080

Service示例：

apiVersion: v1
kind: Service
metadata:
name: my-spring-boot-app
spec:
selector:
 app: my-spring-boot-app
ports:
- protocol: TCP
 port: 80
 targetPort: 8080

使用kubectl部署：

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl get services

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

梵蒂冈之花

手记
篇

粉丝

30

获赞与收藏

168

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

Pandas 入门教程

25个小节 18600 342

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Spring Boot入门教程：快速搭建你的第一个项目

什么是Spring Boot

Spring Boot的优势

Spring Boot的主要特点

安装Java环境

创建Spring Boot项目

配置开发工具

使用Spring Initializr创建项目

项目结构解析

自动配置机制

自动配置原理

示例代码

Starter依赖管理

Starter依赖示例

配置文件详解

配置文件位置

配置文件示例

创建简单的RESTful API

创建实体类

创建Repository接口

创建服务层

创建控制器

测试API

使用Spring Boot集成数据库

创建数据库

配置数据库连接

创建实体类

创建Repository接口

创建服务层

创建控制器

测试数据库操作

在IDE中运行项目

打包并部署Spring Boot应用

打包应用

部署应用

阅读免费教程