BeanFactory和FactoryBean的区别:
	FactoryBean是Spring工厂生产出来的Bean,所以叫FactoryBean

	beans定义的是规范
	context是具体实现
	aop是aspects的上层建筑
	targetClass,MethodInvoker
	从IOC中取得代理以后的对象,对每个方法进行重写,加入一些切面所需要的东西

	默认是按照类型进行自动装配
	Spring默认都是单例
	prototype,每次使用到就实例一次

	allowBeanDefinitionOverriding属性是指是否允许对一个名字相同但definition不同进行重新注册，默认是true。
	allowCircularReferences属性是指是否允许Bean之间循环引用，默认是true.
	这两个默认都是空的，所以可以扩展

	一个切面，代表N个bean的集合，这个N个bean它们都拥有共同点，所以组成一个切面

	连接点：
		程序执行过程中的某一行为，在切面中的bean之间的关联点

	切入点:
		进入切面内部的一个入口
		因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

	目标对象：
		被一个或者多个切面通知的对象
		持有被代理对象的引用，在调用被代理的方法时，在调用之前加点东西，在调用之后加点东西，在中间具体调用

	如果一个方法是final的,就无法进行代理,也就是说无法进行切面

	spring的四种装配策略:
		byName
		byType
		constructor
		autodetect
			首先尝试用constructor来进行装配,如果无法装配就使用byType

	spring的@autowired注解时,可以注解所有的方法,也可以注解构造器
	但是当注解构造器时,只有一个构造器可以设置required属性为true,其他的都会被设置为false,并且当注解多个构造器时,spring
	会选择入参最多的那个

	如果有多个候选bean的情况:
		@qualifier注解
			Qualifier的意思是合格者，通过这个标示，表明了哪个实现类才是我们所需要的，添加@Qualifier注解，需要注意的是@Qualifier的参数名称为我们之前定义@Service注解的名称之一


	过滤组件扫描:
		即在spring中如果遇到不方便添加注解或者看不到源码,又需要生成自动扫描生成bean的java类
		下面的规则都可以分为正向的和反向的，即该类型的需要扫描以及该类型的不需要扫描。
		<context:component-scan base-package=”被扫描的包路径”>
		正向的写在
		<context:include-filter type=”5种情况” expression=”如下所示”/>
		反向的写在
		<context:exclude-filter type=”5种情况” expression=”如下所示”/>
		需要用到时在去查

	web开发中,Spring启动的方式:
		1.Lisenter方式
		2.手动启动
		3.插件形式可以启动

	过滤器是J2EE的标准,在J2EE中是没有拦截器这个概念的

	SpringBean什么时候被回收:
		1.类指针丢失,过一段时间会自动回收
		2.手动置为null,也会被回收

	类加载的顺序:
		1.静态变量
		2.静态代码块
		3.成员变量
		4.匿名代码块
		5.构造函数

代理模式:
	JDK的动态代理是通过接口来进行强制转换的
	生成之后的代理对象，可以强制转换为接口


	CGLib的动态代理是通过生成一个被代理对象的子类，然后重写父类的方法
	生成以后的对象，可以强制转换为被代理对象（也就是自己写的类）
	子类可以赋值给父类，同样是做了字节码重组这件事
	obj的引用是由CGLib给我们new出来的
	cglib new出来后是被代理对象的子类
	在new子类之前，实际上默认先调用了我们super()方法的
	子类重写了父类的所有的方法，也就是说改变子类对象的某些属性是可以间接操作父类的属性的
	设置生成的子类继承哪个类
	enhancer.setSuperclass(Car.class);
	设置回调
	enhancer.setCallback(this)

	AOP:事务代理(声明式事务),日志监听
	service方法调用之前要开启一个事务
	事务的执行是由我们自己的代码完成的,执行过程或结果需要监听是否有异常,然后根据异常判断事务是否回滚还是继续提交

	spring中的工厂模式:
		Bean:
			单例的Bean
			被代理过的Bean
			最原始的Bean
			List类型的Bean
			作用域不同的Bean

	spring中实际解析xml文件的位置在BeanDefinitionParserDelegate这个类中

JAVA的IO体系结构:
	最重要的就是五个类和一个接口
		1.File
		2.OutputStream
		3.InputStream
		4.Writer
		5.Reader
		6.Serializable
	分为三个层次:
		1.流式部分
			IO的主体部分
		2.非流式部分
			辅助流式部分的辅助部分
		3.其他类
			读取文件的类以及安全类
		Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示

java反射:
	Class是反射技术的源头,Class类不能有子类,并且在JDK1.5之后引入了泛型技术
		这个类中的构造方法并不能被直接使用,而要取的反射类的实例化对象,在java里面有三种类型:
			1.利用Object类的getClass()方法,这个类是final的,表示所有类的实例化对象都可以调用此方法,基本上不会使用
				在任何开发中,getClass()很少会直接出现直接的编写形式上
			2.使用类.class的形式取得反射的实例化对象
				只有在框架技术上才会使用到
			3.使用Class的forName()方法
				其他的两个方法都必须存在这个类才能使用
	实例化对象:
		public T newInstance() throws InstantiationException, IllegalAccessException
		在开发中如果是你自己定义的接口,要取的实例化对象,不能够直接new利用对象的向上转型为接口对象实例化,而是使用工厂方法模式

	Class类最大的功能是可以完全的去解剖一个类
		类所在的包
			getPackage()
		类的声明方式
			getName()//完整的
			getSimpleName()//类名
		类继承的父类
			getSuperclass()
		类所实现的接口
			getInterfaces()

	取得构造方法:
		1.取得全部构造
			getConstructors()
		1.取得指定构造
			getConstructor()
			取得指定构造时,所匹配的只是参数的类型
		都有取得构造方法的名称的方法
			getName()
		取得方法的修饰符
			getModifiers()
		取得构造方法的参数的数量
			getParameterCount()
		取得构造方法的参数类型
			getParameterTypes()
		取得构造方法上的所抛出的异常类型
			getExceptionTypes()
		调用指定构造传递参数来实例化对象
			newInstance()
		调用Constructor类中的toString()方法可以得到构造方法的完整输出
		对于方法修饰符都是利用数字完成的,所以必须将数字翻译为可以读懂的字符串
			利用Modeifier类,有一个操作方法toString()
			Modifier.toString(constructor.getModifiers())
			public static void main(String[] args) throws Exception{
				Class<?> cls = Class.forName("com.fang.vo.Dept");
				Constructor<?>[] cons = cls.getConstructors();
				for (Constructor<?> constructor : cons) {
					StringBuffer buffer = new StringBuffer();
					buffer.append(Modifier.toString(constructor.getModifiers())).append(" ");
					buffer.append(constructor.getName());
					buffer.append("(");
					Class<?>[] parameterTypes = constructor.getParameterTypes();
					if (parameterTypes.length > 0) {
						for (int y = 0 ;y<parameterTypes.length;y++) {
							buffer.append(parameterTypes[y].getSimpleName()).append(" ref").append(y).append(",");
						}
					}
					buffer.delete(buffer.length()-1, buffer.length());
					buffer.append(")").append(" ");
					Class<?>[] exceptionTypes = constructor.getExceptionTypes();
					if (exceptionTypes.length > 0) {
						buffer.append("throws").append(" ");
						for(int z = 0;z < exceptionTypes.length;z++) {
							buffer.append(exceptionTypes[z].getSimpleName()).append(",");
						}
						buffer.delete(buffer.length()-1, buffer.length());
					}
					System.out.println(buffer);
				}
			}
			这些操作会在一些工具类中使用到,而在程序中出现的异议并不大,在程序中就是如何利用构造方法明确的调用有参构造方法实例化对象


	反射最大的用处,就是针对于方法的操作,在反射机制里面,普通方法可以在保存对象状态的情况下进行各种操作
	在反射的操作过程中,必须掌握方法的调用问题
		Class类中,方法有关的操作
			取得类中所有的方法
				getMethods()
			取得类中指定的方法
				getMethod()
			以上的方法返回的都是一个类型Method,Method类中有如下方法
				getName()取得方法的名字
				getModifiers()取得方法修饰符
				getParameterTypes()取得方法的参数类型
				invoke()调用指定的方法(最关键),任何方法调用时都必须有实例化对象,然后再设置参数
				getReturnType()返回值类型
				getDeclaredMethods()返回本类的方法

		public static void main(String[] args) throws Exception{
			String str = "dname:测试部|loc:北京";
			Class<?> cls = Class.forName("com.fang.vo.Dept");
			Object obj = cls.newInstance();
			String[] result = str.split("\\|");
			for(int i=0;i<result.length;i++) {
				String[] temp = result[i].split(":");
				String methodName = "set" + StringUtils.initcap(temp[0]);
				Method method = cls.getMethod(methodName,String.class);
				method.invoke(obj,temp[1]);
			}
			System.out.println(obj);
		}

	取得成员:
		分为两组:
			取得全部的成员:
				取得本类声明的成员
					getDeclaredFields()
				取得继承的声明成员
					getFields()
			取得指定的成员:
				获得本类指定的声明成员
					getField()
				获取继承的声明成员
					getDeclaredField()
		java.lang.reflect.Field表示成员的类型,而在这个类里面定义有如下的方法
			取得属性内容
				get()
			取得属性类型
				getType()
			设置属性
				set()
		在实际开发中,Field可以做以下两件事情
			1.可以取得指定成员的类型
			2.可以直接操作属性,完全避免掉Method的操作
			但是直接操作属性的情况是不允许操作的,而且所有的属性都使用了private关键字封装的,但是这种封装是可以解除的
				找到Field,Method,Constructor的父类AccessibleObject的方法setAccessible()
				但是这样的方法是不标准的

java通过八种方式来完成变量从工作内存到主内存的同步
	1.lock
	2.unlock
	3.read
	4.load
	5.use
	6.assign
	7.store
	8.write





MySql:
	索引是帮助高效获取数据的数据结构



如果实现了Spring的InitializingBean接口,在初始化时将执行afterPropertiesSet方法,这个
方法在init-method方法之前执行


整体来看，如果我们要实现自己的 xml 标签，仅需完成以下几步即可：

1、定义 xsd 文件
2、编写 NamespaceHandler
3、编写 BeanDefinitionParser
4、配置 spring.handlers 和 spring.schmas

springboot事件体系
	在实现类 EventPublishingRunListener 中，事件发布有两种模式：
		通过 SimpleApplicationEventMulticaster 进行事件广播
		所有监听器交给相应的 Context

springcloudeureka:
	eureka客户端:eurekaclient
	关联应用管理:applications
	单个应用信息:application
	单个应用实例:instanceInfo


Eureka客户端配置

      1、RegistryFetchIntervalSeconds

      从eureka服务器注册表中获取注册信息的时间间隔（s），默认为30秒

      2、InstanceInfoReplicationIntervalSeconds

      复制实例变化信息到eureka服务器所需要的时间间隔（s），默认为30秒

      3、InitialInstanceInfoReplicationIntervalSeconds

      最初复制实例信息到eureka服务器所需的时间（s），默认为40秒

      4、EurekaServiceUrlPollIntervalSeconds

      询问Eureka服务url信息变化的时间间隔（s），默认为300秒

      5、ProxyHost

      获取eureka服务的代理主机，默认为null

      6、ProxyProxyPort

      获取eureka服务的代理端口, 默认为null 

       7、ProxyUserName

      获取eureka服务的代理用户名，默认为null

       8、ProxyPassword

      获取eureka服务的代理密码，默认为null 

       9、GZipContent

       eureka注册表的内容是否被压缩，默认为true，并且是在最好的网络流量下被压缩

      10、EurekaServerReadTimeoutSeconds

      eureka需要超时读取之前需要等待的时间，默认为8秒

      11、EurekaServerConnectTimeoutSeconds

      eureka需要超时连接之前需要等待的时间，默认为5秒

      12、BackupRegistryImpl

      获取实现了eureka客户端在第一次启动时读取注册表的信息作为回退选项的实现名称

      13、EurekaServerTotalConnections

       eureka客户端允许所有eureka服务器连接的总数目，默认是200

       14、EurekaServerTotalConnectionsPerHost

       eureka客户端允许eureka服务器主机连接的总数目，默认是50

       15、EurekaServerURLContext

       表示eureka注册中心的路径，如果配置为eureka，则为http://x.x.x.x:x/eureka/，在eureka的配置文件中加入此配置表示eureka作为客户端向注册中心注册，从而构成eureka集群。此配置只有在eureka服务器ip地址列表是在DNS中才会用到，默认为null

       16、EurekaServerPort

       获取eureka服务器的端口，此配置只有在eureka服务器ip地址列表是在DNS中才会用到。默认为null

       17、EurekaServerDNSName

       获取要查询的DNS名称来获得eureka服务器，此配置只有在eureka服务器ip地址列表是在DNS中才会用到。默认为null

       18、UseDnsForFetchingServiceUrls

       eureka客户端是否应该使用DNS机制来获取eureka服务器的地址列表，默认为false

       19、RegisterWithEureka

       实例是否在eureka服务器上注册自己的信息以供其他服务发现，默认为true

       20、PreferSameZoneEureka

       实例是否使用同一zone里的eureka服务器，默认为true，理想状态下，eureka客户端与服务端是在同一zone下

       21、AllowRedirects

       服务器是否能够重定向客户端请求到备份服务器。 如果设置为false，服务器将直接处理请求，如果设置为true，它可能发送HTTP重定向到客户端。默认为false

       22、LogDeltaDiff

       是否记录eureka服务器和客户端之间在注册表的信息方面的差异，默认为false

       23、DisableDelta(*)

       默认为false

       24、fetchRegistryForRemoteRegions

       eureka服务注册表信息里的以逗号隔开的地区名单，如果不这样返回这些地区名单，则客户端启动将会出错。默认为null

       25、Region

       获取实例所在的地区。默认为us-east-1

       26、AvailabilityZones

       获取实例所在的地区下可用性的区域列表，用逗号隔开。

       27、EurekaServerServiceUrls

       Eureka服务器的连接，默认为http：//XXXX：X/eureka/,但是如果采用DNS方式获取服务地址，则不需要配置此设置。

       28、FilterOnlyUpInstances（*）

       是否获得处于开启状态的实例的应用程序过滤之后的应用程序。默认为true

       29、EurekaConnectionIdleTimeoutSeconds

       Eureka服务的http请求关闭之前其响应的时间，默认为30 秒

       30、FetchRegistry

       此客户端是否获取eureka服务器注册表上的注册信息，默认为true

       31、RegistryRefreshSingleVipAddress

       此客户端只对一个单一的VIP注册表的信息感兴趣。默认为null

       32、HeartbeatExecutorThreadPoolSize(*)

       心跳执行程序线程池的大小,默认为5

       33、HeartbeatExecutorExponentialBackOffBound(*)

       心跳执行程序回退相关的属性，是重试延迟的最大倍数值，默认为10

       34、CacheRefreshExecutorThreadPoolSize(*)

       执行程序缓存刷新线程池的大小，默认为5

       35、CacheRefreshExecutorExponentialBackOffBound

       执行程序指数回退刷新的相关属性，是重试延迟的最大倍数值，默认为10

       36、DollarReplacement

       eureka服务器序列化/反序列化的信息中获取“$”符号的的替换字符串。默认为“_-”

       37、EscapeCharReplacement

       eureka服务器序列化/反序列化的信息中获取“_”符号的的替换字符串。默认为“__”

       38、OnDemandUpdateStatusChange（*）

       如果设置为true,客户端的状态更新将会点播更新到远程服务器上，默认为true

       39、EncoderName

       这是一个短暂的编码器的配置，如果最新的编码器是稳定的，则可以去除，默认为null

       40、DecoderName

       这是一个短暂的解码器的配置，如果最新的解码器是稳定的，则可以去除，默认为null

       41、ClientDataAccept（*）

       客户端数据接收

       42、Experimental（*）

       当尝试新功能迁移过程时，为了避免配置API污染，相应的配置即可投入实验配置部分，默认为null


实例微服务端配置

       1、InstanceId

       此实例注册到eureka服务端的唯一的实例ID,其组成为spring.application.name:{spring.application.instance_id:${random.value}}

       2、Appname

       获得在eureka服务上注册的应用程序的名字，默认为unknow

       3、AppGroupName

       获得在eureka服务上注册的应用程序组的名字，默认为unknow

       4、InstanceEnabledOnit（*）

       实例注册到eureka服务器时，是否开启通讯，默认为false

       5、NonSecurePort

       获取该实例应该接收通信的非安全端口。默认为80

       6、SecurePort

       获取该实例应该接收通信的安全端口，默认为443

       7、NonSecurePortEnabled

       该实例应该接收通信的非安全端口是否启用，默认为true

       8、SecurePortEnabled

       该实例应该接收通信的安全端口是否启用，默认为false

       9、LeaseRenewalIntervalInSeconds

       eureka客户需要多长时间发送心跳给eureka服务器，表明它仍然活着,默认为30 秒

       10、LeaseExpirationDurationInSeconds

       Eureka服务器在接收到实例的最后一次发出的心跳后，需要等待多久才可以将此实例删除，默认为90秒

       11、VirtualHostName

       此实例定义的虚拟主机名，其他实例将通过使用虚拟主机名找到该实例。

       12、SecureVirtualHostName

       此实例定义的安全虚拟主机名

       13、ASGName（*）

       与此实例相关联 AWS自动缩放组名称。此项配置是在AWS环境专门使用的实例启动，它已被用于流量停用后自动把一个实例退出服务。

       14、HostName

       与此实例相关联的主机名，是其他实例可以用来进行请求的准确名称

       15、MetadataMap(*)

       获取与此实例相关联的元数据(key,value)。这个信息被发送到eureka服务器，其他实例可以使用。

       16、DataCenterInfo（*）

       该实例被部署在数据中心

       17、IpAddress

       获取实例的ip地址

       18、StatusPageUrlPath（*）

       获取此实例状态页的URL路径，然后构造出主机名，安全端口等，默认为/info

       19、StatusPageUrl(*)

       获取此实例绝对状态页的URL路径，为其他服务提供信息时来找到这个实例的状态的路径，默认为null

       20、HomePageUrlPath（*）

       获取此实例的相关主页URL路径，然后构造出主机名，安全端口等，默认为/

       21、HomePageUrl(*)

       获取此实例的绝对主页URL路径，为其他服务提供信息时使用的路径,默认为null

       22、HealthCheckUrlPath

       获取此实例的相对健康检查URL路径，默认为/health

       23、HealthCheckUrl

       获取此实例的绝对健康检查URL路径,默认为null

       24、SecureHealthCheckUrl

       获取此实例的绝对安全健康检查网页的URL路径，默认为null

       25、DefaultAddressResolutionOrder

       获取实例的网络地址，默认为[]

       26、Namespace

       获取用于查找属性的命名空间，默认为eureka


Eureka服务端配置

       1、AWSAccessId

       获取aws访问的id，主要用于弹性ip绑定，此配置是用于aws上的，默认为null

       2、AWSSecretKey

       获取aws私有秘钥，主要用于弹性ip绑定，此配置是用于aws上的，默认为null

       3、EIPBindRebindRetries

       获取服务器尝试绑定到候选的EIP的次数，默认为3

       4、EIPBindingRetryIntervalMsWhenUnbound(*)

       服务器检查ip绑定的时间间隔，单位为毫秒，默认为1 * 60 * 1000

       5、EIPBindingRetryIntervalMs

       与上面的是同一作用，仅仅是稳定状态检查，默认为5 * 60 * 1000

       6、EnableSelfPreservation

       自我保护模式，当出现出现网络分区、eureka在短时间内丢失过多客户端时，会进入自我保护模式，即一个服务长时间没有发送心跳，eureka也不会将其删除，默认为true

       7、RenewalPercentThreshold(*)

       阈值因子，默认是0.85，如果阈值比最小值大，则自我保护模式开启

       8、RenewalThresholdUpdateIntervalMs

       阈值更新的时间间隔，单位为毫秒，默认为15 * 60 * 1000

       9、PeerEurekaNodesUpdateIntervalMs(*)

       集群里eureka节点的变化信息更新的时间间隔，单位为毫秒，默认为10 * 60 * 1000

       10、EnableReplicatedRequestCompression

       复制的数据在发送请求时是否被压缩，默认为false

       11、NumberOfReplicationRetries

       获取集群里服务器尝试复制数据的次数，默认为5

       12、PeerEurekaStatusRefreshTimeIntervalMs

       服务器节点的状态信息被更新的时间间隔，单位为毫秒，默认为30 * 1000

       13、WaitTimeInMsWhenSyncEmpty(*)

       在Eureka服务器获取不到集群里对等服务器上的实例时，需要等待的时间，单位为毫秒，默认为1000 * 60 * 5

       14、PeerNodeConnectTimeoutMs

       连接对等节点服务器复制的超时的时间，单位为毫秒，默认为200

       15、PeerNodeReadTimeoutMs

       读取对等节点服务器复制的超时的时间，单位为毫秒，默认为200

       16、PeerNodeTotalConnections

       获取对等节点上http连接的总数，默认为1000

       17、PeerNodeTotalConnectionsPerHost(*)

       获取特定的对等节点上http连接的总数，默认为500

       18、PeerNodeConnectionIdleTimeoutSeconds(*)

       http连接被清理之后服务器的空闲时间，默认为30秒

       19、RetentionTimeInMSInDeltaQueue(*)

       客户端保持增量信息缓存的时间，从而保证不会丢失这些信息，单位为毫秒，默认为3 * 60 * 1000

       20、DeltaRetentionTimerIntervalInMs

       清理任务程序被唤醒的时间间隔，清理过期的增量信息，单位为毫秒，默认为30 * 1000

       21、EvictionIntervalTimerInMs

       过期实例应该启动并运行的时间间隔，单位为毫秒，默认为60 * 1000

       22、ASGQueryTimeoutMs（*）

       查询AWS上ASG（自动缩放组）信息的超时值，单位为毫秒，默认为300

       23、ASGUpdateIntervalMs

       从AWS上更新ASG信息的时间间隔，单位为毫秒，默认为5 * 60 * 1000

       24、ASGCacheExpiryTimeoutMs(*)

       缓存ASG信息的到期时间，单位为毫秒，默认为10 * 60 * 1000

       25、ResponseCacheAutoExpirationInSeconds（*）

       当注册表信息被改变时，则其被保存在缓存中不失效的时间，默认为180秒

       26、ResponseCacheUpdateIntervalMs（*）

       客户端的有效负载缓存应该更新的时间间隔，默认为30 * 1000毫秒

       27、UseReadOnlyResponseCache（*）

       目前采用的是二级缓存策略，一个是读写高速缓存过期策略，另一个没有过期只有只读缓存，默认为true，表示只读缓存

       28、DisableDelta（*）

       增量信息是否可以提供给客户端看，默认为false

       29、MaxIdleThreadInMinutesAgeForStatusReplication（*）

       状态复制线程可以保持存活的空闲时间，默认为10分钟

       30、MinThreadsForStatusReplication

       被用于状态复制的线程的最小数目，默认为1

       31、MaxThreadsForStatusReplication

       被用于状态复制的线程的最大数目，默认为1

       32、MaxElementsInStatusReplicationPool

       可允许的状态复制池备份复制事件的最大数量，默认为10000

       33、SyncWhenTimestampDiffers

       当时间变化实例是否跟着同步，默认为true

       34、RegistrySyncRetries

       当eureka服务器启动时尝试去获取集群里其他服务器上的注册信息的次数，默认为5

       35、RegistrySyncRetryWaitMs

       当eureka服务器启动时获取其他服务器的注册信息失败时，会再次尝试获取，期间需要等待的时间，默认为30 * 1000毫秒

       36、MaxElementsInPeerReplicationPool（*）

       复制池备份复制事件的最大数量，默认为10000

       37、MaxIdleThreadAgeInMinutesForPeerReplication（*）

       复制线程可以保持存活的空闲时间，默认为15分钟

       38、MinThreadsForPeerReplication（*）

       获取将被用于复制线程的最小数目，默认为5

       39、MaxThreadsForPeerReplication

       获取将被用于复制线程的最大数目，默认为20

       40、MaxTimeForReplication（*）

       尝试在丢弃复制事件之前进行复制的时间，默认为30000毫秒

       41、PrimeAwsReplicaConnections（*）

       对集群中服务器节点的连接是否应该准备，默认为true

       42、DisableDeltaForRemoteRegions（*）

       增量信息是否可以提供给客户端或一些远程地区，默认为false

       43、RemoteRegionConnectTimeoutMs（*）

       连接到对等远程地eureka节点的超时时间，默认为1000毫秒

       44、RemoteRegionReadTimeoutMs（*）

       获取从远程地区eureka节点读取信息的超时时间，默认为1000毫秒

       45、RemoteRegionTotalConnections

       获取远程地区对等节点上http连接的总数，默认为1000

       46、RemoteRegionTotalConnectionsPerHost

       获取远程地区特定的对等节点上http连接的总数，默认为500

       47、RemoteRegionConnectionIdleTimeoutSeconds

       http连接被清理之后远程地区服务器的空闲时间，默认为30秒

       48、GZipContentFromRemoteRegion（*）

       eureka服务器中获取的内容是否在远程地区被压缩，默认为true

       49、RemoteRegionUrlsWithName

       针对远程地区发现的网址域名的map

       50、RemoteRegionUrls

       远程地区的URL列表

       51、RemoteRegionAppWhitelist（*）

       必须通过远程区域中检索的应用程序的列表

       52、RemoteRegionRegistryFetchInterval

       从远程区域取出该注册表的信息的时间间隔，默认为30秒

       53、RemoteRegionFetchThreadPoolSize

       用于执行远程区域注册表请求的线程池的大小，默认为20

       54、RemoteRegionTrustStore

       用来合格请求远程区域注册表的信任存储文件，默认为空

       55、RemoteRegionTrustStorePassword

       获取偏远地区信任存储文件的密码，默认为“changeit”

       56、disableTransparentFallbackToOtherRegion(*)

       如果在远程区域本地没有实例运行，对于应用程序回退的旧行为是否被禁用， 默认为false

       57、BatchReplication(*)

       表示集群节点之间的复制是否为了网络效率而进行批处理，默认为false

       58、LogIdentityHeaders(*)

       Eureka服务器是否应该登录clientAuthHeaders，默认为true

       59、RateLimiterEnabled

       限流是否应启用或禁用，默认为false

       60、RateLimiterThrottleStandardClients

       是否对标准客户端进行限流，默认false

       61、RateLimiterPrivilegedClients（*）

       认证的客户端列表，这里是除了标准的eureka Java客户端。

       62、RateLimiterBurstSize（*）

       速率限制的burst size ，默认为10，这里用的是令牌桶算法

       63、RateLimiterRegistryFetchAverageRate(*)

       速率限制器用的是令牌桶算法，此配置指定平均执行注册请求速率，默认为500

       64、RateLimiterFullFetchAverageRate（*）

       速率限制器用的是令牌桶算法，此配置指定平均执行请求速率，默认为100

       65、ListAutoScalingGroupsRoleName（*）

       用来描述从AWS第三账户的自动缩放组中的角色名称，默认为“ListAutoScalingGroups”

       66、JsonCodecName（*）

       如果没有设置默认的编解码器将使用全JSON编解码器，获取的是编码器的类名称

       67、XmlCodecName(*)

       如果没有设置默认的编解码器将使用xml编解码器，获取的是编码器的类名称

       68、BindingStrategy(*)

       获取配置绑定EIP或Route53的策略。

       69、Route53DomainTTL（*）

       用于建立route53域的ttl，默认为301

       70、Route53BindRebindRetries（*）

       服务器尝试绑定到候选Route53域的次数，默认为3

       71、Route53BindingRetryIntervalMs（*）

       服务器应该检查是否和Route53域绑定的时间间隔，默认为5 * 60 * 1000毫秒

       72、Experimental(*)


Spring IOC源码深度剖析
	1.IOC容器的组成逻辑与体系结构
	2.BeanFactory对Bean的实例化过程
	3.Beandefinition定义的组成
	4.依赖注入的实现逻辑

	IOC容器
		管理Bean(BeanFactory):
			Bean的创建
			Bean的存储
			Bean的获取
			自动完成依赖检测和注入
			自动生成Bean
		Bean的定义
			定义,载入,注册
			Bean属性定义:
				name
				id
				scope(单例,多例)
				className
				parent
				lazyInit
				denpends
				Property
			Bean定义存储:
				XML
				Propertyes
		加载解析Bean
			加载XML文件流
			转换成Document
			解析注册BeanDefinition
		Spring IOC实现流程
			加载注册BeanDefinition
			创建Bean的具体实例
			依赖具体实现


Spring AOP(面向切面):
	当需要批量的定义程序逻辑
	通知拦截组件
	AOP定义组件
		proxyConfig
			AdviseSupport
				AspectProxyFactory
				ProxyFactory
				ProxyFactoryBean
	调用执行组件
		java proxy
		cglib proxy
	其他
		AopProxyBeanFactory
		AopProxy

		

源码解析:
	Spring解析Bean:
		scan
		parse
		调用扩展
		遍历map validate
		new
	Spring最终产生一个Bean跟类没有很大的直接关系,跟类对应的BeanDefinition有关系

	bean->spring bean
	java对象->对象

	循环依赖
		怎么证明Spring默认支持循环依赖
		在类AbstractAutowireCapableBeanFactory中有个allowCircularReferences自动,这个字段默认为true
			boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));

		IndexService object注入UserService->容器getBean(userService)->从容器中->拿不到->开始new UserService->object user->
		注入IndexService->容器getBean(index)(这里拿不到,最终能拿到,从第三个缓存中拿,因为IndexService还是一个对象)

	Spring初始化的流程中会调用9次后置处理器

	map singleobjets = new hashmap
	BeanDefiniton Scanner BeanFactoryPostProcessor

	spring的9个后置处理器
		BeanPostProcessor
		InstantiationAwareBeanPostProcessor
		CommonAnnotationBeanPostProcessor
		InitDestroyAnnotationBeanPostProcessor
		DestructionAwareBeanPostProcessor

	ApplicationContextAwareProcessor类提供了对Aware扩展点的支持
	org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization
	方法会调用invokeAwareInterfaces方法
		private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
			}
			if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}
			if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			//spring帮你set一个applicationContext对象
			//所以当我们自己的一个对象实现了ApplicationContextAware对象只需要提供setter就可以获取到
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}

spring的9个后置处理器:
	1.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
		applyBeanPostProcessorsBeforeInstantiation
		applyBeanPostProcessorsAfterInitialization
	2.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#determineConstructorsFromBeanPostProcessors
		用于推断构造方法
		determineCandidateConstructors
	3.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors
		postProcessMergedBeanDefinition
	4.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getEarlyBeanReference
		getEarlyBeanReference
	5.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
		InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
		判断是否需要自动注入属性
	6.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
		InstantiationAwareBeanPostProcessor.postProcessProperties
	7.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization
		BeanPostProcessor.postProcessBeforeInitialization
	8.org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
		BeanPostProcessor.postProcessAfterInitialization
	9.org.springframework.beans.factory.support.AbstractBeanFactory#registerDisposableBeanIfNecessary


如何把第三方的对象或者自己产生的对象交给spring管理
	@Service,@Compent 类交给spring管理,然后spring实例化这个对象然后放入容器进行管理

SpringAop中事务失效的情况
	1.方法修饰符为private
	2.类中有A,B方法,A方法无事务,B方法有事务,A方法中调用了B事务
	3.数据库不支持事务
	4.异常被catch掉了
	5.@Transactional注解属性rollbackFor设置错误
	6.@Transactional注解属性propagation设置错误
	7.如果采用spring+spring mvc,则context:component-scan重复扫描问题可能会引起事务失败

循环依赖:
      概念:
            Java中的循环依赖分两种，一种是构造器的循环依赖，另一种是属性的循环依赖
            构造器循环依赖:
                  构造器的循环依赖就是在构造器中有属性循环依赖，如下所示的两个类就属于构造器循环依赖
                  这种循环依赖没有什么解决办法，因为JVM虚拟机在对类进行实例化的时候，需先实例化构造器的参数，而由于循环引用这个参数无法提前实例化，故只能抛出错误
                  BeanCurrentylyInCreationException
                  Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中，bean表示符在创建过程中将一直保持在这个池中，因此，如果在创建bean过程中发现自己
                  已经在“当前创建bean池”中，将抛出BeanCurrentylyInCreationException异常，表示循环依赖；对于创建完毕的bean，将从“当前创建bean池”中清除掉

            属性的循环依赖:
                  Spring解决的循环依赖就是指属性的循环依赖

      循环依赖与属性注入:
            对于非懒加载的类，是在refresh方法中的 finishBeanFactoryInitialization(beanFactory) 方法完成的包扫描以及bean的初始化
            三个map缓存的优先级:
                  先后顺序是，单例对象先存在于singletonFactories中，后存在于earlySingletonObjects中，最后初始化完成后放入singletonObjects中

      Spring中执行回调方法的顺序
            1.@PostConstruct
            2.xml中指定的,如init-method
            3.实现了接口的


      如何把第三方的对象或自己产生的对象交给spring管理
            1.@Bean
            2.api register
            3.fb
            4.fm

      生命周期
            1.实例化
            2.填入属性
            3.事件通知
            4.使用
            5.销毁

      对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责:
      容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了
      不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法。但对prototype而言，任何配置好的析构生命周期回
      调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的
      职责。（让Spring容器释放被prototype作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持
      有要被清除的bean的引用。）谈及prototype作用域的bean时，在某些方面你可以将Spring容器的角色看作是Java 
      new操作的替代者。任何迟于该时间点的生命周期事宜都得交由客户端来处理

      生命周期的管理方式
            init和destroy
                  init-method
                  distroy-method
            InitializingBean和DisposableBean
                  org.springframework.beans.factory.InitializingBean接口，在其他初始化工作完成后，才开始调用他的afterPropertiesSet()方法.
                  org.springframework.beans.factory.DisposableBean接口，在容器销毁时，会调用destroy()这个方法
            @PostConstruct和@PreDestroy
                  @PostConstruct和@PreDestroy不属于spring,而是属于JSR-250规则,日常用的较多的还是这两个注解.
            执行顺序:
                  初始化:@PostConstruct > InitializingBean的afterPropertiesSet()方法 > init()方法。
                  销毁:@PreDestroy > DisposableBean的destroy()方法 > destroy()方法

    Spring的编程风格
    	schema-based--xml
    	annotation-based--annotation
    	java-based--javaconfig
    Spirng注入方式
    	1.构造器注入
    	2.setter方法注入
    	以前还有接口注入,但是后面不用了

    缓存中获取单例
        在创建单例Bean的时候会存在依赖注入的情况，为了避免循环依赖，Spring创建bean的原则是不等bean创建完，就将创建bean的ObjectFactory
        提早暴露出来加入缓存中，一旦下一个bean需要依赖上个bean，则直接使用ObjectFactory

    Spring AOP
        aspect一定要给spring去管理
        pointcut:切点表示连接点的集合
        joinpoint:连接点表示目标中的方法
        weaving:把代理逻辑加入到目标对象上的过程叫做织入
        advice:通知
        通知类型:
            before
            after throwing
            after(finally)
            around advice
        proceedingjoinpoint和joinpoint的区别

    Spring实现AOP的思路:
        1:创建AnnotationAwareAspectJAutoProxyCreator对象
        2:扫描容器中的切面,创建PointcutAdvisor对象
        3:生成代理类

        org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary方法的处理逻辑
            1.如果已经处理过，且该bean没有被代理过，则直接返回该bean
            2.如果该bean是内部基础设置类Class 或 配置了该bean不需要代理，则直接返回bean（返回前标记该bean已被处理过）
            3.获取所有适合该bean的增强Advisor如果增强不为null，则为该bean创建代理对象，并返回结果标记该bean已经被处理过

        继承自Advice、Pointcut、Advisor、AopInfrastructureBean无法被增强
        如果一个bean继承自Advice、Pointcut、Advisor、AopInfrastructureBean或者带有@Aspect注解,或被AjcAspectJ编译器)
        编译都会被认定为内部基础设置类

        proxy-target-class:
            强制使用CGLib为目标对象创建代理（如果没有设置该属性的话，如果目标对象实现了至少一个接口
            则会使用JDK的动态代理）。但是，CGLib的有两个问题需要考虑:
                1.无法代理final class，因为CGLib是通过生成子类来创建代理对象的
                2.需要无参构造函数
        expose-proxy:
            为了解决目标对象内部的自我调用时，无法实现切面的增强的问题

        Spring原码导入Idea问题
            spring-core报错，缺失DefaultNamingPolicy类
                  执行gradle objenesisRepackJar和gradle cglibRepackJar

    BeanFactoryPostProccessor
    BeanDefinitionRegistryPostProccessor

    AOP在BeanPostProccessor中实现


Spring IOC容器的内建依赖
    1.ConfigurationClassPostProcessor对象
        处理Spring配置类
    2.AutowiredAnnotationBeanPostProcessor对象
        处理@Autowired和@Value注解
    3.CommonAnnotationBeanPostProcessor对象
        条件激活,处理JSR-250注解,如@PostConstruct等
    4.EventListenerMethodProcessor对象
        处理标注@EventListener的Spring事件监听方法
    5.DefaultEventListenerFactory对象
        @EventListener事件监听方法适配为ApplicationListener
    6.PersistenceAnnotationBeanPostProcessor对象
        条件激活,处理JPA注解场景的

    AnnotationConfigUtils中注册了上面这几个对象


    FactoryBean的着重于自定义创建对象过程,由BeanFactory通过FactoryBean来获取目标对而如果是isSingleton返回true的话spring会利用单例缓存来缓存通过FactoryBean创建的对象

    而ObjectFactory就是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而
    创建的时机交给拓展接口Scope，除此之外ObjectFactory就是一个普通的接口。
    此外在将给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。

    简单来说就是通过FactoryBean你可以控制对象如何创建，而ObjectFactory借助Scope接口自定义scope你可以控制对象的创建时机

    ObjectFactory与BeanFactory的区别
        ObjectFactory和BeanFactory均提供依赖查找的能力
        不过ObjectFactory仅关注一个或一种类型的Bean依赖查找,并且自身不具备依赖查找的能力,能力则由BeanFactory输出.
        BeanFactory则提供了单一类型,集合类型以及层次性等多种依赖查找方式
    BeanFactory.getBean操作是否线程安全
        是线程安全的,操作过程中会增加互斥锁
    Spring依赖查找和注意在来源上的区别

BeanDefinition的注册是通过DefaultListableBeanFactory来实现的.在注册的时候为了确保
注册的顺序,冗余了一个字段beanDefinationNames,帮助我们来确保在未来的初始化过程中按照
顺序来执行.

依赖来源
    单体对象
        要素
            外部普通java对象,不一定要是POJO
            注册通过SingletonBeanRegistry#registerSingleton
        限制:
            无生命周期管理
            无法实现延迟初始化Bean
        
通常而言,Servlet程序会包含了SpringMVC的两个上下文,即RootApplication和DispatcherServlet所关联应用上下文,按数量来说是一比一的

page->request->session>application

org.springframework.cloud.context.scope.refresh.RefreshScope#eagerlyInitialize过滤哪些是refresh哪些不是refresh的

BeanDefinition配置
    1.面向资源
        XML配置
        Properties资源配置
    2.面向注解
    3.面向API
BeanDefinition元信息解析阶段
    面向资源BeanDefinition解析
        BeanDefinitionReader
        XML解析器-BeanDefinitionParser
    面向注解BeanDefinition解析
        AnnotatedBeanDefinitionReader

Spring Bean属性值元信息
    PropertyValues
Spring Bean赋值前回调
    org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessPropertyValues
    org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessProperties

Spring Bean生命周期
    Spring Bean初始化前阶段
        已完成
            Bean实例化
            Bean属性赋值
            Bean Aware接口回调
        方法回调
            org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization
    Spring Bean的初始化阶段
        @PostConstruct标注方法
        实现org.springframework.beans.factory.InitializingBean#afterPropertiesSet方法
        自定义初始化方法
    Spring Bean初始化后阶段
        方法回调
            org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization
    Spring Bean初始化完成阶段
        方法回调
            org.springframework.beans.factory.SmartInitializingSingleton#afterSingletonsInstantiated
            这个方法在org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
            这里进行调用
    Spring Bean销毁前阶段
        方法回调
            org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
            InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata#invokeDestroyMethods


Spring配置元信息
    org.springframework.beans.factory.config.BeanDefinition
        org.springframework.beans.factory.annotation.AnnotatedBeanDefinition
        org.springframework.beans.factory.support.AbstractBeanDefinition
    Bean属性元信息
        PropertyValues
            可修改实现
                MutablePropertyValues
            元素成员
                PropertyValue
    Bean属性上下文存储
        AttributeAccessor
    Bean元信息元素
        BeanMetadataElement

org.springframework.context.event.GenericApplicationListener这个接口对org.springframework.context.ApplicationListener
这个接口进行了扩展
Spring依赖查找和注意在来源上的区别

Spring的Aop就是在BeanPostProcessor中实现的
Spring为什么要使用三级缓存

精通https底层原理以及https下的安全原理,管理公司证书

Spring转换器
    提供了三种类型的转换器
        1.Converter
        2.ConverterFactory
        3.GenericConverter
    分别用来处理 1:1、1:N、N:N 的类型转换

    ConversionService
        统一管理所有的类型转换器，负责注册、查找、转换等功能，统一对外提供服务
        ConversionService 类型转换。
        ConverterRegistry 转换器注册、删除、查找功能。
        ConfigurableConversionService 集合了上面两个接口的功能。
        GenericConversionService 实现了 ConfigurableConversionService 接口，Spring 使用的 ConversionService 都是基于这个类的扩展。
        DefaultConversionService 扩展 GenericConversionService，注册了一批默认的转换器
    DefaultConversionService
        ConversionService有一个默认的实现DefaultConversionService,这个类在初始化时会添加Spring默认的转换器,大部分时候使用这个实现就可以完成所需要的功能


ignoreDependency方法忽略指定依赖类型的自动装配,ignoreDependency和ignoreDependencyInterface不同的是一个前者按照class类型进行忽略自动装配,后者按照接口中的set方法进行忽略自动装配.
ignoreDependency和ignoreDependencyInterface方法的忽略自动装配和自动绑定方式无关!

ignoreDependencyInterface方法忽略指定依赖接口的自动装配指的是忽略接口中的set方法这样的自动装配方式

ignoreDependency忽略指定依赖类型的自动装配指的是忽略参数class类型的自动装配.

以上两种忽略方式都和自动装配(自动绑定)的方式无关.


InstantiationStrategy实例化策略

默认标签的解析过程：

DefaultBeanDefinitonDocumentReader class中processBeanDefinition

(1)     该方法先解析element元素获得BeanDefinitionHolder,

(2)     由BeanDefintionParserDelegate对于holder进行装饰加工

(3)     由BeanDefinitionReaderUtils.registerBeanDefinition对于holder进行注册

(4)     之后发送注册事件getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))


EmbeddedValueResolver