SpringBoot

.:::.

已于 2024-02-06 20:56:03 修改

阅读量95

点赞数

文章标签： springboot

于 2023-11-20 19:59:15 首次发布

本文链接：https://blog.csdn.net/m0_74378487/article/details/134516756

版权

https://start.spring.io/

http://start.aliyun.com

https://start.springboot.io

Spring Boot 是基于 Spring 的框架该框架使用了特定的方式来进行配置从而使开发人员不再需要定义样板化的配置

前后端分离项目的后端通常需要编写以下几层：

1.config（配置层）：

配置层负责应用程序的配置管理，包括数据库连接配置、日志配置等。配置层通常使用配置文件或注解方式进行配置。

2.controller（控制器层）：

控制器层负责接收前端的请求，处理请求并返回响应。控制器层与视图层进行交互，将数据传递给视图层进行展示。

3.dao（数据访问层）：

数据访问层负责与数据库进行交互，实现数据的持久化操作。数据访问层通常包含一些数据访问接口和其对应的实现类，用于执行数据库操作。通俗来讲就是和数据库进行交互，对数据库进行增、删除、修改、查询操作，取得结果集，然后将结果中数据封装成VO或DTO返回给Service层。

mybatis

该层是数据访问层的一个框架，用来进行数据库访问的优化，专注于SQL语句，极大的简化了JDBC的访问。

mapper

该层是数据访问层的一部分，主要负责将数据从数据库中提取出来并转换成Java对象，或将Java对象转换为数据库中的数据。主要职责是提供数据访问接口，将数据库操作和Java对象之间的转换封装起来，使Service层无需直接与数据库打交道。

4.pojo（实体层）：

pojo层是一个用于封装数据和简单业务逻辑的普通Java类。它们是无关框架、简单、可重用的对象，通常与业务逻辑无关，只负责持有和传输数据。pojo类通常包含一组私有字段（成员变量）、对应的 getter 和 setter 方法、以及其他的实例方法。

entity

该层通常包含一组私有字段（成员变量）、对应的getter和setter方法、以及其他的实例方法，用于表示实际的业务实体。它们可以用于表示系统中的各种对象，如用户、订单、产品等等。这些字段可以用于表示数据、状态或属性，并通过getter和setter方法提供对这些字段的访问和修改。

5.service（服务层）：

服务层是业务逻辑层，负责实现应用程序的业务功能，对外提供API接口，接收请求并处理。服务层通常包含一些业务逻辑的实现，例如数据的增删改查等操作。

common

该层是一个通用的模块或组件集合，它包含了一些通用的代码、工具类、常量、配置文件等，以供整个应用程序使用。common 层在多层架构中通常位于服务层和持久化层之间，它提供了一些常用的工具类和方法，以供不同的层次之间共享或重用。

filter

该层是指在软件开发中，用于对请求或响应进行过滤或拦截的一层组件。它通常位于系统的输入和输出之间，可以用来对请求进行预处理、过滤无效请求、验证权限、记录日志等操作，也可以对响应进行处理、加工数据、设置头信息等操作。

component

该层通常包含了一系列的Spring组件（Component），例如服务（Service）、存储库（Repository）、控制器（Controller）等。这些组件通常是通过依赖注入（Dependency Injection）的方式进行管理和组合，以构建出完整的应用程序。

具体层次结构可能因不同的架构或框架而有所差异，但一般情况下，整个应用程序可以被划分为以下几个主要层次：

1.表现层（Presentation Layer）：负责处理用户界面和用户交互，通常是展示数据和接收用户输入的界面组件。

2.应用层（Application Layer）：负责处理业务逻辑和应用程序的工作流程，通常包含了业务逻辑的实现。

3.领域层（Domain Layer）：负责定义核心业务领域的模型和规则，通常包含了业务对象、服务和规则的定义。

4.数据访问层（Data Access Layer）：负责与数据存储交互，通常包含了数据库操作和数据访问的实现。

5.基础设施层（Infrastructure Layer）：提供通用的基础设施支持，如日志记录、安全性、配置管理等。

6.外部接口层（External Interface Layer）：负责与外部系统或服务进行通信和集成。

get和set

get 和 set 是常用的命名约定，用于访问和修改对象的属性（字段）值。这样的命名约定是面向对象编程的一种规范。

get 方法用于获取对象的属性值，通常以 get 开头，后面跟着属性的名称。例如，如果有一个名为 name 的属性，那么对应的 get 方法通常命名为 getName()。

set 方法用于设置对象的属性值，通常以 set 开头，后面跟着属性的名称。例如，如果有一个名为 name 的属性，那么对应的 set 方法通常命名为 setName()。

下面是一个示例，演示了如何使用 get 和 set 方法：

public class Person {
    private String name;//定义一个私有的string类型的变量name
    public String getName() {//getName() 方法用于获取 name 属性的值，返回类型为 String
        return name;
    }
    public void setName(String name) {//定义一个公共的方法，返回类型为 void，方法名为 setName。这里的参数名与类的成员变量名相同。
        this.name = name;//这行代码使用关键字 this 来引用当前对象，将传入的 name 参数的值赋给对象的成员变量 name。通过使用 this 关键字，我们明确指示要访问的是当前对象的成员变量，而不是方法的参数。
    }
}

在其他地方使用 Person 类及其 get、set 方法

Person person = new Person();//实例化person类，Person person = new Person(); 这行代码创建了一个 Person 对象并将其赋值给 person 变量。这个过程被称为实例化，它通过调用类的构造方法来创建一个类的实例（对象）。
person.setName("Alice");//调用了 person 对象的 setName 方法，并传入参数 "Alice"。这个方法会将传入的字符串设置为 person 对象的姓名属性。
String name = person.getName();//调用了 person 对象的 getName 方法，并将返回的姓名字符串赋值给 name 变量。这个方法会返回 person 对象的姓名属性。

实例化

Java 中的实例化是指创建一个对象的过程，即将一个类转换为该类的具体实例。而实例方法则是属于特定对象的函数或过程。

要实例化一个对象并使用实例方法，可以按照以下步骤进行：

1.定义一个类：首先，需要定义一个类，其中包含所需的属性和方法。

2.创建类的实例：使用类名和括号来创建一个类的实例，例如：

MyClass myObject = new MyClass();

3.调用实例方法：使用实例对象来调用实例方法，例如：

myObject.myMethod();

下面是一个示例代码，展示了如何实例化一个类并使用实例方法：

public class MyClass {//定义一个公共的类MyClass。
    private String name;//定义一个私有的字符串变量name，用于存储对象的名称。
    public MyClass(String name) {//定义一个公共的构造方法MyClass，接受一个字符串参数name。
        this.name = name;//在构造方法中，使用关键字"this"将传入的name参数赋值给类的成员变量name。
    }
    public void sayHello() {//定义一个公共的无返回值方法sayHello()。
        System.out.println("Hello, my name is " + name);//在sayHello()方法中，使用System.out.println()语句打印一条消息，其中包含对象的名称。
    }
    public static void main(String[] args) {
        MyClass myObject = new MyClass("aa");//在main()方法中，创建一个名为myObject的MyClass对象，并传入参数"aa"进行初始化。
        myObject.sayHello();//调用myObject对象的sayHello()方法，输出打印的消息。
    }
}

在这个例子中，我们定义了一个名为MyClass的类，它包含一个构造函数MyClass(String name)和一个实例方法sayHello()。在main方法中，我们使用new MyClass("Alice")来创建一个名为myObject的实例对象，并将"Alice"作为参数传递给构造函数。然后，我们通过myObject.sayHello()来调用实例方法sayHello()，它将输出"Hello, my name is Alice"。

Impl后缀

在Spring Boot中，类名后面的"Impl"后缀通常表示该类是一个实现类，用于实现某个接口或继承某个抽象类。这种命名约定是一种编程约定，旨在使代码更具可读性和可维护性。

在Spring Boot中，常见的使用场景是使用"ServiceImpl"后缀来标记服务层的实现类。服务层通常用于处理业务逻辑，而"Impl"后缀用于明确表示该类是某个服务接口的实现。

例如，如果你有一个名为"MyService"的接口

public interface MyService {//定义一个公共的接口MyService。
    void doSomething();//在接口中声明了一个无返回值的方法doSomething()。接口中的方法声明没有方法体，只有方法签名。
}

为了实现这个接口，你可能会创建一个类：

@Service//这是一个注解，用于表示该类是一个服务类。注解是一种元数据，通过在代码中加入注解，可以为程序提供额外的信息或指示。
public class MyServiceImpl implements MyService {//定义了一个公共的类MyServiceImpl，并实现了接口MyService。
    @Override//这也是一个注解，用于告诉编译器该方法是覆盖（重写）了父类或接口中的方法。
    public void doSomething() {//重写了接口中的doSomething()方法。
    //在doSomething()方法中，编写具体的实现细节。
    }
}

在springboot的配置文件中，你可能会这样引用这个实现类：

<bean id="myService" class="com.example.MyServiceImpl">
    <!-- 其他配置 -->
</bean>

在这里，“MyServiceImpl”就是“MyService”接口的实现类。这种命名约定在许多Java项目中都是通用的，不仅仅是Spring。它的主要目的是为了明确指出一个类是为了实现某个接口或扩展某个类而设计的。

在Java中，可以使用@RequestBody注解将JSON请求体绑定到方法参数上。以下是一个示例：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController//这是一个注解，用于将该类标识为一个REST风格的控制器，可以处理HTTP请求并返回响应。
public class MyController {//定义了一个公共的类MyController。
    @PostMapping("/api/myendpoint")//这是一个注解，用于指定处理POST请求的URL路径为"/api/myendpoint"。
    public ResponseEntity<String> myMethod(@RequestBody MyRequestBody requestBody) {//ResponseEntity<String>是一个泛型类，表示HTTP响应实体。在这里，它被指定为泛型类型为String，即表示响应体的类型是字符串。定义了一个公共的方法myMethod，使用了注解@PostMapping指定它处理POST请求，并接受一个类型为MyRequestBody的请求体参数。
        //在myMethod方法中，可以编写代码来处理接收到的请求数据。
        String response = "处理成功";//在myMethod方法中，定义了一个字符串变量response，并给它赋值为"处理成功"。
        return new ResponseEntity<>(response, HttpStatus.OK);//使用ResponseEntity类封装响应数据，返回一个包含响应体和HTTP状态码的对象。这里将response作为响应体，HttpStatus.OK表示响应状态为200（请求成功）。
    }
}

在上面的代码中，我们使用@PostMapping注解将/api/myendpoint路径映射到myMethod方法上。该方法接受一个名为requestBody的参数，该参数使用@RequestBody注解进行标记，表示该参数的值应从请求体中获取。MyRequestBody是一个自定义的Java类，用于表示请求体的结构。

当客户端发送一个POST请求到/api/myendpoint时，Spring框架将自动将请求体中的JSON数据绑定到requestBody参数上。然后，您可以在方法体内使用requestBody对象来访问请求体的数据。

请注意，要使此代码正常工作，您需要在项目中包含Spring Web依赖项，并且需要确保客户端发送的JSON数据与MyRequestBody类的结构匹配。

Spring Web依赖项在Maven项目中可以在pom.xml文件中添加以下依赖项：

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

import导入包

在Java中，使用import关键字导入一个类，并不会使当前类成为被导入类的子类。import关键字主要用于简化代码，使得在代码中可以不必使用完整的类名来引用一个类。

例如，如果你有一个名为Animal的类，你可以使用import关键字导入它，然后在代码中直接使用Animal类，而不需要使用完整的包名和类名。

import com.example.Animal;

public class Zoo {//定义了一个公共的类Zoo。
    Animal animal = new Animal();//创建了一个名为animal的Animal对象，并将其实例化赋值给变量animal。
}

在上面的代码中，Animal类被导入到Zoo类中，但Zoo类并不是Animal类的子类。它们之间的关系是实例关系，即Zoo类创建了一个Animal类的实例。

如果想要创建一个子类，你需要在代码中声明一个新的类，并在声明时指定父类。例如：

public class Dog extends Animal {
    // Dog类的属性和方法
}

在上面的代码中，Dog类被声明为Animal类的子类。这意味着Dog类继承了Animal类的所有属性和方法。

手动封装

1.创建包结构：根据项目需求，创建合适的包结构，例如 com.example.myapp。

2.定义组件：使用@Component、@Service、@Repository或@Controller等注解来定义组件。例如，创建一个名为UserService的Service组件：

package com.spring.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    // 实现业务逻辑
}

配置属性：在application.properties或application.yml文件中配置相关属性。例如，配置数据库连接信息：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/spring
    username: root
    password: 1234

编写配置类：使用@Configuration注解创建一个配置类，并在其中使用@Bean注解来定义Bean。例如，创建一个名为UserConfig的配置类：

package com.spring.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.spring.service.UserService;

@Configuration
public class UserConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

创建数据访问对象（DAO）：使用JPA或MyBatis等持久层框架创建数据访问对象，封装数据库操作。例如，创建一个名为UserDao的DAO类：

package com.spring.dao;

import org.springframework.stereotype.Repository;
import com.spring.model.User;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.util.List;

@Repository//@Repository 注解是 Spring 框架提供的，它会将这个类作为 Bean 注册到 Spring 的应用上下文中，方便其他组件进行依赖注入。
public class UserDao {//定义了一个名为 UserDao 的公共类，用于处理与用户数据相关的操作。
    @PersistenceContext//用于将 EntityManager 对象注入到该类中。
    private EntityManager entityManager;//声明了一个私有的 EntityManager 对象，用于执行数据库操作。
    public List<User> findAll() {//定义了一个公共方法 findAll()，返回类型为 List<User>。这个方法用于查询数据库中的所有用户数据。
        Query query = entityManager.createQuery("SELECT u FROM User u");//创建一个查询对象 Query，并使用 EntityManager 对象创建一个查询。通过调用 createQuery() 方法，传入一个 JPQL（Java Persistence Query Language）查询语句，这里的查询语句表示查询所有 User 实体对象。
        return query.getResultList();//执行查询并返回结果列表。通过调用 getResultList() 方法，获取查询的结果集，并将其作为 List<User> 类型返回。
    }
}

在某些情况下，服务类可能没有实现特定的接口，而是直接作为一个具体的类存在。这是因为在这种情况下，服务类可能不需要与其他类进行交互或扩展特定的接口。这样做可以简化代码结构，并且在某些情况下可以提高性能。

通常情况下，如果一个方法不需要访问类的实例变量或方法，并且可以独立地执行，那么将其声明为静态方法是更常见的做法。这样可以直接通过类名调用方法，而无需实例化对象。

在main方法中，由于它是程序的入口点，是一个静态方法，因此可以直接调用其他静态方法。如果example方法是静态方法，你可以直接在main方法中调用它，就像你最初提供的代码一样。

但如果你希望将reverseString方法作为实例方法，那么你需要先创建一个类的实例，然后通过该实例调用方法。这种方式适用于方法需要访问实例变量或其他实例方法的情况。

所以，选择将方法声明为静态还是非静态取决于方法的功能和是否需要访问类的实例变量或方法。根据具体情况来选择合适的方式。

Spring和Spring Boot的区别如下：

1.简化操作：Spring Boot通过使用Spring JDBC模块的JDBCTemplate，简化了操作，只需配置几行代码。

2.配置要求：Spring Boot消除了设置Spring应用程序所需的XML配置，为更快、更高效的开发生态系统铺平了道路。

3.运行环境：Spring Boot提供了Spring运行的默认配置，为通用Spring项目提供了很多非功能性特性。

4.创建应用：Spring Boot可创建独立的Spring应用程序，嵌入Tomcat、JettyUndertow，而且不需要部署。

现在开发中，Spring和SpringBoot都有广泛的应用。

Spring是Java后端框架家族中最强大的一个，拥有IOC和AOP两大利器，简化了开发的复杂性。而且Spring现在能与所有主流开发框架集成，是一个万能框架，让Java开发变得简单。

SpringBoot在很多中小公司中是首选，由于它的应用实在是太广泛，这里就不浪费笔墨做过多介绍了。SpringBoot当年的目标，是为了干掉J2EE。不过，尽量的做的轻量级，一直是它的主旋律，这一点从来没有变过。

Spring Boot中的单例模式是指某些Bean只需要被创建一次，在一个JVM进程中仅有一个实例，只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例，并在整个应用程序的生命周期中被共享使用。

单例模式是一种常见的设计模式，指的是在整个应用程序的生命周期中，某个类的实例只能被创建一次。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

SpringBoot的Bean默认是懒汉模式。

Spring在启动时，默认会立即将单实例Bean进行实例化，并加载到Spring容器中。

Spring的懒加载有两种方式：一是配置全局懒加载，二是配置某个Bean上的懒加载。如果同时配置了两种方式，则以Bean上配置懒加载属性为准。

application.properties是SpringBoot框架中的一个全局的配置文件。

application.properties是核心配置文件，用于配置SpringBoot应用中的参数，如数据库连接、服务器端口号等。

springboot.iml 文件是 IntelliJ IDEA 生成的模块文件，它描述了与 Spring Boot 项目相关的模块信息，用于存储模块的路径、依赖等。

SpringBoot.iml文件很重要，如果缺少该文件，IDEA将无法识别项目，而且这些文件在不同的设备上的内容也会有所差异，所以在项目管理的时候，SpringBoot.iml文件需要忽略掉。

SpringBoot.iml文件名是根据项目名称自动生成的。

当你在 IntelliJ IDEA 中更新或更改一个项目时，该文件可能会被自动更新以反映最新的项目结构和依赖关系。

例如，如果你添加或删除了依赖项，或者移动了项目中的某些文件或目录，IntelliJ IDEA 可能会自动更新 springboot.iml 文件以反映这些更改。

但是，如果你手动更改了 springboot.iml 文件，它可能不会被 IntelliJ IDEA 自动识别或更新。在这种情况下，你可能需要手动同步该文件以保持其与项目的一致性。

总的来说，虽然 springboot.iml 文件可能随着项目的更新而自动更新，但最佳实践是不要直接编辑该文件，而是依赖于 IntelliJ IDEA 的智能感知和项目同步功能。如果你需要手动更改依赖项或项目结构，建议在 IntelliJ IDEA 的 UI 中进行操作，以确保 springboot.iml 文件得到正确的更新。

SpringBoot项目中的target文件夹是用来存放项目构建后的文件和目录、jar包、war包、编译的class文件，都是maven构建时生成的，不可以删除。

在Idea的SpringBoot项目中，如果target目录中没有同步更新目录文件和资源就会报错，需要删除target文件夹，然后maven会再次构建生成，这样就不会报错了。

删除target目录可以清理编译过程中产生的临时文件，避免提交不必要的构建产物到版本控制系统中。

关于SpringBoot谈谈你的理解：

一、自动装配：

1. SpringBoot 启动会加载大量的自动配置类

2. 我们看我们需要的功能有没有在 SpringBoot 默认写好的自动配置类当中

3. 我们再来看这个自动配置类中到底配置了哪些组件（只要我们要用的组件存在其中我们就不需要再手动配置了）

4. 给容器中自动配置类添加组件的时候会从 properties 类中获取某些属性我们只需要在配置文件中指定这些属性的值即可

xxxxAutoConfiguration：自动配置类给容器中添加组件

xxxxProperties：封装配置文件中相关属性

二、run()：

SpringApplication

这个类主要做了以下四件事情：

1.推断应用的类型是普通的项目还是 Web 项目

2.查找并加载所有可用初始化器设置到 initializers 属性中

3.找出所有的应用程序监听器设置到 listeners 属性中

4.推断并设置 main 方法的定义类找到运行的主类

装配机制

Spring框架的装配机制是指Spring容器如何组装（或“装配”）应用程序中的不同对象及其依赖关系的过程。这个过程是Spring依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IoC）原则的核心实现。

Spring依赖注入

Spring框架的依赖注入（Dependency Injection, DI）是一种实现控制反转（Inversion of Control, IoC）的技术，用于减少代码之间的耦合度。在传统的程序设计中，对象负责管理它们自己的依赖关系，这通常会导致代码之间的紧密耦合，使得修改和测试变得困难。依赖注入通过将对象的创建和依赖关系的管理交给外部容器（在Spring中是IoC容器）来处理，从而降低了组件之间的耦合度，并增加了代码的灵活性和可测试性。

Spring支持以下几种依赖注入的方式：

1.构造函数注入：通过类的构造函数来注入依赖。当创建一个对象时，Spring容器会通过调用一个带参数的构造函数，将依赖作为参数传递进去。

public class MyClass {
    private final MyDependency myDependency;

    public MyClass(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}

2.Setter方法注入：通过类的setter方法来注入依赖。Spring容器首先调用无参构造函数或无参静态工厂方法来创建对象，然后调用对象的setter方法来注入依赖。

public class MyClass {
    private MyDependency myDependency;

    public void setMyDependency(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}

3.字段注入：直接在类的字段上注入依赖。虽然这种方式简单，但不推荐使用，因为它违反了封装原则，且使得单元测试变得更加困难。

public class MyClass {
    @Autowired
    private MyDependency myDependency;
}

控制反转

控制反转（Inversion of Control, IoC）是一种设计原则，用于减少计算机代码之间的耦合度。在传统的程序设计中，代码的流程是由应用程序本身控制的，例如，一个模块直接创建和管理它依赖的对象。这种方式导致了高耦合和低灵活性，因为模块之间直接相互依赖，修改一个模块可能会影响到使用它的其它模块。

IoC原则提出了一种不同的方法：将对象的创建和管理交给外部容器处理，而不是由对象本身负责。这意味着对象的依赖关系不再由对象内部控制，而是由外部环境（即IoC容器）来控制，从而“反转”了控制流程。通过这种方式，模块之间的耦合度降低，增加了代码的灵活性和可测试性。

依赖注入（Dependency Injection, DI）是实现IoC的最常用方法。DI允许对象通过构造函数、setter方法或直接在字段上声明它们的依赖，然后由IoC容器在运行时自动注入这些依赖。这样，对象不需要知道如何创建它们的依赖，只需要声明需要哪些依赖即可。