• 简单地聊一聊Spring Boot的构架

    前言

    本文小编将详细解析Spring Boot框架，并通过代码举例说明每个层的作用。我们将深入探讨Spring Boot的整体架构，包括展示层、业务逻辑层和数据访问层。通过这些例子，读者将更加清晰地了解每个层在应用程序中的具体作用。通过代码实例，我们将帮助读者更好地理解和应用Spring Boot框架，从而提高应用程序的可维护性和可扩展性。

    什么是Spring Boot

    在介绍Spring Boot框架的分层之前，小编先为大家介绍一下什么是Spring Boot：

    Spring Boot是一个基于Spring框架的开发框架，旨在简化Spring应用程序的搭建和开发。Spring Boot提供了很多自动化配置的功能，可以快速地搭建一个基于Spring的Web应用程序，而不需要手动进行繁琐的配置。

    Spring Boot可以帮助开发人员快速构建各种类型的应用程序，包括Web应用程序、RESTful服务、批处理应用程序和基于消息的应用程序等。它采用Java编程语言，并且可以与各种其他技术集成，例如Thymeleaf、MongoDB、Redis等。

    Spring Boot还提供了很多有用的工具和插件，例如Spring Boot CLI（命令行界面），可以帮助开发人员更加便捷地创建、运行和测试Spring Boot应用程序。此外，Spring Boot还支持各种构建工具，例如Maven和Gradle，以及各种开发环境，例如Eclipse和IntelliJ IDEA。

    Spring Boot分层：

    Spring Boot主要分为4层：Controller层、Service层、Repository/DAO层和Model层。

    1. Controller层

    在SpringBoot中，Controller层是MVC（Model-View-Controller）模式中的控制器部分，负责处理来自用户发起的HTTP请求，并返回相应的响应结果。Controller层接收到请求后，通常会调用Service层进行业务逻辑处理，最后再将处理结果封装成响应对象并返回给前端。

    一个Controller类通常包含多个方法，每个方法对应一个不同的HTTP请求路径，并使用特定的注解来标识。例如，使用@GetMapping注解表示该方法处理GET请求，@PostMapping表示该方法处理POST请求。同时，通过@RequestParam注解可以获取请求参数，@PathVariable注解可以获取URL路径参数，@RequestBody注解可以获取请求体中的数据。

    2. Service层

    在Spring Boot中，Service层是应用程序的一部分，负责处理业务逻辑和协调不同的组件。它是控制器（Controller）和数据访问层（Repository）之间的中间层，用于将业务逻辑与数据操作解耦。

    Service层的主要职责可以总结如下：

    1. 执行业务逻辑：Service层负责实现应用程序的业务逻辑。它包含了具体的业务规则和操作流程，以满足需求和业务规定。例如，对于电子商务应用程序，Service层可能会包含创建订单、处理支付、验证库存等业务逻辑的实现。

    1. 协调数据访问：Service层充当控制器和数据访问层之间的桥梁。它通过调用相应的Repository接口来执行数据操作，如查询数据库、保存数据、更新数据等。Service层可以组织和协调多个Repository操作，以完成复杂的业务需求。

    1. 提供业务接口：Service层可以定义一些公共接口或方法，供其他组件（如控制器、其他Service等）使用。这样可以封装底层的业务逻辑实现，使其对外提供统一的接口。这种封装有助于提高代码的可维护性和重用性。

    1. 处理事务管理：Service层通常涉及到数据库的读写操作，需要保证数据的一致性和完整性。通过使用Spring框架提供的事务管理机制，Service层可以确保多个数据库操作在一个事务中执行。它可以定义事务的边界、隔离级别、回滚策略等，以确保数据操作的正确性和可靠性。

    1. 实现业务规则和验证：Service层可以包含对传入数据的验证和处理逻辑。例如，对于用户注册操作，Service层可能会对输入的用户名进行唯一性检查，对密码进行加密等。这样可以保证应用程序的安全性和数据的有效性。

    3. Repository/DAO层

    DAO全称是Data Access Object，其主要目标是从数据库高效获取（查询）数据，并为service层提供服务。

    Repository/DAO层的主要职责可以总结如下：

    1. 定义数据访问接口：Repository或DAO层定义了访问数据库的接口，它们通常包括各种读、写、更新、删除等操作。这些操作通过方法调用来实现，使得业务逻辑可以轻松地使用这些操作。

    1. 提供数据映射：Repository或DAO层负责将数据库中的数据映射到Java类或对象中。这种映射可以是简单的一对一关系，也可以是复杂的关联关系。通常情况下，开发人员会使用ORM框架（如Hibernate）来自动完成数据映射。

    1. 处理数据访问异常：Repository或DAO层负责处理与数据访问相关的异常情况，例如数据库连接失败、SQL语句执行错误等。它们可以捕获这些异常并进行相应的处理，以保证应用程序的稳定性和可靠性。

    1. 支持数据源配置：Repository或DAO层支持不同类型的数据源配置，例如关系型数据库、NoSQL数据库、文件系统等。它们可以根据不同的数据源类型，提供相应的数据访问接口和数据映射策略。

    1. 提供数据缓存：Repository或DAO层可以缓存已经读取的数据，以提高应用程序的性能。它们可以使用内存缓存、分布式缓存等不同类型的缓存机制，根据业务需求进行选择。

    4. Model层

    在Spring Boot中，Model层对象是用于封装和传递数据的Java对象。它表示应用程序中的业务数据，并负责处理数据的获取、保存和修改等操作。Model层对象通常具有以下特点：

    1. 实体类（Entity Class）：Model层对象通常是实体类或POJO（Plain Old Java Object），用于表示业务数据的结构。实体类的属性对应数据库表的字段，通过ORM（Object-Relational Mapping）框架可以将实体类与数据库进行映射。

    1. 数据传输对象（Data Transfer Object，DTO）：在一些场景下，为了满足特定的需求，可能需要使用DTO来封装数据。DTO是一个简单的Java对象，用于在不同的层之间传输数据。DTO通常只包含必要的属性，以减少数据传输的大小和复杂性。

    1. 数据校验（Data Validation）：Model层对象可以用于数据校验，确保传入的数据符合特定的规则和要求。可以使用注解（如javax.validation.constraints）或其他验证框架（如Hibernate Validator）对属性进行校验。

    1. 业务逻辑（Business Logic）：Model层对象可以包含一些业务逻辑的方法，用于处理数据的计算、转换和操作等。这些方法可以在Model层对象中定义，或者在服务层（Service Layer）中进行实现。

    代码示例：

    1.Controller层：

    ProjectController.java

    1. package com.example.Controller;
    2. //import statements goes here
    3. @RestController
    4. public class UserController {
    5.    
    6.     //List all the available projects
    7.     @GetMapping(path = "/projects", produces = MediaType.APPLICATION_JSON_VALUE)
    8.     public ResponseEntity> getProjects() {
    9.      
    10.     // perform validation checks
    11.     // return the services provided by service layer
    12.     }
    13.     //Apply for the project
    14.     @PostMapping(path = "/apply-project", consumes = MediaType.APPLICATION_JSON_VALUE)
    15.     public ResponseEntity applyProject(@RequestBody Map json) {
    16.     // perform validation checks
    17.     // return the services provided by service layer
    18.     }
    19.     
    20.     //Upload resume
    21.     @PostMapping(path = "/upload-resume/{usn}")
    22.     public ResponseEntity> uploadToDB(@RequestParam("file") MultipartFile[] file,@PathVariable String usn) {
    23.     
    24.     // perform validation checks
    25.     // return the services provided by service layer
    26.     }
    27.     //Download resume
    28.     @GetMapping("/files/download/{fileName:.+}")
    29.     public ResponseEntity downloadFromDB(@PathVariable String fileName) {
    30.     // perform validation checks
    31.     // return the services provided by service layer
    32.     }
    33. }

    上面例子使用了@GetMapping和@PostMapping：

    @GetMapping注解用于将一个方法映射到指定的HTTP GET请求。它可以用于处理浏览器直接访问某个URL或者其他应用程序发起GET请求的情况。通过在方法上添加@GetMapping，我们可以定义一个处理该请求的方法，并在方法中编写相应的业务逻辑。

    @PostMapping注解用于将一个方法映射到指定的HTTP POST请求。它可以用于处理表单提交、客户端数据上传等操作。通过在方法上添加@PostMapping，我们可以定义一个处理该请求的方法，并在方法中编写相应的业务逻辑。

    2.Service层：

    下面这段定义了项目相关的服务方法，并规定这些方法的输入参数和返回值。

    在代码示例中，ProjectService 接口声明了三个方法：

    1. getProjects() 方法返回一个 List 对象作为响应体（ResponseEntity），用于获取所有项目信息。

    1. applyProject(String USN,int project_id) 方法返回 HttpStatus 枚举值，表示申请参与某个项目的状态。

    1. uploadProjectDocument(MultipartFile[] files,int project_id) 方法返回 List 对象作为响应体，用于上传项目文档。

      ProjectService.java

      1. package com.example.Service;
      2.  
      3. // import statements
      4.  
      5. public interface ProjectService {
      6.  
      7.     ResponseEntity<List<Project>> getProjects();
      9.     HttpStatus applyProject(String USN,int project_id);
      10.  
      11.     ResponseEntity<List<Object>> uploadProjectDocument(MultipartFile[] files,int project_id);
      13. }

      ProjectServiceImpl.java

      1. package com.example.Service;
      2.  
      3. //import statements
      4. @Service
      5. public class ProjectServiceImpl implements ProjectService {
      6. //dependency injection of DAO to be gone here (Autowire)
      7.   
      8.     @Override
      9.     public ResponseEntity<List<Project>> getProjects() {
      10.         try {
      11.            //Business logic implementation using DAO services
      12.         } catch (Exception e) {
      13.             return new ResponseEntity<>(null,HttpStatus.INTERNAL_SERVER_ERROR) ;
      14.         }
      15.     }
      16.    
      17.     @Override
      18.     public HttpStatus applyProject(String USN, int project_id) {
      19.    
      20.     //Business logic implementation using DAO services
      21.     }
      22.   
      23.    //helper functions
      24.     public ResponseEntity uploadToLocalFileSystem(MultipartFile file,int project_id) {
      25.      
      26.     }
      27.     @Override
      28.     public ResponseEntity<List<Object>> uploadProjectDocument(MultipartFile[] files,int project_id) {
      29.        //Business logic implementation using DAO services
      30.     }
      31.  
      32. }

      3.Repository/DAO层：

      下面的这段代码是一个接口类，属于包名为"com.example.Dao"的项目数据访问对象（DAO）。它扩展了 JpaRepository 接口，该接口提供了基本的CRUD（创建、读取、更新、删除）操作方法，用于对数据库中的 "Project" 实体进行操作。

      ProjectDAO.java

      1. package com.example.Dao;
      2.  
      3. //import statements
      4.  
      5. public interface ProjectDao extends JpaRepository<Project,Integer> {
      6.  
      7. //You can also include native queries on top of CRUD operations provided by JPA
      8. // Add queries here using @Query annotations and corresponding functions
      9.  
      10.     @Query(value = "Your SQL query ",nativeQuery = true)
      11.     public List<Project> getProjects();
      12.  
      13. }
      14.  
      15. }

      4.Model层：

      下面这段代码定义了一个名为 "Project" 的实体类，表示一个项目。它包含了项目的各个属性（如项目ID、公司名称、描述、要求等），并与其他实体类（如员工、学生、文档、资金等）之间建立了关联关系。通过使用 JPA 注解，该类可以方便地进行数据库操作和查询。

      代码中的各个部分的含义如下：

      1. @Entity 注解表示该类是一个实体类，与数据库中的表进行映射。

      1. @Table(name = "project") 注解指定了对应的数据库表名为 "project"。

      1. @Id 注解表示该字段是主键。

      1. @GeneratedValue(strategy = GenerationType.IDENTITY) 注解指定了主键的生成策略为自增长。

      1. @Column 注解用于指定该属性与数据库表中的列的映射关系，其中 nullable 属性表示该列是否允许为空，name 属性指定了对应的数据库列名。

      1. @JsonIgnore 注解用于忽略该属性在序列化和反序列化过程中的处理。

      1. @ManyToMany(mappedBy="funded_projects") 注解表示当前实体与另一个实体 Fund 之间存在多对多的关联关系，通过 mappedBy 属性指定了在 Fund 实体中维护关联关系的属性名为

      1. "funded_projects"。

      1. Set, Set, Set, Set 表示与其他实体之间的关联关系，通过集合类型的属性来表示多对多关系或一对多关系。

      Project.java

      1. package com.example.Entity;
      2.  
      3. //import statements
      4.  
      5. @Entity
      6. @Table(name = "project")
      7. public class Project {
      8.     @Id
      9.     @GeneratedValue(strategy = GenerationType.IDENTITY)
      10.     private int project_id;
      11.     @Column(nullable = false, name = "company_name")
      12.     private String company_name;
      13.  
      14.     @Column(nullable = false, name = "description")
      15.     private String description;
      16.  
      17.     @Column(nullable = false, name = "requirements")
      18.     private String requirements;
      19.  
      20.     @Column(nullable = false, name = "manager")
      21.     private String manager;
      22.     @Column(nullable = false, name = "start_date")
      23.     private Date start_date = new Date();
      24.  
      25.     @Column( name = "end_date")
      26.     private Date end_date = new Date();
      27.     @Column(nullable = false,name = "opening")
      28.     private int opening;
      29.     @Column(name = "resources")
      30.     private String resources;
      31.     public Set<Staff> getStaff_incharge() {
      32.         return staff_incharge;
      33.     }
      34.     public void setStaff_incharge(Set staff_incharge) {
      35.         this.staff_incharge = staff_incharge;
      36.     }
      37.     public Set<Student> getApplied_students() {
      38.         return applied_students;
      39.     }
      40.     public Set<Document> getDocuments() {
      41.         return documents;
      42.     }
      43.     public void setDocuments(Set documents) {
      44.         this.documents = documents;
      45.     }
      46.     @JsonIgnore
      47.     @ManyToMany(mappedBy="funded_projects")
      48.     private Set<Fund> funds;
      49.     public Set<Fund> getFunds() {
      50.         return funds;
      51.     }
      52.     public void setFunds(Set funds) {
      53.         this.funds = funds;
      54.     }
      55.     public void setApplied_students(Set applied_students) {
      56.         this.applied_students = applied_students;
      57.     }
      58.     public Set<Student> getWorking_students() {
      59.         return working_students;
      60.     }
      61.     public void setWorking_students(Set working_students) {
      62.         this.working_students = working_students;
      63.     }
      64. //constructors
      65.     public Project() {
      66.         super();
      67.     }
      68.     public Project(int project_id, String company_name, String description, String requirements, String manager, Date start_date, Date end_date, int opening, String resources) {
      69.         super();
      70.         this.project_id = project_id;
      71.         this.company_name = company_name;
      72.         this.description = description;
      73.         this.requirements = requirements;
      74.         this.manager = manager;
      75.         this.start_date = start_date;
      76.         this.end_date = end_date;
      77.         this.opening = opening;
      78.         this.resources = resources;
      79.     }
      80.     public int getProject_id() {
      81.         return project_id;
      82.     }
      83.     public void setProject_id(int project_id) {
      84.         this.project_id = project_id;
      85.     }
      86.     public String getCompany_name() {
      87.         return company_name;
      88.     }
      89.     public void setCompany_name(String company_name) {
      90.         this.company_name = company_name;
      91.     }
      92.  
      93.     public String getDescription() {
      94.         return description;
      95.     }
      96.     public void setDescription(String description) {
      97.         this.description = description;
      98.     }
      99.     public String getRequirements() {
      100.         return requirements;
      101.     }
      102.     public void setRequirements(String requirements) {
      103.         this.requirements = requirements;
      104.     }
      105.     public String getManager() {
      106.         return manager;
      107.     }
      108.     public void setManager(String manager) {
      109.         this.manager = manager;
      110.     }
      111.     public Date getStart_date() {
      112.         return start_date;
      113.     }
      114.     public void setStart_date(Date start_date) {
      115.         this.start_date = start_date;
      116.     }
      117.     public Date getEnd_date() {
      118.         return end_date;
      119.     }
      120.     public void setEnd_date(Date end_date) {
      121.         this.end_date = end_date;
      122.     }
      123.     public int getOpening() {
      124.         return opening;
      125.     }
      126.     public void setOpening(int opening) {
      127.         this.opening = opening;
      128.     }
      129.     public String getResources() {
      130.         return resources;
      131.     }
      132.     public void setResources(String resources) {
      133.         this.resources = resources;
      134.     }
      135.     @Override
      136.     public String toString() {
      137.         return "Project{" +
      138.                 "project_id=" + project_id +
      139.                 ", company_name='" + company_name + '\'' +
      140.                 ", description='" + description + '\'' +
      141.                 ", requirements='" + requirements + '\'' +
      142.                 ", manager='" + manager + '\'' +
      143.                 ", start_date=" + start_date +
      144.                 ", end_date=" + end_date +
      145.                 ", opening=" + opening +
      146.                 ", resources='" + resources + '\'' +
      147.                 '}';
      148.     }
      149. }

      总结

      本文为读者详细介绍了Spring Boot框架的四层构架，以及如何使用各种技术和工具来进行开发。通过阅读本文，希望可以帮助读者可以更好地理解Spring Boot框架的工作原理和应用场景，并能够利用所学知识来实现自己的项目。

      参考资料：《Understanding Spring Boot Architecture》

      扩展链接：

      Redis从入门到实践

      一节课带你搞懂数据库事务！

      Chrome开发者工具使用教程

      从表单驱动到模型驱动，解读低代码开发平台的发展趋势

      低代码开发平台是什么？

      基于分支的版本管理，帮助低代码从项目交付走向定制化产品开发

      文章转载自：葡萄城技术团队

      原文链接：https://www.cnblogs.com/powertoolsteam/p/17816504.html

    2. 相关阅读:
      kubernetes实战入门-Service
      容易对一个异性产生依赖感怎么办？
      [附源码]java毕业设计高校评教系统
      OpenCascade学习一：OpenCascade的重要类解释和OpenCascade的Brep方式表示几何解释
      面向临床需求的CT图像降噪综述
      ViT:Vision transformer的cls token如何实现分类？
      el-row和el-col在element ui中的注意点
      【快速幂】
      cv2绘图 cv.line()，cv.circle()，cv.rectangle()，cv.ellipse()，cv.putText() python
      python 线程安全和锁
    3. 原文地址：https://blog.csdn.net/kfashfasf/article/details/134401725