SpringBoot源码最全解析

最新推荐文章于 2024-03-15 14:05:54 发布
最新推荐文章于 2024-03-15 14:05:54 发布
阅读量902 收藏 6
点赞数 1
分类专栏： Java源码 Spring 文章标签： java spring spring boot servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Apandam/article/details/114198782
版权

SpringBoot源码

自动配置原理
SpringBoot的核心注解@SpringBootApplication
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

@SpringBootApplication是由@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan合成的

@SpringBootConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

@SpringBootConfiguration表示就是一个配置类

@ComponentScan
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {

@ComponentScan就是spring中的包扫描注解

@EnableAutoConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

  1. @AutoConfigurationPackage

    @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class) //给容器导入一个组件
public @interface AutoConfigurationPackage {

    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

   @Override
   public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
       //将当前主程序指定的包名注册进来
      register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
   }

  2. @Import(AutoConfigurationImportSelector.class)

    @Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
   }
    //给容器导入组件
   AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
   return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

    //获取到所有需要导入的组件
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
->
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
->
    return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
->
    //得到所有的组件
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {

    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

//从META-INF/spring.factories中加载
//默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);

    spring-boot-autoconfigure-2.4.2.jar下META-INF/spring.factories中写死了springboot一启动就要给容器中加载的所有配置类

    # Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.neo4j.Neo4jAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration,\
org.springframework.boot.autoconfigure.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration
静态资源配置原理

SpringMVC功能的自动配置类WebMvcAutoConfiguration

//默认是生效的
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

//配置文件的相关属性和xxx进行了绑定
//WebMvcProperties==spring.mvc，ResourceProperties==spring.resources，WebProperties==spring.web
@SuppressWarnings("deprecation")
	@Configuration(proxyBeanMethods = false)
	@Import(EnableWebMvcConfiguration.class)
	@EnableConfigurationProperties({ WebMvcProperties.class,
			org.springframework.boot.autoconfigure.web.ResourceProperties.class, WebProperties.class })
	@Order(0)
	public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {

//配置类只有一个有参构造器，所有参数的值都会从容器中找
public WebMvcAutoConfigurationAdapter(WebProperties webProperties, WebMvcProperties mvcProperties,
				ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
				ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
				ObjectProvider<DispatcherServletPath> dispatcherServletPath,
				ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
			this.mvcProperties = mvcProperties;
			this.beanFactory = beanFactory;
			this.messageConvertersProvider = messageConvertersProvider;
			this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
			this.dispatcherServletPath = dispatcherServletPath;
			this.servletRegistrations = servletRegistrations;
			this.mvcProperties.checkConfiguration();
		}
资源处理的默认规则
# 禁用所有静态资源规则
spring:
  web:
    resources:
      add-mappings: false

		@Override
		protected void addResourceHandlers(ResourceHandlerRegistry registry) {
			super.addResourceHandlers(registry);
			if (!this.resourceProperties.isAddMappings()) {
				logger.debug("Default resource handling disabled");
				return;
			}
			ServletContext servletContext = getServletContext();
            //webjars的规则
			addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
            //静态资源的处理规则
			addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
             //this.resourceProperties.getStaticLocations()得到默认的静态资源配置位置
		registration.addResourceLocations(this.resourceProperties.getStaticLocations());
				if (servletContext != null) {
					registration.addResourceLocations(new ServletContextResource(servletContext, SERVLET_LOCATION));
				}
			});
		}

public static class Resources {
   //默认的静态资源配置位置
   private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
         "classpath:/resources/", "classpath:/static/", "classpath:/public/" };

   /**
    * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
    * /resources/, /static/, /public/].
    */
   private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
欢迎页的处理规则
//HandlerMapping：处理器映射。保存了每个Handler能处理哪些请求		
@Bean
		public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
				FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            //创建WelcomePageHandlerMapping的时候说明了
			WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
					new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
					this.mvcProperties.getStaticPathPattern());
			welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
			welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
			return welcomePageHandlerMapping;
		}

WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
			ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
		if (welcomePage != null && "/**".equals(staticPathPattern)) {
            //要用欢迎页功能，必须是/**
			logger.info("Adding welcome page: " + welcomePage);
			setRootViewName("forward:index.html");
		}
		else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {		
            //调用Controller
			logger.info("Adding welcome page template: index");
			setRootViewName("index");
		}
	}
请求映射
Rest风格（使用HTTP请求方式动词来表示对资源的操作）
	@Bean
	@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
	//默认不是开启的
	@ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
	public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
		return new OrderedHiddenHttpMethodFilter();
	}

# 开区Rest风格功能
spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true
Rest风格原理（表单提交）
  • 表单提交会带上_method=PUT(DELETE)
  • 请求过来被HiddenHttpMethodFilter拦截
    • 请求是否正常，并且是POST
    • 获取到_method的值
    • 兼容以下请求：PUT、DELETE、PATCH
    • 原生request(post)，包装模式requestWrapper重写了getMethod()方法，返回的是传入的值
    • 过滤器链放行的时候用的是wrapper，以后方法调用getMethod()是调用requestWrapper的
public class HiddenHttpMethodFilter extends OncePerRequestFilter {

	private static final List<String> ALLOWED_METHODS =
			Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),
					HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));

	/** Default method parameter: {@code _method}. */
	public static final String DEFAULT_METHOD_PARAM = "_method";
    
    
    @Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {

		HttpServletRequest requestToUse = request;
		//表单提交的时候方式必须是POST
		if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
            //获取到_method的值
			String paramValue = request.getParameter(this.methodParam);
			if (StringUtils.hasLength(paramValue)) {
				String method = paramValue.toUpperCase(Locale.ENGLISH);
                //允许以下请求PUT、DELETE、PATCH
                //private static final List<String> ALLOWED_METHODS =Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));
				if (ALLOWED_METHODS.contains(method)) {
                    //这里包装成了HttpMethodRequestWrapper
					requestToUse = new HttpMethodRequestWrapper(request, method);
				}
			}
		}

		filterChain.doFilter(requestToUse, response);
	}
请求映射原理

调用链

HttpServlet doGet()和doPost()
    ->FrameworkServlet重写了HttpServlet中的doGet()和doPost()，其中都是调用processRequest(request, response);
		->doService(request, response)抽象方法
            ->DispatcherServlet实现了doService(request, response)方法
            	->doDispatch(request, response);

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
                  //检查是否文件上传请求
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
                 // 寻找当前请求使用哪个handler(controller)来处理
				mappedHandler = getHandler(processedRequest);
            }

在这里插入图片描述

	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
            //遍历所有的handlerMappings
			for (HandlerMapping mapping : this.handlerMappings) {
                //得到对应的handler
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}
  • SpringBoot自动配置了欢迎页的WelcomePageHandlerMapping。访问/能访问到index.html
  • SpringBoot自动配置了默认的RequestMappingHandlerMapping。
  • 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息
    • 如果有就找到这个请求对应的Handler
    • 如果没有就是下一个HandlerMapping
  • 我们需要一些自定义的映射处理，也可以给容器中放置HandlerMapping
请求参数处理
请求参数处理原理
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 寻找当前请求使用哪个handler(controller)来处理
        mappedHandler = getHandler(processedRequest);

        // 为当前Handler找到一个适配器
        //RequestMappingHandlerAdapter
        //HandlerFunctionAdapter
        //HttpRequestHandlerAdapter
        //SimpleControllerHandlerAdapter
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        
        //执行目标方法
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

    }

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
            //便利所有的handlerAdapters
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}

//执行链
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
	->return handleInternal(request, response, (HandlerMethod) handler);
		->mav = invokeHandlerMethod(request, response, handlerMethod);
			->invocableMethod.invokeAndHandle(webRequest, mavContainer);
				//真正执行目标方法
				->Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
					//获取方法所有的参数值
					->Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
						//利用反射执行方法
						->return doInvoke(args);
参数解析器：确定将要执行的目标方法的每一个参数的值是什么

SpringMVC目标方法能写多少种参数类型，取决于参数解析器

在这里插入图片描述

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		//得到方法参数信息
		MethodParameter[] parameters = getMethodParameters();
		if (ObjectUtils.isEmpty(parameters)) {
			return EMPTY_ARGS;
		}
		
		Object[] args = new Object[parameters.length];
    	//遍历每个参数
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			args[i] = findProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
            //判断参数解析器是否支持当前参数的解析
			if (!this.resolvers.supportsParameter(parameter)) {
				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
			}
			try {
                //解析参数
				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
			}
			catch (Exception ex) {
				// Leave stack trace for later, exception may actually be resolved and handled...
				if (logger.isDebugEnabled()) {
					String exMsg = ex.getMessage();
					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
						logger.debug(formatArgumentError(parameter, exMsg));
					}
				}
				throw ex;
			}
		}
		return args;
	}

//挨个判断所有参数解析器哪个支持解析当前参数
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
				if (resolver.supportsParameter(parameter)) {
					result = resolver;
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}
复杂参数请求处理

Map、Model（map、model里面的数据会被放在request请求域中）、RedirectAttributes（重定向携带数据）、

ServletResponse（response）

//Map、Model类型的参数，会返回mavContainer.getModel();
public class ModelAndViewContainer {

	private boolean ignoreDefaultModelOnRedirect = false;

	@Nullable
	private Object view;
    
	//BindingAwareModelMap既是map也是model
	private final ModelMap defaultModel = new BindingAwareModelMap();

protected void exposeModelAsRequestAttributes(Map<String, Object> model,
			HttpServletRequest request) throws Exception {
		//将model中的数据全部放到请求域中
		model.forEach((name, value) -> {
			if (value != null) {
				request.setAttribute(name, value);
			}
			else {
				request.removeAttribute(name);
			}
		});
	}
自定义参数绑定原理
//WebDataBinder：web数据绑定器，将请求参数的值绑定到指定的JavaBean中
//WebDataBinder利用它里面的Converters将请求数据转换成指定的数据类型，再次封装到JavaBean中
WebDataBinder binder = binderFactory.createBinder(webRequest,attribute,name);
返回值处理
返回值解析器：确定方法的返回值有多少种

在这里插入图片描述

返回值解析器原理
  • 返回值解析器判断是否支持这种类型的返回值
  • 返回值解析器调用handlerReturnValue进行处理
  • RequestResponseBodyMethodProcessor可以处理返回值标了@ResponseBody注解的
    • 利用MessageConverters进行处理，将数据写为json
      • 1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
      • 2、服务器最终根据自己的自身能力，决定服务器能生产出什么样内容类型的数据
      • 3、挨个遍历所有容器底层的HttpMessageConverter
//RequestResponseBodyMethodProcessor.class
@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

		mavContainer.setRequestHandled(true);
		ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
		ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

		// Try even with null return value. ResponseBodyAdvice could get involved.
        //使用消息转换器进行写出操作
		writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
	}
HttpMessageConverter

看是否支持将此Class类型的对象，转为MediaType类型的数据

在这里插入图片描述

内容协商原理
  • 判断当前响应头中是否已经有明确的媒体对象
MediaType contentType = outputMessage.getHeaders().getContentType();
  • 获取客户端、浏览器支持接收的内容类型（获取客户端Accept请求头字段）
List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);

//contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略
  • 获取服务器能够产生的内容类型
    • 遍历循环所有当前系统的MessageConverter，看谁支持操作当前对象
    • 找到支持操作当前对象的converter，把converter支持的媒体类型统计出来
List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);

for (HttpMessageConverter<?> converter : this.messageConverters) {
				if (converter instanceof GenericHttpMessageConverter && targetType != null) {
					if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) {
						result.addAll(converter.getSupportedMediaTypes());
					}
				}
				else if (converter.canWrite(valueClass, null)) {
					result.addAll(converter.getSupportedMediaTypes());
				}
			}
  • 将客户端、浏览器支持的内容类型与服务器能够提供的内容类型进行匹配
for (MediaType requestedType : acceptableTypes) {
				for (MediaType producibleType : producibleTypes) {
					if (requestedType.isCompatibleWith(producibleType)) {
						mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
					}
				}
			}
  • 排序，并得到最佳匹配
MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
			for (MediaType mediaType : mediaTypesToUse) {
				if (mediaType.isConcrete()) {
					selectedMediaType = mediaType;
					break;
				}
				else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
					selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
					break;
				}
			}
  • 用支持将对象转为最佳匹配媒体类型的converter，调用它进行转换
for (HttpMessageConverter<?> converter : this.messageConverters) {
				GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
						(GenericHttpMessageConverter<?>) converter : null);
				if (genericConverter != null ?
						((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
						converter.canWrite(valueType, selectedMediaType)) {
					body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
							(Class<? extends HttpMessageConverter<?>>) converter.getClass(),
							inputMessage, outputMessage);
					if (body != null) {
						Object theBody = body;
						LogFormatUtils.traceDebug(logger, traceOn ->
								"Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
						addContentDispositionHeader(inputMessage, outputMessage);
						if (genericConverter != null) {
							genericConverter.write(body, targetType, selectedMediaType, outputMessage);
						}
						else {
							((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
						}
					}
					else {
						if (logger.isDebugEnabled()) {
							logger.debug("Nothing to write: null body");
						}
					}
					return;
				}
			}
开启浏览器参数方式的内容协商功能
spring:
  mvc:
    contentnegotiation:
      favor-parameter: true

/**
		 * Whether a request parameter ("format" by default) should be used to determine
		 * the requested media type.
		 */
		//请求中带format参数
		private boolean favorParameter = false;
视图解析原理流程

  • 目标方法处理的过程中，所有的数据都会被放在ModelAndViewContainer里面。包括数据和视图地址

  • 任何目标方法执行完成以后都会返回ModelAndView(数据和视图地址)

  • //DispatcherServlet.class
//处理派发结果，页面该如何响应
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    • 视图解析器

在这里插入图片描述

  • //得到view对象
view = resolveViewName(viewName, mv.getModelInternal(), locale, request);

  • //遍历所有的视图解析器看谁能处理
for (ViewResolver viewResolver : this.viewResolvers) {
				View view = viewResolver.resolveViewName(viewName, locale);
				if (view != null) {
					return view;
				}
			}

  • //视图对象调用自定义的render进行页面渲染工作
view.render(mv.getModelInternal(), request, response);
拦截器原理

  • 根据当前请求，找到HandlerExecutionChain(可以处理请求的handler以及handler的所有拦截器)

    mappedHandler = getHandler(processedRequest);

  • 执行目标方法前会做判断

if (!mappedHandler.applyPreHandle(processedRequest, response)) {
   return;
}

  • boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
   for (int i = 0; i < this.interceptorList.size(); i++) {
      HandlerInterceptor interceptor = this.interceptorList.get(i);
       //顺序执行所有拦截器的preHandle方法
       //如果当前拦截器preHandle方法返回为true，则执行下一个拦截器的preHandle
       //如果当前拦截器preHandle方法返回为false，执行triggerAfterCompletion方法
      if (!interceptor.preHandle(request, response, this.handler)) {
         triggerAfterCompletion(request, response, null);
         return false;
      }
      this.interceptorIndex = i;
   }
   return true;
}

  • void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
   for (int i = this.interceptorIndex; i >= 0; i--) {
      HandlerInterceptor interceptor = this.interceptorList.get(i);
      try {
          //倒叙执行所有已经执行了的拦截器的afterCompletion方法
         interceptor.afterCompletion(request, response, this.handler, ex);
      }
      catch (Throwable ex2) {
         logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
      }
   }
}

  • 如果任何一个拦截器返回false，直接跳出不执行目标方法

  • 所有拦截器都返回true，才执行目标方法

  • 方法执行完成后

mappedHandler.applyPostHandle(processedRequest, response, mv);


//倒叙执行所有拦截器的postHandle方法
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			interceptor.postHandle(request, response, this.handler, mv);
		}
	}
  • 前面的步骤有任何异常都会直接倒叙执行拦截器的afterCompletion方法
  • 页面渲染完成以后也会倒叙执行拦截器的afterCompletion方法

在这里插入图片描述

Polarisy丶
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot源码 TargetSource解析
08-25
主要介绍了Springboot源码 TargetSource解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot源码分析
weixin_44044929的博客
03-08 5011
快速开发底层原理 SpringBoot核心理念 能够实现帮助开发者快速的整合第三方框架(Spring、Mybatis、hibernate) 原理:Maven依赖封装整合和自定义starter. 完全去除XML配置，采用注解形式 原理:SpringBoot其实根据 Spring 体系原生的注解实现包装 不需要外部容器，内嵌入服务器(Tomcat) . 原理:Java语言创建tomcat服务器，让后将本地class文件交给tomcat加载。 案例:注解方式启动MVC将SpringMVC交给内部tomcat运行
SpringBoot 核心源码解读
踩踩踩从踩的博客
02-15 7699
前面文章对于springboot得基本使用以及stater机制 以及autoconfig 做了一个解读，如何手写一个starter的包，对于 自动装配 解读，有了个大概的思维；这篇文章继续讲解SpringBoot的核心源码 ，然后深入的解析整个Springboot怎么快速的构建项目 并管理我们的依赖jar包等等。
Springboot启动源浅析
最新发布
liuzhenji的博客
03-15 405
spring启动
Spring Boot源码分析
YINZONGCHAO的博客
12-31 225
1.通过源码分析SpringBoot的启动流程.首先找到启动程序的入口,从run方法点进去. @SpringBootApplication public class OrderApplication extends SpringBootServletInitializer { public static void main(String[] args) { SpringApplication.run(OrderApplication.class); } /**
SpringBoot高级_02_SpringBoot原理深入及源码剖析
qq_52922453的博客
06-07 196
因此 在定义项目包结构时，要求定义的包结构非常规范，项目主程序启动类要定义在最外层的根目录位置，然后在根目录位置内部建立子包和类进行业务开发，这样才能够保证定义的类能够被组件扫描器扫描。项目中加入相关依赖启动器后，基本上不需要任何配置就可以运行程序，当然，我们也可以对这些自动配置类中默认的配置进行更改。自动配置类就会生效，打开该自动配置类会发现，在该配置类中通过全注解配置类的方式对Spring MVC。包依赖的时候，自动为我们配置一些组件的相关配置，我们无需配置或者只需要少量配置就能运行编写的项目。
Spring源码深度解析 Spring Boot 体系原理总结
勤劳的搬运工
03-22 1092
Spring Boot 特点如下： 创建独立的 Spring 应用程序； 嵌入的 Tomcat ，无须部署 WAR 文件； 简化 Maven 配置； 自动配置 Spring; 提供生产就绪型功能，如指标、健康检查和外部配置； 绝对没有代码生成，以及对 XML 没有配置要求 首先搭建一个 maven 工程， pom 如下： 然后建立一个 controller 类 最后再加入启动整个项目的 main 函数 最后启动main函数并在浏览器中输入localhost:8080 第一个 Starter spr
Springboot源码 AbstractAdvisorAutoProxyCreator解析
08-25
主要介绍了Springboot源码 AbstractAdvisorAutoProxyCreator解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot源码解析视频
02-19
最新版的springboot源码解析视频，地址亲测有效，失效了请联系我。 某某学院springboot源码解析视频。
第三节-springboot源码解析-王炸篇.pdf
11-11
，spring注解 热身，springboot 自动装配原理
SpringBoot源码深度解析（一）：SpringBoot的自动配置原理详解
欢迎来到Jimmy的博客
09-22 8753
SpringBoot流行之前，程序员大多是用SSM框架整合来进行WEB后端开发。这种方式非常麻烦，需要手动引入大量的包，还要配置很多XML文件，光是搭建环境就需要很久。随着“约定大于配置”理念的流行，SpringBoot随之兴起，它大大简化了web开发的流程，可以让初学者快速上手。SpringBoot的核心理念大致有3点：1、帮助开发者快速整合第3方框架，原理是maven依赖封装和自定义的Starter。2、完全去除XML，采用纯注解的方式。.........
这应该是最全的Spring Boot启动原理源码剖析了
weixin_51702416的博客
07-29 2774
至此咱们的spring启动原理源码就讲完了，在此小编也整理了很多springboot资料来供大家学习，了解更多Java知识可关注微信公众号“老周扯IT”httpshttpshttpshttpshttpshttpshttps。
SpringBoot原理深入及源码剖析
weixin_42740360的博客
04-19 2942
目录 1、SpringBoot原理深入及源码剖析 2、依赖管理 问题：（1）为什么导入dependency时不需要指定版本？ 2.1．spring-boot-starter-parent依赖 ​ 2）问题2： spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理，那么项目运行依赖的JAR包是从何而来的？ 2. spring-boot-starter-web依赖 3.自动配置 问题：Spring Boot到底是如何进行自动配置的，都把哪些组件进行了自动
1、SpringBoot解析启动类之源码分析
qq_36851469的博客
01-31 822
是一种服务发现机制，JDK自带有来实现这种机制，当然更为出名的是Spring的（Dubbo也有自己的SPI实现哦），具体实现方式上都大同小异。第二步：parse方法解析组件添加到configurationClasses集合中。Springboot 自动化配置。AutoConfigurationImportSelector注解的解析。try {// 启动类执行else {...
springboot源码解析
qq_52219290的博客
04-30 1247
如果注入了就从容器获取，并将包名赋值给他的basePackages属性，然后执行这块的时候其实是并没有注册的，所以直接执行else。spi：当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。也就是这个包下的只要使用注入容器相关的注解，就会被放入到IOC容器当中。
【源码解析】SpringBoot的源码深入分析
秋装什么的博客
02-28 453
【源码解析】SpringBoot的源码深入分析
Spring Boot：基本应用，源码解析，数据访问和视图技术
qq_40286307的博客
11-07 737
SpringBoot 基本应用 约定优于配置 约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式。 本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为 User 的类，那么数据库中对应的表就会默认命名为 User。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进行开发
SpringBoot启动过程(底层源码深度剖析)
ZhzZhi的博客
04-28 1979
SpringBoot启动过程 本文所使用的springboot版本：2.1.8.RELEASE 开发环境：JDK8 概述： Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》。Spring是为了解决企业级应用开发的复杂性而创建的，使用Spring可以让简单的JavaBean实现之前只有EJB才能完成的事情。...
SpringBoot之事务源码解析
qq_36851469的博客
10-16 1476
初始化bean过程中涉及的beanPostProcessor之InfrastructureAdvisorAutoProxyCreator作为服务启动过程中解析@Transaction注解注释的方法或者类。通过调用其InfrastructureAdvisorAutoProxyCreator之After相关的初始化后置处理器。：有资格的;合格的;具备条件的。
springboot源码解析pdf
06-25
Springboot源码解析PDF是一本深入解析Springboot框架的技术书籍，涵盖了Springboot的背景、原理、设计思路、运行机制、开发实践等方面。全书主要分为三部分：第一部分介绍Springboot的基础知识，包括Spring框架的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值