登录 注册

spring 的 IOC 流程（源码流程）

本贴最后更新于 2450 天前，其中的信息可能已经时移世易

先从源码来看 spring 的 IOC 都经历了哪些方法：
1.开始加载 xml 配置文件

ApplicationContext context = new ClassPathXmlApplicationContext("test.xml");
​

2.ApplicationContext 的构造方法

this(new String[] {configLocation}, true, null);
public ClassPathXmlApplicationContext(  
      String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)  
      throws BeansException {  
  
   super(parent);  
   setConfigLocations(configLocations);  
   if (refresh) {  
      refresh();  
   }  
}
​

3.父类构造方法
一直跳转到 AbstractApplicationContext 文件

public AbstractApplicationContext(@Nullable ApplicationContext parent) {  
   this();  
   setParent(parent);  
}
​

其中 this（）方法是创建一个新的 AbstractApplicationContext，并生成一个默认的资源模式解析器。因为 parent 为 null,所以 setParent 没有实质作用。

4.设置配置文件路径
返回 ClassPathXmlApplicationContext 查看 setConfigLocations 方法。此方法是将传入的资源路径保存下来。

public void setConfigLocations(@Nullable String... locations) {  
   if (locations != null) {  
      Assert.noNullElements(locations, "Config locations must not be null");  
      this.configLocations = new String[locations.length];  
      for (int i = 0; i < locations.length; i++) {  
         this.configLocations[i] = resolvePath(locations[i]).trim();  
      }  
   }  
   else {  
      this.configLocations = null;  
   }  
}
​

5.refresh 方法
主要的 IOC 方法。主要看 spring 的 beanfactory 怎么生成的，以及保存了什么。

@Override  
public void refresh() throws BeansException, IllegalStateException {  
   synchronized (this.startupShutdownMonitor) {  
      // 准备此上下文以进行刷新。
  prepareRefresh();  
  
      // 告诉子类刷新内部bean工厂。
  ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
  
      // 准备在这种情况下使用的Bean工厂。
  prepareBeanFactory(beanFactory);  
  
      try {  
         // 允许在上下文子类中对bean工厂进行后处理。
  postProcessBeanFactory(beanFactory);  
  
         // 调用工厂处理器在上下文中注册为bean。 
  invokeBeanFactoryPostProcessors(beanFactory);  
  
         // 注册bean处理器，拦截bean创建。
  registerBeanPostProcessors(beanFactory);  
  
         // Initialize message source for this context.  
  initMessageSource();  
  
         // 初始化此上下文的消息源。
  initApplicationEventMulticaster();  
  
         // 在特定上下文子类中初始化其他特殊bean。
  onRefresh();  
  
         // Check for listener beans and register them.  
  registerListeners();  
  
         // 检查侦听器bean并注册它们。
  finishBeanFactoryInitialization(beanFactory);  
  
         // 最后一步：发布相应的事件。
  finishRefresh();  
      }  
  
      catch (BeansException ex) {  
         if (logger.isWarnEnabled()) {  
            logger.warn("Exception encountered during context initialization - " +  
                  "cancelling refresh attempt: " + ex);  
         }  
  
         // Destroy already created singletons to avoid dangling resources.  
  destroyBeans();  
  
         // Reset 'active' flag.  
  cancelRefresh(ex);  
  
         // Propagate exception to caller.  
  throw ex;  
      }  
  
      finally {  
         // Reset common introspection caches in Spring's core, since we  
 // might not ever need metadata for singleton beans anymore...  resetCommonCaches();  
      }  
   }  
}
​

6.obtainFreshBeanFactory 方法
在 refreshBeanFactory 生成 beanFactory，然后通过 getBeanFactory 获取

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {  
   refreshBeanFactory();  
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();  
   if (logger.isDebugEnabled()) {  
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);  
   }  
   return beanFactory;  
}
​

7.refreshBeanFactory 的实现方法
在 idea 中可以使用 ctrl+alt+b 的快捷键查看方法的实现方法。该方法在 AbstractRefreshableApplicationContext 中，
可以看到，方法中先销毁了之前的 beanFactory（如果有的话）,然后生成了一个默认的 DefaultListableBeanFactory。然后将 beanFactory 保存，使得上一步的 getBeanFactory 可以获取。然后看 loadBeanDefinitions 方法。

protected final void refreshBeanFactory() throws BeansException {  
   if (hasBeanFactory()) {  
      destroyBeans();  
      closeBeanFactory();  
   }  
   try {  
      DefaultListableBeanFactory beanFactory = createBeanFactory();  
      beanFactory.setSerializationId(getId());  
      customizeBeanFactory(beanFactory);  
      loadBeanDefinitions(beanFactory);  
      synchronized (this.beanFactoryMonitor) {  
         this.beanFactory = beanFactory;  
      }  
   }  
   catch (IOException ex) {  
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  
   }  
}
​

8.loadBeanDefinitions 方法
这里有很多的 loadBeanDefinitions 在互相调用，这些 loadBeanDefinitions 的作用就是将最开始传入的资源文件路径加载，封装成 InputSource，方便后续解析文件。

//生成一个xml读取器
@Override  
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {  
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.  
  XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
  
   // Configure the bean definition reader with this context's  
 // resource loading environment.  beanDefinitionReader.setEnvironment(this.getEnvironment());  
//传入一个资源加载器，就是AbstractXmlApplicationContext
   beanDefinitionReader.setResourceLoader(this);  
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
  
   // Allow a subclass to provide custom initialization of the reader,  
 // then proceed with actually loading the bean definitions.  initBeanDefinitionReader(beanDefinitionReader);  
   loadBeanDefinitions(beanDefinitionReader);  
}
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {  
   Resource[] configResources = getConfigResources();  
   if (configResources != null) {  
      reader.loadBeanDefinitions(configResources);  
   }  
//用reader读取最开始传入的资源文件路径
   String[] configLocations = getConfigLocations();  
   if (configLocations != null) {  
      reader.loadBeanDefinitions(configLocations);  
   }  
}
@Override  
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {  
   Assert.notNull(locations, "Location array must not be null");  
   int counter = 0;  
   for (String location : locations) {  
      counter += loadBeanDefinitions(location);  
   }  
   return counter;  
}
@Override  
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {  
   return loadBeanDefinitions(location, null);  
}
public int loadBeanDefinitions(String location, @Nullable Set actualResources) throws BeanDefinitionStoreException {  
   ResourceLoader resourceLoader = getResourceLoader();  
   if (resourceLoader == null) {  
      throw new BeanDefinitionStoreException(  
            "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");  
   }  
  //前面传入了一个资源加载器，可以通过继承树看出AbstractXmlApplicationContext是ResourcePatternResolver的子类
   if (resourceLoader instanceof ResourcePatternResolver) {  
      // Resource pattern matching available.  
  try {  
//将资源文件的路径封装成Resource
         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);  
         int loadCount = loadBeanDefinitions(resources);  
         if (actualResources != null) {  
            for (Resource resource : resources) {  
               actualResources.add(resource);  
            }  
         }  
         if (logger.isDebugEnabled()) {  
            logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");  
         }  
         return loadCount;  
      }  
      catch (IOException ex) {  
         throw new BeanDefinitionStoreException(  
               "Could not resolve bean definition resource pattern [" + location + "]", ex);  
      }  
   }  
   else {  
      // Can only load single resources by absolute URL.  
  Resource resource = resourceLoader.getResource(location);  
      int loadCount = loadBeanDefinitions(resource);  
      if (actualResources != null) {  
         actualResources.add(resource);  
      }  
      if (logger.isDebugEnabled()) {  
         logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");  
      }  
      return loadCount;  
   }  
}
@Override  
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {  
   Assert.notNull(resources, "Resource array must not be null");  
   int counter = 0;  
   for (Resource resource : resources) {  
      counter += loadBeanDefinitions(resource);  
   }  
   return counter;  
}
@Override  
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {  
   return loadBeanDefinitions(new EncodedResource(resource));  
}
//封装资源文件和inputstream
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
   Assert.notNull(encodedResource, "EncodedResource must not be null");  
   if (logger.isInfoEnabled()) {  
      logger.info("Loading XML bean definitions from " + encodedResource.getResource());  
   }  
  
   Set currentResources = this.resourcesCurrentlyBeingLoaded.get();  
   if (currentResources == null) {  
      currentResources = new HashSet<>(4);  
      this.resourcesCurrentlyBeingLoaded.set(currentResources);  
   }  
   if (!currentResources.add(encodedResource)) {  
      throw new BeanDefinitionStoreException(  
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");  
   }  
   try {  
      InputStream inputStream = encodedResource.getResource().getInputStream();  
      try {  
         InputSource inputSource = new InputSource(inputStream);  
         if (encodedResource.getEncoding() != null) {  
            inputSource.setEncoding(encodedResource.getEncoding());  
         }  
         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());  
      }  
      finally {  
         inputStream.close();  
      }  
   }  
   catch (IOException ex) {  
      throw new BeanDefinitionStoreException(  
            "IOException parsing XML document from " + encodedResource.getResource(), ex);  
   }  
   finally {  
      currentResources.remove(encodedResource);  
      if (currentResources.isEmpty()) {  
         this.resourcesCurrentlyBeingLoaded.remove();  
      }  
   }  
}
​

8.doLoadBeanDefinitions 方法

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)  
      throws BeanDefinitionStoreException {  
   try {  
//使用前面封装的资源文件和inputSource读取资源文件，并封装为Document对象
      Document doc = doLoadDocument(inputSource, resource);  
      return registerBeanDefinitions(doc, resource);  
   }  
   catch (BeanDefinitionStoreException ex) {  
      throw ex;  
   }  
   catch (SAXParseException ex) {  
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
            "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);  
   }  
   catch (SAXException ex) {  
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
            "XML document from " + resource + " is invalid", ex);  
   }  
   catch (ParserConfigurationException ex) {  
      throw new BeanDefinitionStoreException(resource.getDescription(),  
            "Parser configuration exception parsing XML from " + resource, ex);  
   }  
   catch (IOException ex) {  
      throw new BeanDefinitionStoreException(resource.getDescription(),  
            "IOException parsing XML document from " + resource, ex);  
   }  
   catch (Throwable ex) {  
      throw new BeanDefinitionStoreException(resource.getDescription(),  
            "Unexpected exception parsing XML document from " + resource, ex);  
   }  
}
​

9.registerBeanDefinitions 方法

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {  
//创建一个BeanDefinition读取器
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();  
   int countBefore = getRegistry().getBeanDefinitionCount();  
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));  
   return getRegistry().getBeanDefinitionCount() - countBefore;  
}
@Override  
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {  
   this.readerContext = readerContext;  
   logger.debug("Loading bean definitions");  
   Element root = doc.getDocumentElement();  
   doRegisterBeanDefinitions(root);  
}
​

10.doRegisterBeanDefinitions

protected void doRegisterBeanDefinitions(Element root) {  
   // Any nested  elements will cause recursion in this method. In  
 // order to propagate and preserve  default-* attributes correctly, // keep track of the current (parent) delegate, which may be null. Create // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one.  BeanDefinitionParserDelegate parent = this.delegate;  
   this.delegate = createDelegate(getReaderContext(), root, parent);  
  
   if (this.delegate.isDefaultNamespace(root)) {  
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);  
      if (StringUtils.hasText(profileSpec)) {  
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(  
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);  
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {  
            if (logger.isInfoEnabled()) {  
               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +  
                     "] not matching: " + getReaderContext().getResource());  
            }  
            return;  
         }  
      }  
   }  
  
   preProcessXml(root);  
//开始解析Document中的Element信息
   parseBeanDefinitions(root, this.delegate);  
   postProcessXml(root);  
  
   this.delegate = parent;  
}
​

11.parseBeanDefinitions

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {  
   if (delegate.isDefaultNamespace(root)) {  
      NodeList nl = root.getChildNodes();  
      for (int i = 0; i < nl.getLength(); i++) {  
         Node node = nl.item(i);  
         if (node instanceof Element) {  
            Element ele = (Element) node;  
            if (delegate.isDefaultNamespace(ele)) { 
//             使用默认的命名空间解析element 
               parseDefaultElement(ele, delegate);  
            }  
            else {  
               delegate.parseCustomElement(ele);  
            }  
         }  
      }  
   }  
   else {  
      delegate.parseCustomElement(root);  
   }  
}
​

12.parseDefaultElement

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {  
//注册import标签信息
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {  
      importBeanDefinitionResource(ele);  
   }  
//注册alias标签信息
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {  
      processAliasRegistration(ele);  
   }  
//注册Bean标签信息
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {  
      processBeanDefinition(ele, delegate);  
   }  
//解析beans标签信息
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {  
      // recurse  
  doRegisterBeanDefinitions(ele);  
   }  
}
​

13.processBeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {  
//这里已经将配置文件的信息封装为BeanDefinitionHolder，该类保存了BeanDefinition，BeanName和BeanAlices
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  
   if (bdHolder != null) {  
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);  
      try {  
         // Register the final decorated instance.  
  BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());  
      }  
      catch (BeanDefinitionStoreException ex) {  
         getReaderContext().error("Failed to register bean definition with name '" +  
               bdHolder.getBeanName() + "'", ele, ex);  
      }  
      // Send registration event.  
  getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));  
   }  
}
​

14.registerBeanDefinition

public static void registerBeanDefinition(  
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)  
      throws BeanDefinitionStoreException {  
  
   // Register bean definition under primary name.  
  String beanName = definitionHolder.getBeanName();  
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());  
  
   // Register aliases for bean name, if any.  
  String[] aliases = definitionHolder.getAliases();  
   if (aliases != null) {  
      for (String alias : aliases) {  
         registry.registerAlias(beanName, alias);  
      }  
   }  
}
​

15.registerBeanDefinition

@Override  
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
      throws BeanDefinitionStoreException {  
  
   Assert.hasText(beanName, "Bean name must not be empty");  
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");  
  
   if (beanDefinition instanceof AbstractBeanDefinition) {  
      try {  
         ((AbstractBeanDefinition) beanDefinition).validate();  
      }  
      catch (BeanDefinitionValidationException ex) {  
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,  
               "Validation of bean definition failed", ex);  
      }  
   }  
  
   BeanDefinition oldBeanDefinition;  
  
   oldBeanDefinition = this.beanDefinitionMap.get(beanName);  
   if (oldBeanDefinition != null) {  
      if (!isAllowBeanDefinitionOverriding()) {  
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,  
               "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +  
               "': There is already [" + oldBeanDefinition + "] bound.");  
      }  
      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {  
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE  
  if (this.logger.isWarnEnabled()) {  
            this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +  
                  "' with a framework-generated bean definition: replacing [" +  
                  oldBeanDefinition + "] with [" + beanDefinition + "]");  
         }  
      }  
      else if (!beanDefinition.equals(oldBeanDefinition)) {  
         if (this.logger.isInfoEnabled()) {  
            this.logger.info("Overriding bean definition for bean '" + beanName +  
                  "' with a different definition: replacing [" + oldBeanDefinition +  
                  "] with [" + beanDefinition + "]");  
         }  
      }  
      else {  
         if (this.logger.isDebugEnabled()) {  
            this.logger.debug("Overriding bean definition for bean '" + beanName +  
                  "' with an equivalent definition: replacing [" + oldBeanDefinition +  
                  "] with [" + beanDefinition + "]");  
         }  
      }  
//将前面封装的BeanDefinitionHolder中的beanName和beanDefinition保存到一个ConcurrentHashMap中
      this.beanDefinitionMap.put(beanName, beanDefinition);  
   }  
   else {  
      if (hasBeanCreationStarted()) {  
         // Cannot modify startup-time collection elements anymore (for stable iteration)  
  synchronized (this.beanDefinitionMap) {  
            this.beanDefinitionMap.put(beanName, beanDefinition);  
            List updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);  
            updatedDefinitions.addAll(this.beanDefinitionNames);  
            updatedDefinitions.add(beanName);  
            this.beanDefinitionNames = updatedDefinitions;  
            if (this.manualSingletonNames.contains(beanName)) {  
               Set updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);  
               updatedSingletons.remove(beanName);  
               this.manualSingletonNames = updatedSingletons;  
            }  
         }  
      }  
      else {  
         // Still in startup registration phase  
  this.beanDefinitionMap.put(beanName, beanDefinition);  
         this.beanDefinitionNames.add(beanName);  
         this.manualSingletonNames.remove(beanName);  
      }  
      this.frozenBeanDefinitionNames = null;  
   }  
  
   if (oldBeanDefinition != null || containsSingleton(beanName)) {  
      resetBeanDefinition(beanName);  
   }  
}
​

终于结束了，可以看到，最后将 beanDefinition 存放在了 beanDefinitionMap 中，而 beanDefinitionMap 就是一个 ConcurrentHashMap 集合。

  • Spring

    Spring 是一个开源框架，是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

    948 引用 • 1460 回帖
成都 位置
537 2 53 185 30 57 58 135

相关帖子

回帖
spring 的 IOC 流程（源码流程）

欢迎来到这里！

我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。

注册 关于
请输入回帖内容 ...
18380422102
成都
回帖
1
 帖子
6
 积分
505

近期热议

推荐标签 标签

  • 链书

    链书（Chainbook）是 B3log 开源社区提供的区块链纸质书交易平台，通过 B3T 实现共享激励与价值链。可将你的闲置书籍上架到链书，我们共同构建这个全新的交易平台，让闲置书籍继续发挥它的价值。

    链书社

    链书目前已经下线，也许以后还有计划重制上线。

    14 引用 • 257 回帖
  • Python

    Python 是一种面向对象、直译式电脑编程语言，具有近二十年的发展历史，成熟且稳定。它包含了一组完善而且容易理解的标准库，能够轻松完成很多常见的任务。它的语法简捷和清晰，尽量使用无异义的英语单词，与其它大多数程序设计语言使用大括号不一样，它使用缩进来定义语句块。

    556 引用 • 675 回帖
  • Gzip

    gzip （GNU zip）是 GNU 自由软件的文件压缩程序。我们在 Linux 中经常会用到后缀为 .gz 的文件，它们就是 Gzip 格式的。现今已经成为互联网上使用非常普遍的一种数据压缩格式，或者说一种文件格式。

    9 引用 • 12 回帖 • 165 关注
  • V2Ray
    1 引用 • 15 回帖
  • Log4j

    Log4j 是 Apache 开源的一款使用广泛的 Java 日志组件。

    20 引用 • 18 回帖 • 30 关注
  • 分享

    有什么新发现就分享给大家吧！

    248 引用 • 1794 回帖
  • BND

    BND（Baidu Netdisk Downloader）是一款图形界面的百度网盘不限速下载器，支持 Windows、Linux 和 Mac，详细介绍请看这里。

    107 引用 • 1281 回帖 • 33 关注
  • PWL

    组织简介

    用爱发电 (Programming With Love) 是一个以开源精神为核心的民间开源爱好者技术组织，“用爱发电”象征开源与贡献精神，加入组织，代表你将遵守组织的“个人开源爱好者”的各项条款。申请加入：用爱发电组织邀请帖。
    用爱发电组织官网：https://programmingwithlove.stackoverflow.wiki/

    用爱发电组织的核心驱动力：

    • 遵守开源守则，体现开源&贡献精神：以分享为目的，拒绝非法牟利。
    • 自我保护：使用适当的 License 保护自己的原创作品。
    • 尊重他人：不以各种理由、各种漏洞进行未经允许的抄袭、散播、洩露；以礼相待，尊重所有对社区做出贡献的开发者；通过他人的分享习得知识，要留下足迹，表示感谢。
    • 热爱编程、热爱学习：加入组织，热爱编程是首当其要的。我们欢迎热爱讨论、分享、提问的朋友，也同样欢迎默默成就的朋友。
    • 倾听：正确并恳切对待、处理问题与建议，及时修复开源项目的 Bug ，及时与反馈者沟通。不抬杠、不无视、不辱骂。
    • 平视：不诋毁、轻视、嘲讽其他开发者，主动提出建议、施以帮助，以和谐为本。只要他人肯努力，你也可能会被昔日小看的人所超越，所以请保持谦虚。
    • 乐观且活跃：你的努力决定了你的高度。不要放弃，多年后回头俯瞰，才会发现自己已经成就往日所仰望的水平。积极地将项目开源，帮助他人学习、改进，自己也会获得相应的提升、成就与成就感。
    1 引用 • 487 回帖 • 2 关注
  • C++

    C++ 是在 C 语言的基础上开发的一种通用编程语言，应用广泛。C++ 支持多种编程范式，面向对象编程、泛型编程和过程化编程。

    107 引用 • 153 回帖 • 1 关注
  • Electron

    Electron 基于 Chromium 和 Node.js，让你可以使用 HTML、CSS 和 JavaScript 构建应用。它是一个由 GitHub 及众多贡献者组成的活跃社区共同维护的开源项目，兼容 Mac、Windows 和 Linux，它构建的应用可在这三个操作系统上面运行。

    15 引用 • 136 回帖 • 4 关注
  • 设计模式

    设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    200 引用 • 120 回帖
  • PostgreSQL

    PostgreSQL 是一款功能强大的企业级数据库系统，在 BSD 开源许可证下发布。

    22 引用 • 22 回帖 • 2 关注
  • Openfire

    Openfire 是开源的、基于可拓展通讯和表示协议 (XMPP)、采用 Java 编程语言开发的实时协作服务器。Openfire 的效率很高，单台服务器可支持上万并发用户。

    6 引用 • 7 回帖 • 105 关注
  • SendCloud

    SendCloud 由搜狐武汉研发中心孵化的项目，是致力于为开发者提供高质量的触发邮件服务的云端邮件发送平台，为开发者提供便利的 API 接口来调用服务，让邮件准确迅速到达用户收件箱并获得强大的追踪数据。

    2 引用 • 8 回帖 • 497 关注
  • 持续集成

    持续集成（Continuous Integration）是一种软件开发实践，即团队开发成员经常集成他们的工作，通过每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，从而尽早地发现集成错误。

    15 引用 • 7 回帖
  • 服务器

    服务器，也称伺服器，是提供计算服务的设备。由于服务器需要响应服务请求，并进行处理，因此一般来说服务器应具备承担服务并且保障服务的能力。

    125 引用 • 585 回帖
  • Spark

    Spark 是 UC Berkeley AMP lab 所开源的类 Hadoop MapReduce 的通用并行框架。Spark 拥有 Hadoop MapReduce 所具有的优点；但不同于 MapReduce 的是 Job 中间输出结果可以保存在内存中，从而不再需要读写 HDFS，因此 Spark 能更好地适用于数据挖掘与机器学习等需要迭代的 MapReduce 的算法。

    74 引用 • 46 回帖 • 565 关注
  • HBase

    HBase 是一个分布式的、面向列的开源数据库，该技术来源于 Fay Chang 所撰写的 Google 论文 “Bigtable：一个结构化数据的分布式存储系统”。就像 Bigtable 利用了 Google 文件系统所提供的分布式数据存储一样，HBase 在 Hadoop 之上提供了类似于 Bigtable 的能力。

    17 引用 • 6 回帖 • 57 关注
  • C

    C 语言是一门通用计算机编程语言，应用广泛。C 语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

    86 引用 • 165 回帖 • 2 关注
  • 浅吟主题

    Jeffrey Chen 制作的思源笔记主题，项目仓库：https://github.com/TCOTC/Whisper

    1 引用 • 28 回帖
  • DNSPod

    DNSPod 建立于 2006 年 3 月份，是一款免费智能 DNS 产品。 DNSPod 可以为同时有电信、网通、教育网服务器的网站提供智能的解析，让电信用户访问电信的服务器，网通的用户访问网通的服务器，教育网的用户访问教育网的服务器，达到互联互通的效果。

    6 引用 • 26 回帖 • 530 关注
  • OnlyOffice
    4 引用 • 22 关注
  • 架构

    我们平时所说的“架构”主要是指软件架构，这是有关软件整体结构与组件的抽象描述，用于指导软件系统各个方面的设计。另外还有“业务架构”、“网络架构”、“硬件架构”等细分领域。

    143 引用 • 442 回帖
  • SSL

    SSL（Secure Sockets Layer 安全套接层），及其继任者传输层安全（Transport Layer Security，TLS）是为网络通信提供安全及数据完整性的一种安全协议。TLS 与 SSL 在传输层对网络连接进行加密。

    70 引用 • 193 回帖 • 411 关注
  • Angular

    Angular 是 AngularJS 的新版本。

    26 引用 • 66 回帖 • 549 关注
  • 百度

    百度（Nasdaq：BIDU）是全球最大的中文搜索引擎、最大的中文网站。2000 年 1 月由李彦宏创立于北京中关村，致力于向人们提供“简单，可依赖”的信息获取方式。“百度”二字源于中国宋朝词人辛弃疾的《青玉案·元夕》词句“众里寻他千百度”，象征着百度对中文信息检索技术的执著追求。

    63 引用 • 785 回帖 • 92 关注
  • 倾城之链
    23 引用 • 66 回帖 • 166 关注

最新标签