吃透SpringBoo的这些t知识，你就已经超过90%的Java面试者了

偏执的太偏执、 2023-09-29 16:31 8阅读 0赞

### 前言 ###

做 Java 开发，没有人敢小觑 Spring Boot 的重要性，现在出去面试，无论多小的公司 or 项目，都要跟你扯一扯 Spring Boot，扯一扯微服务，如果啃不下来，很可能就与大厂失之交臂。

精通Spring Boot的原理实现的话，可以帮助你更好地职业进阶，学习前辈优秀的架构设计思想，总结出最优使用方案，绕过工作中遇到的很多坑。

## SpringBoot ##

## 第一章 JavaConfig ##

1.  为什么要使用 Spring Boot
    
    因为Spring， SpringMVC 需要使用的大量的配置文件 （xml文件）
    
    还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象
    
    需要了解其他框架配置规则。
2.  SpringBoot 就相当于 不需要配置文件的Spring+SpringMVC。 常用的框架和第三方库都已经配置好了。
    
    拿来就可以使用了。
3.  SpringBoot开发效率高，使用方便多了

### 1.1 JavaConfig ###

JavaConfig: 使用java类作为xml配置文件的替代， 是配置spring容器的纯java的方式。 在这个java类这可以创建java对象，把对象放入spring容器中（注入到容器），

使用两个注解：

1）@Configuration ： 放在一个类的上面，表示这个类是作为配置文件使用的。

2）@Bean：声明对象，把对象注入到容器中。

例子：
    package comfig;
    
    import com.bjpowernode.vo.Student;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * Configuration:表示当前类是作为配置文件使用的。 就是用来配置容器的
     *       位置：在类的上面
     *
     *  SpringConfig这个类就相当于beans.xml
     */
    @Configuration
    public class SpringConfig {
    
        /**
         * 创建方法，方法的返回值是对象。 在方法的上面加入@Bean
         * 方法的返回值对象就注入到容器中。
         *
         * @Bean: 把对象注入到spring容器中。 作用相当于<bean>
         *
         *     位置：方法的上面
         *
         *     说明：@Bean,不指定对象的名称，默认是方法名是 id
         *
         */
        @Bean
        public Student createStudent(){
            Student s1  = new Student();
            s1.setName("张三");
            s1.setAge(26);
            s1.setSex("男");
            return s1;
        }
    
    
        /***
         * 指定对象在容器中的名称（指定<bean>的id属性）
         * @Bean的name属性，指定对象的名称（id）
         */
        @Bean(name = "lisiStudent")
        public Student makeStudent(){
            Student s2  = new Student();
            s2.setName("李四");
            s2.setAge(22);
            s2.setSex("男");
            return s2;
        }
    }

### 1.2 @ImporResource ###

@ImportResource 作用导入其他的xml配置文件， 等于 在xml

例如：

@Configuration
    @ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
    public class SpringConfig {
    }

### 1.3 @PropertyResource ###

@PropertyResource: 读取properties属性配置文件。 使用属性配置文件可以实现外部化配置 ，

在程序代码之外提供数据。

步骤：

1.  在resources目录下，创建properties文件， 使用k=v的格式提供数据
2.  在PropertyResource 指定properties文件的位置
3.  使用@Value（value="$\{key\}"）

@Configuration
    @ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
    @PropertySource(value = "classpath:config.properties")
    @ComponentScan(basePackages = "com.bjpowernode.vo")
    public class SpringConfig {
    }

## 第二 章 Spring Boot ##

### 2.1 介绍 ###

SpringBoot是Spring中的一个成员， 可以简化Spring，SpringMVC的使用。 他的核心还是IOC容器。

特点：

*  Create stand-alone Spring applications
    
    创建spring应用
 *  Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
    
    内嵌的tomcat， jetty ， Undertow
 *  Provide opinionated 'starter' dependencies to simplify your build configuration
    
    提供了starter起步依赖，简化应用的配置。
    
    比如使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象
    
    在SpringBoot项目中，在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖
 *  Automatically configure Spring and 3rd party libraries whenever possible
    
    尽可能去配置spring和第三方库。叫做自动配置（就是把spring中的，第三方库中的对象都创建好，放到容器中， 开发人员可以直接使用）
 *  Provide production-ready features such as metrics, health checks, and externalized configuration
    
    提供了健康检查， 统计，外部化配置
 *  Absolutely no code generation and no requirement for XML configuration
    
    不用生成代码， 不用使用xml，做配置

### 2.2 创建Spring Boot项目 ###

#### 2.2.1 第一种方式， 使用Spring提供的初始化器， 就是向导创建SpringBoot应用 ####

使用的地址： [https://start.spring.io][https_start.spring.io]

SpringBoot项目的结构：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-obbEjRya-1645601371946)(D:\\course\\25-SpringBoot\\笔记\\images\\image-20210115152427829.png)\]

#### 2.2.1 使用国内的地址 ####

[https://start.springboot.io][https_start.springboot.io]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WUQwGegr-1645601371948)(D:\\course\\25-SpringBoot\\笔记\\images\\image-20210115155556662.png)\]

### 2.3 注解的使用 ###

@SpringBootApplication
    符合注解：由
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan
        
        
    1.@SpringBootConfiguration
        
    @Configuration
    public @interface SpringBootConfiguration {
        @AliasFor(
            annotation = Configuration.class
        )
        boolean proxyBeanMethods() default true;
    }
    
    说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用的，
        可以使用Bean声明对象，注入到容器

2.@EnableAutoConfiguration

启用自动配置， 把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中

3.@ComponentScan

@ComponentScan 扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。
    默认扫描的包： @ComponentScan所在的类所在的包和子包。

### 2.4 SpringBoot的配置文件 ###

配置文件名称： application

扩展名有： properties( k=v) ; yml ( k: v)

使用application.properties, application.yml

例1：application.properties设置 端口和上下文

#设置端口号
    server.port=8082
    #设置访问应用上下文路径， contextpath
    server.servlet.context-path=/myboot

例2： application.yml

server:
      port: 8083
      servlet:
        context-path: /myboot2

### 2.5 多环境配置 ###

有开发环境， 测试环境， 上线的环境。

每个环境有不同的配置信息， 例如端口， 上下文件， 数据库url，用户名，密码等等

使用多环境配置文件，可以方便的切换不同的配置。

使用方式： 创建多个配置文件， 名称规则： application-环境名称.properties(yml)

创建开发环境的配置文件： application-dev.properties( application-dev.yml )

创建测试者使用的配置： application-test.properties

### 2.6 @ConfigurationProperties ###

@ConfigurationProperties: 把配置文件的数据映射为java对象。

属性：prefix 配置文件中的某些key的开头的内容。

@Component
    @ConfigurationProperties(prefix = "school")
    public class SchoolInfo {
    
        private String name;
    
        private String website;
    
        private String address;
    
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getWebsite() {
            return website;
        }
    
        public void setWebsite(String website) {
            this.website = website;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "SchoolInfo{" +
                    "name='" + name + '\'' +
                    ", website='" + website + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

application.properties

#配置端口号
    server.port=8082
    #context-path
    server.servlet.context-path=/myboot
    
    #自定义key=value
    school.name=动力节点
    school.website=www
    school.address=北京的大兴区
    
    site=www

### 2.7 使用jsp ###

SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp

使用jsp需要配置：

1） 加入一个处理jsp的依赖。 负责编译jsp文件

<dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>

1.  如果需要使用servlet， jsp，jstl的功能

<dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>jstl</artifactId>
    </dependency>
    
    <dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>javax.servlet-api</artifactId>
    </dependency>
    
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    	<artifactId>javax.servlet.jsp-api</artifactId>
    	<version>2.3.1</version>
    </dependency>

1.  创建一个存放jsp的目录，一般叫做webapp

index.jsp

1.  需要在pom.xml指定jsp文件编译后的存放目录。

META-INF/resources

5）创建Controller， 访问jsp

6）在application.propertis文件中配置视图解析器

### 2.8 使用容器 ###

你想通过代码，从容器中获取对象。

通过SpringApplication.run(Application.class, args); 返回值获取容器。

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
            return run(new Class[]{primarySource}, args);
    }
    
    ConfigurableApplicationContext : 接口，是ApplicationContext的子接口
    public interface ConfigurableApplicationContext extends ApplicationContext

### 2.9 ComnandLineRunner 接口 ， ApplcationRunner接口 ###

这两个接口都 有一个run方法。 执行时间在容器对象创建好后， 自动执行run（）方法。

可以完成自定义的在容器对象创建好的一些操作。

@FunctionalInterface
    public interface CommandLineRunner {
        void run(String... args) throws Exception;
    }
    
    @FunctionalInterface
    public interface ApplicationRunner {
        void run(ApplicationArguments args) throws Exception;
    }

## 第三章 Web组件 ##

讲三个内容： 拦截器， Servlet ，Filter

### 3.1 拦截器 ###

拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。

拦截器框架中有系统的拦截器， 还可以自定义拦截器。 实现对请求预先处理。

实现自定义拦截器：

1.  创建类实现SpringMVC框架的HandlerInterceptor接口

public interface HandlerInterceptor \{  
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception \{  
return true;  
\}

default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }

2.需在SpringMVC的

[https_start.spring.io]: https://start.spring.io/
[https_start.springboot.io]: https://start.springboot.io/