• Java Spring Boot: 极简配置与快速开发的利器

    引言：

    Java Spring Boot是一款开源的Java框架，它以极简配置和快速开发为特点，帮助开发者轻松构建基于Spring框架的应用程序。本文将介绍Spring Boot的核心特性，并结合案例和代码，展示其在简化配置、内嵌服务器、自动化依赖管理、健康检查与度量指标、集成测试支持和外部化配置等方面的优势。

    1. 简化配置

    Spring Boot采用了自动配置和约定优于配置的原则，通过默认的配置和自动扫描机制，减少了开发者需要手动配置的工作量。开发者只需少量的配置即可使应用程序运行起来，大大简化了配置的过程。

    案例：下面的代码展示了如何创建一个简单的Spring Boot应用程序，并通过自动配置的方式来实现数据库访问。

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

@RestController
public class MyController {
    @Autowired
    private UserRepository userRepository;
    
    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 省略其他方法
}

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;
    // 省略getter和setter方法
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    2. 内嵌服务器

    Spring Boot内置了多种常用的Web服务器，如Tomcat、Jetty等，开发者无需单独安装和配置服务器，可以直接运行应用程序。只需将应用程序打包成可执行的jar文件，就可以直接在内嵌的服务器上运行，简化了部署和运行的过程。

    案例：下面的代码展示了如何使用Spring Boot内嵌的Tomcat服务器来运行一个简单的Web应用程序。

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    3. 自动化依赖管理

    Spring Boot引入了起步依赖（Starter）的概念，通过添加相关的起步依赖，自动导入所需的依赖库。起步依赖是一组关联的依赖库的集合，使得依赖管理更加简单和便捷。开发者只需关注自己需要的功能，无需关心具体的依赖库和版本号。

    案例：下面的代码展示了如何通过起步依赖来自动导入Spring Web和MySQL数据库的依赖。

    <dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
    dependency>
dependencies>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    4. 健康检查和度量指标

    Spring Boot集成了Actuator模块，提供了健康检查和度量指标的功能。通过暴露应用程序的健康检查接口和度量指标接口，开发者可以监控应用程序的运行状态和性能指标，及时发现和解决问题。

    案例：下面的代码展示了如何通过Actuator来实现应用程序的健康检查和度量指标。

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

@RestController
public class HealthCheckController {
    @GetMapping("/health")
    public String checkHealth() {
        return "OK";
    }
}

@Configuration
public class ActuatorConfig {
    @Bean
    public HealthIndicator customHealthIndicator() {
        return () -> {
            // 自定义的健康检查逻辑
            return Health.status("UP").build();
        };
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    5. 集成测试支持

    Spring Boot提供了集成测试支持，可以方便地进行单元测试和集成测试。开发者可以使用Spring Boot提供的测试框架和工具，编写各种类型的测试用例，确保应用程序的质量。支持MockMvc，能够模拟HTTP请求和响应，对Web应用程序进行测试。

    案例：下面的代码展示了如何使用Spring Boot的测试框架和MockMvc来进行集成测试。

    @SpringBootTest
@AutoConfigureMockMvc
public class MyControllerTest {
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    public void testGetUsers() throws Exception {
        mockMvc.perform(get("/users"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$[0].name", is("John")))
                .andExpect(jsonPath("$[0].age", is(25)));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    6. 外部化配置

    Spring Boot支持外部化配置，开发者可以使用属性文件、环境变量等方式进行配置。应用程序的配置更加灵活和可维护，可以根据不同的环境设置不同的配置，适应不同的需求和场景。

    案例：下面的代码展示了如何使用属性文件来配置数据库连接信息。

    application.properties：

    spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456

    • 1
    • 2
    • 3
    @SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

@RestController
public class MyController {
    @Value("${spring.datasource.url}")
    private String dbUrl;
    
    @GetMapping("/dburl")
    public String getDbUrl() {
        return dbUrl;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    案例分析：

    假设我们正在开发一个图书管理系统，并使用Spring Boot来构建后端服务。我们需要实现以下功能：

    1. 添加图书：接收图书的标题、作者和价格等信息，并将其保存到数据库中。
    2. 查询图书：根据图书的标题或作者进行模糊查询，并返回符合条件的图书列表。
    3. 更新图书价格：根据图书的ID，接收新的价格，并将其更新到数据库中。
    4. 删除图书：根据图书的ID，从数据库中删除相应的图书记录。

    为了实现上述功能，我们需要进行一些基本的配置和编码工作。但是，借助Spring Boot的简化配置特性，我们可以轻松完成这个案例。

    首先，我们需要创建一个Spring Boot应用程序的入口类。

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    接下来，我们需要创建一个Book实体类，表示图书的信息。

    @Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    private String author;
    private Double price;
    
    // 省略构造函数、getter和setter方法
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    然后，我们需要创建一个BookRepository接口，用于与数据库进行交互。

    @Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    List<Book> findByTitleContainingOrAuthorContaining(String title, String author);
}

    • 1
    • 2
    • 3
    • 4

    接下来，我们需要创建一个BookController类，用于处理图书相关的HTTP请求。

    @RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookRepository bookRepository;
    
    @PostMapping
    public Book addBook(@RequestBody Book book) {
        return bookRepository.save(book);
    }
    
    @GetMapping
    public List<Book> searchBooks(@RequestParam(required = false) String keyword) {
        if (keyword != null) {
            return bookRepository.findByTitleContainingOrAuthorContaining(keyword, keyword);
        }
        return bookRepository.findAll();
    }
    
    @PutMapping("/{id}")
    public Book updateBookPrice(@PathVariable Long id, @RequestParam Double price) {
        Book book = bookRepository.findById(id).orElse(null);
        if (book != null) {
            book.setPrice(price);
            return bookRepository.save(book);
        }
        return null;
    }
    
    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable Long id) {
        bookRepository.deleteById(id);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    最后，我们需要创建一个application.properties文件，并配置数据库连接信息。

    spring.datasource.url=jdbc:mysql://localhost:3306/book_db
spring.datasource.username=root
spring.datasource.password=123456

    • 1
    • 2
    • 3

    通过以上配置和代码，我们就完成了一个基于Spring Boot的图书管理系统。

    练习题：

    1. 如何使用Spring Boot的自动配置特性来简化数据库连接的配置？
    2. 什么是起步依赖（Starter）？如何使用起步依赖来自动导入所需的依赖库？
    3. 如何使用Spring Boot的约定优于配置特性来减少配置工作量？
    4. 在上述案例中，如何实现根据图书的标题或作者进行模糊查询？
    5. 在上述案例中，如何实现根据图书的ID更新图书的价格？
    6. 在上述案例中，如何实现根据图书的ID删除图书记录？

    答案：

    1. 使用Spring Boot的自动配置特性，我们可以在application.properties文件中配置数据库连接的相关信息，如数据库的URL、用户名和密码等。Spring Boot会根据这些配置自动创建数据源，并将其注入到应用程序中的Repository类中，从而使得我们可以方便地进行数据库操作。

    2. 起步依赖（Starter）是一种特殊的依赖，它能够自动导入所需的依赖库。在使用起步依赖时，我们只需要在项目的pom.xml文件中添加对应的起步依赖，然后Maven或Gradle会自动下载并导入所需的依赖库。例如，在Spring Boot中，我们可以使用"spring-boot-starter-web"起步依赖来自动导入Spring MVC和相关的依赖库。

    3. Spring Boot的约定优于配置特性意味着我们可以通过遵循一些约定来减少配置的工作量。例如，在Spring Boot中，默认的配置文件名是application.properties，如果我们将配置文件命名为application.properties并将其放置在classpath下的根目录下，Spring Boot会自动读取该配置文件中的配置项，并将其应用到应用程序中。

    4. 在上述案例中，我们可以通过在BookRepository接口中定义一个findByTitleContainingOrAuthorContaining方法，使用Spring Data JPA提供的命名查询来实现根据图书的标题或作者进行模糊查询。具体代码如下：

    @Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    List<Book> findByTitleContainingOrAuthorContaining(String title, String author);
}

    • 1
    • 2
    • 3
    • 4
    1. 在上述案例中，我们可以在BookController类中定义一个@PutMapping方法，接收图书的ID和新的价格作为参数，然后通过调用bookRepository.findById方法找到相应的图书记录，并更新其价格。具体代码如下：
    @PutMapping("/{id}")
public Book updateBookPrice(@PathVariable Long id, @RequestParam Double price) {
    Book book = bookRepository.findById(id).orElse(null);
    if (book != null) {
        book.setPrice(price);
        return bookRepository.save(book);
    }
    return null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    1. 在上述案例中，我们可以在BookController类中定义一个@DeleteMapping方法，接收图书的ID作为参数，然后通过调用bookRepository.deleteById方法删除相应的图书记录。具体代码如下：
    @DeleteMapping("/{id}")
public void deleteBook(@PathVariable Long id) {
    bookRepository.deleteById(id);
}

    • 1
    • 2
    • 3
    • 4

    综上所述，Java Spring Boot框架通过简化配置、内嵌服务器、自动化依赖管理、健康检查和度量指标、集成测试支持和外部化配置等特性，极大地提高了开发效率和应用程序的质量。开发者能够专注于业务逻辑的开发，而无需花费过多的时间和精力在繁琐的配置和部署上。无论是Web应用、RESTful服务、批处理任务还是消息队列等，Spring Boot都能够提供强力支持，成为Java开发者的首选框架。

  • 相关阅读:
    （附源码）php疫情上报管理系统 毕业设计 170948
    （十五） 共享模型之工具【线程池】
    蓝桥杯2023年第十四届省赛真题-买瓜--C语言题解
    Java的数据类型
    使用Hot Chocolate和.NET 6构建GraphQL应用(9) —— 实现Mutate更新数据
    Qt绘图机制
    通过python 的selenium 操作shadow前端页面实现自动点击上传图片
    前端实现下载文件（处理后端返回的二进制流）
    【PAT甲级】1131 Subway Map
    下载离线地图地形数据库（3D离线地图开发）
  • 原文地址：https://blog.csdn.net/hitpter/article/details/133254856