spring mvc boot cloud

bean加载顺序   构造方法 > @Autowired > @PostConstruct==>init==destory==>predestory==卸载servlet;  
使用到Autowired中的bean时，会先初始化这个bean所有的PostConstruct

https://www.cnblogs.com/summerday152/p/13639896.html
https://www.cnblogs.com/grasp/p/11942735.html

spring启动过程  bean周期
web.xml->ContextLoaderListener->初始化上下文->初始化ApplicationContext->(1.创建webAC 2.加载bean 3.加入到全局变量中)
Spring容器和SpringMVC容器是父子容器的关系，Spring容器ApplicationContext是父容器，SpringMVC容器WebApplicationContext是子容器，子容器中可以访问父容器的对象，但父容器中不能访问子容器的对象

其启动过程主要包含三个类，ContextLoaderListener，ContextLoader和XmlWebApplicationContext。
在web.xml中提供ContextLoaderListener上下文监听器，在web容器启动时，会触发容器初始化事件，ContextLoaderListener会监听到这个事件，从而触发ContextInitialized方法完成上下文初始化，这个方法中调用父类ContextLoader的方法完成上下文初始化。ContextLoader类中主要完成三件事：1）创建WebApplicationContext；2）加载对应的Spring配置文件中的bean；（refresh方法，完成bean的加载）比如过滤器，监听器，DispatcherServlet3）将WebApplicationContext放入servletContext中。 !!!!!!!!!!!
ServletContext（Java Web的全局变量） ApplicationContext实现ServletContext    上下文就是ServletContext!!!!!!!

refesh初始化IOC容器 synchronized  Spring容器创建之后，会调用它的refresh方法刷新Spring应用的上下文
prepareRefresh；准备上下文环境
得到一个beanFactory组件。 默认DefaultListableBeanFactory
预处理 prepareBeanFactory（BeanFactory） 比如context的类加载器，BeanPostProcessor和XXXAware自动装配等
对BeanFactory组件进行后处理 postProcessBeanFactory（BeanFactory） BeanFactory准备工作完成后进行的后置处理工作
调用bean工厂的后置处理器 invokeBeanFactoryPostProcessors

/刷新前的预处理;
prepareRefresh();
//获取BeanFactory；默认实现是DefaultListableBeanFactory，在创建容器的时候创建的
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器，BeanPostProcessor和XXXAware自动装配等）
prepareBeanFactory(beanFactory);
//BeanFactory准备工作完成后进行的后置处理工作
postProcessBeanFactory(beanFactory);
//执行BeanFactoryPostProcessor的方法；
invokeBeanFactoryPostProcessors(beanFactory);
//注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
registerBeanPostProcessors(beanFactory);
//初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
initMessageSource();
//初始化事件派发器
initApplicationEventMulticaster();
//子类重写这个方法，在容器刷新的时候可以自定义逻辑；如创建Tomcat，Jetty等WEB服务器
onRefresh();
//注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的
registerListeners();
//初始化所有剩下的非懒加载的单例bean
finishBeanFactoryInitialization(beanFactory);
//完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
finishRefresh();

beanDefinition描述xml配置的bean   scope lazyinit 父节点 依赖的其他bean  单例  指向的类
DefaultListableBeanFactory  //获取BeanFactory；默认实现是DefaultListableBeanFactory，在创建容器的时候创建的    就会加载所有beanDefinition!!!注册到beanfactory
volatile List<String> beanDefinitionNames = new ArrayList(256);  存名字   名字不重复就使用LinkedHashSet
final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256); 名字对应BeanDefinition
final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap(16);   多级缓存解决循环依赖  但是解决不了构造器中去依赖

bean生命周期  getbean
1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。  
2）利用依赖注入完成 Bean 中所有属性值的配置注入。  poplatebean方法
3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。  设置的名字
4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。
7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。
10）如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。
11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

BeanFactoryPostProcessor的主要作用是在容器实例化任何bean之前读取bean的定义(配置元数据)并且可以修改它，可以定义多个，通过order来确定执行顺序。BeanPostProcessor主要是spring完成bean实例化配置以及其他初始化前后可以添加一些自己的处理逻辑，同样也可以定义多个并通过order来确定执行顺序!!!!!!!!!!!!!

 

spring解决初始化的循环依赖，解决不了构造器的循环依赖！！！
相当于先实例化对象到cache,依赖无参构造,bean提前暴露，在注入！！

ApplicationContext在自身初始化时就一次性创建Bean,基本的BeanFactory总是延迟加载Bean,直到第一次调用getBean("BeanId")方法  检测配置正确性
先实例化在初始化
实例化：创建对象，通过底层的class反射创建
初始化：成员变量赋值，各种增强等等 Initialization:表示初始化

getbean   synchronized
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap(16);

ioc  aop  
spring启动流程 boot 生命周期
springcloud
设计模式
es kafka redis zookeper
 

 

但是在interceptor中获取了参数之后，在controller中就获取不到参数了，因为在request中获取post方式提交的参数是从流中获取的，并且只能获取一次

①拦截器是基于java的反射机制的，而过滤器是基于函数回调。
②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

Filter的执行顺序在Interceptor之前  Filter实例只能在容器初始化时调用一次、所有请求拦截
Interceptor在SpringMVC中就是依赖于SpringMVC框架。在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种，同时一个拦截器实例在一个controller生命周期之内可以多次调用，缺点是只能对controller请求进行拦截
preHandle 调用方法前 postHandle 前后  afterCompletion后
servlert所以filter是ServletRequest，而不是httpservletrequest
容器->filter->servlet->Interceptor->controller

 

WebMvcConfigurer自己定义一些Handler，Interceptor   RequestInterceptor Feign请求  HandlerInterceptor请求方法周围
Configuration @Bean 注解的方法都会被动态代理  该类作为spring的xml配置文件中的<beans> ！！
@ImportResource(locations= {"classpath:application-bean.xml"}) 引入其他文件
<context:component-scan base-package="com.xxx.xxx" />

注解 https://blog.csdn.net/yaheng100/article/details/81741693
RequestMapping(uri) ResponseBody RequestBody(json转成java对象) RequestParam PathVarible(获取uri中的参数)
autowire 默认byType,byName结合qualifier required    resource默认byname
Value外部值“${xxx}”  scope single prorotype request...

springmvc  model view controller 解耦 复用
DispatcherServlet->HandlerMapping(多种处理器)->HandlerAdapter->找到Controller->ModelAndView->ViewReslover->View->用户

spring ioc aop
注入方法有构造器 setter 注解
ioc 解耦,减少入侵,对象复用
BeanFactory（延迟加载）->ApplicationContext  容器，它叫做应用上下文  项目启动时就加载所有bean,可以找出依赖错误，BeanFactory是getBean才会创建，调用才会报错
提供国际化的标准,加载多个 Resource资源

 

初始化过程和生命周期！！
BeanFactory是IOC最基本的容器，负责生产和管理bean
FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象
是一个能生产或者修饰对象生成的工厂Bean！！  能帮助生产对象

BeanFactoryPostProcessor：BeanFactory后置处理器，是对BeanDefinition对象进行修改。（BeanDefinition：存储bean标签的信息，用来生成bean实例）
在当前BeanFactory初始化（spring容器加载bean定义文件）后，在容器实例化任何其它bean之前读取配置元数据，并可以根据需要进行修改，例如可以把bean的scope从singleton改为prototype
BeanPostProcessor：Bean后置处理器，是对生成的Bean对象进行修改。  在spring容器实例化bean之后，在执行bean的初始化方法前后

生命周期 反射
实例化->设置名称（属性赋值）->初始化->销毁 
存储和管理，通过hashmap,key为id
而非单例bean是不会被放入hashmap中只会从spring容器中加载

aop 面向切面编程 代理jdk cglib （前者基于接口，后者基于子类） 减少大量代码的重复(公共行为,权限认证、日志、事物)   减少入侵  
(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知
(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用
(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around  顺序 around before method around after afterReturning|afterThrowing
(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式 execution  就是那个方法JointPoint

多个AOP，Spring框架是一个大量使用策略设计模式的框架，这意味着有很多相同接口的实现类，那么必定会有优先级的问题 Ordered

springboot 减少配置和微服务  spring-boot-starter-web包包含了需要的core log aop mvc  <exclusion>去除tomcat
@SpringBootApplication = @Configuration、@EnableAutoConfiguration和@ComponentScan  注解exclude排除
main->反射CalssPath->spring扫描

springcloud
EnableEurekaClient|Setver  eureka.client.service-url.defaultZone注册到eureka服务地址
Hystrix熔断器  zuul可以作为资源的统一访问入口,相当于门卫,对请求进行一些校验

https://blog.csdn.net/cml_blog/article/details/78349703

Zuul提供默认的四种过滤器类型，通过filterType方法进行标识
pre：可以在请求被路由之前调用
route：在路由请求时候被调用
post：在route和error过滤器之后被调用
error：处理请求时发生错误时被调用

filterOrder 0最先
shouldFilter filter是否执行

RequestContext ctx = RequestContext.getCurrentContext();
通过ctx.setSendZuulResponse(false)可以终止请求的转发，但是只在pre类型的过滤器中设置才可以。

限制接口权限  token权限

zuul让path不是映射到具体url上，而是映射到某个具体的服务上！！！！
所有外部请求都经过Zuul的转发到具体的服务实例，减少了每个服务之间互相鉴权代码冗余问题，统一交给Zuul进行鉴权，在此基础上集成上边说的高级功能。路由功能相当于反向代理。
服务多个实例就负载均衡，用到ribbon
Zuul中包含了Hystrix和Ribbon的依赖，所以Zuul拥有线程隔离和断路器的自我保护功能，以及对服务调用的客户端负载均衡
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds 超时
ribbon.ConnectTimeout 小于hystrix

zuul:
  routes:
    traditional-url:                             #传统的路由配置,此名称可以自定义
      path: /tr-url/**                           #映射的url
      url: http://localhost:9001/                #被映射的url
    orient-service-url:                          #面向服务的路由配置,此名称可以自定义
      path: /os-url/**
      service-id: feign-customer                 #服务名
      
?    匹配单个字符    /feign/?
*    匹配任意数量字符，但不支持多级目录    /feign/*
**    匹配任意数量字符，支持多级目录    /feign/**

zuul:
  routes:
    service-order: /service-order/**
    service-snmp: /service-snmp/**

 

 

公共工具类  对象抽取
pom.xml继承!!!!!!!  公共的common.xml   引入要用的jar包和版本  <relativePath>../public-maven/common.xml</relativePath>
common在引入公共的jar包，修改要先打包  <systemPath>${pom.basedir}/../common/target/common-${common.version}.jar</systemPath>

配置多个yml config-server
多个项目共用一个服务中心,spring-cloud-config-server @EnableConfigServer   其他项目添加spring-cloud-starter-config    
spring.cloud.config.server.uri  指的是资源库的地址
spring.cloud.config.server.search-paths: ‘{profile}’ 这里要注意{profile}外面一定要加单引号
spring.profiles.active: qa                       @Profile指定那个环境  application-{profile}.properties来定义多个配置文件,profile分支名
#指定读取配置文件:dev(开发环境),prod(生产环境),qa(测试环境)

其他服务
bootstrap.properties  用来在程序引导时执行
spring.cloud.config.uri=http://localhost:8900/  指的是spring-cloud-config-server端的访问地址
spring.cloud.config.name=enrekaserver-test  是配置文件的名称,如需要加载多个文件需要使用逗号隔开
#对应着文件后面的后缀{profile}
spring.cloud.config.profile=enreka-server-config
#分支
spring.cloud.config.label=master  指的是git master 分支

eureka.client.service.url.defaultZone=http://localhost:8761/eureka/ 注册中心
#配置文件在本地  默认是git,可以设置：subversion(SVN)
spring.profiles.active=native
#配置文件的目录
spring.cloud.config.server.native.search-locations=classpath:/shared