作者 l cxuan

来源 l Hollis（ID：hollischuang）

现在大部分的Spring项目都采用了基于注解的配置，采用了@Configuration 替换标签的做法。一行简单的注解就可以解决很多事情。但是，其实每一个注解背后都有很多值得学习和思考的内容。这些思考的点也是很多大厂面试官喜欢问的内容。

在一次关于Spring注解的面试中，可能会经历面试官的一段夺命连环问：

@Configuration有什么用？

@Configuration和XML有什么区别？哪种好？

Spring是如何基于来获取Bean的定义的？

@Autowired 、 @Inject、@Resource 之间有什么区别？

@Value、@PropertySource 和 @Configuration？

Spring如何处理带@Configuration @Import的类？

@Profile有什么用？

@Configuration 如何嵌套？

Spring如何对Bean进行延迟初始化？

Spring项目怎么进行单元测试？

@Configuration 使用上有哪些约束？

本文就来尝试回答下以上问题。简单介绍下@Configuration 注解，并且你看一下他的基本用法以及和其他注解产生化学反应。文章内容较长，建议收藏。

@Configuration 基本说明

定义：指示一个类声明一个或者多个@Bean 声明的方法并且由Spring容器统一管理，以便在运行时为这些bean生成bean的定义和服务请求的类。例如：

@Configuration
public class AppConfig {@Beanpublic MyBean myBean(){return new MyBean();}
}

上述AppConfig 加入@Configuration 注解，表明这就是一个配置类。有一个myBean()的方法，返回一个MyBean()的实例，并用@Bean 进行注释，表明这个方法是需要被Spring进行管理的bean。@Bean 如果不指定名称的话，默认使用myBean名称，也就是小写的名称。

通过注解启动

通过启动一个AnnotationConfigApplicationContext 来引导这个@Configuration 注解的类，比如：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class);
ctx.refresh();

在web项目中，也可以使用AnnotationContextWebApplicationContext或者其他变体来启动。

新建一个SpringBoot项目(别问我为什么，因为这样创建项目比较快)。

pom.xml 文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.5.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.spring.configuration</groupId><artifactId>spring-configuration</artifactId><version>0.0.1-SNAPSHOT</version><name>spring-configuration</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.6.RELEASE</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

在config 包下新建一个MyConfiguration环境配置，和上面的示例代码相似，完整的代码如下：

@Configuration
public class MyConfiguration {@Beanpublic MyBean myBean(){System.out.println("myBean Initialized");return new MyBean();}
}

说明MyConfiguration 是一个配置类，能够在此类下面声明管理多个Bean，我们声明了一个MyBean的bean，希望它被容器加载和管理。

在pojo包下新建一个MyBean的类，具体代码如下

public class MyBean {public MyBean(){System.out.println("generate MyBean Instance");}public void init(){System.out.println("MyBean Resources Initialized");}
}

新建一个SpringConfigurationApplication类，用来测试MyConfiguration类，具体代码如下：

public class SpringConfigurationApplication {public static void main(String[] args) {
//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)// 因为我们加载的@Configuration 是基于注解形式的，所以需要创建AnnotationConfigApplicationContextAnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册MyConfiguration 类并刷新bean 容器。context.register(MyConfiguration.class);context.refresh();}
}

输出：

myBean Initialized
generate MyBean Instance

从输出的结果可以看到，默认名称为myBean 的bean随着容器的加载而加载，因为myBean方法返回一个myBean的构造方法，所以myBean被初始化了。

通过XML 的方式来启动

可以通过使用XML方式定义的开启基于注解的启动，然后再定义一个MyConfiguration的bean，在/resources 目录下新建 application-context.xml 代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<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:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
><!-- 相当于基于注解的启动类 AnnotationConfigApplicationContext--><context:annotation-config /><bean class="com.spring.configuration.config.MyConfiguration"/></beans>

需要引入applicationContext.xml ，在SpringConfigurationApplication 需要进行引入，修改后的SpringConfigurationApplication如下：

public class SpringConfigurationApplication {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");}
}

输出：

myBean Initialized
generate MyBean Instance

基于ComponentScan() 来获取Bean的定义

@Configuration 使用@Component 进行原注解，因此@Configuration 类也可以被组件扫描到（特别是使用XML元素）。

在这里认识几个注解: @Controller, @Service, @Repository, @Component

  • @Controller: 表明一个注解的类是一个"Controller"，也就是控制器，可以把它理解为MVC 模式的Controller 这个角色。这个注解是一个特殊的@Component，允许实现类通过类路径的扫描扫描到。它通常与@RequestMapping 注解一起使用。

  • @Service: 表明这个带注解的类是一个"Service"，也就是服务层，可以把它理解为MVC 模式中的Service层这个角色，这个注解也是一个特殊的@Component，允许实现类通过类路径的扫描扫描到

  • @Repository: 表明这个注解的类是一个"Repository",团队实现了JavaEE 模式中像是作为"Data Access Object" 可能作为DAO来使用，当与 PersistenceExceptionTranslationPostProcessor 结合使用时，这样注释的类有资格获得Spring转换的目的。这个注解也是@Component 的一个特殊实现，允许实现类能够被自动扫描到

  • @Component: 表明这个注释的类是一个组件，当使用基于注释的配置和类路径扫描时，这些类被视为自动检测的候选者。

也就是说，上面四个注解标记的类都能够通过@ComponentScan 扫描到，上面四个注解最大的区别就是使用的场景和语义不一样，比如你定义一个Service类想要被Spring进行管理，你应该把它定义为@Service 而不是@Controller因为我们从语义上讲，@Service更像是一个服务的类，而不是一个控制器的类，@Component通常被称作组件，它可以标注任何你没有严格予以说明的类，比如说是一个配置类，它不属于MVC模式的任何一层，这个时候你更习惯于把它定义为 @Component。@Controller，@Service，@Repository 的注解上都有@Component，所以这三个注解都可以用@Component进行替换。

来看一下代码进行理解：

定义五个类，类上分别用@Controller, @Service, @Repository, @Component, @Configuration 进行标注，分别如下

@Component
public class UserBean {}@Configuration
public class UserConfiguration {}@Controller
public class UserController {}@Repository
public class UserDao {}@Service
public class UserService {}

在MyConfiguration上加上@ComponentScan 注解，扫描上面5个类所在的包位置。代码如下：

@Configuration
@ComponentScan(basePackages = "com.spring.configuration.pojo")
public class MyConfiguration {@Beanpublic MyBean myBean(){System.out.println("myBean Initialized");return new MyBean();}
}

修改 SpringConfigurationApplication 中的代码，如下：

public class SpringConfigurationApplication {public static void main(String[] args) {//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(MyConfiguration.class);context.refresh();// 获取启动过程中的bean 定义的名称for(String str : context.getBeanDefinitionNames()){System.out.println("str = " + str);}context.close();}
}

输出：

myBean Initialized
generate MyBean Instance
str = org.springframework.context.annotation.internalConfigurationAnnotationProcessor
str = org.springframework.context.annotation.internalAutowiredAnnotationProcessor
str = org.springframework.context.annotation.internalRequiredAnnotationProcessor
str = org.springframework.context.annotation.internalCommonAnnotationProcessor
str = org.springframework.context.event.internalEventListenerProcessor
str = org.springframework.context.event.internalEventListenerFactory
str = myConfiguration
str = userBean
str = userConfiguration
str = userController
str = userDao
str = userService
str = myBean

由输出可以清楚的看到，上述定义的五个类成功被@ComponentScan 扫描到，并在程序启动的时候进行加载。

@Configuration 和 Environment

@Configuration 通常和Environment 一起使用，通过@Environment 解析的属性驻留在一个或多个"属性源"对象中，@Configuration类可以使用@PropertySource，像Environment 对象提供属性源

为了便于测试，我们引入junit4和spring-test 的依赖，完整的配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.5.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.spring.configuration</groupId><artifactId>spring-configuration</artifactId><version>0.0.1-SNAPSHOT</version><name>spring-configuration</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><spring.version>5.0.6.RELEASE</spring.version><spring.test.version>4.3.13.RELEASE</spring.test.version><junit.version>4.12</junit.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>${spring.test.version}</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

在config 包下定义一个 EnvironmentConfig 类，注入Environment 属性，完整代码如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = EnvironmentConfig.class)
@Configuration
@PropertySource("classpath:beanName.properties")
public class EnvironmentConfig {@AutowiredEnvironment env;@Testpublic void testReadProperty(){// 获取bean.name.controller 的属性System.out.println(env.getProperty("bean.name.controller"));// 判断是否包含bean.name.componentSystem.out.println(env.containsProperty("bean.name.component"));// 返回与给定键关联的属性值System.out.println(env.getRequiredProperty("bean.name.service"));}
}

在/resources 目录下新建beanName.properties 文件，如下：

bean.name.configuration=beanNameConfiguration
bean.name.controller=beanNameController
bean.name.service=beanNameService
bean.name.component=beanNameComponent
bean.name.repository=beanNameRepository

启动并进行Junit测试，输出如下：

…..……beanNameControllertruebeanNameService…..……

@Autowired 、 @Inject、@Resource 的区别

@Inject: 这是jsr330 的规范，通过AutowiredAnnotationBeanPostProcessor 类实现的依赖注入。位于javax.inject包内，是Java自带的注解。

@Inject
@Named("environment")
Environment env;

不加@Named注解，需要配置与变量名一致即可。

@Autowired: @Autowired 是Spring提供的注解，通过AutowiredAnnotationBeanPostProessor 类实现注入。位于org.springframework.beans.factory.annotation 包内，是Spring 中的注解

@Autowired
Environment env;

默认是通过byType 实现注入

@Resource: @Resource 是jsr250规范的实现，@Resource通过CommonAnnotationBeanPostProcessor 类实现注入。@Resource 一般会指定一个name属性，如下：

@Resource(name = "environment")
Environment env;

默认是通过byName 实现注入

区别：

@Autowired和@Inject基本是一样的，因为两者都是使用AutowiredAnnotationBeanPostProcessor来处理依赖注入。但是@Resource是个例外，它使用的是CommonAnnotationBeanPostProcessor来处理依赖注入。当然，两者都是BeanPostProcessor。

在介绍完上述三者的区别之后，可以对Environment的属性以上述注入方式进行改造

@Value、@PropertySource 和 @Configuration

@Configuration 可以和@Value 和@PropertySource 一起使用读取外部配置文件，具体用法如下：

在config 包下新建一个ReadValueFromPropertySource类，代码如下

@PropertySource("classpath:beanName.properties")
@Configuration
public class ReadValueFromPropertySource {@Value("bean.name.component")String beanName;@Bean("myTestBean")public MyBean myBean(){return new MyBean(beanName);}}

通过@PropertySource引入的配置文件，使@Value 能够获取到属性值，在给myBean()方法指定了一个名称叫做myTestBean。

修改MyBean类，增加一个name属性和一个构造器，再生成其toString() 方法

public class MyBean {String name;public MyBean(String name) {this.name = name;}public MyBean(){System.out.println("generate MyBean Instance");}public void init(){System.out.println("MyBean Resources Initialized");}@Overridepublic String toString() {return "MyBean{" +"name='" + name + '\'' +'}';}
}

在SpringConfigurationApplication中进行测试，如下

public class SpringConfigurationApplication {public static void main(String[] args) {// 为了展示配置文件的完整性，之前的代码没有删除。
//        AnnotationConfigApplicationContext context = = new AnnotationConfigApplicationContext(MyConfiguration.class)
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//        context.register(MyConfiguration.class);
//        context.refresh();
//
//        // 获取启动过程中的bean 定义的名称
//        for(String str : context.getBeanDefinitionNames()){
//            System.out.println("str = " + str);
//        }
//        context.close();ApplicationContext context =new AnnotationConfigApplicationContext(ReadValueFromPropertySource.class);MyBean myBean = (MyBean) context.getBean("myTestBean");System.out.println("myBean = " + myBean);}
}

使用Applicatio@InConntext 就能够获取myTestBean 这个bean，再生成myBean的实例。

输出：myBean = MyBean{name='bean.name.component'}

@Import 和 @Configuration

@Import的定义(来自于JavaDoc)：表明一个或者多个配置类需要导入，提供与Spring XML中相等的功能，允许导入@Configuration 、@ImportSelector、@ImportBeanDefinitionRegistar的实现，以及常规组件类似于AnnotationConfigApplicationContext。可能用于类级别或者是原注解。如果XML或者其他非@Configuration标记的Bean资源需要被导入的话，使用@ImportResource。下面是一个示例代码：

在pojo 包下新建两个配置类，分别是CustomerBo, SchedualBo

@Configuration
public class CustomerBo {public void printMsg(String msg){System.out.println("CustomerBo : " + msg);}@Beanpublic CustomerBo testCustomerBo(){return new CustomerBo();}
}@Configuration
public class SchedulerBo {public void printMsg(String msg){System.out.println("SchedulerBo : " + msg);}@Beanpublic SchedulerBo testSchedulerBo(){return new SchedulerBo();}
}

在config 包下新建一个AppConfig，导入CustomerBo 和 SchedulerBo 。

@Configuration
@Import(value = {CustomerBo.class,SchedulerBo.class})
public class AppConfig {}

在config 包下新建一个ImportWithConfiguration ，用于测试@Import 和 @Configuration 的使用

public class ImportWithConfiguration {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);CustomerBo customerBo = (CustomerBo) context.getBean("testCustomerBo");customerBo.printMsg("System out println('get from customerBo')");SchedulerBo schedulerBo = (SchedulerBo) context.getBean("testSchedulerBo");schedulerBo.printMsg("System out println('get from schedulerBo')");}
}

输出：

CustomerBo : System out println('get from customerBo')
SchedulerBo : System out println('get from schedulerBo')

@Profile

@Profile: 表示当一个或多个@Value 指定的配置文件处于可用状态时，组件符合注册条件，可以进行注册。

三种设置方式：

  • 可以通过ConfigurableEnvironment.setActiveProfiles()以编程的方式激活

  • 可以通过AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME (spring.profiles.active )属性设置为

    JVM属性

  • 作为环境变量，或作为web.xml 应用程序的Servlet 上下文参数。也可以通过@ActiveProfiles 注解在集成测试中以声明方式激活配置文件。

作用域

  • 作为类级别的注释在任意类或者直接与@Component 进行关联，包括@Configuration 类

  • 作为原注解，可以自定义注解

  • 作为方法的注解作用在任何方法

注意:

如果一个配置类使用了Profile 标签或者@Profile 作用在任何类中都必须进行启用才会生效，如果@Profile({"p1","!p2"}) 标识两个属性，那么p1 是启用状态 而p2 是非启用状态的。

@ImportResource 和 @Configuration

@ImportResource: 这个注解提供了与@Import 功能相似作用，通常与@Configuration 一起使用，通过AnnotationConfigApplicationContext 进行启动，下面以一个示例来看一下具体用法：

在config下新建TestService 类，声明一个构造函数，类初始化时调用

public class TestService {public TestService(){System.out.println("test @importResource success");}
}

在/resources 目录下新建 importResources.xml ，为了导入TestService

<?xml version="1.0" encoding="UTF-8"?>
<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:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
><bean id = "testService" class="com.spring.configuration.config.TestService" /></beans>

然后在config 下新建一个ImportResourceWithConfiguration， 用于读取配置文件

@Configuration
@ImportResource("classpath:importResources.xml")
public class ImportResourceWithConfiguration {@Autowiredprivate TestService service;public void getImportResource(){new TestService();}public static void main(String[] args) {AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(ImportResourceWithConfiguration.class);context.getBean("testService");}
}

输出：test @importResource success

@Configuration 嵌套

@Configuration注解作用在类上，就和普通类一样能够进行相互嵌套，定义内部类。

// 来自JavaDoc
@Configuration
public class AppConfig{@InjectDataSource dataSource;@Beanpublic MyBean myBean(){return new MyBean(dataSource);}@Configurationstatic class DataConfig(){@BeanDataSource dataSource(){return new EmbeddedDatabaseBuilder().build()}}
}

在上述代码中，只需要在应用程序的上下文中注册 AppConfig 。由于是嵌套的@Configuration 类，DatabaseConfig 将自动注册。当AppConfig 、DatabaseConfig 之间的关系已经隐含清楚时，这就避免了使用@Import 注解的需要。

@Lazy 延迟初始化

@Lazy : 表明一个bean 是否延迟加载，可以作用在方法上，表示这个方法被延迟加载；可以作用在@Component (或者由@Component 作为原注解) 注释的类上，表明这个类中所有的bean 都被延迟加载。如果没有@Lazy注释，或者@Lazy 被设置为false，那么该bean 就会急切渴望被加载；除了上面两种作用域，@Lazy 还可以作用在@Autowired和@Inject注释的属性上，在这种情况下，它将为该字段创建一个惰性代理，作为使用ObjectFactory或Provider的默认方法。下面来演示一下：

修改MyConfiguration类，在该类上添加@Lazy 注解，新增一个IfLazyInit()方法，检验是否被初始化。

@Lazy
@Configuration
@ComponentScan(basePackages = "com.spring.configuration.pojo")
public class MyConfiguration {@Beanpublic MyBean myBean(){System.out.println("myBean Initialized");return new MyBean();}@Beanpublic MyBean IfLazyInit(){System.out.println("initialized");return new MyBean();}
}

修改SpringConfigurationApplication 启动类，放开之前MyConfiguration 的启动类

public class SpringConfigurationApplication {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//        context.register(MyConfiguration.class);
//        context.refresh();
//
//        // 获取启动过程中的bean 定义的名称for(String str : context.getBeanDefinitionNames()){System.out.println("str = " + str);}
//        context.close();//        ApplicationContext context =
//                new AnnotationConfigApplicationContext(ReadValueFromPropertySource.class);
//        MyBean myBean = (MyBean) context.getBean("myTestBean");
//        System.out.println("myBean = " + myBean);}
}

输出你会发现没有关于bean的定义信息，但是当吧@Lazy 注释拿掉，你会发现输出了关于bean的初始化信息：

myBean Initialized
generate MyBean Instance
initialized
generate MyBean Instance

@RunWith 和 @ContextConfiguration

Junit4 测试类，用于注解在类上表示通过Junit4 进行测试，可以省略编写启动类代码，是ApplicationContext 等启动类的替换。一般用@RunWith 和 @Configuration 进行单元测试，这是软件开发过程中非常必要而且具有专业性的一部分，上面EnvironmentConfig 类证实了这一点：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = EnvironmentConfig.class)
@Configuration
@PropertySource("classpath:beanName.properties")
public class EnvironmentConfig {//    @Autowired
//    Environment env;@InjectEnvironment env;@Testpublic void testReadProperty(){// 获取bean.name.controller 的属性System.out.println(env.getProperty("bean.name.controller"));// 判断是否包含bean.name.componentSystem.out.println(env.containsProperty("bean.name.component"));// 返回与给定键关联的属性值System.out.println(env.getRequiredProperty("bean.name.service"));}
}

@Enable 启动Spring内置功能

详情查阅@EnableAsync，@EnableScheduling，@EnableTransactionManagement，@EnableAspectJAutoProxy，@EnableWebMvc官方文档

@Configuration 使用约束

必须以类的方式提供(即不是从工厂方法返回的实例)

@Configuration 注解的类必须是非final的

配置类必须是非本地的（即可能不在方法中声明）,native 标注的方法

任何嵌套的@Configuration 都必须是static 的。

@Bean 方法可能不会反过来创建更多配置类

参考资料：

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/PropertySource.html

https://blog.csdn.net/u012734441/article/details/51706504

本文来自作者投稿，原作者：cxuan

关注下方二维码，订阅更多精彩内容。

转发朋友圈，是对我最大的支持。

我被面试官给虐懵了，竟然是因为我不懂Spring中的@Configuration相关推荐

  1. 原创 | 我被面试官给虐懵了，竟然是因为我不懂Spring中的@Configuration

    这是Hollis的第 216 篇原创分享 作者 l cxuan 来源 l Hollis(ID:hollischuang) 现在大部分的Spring项目都采用了基于注解的配置,采用了@Configura ...

  2. 32岁坚持裸辞背负房贷1w4，被阿里面试官狂虐，沉淀3个月拿到腾讯offer年薪40w+！

    我的情况 是的,我工作五年了,在互联网某血汗厂. 上周和组长提了裸辞,组长拉着我聊了两个小时,希望我还是考虑考虑,建议我不要裸辞,多想想工作的意义之类的.现在的情况就是,那次谈话之后的一周,组长没给我 ...

  3. 与面试官的终局之战：精选Android面试题，再也不怕面试官血虐我了

    原文作者:Focusing 废话不多说,直接开始正文就是对各位看官最大的尊重! 1.如何进行单元测试,如何保证App稳定 ? 参考回答:要测试Android应用程序,通常会创建以下类型自动单元测试: ...

  4. Java程序员：真是会服了面试官，不就要个40k嘛硬是把Spring问烂

    你们知道今年工作有多难找吗?反正我是累了,面试官已经把Spring给问烂了,问!烂!了! 先随便上十道面试题你们感受一下: 使 用 Spring 框 架 的 好 处 是 什 么 解 释 AOP 模 块 ...

  5. spring ioc原理_干了5年的Java面试官，把他喜欢问的几十个Spring面试题告诉我了

    前言: Spring 框架知识是互联网公司面试必考知识点.对于开发同学来说,Spring 框架熟悉又陌生. 熟悉:开发过程中无时无刻不在使用 Spring 的知识点:陌生:对于基本理论知识疏于整理与记 ...

  6. 阿里面试官：给我说说Netty是如何在Dubbo中应用的？

    点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试资料 作者:莫那 鲁道 来源:cnblogs.com/stateis0/ ...

  7. 面试官：你连复杂度分析都不懂还敢来面试？

    算法(Algorithm)是指用来操作数据.解决程序问题的一组方法.对于同一个问题,使用不同的算法,也许最终得到的结果是一样的,比如排序就有前面的十大经典排序和几种奇葩排序,虽然结果相同,但在过程中消 ...

  8. Spring注解驱动开发第11讲——面试官让我说说：如何使用FactoryBean向Spring容器中注册bean？

    写在前面 经过前面的学习,我们知道可以通过多种方式向Spring容器中注册bean.可以使用@Configuration注解结合@Bean注解向Spring容器中注册bean:可以按照条件向Sprin ...

  9. 面试官让我手写一个生产者消费者模式？

    不知道你是否遇到过面试官让你手写生产者消费者代码.别说,前段时间有小伙伴还真的遇到了这种情况,当时是一脸懵逼. 但是,俗话说,从哪里跌倒就要从哪里爬起来.既然这次被问到了,那就回去好好研究一下,争取下 ...

最新文章

  1. python学习day24 继承 派生
  2. 4篇SCI，获得多次国奖，这个硕士小姐姐分享科研之路
  3. 3117 高精度练习之乘法
  4. nginx location 配置详细解释
  5. 这周开发工作时间及内容、思考和阅读的内容
  6. java字符类的英文表示_java 字符串截取类 区分中文、英文、数字、标点符号
  7. 一个收入很低的人，能装大款到什么地步？
  8. sql server 缓存_深入了解SQL Server缓冲区缓存
  9. 集合类型及其操作(复习)
  10. Oracle 10g OCP 官方培训
  11. Linux内核抢占实现机制分析
  12. 【路径规划】基于matlab模拟退火算法求解火灾巡逻最短路径问题【含Matlab源码 252期】
  13. gpu超算算法_2018电磁仿真(HFSS、CST、FEKO)单机集群并行计算特点分析与完美解决方案...
  14. Unity3D 实现阴阳师 画符
  15. 基于Python技术的营养信息管理系统
  16. 如何解决layui弹出层闪退的问题
  17. JSONObject、JSONArray
  18. 网易免费企业邮箱 使用感受
  19. 小程序空格解决文字分散对齐
  20. 【安全系列】setoolkit钓鱼

热门文章

  1. Redis的AOF日志
  2. oracle中修改process
  3. LDAP命令介绍---dsreplication--initialize
  4. Mysql截取中英数混合的字符串
  5. 创建自定义Tabs组件-01
  6. Symantec(赛门铁克）非受管检测
  7. kafka清理数据日志
  8. vscode gcc debug dbg gdb c cpp c++ cuckoo monitor
  9. .NET配置文件读写实例（附SosoftConfigHelper类）
  10. postfixadmin 导入数据库出错 ERROR 1062 (23000) at line 29