1.Spring的整体架构

Spring IoC：包含了最基本的IoC容器的BeanFactory的接口与实现。BeanFactory系列容器只实现了最基本的IoC容器的功能；ApplicationContext应用上下文，作为容器的高级形态存在，增加了许多面向框架的特性，包括国际化和应用支持。

Spring Aop：集成AspectJ作为AOP的一个特定实现，同时还在JVM动态代理和CGLIB的基础上，实现了AOP框架；声明式事务，日志处理，权限判断。

Spring MVC：以DispatcherServlet为核心，实现了MVC模式，包括怎样与Web容器集成，Web请求的拦截、转发、处理和ModelAndView数据的返回。

Spring JDBC/ORM：对JDBC进行封装，使得通过JDBC完成的对数据库的操作更加方便，还提供了JdbcTemplate作为模板类，封装了基本数据库的操作方法。还提供了许多ORM工具的封装，例如HibernateTemplate等。

Spring事务处理：通过Spring AOP实现自身功能增强的典型模块。

Spring 远端调用：通过Spring的封装从Spring应用到Spring应用之间的端到端的调用。在这个过程中，通过Spring的封装，为应用屏蔽了各种通信和调用的细节，从而可以使用不同的远端调用来实现，HTTP调用器已经传统的RMI调用。

Spring 应用：通过这个模块使得Spring应用能够简洁的容纳第三方的技术实现，丰富了Spring的应用功能。

2.Spring IoC容器的概述

控制反转，控制权的反转，控制权从具体业务对象手中转到IoC容器中；如果相关对象的引用或依赖关系的管理由具体对象来完成，会导致代码的高度耦合。对象的依赖关系往往体现在对数据和方法的依赖上，这些依赖关系可以通过把对象的依赖注入交给框架或者IoC容器来完成，这种控制权的转移能够降低耦合提高可测试性。

控制反转的实现有很多种方式，可以在对象初始化时，就进行数据注入，也可以通过对象引用注入到数据域中实现。对象之间的相互依赖关系由IoC容器进行管理，并由IoC容器完成对象的注入。

2.1IoC容器的设计

①BeanFactory-HierachicalBeanFactory-ConfigurableBeanFactory，HierachicalBeanFactory继承了BeanFactory，增加了getParentBeanFactory的接口功能，ConfigurableBeanFactory接口，主要定义了一些对BeanFactory的配置功能。

②BeanFactory-ListableBeanFactory-ApplicationContext-ConfigurableApplicationContext，ListableBeanFactory细化了好多BeanFactory的接口功能，如定义了getBeanDefinitionNames接口方法，ApplicationContext通过集成MessageSource、ResourceLoader、ApplicationEventPublisher接口，添加了许多对高级容器的特性支持。

BeanFactory与FactoryBean，BeanFactory是IoC容器或者对象工厂，所有的Bean都是由BeanFactory进行管理的。FactoryBean是一个能够产生对象的工厂Bean，使用&可以得到FactoryBean本身，不会得到FactoryBean产生的对象。

 

2.1.1BeanFactory的应用场景

BeanFactory的getBean方法，可以取得IoC容器中管理的Bean，通过指定名字来索引，还可以带Bean的类型，或者prototype类型的参数。

2.1.2 BeanFactory容器的设计原理

以XmlBeanFactory为例，简单说明IoC容器的设计原理

只提供最基本的IoC容器的功能。XmlBeanFactory继承了DefaultListableBeanFactory这个类，DefaultListableBeanFactory是经常需要用到的一个IoC的实现，ApplicationContext就会使用到该类，它包含了基本IoC容器所具有的重要功能。XmlBeanFactory在DefaultListableBeanFactory的基础上增加了可以读取xml文件定义的BeanDefinition的功能。实现过程如下

XmlBeanFactory中初始化了一个XmlBeanDefinitionReader对象，该对象那个可以处理xml方式定义的BeanDefinition。构造XmlBeanFactory的时候，需要指定BeanDefinition的信息来源（某个xml文件），而这个信息来源需要封装成Resource类（用来封装IO的类），例如ClassPathResource res = new ClassPathResource(“beans.xml”)；将resource作为构造参数传入到XmlBeanFactory的构造器中，调用loadBeanDefinition方法，从Resource中载入BeanDefinition。

理解编程方式使用IoC容器

①创建IoC配置文件的抽象资源Resource，包含了BeanDefinition的定义

②创建一个BeanFactory，这里使用DefaultListableBeanFactory

③创建一个载入BeanFactory的读取器，使用XmlBeanDefinitionReader来载入xml文件形式的BeanDefinition。

④调用loadBeanDefinition，完成载入信息操作，载入和注册bean后，就可以使用IoC容器了。

2.1.3ApplicationContext的应用场景

ApplicationContext是一个高级形态意义的IoC容器，提供了一些附加功能

①继承了MessageSource接口，支持国际化实现

②继承了ResourceLoader接口，可以从不同地方得到Bean定义资源

③继承了ApplicationEventPublisher接口，引入了事件机制，与Bean生命周期结合为Bean的管理提供便利。

2.1.4 ApplicationContext容器的设计原理

以FileSystemXmlApplicationContext的实现为例

ApplicationContext主要功能已经在AbstractXmlApplicationContext中实现了，FileSystemXmlApplicationContext只需要实现与其自身设计相关的功能即可

①如果直接使用FileSystemXmlApplicationContext，对于实例化ApplicationContext的支持，同时启动IoC容器的refresh过程

②怎样从文件系统中加载xml的bean定义资源

从xml中得到BeanDefinition的抽象资源，然后返回Resource

2.2 IoC容器的初始化过程

IoC的初始化过程是由refresh来启动，这个方法标志着IoC容器的正式启动。启动过程包括BeanDefinition的Resource定位、BeanDefinition的载入和BeanDefinition的注册。

Spring把三个过程分开，并使用不同模块来完成，通过这样的设计方式，可以让用户更加灵活地对这三个过程进行裁剪和扩展。

①Resource定位，由ResourceLoader通过统一的Resource接口来完成，可以使用上述getResourceByPath完成，也可以使用ClassPathResource来完成。

②BeanDefinition载入，用户定义好的Bean表示成IoC容器内部的数据结构，而这个容器的内部数据结构就是BeanDefinition。

③注册BeanDefinition，调用BeanDefinitionRegistry接口实现。IoC容器内部将BeanDefinition注入到一个HashMap中去，通过HashMap持有这些BeanDefinition

注意：一般来说初始化和依赖注入是两个分开的过程，依赖注入是在第一次调用getBean时进行的，即默认的lazyinit属性是true，有个例外，对bean设置了lazyinit属性为false，并且是singleton之后，那么这个Bean的依赖注入就会在容器初始化时就预先完成了。如果是prototype类型，那么即使lazyinit是false，那么也不会在初始化就进行依赖注入，详情见DefaultListableBeanFactory中的preInstantiateSingletons()方法

2.2.1 Resource定位

以FileSystemXmlApplicationContext为例，通过继承AbstractApplicationContext具备了ResourceLoader从Resource中读入BeanDefinition的能力；

getResourceBypath方法用于BeanDefinition的定位，构造器中的refresh方法用于实现BeanDefinition的载入过程。FileSystemXmlApplicationContext的refresh方法调用AbstractRefreshableApplicationContext的refreshBeanFactory方法。refreshBeanFactory通过createBeanFactory构建了一个IoC容器供ApplicationContext使用，就是defaultlistableBeanfactory，然后调用loadBeanDefinitions来载入BeanDefinition，方法参数就是defaultlistableBeanfactory；该过程实际上调用的是AbstractApplicationContext里面的loadBeanDefinitions，然后初始化了XmlBeanDefinitionReader，调用loadBeanDefinitions(XmlBeanDefinitionReader reader)方法，里面有获取getConfigLocations，之后就会在AbstractBeanDefinitionReader里面的loadBeanDefinitions(String location, Set<Resource> actualResources)方法getResourceLoader，此时get到的ResourceLoader就是FileSystemXmlApplicationContext，然后就会调用ResourceLoader的getResource方法，由于FileSystemXmlApplicationContext继承了DefaultResourceLoader，所以调用其中的getResource方法；如下。

由于FileSystemXMLApplicationContext设定了configLocation，所以用的是reader.loadBeanDefinitions(configLocations);这个方法，此方法在getResource得到Resource之后就会进行BeanDefinition的载入

由于AbstractBeanDefinitionReader没有实现loadBeanDefinitions(resource);因此调用xmlBeanDefinitionReader类中的loadBeanDefinitions(resource);进行载入；

2.2.2 BeanDefinition的载入和解析

Refresh方法的实现，是在AbstractApplicationContext中，代码如下，BeanFactory的更新，此方法在AbstractRefreshableApplicationContext类的refreshBeanFactory方法

如果有旧的beanFactory，就销毁和关闭并且创建新的BeanFactory；MessageSource和PostProcessor的注册等。

真正BeanDefinition的载入过程在refreshBeanFactory方法中

loadBeanDefinitions是一个抽象方法，在AbstractXmlApplicationContext中实现，在该方法中，初始化了XmlBeanDefinitionReader，然后把这个读取器在IoC容器中设置好，在loadBeanDefinitions(beanDefinitionReader);调用reader.loadBeanDefinitions(configLocations)完成BeanDefinition的载入

然后就是loadBeanDefinitions调用，首先得到Resource定位，具体由子类进行，此时由于FileSystemXmlApplicationContext不是ClassPathXmlApplicationContext，所以configResources返回null，进行getConfigLocation载入。

reader.loadBeanDefinitions(configLocations)在AbstractBeanDefinitionReader中，然后进行资源的定位以及载入；

上面已经分析过，得到resource之后，进行真正的载入过程，此时的loadBeanDefinitions(resource)在XmlBeanDefinitionReader中，

得到输入流之后，就可以采用doLoadBeanDefinitions方法进行xml文件解析

获取Document对象，采用SAX解析xml；Spring的BeanDefinition是怎么样按照Spring的Bean语义要求进行解析并转化为内部数据结构的，这个过程由registerBeanDefinitions完成；

parseBeanDefinition到下面的方法

创建一个BeanDefinitionDocumentReader，默认是DefaultBeanDefinitionDocumentReader，使用BeanDefinitionParserDelegate进行解析Document对象，解析后的结果

放在BeanDefinition中，并将beanName,aliase作为参数保存到BeanDefinitionHolder中。

一层一层调用解析，这样xml中定义的BeanDefinition就被载入到IoC容器中了，并在容器中建立了数据的映射。这个时候容器还没有完全起作用，要完全发挥容器作用，还需要进行注册

2.2.3 BeanDefinition在IoC中的注册

载入和解析过程，已经将用户定义的BeanDefinition信息在IoC容器中建立起了自己的数据结构，但是还需要进行注册才能使用。在DefaultListableBeanFactory中，通过一个ConcurrentHashMap来持有载入的BeanDefinition

在xmlBeanDefinitionReader传入的DefaultListableBeanFactory，就是设定AbstractBeanDefinitionReader中的registry为DefaultListableBeanFactory。因此在DefaultBeanDefinitionDocumentReader的processBeanDefinition方法中BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());就是用来注册BeanDefinition；

调用的是DefaultListableBeanFactory的registerBeanDefinition(String, BeanDefinition)方法

 

注册之后，BeanDefinition就可以被使用了。

2.3 依赖注入

依赖注入过程是用户第一次调用getBean时触发的，例外就是lazy-init属性的预实例化，后面会讲。GetBean调用完之后会触发doGetBean；就是用于依赖注入；getBean-dogetBean-createbean；

AbstractBeanFactory中的dogetBean方法会调用AbstractAutowireCapableBeanFactory的CreateBean方法；该方法生成了需要的bean，还对bean初始化进行了处理，定义后置处理器，定义init-method属性等；createBean中调用了doCreateBean方法

该方法中主要就是createBeanInstance和populateBean方法，createBeanInstance生成了Bean所包含的java对象，这个对象的生成有很多种不同的方式，可以通过工厂方法生成，也可以通过容器的autowire特性生成。

使用不同的方式进行bean的实例化

使用cglib进行bean实例化，cglib是一个常用的字节码生成器的类库，提供了生成和转换字节码的功能。Cglib如何生成bean对象需要看simpleInstantiationStrategy。提供了两种实例化对象的方法，一种是BeanUtils，使用JVM的反射功能，一种使用cglib生成

实例化对象后，需要为依赖关系进行处理，即使用populateBean方法，在AbstractAutowireCapableBeanFactory中；

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { 获取BeanDefinition的property属性值        PropertyValues pvs = mbd.getPropertyValues();          if (bw == null) {            if (!pvs.isEmpty()) {               throw new BeanCreationException(                      mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");            }            else {               // Skip property population phase for null instance.               return;            }        }        boolean continueWithPropertyPopulation = true; 开始依赖注入过程，先处理autowired的注入        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||               mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);              对autowired注入的处理，可以根据名字或者类型来完成bean注入            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {               autowireByName(beanName, mbd, bw, newPvs);            }            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {               autowireByType(beanName, mbd, bw, newPvs);            }              pvs = newPvs;        }          boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);          if (hasInstAwareBpps || needsDepCheck) {            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);            if (hasInstAwareBpps) {               for (BeanPostProcessor bp : getBeanPostProcessors()) {                   if (bp instanceof InstantiationAwareBeanPostProcessor) {                      InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                      pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);                      if (pvs == null) {                          return;                      }                   }               }            }            if (needsDepCheck) {               checkDependencies(beanName, mbd, filteredPds, pvs);            }        }          然后对属性进行注入        applyPropertyValues(beanName, mbd, bw, pvs);     }

通过applyPropertyvalues了解具体的对属性行进行解析然后注入的过程 protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {        if (pvs == null || pvs.isEmpty()) {            return;        }          MutablePropertyValues mpvs = null;        List<PropertyValue> original;          if (System.getSecurityManager() != null) {            if (bw instanceof BeanWrapperImpl) {               ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());            }        }          if (pvs instanceof MutablePropertyValues) {            mpvs = (MutablePropertyValues) pvs;            if (mpvs.isConverted()) {               // Shortcut: use the pre-converted values as-is.               try {                   bw.setPropertyValues(mpvs);                   return;               }               catch (BeansException ex) {                   throw new BeanCreationException(                          mbd.getResourceDescription(), beanName, "Error setting property values", ex);               }            }            original = mpvs.getPropertyValueList();        }        else {            original = Arrays.asList(pvs.getPropertyValues());        }          TypeConverter converter = getCustomTypeConverter();        if (converter == null) {            converter = bw;        }                 这个BeanDefinitionValueResolver对BeanDefinition的解析是在这个valueResolver中完成的        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter); 为解析之后的属性值创建一个副本，副本数据将会被注入到bean中        // Create a deep copy, resolving any references for values.        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());        boolean resolveNecessary = false;        for (PropertyValue pv : original) {            if (pv.isConverted()) {               deepCopy.add(pv);            }            else {               String propertyName = pv.getName();               Object originalValue = pv.getValue(); 根据需要解析的内容，originalValue和propertyName判断是reference还是list还是其他集合               Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);               Object convertedValue = resolvedValue;               boolean convertible = bw.isWritableProperty(propertyName) &&                       !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);               if (convertible) {                   convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);               }               // Possibly store converted value in merged bean definition,               // in order to avoid re-conversion for every created bean instance.               if (resolvedValue == originalValue) {                   if (convertible) {                      pv.setConvertedValue(convertedValue);                   }                   deepCopy.add(pv);               }               else if (convertible && originalValue instanceof TypedStringValue &&                      !((TypedStringValue) originalValue).isDynamic() &&                      !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {                   pv.setConvertedValue(convertedValue);                   deepCopy.add(pv);               }               else {                   resolveNecessary = true;                   deepCopy.add(new PropertyValue(pv, convertedValue));               }            }        }        if (mpvs != null && !resolveNecessary) {            mpvs.setConverted();        } 这里是依赖注入发生的地方，会在beanWrapperImpl中完成        // Set our (possibly massaged) deep copy.        try {            bw.setPropertyValues(new MutablePropertyValues(deepCopy));        }        catch (BeansException ex) {            throw new BeanCreationException(                   mbd.getResourceDescription(), beanName, "Error setting property values", ex);        }     }

大致过程：第一个调用getBean的时候，getBean会调用AbstractBeanFactory的createBean方法；createBean方法会调用doCreateBean方法得到一个Bean的引用；doCreateBean方法中定义了一个BeanWrapper用来持有创建出来bean对象，主要有两个过程，一是实例化bean，二是设置bean的依赖关系；createInstance方法中有两种方法对bean进行实例化，通过BeanUtils，使用jvm反射，一种是使用cglib生成；实例化对象之后，就需要设置bean的依赖关系；populateBean方法中先取得载入解析过程的property的值；先处理autowire的注入，根据bean的名字，类型等；然后处理property的注入；调用applyPropertyValues方法；方法中定义了一个BeanDefinitionValueResolver，设定一个需要注入的属性值的副本deepcopy，遍历属性值，使用解析器BeanDefinitionValueResolver进行属性值的解析；然后添加到deepcopy中。

上述的过程是为解析准备条件，真正把bean对象设置到另外一个依赖bean是在bw.setPropertyValues(new MutablePropertyValues(deepCopy));具体是在子类中实现了注入过程；通过几个地方的递归将，集合map，list和非集合的属性值注入到bean中，然后返回到BeanWapper，最终得到注入完成的Bean的实例。

2.4 容器其他相关特性的设计与实现

2.4.1 ApplicationContext和Bean的初始化及销毁

在容器要关闭的时候，也需要完成一系列的工作，这些工作在doClose方法中完成。在这个方法中，先发出容器关闭信号，然后将Bean逐个关闭，最后关闭容器自身。

容器的实现是通过IoC管理Bean的生命周期实现的。

 

Bean的生命周期：

①bean的初始化和实例化

②设置bean的属性，依赖注入

③应用可以通过IoC容器使用bean

④当容器关闭时，调用bean的销毁方法

Bean的初始化方法调用在initializeBean中实现：该方法在AbstractAutowireCapableBeanFactory类中

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {        if (System.getSecurityManager() != null) {            AccessController.doPrivileged(new PrivilegedAction<Object>() {               @Override               public 版权声明：本文来源CSDN，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 原文链接：https://blog.csdn.net/huangwei18351/article/details/82953688 站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。 发表于 2020-02-25 00:37:50 阅读 ( 955 ) 分类： 0 推荐 收藏 你可能感兴趣的文章 jwt,spring security ,feign,zuul,eureka 前后端分离 整合 实现 简单 权限管理系统 与 用户认证的实现 2364 浏览 Netflix时代之后Spring Cloud微服务的未来 1770 浏览 SSM框架——详细整合教程（Spring+SpringMVC+MyBatis） 1995 浏览 SpringMVC原理 1521 浏览 SpringBoot使用Async注解失效分析、解决（spring异步回调） 1833 浏览 SpringBoot之从Java到Kotlin（混用）-1 3107 浏览 SpringBoot 2.2.0.M4 发布！带来大量新特性！以及2.1.6发布！大量bug修复！ 1891 浏览 10个Spring Boot快速开发的项目，接私活利器（快速、高效） 2360 浏览 2019最全Activiti6.0集成SpringBoot2.0 2768 浏览 精选的优质文章 也许 Go 开发可以更简单！ 10539 浏览 如何使用 Golang 日志监控你的应用程序？ 12020 浏览 阿里云基于 Go 的微服务架构分享 23933 浏览 java是否会被取代？Go会否给Java带来冲击？ 28460 浏览 千万级规模高性能、高并发的网络架构经验分享 30011 浏览 阿里部分面试题汇总,对想进阿里的同学非常实用 62307 浏览 实用好文：知乎实时数仓架构实践及演进 31331 浏览 支撑马蜂窝「双11」营销大战背后的技术架构 228287 浏览 想进大厂？50个多线程面试题，你会多少？（一） 23063 浏览 0 条评论 请先 登录 后评论 官方社群 GO教程   1. Go语言简介   1.1 Go语言简介 1.2 Go语言的特性 1.3 Go语言为并发而生 1.4 哪些项目使用Go语言开发？ 1.5 哪些大公司正在使用Go语言 1.6 Go语言的性能如何？ 1.7 Go语言标准库强大 1.8 Go语言上手简单 1.9 Go语言代码风格清晰、简单 1.10 Go语言工程结构详述 1.11 第一个Go语言程序 1.12 Go语言历史版本   2. Go语言基本语法   2.1 Go语言变量的声明 2.2 Go语言变量的初始化 2.3 Go语言多个变量同时赋值 2.4 Go语言匿名变量 2.5 Go语言变量的作用域 2.6 Go语言整型（整数类型） 2.7 Go语言浮点类型（小数类型） 2.8 Go语言复数 2.9 Go语言bool类型（布尔类型） 2.10 Go语言字符串 2.11 Go语言字符类型（byte和rune） 2.12 Go语言数据类型转换 2.13 Go语言指针 2.14 Go语言变量的生命周期 2.15 Go语言常量 2.16 Go语言类型别名 2.17 Go语言关键字与标识符 2.18 Go语言运算符的优先级   3. Go语言数据结构   3.1 Go语言数组 3.2 Go语言多维数组 3.3 Go语言切片 3.4 使用append()为切片添加元素 3.5 Go语言切片复制 3.6 Go语言从切片中删除元素 3.7 Go语言range关键字 3.8 Go语言多维切片 3.9 Go语言map（映射） 3.10 Go语言遍历map 3.11 map元素的删除和清空 3.12 Go语言sync.Map 3.13 Go语言list（列表） 3.14 Go语言nil：空值/零值   4. Go语言流程控制   4.1 Go语言分支结构 4.2 Go语言循环结构 4.4 Go语言键值循环 4.5 Go语言switch语句 4.6 Go语言goto语句 4.7 Go语言break（跳出循环） 4.8 Go语言continue   5. Go语言函数   5.1 Go语言函数声明 5.2 Go语言函数变量 5.3 Go语言匿名函数 5.4 Go语言函数类型实现接口 5.5 Go语言闭包（Closure） 5.6 Go语言可变参数 5.7 Go语言defer（延迟执行语句） 5.8 Go语言递归函数 5.9 Go语言处理运行时错误 5.10 Go语言宕机（panic） 5.11 Go语言宕机恢复（recover） 5.12 Go语言计算函数执行时间 5.13 Go语言Test功能测试函数   6. Go语言结构体   6.1 Go语言结构体定义 6.2 Go语言实例化结构体 6.3 初始化结构体的成员变量 6.4 Go语言构造函数 6.5 类型内嵌和结构体内嵌 6.6 初始化内嵌结构体 6.7 内嵌结构体成员名字冲突 6.8 Go语言垃圾回收和SetFinalizer 6.9 Go语言链表操作 6.10 Go语言数据I/O对象及操作   7. Go语言接口   7.1 Go语言接口声明（定义） 7.2 Go语言实现接口的条件 7.3 Go语言类型与接口的关系 7.4 Go语言类型断言 7.5 Go语言排序 7.6 Go语言接口的嵌套组合 7.9 Go语言接口和类型之间的转换 7.10 Go语言空接口类型 7.11 Go语言类型分支 7.12 Go语言error接口   8. Go语言包   8.1 包的基本概念 8.2 Go语言封装简介及实现细节 8.3 Go语言GOPATH 8.4 Go语言常用内置包 8.5 Go语言自定义包 8.6 Go语言package 8.7 Go语言导出包中的标识符 8.8 Go语言import导入包 8.9 Go语言sync包与锁 8.10 Go语言big包 8.11 Go语言正则表达式：regexp包 8.12 Go语言time包：时间和日期 8.13 Go语言os包用法简述 8.14 Go语言flag包：命令行参数解析 8.15 Go语言go mod包依赖管理工具 8.16 Go语言runtime包:运行时   9. Go语言并发   9.1 Go语言并发简述 9.2 Go语言轻量级线程 9.3 Go语言并发通信 9.4 Go语言竞争状态 9.5 Go语言调整并发的运行性能 9.6 并发和并行的区别 9.7 goroutine和coroutine的区别 9.8 Go语言通道（chan） 9.9 示例：并发打印 9.10 Go语言单向通道 9.11 Go语言无缓冲的通道 9.12 Go语言带缓冲的通道 9.13 Go语言channel超时机制 9.14 Go语言多核并行化 9.15 互斥锁和读写互斥锁 9.16 Go语言等待组 9.17 死锁、活锁和饥饿概述 9.18 Go语言CSP：通信顺序进程简述 9.19 示例：聊天服务器   10. Go语言反射   10.1 Go语言反射（reflection） 10.2 Go语言反射规则浅析 10.3 通过反射获取类型信息 10.4 通过反射获取指针指向的元素类型 10.5 通过反射获取结构体的成员类型 10.6 Go语言结构体标签 10.7 通过反射获取值信息 10.8 通过反射访问结构体成员的值 10.9 判断反射值的空和有效性 10.10 通过反射修改变量的值 10.11 通过类型信息创建实例 10.12 通过反射调用函数 10.13 Go语言inject库：依赖注入   11. Go语言文件处理   11.1 Go语言自定义数据文件 11.2 Go语言JSON文件的读写操作 11.3 Go语言XML文件的读写操作 11.4 Go语言使用Gob传输数据 11.5 Go语言纯文本文件的读写操作 11.6 Go语言二进制文件的读写操作 11.7 Go语言自定义二进制文件的读写操作 11.8 Go语言zip归档文件的读写操作 11.9 Go语言tar归档文件的读写操作 11.10 Go语言使用buffer读取文件 11.11 Go语言文件的写入、追加、读取、复制操作 11.12 Go语言文件锁操作   12. Go语言编译和工具链   12.1 go build命令 12.2 go clean命令 12.3 go run命令 12.4 go fmt命令 12.5 go install命令 12.6 go get命令 12.7 go generate命令 12.8 go test命令 12.9 go pprof命令   13. Go语言进阶   13.1 Go语言的深拷贝和浅拷贝 13.2 Go语言引用传递和值传递 13.3 Go语言的Socket编程   14. 常见面试题   14.1 Golang Map底层实现 14.2 go语言触发异常的场景有哪些 14.3 Printf()、Sprintf()、Fprintf()函数的区别用法是什么 14.4 详细说说new和make的区别 14.5 详细说说切片和数组的区别 14.6 Golang的内存模型，为什么小对象多了会造成gc压力 14.7 Data Race问题怎么解决？能不能不加锁解决这个问题 14.8 在 range 迭代 slice 时，你怎么修改值的 14.9 select可以用于什么 14.10 go语言编程的好处是什么 14.11 你是否主动关闭过http连接，为啥要这样做 14.12 recover的执行时机 14.13 说出一个避免Goroutine泄露的措施 14.14 如何跳出for select 循环 14.15 如何初始化带嵌套结构的结构体 14.16 Printf()、Sprintf()、Fprintf()函数的区别用法是什么 14.17 go语言中的引用类型包含哪些 14.18 说说go语言的select机制 推荐文章 Spring.Net学习笔记八(方法的注入) 关于springboot热启动 SpringBoot入门系列：第六篇 mybatis 社区版idea搭建SpringBoot+Mybatis WEB工程，附源码 kubernetes构建微服务-Springboot/Python之helloworld SpringCloud结合Python,Golang实现多语言微服务架构 springboot源码编译 Spring浅谈 使用Validator做SpringMVC的验证框架 - Validator前端验证 让 Spring Boot 启动更快一点 猜你喜欢 随便看看 android 加载自定义图片并在图片上绘图 Android图片叠加效果 Android获取两张图片重叠部分，并融合 Android图片放置技巧 Android图片重叠效果绘制图片 android图片特效处理之图片叠加 Android图片特效处理之图片叠加 android smack源码分析——接收消息以及如何解析消息 android ftp4j 源码分析 深入研究mysql中group by与order by取分类最新时间内容——同理在android里也可用 × 发送私信 发给: 内容: 取消 发送 × 如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！