SpringBoot面试题

最新推荐文章于 2024-05-13 15:49:11 发布

前端交互仔

最新推荐文章于 2024-05-13 15:49:11 发布

阅读量1.1k

点赞数

分类专栏：程序员面试刷题

原文链接：https://www.cnblogs.com/lenve/p/10728897.html

版权

程序员面试刷题专栏收录该内容

26 篇文章 1 订阅

订阅专栏

1.简单介绍一下Spring?有啥缺点？

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。
1.目的：解决企业应用开发的复杂性
2.功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
3.范围：任何Java应用
Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架
1.什么是Spring?

Spring是一个分层的JavaSE/EE full-stack(一站式)轻量级开源框架.
Spring为不同的层都提供的企业级解决方案:
web层:spring mvc
service层:spring
dao层:JDBCTemplate、Spring data jpa(Java Persistence API)
Spring的核心思想是IOC(控制反转)和AOP(面向切面编程)
2.为什么要用Spring?

1.方便解耦,简化开发(高内聚低耦合)
Spring就是一个大工厂(容器),用于创建对象(bean)和维护对象间的依赖关系.
2.AOP编程的支持
Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能.
声明式事务的支持,只需要通过配置就可以完成对事务的管理,而且无需手动编程.
3.方便程序的测试
Spring对Junit4支持,可以通过注解方便的测试Spring程序.
4.方便集成各种的优秀框架
5.降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API,都提供了封装,使用这些API应用难度大大降低.
3.Spring的优点

1.降低了组件之间的耦合性,实现了软件各层之间的解耦.
2.可以使用容器提供的众多服务,如事务管理,消息服务等.
3.容器提供单利模式支持.
4.容器提供了AOP技术,利用它可以很容易实现的一些拦截,如权限拦截,运行期监控等.
5.容器提供了AOP技术,利用它可以很容易实现运行拦截,如权限拦截,运行期监控等.
6.spring对于主流的应用框架提供了很好的支持,例如mybatis等.
7.spring属于低入侵设计
8.独立各种应用服务器
9.spring的DI机制减低了业务对象替换的复杂性.
10.spring的高开放性,并不强制应用于完全依赖于它,开发者可以自由选择spring的部分或者全部.
4.Spring的缺点

使用了大量的反射机制，反射机制非常占用内存。
转自：https://blog.csdn.net/Strangerrainyday/article/details/108194912

1、Spring

Spring是一个开源容器框架，可以接管web层，业务层，dao层，持久层的组件，并且可以配置各种bean,和维护bean与bean之间的关系。其核心就是控制反转(IOC),和面向切面(AOP),简单的说就是一个分层的轻量级开源框架。

2、SpringMVC

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。SpringMVC是一种web层mvc框架，用于替代servlet（处理|响应请求，获取表单参数，表单校验等。SpringMVC是一个MVC的开源框架，SpringMVC=struts2+spring，springMVC就相当于是Struts2加上Spring的整合。

从名字上就可以窥探出，Spring>SpringMVC，那么事实上，spring和SpringMVC是一种父子关系。SpringMVC是spring扩展出的一个应用于web端的框架。在这里需要注意的一点，就是到底什么是父子容器关系：

spring主要的作用是黏合其他模块组件，进行统一管理，springmvc则主要是负责web端。那么，我们都知道，我们在应用spring的时候，可以使用注入。这个时候，如果我们的web端是用的SpringMVC，这个时候，controller理论上是通过SpringMVC去注入，但是，使用spring注入，同样是可行的。同理，service等层，使用SpringMVC配置的统一扫描装配也是可以的。所以，如果说只是为了使用spring的依赖注入，是大可不必将springMVC和spring同时使用的。他们完全可以分开！

但是，尽管SpringMVC和spring都可以进行自动装配扫描，值得注意的是：

spring（父容器）并不能直接访问SpringMVC（子容器）所注入的对象，但是SpringMVC却可以访问到spring装载的对象。所以，在配置自动装配的时候，应该注意到这一点。

一句话，使用springmvc必须集成spring，使用spring可以不使用springmvc

在这里插入图片描述 ### 2.为什么要有SpringBoot?

任何先进技术的产生都不是凭空出现的，SpringBoot 也不例外，SpringBoot 是基于Spring 的基础上产生的。总所周知，Spring 是一个轻量级的容器，在Java EE 项目中得到广泛使用，但是Spring复杂、繁琐和臃肿的XML配置方式配置使得开发人员在实际使用过程中变得非常痛苦，尤其是与其他第三方工具进行整合时，比如Mybatis等就更会使得配置文件变得异常复杂和重复。

在这里插入图片描述

在没有 Spring Boot 之前，我们要搭建一个 Web 项目，通常要这么做：

1）配置 web.xml，加载 Spring 和 SpringMVC

2）配置数据库链接、配置 Spring 事务

3）配置日志文件

4）部署 Tomcat 运行 Web 项目

上图是一段配置数据库以及事务管理和Mybatis 的配置，我们发现仅仅是配置文件就非常的多，当然这还不是最复杂的。在这种基础上，SpringBoot 诞生了。

SpringBoot 的出现给开发者带来了新的自动化配置解决方案，使得开发者能够基于 SpringBoot 快速创建基于 Spring 生产级的独立应用程序， SpringBoot 中对一些常用的第三方库提供了默认的自动化配置方案，使得开发者只需要很少的 Spring 配置就能运行完整的 JavaEE 应用。由于其拥有了开箱即用的特性以及服务监控方案同时自带web服务器且与Spring的另一个主流的Spring Cloud 等服务治理框架以及kubernetes 等技术的融合使得开发人员可以快速的实现微服务以及服务的治理、熔断等，最重要的是你可以完全不需要配置XML，真的是太爽了。

在这里插入图片描述其中ComponentScan 会扫描@Service、@Repository、@Component、@Controller、@RestController以及带@Configuration 注解的类，但是我们为了更方便，通常都是直接在入口加上@SpringBootApplication。

转自:https://blog.csdn.net/csdnsevenn/article/details/105671513

SpringBoot的注解

在这里插入图片描述转自:https://www.php.cn/faq/417146.html

3.什么是SpringBoot Starters?

SpringBoot的一大优势就是Starter，由于SpringBoot有很多开箱即用的Starter依赖，使得我们开发变得简单，我们不需要过多的关注框架的配置。

转自： https://zhuanlan.zhihu.com/p/64309456

4.SpringBoot支持哪些内嵌Servlet容器？

Spring Boot支持Tomcat、Jetty和Undertow三种Servlet容器嵌入到Web应用程序中，开发者使用starter即可方便嵌入，默认情况下，嵌入服务器的访问端口为8080。

5.如何在SpringBoot应用程序中使用Jetty而不是Tomcat?

将默认的tomcat替换成jetty，打开pom.xml文件，然后修改为

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<exclusions>

<exclusion>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-tomcat</artifactId>

</exclusion>

</exclusions>

</dependency>

然后添加jetty依赖

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jetty</artifactId>

</dependency>

修改pom.xml文件之后，刷新maven重现加载，然后查看依赖文件，现在可以看到，之前的tomcat依赖文件没有了，变成了jetty文件

转自：https://jingyan.baidu.com/article/4b52d702dd3278fc5c774b2a.html

6.介绍一下@SpringBootApplication注解

@SpringBootApplication的作用等价于同时组合使用@EnableAutoConfiguration，@ComponentScan，@SpringBootConfiguration．

7.SpringBoot的自动配置是如何实现的

每次问到 Spring Boot，面试官非常喜欢问这个问题：“讲述一下 SpringBoot 自动装配原理？”。

我觉得我们可以从以下几个方面回答：

什么是 SpringBoot 自动装配？
SpringBoot 是如何实现自动装配的？如何实现按需加载？
如何实现一个 Starter？

使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring 特性或者引入第三方依赖的时候，还是需要用 XML 或 Java 进行显式配置。

@Configuration
public class RESTConfiguration
{
    @Bean
    public View jsonTemplate() {
        MappingJackson2JsonView view = new MappingJackson2JsonView();
        view.setPrettyPrint(true);
        return view;
    }

    @Bean
    public ViewResolver viewResolver() {
        return new BeanNameViewResolver();
    }
}

spring-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context/ http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc/ http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.howtodoinjava.demo" />
    <mvc:annotation-driven />

    <!-- JSON Support -->
    <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
    <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>

</beans>

但是，Spring Boot 项目，我们只需要添加相关依赖，无需配置，通过启动下面的 main 方法即可。

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

并且，我们通过 Spring Boot 的全局配置文件 application.properties或application.yml即可对项目进行设置比如更换端口号，配置 JPA 属性等等。

为什么 Spring Boot 使用起来这么酸爽呢？ 这得益于其自动装配。自动装配可以说是 Spring Boot 的核心，那究竟什么是自动装配呢？

什么是 SpringBoot 自动装配？

我们现在提到自动装配的时候，一般会和 Spring Boot 联系在一起。但是，实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。

SpringBoot 定义了一套接口规范，这套规范规定：SpringBoot 在启动时会扫描外部引用 jar 包中的META-INF/spring.factories文件，将文件中配置的类型信息加载到 Spring 容器（此处涉及到 JVM 类加载机制与 Spring 的容器知识），并执行类中定义的各种操作。对于外部 jar 来说，只需要按照 SpringBoot 定义的标准，就能将自己的功能装置进 SpringBoot

没有 Spring Boot 的情况下，如果我们需要引入第三方依赖，需要手动配置，非常麻烦。但是，Spring Boot 中，我们直接引入一个 starter 即可。比如你想要在项目中使用 redis 的话，直接在项目中引入对应的 starter 即可。

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

引入 starter 之后，我们通过少量注解和一些简单的配置就能使用第三方组件提供的功能了。在我看来，自动装配可以简单理解为：通过注解或者一些简单的配置就能在 Spring Boot 的帮助下实现某块功能。

SpringBoot 是如何实现自动装配的？

我们先看一下 SpringBoot 的核心注解 SpringBootApplication 。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
<1.>@SpringBootConfiguration
<2.>@ComponentScan
<3.>@EnableAutoConfiguration
public @interface SpringBootApplication {

}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration //实际上它也是一个配置类
public @interface SpringBootConfiguration {
}

大概可以把 @SpringBootApplication看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合。根据 SpringBoot 官网，这三个注解的作用分别是：

@EnableAutoConfiguration：启用 SpringBoot 的自动配置机制
@Configuration：允许在上下文中注册额外的 bean 或导入其他配置类
@ComponentScan：扫描被@Component (@Service,@Controller)注解的 bean，注解默认会扫描启动类所在的包下所有的类，可以自定义不扫描某些 bean。如下图所示，容器中将排除TypeExcludeFilter和AutoConfigurationExcludeFilter。

在这里插入图片描述 @EnableAutoConfiguration 是实现自动装配的重要注解，我们以这个注解入手。

@EnableAutoConfiguration:实现自动装配的核心注解

EnableAutoConfiguration 只是一个简单地注解，自动装配核心功能的实现实际是通过 AutoConfigurationImportSelector类。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage //作用：将main包下的所欲组件注册到容器中
@Import({AutoConfigurationImportSelector.class}) //加载自动装配类 xxxAutoconfiguration
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

我们现在重点分析下AutoConfigurationImportSelector 类到底做了什么？

AutoConfigurationImportSelector:加载自动装配类

AutoConfigurationImportSelector类的继承体系如下：

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

}

public interface DeferredImportSelector extends ImportSelector {

}

public interface ImportSelector {
    String[] selectImports(AnnotationMetadata var1);
}

可以看出，AutoConfigurationImportSelector 类实现了 ImportSelector接口，也就实现了这个接口中的 selectImports方法，该方法主要用于获取所有符合条件的类的全限定类名，这些类需要被加载到 IoC 容器中。

private static final String[] NO_IMPORTS = new String[0];

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // <1>.判断自动装配开关是否打开
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
          //<2>.获取所有需要装配的bean
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

这里我们需要重点关注一下getAutoConfigurationEntry()方法，这个方法主要负责加载自动配置类的。该方法调用链如下：

现在我们结合getAutoConfigurationEntry()的源码来详细分析一下：

private static final AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationEntry();

AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        //<1>.
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            //<2>.
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            //<3>.
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            //<4>.
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

第 1 步:判断自动装配开关是否打开。默认spring.boot.enableautoconfiguration=true，可在 application.properties 或 application.yml 中设置

在这里插入图片描述 第 2 步 ：用于获取EnableAutoConfiguration注解中的 exclude 和 excludeName。

在这里插入图片描述 第 3 步获取需要自动装配的所有配置类，读取META-INF/spring.factories

spring-boot/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

在这里插入图片描述从下图可以看到这个文件的配置内容都被我们读取到了。XXXAutoConfiguration的作用就是按需加载组件。
不光是这个依赖下的META-INF/spring.factories被读取到，所有 Spring Boot Starter 下的META-INF/spring.factories都会被读取到。

所以，你可以清楚滴看到， druid 数据库连接池的 Spring Boot Starter 就创建了META-INF/spring.factories文件。

如果，我们自己要创建一个 Spring Boot Starter，这一步是必不可少的。

在这里插入图片描述 第 4 步 ：到这里可能面试官会问你:“spring.factories中这么多配置，每次启动都要全部加载么？”。很明显，这是不现实的。我们 debug 到后面你会发现，configurations 的值变小了。

在这里插入图片描述因为，这一步有经历了一遍筛选，@ConditionalOnXXX 中的所有条件都满足，该类才会生效。

@Configuration
// 检查相关的类：RabbitTemplate 和 Channel是否存在
// 存在才会加载
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
}

有兴趣的童鞋可以详细了解下 Spring Boot 提供的条件注解

@ConditionalOnBean：当容器里有指定 Bean 的条件下
@ConditionalOnMissingBean：当容器里没有指定 Bean 的情况下
@ConditionalOnSingleCandidate：当指定 Bean 在容器中只有一个，或者虽然有多个但是指定首选 Bean
@ConditionalOnClass：当类路径下有指定类的条件下
@ConditionalOnMissingClass：当类路径下没有指定类的条件下
@ConditionalOnProperty：指定的属性是否有指定的值
@ConditionalOnResource：类路径是否有指定的值
@ConditionalOnExpression：基于 SpEL 表达式作为判断条件
@ConditionalOnJava：基于 Java 版本作为判断条件
@ConditionalOnJndi：在 JNDI 存在的条件下差在指定的位置
@ConditionalOnNotWebApplication：当前项目不是 Web 项目的条件下
@ConditionalOnWebApplication：当前项目是 Web 项目的条件下

如何实现一个 Starter光说不练假把式，现在就来撸一个 starter，实现自定义线程池

第一步，创建threadpool-spring-boot-starter工程

第二步，引入 Spring Boot 相关依赖

在这里插入图片描述第三步，创建ThreadPoolAutoConfiguration

在这里插入图片描述第四步，在threadpool-spring-boot-starter工程的 resources 包下创建META-INF/spring.factories文件

最后新建工程引入threadpool-spring-boot-starter

测试通过！！！

总结

Spring Boot 通过@EnableAutoConfiguration开启自动装配，通过 SpringFactoriesLoader 最终加载META-INF/spring.factories中的自动配置类实现自动装配，自动配置类其实就是通过@Conditional按需加载的配置类，想要其生效必须引入spring-boot-starter-xxx包实现起步依赖

转自：https://zhuanlan.zhihu.com/p/345895748

面试高频题：springboot自动装配的原理你能说出来吗？ - java金融的文章 - 知乎 https://zhuanlan.zhihu.com/p/163685081

8.开发Restful Web服务器常用的注解有哪些？
在这里插入图片描述转自:https://blog.csdn.net/xfx_1994/article/details/103854398

9.SpringBoot常用的两者配置文件

properties和yaml有序无序体现在哪里

在Spring Boot中，配置文件有两种不同的格式，一个是properties，另一个是yaml。properties文件比较常见相对于properties而言，yaml更加简洁明了，而且使用的场景也更多，很多的开源项目都是使用yaml进行配置。除了简洁，yaml还有另外一个特点，就是yaml中的数据是有序的，properties中的数据是无序的。在一些需要路径匹配的的配置中，顺序就显得尤为重要，此时我们一般采用yaml。
转自：https://blog.csdn.net/qq_44717317/article/details/104099618?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2_{aggregatepage}first_rank_v2~rank_aggregation-1-104099618.pc_agg_rank_aggregation&utm_term=yaml%E9%85%8D%E7%BD%AE%E6%98%AF%E6%9C%89%E5%BA%8F%E7%9A%84&spm=1000.2123.3001.4430(绝对是大佬)

10.SpringBoot常用的读取配置文件的方法有哪些？

@SpringBootApplication //声明当前类是一个springBoot引导类,项目中只能有一个,是一个组合注解，其中有三个主要注解 @SpringBootConfiguration //声明当前类是SpringBoot应用的配置类，项目中只能有一个，它里面包含了Configuration注解 @Configuration @EnableAutoConfiguration //开启自动配置 @ComponentScan //开启注解扫描

读取配置文件这里有一个配置文件：jdbc.properties，读取配置文件并注入spring容器

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

1、使用PropertySource指定配置文件

@Configuration //声明一个类作为配置类，代替xml文件

@PropertySource //指定外部属性文件

@Bean //声明在方法上，将方法的返回值加入Bean容器，代替标签

@Value //为属性注入值

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfiguration {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

因为使用@Bean将DataSource注入了spring容器，因此就可以在任意位置通过@Autowired注入DataSource了。

在这里插入图片描述转自： https://zhuanlan.zhihu.com/p/265982399

这个@Bean的注解就是替代我们之前配置spring的XML文件里面的的，毕竟按照配置文件的方式，在Java文件上用写代码写个bean，然后再去XML文件通过注册，来回操作太麻烦，直接在当前用到的直接写。一般来说现在涉及到框架或者特别的业务处理会用到这个，比如我们shiro自定义自己的登录逻辑和方式，会用到。

@Autowired注解平常使用的频率要高的多，修饰变量和方法，自动装配（需要外部资源注入

@Autowired同样也是跟上面这些搭配，但是他的作用是“自动装配”，比如说我们controller层调用service层，首先这个service要注册过或者被@Service注解修饰过，容器里面有才行，要不然没办法去装配。（所以我们使用SpringBoot构建项目的时候用的都是@Autowired,@Bean人家已经帮我们完成了）

转自: https://zhuanlan.zhihu.com/p/336155878

2、SpringBoot的属性注入SpringBoot默认会读取文件名为application.properties的资源文件因此创建配置文件 [application.properties](

](https://link.zhihu.com/?target=http%3A//application.properties/)

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

@ConfigurationProperties //声明当前类是属性读取类，prefix="jdbc"读取属性文件中，前缀为jdbc的值。在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致，并且必须具有getter和setter方法

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    // getters 和 setters
}

然后就可以在JdbcConfiguration中使用JdbcProperties

注解@EnableConfigurationProperties(JdbcProperties.class)来声明要使用JdbcProperties这个类的对象

然后可以使用三种方式注入：@Autowired注入、构造函数注入、@Bean方法的参数注入

2.1 @Autowired注入

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    @Autowired
    private JdbcProperties jdbcProperties;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbcProperties.getUrl());
        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        dataSource.setUsername(jdbcProperties.getUsername());
        dataSource.setPassword(jdbcProperties.getPassword());
        return dataSource;
    }

}

2.2 构造函数注入

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    private JdbcProperties jdbcProperties;

    public JdbcConfiguration(JdbcProperties jdbcProperties){
        this.jdbcProperties = jdbcProperties;
    }

    @Bean
    public DataSource dataSource() {
        // 略
    }

}

2.3 @Bean方法的参数注入

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        // ...
    }
}

不管哪种方式，我们都可以在controller中获取到spring容器中注入好的DataSource

3、在方法上使用@ConfigurationProperties如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties）中。而是直接在需要的地方声明即可

@Configuration
public class JdbcConfiguration {
    
    @Bean
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

我们直接把@ConfigurationProperties(prefix = “jdbc”)声明在需要使用的@Bean的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。

使用的前提是：该类必须有对应属性的set方法！

静态资源springboot默认读取路径：

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/

通用mapper的使用

依赖坐标

<dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.2</version>
</dependency>

持久层接口

@Mapper public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User> { }

调用持久层中的方法

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryUserById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    public List<User> queryAll(){
        return this.userMapper.selectAll();
    }

    @Transactional
    public void deleteUserById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

ThymeleafSpringBoot并不推荐使用jsp，但是支持一些模板引擎技术：Freemarker、Thymeleaf

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

在这里插入图片描述转自:https://www.cnblogs.com/hlkawa/p/9723838.html

12.常用的Bean映射工具有哪些？

转自:https://www.cnblogs.com/javaguide/p/11861749.html

13.SpringBoot如何监控系统实际运行情况

转自:https://blog.csdn.net/qq_28289405/article/details/86502053

14.SpringBoot如何请求参数校验？

转自:https://blog.csdn.net/u013934408/article/details/108872775

15.如何使用SpringBoot实现全局异常处理?

https://www.cnblogs.com/xuwujing/p/10933082.html

16.SpringBoot如何实现定时任务?

转自:https://www.cnblogs.com/lenve/p/10728897.html

前端交互仔

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot面试题

1.简单介绍一下Spring?有啥缺点？Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。1.目的：解决企业应用开发的复杂性2.功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能3.范围：任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容
复制链接

扫一扫