【Spring Boot】五、注解（自动配置）原理浅析

最新推荐文章于 2024-09-21 06:02:09 发布
最新推荐文章于 2024-09-21 06:02:09 发布
阅读量1k 收藏
点赞数
分类专栏： Spring 文章标签： Spring 源码 原理 注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqchaozai/article/details/82459983
版权

1概述

Spring关于自动配置的源码在spring-boot-autoconfigure-2.0.2.RELEASE.jar内：

spring.factories文件中声明了有哪些自动配置：

三种查看自动配置的方式：

  1. 运行jar添加--debug
  2. application.properties设置：debug=true
  3. eclipse的Run Configurations中VM arguments添加-Ddebug

添加后可在启动日志中查看到，Positive-启用的自动配置，Negative-未启用的自动配置：

2运作原理

从@SpringBootApplication说起，它是一个组合注解，核心功能有@EnableAutoConfiguration注解提供。

@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({ AutoConfigurationImportSelector.class })
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

    String[] excludeName() default {};
}

通过@Import引入AutoConfigurationImportSelector，getCandidateConfigurations中通过SpringFactoriesLoader的loadFactoryNames扫描META-INF/spring.factories中的自动配置类

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
	ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    private static final String[] NO_IMPORTS = new String[0];
    private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
    private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
    private ConfigurableListableBeanFactory beanFactory;
    private Environment environment;
    private ClassLoader beanClassLoader;
    private ResourceLoader resourceLoader;

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
	if (!this.isEnabled(annotationMetadata)) {
	    return NO_IMPORTS;
	} else {
	    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
		    .loadMetadata(this.beanClassLoader);
	    AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
	    List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
	    configurations = this.removeDuplicates(configurations);
	    Set exclusions = this.getExclusions(annotationMetadata, attributes);
	    this.checkExcludedClasses(configurations, exclusions);
	    configurations.removeAll(exclusions);
	    configurations = this.filter(configurations, autoConfigurationMetadata);
	    this.fireAutoConfigurationImportEvents(configurations, exclusions);
	    return StringUtils.toStringArray(configurations);
	}
    }

    public Class<? extends Group> getImportGroup() {
	return AutoConfigurationImportSelector.AutoConfigurationGroup.class;
    }

    protected boolean isEnabled(AnnotationMetadata metadata) {
	return this.getClass() == AutoConfigurationImportSelector.class
		? ((Boolean) this.getEnvironment().getProperty("spring.boot.enableautoconfiguration", Boolean.class,
			Boolean.valueOf(true))).booleanValue()
		: true;
    }

    protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
	String name = this.getAnnotationClass().getName();
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
	Assert.notNull(attributes, () -> {
	    return "No auto-configuration attributes found. Is " + metadata.getClassName() + " annotated with "
		    + ClassUtils.getShortName(name) + "?";
	});
	return attributes;
    }

    protected Class<?> getAnnotationClass() {
	return EnableAutoConfiguration.class;
    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
	List configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(),
		this.getBeanClassLoader());
	Assert.notEmpty(configurations,
		"No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
	return configurations;
    }

    protected Class<?> getSpringFactoriesLoaderFactoryClass() {
	return EnableAutoConfiguration.class;
    }
    ......略......
}

抽象类：SpringFactoriesLoader

public abstract class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
    private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap();

    public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {
	Assert.notNull(factoryClass, "\'factoryClass\' must not be null");
	ClassLoader classLoaderToUse = classLoader;
	if (classLoader == null) {
	    classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
	}

	List factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
	if (logger.isTraceEnabled()) {
	    logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
	}

	ArrayList result = new ArrayList(factoryNames.size());
	Iterator arg4 = factoryNames.iterator();

	while (arg4.hasNext()) {
	    String factoryName = (String) arg4.next();
	    result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
	}

	AnnotationAwareOrderComparator.sort(result);
	return result;
    }

    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
	String factoryClassName = factoryClass.getName();
	return (List) loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
	MultiValueMap result = (MultiValueMap) cache.get(classLoader);
	if (result != null) {
	    return result;
	} else {
	    try {
		Enumeration ex = classLoader != null ? classLoader.getResources("META-INF/spring.factories")
			: ClassLoader.getSystemResources("META-INF/spring.factories");
		LinkedMultiValueMap result1 = new LinkedMultiValueMap();

		while (ex.hasMoreElements()) {
		    URL url = (URL) ex.nextElement();
		    UrlResource resource = new UrlResource(url);
		    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
		    Iterator arg5 = properties.entrySet().iterator();

		    while (arg5.hasNext()) {
			Entry entry = (Entry) arg5.next();
			List factoryClassNames = Arrays
				.asList(StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
			result1.addAll((String) entry.getKey(), factoryClassNames);
		    }
		}

		cache.put(classLoader, result1);
		return result1;
	    } catch (IOException arg8) {
		throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]",
			arg8);
	    }
	}
    }

    private static <T> T instantiateFactory(String instanceClassName, Class<T> factoryClass, ClassLoader classLoader) {
	try {
	    Class ex = ClassUtils.forName(instanceClassName, classLoader);
	    if (!factoryClass.isAssignableFrom(ex)) {
		throw new IllegalArgumentException(
			"Class [" + instanceClassName + "] is not assignable to [" + factoryClass.getName() + "]");
	    } else {
		return ReflectionUtils.accessibleConstructor(ex, new Class[0]).newInstance(new Object[0]);
	    }
	} catch (Throwable arg3) {
	    throw new IllegalArgumentException("Unable to instantiate factory class: " + factoryClass.getName(), arg3);
	}
    }
}

3核心注解

随便选择一个自动配置类打开，如AopAutoConfiguration：

@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class, AnnotatedElement.class })
@ConditionalOnProperty(prefix = "spring.aop", name = { "auto" }, havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    @ConditionalOnProperty(prefix = "spring.aop", name = {
	    "proxy-target-class" }, havingValue = "true", matchIfMissing = true)
    public static class CglibAutoProxyConfiguration {
    }

    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = false)
    @ConditionalOnProperty(prefix = "spring.aop", name = {
	    "proxy-target-class" }, havingValue = "false", matchIfMissing = false)
    public static class JdkDynamicAutoProxyConfiguration {
    }
}

可以看到包含很多条件注解@Conditional*，org.springframework.boot.autoconfigure.condition包下定义了许多：

这些注解都是组合了@Conditional元注解，只是使用了不同的条件。

已OnWebApplicationCondition做示例：

class OnWebApplicationCondition extends SpringBootCondition {
    private static final String WEB_CONTEXT_CLASS = "org.springframework.web.context.support.GenericWebApplicationContext";

    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
	boolean required = metadata.isAnnotated(ConditionalOnWebApplication.class.getName());
	ConditionOutcome outcome = this.isWebApplication(context, metadata, required);
	return required && !outcome.isMatch() ? ConditionOutcome.noMatch(outcome.getConditionMessage())
		: (!required && outcome.isMatch() ? ConditionOutcome.noMatch(outcome.getConditionMessage())
			: ConditionOutcome.match(outcome.getConditionMessage()));
    }

    private ConditionOutcome isWebApplication(ConditionContext context, AnnotatedTypeMetadata metadata,
	    boolean required) {
	Builder message = ConditionMessage.forCondition(ConditionalOnWebApplication.class,
		new Object[] { required ? "(required)" : "" });
	Type type = this.deduceType(metadata);
	if (Type.SERVLET == type) {
	    return this.isServletWebApplication(context);
	} else if (Type.REACTIVE == type) {
	    return this.isReactiveWebApplication(context);
	} else {
	    ConditionOutcome servletOutcome = this.isServletWebApplication(context);
	    if (servletOutcome.isMatch() && required) {
		return new ConditionOutcome(servletOutcome.isMatch(), message.because(servletOutcome.getMessage()));
	    } else {
		ConditionOutcome reactiveOutcome = this.isReactiveWebApplication(context);
		if (reactiveOutcome.isMatch() && required) {
		    return new ConditionOutcome(reactiveOutcome.isMatch(),
			    message.because(reactiveOutcome.getMessage()));
		} else {
		    boolean finalOutcome = required ? servletOutcome.isMatch() && reactiveOutcome.isMatch()
			    : servletOutcome.isMatch() || reactiveOutcome.isMatch();
		    return new ConditionOutcome(finalOutcome, message.because(servletOutcome.getMessage()).append("and")
			    .append(reactiveOutcome.getMessage()));
		}
	    }
	}
    }

    private ConditionOutcome isServletWebApplication(ConditionContext context) {
	Builder message = ConditionMessage.forCondition("", new Object[0]);
	if (!ClassUtils.isPresent("org.springframework.web.context.support.GenericWebApplicationContext",
		context.getClassLoader())) {
	    return ConditionOutcome.noMatch(message.didNotFind("web application classes").atAll());
	} else {
	    if (context.getBeanFactory() != null) {
		String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
		if (ObjectUtils.containsElement(scopes, "session")) {
		    return ConditionOutcome.match(message.foundExactly("\'session\' scope"));
		}
	    }

	    return context.getEnvironment() instanceof ConfigurableWebEnvironment
		    ? ConditionOutcome.match(message.foundExactly("ConfigurableWebEnvironment"))
		    : (context.getResourceLoader() instanceof WebApplicationContext
			    ? ConditionOutcome.match(message.foundExactly("WebApplicationContext"))
			    : ConditionOutcome.noMatch(message.because("not a servlet web application")));
	}
    }

    private ConditionOutcome isReactiveWebApplication(ConditionContext context) {
	Builder message = ConditionMessage.forCondition("", new Object[0]);
	return context.getEnvironment() instanceof ConfigurableReactiveWebEnvironment
		? ConditionOutcome.match(message.foundExactly("ConfigurableReactiveWebEnvironment"))
		: (context.getResourceLoader() instanceof ReactiveWebApplicationContext
			? ConditionOutcome.match(message.foundExactly("ReactiveWebApplicationContext"))
			: ConditionOutcome.noMatch(message.because("not a reactive web application")));
    }

    private Type deduceType(AnnotatedTypeMetadata metadata) {
	Map attributes = metadata.getAnnotationAttributes(ConditionalOnWebApplication.class.getName());
	return attributes != null ? (Type) attributes.get("type") : Type.ANY;
    }
}

说明：

  • 发现源码中不包含matches方法，那它如何实现条件判断？查看父类：
public abstract class SpringBootCondition implements Condition {
    private final Log logger = LogFactory.getLog(this.getClass());

    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
	String classOrMethodName = getClassOrMethodName(metadata);

	try {
	    ConditionOutcome ex = this.getMatchOutcome(context, metadata);
	    this.logOutcome(classOrMethodName, ex);
	    this.recordEvaluation(context, classOrMethodName, ex);
	    return ex.isMatch();
	} catch (NoClassDefFoundError arg4) {
	    throw new IllegalStateException(
		    "Could not evaluate condition on " + classOrMethodName + " due to " + arg4.getMessage()
			    + " not found. Make sure your own configuration does not rely on that class. This can also happen if you are @ComponentScanning a springframework package (e.g. if you put a @ComponentScan in the default package by mistake)",
		    arg4);
	} catch (RuntimeException arg5) {
	    throw new IllegalStateException("Error processing condition on " + this.getName(metadata), arg5);
	}
    }
    ......略......
}

 

  • 父类重写matches方法，且声明方法为final类型，子类无法覆盖，那子类如何实现条件判断逻辑？通过返回ConditionOutcome对象
  • 返回过程getMatchOutcome-->isWebApplication，此时按类型分别判断isServletWebApplication和isReactiveWebApplication，springboot2.*版本新加入Reactive模式。
  • Servlet判断过程：
  1. GenericWebApplicationContext是否被加载
  2. 容器里是否有session的scope-
  3. 当前容器的Environment是否为ConfigurableWebEnvironment
  4. 当前容器的ResourceLoader是否为WebApplicationContext
  • Reactive判断过程：
  1. 当前容器的Environment是否为ConfigurableReactiveWebEnvironment
  2. 当前容器的ResourceLoader是否为ReactiveWebApplicationContext

4实例分析

Spring boot编码设置：

spring.http.encoding.charset=UTF-8
spring.http.encoding.force=true
#spring.http.encoding.enabled=true

自动配置类-HttpEncodingAutoConfiguration：

@Configuration
@EnableConfigurationProperties({ HttpEncodingProperties.class })
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ CharacterEncodingFilter.class })
@ConditionalOnProperty(prefix = "spring.http.encoding", value = { "enabled" }, matchIfMissing = true)
public class HttpEncodingAutoConfiguration {
    private final HttpEncodingProperties properties;

    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
	this.properties = properties;
    }

    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
	OrderedCharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
	filter.setEncoding(this.properties.getCharset().name());
	filter.setForceRequestEncoding(this.properties
		.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.REQUEST));
	filter.setForceResponseEncoding(this.properties
		.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.RESPONSE));
	return filter;
    }

    @Bean
    public HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
	return new HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer(this.properties);
    }

    private static class LocaleCharsetMappingsCustomizer
	    implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>, Ordered {
	private final HttpEncodingProperties properties;

	LocaleCharsetMappingsCustomizer(HttpEncodingProperties properties) {
	    this.properties = properties;
	}

	public void customize(ConfigurableServletWebServerFactory factory) {
	    if (this.properties.getMapping() != null) {
		factory.setLocaleCharsetMappings(this.properties.getMapping());
	    }

	}

	public int getOrder() {
	    return 0;
	}
    }
}

属性配置类-HttpEncodingProperties：

@ConfigurationProperties(prefix = "spring.http.encoding")
public class HttpEncodingProperties {
    public static final Charset DEFAULT_CHARSET;
    private Charset charset;
    private Boolean force;
    private Boolean forceRequest;
    private Boolean forceResponse;
    private Map<Locale, Charset> mapping;

    public HttpEncodingProperties() {
	this.charset = DEFAULT_CHARSET;
    }

    public Charset getCharset() {
	return this.charset;
    }

    public void setCharset(Charset charset) {
	this.charset = charset;
    }

    public boolean isForce() {
	return Boolean.TRUE.equals(this.force);
    }

    public void setForce(boolean force) {
	this.force = Boolean.valueOf(force);
    }

    public boolean isForceRequest() {
	return Boolean.TRUE.equals(this.forceRequest);
    }

    public void setForceRequest(boolean forceRequest) {
	this.forceRequest = Boolean.valueOf(forceRequest);
    }

    public boolean isForceResponse() {
	return Boolean.TRUE.equals(this.forceResponse);
    }

    public void setForceResponse(boolean forceResponse) {
	this.forceResponse = Boolean.valueOf(forceResponse);
    }

    public Map<Locale, Charset> getMapping() {
	return this.mapping;
    }

    public void setMapping(Map<Locale, Charset> mapping) {
	this.mapping = mapping;
    }

    public boolean shouldForce(HttpEncodingProperties.Type type) {
	Boolean force = type != HttpEncodingProperties.Type.REQUEST ? this.forceResponse : this.forceRequest;
	if (force == null) {
	    force = this.force;
	}

	if (force == null) {
	    force = Boolean.valueOf(type == HttpEncodingProperties.Type.REQUEST);
	}

	return force.booleanValue();
    }

    static {
	DEFAULT_CHARSET = StandardCharsets.UTF_8;
    }

    public static enum Type {
	REQUEST, RESPONSE;
    }
}

说明：

  1. 通过@EnableConfigurationProperties声明属性注入对象
  2. @ConditionalOnClass声明CharacterEncodingFilter需要在类路径下
  3. 当设置spring.http.encoding=enabled的情况下，默认为true，即满足条件
  4. 通过@Bean注入CharacterEncodingFilter，@ConditionalOnMissingBean声明如果容器内没有则创建新的Bean
  5. HttpEncodingProperties中声明spring.http.encoding为前缀，默认字符集配置为UTF-8。

5实战

pom:

<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>

  <groupId>com.study.spring</groupId>
  <artifactId>spring-boot-starter-hello</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>spring-boot-starter-hello</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
  	<dependency>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-autoconfigure</artifactId>
  		<version>2.0.2.RELEASE</version>
  	</dependency>
  </dependencies>
</project>

配置类：

package com.study.spring.spring_boot_starter_hello;

import org.springframework.boot.context.properties.ConfigurationProperties;
/**
 * 通过hello.msg设置，默认world
 * @author chaozai
 * @date 2018年9月9日
 *
 */
@ConfigurationProperties(prefix = "hello")
public class HelloServiceProperties {

    private static final String MSG = "world";
    private String msg = MSG;

    public String getMsg() {
	return msg;
    }

    public void setMsg(String msg) {
	this.msg = msg;
    }

}

服务类：

package com.study.spring.spring_boot_starter_hello;
/**
 * 默认服务
 * @author chaozai
 * @date 2018年9月9日
 *
 */
public class HelloService {
    
    private String msg;
    
    public String sayHello(){
	return "Hello "+msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
    
}

自动配置类：

package com.study.spring.spring_boot_starter_hello;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 自动配置类
 * @author chaozai
 * @date 2018年9月9日
 *
 */
@Configuration
@EnableConfigurationProperties(HelloServiceProperties.class)
@ConditionalOnClass(HelloService.class)
@ConditionalOnProperty(prefix="hello",value="enable",matchIfMissing=true)
public class HelloServiceAutoConfiguration {
    @Autowired
    private HelloServiceProperties helloServiceProperties;

    @Bean
    @ConditionalOnMissingBean
    public HelloService helloService(){
	HelloService service = new HelloService();
	service.setMsg(helloServiceProperties.getMsg());
	return service;
    }
}

src\main\resources\META-INF\spring.factories:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.study.spring.spring_boot_starter_hello.HelloServiceAutoConfiguration

验证：

<dependency>
	<groupId>com.study.spring</groupId>
	<artifactId>spring-boot-starter-hello</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</dependency>
package com.study.spring.springboot2.autoconfiguration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import com.study.spring.spring_boot_starter_hello.HelloService;
/**
 * 验证自定义starter-pom
 * @author chaozai
 * @date 2018年9月9日
 *
 */
@SpringBootApplication
@RestController
public class HelloStarterApp {

    @Autowired
    HelloService service;
    
    @GetMapping("/")
    public String hello(){
	return service.sayHello();
    }
    public static void main(String[] args) {
	SpringApplication.run(HelloStarterApp.class, args);
    }
}

结果：

 

 

爱家人，爱生活，爱设计，爱编程，拥抱精彩人生！

qqchaozai
关注
专栏目录
SpringBoot注解最全详解(整合超详细版本)
浩瀚星空
07-30 35万+
使用注解的优势： 1.采用纯java代码，不在需要配置繁杂的xml文件 2.在配置中也可享受面向对象带来的好处 3.类型安全对重构可以提供良好的支持 4.减少复杂配置文件的同时亦能享受到springIoC容器提供的功能 一、注解详解（配备了完善的释义）------(可采用ctrl+F 来进行搜索哦~~~~) @SpringBootAppli...
Spring Boot自动配置原理浅析，华为java开发面试
m0_61043185的博客
03-23 672
Spring Boot的最大的特点就是简化了各种xml配置内容，还记得曾经使用SSM框架时我们在spring-mybatis.xml配置了多少内容吗？数据源、连接池、会话工厂、事务管理···，而现在Spring Boot告诉你这些都不需要了，一切交给它的自动配置吧！所以现在能大概明白什么是Spring Boot的自动配置了吗？简单来说就是用注解来对一些常规的配置做默认配置，简化xml配置内容，使你的项目能够快速运行。
spring boot注解
超帅哥哥的人生巅峰
12-13 1403
Spring Boot 优于Spring mvc ,SSM,SSH 的一个亮点就是他使用了好多的注解。@Autowired 这个注解的作用是将其他的类，接口引入，类似于之前的类的初始化等，用这个注解，类中或接口的方法就可以直接调用了。这个注解和@Inject，@Resource 作用类似，都能注入类， 接口，但是区别我就不知道了。@RestController这个注解的作用是告诉Servlet 这个
No auto configuration classes found in META-INF/spring.factories 解决
最新发布
houmingwei的博客
09-21 257
在使用idea的build artifacts 功能进行打包的时候，发现打出的jar包在运行会报错，使用右边的maven指令 package打出的却能够正常运行。后来发现打包时选择将依赖的包 放到同一目录方式打出的包能够正常运行。具体原因尚不太清楚，但是能用就行。
Spring Boot 注解大全
鄢秋实的博客
04-25 890
1、注解大全 @SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan：让springBoot扫描到Configuration类并把它加入到程序上下文。 @Configuration： 等同于spring的XML配置文件；使用Java代码可以检查类型安...
springboot注解（全）
zhaoshuangjian
04-15 6916
Spring Boot是一个快速开发框架，快速的将一些常用的第三方依赖整合（通过Maven子父亲工程的方式），简化xml配置，全部采用注解形式，内置Http服务器（Jetty和Tomcat），最终以Java应用程序进行执行。
SpringBoot注解汇总
qq_45515347的博客
07-26 283
一些常用的注解总结
Spring Boot 自动配置之条件注解浅析
08-26
Spring Boot 自动配置之条件注解浅析 Spring Boot 提供了自动配置的机制，通过大量的条件注解来实现自动化配置。条件注解是指在特定条件下创建特定的Bean，例如，在某些系统变量下创建Bean，或者只有在某个Bean创建...
浅析SpringBoot自动化配置原理实现
08-19
Spring Boot 的自动配置类通常会使用 `@Conditional` 注解，比如 `@ConditionalOnClass` 和 `@ConditionalOnBean`，这些注解用于判断类路径中是否存在某个类或某个 Bean，如果满足条件，则自动配置相应的 Bean。...
Spring Boot事件机制浅析
No_Showbo的博客
02-27 664
spring事件机制使用，以及源码浅析
SpringBoot核心注解
热门推荐
Ein的博客
03-06 3万+
1.@SpringBootApplication* 用于Spring主类上最最最核心的注解，自动化配置文件，表示这是一个SpringBoot项目，用于开启SpringBoot的各项能力。 相当于@SpringBootConfigryation、@EnableAutoConfiguration、@ComponentScan三个注解的组合。 2.@EnableAutoConfiguration ...
SpringBoot注解详解
HongYu012的博客
03-24 3970
一、简介 基于 SpringBoot 平台开发的项目数不胜数，与常规的基于Spring开发的项目最大的不同之处，SpringBoot 里面提供了大量的注解用于快速开发，而且非常简单，基本可以做到开箱即用! 那 SpringBoot 为开发者提供了多少注解呢?我们该如何使用? 针对此问题，小编特意对其进行了一番整理，内容如下，个人感觉还是比较清晰的，今天我们就一起来整一整每个注解的含义和用法，以免踩坑! 二、注解总结 2.1.SpringMVC 相关注解 @Controller 通常用于修饰.
SpringBoot注解最全详解
jack
07-11 251
转 SpringBoot注解最全详解(整合超详细版本) 置顶 ...
spring boot常用注解
Smile0305的博客
06-07 8350
Spring Boot 常用注解常见注解1. @SpringBootApplication 申明让spring boot自动给程序进行必要的配置， 等价于以默认属性使用@Configuration，@EnableAutoConfiguration和@ComponentScan2. @Configuration 相当于把该类作为spring的xml配置文件中的，作用为：配置spring容器(应用上下...
SpringBoot注解大全（超详细）
weixin_55772633的博客
07-23 1万+
是一个注解，它是 Spring Boot 应用的入口注解，用于表示一个应用程序的主类。这个组合注解简化了 Spring Boot 应用的配置，可以减少开发者的工作量。：通过启用 Spring Boot 的自动配置机制，根据项目的依赖和配置信息来自动配置应用程序。@SpringBootApplication详细可参考------>等注解标记的类），将它们注册为 Spring 的组件。注解标记的方法，用于定义 Bean 对象。：标记该类是一个配置类，其中可能包含用。注解放置在项目的主类上。
SpringBoot(一)——注解配置
weixin_44240370的博客
05-12 7780
为文章目录一、简介1、概述2、特性3、四大核心二、搭建环境三、入门小程序--HelloWorld四、配置文件1、YML文件2、YML语法<1>、基本语法<2>、值的写法(1)、字面量(数字、字符串、布尔)(2)、对象、Map(3)、数组(List, Set)(4)、简单实现、基于以上的语法3、配置文件注入<1>、@PropertySource<2>、...
【SpringBoot 自动配置】-EnableAutoConfiguration 注解
qq_33827423的博客
02-21 1393
续接上回与,在前面笔者分析了在 SpringBoot 自动装配中的最重要的两个注解类，@Condition与哎~说到这里，那首先我们跟随笔者一起先回忆一下这两个注解的在 SpringBoot 当中充当什么角色呢？
SpringBoot自动配置
2401_82742105的博客
08-18 1183
1、创建实体类//2、创建注解@Target({ElementType.TYPE, ElementType.METHOD})//可以修饰在类与方法上@Retention(RetentionPolicy.RUNTIME)//注解生效节点runtime@Documented//生成文档//设置此注解的属性redis.clients.jedis.Jedis3、创建一个条件类继承Condition重写matches方法//2.需求： 导入通过注解属性值value指定坐标后创建Bean。
深入探讨Spring Boot自动配置原理及源码常见注解拾遗
本文主要讨论了Spring Boot自动配置的原理，主要分为三个部分：SpringBoot源码常见注解解析、SpringBoot启动过程以及SpringBoot自动配置原理。第一部分主要讨论了SpringBoot中经常使用到的注解，为后续理解源码提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qqchaozai

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值