首頁手記 Spring Boot框架實戰：從入門到初級應用

Spring Boot框架實戰：從入門到初級應用

標簽：

SpringBoot

概述

本文将详细介绍如何使用Spring Boot框架从入门到初级应用的全过程，涵盖环境搭建、快速入门项目、核心功能详解以及实战项目开发。文章还将深入探讨数据库集成、RESTful服务创建、日志管理和安全配置等内容，帮助读者快速掌握Spring Boot框架实战技巧。

Spring Boot框架实战：从入门到初级应用

Spring Boot简介

Spring Boot是什么

Spring Boot是由Pivotal团队提供的基于Spring平台的快速开发框架。它旨在简化Spring应用的初始搭建以及开发、配置过程。Spring Boot的核心功能是通过一些约定优于配置的方式，让用户可以快速构建独立的、生产级别的应用。

Spring Boot的优势

快速开发：Spring Boot简化了传统Spring应用的配置过程，减少了样板代码，使开发者的精力可以更多地放在业务逻辑上。
自动配置：Spring Boot通过约定优于配置，提供了大量默认配置，使应用的配置变得容易。
无须web.xml：Spring Boot的Servlet容器内嵌功能，使得应用可以无需配置web.xml直接启动。
独立的可执行JAR：Spring Boot支持打包成独立的可执行JAR文件，可以方便地部署到任何Java虚拟机（JVM）上。
嵌入式Servlet容器：Spring Boot支持Tomcat、Jetty和Undertow等，使得开发过程无需额外的外部容器。
支持多种数据库：Spring Boot支持多种关系型数据库和NoSQL数据库，如MySQL、PostgreSQL、MongoDB等。
支持多种缓存：Spring Boot支持Redis、Ehcache等缓存解决方案。
支持多种消息队列：Spring Boot支持RabbitMQ、Kafka等消息队列。
支持多种模板引擎：Spring Boot支持Thymeleaf、Mustache等模板引擎。
自动配置与特性开关：Spring Boot可以根据类路径中的依赖为应用自动配置所需资源，并提供特性开关来控制是否启用某些功能。

开发环境搭建

安装Java环境

下载并安装JDK：建议使用JDK 8及以上版本。
配置环境变量：确保Java环境变量正确设置。
验证Java安装：可以通过运行以下命令来检查：
```
java -version
```

安装IDE

推荐使用IntelliJ IDEA或Spring Tool Suite（STS）作为开发工具。

准备Spring Boot项目

下载并安装Spring Initializr，或者使用Maven或Gradle创建项目。
通过Spring Initializr创建一个简单的Spring Boot项目，选择合适的依赖。

创建第一个Spring Boot应用：

使用Spring Initializr创建一个Spring Boot项目，选择合适的依赖。

在生成的项目中，有一个Application.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);
  }

}

快速入门项目

创建第一个Spring Boot应用

创建一个新的Spring Boot项目，可以通过Spring Initializr在线工具创建，也可以通过Maven或Gradle创建。

项目结构如下：

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       └── DemoApplication.java
│   └── resources
└── test
   └── java
       └── com.example.demo
           └── DemoApplicationTests.java

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

}

添加依赖和配置文件

依赖管理：在pom.xml文件中添加必要的依赖，例如，Spring Web依赖：

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

配置文件：在src/main/resources目录下添加application.properties文件，定义应用的配置：
```
server.port=8080
spring.application.name=demo-app
```

运行和测试项目

启动项目：运行DemoApplication类中的main方法，启动应用。
测试应用：在浏览器中访问http://localhost:8080，查看应用是否成功启动。

Spring Boot核心功能详解

自动配置原理

Spring Boot通过@SpringBootApplication注解来启用自动配置功能。这个注解实际上包含了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解的功能。

配置类：定义一个配置类，可以用来定义Spring Bean等。

@SpringBootConfiguration
public class MyConfiguration {
   // 自定义配置
}

自动配置：启用自动配置功能，Spring Boot会根据类路径中的依赖自动配置应用。
```
@EnableAutoConfiguration
public class MyAutoConfiguration {
   // 自动配置逻辑
}
```

组件扫描：扫描指定包下的所有组件，如Controller、Service、Repository等。

@ComponentScan
@SpringBootApplication
public class DemoApplication {
   // 应用启动逻辑
}

内嵌的Web服务器

Spring Boot内嵌的Web服务器，如Tomcat、Jetty或Undertow，可以简化开发流程。通过spring-boot-starter-web依赖，可以自动配置内嵌的Tomcat服务器，使得应用可以直接启动，而无需额外配置外部容器。

内嵌Tomcat：spring-boot-starter-web依赖包含了Tomcat的内嵌实现。

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

使用内嵌服务器：运行DemoApplication类中的main方法，可以启动内嵌的Tomcat服务器。

启动器和自动依赖管理

Spring Boot提供的启动器（Starter）功能，提供了很多预定义的依赖组合，可以自动管理依赖和其版本。例如，spring-boot-starter-web包含了Servlet API和Tomcat内嵌服务器。

启动器依赖：通过引入启动器依赖，可以自动管理所有相关依赖。

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

版本管理：Spring Boot会自动管理这些依赖的版本，避免版本冲突。

实战项目开发

创建RESTful服务

创建Controller：定义一个简单的RESTful控制器，用于处理HTTP请求。

package com.example.demo;

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

@RestController
@RequestMapping("/api")
public class HelloController {

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

}

运行应用：启动应用后，访问http://localhost:8080/api/hello，返回"Hello, Spring Boot!"。

数据库集成与JPA使用

数据库依赖：在pom.xml文件中添加MySQL驱动依赖和Spring Data JPA依赖。

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

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

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

创建Entity：定义一个简单的实体类。

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：定义一个接口，继承JpaRepository接口。

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> {
}

创建Service：定义一个服务类，用于处理业务逻辑。

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

   @Autowired
   private UserRepository userRepository;

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

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

}

创建Controller：定义一个控制器类，处理用户相关请求。

package com.example.demo.controller;

import com.example.demo.entity.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("/api/users")
public class UserController {

   @Autowired
   private UserService userService;

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

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

}

日志管理和安全配置

日志管理：使用Spring Boot的日志框架，可以方便地配置日志输出。
```
logging.level.root=INFO
logging.file.name=spring-boot.log
```

安全配置：使用Spring Security框架来实现应用的安全性。

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

配置Spring Security：在application.properties文件中配置安全相关的属性。

spring.security.user.name=admin
spring.security.user.password=123456
spring.security.user.roles=ADMIN

创建过滤器：自定义过滤器来实现更细粒度的安全控制。

package com.example.demo.security;

import org.springframework.security.web.csrf.CsrfToken;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.util.WebUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class CsrfTokenResponseHeaderBindingFilter extends OncePerRequestFilter {

   @Override
   protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
       CsrfToken csrf = (CsrfToken) request.getAttribute(CsrfToken.class.getName());
       if (csrf != null) {
           Cookie cookie = WebUtils.getCookie(request, "XSRF-TOKEN");
           String token = csrf.getToken();
           if (cookie == null || token != null && !token.equals(cookie.getValue())) {
               cookie = new Cookie("XSRF-TOKEN", token);
               cookie.setPath("/");
               response.addCookie(cookie);
           }
       }
       filterChain.doFilter(request, response);
   }

}

测试与调试

单元测试与集成测试

单元测试：使用JUnit和Mockito进行单元测试。

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

public class UserServiceTest {

   @Mock
   UserRepository userRepository;

   @InjectMocks
   UserService userService;

   @BeforeEach
   void setUp() {
       MockitoAnnotations.openMocks(this);
   }

   @Test
   void findAll() {
       when(userRepository.findAll()).thenReturn(Arrays.asList(
           new User(1L, "John Doe", "[email protected]"),
           new User(2L, "Jane Doe", "[email protected]")
       ));
       List<User> users = userService.findAll();
       assertEquals(2, users.size());
   }

   @Test
   void save() {
       User user = new User(null, "Alice", "[email protected]");
       when(userRepository.save(user)).thenReturn(user);
       User savedUser = userService.save(user);
       assertEquals("Alice", savedUser.getName());
   }

}

集成测试：使用Spring Boot的测试支持进行集成测试。

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.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {

   @Autowired
   private MockMvc mockMvc;

   @Autowired
   private UserRepository userRepository;

   @Test
   void getAllUsers() throws Exception {
       User user1 = new User(null, "John Doe", "[email protected]");
       User user2 = new User(null, "Jane Doe", "[email protected]");
       userRepository.saveAll(Arrays.asList(user1, user2));

       mockMvc.perform(MockMvcRequestBuilders.get("/api/users"))
           .andExpect(MockMvcResultMatchers.status().isOk())
           .andExpect(MockMvcResultMatchers.jsonPath("$.[0].name").value("John Doe"))
           .andExpect(MockMvcResultMatchers.jsonPath("$.[1].name").value("Jane Doe"));
   }

}

异常处理和日志记录

全局异常处理：定义一个全局的异常处理器。

package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import static org.springframework.http.HttpStatus.BAD_REQUEST;

@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

   @ExceptionHandler({IllegalArgumentException.class})
   @ResponseBody
   public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
       return new ResponseEntity<>(ex.getMessage(), BAD_REQUEST);
   }

}

日志记录：在代码中添加日志记录。

package com.example.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

   private static final Logger logger = LoggerFactory.getLogger(HelloController.class);

   @GetMapping("/hello")
   public String hello() {
       logger.info("Handling request to say hello.");
       return "Hello, Spring Boot!";
   }

}

调试技巧

使用断点：在代码中设置断点，使用IDE的调试工具逐步执行代码。
使用日志：通过添加详细的日志记录，帮助定位问题。
使用Spring Boot Actuator：启用Spring Boot Actuator，可以获取应用的运行时信息，如使用management.endpoints.web.exposure.include配置来启用特定的端点。
```
management.endpoints.web.exposure.include=health,info
```

部署与运行

打包与发布

打包成JAR文件：通过Maven或Gradle打包应用。
```
mvn clean package
```
或
```
./gradlew bootJar
```
发布到服务器：将生成的JAR文件上传到服务器，并使用Java命令启动。
```
java -jar demo-0.0.1-SNAPSHOT.jar
```

部署到云平台

云平台选择：可以选择阿里云、腾讯云或AWS等云平台进行部署。
部署步骤：
- 创建服务器实例。
- 将生成的JAR文件上传到服务器。
- 启动应用。
- 配置负载均衡和监控。

监控和日志收集

日志收集：使用日志收集工具，如Logstash或Fluentd，将日志发送到集中式的日志存储系统。
监控：使用Prometheus、Grafana或Zabbix等监控工具，监控应用的运行状态。

配置Spring Boot Actuator：启用监控功能。

management.endpoints.web.exposure.include=health,info,metrics

通过以上步骤，可以实现Spring Boot应用的快速开发、测试、部署和监控，使得开发过程更加高效和便捷。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

森欄

手記
篇

粉絲

104

獲贊與收藏

477

關注作者，訂閱最新文章

閱讀免費教程

后端通用面試教程

41個小節 32074 358

網絡編程入門教程

20個小節 13196 249

Pandas 入門教程

25個小節 19586 369

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空