java复制代码> 实例化过程
    1 实例化Bean 对象 : Spring 容器根据实例化策略对 Bean 进行实例化
        ?- 常用策略模式 , 通常包括反射和 CGLIB 动态字节码
            - SimpleInstantiationStrategy : 反射
            - CglibSubclassingInstantiationStrategy : 通过 CGLIB 的动态字节码 (默认)
    	- createBeanInstance(...) 方法实现 ,返回 BeanWrapper 
            - BeanWrapper  : 低级 Bean 基础结构的核心接口
            ?- 低级 Bean : 无任何属性
    	- BeanWrapperImpl 对  Bean 进行“包裹” ,用于注入Bean 属性
    	|- InstantiationStrategy -> SimpleInstantiationStrategy 
    	|- SimpleInstantiationStrategy -> CglibSubclassingInstantiationStrategy 
    2 注入对象属性
        |- 实例化完成后，如果该 bean 设置了一些属性的话，则利用 set 方法设置一些属性
    3 检测 , 激活 Aware
    	| -感知 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
    	|- 如果该 Bean 实现了 BeanNameAware 接口
            |- 则调用 #setBeanName(String beanName) 方法
    4 BeanPostProcessor 前置处理
        |- 如果该 bean 实现了 BeanClassLoaderAware 接口
            |- 则调用 setBeanClassLoader(ClassLoader classLoader) 方法。
        |- 如果该 bean 实现了 BeanFactoryAware接口
            |- 则调用 setBeanFactory(BeanFactory beanFactory) 方法
        |- 如果该容器注册了 BeanPostProcessor
            |- 则会调用#postProcessBeforeInitialization
            |- 完成 bean 前置处理
    5 检查 InitializingBean 和 init-method
        |- 如果该 bean 实现了 InitializingBean 接口
            |-则调用#afterPropertiesSet() 方法
        |- 如果该 bean 配置了 init-method 方法，则调用其指定的方法。
    6 BeanPostProcessor 后置处理
        |- 初始化完成后，如果该容器注册了 BeanPostProcessor 
            |- 则会调用 #postProcessAfterInitialization,完成 bean 的后置处理。
    7 注册必要的Destruction 回调
    8 使用Bean
        |- 对象完成初始化，开始方法调用
    9 检查 DisposableBean 和 destory-method
    	|- 在容器进行关闭之前，如果该 bean 实现了 DisposableBean 接口
            |- 则调用 #destroy() 方法
            |- 在容器进行关闭之前，如果该 bean 配置了 destroy-method 
            |- 则调用其指定的方法。

java复制代码C171- AbstractBeanFactory 
	M171_01- getBean(String name, Class<T> requiredType)
            ?- 直接调用 doGetBean , 这里会根据类型不同调用不同的 getBean

java复制代码// 核心方法一 : 
M171_02- doGetBean( String name, Class<T> requiredType,Object[] args, boolean typeCheckOnly)
        	
    // 阶段一 : 生成 beanName 后尝试从单例缓存中获取
    1- transformedBeanName 生成 beanName -> PS:M171_02_01
    2- getSingleton(beanName) : 单例方式获取一个 Bean , 循环依赖就是这个环节处理 -> -> PS:M171_02_02 
    IF- sharedInstance != null : 如果此时已经生成 , 且 args 为空不需要继续加载
        - getObjectForBeanInstance(sharedInstance, name, beanName, null) 
        
    // 阶段二 : 单例缓存中获取失败后 ,尝试 ParentBeanFactory 中获取
    ELSE- 
        3- isPrototypeCurrentlyInCreation(beanName) : 如果是原型模式且存在循环依赖则抛出异常
        4- getParentBeanFactory() : 检查这个工厂中是否存在bean定义
            ?- 如果工厂中已经存在了 , 会有四种情况会直接 return -> PS:M171_02_03
            4.1- AbstractBeanFactory :  parentBeanFactory.doGetBean
            4.2- args != null : parentBeanFactory.getBean(nameToLookup, args)
            4.3- requiredType != null: parentBeanFactory.getBean(nameToLookup, requiredType)
            4.4- 都不符合 : parentBeanFactory.getBean(nameToLookup)
        - 如果为类型检查而获取实例，而不是实际使用 , 则将指定的bean标记为已经创建 -> PS:M171_02_04
        - RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName) + checkMergedBeanDefinition
            ?- RootBeanDefinition的获取和检查  LV171_001
            
        // 阶段三 : 依赖检查 , 保证初始化当前bean所依赖的bean
        -  对于属性 LV171_001:mbd , 通过 getDependsOn 获取所有依赖
        FOR- 循环所有的依赖 , 分别调用 registerDependentBean + getBean 进行递归操作
        
        // 阶段四 : 三种不同的类型获得 Bean 实例
        5- 判断 Bean 的类型不同创建 Bean -> PS:M171_02_05 
            5.1- isSingleton : getSingleton + createBean + getObjectForBeanInstance
            5.2- isPrototype : beforePrototypeCreation + createBean + afterPrototypeCreation  + getObjectForBeanInstance
            5.3- 其他 : 主要是通过 Scope 控制域 + Prototype 流程
            
        // 阶段五 : 此时 Bean 已经准备完成了 , 此处检查所需的类型是否与实际bean实例的类型匹配
        IF- 如果实例不匹配 , 则需要转换, 转换后直接返回
            - return getTypeConverter().convertIfNecessary(bean, requiredType)
        // 如果上面没有返回 , 则直接发返回原本的Bean 
                        
                       
// 其他方法
M171_10- getSingleton(String beanName, ObjectFactory<?> singletonFactory) : 获取单例 Bean
M171_20- getObject() : 这里实际是调用 FactoryBean
    ?- 这里会通过一个 方法回调的语法糖 , 调用 createBean , 整个就连起来了 -> M173_02
                        
                        
// 核心方法二 : 实例化 Bean    
// 首先要知道 , 前面传过来的是什么 : TODO                     
M171_ - getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd)

                        
// PS : doGetBean 在附录中展示

java复制代码--> canonicalName(BeanFactoryUtils.transformedBeanName(name))
----> 
C181- SimpleAliasRegistry
    F181_01- Map<String, String> aliasMap
    M- canonicalName(BeanFactoryUtils.transformedBeanName(name))
        - 主要是从 F181_01 中获取 alias 别名
            ?- PS : 这里的代码有点意思 , 看样子是为了解决别名链的问题 , 即别名对应的还有别名 , 直到取不出来

public String canonicalName(String name) {
    String canonicalName = name;
    String resolvedName;
    do {
        
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    // 循环获取别名对应的是否存在别名 , 直到获取不到
    }while (resolvedName != null);
    return canonicalName;
}

java复制代码4.1- AbstractBeanFactory :  parentBeanFactory.doGetBean
4.2- args != null : parentBeanFactory.getBean(nameToLookup, args)
    ?- 使用显式参数委托给父类
4.3- requiredType != null: parentBeanFactory.getBean(nameToLookup, requiredType)
    ?- 委托给标准的getBean方法
4.4- 都不符合 : parentBeanFactory.getBean(nameToLookup)
    ?- Pro2
    
// 这里直接返回是因为存在父 BeanFactory , 且存在 BeanDefinition , 这就意味着ParentBeanFactory 能处理 , 基于 Pro 1 的原因 , 选择直接返回 
    
    
// Pro 1 :  为什么从父工厂里面获取 -> BeanFactory parentBeanFactory = getParentBeanFactory();
这是一个递归操作 , 也是仿照双亲委派的方式来处理 , 即先有父对象来加载对应的对象

同样的 , 当进入 doGet 的时候 , 默认通过父方法去加载 , 如果父方法处理完成了 , 即加载出 Bean 了 , 就直接返回
好处呢 , 想了一下 , 可以保证每个实现能专注于其本身需要处理的 Bean , 而不需要关注原本就会加载的 Bean 
回顾一下双亲委派的目的 : 避免重复加载 + 避免核心类篡改    
    
// Pro 2 : 四种方式去返回的区别
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

java复制代码    
这里如果是只检查而无需创建 , 会在 markBeanAsCreated 方法中做2件事
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);    

这样的目的是为了即标注方法已经检查成功 , 而避免走没必要的反复流程 ,允许bean工厂为重复创建指定bean而优化其缓存 
--> 实际逻辑    

// Step 1 : alreadyCreated 是什么 ?
Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
    ?- alreadyCreated 包含 至少已经创建过一次的bean的名称的 Set 集合

// Step 2 : 如何利用这个对象 ?
1 : AbstractAutowireCapableBeanFactory # getTypeForFactoryBean
    ?- 这里会通过这个对象校验引用的工厂bean还不存在，那么在这里退出——不会仅仅为了获取FactoryBean的对象类型而强制创建另一个bean
    
2 : clearMetadata 时 , 需要判断是否为空

java复制代码相同点 :  最终调用 getObjectForBeanInstance    
5.1- isSingleton : getSingleton + createBean + getObjectForBeanInstance
    - 首先通过 getSingleton 方法, 保证加载的唯一性
    - 回调 createBean 创建 Bean
    - 通过 getObjectForBeanInstance 实例化真正的 Bean
    
5.2- isPrototype : beforePrototypeCreation + createBean + afterPrototypeCreation  + getObjectForBeanInstance
    - 仔细看就能发现 , 没有相关的 scope 对象控制 , 直接进行创建
    
5.3- 其他 : 主要是通过 Scope 控制域 + Prototype 流程
    - 它是 singleton 的结合体 , 
    - 首先会准备一个 Scope 对象用于控制 Scope 域内的 Bean 情况
    - 再调用和 Prototype 一致的流程进行创建

JAVA复制代码if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, () -> {
        try {
            return createBean(beanName, mbd, args);
        }catch (BeansException ex) {
            destroySingleton(beanName);
            throw ex;
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

// 这就涉及到 Bean 的工厂了 , 一般情况下 , createBean 创建的 Bean 就是一个 完整的 Bean
// 但是 ,如果它是一个FactoryBean，需要使用它来创建一个bean实例，除非调用者实际上想要一个对工厂的引用。

java复制代码C171- AbstractBeanFactory 
	M171_03- createBean(String beanName, RootBeanDefinition mbd, Object[] args) 
            P- mbd :  BeanDefinition 对象 , 已经合并了父类属性
            p- args : 用于构造函数或者工厂方法创建 Bean 实例对象的参数

java复制代码C173- AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
    M173_02- createBean(String beanName, RootBeanDefinition mbd,Object[] args)
        ?- M170_01 方法的默认实现
        LV173_02_01- RootBeanDefinition mbdToUse : 内部属性 , 用于标识根 BeanDefinition 
        1- Class<?> resolvedClass = resolveBeanClass(mbd, beanName) -> PS:M173_02_01
            ?- 解析获得指定 BeanDefinition 的 class 属性 -> M173_04
        IF- 解析的 Class 不为 null , 且存在 BeanClass 和 BeanClassName
            - new RootBeanDefinition(mbd)
            - mbdToUse.setBeanClass(resolvedClass)
        2- mbdToUse.prepareMethodOverrides() : 处理 Overrides 属性 -> PS:M173_02_02
             - GetMethodOverrides().getOverrides()
             - prepareMethodOverride(MethodOverride mo)
        3- Object bean = resolveBeforeInstantiation(beanName, mbdToUse) --- 实例化的前置处理 
        - 如果 bean 不为 null , 则直接返回 (直接返回是因为上一步生成了一个代理类 ,AOP )
        4- Object beanInstance = doCreateBean(beanName, mbdToUse, args); --- 创建对象
    M173_03- createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    M173_04- resolveBeanClass : 将bean类名解析为class引用  
    
    
    
// PS:M173_02_01 RootBeanDefinition 
// 确保bean类在此时被实际解析，如果动态解析的class不能存储在共享合并bean定义中，则克隆bean定义
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    mbdToUse = new RootBeanDefinition(mbd);
    mbdToUse.setBeanClass(resolvedClass);
}

// PS:M173_02_02 prepareMethodOverrides 处理 Overrides
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    if (hasMethodOverrides()) {
        getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
    }
}

// >>>>>>> 对应 prepareMethodOverride 方法
C- AbstractBeanDefinition
    M-  prepareMethodOverride(MethodOverride mo)
        1- ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName())
            ?- 获取当前Method Name 对应的方法数量
        2- 如果没有对应方法 ,抛出 BeanDefinitionValidationException 
        3- 如果 count = 1 , 将 Overloaded 标记为未重载 , 在后续调用的时候，可以直接找到方法而不需要进行方法参数的校验


// M173_02 源码简介
M- createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    -  beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
    -  beanInstance = this.doCreateBean(beanName, mbdToUse, args); -> M173_05

java复制代码 C173- AbstractAutowireCapableBeanFactory extends AbstractBeanFactory   
    M173_05- doCreateBean(beanName, mbdToUse, args) : 创建 Bean 对象
        ?- 非代理对象的 常规Bean 创建 , 主要节点有以下几个
        - 准备 BeanWrapper : BeanWrapper 是对 Bean 的包装
        - 如果单例模型，则从未完成的 FactoryBean 缓存中删除
        - createBeanInstance(beanName, mbd, args) : 进入Bean 创建流程 , 创建一个 Bean 的封装 BeanWrapper 
            ?- 这里的获取如果是单例 , 则直接获取 , 并且移除缓存中的对象 
            ?- 否则调用 createBeanInstance 获取
        - instanceWrapper.getWrappedInstance();
            ?- 包装的实例对象
        - instanceWrapper.getWrappedClass();
            ?- 包装的实例对象的类型
    	IF- applyMergedBeanDefinitionPostProcessors
            ?- 如果有后置处理 , 则在此处进行后置处理 , synchronized 上锁
    	IF- addSingletonFactory 
            ?- 如果是单例 , 且允许+ 存在循环依赖 , 则在此处进行单例模式的处理
    	- populateBean : 属性注入操作 -> M173_30
    	- initializeBean : 初始化 Bean 
            ?- 此处会进行 Init-Method 的处理 ->  PS:M173_05_03
    	IF- getSingleton 
            ?- 循环依赖情况 , 则会递归初始依赖 bean , 此处返回的是一个用于循环处理的空对象
            ?- 2种情况 , 返回早期对象或者 getDependentBeans 递归所有的 -> PS:M173_05_01
    	- registerDisposableBeanIfNecessary
    M173_07- prepareMethodOverrides
        - 获取所有的 Overrides , 并且依次调用 prepareMethodOverride -> M173_08
        
    M173_08- prepareMethodOverride
        - getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride)
            ?- Foreach 所有的 Overrides , 调用 prepareMethodOverride
    M173_10- autowireByName : 根据属性名称，完成自动依赖注入
    M173_11- autowireByType : 根据属性类型，完成自动依赖注入
        - resolveDependency -> resolveDependency
    M173_12- resolveDependency : 完成了所有注入属性的获取
        - doResolveDependency
    M173_13- doResolveDependency	
    M173_15- applyPropertyValues : 应用到已经实例化的 bean 中
    M173_50- initializeBean



// doCreateBean 核心代码流程 
M- doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) : createBean 主流程
    - mbd.isSingleton() : 判断后获取 BeanWrapper (ConfigurationClassPostProcessor) 
        - instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        - instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    - this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    - this.populateBean(beanName, mbd, instanceWrapper) : 主要是属性填充
        - Step 1 : bw == null&&mbd.hasPropertyValues() : BeanWrapper 空值判断
        - Step 2 : this.getBeanPostProcessors().iterator() : 迭代BeanPostProcessors
            - ibp.postProcessAfterInstantiation : 此处是 After 
        - Step 3 : 获取 PropertyValue , 并且通过 autowireByName 或者 autowireByType 注入
        - Step 4 : hasInstantiationAwareBeanPostProcessors
            - this.getBeanPostProcessors().iterator();
            - ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
        - Step 5 : 
        - Step 6 : this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs) : 依赖检查
        - Step 7 : this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs) : 
    - this.initializeBean(beanName, exposedObject, mbd);
    - this.registerDisposableBeanIfNecessary(beanName, bean, mbd);     
    
    
// 附录 : M173_05 doCreateBean 源码比较长 ,放在结尾

java复制代码
在 doCreateBean 中 , 会对循环依赖进行处理

// 循环依赖情况 , 则会递归初始依赖 bean , 此处返回的是一个用于循环处理的空对象
// 2种情况 , 返回早期对象或者 getDependentBeans 递归所有的
if (earlySingletonExposure) {
    // 参考循环依赖那一章 , 这里可能会返回一个未完善的前置对象引用
    // 只有存在循环依赖 , 这里才不会为空
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
        if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
        // 判断存在循环依赖    
        }else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            // 返回依赖于指定bean的所有bean的名称(如果有的话)
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
                // 如果有被用于类型检查之外的其他目的时 ,则不可以删除 -> PS:M173_05_03
                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                    // 无需删除 , 则添加
                    actualDependentBeans.add(dependentBean);
                }
            }
            // 因为上文添加 , 这里就形成依赖
            if (!actualDependentBeans.isEmpty()) {
                throw new BeanCurrentlyInCreationException(".....");
            }
        }
    }
}

// PS:M173_05_03 : 什么是其他的目的 ? 
removeSingletonIfCreatedForTypeCheckOnly 核心是校验 alreadyCreated 
1 . 如果 alreadyCreated 已经存在了 ,则说明对应的对象已经创建完成了 
2 . 如果对应的对象已经创建完了了 , 其中依赖的当前对象不是正在创建的对象
3 . 但是其中的属性又不是当前的对象 , 说明循环依赖不成立 , 依赖已经串了

@ https://www.cnblogs.com/qinzj/p/11485018.html

java复制代码protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {

        // Step 1 : 准备 BeanWrapper : BeanWrapper 是对 Bean 的包装
        BeanWrapper instanceWrapper = null;
        
        if (mbd.isSingleton()) {
            // 如果单例模型，则从未完成的 FactoryBean 缓存中删除
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 进入Bean 创建流程 , 创建一个 Bean 的封装 BeanWrapper 
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        // 获取包装的实例对象
        final Object bean = instanceWrapper.getWrappedInstance();
        // 包装的实例对象的类型
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        //  Step 2 : 如果有后置处理 , 则在此处进行后置处理 , synchronized 上锁
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException("....");
                }
                mbd.postProcessed = true;
            }
        }

        // Step 3 :如果是单例 , 且允许+ 存在循环依赖 , 则在此处进行单例模式的处理
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {

            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Step 4 : 此处会进行 Init-Method 的处理 ->  PS:M173_05_03
        Object exposedObject = bean;
        try {
            // Step 5 :属性注入操作 -> M173_30
            populateBean(beanName, mbd, instanceWrapper);
            // Step 6 : 初始化 Bean 
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException("....");
            }
        }
    
    
        // 循环依赖情况 , 则会递归初始依赖 bean , 此处返回的是一个用于循环处理的空对象
        // 2种情况 , 返回早期对象或者 getDependentBeans 递归所有的 -> PS:M173_05_01
        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(".....");
                    }
                }
            }
        }

        // Step 7 : 注册 Bean
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException("...");
        }

        return exposedObject;
    }

java复制代码- C171- AbstractBeanFactory 
    - M171_02- doGetBean

java复制代码// Step 1 : 
C173- AbstractAutowireCapableBeanFactory 
    M173_02- createBea
    
// Step 2 : 
C173- AbstractAutowireCapableBeanFactory extends AbstractBeanFactory   
    M173_05- doCreateBean

java复制代码protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 阶段一 : 生成 beanName 后尝试从单例缓存中获取
        final String beanName = transformedBeanName(name);
        Object bean;
        
        // 单例方式获取一个 Bean , 循环依赖就是这个环节处理 -> -> PS:M171_02_02 
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            // 直接从实例化中获取 Bean
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {
            // 阶段二 : 单例缓存中获取失败后 
            if (isPrototypeCurrentlyInCreation(beanName)) {
                //  如果是原型模式且存在循环依赖则抛出异常
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // 检查这个工厂中是否存在bean定义
            BeanFactory parentBeanFactory = getParentBeanFactory();
            
            //  如果工厂中已经存在了 , 会有四种情况会直接 return -> PS:M171_02_03
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }

            //  如果为类型检查而获取实例，而不是实际使用 , 则将指定的bean标记为已经创建 -> PS:M171_02_04
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                // RootBeanDefinition的获取和检查  LV171_001
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // 阶段三 : 依赖检查 , 保证初始化当前bean所依赖的bean
                // 对于属性 LV171_001:mbd , 通过 getDependsOn 获取所有依赖
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    //  循环所有的依赖 , 分别调用 registerDependentBean + getBean 进行递归操作
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(.....);
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(.....);
                        }
                    }
                }

                // 阶段四 : 三种不同的类型获得 Bean 实例
                // 判断 Bean 的类型不同创建 Bean -> PS:M171_02_05 
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

                else {
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new BeanCreationException(....);
                    }
                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }

        // 阶段五 : 此时 Bean 已经准备完成了 , 此处检查所需的类型是否与实际bean实例的类型匹配
        // 如果实例不匹配 , 则需要转换, 转换后直接返回
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                }
                return convertedBean;
            }
            catch (TypeMismatchException ex) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        // 如果上面没有返回 , 则直接发返回原本的Bean 
        return (T) bean;
    }

less复制代码for &e in &[1, 2, 3] {} // Ok :)

for e in [1, 2, 3] {} // Error :(

ini复制代码let a = SomeStruct::new();

drop(a.x); // Move out of one field of the struct

println!("{}", a.y); // Ok: Still use another field of the struct

let c = || println!("{}", a.y); // Error: Tries to capture all of `a`
c();

go复制代码panic!("{}", 1); // Ok, panics with the message "1"
panic!("{}"); // Ok, panics with the message "{}"

ini复制代码let a = "{";
println!(a); // Error: First argument must be a format string literal
panic!(a); // Ok: The panic macro doesn't care

ini复制代码高峰期的时候 每秒会有5.5万的请求涌入，5.5/5 = 大约是每台服务器会有1万个请求涌入。
我们之前说的，
10000 * 50kb = 488M  也就是每条服务器，每秒要接受488M的数据。数据还要有副本，副本之间的同步
也是走的网络的请求。488 * 2 = 976m/s
说明一下：
   很多公司的数据，一个请求里面是没有50kb这么大的，我们公司是因为主机在生产端封装了数据
   然后把多条数据合并在一起了，所以我们的一个请求才会有这么大。
   
说明一下：
   一般情况下，网卡的带宽是达不到极限的，如果是千兆的网卡，我们能用的一般就是700M左右。
   但是如果最好的情况，我们还是使用万兆的网卡。
   如果使用的是万兆的，那就是很轻松。

css复制代码kafka-topics.sh --create --zookeeper hadoop1:2181,hadoop2:2181,hadoop3:2181 --replication-factor 1 --partitions 1 --topic test6
kafka-topics.sh --alter --zookeeper hadoop1:2181,hadoop2:2181,ha

css复制代码{“version”:1,“partitions”:[{“topic”:“test6”,“partition”:0,“replicas”:[0,1,2]},{“topic”:“test6”,“partition”:1,“replicas”:[0,1,2]},{“topic”:“test6”,“partition”:2,“replicas”:[0,1,2]}]}

css复制代码kafka-reassign-partitions.sh --zookeeper hadoop1:2181,hadoop2:2181,hadoop3:2181 --reassignment-json-file test.json --execute

css复制代码{“topics”: [{“topic”: “test01”}, {“topic”: “test02”}], “version”: 1} // 把你所有的topic都写在这里


kafka-reassgin-partitions.sh --zookeeper hadoop1:2181,hadoop2:2181,hadoop3:2181 --topics-to-move-json-file topics-to-move.json --broker-list “5,6” --generate

lua复制代码kafka-reassign-partitions.sh --zookeeper hadoop01:2181,hadoop02:2181,hadoop03:2181 --reassignment-json-file expand-cluster-reassignment.json --execute

kafka-reassign-partitions.sh --zookeeper hadoop01:2181,hadoop02:2181,hadoop03:2181 --reassignment-json-file expand-cluster-reassignment.json --verify

arduino复制代码public class HotDataPartitioner implements Partitioner {
private Random random;
@Override
public void configure(Map<String, ?> configs) {
random = new Random();
}
@Override
public int partition(String topic, Object keyObj, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
String key = (String)keyObj;
List partitionInfoList = cluster.availablePartitionsForTopic(topic);
//获取到分区的个数 0,1，2
int partitionCount = partitionInfoList.size();
//最后一个分区
int hotDataPartition = partitionCount - 1;
return !key.contains(“hot_data”) ? random.nextInt(partitionCount - 1) : hotDataPartition;
}
}

java复制代码import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.3.4.RELEASE</version>
    <scope>compile</scope>
</dependency>

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
    <version>2.3.4.RELEASE</version>
    <scope>compile</scope>
</dependency>

xml复制代码<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

xml复制代码<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

xml复制代码<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-console</artifactId>
    <version>${activemq.version}</version>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-logging</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
class Springboot03LoggingApplicationTests {

	Logger logger = LoggerFactory.getLogger(getClass());

	/**
	 * 日志的输出级别：由高到低 trace<debug<info<warn<error
	 * 可以调整日志的输出级别；设置日志输出级别后，日志只会在当前级别和以后的级别生效
	 */
	@Test
	void contextLoads() {
		logger.trace("trace级别日志。。。。。");
		logger.debug("debug级别日志。。。。。");
		// Spring Boot默认输出info级别的日志，没有指定日志级别则使用Spring Boot默认的级别（root级别）
		logger.info("info级别日志。。。。。");
		logger.warn("warn级别日志。。。。。");
		logger.error("error级别日志。。。。。");
	}

}

vbnet复制代码  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.3.4.RELEASE)

2020-10-20 14:46:25.049  INFO 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : Starting Springboot03LoggingApplicationTests on YOGA-S740 with PID 17748 (started by Bruce in E:\workspace\workspace_idea03\demo-springBoot\springboot03_logging)
2020-10-20 14:46:25.051  INFO 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : No active profile set, falling back to default profiles: default
2020-10-20 14:46:26.248  INFO 17748 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2020-10-20 14:46:26.520  INFO 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : Started Springboot03LoggingApplicationTests in 1.745 seconds (JVM running for 2.833)

2020-10-20 14:46:26.716  INFO 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : info级别日志。。。。。
2020-10-20 14:46:26.716  WARN 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : warn级别日志。。。。。
2020-10-20 14:46:26.716 ERROR 17748 --- [           main] .b.s.Springboot03LoggingApplicationTests : error级别日志。。。。。

properties复制代码# 配置日志的输出级别，可以为每个包和类单独配置日志输出级别
logging.level.cn.bruce=trace

# path指定日志的输出目录，会在磁盘根路径下创建spring文件夹，并在目录下生成spring.log文件记录日志信息
# 不加/则在项目目录下创建文件夹，并在文件夹内生成日志输出文件spring.log
#logging.file.path=/spring
# name指定输出文件的名称和路径，文件位置可以自由指定。path和name同时书写时只有name会生效
logging.file.name=E:/spring/demo-spring.log

# 指定控制台输出的日志样式
# %d表示日期时间，
# %thread表示线程名，
# %‐5level：级别从左显示5个字符宽度
# %logger{50} 表示logger名字最长50个字符，否则按照句点分割。
# %msg：日志消息，
# %n是换行符

logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} --> [%thread] --> %-5level --> %logger{50} --> %msg%n

# 指定文件输出日志样式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} === %msg%n

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- 在SpringBoot框架中排除logback日志框架 -->
        <exclusion>
            <artifactId>logback-classic</artifactId>
            <groupId>ch.qos.logback</groupId>
        </exclusion>
        <!-- 在SpringBoot框架中排除logback转换框架 -->
        <exclusion>
            <artifactId>log4j-to-slf4j</artifactId>
            <groupId>org.apache.logging.log4j</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 引入log4j适配包，将logback框架替换为log4j框架 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
</dependency>

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- 排除SpringBoot中logging的starter -->
        <exclusion>
            <artifactId>spring-boot-starter-logging</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 导入log4j的starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

kotlin复制代码    // Kotlin
    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.4.32"
    // 协程核心库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3"
    // 协程Android支持库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3"
    
    implementation "androidx.activity:activity-ktx:1.2.2"
    implementation "androidx.fragment:fragment-ktx:1.3.3"
    
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.3.1"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.3.1"
    
     // ok http
    implementation "com.squareup.okhttp3:okhttp:4.9.0"
    implementation 'com.squareup.okhttp3:logging-interceptor:4.9.0'

    // retrofit
    implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
    implementation "com.squareup.retrofit2:converter-scalars:$retrofit_version"
    implementation "com.squareup.retrofit2:converter-gson:$retrofit_version"

kotlin复制代码android {
    buildFeatures {
        dataBinding  = true
    }
   //省略...
}

kotlin复制代码http[s]://route.showapi.com/9-2?showapi_appid=替换自己的值&showapi_sign=替换自己的值

JSON复制代码{
    "showapi_res_error":"",
    "showapi_res_code":0,
    "showapi_res_body":{
        "time":"20210509180000", //预报发布时间
        "now":{
            "wind_direction":"西风", //风向
            "temperature_time":"01:30", //获得气温的时间
            "wind_power":"0级", //风力
            "aqi":"30", //空气指数，越小越好
            "sd":"40%", //空气湿度
            "weather_pic":"http://app1.showapi.com/weather/icon/day/00.png", //天气小图标
            "weather":"晴", //天气
            "rain":"0.0", //降水量（mm）
            "temperature":"15" //气温
        }
    }
}

KOTLIN复制代码data class CResponse<T>(
   @SerializedName("showapi_res_code")
   val code: Int,
   @SerializedName("showapi_res_error")
   val msg: String? = null,
   @SerializedName("showapi_res_body")
   val data: T
)

KOTLIN复制代码data class Weather(
   val now: WeatherDetail,
   val time: String
)

data class WeatherDetail(
   val aqi: String,
   val rain: String,
   val sd: String,
   val temperature: String,
   @SerializedName("temperature_time")
   val temperatureTime: String,
   val weather: String,
   @SerializedName("weather_pic")
   val weatherPic: String,
   @SerializedName("wind_direction")
   val windDirection: String,
   @SerializedName("windPower")
   val windPower: String
)

KOTLIN复制代码object ServerApi {
   val service: CoroutineService by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
       build()
   }
   
   private fun build():CoroutineService{
       val retrofit = Retrofit.Builder().apply {
           baseUrl(HttpConstant.HTTP_SERVER)
           client(OkHttpClientManager.mClient)
           addConverterFactory(ScalarsConverterFactory.create())
           addConverterFactory(GsonConverterFactory.create())
       }.build()
      return  retrofit.create(CoroutineService::class.java)
   }
}

object HttpConstant {
   internal val HTTP_SERVER = "https://route.showapi.com"
}

KOTLIN复制代码object OkHttpClientManager {

   val mClient: OkHttpClient by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
      buildClient()
  }

  private fun buildClient(): OkHttpClient {
      val logging = HttpLoggingInterceptor()
      logging.level = if (BuildConfig.DEBUG) HttpLoggingInterceptor.Level.BODY else HttpLoggingInterceptor.Level.NONE
      return OkHttpClient.Builder().apply {
          addInterceptor(CommonInterceptor())
          addInterceptor(logging)
          followSslRedirects(true)
      }.build()
  }
}

KOTLIN复制代码class CommonInterceptor : Interceptor {

   @Throws(IOException::class)
   override fun intercept(chain: Interceptor.Chain): Response {
       val oldRequest = chain.request()
       val httpUrl = oldRequest.url
       val host = httpUrl.host
       if (HttpConstant.HTTP_SERVER != host ) {
           return chain.proceed(oldRequest)
       }
       val urlBuilder = httpUrl.newBuilder()
       //这里填写自己申请appid和sign
       urlBuilder.addQueryParameter("showapi_appid", SHOW_API_APPID)
       urlBuilder.addQueryParameter("showapi_sign", SHOW_API_SIGN) 

       val request = oldRequest
           .newBuilder()
           .url(urlBuilder.build())
           .build()
       return chain.proceed(request)
   }
}

KOTLIN复制代码interface CoroutineService {
  @FormUrlEncoded
  @POST("/9-2")
  suspend fun getWeather(
      @Field("area") area: String
  ): CResponse<Weather>

KOTLIN复制代码class WeatherRepository {
    suspend fun getWeather(
        area: String
    ): CResponse<Weather>{
        return ServerApi.service.getWeather(area)
    }
}

KOTLIN复制代码class MainViewModel(private val repository: WeatherRepository):ViewModel() {

    private val _weather:MutableLiveData<Weather> = MutableLiveData()
    val mWeather: LiveData<Weather> = _weather

    fun getWeather( area: String){
        requestMain {
           val result =  repository.getWeather(area)
            _weather.postValue(result.data)
        }
    }
}

KOTLIN复制代码public inline fun <reified VM : ViewModel> ComponentActivity.viewModels(
    noinline factoryProducer: (() -> Factory)? = null
): Lazy<VM> {
    val factoryPromise = factoryProducer ?: {
        defaultViewModelProviderFactory
    }
    return ViewModelLazy(VM::class, { viewModelStore }, factoryPromise)
}

KOTLIN复制代码object ViewModelUtils {
    fun provideMainViewModelFactory(
    ): MainViewModelFactory {
        return MainViewModelFactory(MainRepository())
    }
}

class MainViewModelFactory(
    private val repository: MainRepository
) : ViewModelProvider.Factory {
    @Suppress("UNCHECKED_CAST")
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return MainViewModel(repository) as T
    }
}

KOTLIN复制代码class MainActivity : BaseActivity<ActivityMainBinding>() {
    private val viewModel by viewModels<MainViewModel> {
        ViewModelUtils.provideMainViewModelFactory()
    }
    override fun initObserve() {
        viewModel.mWeather.observe(this) {
            mBinding.contentTv.text = "$it"
        }
    }

    override fun ActivityMainBinding.initBinding() {
        this.mainViewModel = viewModel
    }
}

XML复制代码<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools">

    <data>
        <variable
            name="mainViewModel"
            type="com.carman.kotlin.coroutine.request.viewmodel.MainViewModel" />
    </data>
    
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".ui.MainActivity">

        <TextView
            android:id="@+id/content_tv"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="这里显示获取到的数据"
            android:textColor="@color/black"
            android:textSize="18sp"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />

    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

KOTLIN复制代码    fun getWeather(area: String){
        requestMain {
           val result = try {
               repository.getWeather(area)
           } catch (e: Exception) {
              when(e) {
                   is UnknownHostException -> {
                       //...
                   }
                    //...  各种需要单独处理的异常
                   is ConnectException -> {
                       //...
                   }
                   else ->{
                       //...
                   }
               }
               null
           }
            _weather.postValue(result?.data)
        }
    }

KOTLIN复制代码open class BaseRepository {

    suspend inline fun <reified T : Any> launchRequest(
        crossinline block: suspend () -> CResponse<T>,
        noinline onSuccess:  ((T?) -> Unit)? = null,
        noinline onError:  ((Exception)-> Unit) ? = null,
        noinline onComplete:  (() -> Unit)? = null ){
        try {
            val response = block()
            onSuccess?.invoke(response?.data)
        } catch (e: Exception) {
            e.printStackTrace()
            when (e) {
                is UnknownHostException -> {
                    //...
                }
                //...  各种需要单独处理的异常
                is ConnectException -> {
                    //...
                }
                else -> {
                    //...
                }
            }
            onError?.invoke(e)
        }finally {
            onComplete?.invoke()
        }
    }
}

KOTLIN复制代码    suspend fun getWeather(
        area: String,
        onSuccess:  (Weather?) -> Unit,
        onError:  (Exception) -> Unit,
        onComplete: () -> Unit,
    ){
        launchRequest({
            ServerApi.service.getWeather(area)
        }, onSuccess,onError, onComplete)
    }

KOTLIN复制代码    fun getWeather(area: String) {
        requestMain {
            repository.getWeather(area, {
                _weather.postValue(it)
            }, {
                it.printStackTrace()
                Log.d(Companion.TAG, "异常提示处理")
            }, {
                Log.d(TAG, "请求结束，处理收尾工作")
            })
        }
    }

KOTLIN复制代码    fun sendData(data: String) {
        requestMain {
            repository.launchRequest({
                repository.sendData(data)
            })
        }
    }

KOTLIN复制代码    suspend inline fun <reified T : Any> launchRequest(
        crossinline block: suspend () -> CResponse<T>,
        noinline onSuccess: ((T?) -> Unit)? = null,
        noinline onError: ((Exception) -> Unit)? = null,
        noinline onComplete: (() -> Unit)? = null
    ) {
        try {
            val response = block()
            when (response.code) {
                HttpConstant.OK -> {
                    val isListType = T::class.isSubclassOf(List::class)
                    if (response.data == null && isListType) {
                        onSuccess?.invoke(Collections.EMPTY_LIST as? T)
                    } else {
                        onSuccess?.invoke(response?.data)
                    }
                }
                else -> onError?.invoke(CException(response))
            }
        } catch (e: Exception) {
            e.printStackTrace()
            when (e) {
                is UnknownHostException -> {
                }
                //...  各种需要单独处理的异常
                is ConnectException -> {
                }
                else -> {
                }
            }
            onError?.invoke(e)
        } finally {
            onComplete?.invoke()
        }
    }

KOTLIN复制代码 val isListType = T::class.isSubclassOf(List::class)
 if (response.data == null && isListType) {
     onSuccess?.invoke(Collections.EMPTY_LIST as? T)
 } else {
     onSuccess?.invoke(response?.data)
 }

KOTLIN复制代码sealed class DataResult<out T> {
    data class Success<out T>(val data: T) : DataResult<T>()
    data class Error(val exception: Exception) : DataResult<Nothing>()
}

KOTLIN复制代码    suspend inline fun <reified T : Any> launchRequestForResult(
        noinline block: suspend () -> CResponse<T>
    ): DataResult<T> {
        return try {
            val response = block()
            if (0 == response.code) {
                val isListType = T::class.isSubclassOf(List::class)
                if (response.data == null && isListType) {
                    DataResult.Success(Collections.EMPTY_LIST as? T) as DataResult<T>
                } else {
                    DataResult.Success(response.data)
                }
            } else {
                DataResult.Error(CException(response))
            }
        } catch (e: Exception) {
            when (e) {
                is UnknownHostException -> {
                }
                //...  各种需要单独处理的异常
                is ConnectException -> {
                }
                else -> {
                }
            }
            DataResult.Error(e)
        }
    }

KOTLIN复制代码    suspend fun getWeather(area: String): DataResult<Weather> {
        return launchRequestForResult {
            ServerApi.service.getWeather(area)
        }
    }

KOTLIN复制代码    fun getWeatherForResult(area: String) {
        requestMain {
            val result = repository.getWeather(area)
            when(result){
                is   DataResult.Success ->{
                    _weather.postValue(result.data)
                }
                is   DataResult.Error ->{
                    Log.d(TAG, "${(result?.exception}")
                }
            }
        }
    }

KOTLIN复制代码    suspend inline fun <reified T : Any> launchRequest(
        crossinline block: suspend () -> CResponse<T>
    ): T? {
        return try {
            block()
        } catch (e: Exception) {
            e.printStackTrace()
            when (e) {
                is UnknownHostException -> {
                }
                //...  各种需要单独处理的异常
                is ConnectException -> {
                }
                else -> {
                }
            }
            throw e
        }?.run {
            if (0 == code) {
                val isListType = T::class.isSubclassOf(List::class)
                return if (data == null && isListType) {
                    Collections.EMPTY_LIST as? T
                } else {
                    data
                }
            } else {
                throw CException(this)
            }
        }
    }

KOTLIN复制代码    suspend inline fun <reified T : Any> launchRequest(
        crossinline block: suspend () -> CResponse<T>
    ): T? {
        return try {
            block()
        } catch (e: Exception) {
            null
        }?.run {
            if (0 == code) {
                val isListType = T::class.isSubclassOf(List::class)
                if (data == null && isListType) {
                    Collections.EMPTY_LIST as? T
                } else {
                    data
                }
            } else {
                throw CException(this)
            }
        } ?: let {
            null
        }
    }

KOTLIN复制代码    suspend fun getWeather(area: String): Weather? {
        return launchRequest{
            ServerApi.service.getWeather(area)
        }
    }

KOTLIN复制代码    fun getWeather(area: String) {
        requestMain {
            val weather = try {
                repository.getWeather(area)
            } catch (e: Exception) {
                //二次异常处理...
            }
        }
    }

KOTLIN复制代码class MainActivity05:AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        /** 或者携带实例化工厂
        val viewModel = ViewModelProvider(this,MainViewModelFactory(MainRepository())).get(MainViewModel::class.java) 
        或者
        val viewModel = ViewModelProvider(viewModelStore,MainViewModelFactory(MainRepository())).get(MainViewModel::class.java) */
        viewModel.mUser.observe(this) {
            Log.d("mUser","$it")
        }
    }
}

class MainViewModel：ViewModel() {
    private val _user:MutableLiveData<User> = MutableLiveData(User(1,"测试"))
    val mUser: LiveData<User> = _user
}

//创建一个最简单的ViewModel工厂
class MainViewModelFactory(
) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return MainViewModel() as T
    }
}

KOTLIN复制代码    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

KOTLIN复制代码class MainActivity:AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val viewModel = ViewModelProviders.of(this).get(MainViewModel::class.java)
        viewModel.mUser.observe(this) {
            Log.d("mUser","$it")
        }
    }
}

KOTLIN复制代码/**
 * Utilities methods for {@link ViewModelStore} class.
 * @deprecated Use the constructors for {@link ViewModelProvider} directly.
 */
@Deprecated
public class ViewModelProviders {
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return new ViewModelProvider(activity);
    }
    
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        if (factory == null) {
            factory = activity.getDefaultViewModelProviderFactory();
        }
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }
   
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull Fragment fragment) {
        return new ViewModelProvider(fragment);
    }
    
    @Deprecated
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) {
        if (factory == null) {
            factory = fragment.getDefaultViewModelProviderFactory();
        }
        return new ViewModelProvider(fragment.getViewModelStore(), factory);
    }
}