Springboot学习-day16

Springboot是spring家族中的一个全新框架，用来简化spring程序的创建和开发过程。在以往我们通过SpringMVC+Spring+Mybatis框架进行开发的时候，我们需要配置web.xml，spring配置，mybatis配置，然后整合在一起，而springboot抛弃了繁琐的xml配置过程，采用大量默认的配置来简化我们的spring开发过程。

SpringBoot化繁为简，使开发变得更加的简单迅速。

1. Springboot项目搭建

1.1 maven下载和配置

下载maven的压缩包，并解压

在解压后的文件夹中，找到conf文件夹中的settings.xml文件配置本地库地址和配置国内镜像

<!-- 配置maven本地库的位置 -->
<localRepository>C:\maven\repository</localRepository>

<!-- 配置国内镜像源 -->
<mirror>  
		<id>alimaven</id>  
		<mirrorOf>central</mirrorOf>    
		<name>aliyun maven</name>  
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>        
</mirror>

1.2 pom.xml

在IDEA中创建maven项目

在IDEA的setting中修改maven的配置，将路径改为自己配置的maven路径以及setting.xml和本地库路径

在pom.xml文件中，添加springboot依赖

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

更新maven库，下载完成后可以在External Libraries中看到新添加的jar包

什么是POM？

pom是Project Object Model的缩写，即项目对象模型。pom.xml文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。

maven的基本字段含义

<project xmlns="http://maven.apache.org/POM/4.0.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.funtl</groupId>
    <artifactId>itoken-dependencies</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>
    <name>itoken dependencies</name>
    <url>www.funtl.com</url>
</project>

字段	说明
modelVersion	声明项目描述符遵循的哪一个POM模型版本。这是为了当Maven引入新的特性或者其他模型变更的时候，确保稳定性
groupId	公司或者组织的唯一标识，并且配置时生成的路径也是由此生成的。
artifactId	本项目唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的
version	本项目目前所处的版本号
packaging	打包类型，如pom，jar，rar等
name	项目的名称，Maven产生的文档用，可省略
url	项目主页的url，Maven产生文档用，可省略

其中groupId，artifactId，version，packaging这四项组成了项目的唯一坐标。一般情况下，前面三项就足矣。

依赖项中的字段含义

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

字段	说明
groupId	依赖项的组织名
artifactId	依赖项的子项目名
version	依赖项的版本

约定大于配置？

"约定大于配置"是一种设计理念，它在Spring Boot框架中有广泛的应用。这一理念的核心思想是，通过开发框架中定义一些默认的约定和规则，从而减少开发人员需要配置的工作，使开发更加高效，同时提高了项目的可维护性和可读性。

1.3 启动Springboot项目

创建项目启动类，名字一般为XXApplication

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//@SpringBootApplication 标识SpringBoot应用程序的入口类
@SpringBootApplication
public class EasySpringAApplication {
    //项目启动类  运行起该类就运行了整个项目
    public static void main(String[] args) {
        //SpringApplication.run(启动类的类对象, args);
        SpringApplication.run(EasySpringAApplication.class, args);
    }
}

启动成功如下图所示

可以看到上图中Started EasySpringAApplication in 1.082 seconds，这代表项目已经启动成功

Tomcat started on port(s): 8080 (http) with context path ''表示Tomcat已经在端口8080启动，并准备接受HTTP请求，with context path后是空串，表示应用是部署在根目录下的，访问http://localhost:8080即可访问

2. IoC

IoC（Inverse of Control：控制反转）是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。IoC 在其他语言中也有应用，并非 Spring 特有。IoC 容器是 Spring 用来实现 IoC 的载体，IoC 容器实际上就是个Map（key，value）,Map 中存放的是各种对象。

将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。 IoC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件xml/注解即可，完全不用考虑对象是如何被创建出来的。

优点

• 实现组件之间的解耦
• 提高程序的灵活性和可维护性

缺点

• 对程序员来说创建对象的步骤变复杂了，不直观
• 因为使用反射来创建对象，所以在效率上会有些损耗。但相对于程序的灵活性和可维护性来说，这点损耗是微不足道的。
• 缺少IDE重构的支持，如果修改了类名，还需到XML文件中手动修改。

3. DI

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。**依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。**通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

参考:http://t.csdnimg.cn/OP0ve

4. 常用注解

4.1 @SpringBootApplication

@SpringBootApplication注解通常被用于Spring Boot应用程序的入口类上，用于启动Spring Boot应用程序。它可以简化Spring应用程序的配置和启动过程。这是一个组合注解，包括了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解。

@SpringBootApplication
public class MyApplication {

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

4.2 @Component、@Repository、@Service、@Controller

@Component是最基本的注解，用于将一个普通的类标记为Spring的组件，是以下三个类的父注解

@Component
public class UserService {
    // 类的实现...
}

@Repository用于标记数据访问对象(DAO Date Access)，通常用于与数据库交互的类。

@Repository
public class UserRepositoryDao {
    // 数据访问的实现...
}

@Service用于标记服务类，通常用于业务逻辑处理和组装。

@Service
public class UserService {
    // 服务类的实现...
}

@Controller 用于标记控制器类，通常用于 Web 应用程序中处理用户请求和返回响应。

@Controller
public class UserController {
    // 控制器类的实现...
}

这些注解的作用类似，都是用来将类标记为 Spring 组件，使其被 Spring 容器扫描和管理。使用它们的好处是可以使代码更加清晰和易读，并在代码层面表示出组件的角色和职责。在使用时，根据类的具体功能和用途选择合适的注解来标记类。同时，这些注解也可以与其他注解结合使用，实现更复杂的功能和特性。

4.3 @Bean

@Bean 是 Spring Framework 中的一个注解，用于告诉 Spring 容器将被注解标记的方法的返回值作为一个 Bean 注册到容器中。

通常情况下，我们需要在 Spring 容器中创建和管理对象。通过 @Bean 注解，我们可以自定义方法来返回或创建这些对象，并将它们注册为 Spring 的 Bean，使得它们可以在其他地方进行依赖注入、使用和管理。

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

在上述示例中，@Bean 注解标记了 userService() 方法，该方法返回一个 UserService 对象。当 Spring 容器初始化时，会调用 userService() 方法，并将其返回的对象注册为一个 Bean。这样，在其他需要使用 UserService 的地方，可以通过依赖注入的方式获取该 Bean 的实例，并使用它提供的服务。

除了简单的方法返回对象，@Bean 注解还支持更复杂的配置：

• 可以通过 name 属性指定 Bean 的名称，例如 @Bean(name = “myBean”)。
• 可以通过 initMethod 属性指定在实例化 Bean 之后调用的初始化方法，例如 @Bean(initMethod = “init”)。
• 可以通过 destroyMethod 属性指定在销毁 Bean 之前调用的销毁方法，例如 @Bean(destroyMethod = “cleanup”)。
• 可以通过 @Scope 注解指定 Bean 的作用域，如单例(@Scope(“singleton”))、原型(@Scope(“prototype”))等。

4.4 @Scope

@Scope在和@Component注解一起修饰在类上，作为类级别注解时，@Scope表示该类实例的范围

在和@Bean一起修饰在方法上，作为方法级别注解时，@Scope表示该方法返回的实例的范围。

@Component
@Scope("prototype")
public class MyService {
    // 类的实现...
}

在上述示例中，MyService 类被标记为一个组件，并使用 @Scope("prototype") 注解将该组件的作用域设置为原型模式，每次通过容器获取 MyService 的实例时都会创建一个新的对象。

4.5 @Autowired

通过@Autowired注解，我们可以自动将 Spring 容器中匹配类型的 Bean 注入到目标对象中，避免了手动处理依赖对象的创建和管理，提高了代码的可维护性和可测试性。

@RestController
public class EasyController {
    //该类中需要EasyService类的对象
    //在这个类中只需要声明我们依赖EasyService这个类就可以
    //而不需要通过代码主动获取EasyService类的对象
    //注入依赖 DI  通过识别依赖关系，注入对应的对象
    @Autowired
    EasyService easyS;
}

4.6 @RequestMapping

@RequestMapping 是 Spring Framework 中的一个注解，用于映射请求的 URL 路径到控制器类或方法上。

通过 @RequestMapping 注解，我们可以定义控制器类或方法处理的请求 URL，以及与之关联的 HTTP 请求方法、请求参数、请求头等条件。

@RestController
public class EasyController {
    @Autowired
    TestA testA;

    @RequestMapping("testB")
    public String testB(){
        testA.test();
        return "EasyB method";
    }
}

参考：https://blog.csdn.net/weixin_55772633/article/details/131882825

5. Bean的作用域

bean的作用域就是指Spring给我们创建出的对象的存活范围，在配置文件中通过bean的scope属性指定

scope：对象的作用范围，取值如下

取值范围	说明
singleton	默认值，单例模式，只会创建一个对象
prototype	原型模式，每次需要时都会创建一个新对象
request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

当scope取值为singleton时，Bean的实例化个数只有一个，当Spring核心文件加载时，就会实例化配置的Bean实例

当scope取值为prototype时，Bean的实例化个数就为多个，当调用getBean()方法时，就会实例化Bean类

当scope取值为request时，会在每次http请求中生成一个新的Bean实例类，类似于prototype，应用场景：一次http请求和响应共享Bean

当scope取值为session时，会在http session中定义一个Bean实例，场景用户会话中共享Bean，例如可以用来记录一个用户的登录信息

6. Bean的生命周期

Bean 生命周期管理是 Spring Boot 中的关键功能之一。它负责管理应用程序中的 Java 对象，这些对象被称为 Beans。Spring Boot 通过创建、配置、初始化和销毁这些 Beans 来确保应用程序的正常运行。这个功能的目的是提供一种灵活的方式，使开发人员能够轻松地管理对象的生命周期，从而实现高效的依赖注入和组件化开发。

1. 实例化: 在Spring容器启动时，Spring会创建配置中定义的所有Bean。这是通过类的构造方法或工厂方法来完成的

   //@Component("easybean")
   public class EasyBean{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   }
   

2. 属性注入: 一旦Bean被实例化，Spring会注入所有相关的属性，包括通过构造方法或Setter方法注入的属性

   //@Component("easybean")
   public class EasyBean{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   }
   

3. 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

   //@Component("easybean")
   public class EasyBean implements BeanNameAware{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   
       @Override
       public void setBeanName(String s) {
           System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
       }
   }
   

4. 如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

   //@Component("easybean")
   public class EasyBean implements BeanNameAware, BeanFactoryAware{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   
       @Override
       public void setBeanName(String s) {
           System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
       }
   
       @Override
       public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           System.out.println("4------BeanFactoryAware的setBeanFactory方法" + beanFactory);
       }
   }
   

5. 当一个 Bean 实现了 ApplicationContextAware 接口并在 Spring 容器中被实例化时，Spring 容器会自动调用该 Bean 的 setApplicationContext 方法，并将应用程序上下文ApplicationContext作为参数传递进来

   //@Component("easybean")
   public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   
       @Override
       public void setBeanName(String s) {
           System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
       }
   
       @Override
       public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           System.out.println("4------BeanFactoryAware的setBeanFactory方法" + beanFactory);
       }
   
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           System.out.println("5------ApplicationContextAware接口的setApplicationContext方法");
       }
   }
   

6. BeanPostProcessor 是 Spring 框架中的一个重要接口，它允许开发者在 Spring 容器创建和初始化 bean 的过程中，对 bean 进行自定义处理。这包括在 bean 实例化之后、属性设置之前（postProcessBeforeInitialization 方法），以及在 bean 初始化之后（postProcessAfterInitialization 方法）执行自定义逻辑

   Spring 容器在创建和初始化每一个 bean 时，都会调用 CustomBeanPostProcessor 中的这两个方法，允许你进行自定义处理

   初始化之前执行postProcessBeforeInitialization方法，初始化之后执行postProcessAfterInitialization方法

   @Component
   public class EasyBeanPost implements BeanPostProcessor {
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
           if(beanName.equals("easyBean")) System.out.println("6------BeanPostProcessor的before方法" + beanName);
           return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
       }
   }
   

7. InitializingBean 是 Spring 框架中的一个接口，它定义了一个 afterPropertiesSet 方法。当 Spring 容器创建 bean 的所有属性都被设置完成后，会调用这个方法。

   //@Component("easybean")
   public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   
       @Override
       public void setBeanName(String s) {
           System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
       }
   
       @Override
       public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           System.out.println("4------BeanFactoryAware的setBeanFactory方法" + beanFactory);
       }
   
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           System.out.println("5------ApplicationContextAware接口的setApplicationContext方法");
       }
   
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("7-----InitializingBean接口的afterPropertiesSet方法");
       }
   }
   

8. 如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

   //@Component("easybean")
   public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean{
       public EasyBean(){
           System.out.println("1------EasyBean构造方法");
       }
   
       TestA testA;
   
       @Autowired
       public void setTestA(TestA testA){
           System.out.println("2------注入属性");
           this.testA = testA;
       }
   
       @Override
       public void setBeanName(String s) {
           System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
       }
   
       @Override
       public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           System.out.println("4------BeanFactoryAware的setBeanFactory方法" + beanFactory);
       }
   
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           System.out.println("5------ApplicationContextAware接口的setApplicationContext方法");
       }
   
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("7-----InitializingBean接口的afterPropertiesSet方法");
       }
   
       public void initMethod(){
           System.out.println("8------initMethod方法");
       }
   }
   

   @Configuration
   public class EastConfiguration {
       @Bean(initMethod = "initMethod")
       public EasyBean easyBean(){
           return new EasyBean();
       }
   }
   

9. 如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

   @Component
   public class EasyBeanPost implements BeanPostProcessor {
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
           if(beanName.equals("easyBean")) System.out.println("6------BeanPostProcessor的before方法" + beanName);
           return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
       }
   
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
           if(beanName.equals("easyBean")) System.out.println("9------BeanPostProcessor的after方法");
           return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
       }
   }
   

10. 如果在 <bean> 中指定了该 Bean 的作用范围为 scope=“singleton”，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope=“prototype”，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。

    @Configuration
    public class EastConfiguration {
        @Bean(initMethod = "initMethod")
        //@Scope("prototype")
        public EasyBean easyBean(){
            return new EasyBean();
        }
    }
    

11. 如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

    EasyBean类

    //@Component("easybean")
    public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
        public EasyBean(){
            System.out.println("1------EasyBean构造方法");
        }
    
        TestA testA;
    
        @Autowired
        public void setTestA(TestA testA){
            System.out.println("2------注入属性");
            this.testA = testA;
        }
    
        @Override
        public void setBeanName(String s) {
            System.out.println("3------BeanNameAware接口的setBeanName方法" + s);
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("4------BeanFactoryAware的setBeanFactory方法" + beanFactory);
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            System.out.println("5------ApplicationContextAware接口的setApplicationContext方法");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("7-----InitializingBean接口的afterPropertiesSet方法");
        }
    
        public void initMethod(){
            System.out.println("8------initMethod方法");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("10------easyBean被回收了");
        }
    }
    

    EasyBeanPost类

    @Component
    public class EasyBeanPost implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if(beanName.equals("easyBean")) System.out.println("6------BeanPostProcessor的before方法" + beanName);
            return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if(beanName.equals("easyBean")) System.out.println("9------BeanPostProcessor的after方法");
            return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
        }
    }
    

    EasyConfiguration类

    @Configuration
    public class EastConfiguration {
        @Bean(initMethod = "initMethod")
        //@Scope("prototype")
        public EasyBean easyBean(){
            return new EasyBean();
        }
    }
    

    执行结果如下图所示