首页 > > 程序设计 > Java技术 >

SpringFramework之IoC容器初始化

2020-03-29 16:06:57来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

SpringFramework之IoC容器初始化

原创文章，转发请标注https://www.cnblogs.com/boycelee/p/12595884.html
目录

  • 分析例子
    • 启动类
    • Bean
    • 配置文件
  • 总体结构
  • 源码分析
    • ClassPathXmlApplicationContext
    • AbstractApplicationContext
      • refresh
      • obtainFreshBeanFactory
      • refreshBeanFactory
      • customizeBeanFactory
    • AbstractXmlApplicationContext
      • loadBeanDefinitions
      • loadBeanDefinitions
    • AbstractBeanDefinitionReader
      • loadBeanDefinitions
    • XmlBeanDefinitionReader
      • loadBeanDefinitions
      • doLoadBeanDefinitions
      • registerBeanDefinitions
    • DefaultBeanDefinitionDocumentReader
      • registerBeanDefinitions
      • doRegisterBeanDefinitions
      • parseBeanDefinitions
      • parseDefaultElement
      • processBeanDefinition
    • DefaultListableBeanFactory
      • registerBeanDefinition
  • 调用关系
  • 总结
  • 引用参考

分析例子

启动类

Application，使用的是ClassPathXmlApplicationContext来加载xml文件

/**
 * @author jianw.li
 * @date 2020/3/16 11:53 PM
 * @Description: TODO
 */
public class MyApplication {
    private static final String CONFIG_LOCATION = "classpath:application_context.xml";

    private static final String BEAN_NAME = "hello";

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext(CONFIG_LOCATION);
        Hello hello = (Hello) ac.getBean(BEAN_NAME);
        hello.sayHello();
    }
}

Bean

/**
 * @author jianw.li
 * @date 2020/3/16 11:53 PM
 * @Description: TODO
 */
public class Hello {

	public void sayHello() {
		System.out.println("Hello World");
	}
}

配置文件

? 在resources下建立名为classpath:application_context.xml的配置文件，并配置好Bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="hello" class="com.boyce.bean.Hello"></bean>

</beans>

总体结构

? ClassPathXmlApplicationContext继承体系如下：

KWJf7l

? IoC总体结构图如下：

image-20200322155805716

源码分析

ClassPathXmlApplicationContext

//构造函数，创建ClassPathXmlApplicationContext，其中configLocation为Bean所在的文件路径
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
    //null
		super(parent);
    //设置配置路径至ApplicationContext中
		setConfigLocations(configLocations);
		if (refresh) {
      //核心方法，refresh会将旧的ApplicaionContext销毁
			refresh();
		}
	}

AbstractApplicationContext

refresh

? 核心方法，refresh销毁旧ApplicationContext，生成新的ApplicationContext

@Override
	public void refresh() throws BeansException, IllegalStateException {
		//加锁.没有明确对象，只是想让一段代码同步，可以创建Object startupShutdownMonitor = new Object()
		synchronized (this.startupShutdownMonitor) {
			// 为context刷新准备.设置启动时间，设置激活状态等
			prepareRefresh();

			// 告知子类刷新内部bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//初始化所有未懒加载单例
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//广播初始化完成
				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();
			}
		}
	}
obtainFreshBeanFactory

? 告知子类刷新内部bean factory.

? 核心方法，初始化BeanFactory、加载Bean、注册Bean

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//刷新Bean工厂，关闭并销毁旧BeanFacroty
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}
refreshBeanFactory

? 关闭并销毁旧BeanFactory，创建与初始化新BeanFactory。为什么是DefaultListableBeanFactory？

@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//初始化DefaultListableBeanFactory，为什么选择实例化DefaultListableBeanFactory？而不是其他的Bean工厂
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			//Bean工厂序列化设置id
			beanFactory.setSerializationId(getId());
			//定制Bean工厂,设置不允许覆盖Bean,不允许循环依赖等
			customizeBeanFactory(beanFactory);
			//将Bean加载至Bean工厂中
			loadBeanDefinitions(beanFactory);
			//此处synchronized块与#hasBeanFactory中的synchronized块存在关联，此处锁住之后hasBeanFactory中的synchronized块将等待
			//避免beanFactory未销毁或未关闭的情况
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
customizeBeanFactory

? 定制BeanFactory。设置Bean覆盖、循环依赖等。什么是循环依赖？

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		if (this.allowBeanDefinitionOverriding != null) {
			//默认值为false不允许对Bean进行覆盖
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		if (this.allowCircularReferences != null) {
			//默认值为false,不允许循环依赖
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

AbstractXmlApplicationContext

loadBeanDefinitions
@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());
		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);
	}
loadBeanDefinitions
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			//加载资源对象，最终还是会回到这种方式去加载bean.
			reader.loadBeanDefinitions(configResources);
		}
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			//加载资源路径吗
			reader.loadBeanDefinitions(configLocations);
		}
	}

AbstractBeanDefinitionReader

loadBeanDefinitions
@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;
	}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
        // 将xml转为Resource,所以上面的两种资源加载方式，最终都会回到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;
	}

XmlBeanDefinitionReader

loadBeanDefinitions

? 从详细的XML文件中加载Bean

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());
		}

		//用于存储编译过的Reource
		Set<EncodedResource> 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();
			}
		}
	}
doLoadBeanDefinitions

? 从xml文件中加载bean，将xml转为Document并注册Bean

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			//将xml转为Document
			Document doc = doLoadDocument(inputSource, resource);
			//注册Bean
			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);
		}
	}
registerBeanDefinitions

? 计算从当前配置文件中加载bean的数量

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

DefaultBeanDefinitionDocumentReader

registerBeanDefinitions

? 从“spring-beans” xsd中解析bean。什么是xsd？XML结构定义 （ XML Schemas Definition）

@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}
doRegisterBeanDefinitions

? 从根节点开始注册每一个Bean

/**
	 * Register each bean definition within the given root {@code <beans/>} element.
	 * 从根节点开始注册每一个Bean
	 */
	protected void doRegisterBeanDefinitions(Element root) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> 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.
		//可以通过spring.profiles.active设定当前环境激活的profile,例如配置prod,可以通过@ActiveProfiles配置

		//解析bean定义
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			//获取元素中profile属性，可以通过xml或@Profile设置当前bean所属的profile
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			//不能做profile属性则直接跳过
			if (StringUtils.hasText(profileSpec)) {
				//配置多profile
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				//元素中的profile是否是环境指定的profiles之一
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isInfoEnabled()) {
						logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					//不在当前环境指定的profile中则return
					return;
				}
			}
		}

		preProcessXml(root);
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}
parseBeanDefinitions

? 从文档根节点开始解析元素，import、alias、bean等

/**
	 * Parse the elements at the root level in the document:
	 * "import", "alias", "bean".
	 * @param root the DOM root element of the document
	 */
	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)) {
						//解析default namespace下的元素（例如：<import>、<alias>、<beans>、<bean>）
						parseDefaultElement(ele, delegate);
					}
					else {
						//解析Custom元素（例如：<mvc>、<context>、<aop>）
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}
parseDefaultElement

? 解析default namespace下的元素（例如：、、、）

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			//了解bean解析源码
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}
processBeanDefinition

? 获取bean元素解析并注册

/**
	 * Process the given bean element, parsing the bean definition
	 * and registering it with the registry.
	 * 获取bean元素解析并注册
	 */
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//解析bean元素并封装至BeanDefinitionHolder
		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));
		}

DefaultListableBeanFactory

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;
		//beanDefinitionMap放置所有注册的Bean
		oldBeanDefinition = this.beanDefinitionMap.get(beanName);

		//如果bean名已存在
		if (oldBeanDefinition != null) {
			//不允许覆盖bean
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + oldBeanDefinition + "] bound.");
			}
			//通过比较BeanRole.判断谁覆盖谁
			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 + "]");
				}
			}
			//新bean覆盖旧bean
			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 + "]");
				}
			}
			//将bean放置beanDefinitionMap中
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		//beanName没有与beanDefinitionMap中的重复
		else {
			//非正常情况下，其他的Bean已经初始化，如果已经有bean初始化，则使用者已经在进行业务操作，无法保证对beanDefinitionMap、beanDefinitionNames、manualSingletonNames进行操作的一些列动作的线程安全，所以需要加锁。参考：https://blog.csdn.net/qq_41907991/article/details/97614337
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
				//bean放置beanDefinitionMap中
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//记录bean名称
				this.beanDefinitionNames.add(beanName);
				//bean不需要手动注册
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

调用关系

? qRXagm

总结

? 至此已经完成了IoC容器的初始化。将xml文件中的bean元素解析为Bean，将Bean注册至注册中心，并发送注册事件。DefaultListableBeanFactory建立Bean配置信息，这些信息都存放在BeanDefinitionMap中，由IoC容器来维护。

? 最后，懂得不多，做得很少。文章肯定又不少错误，如大家发现麻烦及时指出，为了避免误导更多人，我也会及时学习并修改！

引用参考

[1]《Spring技术内幕》

[2]https://www.javadoop.com/post/spring-ioc

[3]https://github.com/seaswalker/spring-analysis/blob/master/note/Spring.md#classpathxmlapplicationcontext

原创文章，转发请标注https://www.cnblogs.com/boycelee/p/12595884.html


原文链接:https://www.cnblogs.com/boycelee/p/12595884.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：深入Redis命令的执行过程

下一篇：【数据结构和算法】001 单链表 LinkedList

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签