java复制代码 public static void main(String[] args) {
        long[] array = new long[]{3, 123, 1, 31, 56, 61, 22};
        long total = Arrays.stream(array)
                .reduce(1, (acc, next) -> acc * next);
        System.out.println(total);
    }

java复制代码 int total = Arrays.stream(array)
                .reduce(m, (acc, next) -> acc * next);

java复制代码 public static void main(String[] args) {
        long[] array = new long[]{3, 123, 1, 31, 56, 61, 22};
        long total = Arrays.stream(array)
                .parallel()
                .reduce(1, (acc, next) -> acc * next);
        System.out.println(total);
    }

java复制代码 public static void main(String[] args) {
        long[] array = new long[]{3, 123, 1, 31, 56, 61, 22};
        long total = Arrays.stream(array)
                .parallel()
                .reduce(1, (acc, next) -> acc * next) * m;
        System.out.println(total);
    }

java复制代码// 当用不同的 ResourceLoader 加载资源的时候 , 会根据资源类型的不同 , 选择生成不同的 Resource

C- ByteArrayResource : 给定字节数组的资源实现 , 用于从任何给定的字节数组加载内容，而不必求助于单一使用的InputStreamResource
C- ClassPathResource : 类路径资源的资源实现 , 使用给定的ClassLoader或给定的Class来加载资源
C- ContextResource : 用于从封闭的“上下文”加载资源的扩展接口
C- DescriptiveResource : 保存资源描述但不指向实际可读资源的简单资源实现
C- EncodedResource : 将资源描述符与用于从资源中读取的特定编码或字符集组合在一起
C- FileSystemResource : 资源实现处理一个文件系统目标
C- FileUrlResource : 它假定文件解析，达到实现WritableResource接口的程度
C- HttpResource : 将资源写入HTTP响应的扩展接口
C- ImportResource : 指示一个或多个包含要导入的bean定义的资源
C- InputStreamResource : 给定InputStream的资源实现 , 只在没有其他特定资源实现适用的情况下使用
C- ServletContextResource : ServletContext资源的资源实现，解释web应用程序根目录中的相对路径
C- VfsResource : 基于JBoss VFS的资源实现
C- WritableResource : 支持向资源写入的资源的扩展接口。提供一个输出流访问器

java复制代码// 统一资源的核心类是 : Resource , 为 Spring 框架所有资源的抽象和访问接口 
I- Resource
    E- InputStreamSource

C- AbstractResource
    I- Resource
    
> 以上是统一资源管理中核心的三个类 ，他们的继承关系如上
    : Spring 中所有的资源都可以用 Resource 表示
    : AbstractResource 继承自 Resource ，并且对其做了实现
	
> Resource 中有很多常见的功能
    exists / isReadable / isOpen / isFile / getURL / getFile / readableChannel 
    contentLength / lastModified / createRelative / getFileName / getDescription
	
> AbstractResource 有以下通用的实现 
    - FileSystemResource : 对 java.io.File 类型资源的封装，只要是跟 File 打交道的，基本上与 FileSystemResource 也可以打交道
        - 支持文件和 URL 的形式，实现 WritableResource 接口，从 Spring Framework 5.0 开始，FileSystemResource 使用 NIO2 API进行读/写交互
    - ByteArrayResource : 对字节数组提供的数据的封装。
    - URIResource : 对 java.net.URL类型资源的封装。内部委派 URL 进行具体的资源操作。
    - ClassPathResource : class path 类型资源的实现。使用给定的 ClassLoader 或者给定的 Class 来加载资源。
    - InputStreamResource : 将给定的 InputStream 作为一种资源的 Resource 的实现类。
    
C- AbstractResource
    - exists() : 判断文件是否存在

java复制代码
C- AbstractResource 
    TODO

java复制代码
> Spring 通过 ResourceLoader 来进行 资源的加载

C11- ResourceLoader : 资源的加载
    M- getResource() : 根据所提供资源的路径 location 返回 Resource 实例
        - 支持 URL位置资源 / ClassPath位置资源 / 相对路径资源
    M- getClassLoader() : 返回 ClassLoader 实例
    MC- ResourceLoader(ClassLoader)
         - Thread.currentThread().getContextClassLoader()
         - ClassUtils.getDefaultClassLoader()
         - setClassLoader()


    : interface ResourcePatternResolver extends ResourceLoader
    
C18- DefaultResourceLoader
    MC- DefaultResourceLoader
        - ClassUtils.getDefaultClassLoader();
    MC- DefaultResourceLoader(@Nullable ClassLoader classLoader)
    M- addProtocolResolver(ProtocolResolver) : 自定义的 Resolver 加入 Spring 体系
    M- getResource(String location)
        - 首先，通过 ProtocolResolver 来加载资源 , 成功返回 Resource 
        - 其次，以 / 开头，调用 #getResourceByPath() 方法, 返回 ClassPathContextResource 类型的资源
        - 再次，以 classpath: 开头，返回 ClassPathResource 类型的资源
            - 通过#getClassLoader() 获取当前的 ClassLoader
        - 然后，根据是否为文件 URL ，是则返回 FileUrlResource 类型的资源，否则返回 UrlResource 类型的资源
            - 最后，返回 ClassPathContextResource 类型的资源
            
// resourceLoader.getResource("D:/Users/chenming673/Documents/spark.txt");
    
C- ResourcePatternResolver : ResourceLoader 的默认实现
    M- setClassLoader / getClassLoader

> FileSystemResourceLoader
    内部类 : FileSystemContextResource extends FileSystemResource

C- ProtocolResolver : 用户自定义协议资源解决策略
    ?- 作为 DefaultResourceLoader 的 SPI：它允许用户自定义资源加载协议，而不需要继承 ResourceLoader 的子类
    ?- 现 ProtocolResolver 接口也可以实现自定义的 ResourceLoader
    M-  resolve(String , ResourceLoader )

java复制代码// XML 流程 Resource 加载 , 我们还是从 BeanDefinitionReader 开始看起
C160- AbstractBeanDefinitionReader
	M- loadBeanDefinitions(location, null) 
	M- loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources)
    	- getResourceLoader 获取一个 ResourceLoader
    	- ResourceLoader 通过 location 获取 Resource[] -> 
    	- 讲获取的  Resource 加入 actualResources , 用于后方处理
    
C16- ResourcePatternResolver 
    
    
C51- GenericApplicationContext
    M51_033- getResources(String locationPattern)
    
    
C17- PathMatchingResourcePatternResolver
    M17_02- getResources(String locationPattern)
    	- classpath*: 开头 , 则分别调用 findPathMatchingResources (-> ) / findAllClassPathResources
    	- getResourceLoader() 调用获取 Resource -> M18_05
    M17_03- findPathMatchingResources
    	- 获取路径 ,递归获取包路径
        - 通过包 URLResource 调用 doFindPathMatchingFileResources 获取类
        
    M17_04- findAllClassPathResources
    	- 调用 doFindAllClassPathResources 获取 classResource
        
    M17_05- doFindAllClassPathResources
        - 获取一个 ClassLoader , 通过 ClassLoader 获取 resource url
        - 通过 convertClassLoaderURL 对 URL 列表转换为 UrlResource
            ?- 这里其实还是包路径 -> PS:M17_05_01 
            
        
        
// PS:M17_05_01 
file:/D:/java/workspace/git/case/case%20Origin%20Source/case%20SpringBootIOC/target/classes/com/gang/study/source/springboot/demo/
        
    
C18- DefaultResourceLoader
	M18_05- getResource(String location)
         - 如果存在 ProtocolResolvers 集合, 则循环集合 , 试图用 ProtocolResolver 处理返回
		- 如果是 / 开头 , 则生成一个 ClassPathContextResource
		- 如果是 classpath 打头 ,new 创建出一个 ClassPathResource , 并且为其配置一个 ClassLoader
            	?- 所以 , 这里 bean.xml 是被映射为 ClassPathResource
		- 如果是 URL 类型 , 构建为一个 FileUrlResource
            
            
// M17_03 伪代码
// locationPattern -- classpath*:com/gang/study/source/springboot/demo/**/*.class
protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
    // classpath*:com/gang/study/source/springboot/demo/
    String rootDirPath = determineRootDir(locationPattern);
    // **/*.class
    String subPattern = locationPattern.substring(rootDirPath.length());
    
    // 扫描路径 , 将路径下资源转换为Resource数组
    Resource[] rootDirResources = getResources(rootDirPath);
    Set<Resource> result = new LinkedHashSet<>(16);
    for (Resource rootDirResource : rootDirResources) {
        rootDirResource = resolveRootDirResource(rootDirResource);
        URL rootDirUrl = rootDirResource.getURL();
        if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) {
            URL resolvedUrl = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
            if (resolvedUrl != null) {
                rootDirUrl = resolvedUrl;
            }
            rootDirResource = new UrlResource(rootDirUrl);
        }
        if (rootDirUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
            // VFS 的加载方式
            result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
        }else if (ResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) {
            // JAR 包路径的加载
            result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
        }else {
            // 加载类
            result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
        }
    }
    return result.toArray(new Resource[0]);
}

java复制代码//这种路径 , 其源头为  ComponentScanAnnotationParser 开始 , 更早的源头是 Configuration 的相关扫描逻辑

C153- ComponentScanAnnotationParser
    M153_01- parse : 由该方法扫描处理 ComponentScan  -> M155_03
        
C155- ClassPathBeanDefinitionScanner 
    M155_03- doScan(String... basePackages) -> M201_03
        
C201- ClassPathScanningCandidateComponentProvider
    M201_03- scanCandidateComponents(String basePackage)
        - 构建一个地址 -> PS:201_03_01
        - 调用 ResourcePatternResolver(AnnotationConfigServletWebServerApplicationContext) 获取 Resouce
            - 最终调用 M17_02
        
C17- PathMatchingResourcePatternResolver
    M17_02- getResources(String locationPattern) 
        - Class 前缀 , 最终调用 M17_03
    M17_03- findPathMatchingResources
    M17_04- findAllClassPathResources
        
        
        
// M201_03 伪代码
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
       //...................
    	String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
        	resolveBasePackage(basePackage) + '/' + this.resourcePattern;
       // PS:201_03_01
       // com.gang.study.source.springboot.demo 转变为
       // classpath*:com/gang/study/source/springboot/demo/**/*.class
    	Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        //...................
        
            
}

java复制代码
// 这种情况的加载主要来源于 Configuration , 例如 MessageSourceAutoConfiguration
// 此处对 message 资源进行加载 , 调用 ResourceBundleCondition 进行资源加载


C202- ResourceBundleCondition
    M202_01- getMatchOutcomeForBasename
        
    M202_02- getResources
        - 通过一个 classLoader 构建了一个 PathMatchingResourcePatternResolver 
        - 调用 getResources 返回相关的 resource 资源
            ?- 这里因为需要指定的资源 , 所以方式是定下了的
        
// M202_02 伪代码
private Resource[] getResources(ClassLoader classLoader, String name) {
    String target = name.replace('.', '/');
    return new PathMatchingResourcePatternResolver(classLoader).getResources("classpath*:" + target + ".properties");
			
}

// 同样的 , 调用了 PathMatchingResourcePatternResolver
// 此处无需匹配 , 直接 调用 findAllClassPathResources
C17- PathMatchingResourcePatternResolver
    M17_02- getResources(String locationPattern) 
        - 无需匹配 , 直接 调用 findAllClassPathResources ->  M17_04
    M17_04- findAllClassPathResources

java复制代码

// 起源 : 
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
    ?- 即 ImportedResources 注解导致

// 流程 : 
C160- AbstractBeanDefinitionReader
    M- loadBeanDefinitions
        - ((ResourcePatternResolver) resourceLoader).getResources(location)
            ?- 注意 , 这里的 Resources 仍然是 pring-common.xml 这个对象

// 后续继续调用 XmlBeanDefinitionReader , 这里就不详细说了

java复制代码C25- DocumentLoader : 获取 Document 的策略，由接口 org.springframework.beans.factory.xml.DocumentLoader 定义
    P- inputSource 方法参数，加载 Document 的 Resource 资源。
    P- entityResolver 方法参数，解析文件的解析器。
    P- errorHandler 方法参数，处理加载 Document 对象的过程的错误。
    P- validationMode 方法参数，验证模式。
    P- namespaceAware 方法参数，命名空间支持。如果要提供对 XML 名称空间的支持，则需要值为 true 。

C26- DefaultDocumentLoader : DocumentLoader 的默认实现类 
    M26_01- loadDocument
        - 首先，调用 #createDocumentBuilderFactory(...) 方法，创建 javax.xml.parsers.DocumentBuilderFactory 对象
            - DocumentBuilderFactory.newInstance(); -- 创建 DocumentBuilderFactory
            - factory.setNamespaceAware(namespaceAware);  --  设置命名空间支持
        - 调用 #createDocumentBuilder 方法，创建 javax.xml.parsers.DocumentBuilder 对象
            - 创建 DocumentBuilder 对象
            - 设置 EntityResolver 属性
            - 设置 ErrorHandler 属性
        - 调用 DocumentBuilder#parse(InputSource) 方法，解析 InputSource ，返回 Document 对象
 
// XmlBeanDefinitionReader :     
    M- getEntityResolver() : 返回指定的解析器，如果没有指定，则构造一个未指定的默认解析器
        -1 ResourceLoader resourceLoader = getResourceLoader();
        IF-2 resourceLoader != null 
            - this.entityResolver = new ResourceEntityResolver(resourceLoader);
        ELSE-2 
            - this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());

java复制代码
// 起点 : Document 的起点是 , 这里会通过一个 Resource 加载对于的 xml , 将 XML 转换为 Document
C- ConfigurationClassBeanDefinitionReader
    M- loadBeanDefinitionsFromImportedResources 

// 中间的逻辑比较简单 , 我们直接从 XmlBeanDefinitionReader 开始看
    
C21- XmlBeanDefinitionReader
    M21_01- doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        - 调用 doLoadDocument  , 将  Resource 转换为 Document -> M23_01
        - 调用 registerBeanDefinitions(doc, resource) 注册Bean
    M21_02- doLoadDocument
        - documentLoader.loadDocument : loader 加载
    

C- DocumentLoader

C23- DefaultDocumentLoader
    I- DocumentLoader
    M23_01- loadDocument(InputSource inputSource, EntityResolver entityResolver,ErrorHandler errorHandler, int validationMode, boolean namespaceAware)
        - createDocumentBuilderFactory 创建一个 DocumentBuilderFactory -> M23_02
        - 通过 DocumentBuilderFactory 创建一个 DocumentBuilder -> M23_03
        - DocumentBuilder parse 方法解读 Document
    M23_02- createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
        - 通过 newInstance 生成 DocumentBuilderFactory 
        - 为 DocumentBuilderFactory 设置 NamespaceAware , Validating , 以及 Attribute
            ?- 注意 , 这里会判断 validationMode 类型来设置
    M23_03- createDocumentBuilder(DocumentBuilderFactory factory, EntityResolver entityResolver, ErrorHandler errorHandler)
        - 通过传入的工厂生成 DocumentBuilder
        - 为 DocumentBuilder 设置 EntityResolver 和 ErrorHandler
    
    
// M23_01 补充
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
            ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
    DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    return builder.parse(inputSource);
}


// M23_02 补充
protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware){
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(namespaceAware);
    if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
        factory.setValidating(true);
        if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
            factory.setNamespaceAware(true);
            factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
            //.... 省略catch
        }
    }
    return factory;
}


// N23_03
protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory,
            @Nullable EntityResolver entityResolver, @Nullable ErrorHandler errorHandler)
            throws ParserConfigurationException {

        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        if (entityResolver != null) {
            docBuilder.setEntityResolver(entityResolver);
        }
        if (errorHandler != null) {
            docBuilder.setErrorHandler(errorHandler);
        }
        return docBuilder;
}

java复制代码DocumentBuilder 是一个抽象类 , 其主要 实现是 DocumentBuilderImpl


C24- DocumentBuilder
    F- DOMParser domParser;
    F- EntityResolver fInitEntityResolver
    F- ErrorHandler fInitErrorHandler
    MC- DocumentBuilderImpl
    M24_01- parse
        - domParser.parse(is) 
        - domParser getDocument 获得 Document
        
// 这里涉及到 com.sun.org.apache.xerces.internal.parsers.DOMParser 对象
C- DOMParser
    ?- 用于对 DOM 类型解析处理

java复制代码// Step 1 : ConfigurationClassBeanDefinitionReader # loadBeanDefinitions
    ?- 用于加载 class类上面的 classpath load
// Step 2 : AbstractBeanDefinitionReader # loadBeanDefinitions
    ?- 开始加载 xml 文件
// Step 3 : XmlBeanDefinitionReader # loadBeanDefinitions
    ?- 处理加载的 resource 对象 , xml resource 的加载可以看上文
    
// Step 4 : 主要处理流程开始
C21- XmlBeanDefinitionReader
    M21_01- doLoadBeanDefinitions
        - doLoadDocument(inputSource, resource) -> M21_02
    M21_02- doLoadDocument
    
    
C26- DefaultDocumentLoader : DocumentLoader 的默认实现类 
    M26_01- loadDocument
    
C24- DocumentBuilder
      M24_01- parse

java复制代码protected EntityResolver getEntityResolver() {
    if (this.entityResolver == null) {
        ResourceLoader resourceLoader = getResourceLoader();
        if (resourceLoader != null) {
            this.entityResolver = new ResourceEntityResolver(resourceLoader);
        }else {
            this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());
        }
    }
    return this.entityResolver;
}

java复制代码<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC  "-//SPRING//DTD BEAN//EN"  "http://www.springframework.org/dtd/spring-beans.dtd">

JAVA复制代码
C21- XmlBeanDefinitionReader
    M21_02- doLoadDocument -> PS:M21_02_01
    
// PS:M21_02_01 此处获取了 ValidationMode
return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,getValidationModeForResource(resource), isNamespaceAware());


protected int getValidationModeForResource(Resource resource) {
    int validationModeToUse = getValidationMode();
    if (validationModeToUse != VALIDATION_AUTO) {
        return validationModeToUse;
    }
    int detectedMode = detectValidationMode(resource);
    if (detectedMode != VALIDATION_AUTO) {
        return detectedMode;
    }
    return VALIDATION_XSD;
}


// 常量
/**
* Indicates that the validation mode should be auto-guessed, since we cannot find
* a clear indication (probably choked on some special characters, or the like).
*/
public static final int VALIDATION_AUTO = 1;

/**
* Indicates that DTD validation should be used (we found a "DOCTYPE" declaration).
*/
public static final int VALIDATION_DTD = 2;

/**
* Indicates that XSD validation should be used (found no "DOCTYPE" declaration).
*/
public static final int VALIDATION_XSD = 3;

js复制代码<script>
    var a = 1;
    console.log(a);
    function test(a) {
        console.log(a);
        var a = 123;
        console.log(a);
        function a() {}
        console.log(a);
        var b = function() {}
        console.log(b);
        function d() {}
    }
    var c = function (){
        console.log("I at C function");
    }
    console.log(c);
    test(2);
</script>

js复制代码    //抽象描述
GO/window = {
        a: undefined,
        c: undefined，
        test: function(a) {
            console.log(a);
            var a = 123;
            console.log(a);
            function a() {}
            console.log(a);
            var b = function() {}
            console.log(b);
            function d() {}
        }
    }

js复制代码GO/window = {
        a: 1,
        c: function (){
            console.log("I at C function");
        }
        test: function(a) {
            console.log(a);
            var a = 123;
            console.log(a);
            function a() {}
            console.log(a);
            var b = function() {}
            console.log(b);
            function d() {}
        }
    }

js复制代码//抽象描述
    AO = {
        a:undefined,
        b:undefined,
    }

js复制代码 //抽象描述
    AO = {
        a:123,
        b:undefined,
    }

js复制代码//抽象描述
    AO = {
        a:function a() {},
        b:undefined
        d:function d() {}
    }

js复制代码 //抽象描述
    AO = {
        a:function a() {},
        b:undefined
        d:function d() {}
    }
    --->
    AO = {
        a:123,
        b:undefined
        d:function d() {}
    }
    --->
    AO = {
        a:123,
        b:function() {}
        d:function d() {}
    }

xml复制代码<dependencies>
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>

    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.1</version>
    </dependency>
</dependencies>

xml复制代码<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>3.0.3</version>
    <type>pom</type>
</dependency>

groovy复制代码// 用 groovy 去执行 "groovy -v".
// Windows 环境下需要带上 cmd /C 前缀。
println("cmd /C groovy -v".execute().text)

groovy复制代码// Linux 系统
println("ls -l")

// Windows 系统
println("cmd /C dir")

groovy复制代码evaluate(new File("C:\\Users\\i\\IdeaProjects\\GroovyHello\\src\\HelloWorld.groovy"))
// 在另一个 ./HelloWorld.groovy 脚本中，我们在那个文件里仅使用了一句 print 'hello World! -by groovy' 令其输出一段话。

groovy复制代码// 假定这段代码出现在 Obj.groovy 源文件中 
class Obj{
    //...
}

// 这个方法调用和类声明一样都在文件的 '顶级' 位置。
// We don't need 'System.out.println(...)' anymore.
print('hello groovy')

groovy复制代码// 这段代码出现在 Obj.groovy 源文件中。
// 它相当于是 .java 文件中的 public class 定义.
class Obj{
    // 就像在写 Java 代码一样!
    // 在 Groovy 中，public 关键字其实是多余的，默认情况下所有的声明就是 public。
	public static void main(String[] args){
         // 在 Groovy 中，字符串还可以使用 "",'',""" """,''' ''',包裹，具体区别见后文。
		print('hello groovy')
	}
}

// 它相当于是 .java 文件中的非 public class 定义.
class OtherObj{}

// 代码不能再出现在文件的 '顶层' 位置，因为我们在 Java 开发时就不是这样做的。
print ('oops')

java复制代码public class Test {
    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("src/HelloWorld.groovy");
        // FileInputStream 抛出受检异常，因此调用它的函数要么继续 throws 到上级 (当然，主程序 throws 异常没什么意义)，
        // 要么就通过 try-catch 内部解决掉它。
        FileInputStream fileInputStream = new FileInputStream(file);
    }
}

groovy复制代码// 即使没有声明 throws，也没有定义 try-catch, groovyc 仍然会正常执行。
File file = new File('HelloWorld.groovy')
FileInputStream fileInputStream = new FileInputStream(file)

groovy复制代码String maybeNull = "I'm Java";
if(maybeNull != null){System.out.println(nullString.length());}

groovy复制代码String maybeNull = 'I\'m groovy'
print(maybeNull?.length())

groovy复制代码name = 'Wangfang'
age = '18'

// 占位符拼接的用法
print("my name is ${name},my age is ${age}.")

groovy复制代码class Student_ {
    String name
    Integer age
    
    Student_(String name,Integer age){
        this.name = name
        this.age = age
    }
}

Student_ s = new Student_()
// 这个 getXXX 方法是由编译器生成的。
s.getName()

groovy复制代码class Student_{
	final name
	def age
	Student_(name,age){
		this.name = name 
		this.age = age
	}
}

groovy复制代码class Student_{    
    final name
    def age

    // 使得 name 和 age 属性的实际类型可以被推导 
    Student_(String name, Integer age){
        this.name = name
        this.age = age
    }
}

s = new Student_('Wang Fang',23)

groovy复制代码class Student_{    
    final name
    private age

    // 使得 name 和 age 属性的实际类型可以被推导 
    Student_(String name, Integer age){
        this.name = name
        this.age = age
    }
}

s = new Student('Wang Fang',23)

//报错
s.getName()

groovy复制代码class Student_{
    String name
    Integer age
}

// 没有实现 Student_(name,age) 构造器，但是可以直接使用
stu1 = new Student_(name: "Wang Fang",age: 12)

// 同样，我们也没有手动实现 Student_(name) 构造器。
stu2 = new Student_(name:"Wang Fang")

groovy复制代码stu1 = new Student_("Wang Fang",12)
stu2 = new Student_("Wang Fang")

groovy复制代码def add(Integer arg,Integer implicit = 10){arg + implicit}

// 11
print(add(1))
// 3 
print(add(1,2))

groovy复制代码def swap(x, y) { return [y, x] }

Integer a, b
a = 10
b = 50

// 通过多重赋值实现了两数交换
(a, b) = swap(a, b)
print("a=$a,b=$b")

groovy复制代码Tuple2<Integer,Integer> swap(Integer a,Integer b){
    return new Tuple2<Integer,Integer>(b,a)
}

a = 10
b = 20

(a, b) = swap(a, b)
print("a=${a},b=${b}")

groovy复制代码interface Calculator<T>{
    T add(T a,T b)
}

java复制代码Calculator<Integer> calculator = new Calculator<Integer>() {
    @Override
    public Integer add(Integer a, Integer b) {
        return a + b;
    }
};

css复制代码Calculator<Integer> calculator = (a, b) -> a + b;

groovy复制代码// 多亏类型推导的存在，我们不需要把 Calculator<Integer> 重新抄写一遍 .....
def a = {a,b ->return a+b} as Calculator<Integer>

groovy复制代码interface Calculator<T> {
    T add(T a, T b)
    T sub(T a, T b)
}

def cal = [
        add: { a, b -> a + b },
        sub: { a, b -> a - b }
] as Calculator<Integer>

def c = cal.sub(1,2)
print(c)

java复制代码int a = 10
// :)     => if(a != 0)...
// :(     => if(a)...

groovy复制代码class ComplexNumber {
    Integer real
    Integer imaginary

    //plus 方法对应 + 操作符
    def plus(ComplexNumber other) {
        new ComplexNumber(real: this.real + other.real,imaginary: this.imaginary+other.imaginary)
    }

    @Override
    String toString() { "${real} + ${imaginary}i"}
}

// 注意，这个写法相当于 println(...)
// 内部相当于是调用了 new ComplexNumber(balabala).plus(new ComplexNumber(balabala))
println new ComplexNumber(real:3,imaginary:  2) + new ComplexNumber(real:3,imaginary:1)

java复制代码for (int i = 0; i<3 ; i++){System.out.println("java loop")}

groovy复制代码for (i in 0..2){println "groovy loop"}

groovy复制代码String[] strings = ['java','scala','groovy','go']

//  s 必须指明是 String 类型。
//  : 替换了之前的 in 关键字。
for(String s : strings){
    print(s.length())
}

//  等价写法
for (s in strings){
    print s.length()
}

groovy复制代码// 你可以将 .. 视作是 Integer 的一个双目运算符号，其中 n..m 会返回 [n,n+1,n+2,...m] 的序列。
// seq 是 IntRange 类型。
def seq = 0..10

// 11
print seq.size()

groovy复制代码import java.lang.Math
print Math.random()

groovy复制代码// 静态导入 Math 类的静态 random 方法
// as 关键字可以顺便将导入的静态方法起一个别名，通常用于简化或者避免命名冲突的目的。
import static math.random as rdm
print rdm()

groovy复制代码String[] str = ['java','groovy']

java复制代码{
    System.out.println("block1");
}

{
    System.out.println("block2");
}

// ()->void 函数也可以被理解成是子代码块。
Runnable runnable = () -> {
    System.out.println("block3");
};

runnable.run();

groovy复制代码// 不能通过编译
{print "hello"}

// 编译通过，这种赋值明确地表示 {} 是一个闭包。
def c = {print "hello"}

groovy复制代码def aspect(before, after) {
    before()
    print("method")
    after()
}

// 正常的调用方式
aspect({print "before doing..."},{print "after doing..."})


// 将闭包迁移到调用尾部，aspect() 的小括号 () 可写可不写。
aspect() {
    print("before doing...")
} {
    print("after doing...")
}

groovy复制代码class Aspect{
        // Closure 是 Groovy 中表示闭包的类型。它实际上还有一个泛型，该泛型指代的是该闭包的返回值。
        Aspect(Closure before){
            before()
        }
}

groovy复制代码// 这个写法的原意是将闭包写到构造函数的后面。
def a  = new Aspect(){
	print "create a aspect..."
}

groovy复制代码def a = new Aspect({print "create a aspect..."})

groovy复制代码class Apple{

    String from = "China"

    // 我们不认为它是闭包，而是实例初始化器
    {
        print("这段代码先于 Apple 的构造函数去执行")
    }
}

groovy复制代码// 解决方法1，推荐
class Apple{

    {
        print("")
    }
    
    String from = "China"
}

// 解决方法 2，不太推荐，因为这种写法容易让人混淆实例初始化器和普通闭包的声明。
class Apple{

    String from = "China";

    {
        print("")
    }
}

groovy复制代码@Canonical
// 如果不想打印 id 和 score，可以：
// @Canonical(excludes="id,score")
class Student {
    Integer id
    String name
    Integer age
    String major
    Integer score
}

// 如果没有此注解，打印的则是 Student@Hashcode
// 如果有注解，打印的则是 Student(1,"Wang Fang",20,"CS","score")
print new Student(id: 1,name:"Wang Fang",age: 20,major: "CS",score: 90.0d)

groovy复制代码class Worker{
    void work(){
        print("worker is working exactly.")
    }
}

// Manager 获得了 Worker 的公开方法，尽管 worker 属性本身是 private.
class Manager{
    @Delegate private Worker worker = new Worker()
}

// 检查 Manager 实例有没有 work 方法，没有就去委托 worker 执行此方法。
new Manager().work()

groovy复制代码@Immutable
class Student_{
    String id
    String name
}

def s = new Student_(id:"0001",name:"Wang Fang")

print s

groovy复制代码class Connection{
    
    // 加载 Connection 需要 1 秒的时间
    Connection(){
        Thread.sleep(1000)
        print "Connection 实例初始化完毕"
    }
}

class Pool{
    
    // 由于代码没有调用 conn ，因此实际上 new Connection() 并没有真正执行
    @Lazy def conn = new Connection()
    Pool(){
        print "Pool 实例初始化完毕"
    }
}

def pool = new Pool();

groovy复制代码class Student{
    String id
    String name
}

class Teacher{
    String id
    String name
}

@Newify(Student)
def getStudent(){
    // 在函数内部创建 Student 时，可以省略掉 new 关键字。
    Student(id:"0001",name: "Wang Fang")
}

// 多个类型使用数组的形式排列。
@Newify([Student,Teacher])
static def getStudentAndTeacher(){
    [Student(id:"0001",name:"Wang Fang"),Teacher(id: "0002",name:"Cheng Yu")]
}

groovy复制代码// 懒加载的单例模式，lazy 项是可选的。
@Singleton(lazy = true)
class TheUnique{
    {
        println "created only once"
    }
}

// 通过 .instance 调用这个单例对象。
TheUnique.instance

groovy复制代码str1 = "111"
str2 = "222"

// 相当于是 Java 语义中的 str1 == str2
str1.is(str2)

// 相当于是 Java 语义中的 str1.equals(str2)
str1 == str2

kotlin复制代码private fun testCoroutineExceptionHandler(){
   GlobalScope.launch {
       val job = launch {
            Log.d("${Thread.currentThread().name}", " 抛出未捕获异常")
            throw NullPointerException("异常测试")
        }
       job.join()
       Log.d("${Thread.currentThread().name}", "end")
    }
}

kotlin复制代码D/DefaultDispatcher-worker-2:  抛出未捕获异常
E/AndroidRuntime: FATAL EXCEPTION: DefaultDispatcher-worker-1
    Process: com.carman.kotlin.coroutine, PID: 22734
    java.lang.NullPointerException: 异常测试
        at com.carman.kotlin.coroutine.MainActivity$testException$1$job$1.invokeSuspend(MainActivity.kt:251)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)

kotlin复制代码    internal class CoroutineScheduler(...) : Executor, Closeable {
        @JvmField
        val globalBlockingQueue = GlobalQueue()
        fun runSafely(task: Task) {
            try {
                task.run()
            } catch (e: Throwable) {
                val thread = Thread.currentThread()
                thread.uncaughtExceptionHandler.uncaughtException(thread, e)
            } finally {
                unTrackTask()
            }
        }
        
         //省略... 
        internal inner class Worker private constructor() : Thread() {
            override fun run() = runWorker()
        
            private fun runWorker() {
                var rescanned = false
                while (!isTerminated && state != WorkerState.TERMINATED) {
                    val task = findTask(mayHaveLocalTasks)
                    if (task != null) {
                        rescanned = false
                        minDelayUntilStealableTaskNs = 0L
                        executeTask(task)
                        continue
                    } else {
                        mayHaveLocalTasks = false
                    }
                    //省略...
                    continue
                }
            }
            
            private fun executeTask(task: Task) {
                //省略...
                runSafely(task)
               //省略...
            }

            fun findTask(scanLocalQueue: Boolean): Task? {
                if (tryAcquireCpuPermit()) return findAnyTask(scanLocalQueue)
                val task = if (scanLocalQueue) {
                    localQueue.poll() ?: globalBlockingQueue.removeFirstOrNull()
                } else {
                    globalBlockingQueue.removeFirstOrNull()
                }
                return task ?: trySteal(blockingOnly = true)
            }
            
            //省略... 
        }
        //省略... 
    }

kotlin复制代码internal class GlobalQueue : LockFreeTaskQueue<Task>(singleConsumer = false)

kotlin复制代码internal actual typealias SchedulerTask = Task

kotlin复制代码internal abstract class DispatchedTask<in T>(
    @JvmField public var resumeMode: Int
) : SchedulerTask() {
 //省略...
 internal open fun getExceptionalResult(state: Any?): Throwable? =
        (state as? CompletedExceptionally)?.cause
 
 public final override fun run() {
      assert { resumeMode != MODE_UNINITIALIZED }
      val taskContext = this.taskContext
      var fatalException: Throwable? = null
    try {
            val delegate = delegate as DispatchedContinuation<T>
            val continuation = delegate.continuation
            withContinuationContext(continuation, delegate.countOrElement) {
                val context = continuation.context
                val state = takeState()
                val exception = getExceptionalResult(state)
                val job = if (exception == null && resumeMode.isCancellableMode) context[Job] else null
                if (job != null && !job.isActive) {
                    val cause = job.getCancellationException()
                    cancelCompletedResult(state, cause)
                    continuation.resumeWithStackTrace(cause)
                } else {
                    if (exception != null) {
                        continuation.resumeWithException(exception)
                    } else {
                        continuation.resume(getSuccessfulResult(state))
                    }
                }
            }
        } catch (e: Throwable) {
            fatalException = e
        } finally {
            val result = runCatching { taskContext.afterTask() }
            handleFatalException(fatalException, result.exceptionOrNull())
        }
    }
}

kotlin复制代码public inline fun <T> Continuation<T>.resumeWithException(exception: Throwable): Unit =
    resumeWith(Result.failure(exception))

kotlin复制代码  val delegate = delegate as DispatchedContinuation<T>
  val continuation = delegate.continuation

kotlin复制代码internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {
     public final override fun resumeWith(result: Result<Any?>) {
        var current = this
        var param = result
        while (true) {
            probeCoroutineResumed(current)
            with(current) {
                val completion = completion!! // fail fast when trying to resume continuation 
                val outcome: Result<Any?> =
                    try {
                        val outcome = invokeSuspend(param)
                        if (outcome === COROUTINE_SUSPENDED) return
                        Result.success(outcome)
                    } catch (exception: Throwable) {
                        Result.failure(exception)
                    }
                releaseIntercepted() // this state machine instance is terminating
                if (completion is BaseContinuationImpl) {
                    current = completion
                    param = outcome
                } else {
                    completion.resumeWith(outcome)
                    return
                }
            }
        }
    }
}

kotlin复制代码public interface ThreadContextElement<S> : CoroutineContext.Element {
    public fun updateThreadContext(context: CoroutineContext): S
    public fun restoreThreadContext(context: CoroutineContext, oldState: S)
}

kotlin复制代码public fun handleFatalException(exception: Throwable?, finallyException: Throwable?) {
    //省略....
    handleCoroutineException(this.delegate.context, reason)
}

kotlin复制代码public fun handleCoroutineException(context: CoroutineContext, exception: Throwable) {
    try {
        context[CoroutineExceptionHandler]?.let {
            it.handleException(context, exception)
            return
        }
    } catch (t: Throwable) {
        handleCoroutineExceptionImpl(context, handlerException(exception, t))
        return
    }
    handleCoroutineExceptionImpl(context, exception)
}

kotlin复制代码internal actual fun handleCoroutineExceptionImpl(context: CoroutineContext, exception: Throwable) {
    for (handler in handlers) {
        try {
            handler.handleException(context, exception)
        } catch (t: Throwable) {
            val currentThread = Thread.currentThread()
            currentThread.uncaughtExceptionHandler.uncaughtException(currentThread, handlerException(exception, t))
        }
    }
    val currentThread = Thread.currentThread()
    currentThread.uncaughtExceptionHandler.uncaughtException(currentThread, exception)
}

kotlin复制代码private fun testException(){
    GlobalScope.launch{
        launch(start = CoroutineStart.UNDISPATCHED) {
            Log.d("${Thread.currentThread().name}", " 我要开始抛异常了")
            try {
                throw NullPointerException("异常测试")
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        Log.d("${Thread.currentThread().name}", "end")
    }
}

kotlin复制代码D/DefaultDispatcher-worker-1:  我要开始抛异常了
W/System.err: java.lang.NullPointerException: 异常测试
W/System.err:     at com.carman.kotlin.coroutine.MainActivity$testException$1$1.invokeSuspend(MainActivity.kt:252)
W/System.err:     at com.carman.kotlin.coroutine.MainActivity$testException$1$1.invoke(Unknown 
//省略...
D/DefaultDispatcher-worker-1: end

kotlin复制代码private fun testException(){
    var a:MutableList<Int> = mutableListOf(1,2,3)
    GlobalScope.launch{
       launch {
            Log.d("${Thread.currentThread().name}","我要开始抛异常了" )
            try {
                launch{
                    Log.d("${Thread.currentThread().name}", "${a[1]}")
                }
                a.clear()
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        Log.d("${Thread.currentThread().name}", "end")
    }
}

log复制代码D/DefaultDispatcher-worker-1: end
D/DefaultDispatcher-worker-2: 我要开始抛异常了
E/AndroidRuntime: FATAL EXCEPTION: DefaultDispatcher-worker-2
    Process: com.carman.kotlin.coroutine, PID: 5394
    java.lang.IndexOutOfBoundsException: Index: 1, Size: 0
        at java.util.ArrayList.get(ArrayList.java:437)
        at com.carman.kotlin.coroutine.MainActivity$testException$1$1$1.invokeSuspend(MainActivity.kt:252)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)

kotlin复制代码public interface CoroutineExceptionHandler : CoroutineContext.Element {

    public companion object Key : CoroutineContext.Key<CoroutineExceptionHandler>
    
    public fun handleException(context: CoroutineContext, exception: Throwable)
}

kotlin复制代码private fun testException(){
    val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        Log.d("exceptionHandler", "${coroutineContext[CoroutineName]} ：$throwable")
    }
     GlobalScope.launch(CoroutineName("异常处理") + exceptionHandler){
         val job = launch{
             Log.d("${Thread.currentThread().name}","我要开始抛异常了" )
             throw NullPointerException("异常测试")
         }
         Log.d("${Thread.currentThread().name}", "end")
     }
}

kotlin复制代码D/DefaultDispatcher-worker-1: 我要开始抛异常了
D/exceptionHandler: CoroutineName(异常处理) ：java.lang.NullPointerException: 异常测试
D/DefaultDispatcher-worker-2: end

kotlin复制代码private fun testException(){
    val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        Log.d("exceptionHandler", "${coroutineContext[CoroutineName]} 处理异常 ：$throwable")
    }
    GlobalScope.launch(CoroutineName("父协程") + exceptionHandler){
        val job = launch(CoroutineName("子协程")) {
            Log.d("${Thread.currentThread().name}","我要开始抛异常了" )
            for (index in 0..10){
            launch(CoroutineName("孙子协程$index")) {
                Log.d("${Thread.currentThread().name}","${coroutineContext[CoroutineName]}" )
            }
        }
            throw NullPointerException("空指针异常")
        }
        for (index in 0..10){
            launch(CoroutineName("子协程$index")) {
                Log.d("${Thread.currentThread().name}","${coroutineContext[CoroutineName]}" )
            }
        }
        try {
            job.join()
        } catch (e: Exception) {
            e.printStackTrace()
        }
        Log.d("${Thread.currentThread().name}", "end")
    }
}

kotlin复制代码D/DefaultDispatcher-worker-3: 我要开始抛异常了
W/System.err: kotlinx.coroutines.JobCancellationException: StandaloneCoroutine is cancelling; job=StandaloneCoroutine{Cancelling}@f6b7807
W/System.err: Caused by: java.lang.NullPointerException: 空指针异常
W/System.err:     at com.carman.kotlin.coroutine.MainActivity$testException$1$job$1.invokeSuspend(MainActivity.kt:26//省略...
D/DefaultDispatcher-worker-6: end
D/exceptionHandler: CoroutineName(父协程) 处理异常 ：java.lang.NullPointerException: 空指针异常

kotlin复制代码/**
 *  省略...
 * but overrides context's [Job] with [SupervisorJob].
 * 省略...
 */
public suspend fun <R> supervisorScope(block: suspend CoroutineScope.() -> R): R {
   //省略...
}

kotlin复制代码private fun testException(){
    val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        Log.d("exceptionHandler", "${coroutineContext[CoroutineName].toString()} 处理异常 ：$throwable")
    }
    GlobalScope.launch(exceptionHandler) {
        supervisorScope {
            launch(CoroutineName("异常子协程")) {
                Log.d("${Thread.currentThread().name}", "我要开始抛异常了")
                throw NullPointerException("空指针异常")
            }
            for (index in 0..10) {
                launch(CoroutineName("子协程$index")) {
                    Log.d("${Thread.currentThread().name}正常执行", "$index")
                    if (index %3 == 0){
                        throw NullPointerException("子协程${index}空指针异常")
                    }
                }
            }
        }
    }
}

kotlin复制代码D/DefaultDispatcher-worker-1: 我要开始抛异常了
D/exceptionHandler: CoroutineName(异常子协程) 处理异常 ：java.lang.NullPointerException: 空指针异常
D/DefaultDispatcher-worker-1正常执行: 1
D/DefaultDispatcher-worker-1正常执行: 2
D/DefaultDispatcher-worker-3正常执行: 0
D/DefaultDispatcher-worker-1正常执行: 3
D/exceptionHandler: CoroutineName(子协程0) 处理异常 ：java.lang.NullPointerException: 子协程0空指针异常
D/exceptionHandler: CoroutineName(子协程3) 处理异常 ：java.lang.NullPointerException: 子协程3空指针异常
D/DefaultDispatcher-worker-4正常执行: 4
D/DefaultDispatcher-worker-4正常执行: 5
D/DefaultDispatcher-worker-5正常执行: 7
D/DefaultDispatcher-worker-3正常执行: 6
D/DefaultDispatcher-worker-5正常执行: 8
D/DefaultDispatcher-worker-5正常执行: 9
D/exceptionHandler: CoroutineName(子协程9) 处理异常 ：java.lang.NullPointerException: 子协程9空指针异常
D/exceptionHandler: CoroutineName(子协程6) 处理异常 ：java.lang.NullPointerException: 子协程6空指针异常
D/DefaultDispatcher-worker-2正常执行: 10

kotlin复制代码private fun testException(){
    val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        Log.d("exceptionHandler", "${coroutineContext[CoroutineName].toString()} 处理异常 ：$throwable")
    }
    val supervisorScope = CoroutineScope(SupervisorJob() + exceptionHandler)
    with(supervisorScope) {
        launch(CoroutineName("异常子协程")) {
            Log.d("${Thread.currentThread().name}", "我要开始抛异常了")
            throw NullPointerException("空指针异常")
        }
        for (index in 0..10) {
            launch(CoroutineName("子协程$index")) {
                Log.d("${Thread.currentThread().name}正常执行", "$index")
                if (index % 3 == 0) {
                    throw NullPointerException("子协程${index}空指针异常")
                }
            }
        }
    }
}

kotlin复制代码D/DefaultDispatcher-worker-1: 我要开始抛异常了
D/DefaultDispatcher-worker-2正常执行: 0
D/exceptionHandler: CoroutineName(子协程0) 处理异常 ：java.lang.NullPointerException: 子协程0空指针异常
D/exceptionHandler: CoroutineName(异常子协程) 处理异常 ：java.lang.NullPointerException: 空指针异常
D/DefaultDispatcher-worker-2正常执行: 1
D/DefaultDispatcher-worker-2正常执行: 2
D/DefaultDispatcher-worker-4正常执行: 3
D/exceptionHandler: CoroutineName(子协程3) 处理异常 ：java.lang.NullPointerException: 子协程3空指针异常
D/DefaultDispatcher-worker-1正常执行: 4
D/DefaultDispatcher-worker-4正常执行: 5
D/DefaultDispatcher-worker-4正常执行: 6
D/exceptionHandler: CoroutineName(子协程6) 处理异常 ：java.lang.NullPointerException: 子协程6空指针异常
D/DefaultDispatcher-worker-4正常执行: 8
D/DefaultDispatcher-worker-3正常执行: 7
D/DefaultDispatcher-worker-2正常执行: 9
D/exceptionHandler: CoroutineName(子协程9) 处理异常 ：java.lang.NullPointerException: 子协程9空指针异常
D/DefaultDispatcher-worker-3正常执行: 10

xml复制代码<!--Kaptcha-->
<dependency>
    <groupId>com.github.penggle</groupId>
    <artifactId>kaptcha</artifactId>
    <version>2.3.2</version>
</dependency>