spring配置和注解开发原理

SpringBootApplication注解原理及代码详解1、SpringBoot 启动main()@SpringBootApplicationpublic class TomcatdebugApplication {public static void main(String[] args) {SpringApplication.run(TomcatdebugApplication.class, args);}}1.1 @SpringBootApplication 注解，其实主要是@ComponentScan,@EnableAutoConfiguration,@SpringBootConfiguration三个注解@ComponentScan 注解：spring⾥有四⼤注解：@Service,@Repository,@Component,@Controller⽤来定义⼀个bean.@ComponentScan注解就是⽤来⾃动扫描被这些注解标识的类，最终⽣成ioc容器⾥的bean．可以通过设置@ComponentScan　basePackages，includeFilters，excludeFilters属性来动态确定⾃动扫描范围，类型已经不扫描的类型．　默认情况下:它扫描所有类型，并且扫描范围是@ComponentScan注解所在配置类包及⼦包的类@SpringBootConfiguration 注解：@SpringBootConfiguration继承⾃@Configuration，⼆者功能也⼀致，标注当前类是配置类，并会将当前类内声明的⼀个或多个以@Bean注解标记的⽅法的实例纳⼊到spring容器中，并且实例名就是⽅法名。

demo 说明：（1）注⼊spring ioc bean@SpringBootConfigurationpublic class Config {@Beanpublic Map createMap(){Map map = new HashMap();map.put("username","gxz");map.put("age",27);return map;}}(2)调⽤：public static void main( String[] args ){//⽅式1 获取contextConfigurableApplicationContext context = SpringApplication.run(App.class, args);context.getBean(Runnable.class).run();context.getBean("createMap"); //注意这⾥直接获取到这个⽅法beanint age = (int) map.get("age");System.out.println("age=="+age);//⽅式2. 使⽤@Autowired注解，应⽤bean// @Autowired// Map createMap}@EnableAutoConfiguration 注解@EnableAutoConfiguration作⽤：从classpath中搜索所有的META-INF/spring.factories配置⽂件，然后将其中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的value加载到spring容器中。

spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。

借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。

这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。

springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。

2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。

(3)调用处理器：dispatcherservlet将请求提交到controller。

(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。

3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。

在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。

（2）handlermappingUSB：能够完成客户请求到controller映射。

（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。

Spring中异步注解@Async的使⽤、原理及使⽤时可能导致的问题及解决⽅法前⾔其实最近都在研究事务相关的内容，之所以写这么⼀篇⽂章是因为前⾯写了⼀篇关于循环依赖的⽂章：《》然后，很多同学碰到了下⾯这个问题，添加了Spring提供的⼀个异步注解@Async循环依赖⽆法被解决了，下⾯是⼀些读者的留⾔跟群⾥同学碰到的问题：本着讲⼀个知识点就要讲明⽩、讲透彻的原则，我决定单独写⼀篇这样的⽂章对@Async这个注解做⼀下详细的介绍，这个注解带来的问题远远不⽌循环依赖这么简单，如果对它不够熟悉的话建议慎⽤。

⽂章要点@Async的基本使⽤这个注解的作⽤在于可以让被标注的⽅法异步执⾏，但是有两个前提条件配置类上添加@EnableAsync注解需要异步执⾏的⽅法的所在类由Spring管理需要异步执⾏的⽅法上添加了@Async注解我们通过⼀个Demo体会下这个注解的作⽤吧第⼀步，配置类上开启异步：@EnableAsync@Configuration@ComponentScan("com.dmz.spring.async")public class Config {}第⼆步，[code]@Component // 这个类本⾝要被Spring管理public class DmzAsyncService { @Async // 添加注解表⽰这@Component // 这个类本⾝要被Spring管理public class DmzAsyncService {@Async // 添加注解表⽰这个⽅法要异步执⾏public void testAsync(){try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("testAsync invoked");}}第三步，测试异步执⾏public class Main {public static void main(String[] args) {AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);DmzAsyncService bean = ac.getBean(DmzAsyncService.class);bean.testAsync();System.out.println("main函数执⾏完成");}}// 程序执⾏结果如下：// main函数执⾏完成// testAsync invoked通过上⾯的例⼦我们可以发现，DmzAsyncService中的testAsync⽅法是异步执⾏的，那么这背后的原理是什么呢？我们接着分析原理分析我们在分析某⼀个技术的时候，最重要的事情是，⼀定⼀定要找到代码的⼊⼝，像Spring这种都很明显，⼊⼝必定是在@EnableAsync这个注解上⾯，我们来看看这个注解⼲了啥事（本⽂基于5.2.x版本）@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 这⾥是重点，导⼊了⼀个ImportSelector@Import(AsyncConfigurationSelector.class)public @interface EnableAsync {// 这个配置可以让程序员配置需要被检查的注解，默认情况下检查的就是@Async注解Class<? extends Annotation> annotation() default Annotation.class;// 默认使⽤jdk代理boolean proxyTargetClass() default false;// 默认使⽤Spring AOPAdviceMode mode() default AdviceMode.PROXY;// 在后续分析我们会发现，这个注解实际往容器中添加了⼀个// AsyncAnnotationBeanPostProcessor，这个后置处理器实现了Ordered接⼝// 这个配置主要代表了AsyncAnnotationBeanPostProcessor执⾏的顺序int order() default Ordered.LOWEST_PRECEDENCE;}上⾯这个注解做的最重要的事情就是导⼊了⼀个AsyncConfigurationSelector，这个类的源码如下：public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME ="org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";@Override@Nullablepublic String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {// 默认会使⽤SpringAOP进⾏代理case PROXY:return new String[] {ProxyAsyncConfiguration.class.getName()};case ASPECTJ:return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}这个类的作⽤是像容器中注册了⼀个ProxyAsyncConfiguration，这个类的继承关系如下：我们先看下它的⽗类AbstractAsyncConfiguration，其源码如下：@Configurationpublic abstract class AbstractAsyncConfiguration implements ImportAware {@Nullableprotected AnnotationAttributes enableAsync;@Nullableprotected Supplier<Executor> executor;@Nullableprotected Supplier<AsyncUncaughtExceptionHandler> exceptionHandler;// 这⾥主要就是检查将其导⼊的类上是否有EnableAsync注解// 如果没有的话就报错@Overridepublic void setImportMetadata(AnnotationMetadata importMetadata) {this.enableAsync = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableAsync.class.getName(), false));if (this.enableAsync == null) {throw new IllegalArgumentException("@EnableAsync is not present on importing class " + importMetadata.getClassName());}}// 将容器中配置的AsyncConfigurer注⼊// 异步执⾏嘛，所以我们可以配置使⽤的线程池// 另外也可以配置异常处理器@Autowired(required = false)void setConfigurers(Collection<AsyncConfigurer> configurers) {if (CollectionUtils.isEmpty(configurers)) {return;}if (configurers.size() > 1) {throw new IllegalStateException("Only one AsyncConfigurer may exist");}AsyncConfigurer configurer = configurers.iterator().next();this.executor = configurer::getAsyncExecutor;this.exceptionHandler = configurer::getAsyncUncaughtExceptionHandler;}}再来看看ProxyAsyncConfiguration这个类的源码@Configuration@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {@Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE)public AsyncAnnotationBeanPostProcessor asyncAdvisor() {AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();// 将通过AsyncConfigurer配置好的线程池跟异常处理器设置到这个后置处理器中bpp.configure(this.executor, this.exceptionHandler);Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass("annotation"); if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) { bpp.setAsyncAnnotationType(customAsyncAnnotation);}bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));return bpp;}}这个类本⾝是⼀个配置类，它的作⽤是向容器中添加⼀个AsyncAnnotationBeanPostProcessor。

springboot⾃动配置原理以及spring.factories⽂件的作⽤详解⽬录⼀、springboot ⾃动配置原理⼆、spring.factories⽂件的作⽤spring.factories 的妙⽤什么是 SPI 机制？Spring Boot 中的 SPI 机制Spring Factories 实现原理是什么？Spring Factories 在 Spring Boot 中的应⽤⼀、springboot ⾃动配置原理先说说我们⾃⼰的应⽤程序中Bean加⼊容器的办法：package com.ynunicom.dc.dingdingcontractapp;import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;/*** @author jinye.Bai*/@SpringBootApplication(scanBasePackages ={"com.ynunicom.dc.dingdingcontractapp"})public class DingdingContractAppApplication {public static void main(String[] args) {SpringApplication.run(DingdingContractAppApplication.class, args);}}我们在应⽤程序的⼊⼝设置了 @SpringBootApplication标签，默认情况下他会扫描所有次级⽬录。

如果增加了 scanBasePackages属性，就会扫描所有被指定的路径及其次级⽬录。

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><!-- 声明扫描包及其⼦包的类，如果发现有组件注解的类，就创建对象并加⼊到容器中去 --><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

spring框架中@PostConstruct的实现原理在spring项⽬经常遇到@PostConstruct注解，⾸先介绍⼀下它的⽤途: 被注解的⽅法，在对象加载完依赖注⼊后执⾏。

此注解是在Java EE5规范中加⼊的，在Servlet⽣命周期中有⼀定作⽤，它通常都是⼀些初始化的操作，但初始化可能依赖于注⼊的其他组件，所以要等依赖全部加载完再执⾏。

与之对应的还有@PreDestroy，在对象消亡之前执⾏，原理差不多，这⾥不做过多介绍。

那么⾸先看下源码注释PostConstruct注释介绍总体概括如上，注意其中⼏个点1. 要在依赖加载后，对象使⽤前执⾏，⽽且只执⾏⼀次，原因在上⾯已经说了。

2. 所有⽀持依赖注⼊的类都要⽀持此⽅法。

⾸先，我们可以看到这个注解是在javax.annotation包下的，也就是java拓展包定义的注解，并不是spring定义的，但⾄于为什么不在java包下，是因为java语⾔的元⽼们认为这个东西并不是java核⼼需要的⼯具，因此就放到扩展包⾥（javax中的x就是extension的意思），⽽spring是⽀持依赖注⼊的，因此spring必须要⾃⼰来实现@PostConstruct的功能。

3. ⽂档中说⼀个类只能有⼀个⽅法加此注解，但实际测试中，我在⼀个类中多个⽅法加了此注解，并没有报错，⽽且都执⾏了，我⽤的是springboot框架。

再往下看，这个注解有⼀些使⽤条件，挑⼀些重点的说⼀下PostConstruct注释规则1. 除了拦截器这个特殊情况以外，其他情况都不允许有参数，否则spring框架会报IllegalStateException；⽽且返回值要是void，但实际也可以有返回值，⾄少不会报错，只会忽略2. ⽅法随便你⽤什么权限来修饰，public、protected、private都可以，反正功能是由反射来实现3. ⽅法不可以是static的，但可以是final的所以，综上所述，在spring项⽬中，在⼀个bean的初始化过程中，⽅法执⾏先后顺序为Constructor > @Autowired > @PostConstruct先执⾏完构造⽅法，再注⼊依赖，最后执⾏初始化操作，所以这个注解就避免了⼀些需要在构造⽅法⾥使⽤依赖组件的尴尬。

Spring技术内幕深入解析Spring架构与设计原理（一）引子缘起已经很久没有写帖子了，现在总算是有点时间写些东西，也算是对自己的一个记录吧。

刚刚完成了一个软件产品，从概念到运营都弄了一下，正在推广当中，虽然还没有能够达到盈亏平衡，但是这个过程，对自己也算是一种历练。

先不管结果如何，好呆走过这么一遭了。

我打算用这个帖子，把自己在这个过程中的一些心得，特别是对Spring新的理解，记录下来。

使用这个帖子的标题，持续下来。

简单来说，自己的软件产品是一个基于互联网的SaaS协同软件平台,操作简单，支持流程定义，管理和多种客户端 -像短信，MSN，智能手机什么的（我这里就不多做什么广告了），也有一个企业版的版本，使用的技术框架是Hibernate + Spring + Wicket，下面是Linux和MySQL，还有云计算的平台的使用，以支持其扩展性，虽然现在还没有可扩展性的需求，但似乎不难从SaaS上，就会想到云计算, 其实，它们真的是天生的一对！关于云计算，自己对这个技术很感兴趣，觉得和开源软件的结合，是很有意思的，因为它们都有基于服务的基因，在云计算平台的使用上，也有一些初步的实践。

云计算是一个很有意思的话题，但在这里主要是想谈Spring，所以对云计算，这里就先不多说了，但非常欢迎有兴趣的朋友和一起另外找地方讨论！回到正题，在我自己的产品中，其中除了Wicket和云计算外，其他都是大家非常熟知的了，像Hibernate, Spring, MySQL什么的。

在这个过程中，发现自己对一些技术点也有了新的认识，最有体会的是Spring。

当然，在这个过程中，更大的收获是对产品开发整个过程的认识，在这点上，真是一言难尽........回到自己还算了解的Spring, 这次我使用的是3.0的代码，所以，有机会也把这些代码读了几遍，比原来的理解要加深了许多，也发现了不少和2.0代码不同的地方，以及自己一些对 Spring的新的理解，这些，就让我就用这个帖子系列，给自己总结一下，也算是对自己以前的那个代码分析的帖子做一个新的交代吧。

spring原理和实现机制Spring框架是一个开源的应用程序框架，它提供了一种简单的方法来构建基于Java的企业级应用程序。

Spring框架的原理和实现机制主要包括：1. 控制反转（IoC）：Spring使用控制反转（Inversion of Control，IoC）来管理应用程序中的对象。

传统的应用程序中，对象的创建和依赖关系管理是由程序员来实现的，而在Spring 中，对象的创建和管理工作由容器来完成。

容器会在应用程序启动时创建对象，并通过依赖注入的方式将对象之间的依赖关系注入到相应的对象中。

2. 依赖注入（DI）：依赖注入是Spring框架的核心机制之一。

它指的是容器在创建对象时，自动将其所依赖的其他对象注入进来。

通过依赖注入，对象之间的解耦程度大大提高，使得应用程序更加灵活、可扩展和可维护。

3. 面向切面编程（AOP）：Spring框架通过面向切面编程（Aspect-Oriented Programming，AOP）来实现横切关注点的模块化。

AOP可以将应用程序的核心逻辑（称为核心关注点）与横切关注点（如日志、事务管理等）分离开来，并通过切面来统一管理这些横切关注点。

4. 核心容器：Spring框架的核心是其容器（Container）。

容器使用BeanFactory接口作为底层容器的基础，并提供了ApplicationContext接口作为更高级的容器接口。

容器负责创建和管理应用程序中的对象，并提供了丰富的配置和管理功能。

5. 层次化的模块化架构：Spring的模块化架构使得开发者可以根据自己的需要选择使用不同的模块。

例如，Spring的核心模块包括IoC容器、AOP框架和BeanFactory等，而其他模块如Spring MVC、Spring Data等则提供了特定领域的解决方案。

6. 轻量级与非侵入性：Spring框架的设计理念是轻量级和非侵入性的。

它不依赖于特定的编程模型，可以与其他技术和框架无缝集成。

Spring@CrossOrigin注解原理实现现实开发中，我们难免遇到跨域问题，以前笔者只知道jsonp这种解决⽅式，后⾯听说spring只要加⼊@CrossOrigin即可解决跨域问题。

本着好奇的⼼⾥，笔者看了下@CrossOrigin 作⽤原理，写下这篇博客。

先说原理：其实很简单，就是利⽤spring的拦截器实现往response⾥添加 Access-Control-Allow-Origin等响应头信息，我们可以看下spring是怎么做的注：这⾥使⽤的spring版本为5.0.6我们可以先往RequestMappingHandlerMapping 的initCorsConfiguration⽅法打⼀个断点，发现⽅法调⽤情况如下如果controller在类上标了@CrossOrigin或在⽅法上标了@CrossOrigin注解，则spring 在记录mapper映射时会记录对应跨域请求映射，代码如下RequestMappingHandlerMappingprotected CorsConfiguration initCorsConfiguration(Object handler, Method method, RequestMappingInfo mappingInfo) {HandlerMethod handlerMethod = createHandlerMethod(handler, method);Class<?> beanType = handlerMethod.getBeanType();//获取handler上的CrossOrigin 注解CrossOrigin typeAnnotation = AnnotatedElementUtils.findMergedAnnotation(beanType, CrossOrigin.class);//获取handler ⽅法上的CrossOrigin 注解CrossOrigin methodAnnotation = AnnotatedElementUtils.findMergedAnnotation(method, CrossOrigin.class);if (typeAnnotation == null && methodAnnotation == null) {//如果类上和⽅法都没标CrossOrigin 注解，则返回⼀个nullreturn null;}//构建⼀个CorsConfiguration 并返回CorsConfiguration config = new CorsConfiguration();updateCorsConfig(config, typeAnnotation);updateCorsConfig(config, methodAnnotation);if (CollectionUtils.isEmpty(config.getAllowedMethods())) {for (RequestMethod allowedMethod : mappingInfo.getMethodsCondition().getMethods()) {config.addAllowedMethod(());}}return config.applyPermitDefaultValues();}将结果返回到了AbstractHandlerMethodMapping#register，主要代码如下CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);if (corsConfig != null) {//会保存handlerMethod处理跨域请求的配置this.corsLookup.put(handlerMethod, corsConfig);}当⼀个跨域请求过来时，spring在获取handler时会判断这个请求是否是⼀个跨域请求，如果是，则会返回⼀个可以处理跨域的handlerAbstractHandlerMapping#getHandlerHandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);//如果是⼀个跨域请求if (CorsUtils.isCorsRequest(request)) {//拿到跨域的全局配置CorsConfiguration globalConfig = this.globalCorsConfigSource.getCorsConfiguration(request);//拿到hander的跨域配置CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);CorsConfiguration config = (globalConfig != null ? bine(handlerConfig) : handlerConfig);//处理跨域（即往响应头添加Access-Control-Allow-Origin信息等），并返回对应的handler对象executionChain = getCorsHandlerExecutionChain(request, executionChain, config);}我们可以看下如何判定⼀个请求是⼀个跨域请求，public static boolean isCorsRequest(HttpServletRequest request) {//判定请求头是否有Origin 属性即可return (request.getHeader(HttpHeaders.ORIGIN) != null);再看下getCorsHandlerExecutionChain 是如何获取⼀个handlerprotected HandlerExecutionChain getCorsHandlerExecutionChain(HttpServletRequest request,HandlerExecutionChain chain, @Nullable CorsConfiguration config) {if (CorsUtils.isPreFlightRequest(request)) {HandlerInterceptor[] interceptors = chain.getInterceptors();chain = new HandlerExecutionChain(new PreFlightHandler(config), interceptors);}else {//只是给执⾏器链添加了⼀个拦截器chain.addInterceptor(new CorsInterceptor(config));}return chain;}也就是在调⽤⽬标⽅法前会先调⽤CorsInterceptor#preHandle，我们观察得到其也是调⽤了corsProcessor.processRequest⽅法，我们往这⾥打个断点processRequest⽅法的主要逻辑如下public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request,HttpServletResponse response) throws IOException {//....//调⽤了⾃⾝的handleInternal⽅法return handleInternal(serverRequest, serverResponse, config, preFlightRequest);}protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response,CorsConfiguration config, boolean preFlightRequest) throws IOException {String requestOrigin = request.getHeaders().getOrigin();String allowOrigin = checkOrigin(config, requestOrigin);HttpHeaders responseHeaders = response.getHeaders();responseHeaders.addAll(HttpHeaders.VARY, Arrays.asList(HttpHeaders.ORIGIN,HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));if (allowOrigin == null) {logger.debug("Rejecting CORS request because '" + requestOrigin + "' origin is not allowed");rejectRequest(response);return false;}HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);List<HttpMethod> allowMethods = checkMethods(config, requestMethod);if (allowMethods == null) {logger.debug("Rejecting CORS request because '" + requestMethod + "' request method is not allowed");rejectRequest(response);return false;}List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);List<String> allowHeaders = checkHeaders(config, requestHeaders);if (preFlightRequest && allowHeaders == null) {logger.debug("Rejecting CORS request because '" + requestHeaders + "' request headers are not allowed");rejectRequest(response);return false;}//设置响应头responseHeaders.setAccessControlAllowOrigin(allowOrigin);if (preFlightRequest) {responseHeaders.setAccessControlAllowMethods(allowMethods);}if (preFlightRequest && !allowHeaders.isEmpty()) {responseHeaders.setAccessControlAllowHeaders(allowHeaders);}if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());if (Boolean.TRUE.equals(config.getAllowCredentials())) {responseHeaders.setAccessControlAllowCredentials(true);}if (preFlightRequest && config.getMaxAge() != null) {responseHeaders.setAccessControlMaxAge(config.getMaxAge());}//刷新response.flush();return true;}⾄此@CrossOrigin的使命就完成了，说⽩了就是⽤拦截器给response添加响应头信息⽽已到此这篇关于Spring @CrossOrigin 注解原理实现的⽂章就介绍到这了,更多相关Spring @CrossOrigin 注解内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

springboot解析xml_SpringBoot使用及原理浅尝Spring Boot 是一个用于构建Spring 应用程序的框架，它简化了Spring 应用程序的开发过程并提供了一种快速开发的方式。

Spring Boot可以使用XML配置，下面将介绍Spring Boot使用XML配置的方法及原理。

一、Spring Boot使用XML配置的方法1.添加依赖要使用Spring Boot的XML配置，首先需要在项目的pom.xml文件中添加相应的依赖。

Spring Boot提供了spring-boot-starter-parent这个父级依赖，可以继承这个依赖来快速配置相关的依赖版本。

同时，还需要添加spring-boot-starter-web依赖用于构建Web应用程序。

2.创建XML配置文件在src/main/resources目录下创建一个application.xml文件。

在这个文件中，可以配置Spring Boot需要的相关信息，比如数据源、事务管理器、登录验证等。

3. 创建Java配置类4.运行应用程序二、Spring Boot使用XML配置原理Spring Boot使用XML配置的原理其实和普通的Spring应用程序是相似的，只不过Spring Boot提供了更简便的配置方式。

主要原理如下：1.自动配置Spring Boot通过自动配置的方式简化了配置过程。

通过Spring Boot的自动配置机制，可以根据classpath中的jar包、类名、注解等信息，来推断应用程序的配置，并自动加载所需的配置。

2.配置加载3. Bean装载4.自动装配总结Spring Boot提供了使用XML配置的功能，可以通过添加依赖、创建XML配置文件和Java配置类来实现。

Spring Boot的配置原理主要包括自动配置、配置加载、Bean装载和自动装配。

Spring Boot的自动配置功能简化了配置过程，使开发者可以更快地搭建应用程序。

SpringBoot条件注解ConditionalOnClass底层原理
1. 获取当前Bean的定义信息，包括Bean的名称、类型等。

2. 获取当前的Bean工厂，这里指的是Spring的应用上下文。

3.获取当前的类加载器。

4.通过反射加载指定的类，判断该类是否存在。

5. 如果指定的类存在，则返回true，表示条件满足；否则返回false，表示条件不满足。

在SpringBoot的启动过程中，会读取所有的配置类和Bean定义信息，并将其封装成BeanDefinition对象。

然后会通过BeanFactoryPostProcessor的实现类来处理这些BeanDefinition对象，
其中就包括条件注解的处理。

在处理ConditionalOnClass注解时，会调
用OnClassCondition的matches(方法来判断条件是否满足。

如果条件满足，则会加载配置类或者Bean，否则会跳过该配置类或
者Bean的加载过程。

这样就实现了根据特定的条件来决定是否加载类或
者方法的功能。

总结起来，SpringBoot中的条件注解ConditionalOnClass是通过Condition接口的实现类来实现的。

在这个实现类中，会通过反射加载指
定的类，判断该类是否存在。

如果存在，则表示条件满足，会加载配置类
或者Bean；否则表示条件不满足，会跳过加载过程。

这样就实现了根据
特定的条件来决定是否加载类或者方法的功能。

spring成神之路第三篇：Spring容器基本使⽤及原理（ApplicationCont。

1. jdk1.82. idea3. maven-3.6.14. spring-5.2.3.RELEASEIOC容器是具有依赖注⼊功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个⽣命周期都是由容器来控制。

我们需要使⽤的对象都由ioc容器进⾏管理，不需要我们再去⼿动通过new的⽅式去创建对象，由ioc 容器直接帮我们组装好，当我们需要使⽤的时候直接从ioc容器中直接获取就可以了。

那么spring ioc容器是如何知道需要管理哪些对象呢？需要我们给ioc容器提供⼀个配置清单，这个配置⽀持xml格式和java注解的⽅式，在配置⽂件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置⽂件，然后将这些对象给组装好以供外部访问者使⽤。

这⾥所说的IOC容器也叫spring容器。

由spring容器管理的对象统称为Bean对象。

Bean就是普通的java对象，和我们⾃⼰new的对象其实是⼀样的，只是这些对象是由spring去创建和管理的，我们需要在配置⽂件中告诉spring容器需要创建哪些bean对象，所以需要先在配置⽂件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

1. 引⼊spring相关的maven配置2. 创建bean配置⽂件，⽐如bean xml配置⽂件3. 在bean xml⽂件中定义好需要spring容器管理的bean对象4. 创建spring容器，并给容器指定需要装载的bean配置⽂件，当spring容器启动之后，会加载这些配置⽂件，然后创建好配置⽂件中定义好的bean对象，将这些对象放在容器中以供使⽤5. 通过容器提供的⽅法获取容器中的对象，然后使⽤spring内部提供了很多表⽰spring容器的接⼝和对象，我们来看看⽐较常见的⼏个容器接⼝和具体的实现类。

Spring使⽤@Async注解,多线程@Async注解的原理及使⽤本⽂讲述@Async注解，在Spring体系中的应⽤。

本⽂仅说明@Async注解的应⽤规则，对于原理，调⽤逻辑，源码分析，暂不介绍。

对于异步⽅法调⽤，从Spring3开始提供了@Async注解，该注解可以被标注在⽅法上，以便异步地调⽤该⽅法。

调⽤者将在调⽤时⽴即返回，⽅法的实际执⾏将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执⾏。

在项⽬应⽤中，@Async调⽤线程池，推荐使⽤⾃定义线程池的模式。

⾃定义线程池常⽤⽅案：重新实现接⼝AsyncConfigurer。

简介应⽤场景同步：同步就是整个处理过程顺序执⾏，当各个过程都执⾏完毕，并返回结果。

异步：异步调⽤则是只是发送了调⽤的指令，调⽤者⽆需等待被调⽤的⽅法完全执⾏完毕；⽽是继续执⾏下⾯的流程。

例如，在某个调⽤中，需要顺序调⽤ A, B, C三个过程⽅法；如他们都是同步调⽤，则需要将他们都顺序执⾏完毕之后，⽅算作过程执⾏完毕；如B为⼀个异步的调⽤⽅法，则在执⾏完A之后，调⽤B，并不等待B完成，⽽是执⾏开始调⽤C，待C执⾏完毕之后，就意味着这个过程执⾏完毕了。

在Java中，⼀般在处理类似的场景之时，都是基于创建独⽴的线程去完成相应的异步调⽤逻辑，通过主线程和不同的业务⼦线程之间的执⾏流程，从⽽在启动独⽴的线程之后，主线程继续执⾏⽽不会产⽣停滞等待的情况。

Spring 已经实现的线程池1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重⽤线程，默认每次调⽤都会创建⼀个新的线程。

2. SyncTaskExecutor：这个类没有实现异步调⽤，只是⼀个同步操作。

只适⽤于不需要多线程的地⽅。

3. ConcurrentTaskExecutor：Executor的适配类，不推荐使⽤。

如果ThreadPoolTaskExecutor不满⾜要求时，才⽤考虑使⽤这个类。

spring配置详解1.前⾔公司⽼项⽬的后台，均是基于spring框架搭建，其中还⽤到了log4j.jar等开源架包。

在新项⽬中，则是spring和hibernate框架均有使⽤，利⽤了hibernate框架，来实现持久化，简化sql操作等。

Hibernate配置⽂件可以有两种格式，⼀种是 hibernate.properties，另⼀种是hibernate.cfg.xml。

后者稍微⽅便⼀些，当增加hbm映射⽂件的时候，可以直接在 hibernate.cfg.xml ⾥⾯增加，不必像 hibernate.properties 必须在初始化代码中加⼊。

我们新项⽬中使⽤的是hibernate.cfg.xml格式。

不过在本⽂中不将细述，后续有机会再补上。

公司项⽬中，中间件主要有tomcat，webshpere，WebLogic。

以下，将对项⽬中spring基本配置，log4j的配置，还有中间件的相关参数配置做⼀个初步的介绍。

2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。

配置的实现是通过注记配置和XML配置来合作实现。

这⾥，我将按照Spring的配置流程，将其他⼏个⽅⾯的配置融合其中，来进⾏全⾯解析。

2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中，当中间件启动时，中间件会⾸先读取web.xml中的配置。

在web.xml中可以配置监听器，过滤器，servlet映射等等。

在Spring 框架中，我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。

在GISV13的web.xml中，我们定义了如下内容：InitGISConfigServlet定义了容器启动时，⾸先要运⾏这个⽅法。

然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。

spring 原理1、spring原理内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的。

Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。

这些都是通过配置类达到的。

Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置内部通过反射去动态的组装对象）Spring里用的最经典的一个设计模式就是：模板方法模式。

(这里我都不介绍了，是一个很常用的设计模式)， Spring里的配置是很多的，很难都记住，但是Spring里的精华也无非就是以上的两点，把以上两点跟理解了也就基本上掌握了Spring.Spring AOP与IOC1、IoC：概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean二、AOP(Aspect-Oriented Programming): 面向方面编程1、代理的两种方式：静态代理：针对每个具体类分别编写代理类；针对一个接口编写一个代理类；动态代理：针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类2、动态代理:不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过类实例化一个动态代理，在实例化动态代理时将真实对象及装备注入到动态代理中，向客户端公开的是动态代理，当客户端调用动态代理方法时，动态代理根据类的反射得到真实对象的Method,调用装备的invoke方法，将动态代理、Method、方法参数传与装备的invoke方法，invoke方法在唤起method方法前或后做一些处理。

springmvc⼯作原理和源码分析springmvc⼯作原理以及源码分析(基于spring3.1.0) springmvc是⼀个基于spring的web框架.本篇⽂章对它的⼯作原理以及源码进⾏深⼊分析. ⼀、springmvc请求处理流程 ⼆、springmvc的⼯作机制 三、springmvc核⼼源码分析 四、谈谈springmvc的优化⼀、springmvc请求处理流程 引⽤spring in action上的⼀张图来说明了springmvc的核⼼组件和请求处理流程:①：DispatcherServlet是springmvc中的前端控制器(front controller),负责接收request并将request转发给对应的处理组件. ②：HanlerMapping是springmvc中完成url到controller映射的组件.DispatcherServlet接收request,然后从HandlerMapping查找处理request的controller. ③：Cntroller处理request,并返回ModelAndView对象,Controller是springmvc中负责处理request的组件(类似于struts2中的Action),ModelAndView是封装结果视图的组件. ④⑤⑥：视图解析器解析ModelAndView对象并返回对应的视图给客户端.⼆、springmvc的⼯作机制 在容器初始化时会建⽴所有url和controller的对应关系,保存到Map<url,controller>中.tomcat启动时会通知spring初始化容器(加载bean的定义信息和初始化所有单例bean),然后springmvc会遍历容器中的bean,获取每⼀个controller中的所有⽅法访问的url,然后将url和controller保存到⼀个Map中; 这样就可以根据request快速定位到controller,因为最终处理request的是controller中的⽅法,Map中只保留了url和controller中的对应关系,所以要根据request的url进⼀步确认controller中的method,这⼀步⼯作的原理就是拼接controller的url(controller上@RequestMapping的值)和⽅法的url(method上@RequestMapping的值),与request的url进⾏匹配,找到匹配的那个⽅法; 确定处理请求的method后,接下来的任务就是参数绑定,把request中参数绑定到⽅法的形式参数上,这⼀步是整个请求处理过程中最复杂的⼀个步骤。

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注解，继承@Configuration注解，主要⽤于加载配置⽂件@SpringBootConfiguration继承⾃@Configuration`，⼆者功能也⼀致，标注当前类是配置类，并会将当前类内声明的⼀个或多个以@Bean注解标记的⽅法的实例纳⼊到spring容器中，并且实例名就是⽅法名。

@EnableAutoConfiguration 注解，开启⾃动配置功能@EnableAutoConfiguration可以帮助SpringBoot应⽤将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使⽤的IoC容器。

Spring中的注解@Autowired实现过程全解（@Autowired背后的故事）现在⾯试，基本上都是⾯试造⽕箭 ，⼯作拧螺丝 。

⽽且是喜欢问⼀些 Spring 相关的知识点，⽐如之间的区别。

魔⾼⼀丈，道⾼⼀尺。

很快不少程序员学会了背诵⾯试题，那我反过来问“Spring 中的注解 @Autowired是如何实现的？”，“说说 @Autowired 的实现原理？”等等，背诵⾯试题的就露馅了。

基于此，今天我们来说⼀说 @Autowired 背后的故事！前⾔使⽤ Spring 开发时，进⾏配置主要有两种⽅式，⼀是 xml 的⽅式，⼆是 Java config 的⽅式。

Spring 技术⾃⾝也在不断的发展和改变，从当前的⽕热程度来看，Java config 的应⽤是越来越⼴泛了，在使⽤ Java config 的过程当中，我们不可避免的会有各种各样的注解打交道，其中，我们使⽤最多的注解应该就是 @Autowired 注解了。

这个注解的功能就是为我们注⼊⼀个定义好的 bean。

那么，这个注解除了我们常⽤的属性注⼊⽅式之外还有哪些使⽤⽅式呢？它在代码层⾯⼜是怎么实现的呢？这是本篇⽂章着重想讨论的问题。

@Autowired 注解⽤法在分析这个注解的实现原理之前，我们不妨先来回顾⼀下 @Autowired 注解的⽤法。

将 @Autowired 注解应⽤于构造函数，如以下⽰例所⽰`public class MovieRecommender {``private final CustomerPreferenceDao customerPreferenceDao;``@Autowired``public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`将 @Autowired 注释应⽤于 setter ⽅法`public class SimpleMovieLister {``private MovieFinder movieFinder;``@Autowired``public void setMovieFinder(MovieFinder movieFinder) {``this.movieFinder = movieFinder;``}``// ...``}`将 @Autowired 注释应⽤于具有任意名称和多个参数的⽅法`public class MovieRecommender {``private MovieCatalog movieCatalog;``private CustomerPreferenceDao customerPreferenceDao;``@Autowired``public void prepare(MovieCatalog movieCatalog,``CustomerPreferenceDao customerPreferenceDao) {``this.movieCatalog = movieCatalog;``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`您也可以将 @Autowired 应⽤于字段，或者将其与构造函数混合，如以下⽰例所⽰`public class MovieRecommender {``private final CustomerPreferenceDao customerPreferenceDao;``@Autowired``private MovieCatalog movieCatalog;``@Autowired``public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {``this.customerPreferenceDao = customerPreferenceDao;``}``// ...``}`直接应⽤于字段是我们使⽤的最多的⼀种⽅式，但是使⽤构造⽅法注⼊从代码层⾯却是更加好的，具体原因我就不细说了，有不懂的可以留⾔区评论。

springboot的原理Spring Boot是一个基于Spring Framework的开发框架，它主要通过简化和自动化的方式来开发和配置Spring应用程序。

下面将介绍Spring Boot的原理。

1. 自动配置（Auto-configuration）：Spring Boot通过自动配置的方式，根据已添加的依赖和应用程序的定义来决定需要启用哪些特性。

它会根据约定和默认值自动配置Spring应用程序，从而避免了繁琐的配置。

2. 起步依赖（Starter Dependencies）：Spring Boot提供了一系列的起步依赖，它们是预先配置好的Maven依赖，用于简化项目的配置过程。

这些起步依赖集合了常用的第三方库和框架，并且定义了它们之间的版本兼容性。

3. 内嵌容器（Embedded Container）：Spring Boot可以将应用程序打包为一个可执行的JAR文件，并内嵌一个Servlet容器（如Tomcat、Jetty等）。

这样可以简化部署过程，只需通过java -jar命令启动应用程序即可。

4. 简化配置（Simplified Configuration）：Spring Boot通过采用注解和属性配置的方式，大大简化了应用程序的配置过程。

它提供了一套默认的配置规则，可以通过修改配置文件或使用注解来进行自定义配置。

5. 自动装配（Auto-wiring）：Spring Boot利用Spring Framework的自动装配机制，根据依赖关系自动装配和管理Bean的生命周期。

它会根据类路径下的依赖自动装配组件，不再需要手动配置和管理Bean的依赖关系。

6. 健康检查（Health Monitoring）：Spring Boot提供了健康检查的功能，可以实时监控应用程序的运行状态。

通过定义合适的端点，可以对应用程序的健康状况进行监控和管理。

总的来说，Spring Boot通过自动配置、起步依赖、内嵌容器、简化配置、自动装配和健康检查等特性，简化了Spring应用程序的开发和部署过程，提高了开发效率和开发体验。

springboot源码解读与原理分析spring boot 是spring家族中的一款框架，集持久层、视图层、服务层为一体，极大的减低了开发者在开发分析、实现、测试、部署以及维护上的工作量。

spring boot 的架构相比较传统的spring mvc框架简化了很多，采用的是一款简单的分布式server框架，使得开发可以专注于应用开发，而不是框架编程技术；而且通过几个简单的配置，就可以自动初始化和自动装配这些服务，减少了对于ssm架构中繁琐定制的配置。

spring boot 的实现原理主要在于spring 容器，spring boot 需要依赖spring 容器的自动初始化容器及bean，通过加载特殊的Spring 配置文件，可以加载所有的Bean，通过BeanFactory 接口，就可以获得想要的Bean。

另外，spring boot 还通过注解@EnableAutoConfiguration，可以自动完成项目的配置，该注解的作用是会根据不同的包路径自动引入对应的jar依赖，完成自动配置，这样不仅可以简化开发者的编码实现，而且可以节省很多时间。

spring boot，还可以使用嵌入式Web容器，通过这种方式，可以直接生成war文件，无需安装部署Web容器，而且可以通过嵌入式的服务器，在服务中实现高并发的处理，也可以在测试环境做一些调整，这样可以最大化，减少服务器的资源消耗，提高服务效率。

总之，spring boot采用了结合了spring 容器、注解、嵌入式Web容器的技术，为开发者提供了一款轻量级的快速开发框架，而且这种技术方案，在有多个应用时，可以大大提高开发效率，减少重复劳动，使得维护变得更简单，有助于改善应用质量以及提高开发效率。