spring boot

Posted 2021-12-21 jialanshun

一  Spring Boot的一些概念

      1.  Spring Boot是什么？

                    它是一种以更简单的方式来使用Spring生态下所有技术的框架，用于简化Spring项目的

                 构建、开发、配置、部署与jar报引用。简而言之，我们可以说Spring Boot只是Spring本身

                 的扩展，使开发，测试和部署更加方便。这样也就明白了SpringBoot和Spring Cloud的区别。

                 也有的地方是这样讲的：Spring boot 是 Spring 的一套快速配置脚手架（Spring Boot，看名

                 字就知道是Spring的引导）

         2.  Spring Boot与Spring、Spring Boot与Spring Cloud的区别？

                 （1）Spriing Boot和Spring   

                                 SpringBoot是Spring的扩展，它解决了Spring的三大痛点问题。  

                                 Spring的三大痛点问题（以启动一个带Hibernate的Spring MVC为例）：

                                 --  依赖太多了，而且要注意版本兼容。这个应用，要添加10-20个依赖，Spring相

                                     关的包10多个，然后是Hibernate包，Spring与Hibernate整合包，日志包，json

                                     包一堆，而且要注意版本兼容性。

                                 --  配置太多了，要配置注解驱动，要配置数据库连接池，要配置Hibernate，要配

                                     置事务管理器，要配置Spring MVC的资源映射，要在web.xml中配置启动Spring

                                     和pring MVC等

                                 --  部署和运行麻烦。要部署到tomcat里面。不能直接用java命令运行。太多重复和

                                     大家都一样的配置了。

                                 Spring Boot正好解决了上述问题，其哲学思想是约定大于配置。既然很多东西都是

                                 一样的，为什么还要去配置。

                                 --  通过starter（starter是启动依赖机制，start是指在pom中导入少量依赖缺可以在

                                      工程中自动引入大量依赖）和依赖管理解决依赖问题。

                                 --  通过自动配置，解决配置复杂问题。

                                 --  通过内嵌web容器，由应用启动tomcat，而不是tomcat启动应用，来解决部署运

                                     行问题

                                 Spring Boot和Spring的之间的详细关系可以查看文章：

                                  https://www.jianshu.com/p/ffe5ebe17c3a                 

 

                                 Spring Boot和Spring Cloud的区别：

                                 --  Spring Cloud是微服务框架，微服务体系开发中的架构问题，提供了一整套的解

                                     决方案；

                                 --  Spring Boot是Spring框架的扩展可以基于spring boot 快速开发单个微服务。它是

                                      为了解决Spring中的一些痛点而产生的

         3.  Spring Boot工程目录介绍

                   

 

                    别的不说，都会，这里只介绍static和templates

                    static：存放静态资源文件

                    templates：存放动态资源文件

                           

          2.Spring Boot的四大核心机制

            （1）起步依赖机制

                      通过起步依赖机制（starter），简化jar包的引用，解决jar版本冲突问题

                             SpringBoot起步依赖机制主要用来简化jar包的依赖，并通过大量的测试，解决了不同

                      jar之间的版本冲突问题。使得开发人员只需要关注代码的实现，而不必在jar包依赖上花费

                      过多心思。

                             Spring Boot通过启动依赖机制为我们引入了大量的依赖，如果我们不需要某个jar包，

                      我们可以通过<exclusion></exclusion>进行屏蔽

在Maven中，可以使用<exclusions>:
<dependency>
　　<groupId>org.springframework.boot</groupId>
　　<artifactId>spring-boot-starter-web</artifactId>
　　<exclusions>
　　　　<exclusion>
　　　　　　<groupId>com.fasterxml.jackson.core</groupId>
　　　　　　<artifactId>*</artifactId>
　　　　</exclusion>
　　</exclusions>
</dependency>

                      自定义要使用jar包的版本，而不使用启动依赖机制中的jar包

 

 

            （2）自动配置

                            自动配置是指可以实现简单配置，甚至是零配置（比如我搭建一个Spring Boot项目，

                     什么都不配，就可以启动，这就是零配置），就能搭建整套框架，它尽量减少开发人员对

                     配置的编写。

                            注：并不代表Spring Boot可以零配置哈。

                    这里补充一些知识：

                  （a）Spring 获取bean的几种方式

                           --  读取xml文件的方式，这种在初学入门的时候比较适用

             ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:tt.xml");

　　　　      ApplicationContext applicationContext = new FileSystemXmlApplicationContext("classpath:tt.xml");

                           --  继承spring的Aware类，覆盖方法实现获取上下文，从上下文中获取。

　　                        *  继承自抽象类ApplicationObjectSupport

                                  抽象类ApplicationObjectSupport提供getApplicationContext()方法，可以方便的获

                                  取到ApplicationContext。Spring初始化时，会通过该抽象类的

                                  setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象

                                  注入。

                               *  继承自抽象类WebApplicationObjectSupport

                                   类似上面方法，调用getWebApplicationContext()获取WebApplicationContext

                               *  实现接口ApplicationContextAware

　　　　　                当一个类实现了这个接口之后，这个类就可以方便地获得 ApplicationContext 中的

                                  所有bean。换句话说，就是这个类可以直接获取Spring配置文件中，所有有引用到

                                  的bean对象。

                                  使用例子：

                                         第一步，定义一个工具类，实现 ApplicationContextAware，实现

                                                       setApplicationContext方法

                   public class SpringContextUtils implements ApplicationContextAware

                   private static ApplicationContext context;

                   @Override

                   public void setApplicationContext(ApplicationContext context)

                   throws BeansException

                          SpringContextUtils.context = context;

                   

                   public static ApplicationContext getContext()

                          return context;

                 
             

 

                                         

                                                       如此一来，我们就可以通过该工具类，来获得 ApplicationContext，进

                                                       而使用其getBean方法来获取我们需要的bean。

                                         第二步，在Spring配置文件中注册该工具类

                                                        之所以我们能如此方便地使用该工具类来获取，正是因为Spring能够

                                                        为我们自动地执行 setApplicationContext 方法，显然，这也是因为

                                                        IOC的缘故，所以必然这个工具类也是需要在Spring的配置文件中进行

                                                        配置的。

                         <!--Spring中bean获取的工具类-->                         <bean id="springContextUtils" class="com.zker.common.util.SpringContextUtils" />

 

                                         第三步，编写方法进行使用

                                                       一切就绪，我们就可以在需要使用的地方调用该方法来获取bean了。

   /**

     * 利用Ajax实现注册的用户名重复性校验

     * @return

     */

    public String ajaxRegister() throws IOException 

        UserDao userDao = (UserDao)SpringContextUtils.getContext().getBean("userDao");

        if (userDao.findAdminByLoginName(loginName) != null

                || userDao.findUserByLoginName(loginName) != null) 

            message.setMsg("用户名已存在");

            message.setStatus(false);

         else 

            message.setMsg("用户名可以注册");

            message.setStatus(true);

        


        return "register";

    

 

                           --  借助于spring提供的工具类   

                               这种方式适合于采用Spring框架的B/S系统，通过ServletContext对象获取

                               ApplicationContext对象，然后在通过它获取需要的类实例。 下面两个工具方式的区别

                               是，前者在获取失败时抛出异常，后者返回null。

import org.springframework.web.context.support.WebApplicationContextUtils; 
ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc) 
ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc) 
ac1.getBean("beanId"); 
ac2.getBean("beanId"); 

 

                  （b）一些注解                    

                           --  @Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个

                               或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或

                               AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化

                               Spring容器。@Configuration可理解为用spring的时候xml里面的<beans>标签；

                               @Bean可理解为用spring的时候xml里面的<bean>标签

                               AnnotationConfigWebApplicationContext：使用AnnotationConfigApplicationContext

                              可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配

                              置。位于spring-context.jar；AnnotationConfigEmbeddedWebApplicationContext是

                              spring boot中的WebApplicationContext。

                              WebApplicationContext

                                            WebApplicationContext是专门为web应用准备的，他允许从相对于web根目录

                                     的路劲中装载配置文件完成初始化工作，从WebApplicationContext中可以获得

                                     ServletContext的引用，整个Web应用上下文对象将作为属性放置在ServletContext

                                     中，以便web应用可以访问spring上下文,spring中提供WebApplicationContextUtils

                                     的。

                                            在以前的spring项目中，会有两个WebApplicationContext，一个是parent，从

                                     applicationContext.xml里加载的，一个是child，从servlet-context.xml里加载的。两

                                     者是继承关系，child WebApplicationContext 可以通过getParent()函数获取到

                                     root WebApplicationContext。也就是说，我们常常通过listener初始化parent，并

                                     component-scan扫描非controller类。而通过servlet初始化child，只扫描controller类。

                                     这样便于在child可注入parent中的bean，反之就不行（自己感觉这就是父子容器）。

                           --  @ConfigurationProperties("xxx") 注解

                                      加上该注解后,就会注入在application.properties中xxx开头的属性。

                                      示例：

                                       Person.java

@Component
@ConfigurationProperties(prefix="person")
public class Person 

    private String name;
    private int age;
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
    public int getAge() 
        return age;
    
    public void setAge(int age) 
        this.age = age;
    
    

 

                                       application.properties

person.name=Five
person.age=20

 

 

                                       此时Person.java中的name和age的值分别被注入Five和age

                                       测试Controller     

package ai.yunxi.springBootDemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController 

    @Autowired
    private JdbcTemplate template;
    
    @Autowired
    private Person person;
    
    @RequestMapping("/sayHello")
    public String sayHello()
        System.out.println("template:"+template);
        return "Hello "+person.getName()+"!";
    

 

                           --  @ConditionalOnClass：据说后面会讲到

@ConditionalOnBean（仅仅在当前上下文中存在某个对象时，才会实例化一个Bean）
@ConditionalOnClass（某个class位于类路径上，才会实例化一个Bean）
@ConditionalOnExpression（当表达式为true的时候，才会实例化一个Bean）
@ConditionalOnMissingBean（仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean）
@ConditionalOnMissingClass（某个class类路径上不存在的时候，才会实例化一个Bean）
@ConditionalOnNotWebApplication（不是web应用）

            （3）Spring Boot CLI

                     一种命令行工具。

                     --  可以构建SpringBoot项目，其实还是通过https://start.spring.io/去构建工程的

                         例：spring init --dependencies=web,mysql,jdbc bootProject

                     --  可以执行Groovy脚本（spring run命令）

                         例：spring run hello.groovy

                     --  例：spring jar bootProject.jar *.groovy

            （4）Actuator

                            是Spring Boot程序的监控器（暴露端口），可以监控应用程序上下文中的bean、查看自

                     动配置决策、Controller映射、线程活动、应用程序监控状况等。

二  Spring Boot框架构建的四种方式

          1.  Spring Tool Suite

          2.  SpringBoot CLI

          3.  Spring Initializr

          4.  手动引用jar包

三  @RestController 定义一个Controller为RestController，RestController响应的是字符串而不是视图