高如风
高如风

spring源码分析bean的生命周期（上）

bean扫描生成BeanDefinition的过程：

spring源码分析bean的生命周期（上）_第1张图片

创建非懒加载的单例bean的过程：

spring源码分析bean的生命周期（上）_第2张图片

spring容器初始化好之后，首先要进行bean的扫描，然后再进行bean的创建和管理 

一、扫描生成BeanDefinition

public int scan(String... basePackages) {
        // 扫描开始前有多少BeanDefinition
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

        // 扫描结束后有多少BeanDefinition
		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}

scan()方法解释如下：

  1. 获取扫描前BeanDefinition的个数
  2. 获取调用doScan()方法扫描的BeanDefinition个数
protected Set doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
            // 查找BeanDefinition
			Set candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
                // 解析类上的@Scope的value属性
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                // 给BeanDefinition设置Scope属性
				candidate.setScope(scopeMetadata.getScopeName());
                // 根据@Component上指定名称 如果没有调用Introspector.decapitalize(shortClassName)返回
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
                    // 给BeanDefinition设置默认值
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
                    // 解析@Lazy、@Primary、@DependsOn、@Role、@Description
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
                    // 通过beanName判断是否已存在BeanDefinition
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    // 添加到Set集合中
					beanDefinitions.add(definitionHolder);
                    // 注册BeanDefinition
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
public Set findCandidateComponents(String basePackage) {
        // 会对spring.xml文件中对符合includeFilters返回BeanDefinition
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
            // 包路径扫描
			return scanCandidateComponents(basePackage);
		}
	}
private Set scanCandidateComponents(String basePackage) {
		Set candidates = new LinkedHashSet<>();
		try {
			// 获取basePackage下所有的文件资源
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            // 资源加载
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);

			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
            // 遍历资源文件
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
                // 资源是否可读
				if (resource.isReadable()) {
					try {
                        // 元数据读取器读取资源文件
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						// excludeFilters、includeFilters判断
						if (isCandidateComponent(metadataReader)) { // @Component-->includeFilters判断
                            // 创建BeanDefinition设置beanClass属性为类名称
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setSource(resource);
                            // 是否为顶级类&&（不是抽象类或接口||是抽象类并且有方法上加了@Lookup注解）
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
                                // 添加到集合中
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}
// 根据beanDefinition返回beanName
@Override
	public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		if (definition instanceof AnnotatedBeanDefinition) {
			// 获取注解所指定的beanName
			String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
			if (StringUtils.hasText(beanName)) {
				// Explicit bean name found.
				return beanName;
			}
		}
		// Fallback: generate a unique default bean name.
		return buildDefaultBeanName(definition, registry);
	}
@Nullable
	protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
		AnnotationMetadata amd = annotatedDef.getMetadata();
		Set types = amd.getAnnotationTypes();
		String beanName = null;
		for (String type : types) {
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
			if (attributes != null) {
				Set metaTypes = this.metaAnnotationTypesCache.computeIfAbsent(type, key -> {
					Set result = amd.getMetaAnnotationTypes(key);
					return (result.isEmpty() ? Collections.emptySet() : result);
				});
				if (isStereotypeWithNameValue(type, metaTypes, attributes)) {
                    // 获取org.springframework.stereotype.Component注解类的value属性
					Object value = attributes.get("value");
					if (value instanceof String) {
                        // 强转成string
						String strVal = (String) value;
						if (StringUtils.hasLength(strVal)) {
							if (beanName != null && !strVal.equals(beanName)) {
								throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
										"component names: '" + beanName + "' versus '" + strVal + "'");
							}
                            // 赋值
							beanName = strVal;
						}
					}
				}
			}
		}
        // 最终返回
		return beanName;
	}
protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
        // beanName已经注册过BeanDefinition返回true
		if (!this.registry.containsBeanDefinition(beanName)) {
			return true;
		}
		BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
		BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
		if (originatingDef != null) {
			existingDef = originatingDef;
		}
		// 是否兼容，如果兼容返回false表示不会重新注册到Spring容器中，如果不冲突则会抛异常。
		if (isCompatible(beanDefinition, existingDef)) {
			return false;
		}
        // 一个beanName存在其它类@Component指定的名称 就是说两个类用同一个beanName
		throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
				"' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
				"non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
	}
protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
	}

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
        // 获取BeanDefinition注册到spring容器中
		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);
			}
		}
	}

@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 existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			// 默认是允许BeanDefinition覆盖的
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
            // 添加beanDefinition到beanDefinitionMap中
			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;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
                // 添加beanName到beanDefinitionNames中
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}
  1. 首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件（Spring源码中将此文件包装成了Resource对象）
  2. 遍历每个Resource对象
  3. 利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）
  4. 利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选（条件注解并不能理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）
  5. 筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition
  6. 再基于metadataReader判断是不是对应的类是不是接口或抽象类
  7. 如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有

  1. 获取类的名字、
  2. 获取父类的名字
  3. 获取所实现的所有接口名
  4. 获取所有内部类的名字
  5. 判断是不是抽象类
  6. 判断是不是接口
  7. 判断是不是一个注解
  8. 获取拥有某个注解的方法集合
  9. 获取类上添加的所有注解信息
  10. 获取类上添加的所有注解类型集合

值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）
​

最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的，或者@Bean注解得到BeanDefinition对象。（后续课程会分析@Bean注解是怎么生成BeanDefinition的）。

二、合并成RootBeanDefinition

父子BeanDefinition，如果子BeanDefinition有指定属性就按照子BeanDefinition设定，没有指定就继承父BeanDefinition的

合并获取bean的源码 

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 获取合并后的BeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					// 获取FactoryBean对象
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							// isEagerInit()返回true 创建真正的Bean对象(getObject()返回的对象)
							getBean(beanName);
						}
					}
				}
				else {
					// 创建Bean对象
					getBean(beanName);
				}
			}
		}

		// 所有的非懒加载单例Bean都创建完了后
		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
                    // 实现了SmartInitializingSingleton的非懒加载的单例bean 执行afterSingletonsInstantiated()方法
					smartSingleton.afterSingletonsInstantiated();
				}
				smartInitialize.end();
			}
		}
	}

// 合并BeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// Quick check on the concurrent map first, with minimal locking.
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null && !mbd.stale) {
			return mbd;
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {

		return getMergedBeanDefinition(beanName, bd, null);
	}

protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;
			RootBeanDefinition previous = null;

			// Check with full lock now in order to enforce the same merged instance.
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null || mbd.stale) {
				previous = mbd;
                // 如果当前BeanDefinition没有父级BeanDefinition 
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
                        // 当前BeanDefinition如果实现了RootBeanDefinition 克隆
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
                        // 创建一个RootBeanDefinition
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					// Child bean definition: needs to be merged with parent.
					// pbd表示parentBeanDefinition
					BeanDefinition pbd;
					try {
						String parentBeanName = transformedBeanName(bd.getParentName());
                        // BeanDefinition的parent还有parent 所以要递归合并
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
												"': cannot be resolved without a ConfigurableBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}

					// Deep copy with overridden values.
					// 子BeanDefinition的属性覆盖父BeanDefinition的属性，这就是合并
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				// Set default singleton scope, if not configured before.
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(SCOPE_SINGLETON);
				}

				// A bean contained in a non-singleton bean cannot be a singleton itself.
				// Let's correct this on the fly here, since this might be the result of
				// parent-child merging for the outer bean, in which case the original inner bean
				// definition will not have inherited the merged outer bean's singleton status.
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				// Cache the merged bean definition for the time being
				// (it might still get re-merged later on in order to pick up metadata changes)
				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}
			if (previous != null) {
				copyRelevantMergedBeanDefinitionCaches(previous, mbd);
			}
			return mbd;
		}
	}


1、@Conditional注解


实现Condition接口，重写matches()方法，如果返回true就会生成bean，返回false不会生成beanDefinition，更不会生成bean


public class TestCondition implements Condition {
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		return true;
	}
}

@Component
@Conditional(TestCondition.class)
public class UserService {
}

// 创建一个Spring容器
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
		System.out.println(applicationContext.getBean("userService"));


2、@Lookup注解


一个抽象类本来是不会创建称为bean的，如果加了@Lookup注解spring会基于cglib生成了一个代理类


@Component
public abstract class UserService {
	
	@Lookup
	public User test() {
		return null;
	}
}

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
		System.out.println(applicationContext.getBean("userService"));


打印结果： 


com.spring.service.UserService$$EnhancerBySpringCGLIB$$d8196300@3cda1055




如果一个单例bean中依赖注入了prototype的bean，那么单例bean只会初始化一次，那么依赖的多例bean通过单例bean访问始终只会有一个，如果使用@Lookup注解就可以重新生成bean对象


// 多例bean
@Component
@Scope("prototype")
public class OrderService {
}

// 单例bean
@Component
public abstract class UserService {

	@Autowired
	private OrderService orderService;

	public void printAutowired() {
		System.out.println("@Autowired=======>"+orderService);
	}
	public void printLookup() {
		System.out.println("@Lookup=======>"+test());
	}

	@Lookup("orderService")
	public OrderService test() {
		return null;
	}
}


// 测试打印
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
		UserService userService = applicationContext.getBean("userService", UserService.class);
		userService.printAutowired();
		userService.printAutowired();
		userService.printAutowired();

		userService.printLookup();
		userService.printLookup();
		userService.printLookup();


打印结果：


@Autowired=======>com.spring.service.OrderService@366e2eef
 @Autowired=======>com.spring.service.OrderService@366e2eef
 @Autowired=======>com.spring.service.OrderService@366e2eef
 @Lookup=======>com.spring.service.OrderService@6df97b55
 @Lookup=======>com.spring.service.OrderService@3cbbc1e0
 @Lookup=======>com.spring.service.OrderService@35fb3008 


3、抽象的BeanDefinition


抽象的BeanDefinition不会实例化生成bean，可以用作公共的BeanDefinition，作为其它Definition的parent，定义一个规范






4、合并BeanDefinition为什么要创建一个新的BeanDefinition？ 


因为任何BeanDefinition都有可能是其它BeanDefinition的parent，所以只能新建一个，不能在原来的BeanDefinition上修改


5、SmartFactoryBean接口


@Component
public class TestFactoryBean implements SmartFactoryBean {

	@Override
	public boolean isEagerInit() {
		return true;
	}

	@Override
	public Object getObject() throws Exception {
		UserService userService = new UserService();

		return userService;
	}

	@Override
	public Class getObjectType() {
		return UserService.class;
	}
}


 SmartFactoryBean继承了FactoryBean，当isEagerInit()返回true时，在创建非懒加载的单例bean的TestFactoryBean时就会调用getObject()方法创建userService对象


6、SmartInitializingSingleton接口


所有非懒加载的单例bean创建完之后，再遍历所有beanNames，通过beanName从单例池中拿出单例bean判断是否实现了SmartInitializingSingleton接口，如果是会调用afterSingletonsInstantiated()方法


@Component
public class UserService implements SmartInitializingSingleton {

	@Override
	public void afterSingletonsInstantiated() {
        // 创建完所有的非懒加载的单例bean时会来调这个方法
		System.out.println("afterSingletonsInstantiated()");
	}
}

























你可能感兴趣的:(spring,spring,java)






    

  • 都2023了还不会Vue3？一篇笔记带你快速入门
Evan-Sky
vue3笔记arcgisvue.jsvueelementui前端

    Vue3简介Vue3是一款用于构建用户界面的JavaScript框架。它基于标准HTML、CSS和JavaScript构建，并提供了一套声明式的、组件化的编程模型，帮助你高效地开发用户界面。无论是简单还是复杂的界面，Vue都可以胜任。快速上手创建一个Vue3项目在vue3中推荐使用pnpm，如果没有安装pnpm，请先用npm全局安装：npminstall-gpnpm首先，我们需要通过Vite创建一
    

    • 

  • (转载)程序员文史综合题目一(附答案)
weixin_34258782
php人工智能python

    一、单选题1，以下谁是二进制思想的最早提出者？a，伏羲；b，姬昌；c，莱布尼茨；d，柏拉图。2，以下哪个概念和公孙龙的《指物论》中的“指”字含义相近？a，变量；b，数组；c，对象；d，指针。3，蔺相如，司马相如；魏无忌，长孙无忌。下列哪一组对应关系与此类似？a，PHP，Python；b，JSP，servlet；c，java，javascript；d，C，C++。4，秦始皇吞并六国采用了以下哪种算法
    

    • 

  • Java语言的9个特质，你知道几个？
小宇java

    Java作为长期编程语言排行榜首位的开发语言，20多年过去了，学习者仍然络绎不绝，本文小编总结了Java的白皮书为我们提出了Java语言的9个关键特质，测测你知道几个吧！(1)Easy：Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb。(2)分布式：Java带有很强大的T
    

    • 

  • Scala Trait(特征)
lly202406
开发语言

    ScalaTrait(特征)Scala中的Trait是一种特殊的概念，它类似于Java中的接口，但提供了更多的功能。Trait允许我们定义一组方法，这些方法可以被子类实现，同时还可以包含方法的实现。这使得Trait既具有接口的灵活性，又具有抽象类的实用性。在本文中，我们将深入探讨ScalaTrait的概念、用法以及它在Scala编程语言中的重要性。什么是ScalaTrait？ScalaTrait是
    

    • 

  • 初学者指南：Spring Boot入门
努力编程的阿伟
springboot后端java

    引言在当今快速发展的软件开发领域，SpringBoot已经成为了构建现代Java应用程序的首选框架之一。它以其简洁、易用和强大的特性，帮助开发者快速搭建起基于Spring的应用程序。如果你是Java开发新手，或者正在寻找一种更高效的开发方式，那么SpringBoot无疑是一个值得学习的技术。SpringBoot是什么？SpringBoot是一个开源的Java框架，由Pivotal团队（现为VMwa
    

    • 

  • 关于springboot对接chatglm3-6b大模型的尝试
橘子在努力
#springcloud#springbootJAVAspringboot后端语言模型

    之前我们通过阿里提供的cloudai对接了通义千问。cloudai对接通义千问那么接下来我们尝试一些别的模型看一下，其实这个文章主要是表达一种对接方式，其他的都大同小异。都可以依此方法进行处理。一、明确模型参数本次我们对接的理论支持来自于阿里云提供的文档。阿里云大3-6b模型文档我们看到他其实支持多种调用方式，包括sdk和http，我本人是不喜欢sdk的，因为会有冲突或者版本之类的问题，不如直接调
    

    • 

  • Maven 快照（SNAPSHOT）
lly202406
开发语言

    Maven快照（SNAPSHOT）1.引言在Java项目开发中，Maven是一个广泛使用的构建工具和依赖管理器。它通过一个中央仓库来管理项目的依赖项，使得开发者可以轻松地添加、更新和删除依赖。在Maven中，快照（SNAPSHOT）是一个特殊的版本标识，用于表示一个正在开发中的版本。本文将详细介绍Maven快照的概念、用途、以及如何使用快照。2.快照的概念在Maven中，每个依赖都有一个唯一的坐标
    

    • 

  • 深入解析Spring Boot中的@ConfigurationProperties注解
需要重新演唱
springbootspringbootjava前端

    深入解析SpringBoot中的@ConfigurationProperties注解在SpringBoot框架中，配置管理是一个核心功能。SpringBoot提供了多种方式来处理外部配置，其中@ConfigurationProperties注解是一个非常强大且灵活的工具。本文将深入探讨@ConfigurationProperties注解的概念、用法、工作原理、配置绑定、类型安全以及如何在实际开发中
    

    • 

  • JAVA高级编程之集合框架和泛型（超详细）
就这个java爽！
开发语言javaeclipseidea青少年编程

    Java集合框架包含的内容Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中Collection接口存储一组不唯一，无序的对象List接口存储一组不唯一，有序（插入顺序）的对象Set接口存储一组唯一，无序的对象Map接口存储一组键值对象，提供key到value的映射List接口的实现类ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机
    

    • 

  • Error: could not open `D:\java8\jre\lib\amd64\jvm.cfg‘
angen2018
javaideajavaintellij-idea

    如果报这个错误把系统环境变量里面的path里面的这两个值移到最前面即可D:\java8\jdk\bin;D:\java8\jdk\jre\bin;如果是在idea里面报错，外面的cmd没有报错，那么就在idea里面单独设置一下即可
    

    • 

  • spring boot中@ConfigurationProperties 与 @Value区别以及用法
psjasf1314
springbootjavaspring

    目录@Value（“”）介绍@configurationProperties@ConfigurationProperties与@Value比较@Value（“”）介绍：@Value（“”）介绍：用来指定bean中某一个属性的值，它的值可以是字面量，从配置文件获取的值，spel表达式例如：@Value("${person.last-name}")privateStringlastName;@Valu
    

    • 

  • Java Socket tcp udp 使用
心之语歌
javatcp/ipudp

    文章目录简绍Socket的基本概念根据传输层协议的不同，Socket主要有两种类型：TCPTCP服务端TCP客户端服务器端:客户端:UDPJava中的UDP编程UDP服务器端UDP客户端服务器端:客户端:简绍Socket"在计算机网络编程中通常指的是用于在网络中的两个程序之间建立通信连接的一种机制。Socket可以让你的应用程序通过网络发送和接收数据。它提供了一种双向通信协议，使得客户端和服务器端
    

    • 

  • 2019-03-21
蜜思1013

    SPA:单页应用https://baike.baidu.com/item/SPA/175363131.场景（1）中后台管理系统（2）H5前端开发（3）跨端APP开发2.技术栈（1）SpringBootvue-cliIDEnpmElementUI（2）vue-cliSPA,npm,建议自己布局写样式（3）uni-app,Flutter,RN,cordova(调用底层API)3.IDE（1）WSVSc
    

    • 

  • Web前端
2301_78085386
前端

    网页开发学习内容:htmlcssJavaScript两个框架:VUE.jsElementUIUI->userinterface用户界面html(HyperTextMarkupLanguage):超文本标记语言文本:文字字符超文本:网页内容标记:标签标识例如商品上的标签,介绍了商品的信息html语言就是一种标记语言,提供许多的标签,不同的标签功能不同,网页就是通过这些标签描述出来的,最终通过浏览器解
    

    • 

  • java 使用zookeeper包实现zookeeper分布式锁
angen2018
javazookeeper分布式java-zookeeperjava

    zookeeper不可重入锁的实现代码importorg.apache.zookeeper.*;importorg.apache.zookeeper.data.Stat;importjava.io.IOException;importjava.util.Collections;importjava.util.List;publicclassDistributedLockExample{privat
    

    • 

  • AOP面向切面编程
ღ᭄ꦿ࿐Never say never꧂
javaspringboot开发语言

    AOP面向切面编程1什么是AOP？AOP是面向切面编程，是SpringFramework的核心子模块；是一种设计思想，在不修改源代码的情况下给程序统一添加额外功能的一种技术。2AOP的作用？代码重用：将一些通用的功能（比如日志记录、安全控制等）抽象出来，形成可重用的模块；简化开发：使开发人员将关注点从业务逻辑中分离出来，使得开发更加简单明了；提高系统可扩展性：在系统需求变化时，只需要修改AOP模块
    

    • 

  • Spring学习笔记——开篇
weixin_30699741

    整体架构Spring核心容器Beans包含访问配置文件，通过Spring容器创建和管理Bean,进行依赖注入和控制反转操作相关所有类。Core包含Spring框架的基本核心工具类，Spring其它组件均需要使用该包，是其它组件的基本核心。Context为Spring核心提供扩展，能够找到使用SpringApplicationContext特性时需要的所有类；JNDI特性时需要的所有类；UI方面模板
    

    • 

  • 关于重构的自问自答
呆子半醒

    作为一个程序员，已记不清第一次听说重构这个概念是什么时候，只记得读下面这本书的时候我还在学习用C语言开发。重构——改善既有代码的设计近几年学习使用Java语言开发，再看时已是这书的译者之一熊节后来单独翻译的一版。作为程序员，无论是C还是Java，无论是在编程演练还是在产品开发中，自以为一直都在践行重构。作为组织的敏捷教练，时常会遇到重构在团队内落地的困难。熊节在知乎上关于重构的回答看了译者的解答，
    

    • 

  • Kotlin第九弹：深入理解 Kotlin 泛型
Ken'
Kotlin从入门到精通kotlin开发语言android

    Kotlin系列到此结束，大家记得关注我哈，后面会继续出关于Android的系列文章!目录前言1.泛型接口2.泛型类二、泛型字段三、泛型方法四、泛型约束五、泛型中的out与in1.out约束泛型参数的类型上限2.in约束参数的类型下限总结前言Kotlin的泛型与Java一样，都是一种语法糖，即只在源代码中有泛型定义，到了class级别就被擦除了。泛型（Generics）其实就是把类型参数化，真正的
    

    • 

  • 一篇文章讲清楚Java中的反射
工业甲酰苯胺
javapython开发语言

    介绍每个类都有一个Class对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的.class文件，该文件内容保存着Class对象。类加载相当于Class对象的加载。类在第一次使用时才动态加载到JVM中，可以使用Class.forName("com.mysql.jdbc.Driver")这种方式来控制类的加载，该方法会返回一个Class对象。反射可以提供运行时的类信息，并且这个类可以在运行
    

    • 

  • 干货拿走：深入解析Kotlin 泛型
Android高级技术
Android高级开发android

    0.引子Kotlin100%与Java兼容，所以抛开语言表面上面的种种特质之外，背后的语言逻辑或者说“灵魂”与Java总是想通的。本文只涉及KotlinJvm，KotlinJs、KotlinNative的具体实现可能有差异。最近一段时间在网上发了一套Kotlin的入门视频，涵盖了基础语法、面向对象、高阶函数、DSL、协程等比较有特色的知识点，不过有朋友提出了疑问：这门课为什么不专门讲讲泛型、反射和
    

    • 

  • My Batis框架初级知识
Faye_xue
web网站笔记mavenmybatisjava数据库mysql

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档目录一、Mybatis概述1、概念2、持久层3、JavaEE三层架构：4、框架二、JDBC缺点编辑1、硬编码2、SQL语句3、操作繁琐三、使用步骤1.创建表2.创建模块，导入坐标在创建好的模块中的pom.xml配置文件中添加依赖的坐标3、添加配置文件1）将logback.xml、mybatis-config.xml配置到项目的reso
    

    • 

  • Java设计模式【组合模式】-结构型
lianyinghhh
Javajava设计模式组合模式

    1.介绍组合模式（CompositePattern）是一种结构型设计模式，用于将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端可以一致地处理单个对象和对象的组合，客户端无需关心它们是单个对象还是组合对象。组合模式通过递归的方式将对象组合成更复杂的结构，典型应用是树形结构。在组合模式中，通常有三种角色：组件（Component）：定义对象的接口，可以组合叶子节点和组合节点。叶子
    

    • 

  • 力扣刷题122. 买卖股票的最佳时机 II(java)
happytaohaha

    题目：给定一个数组，它的第i个元素是一支给定股票第i天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。示例1:输入:[7,1,5,3,6,4]输出:7解释:在第2天（股票价格=1）的时候买入，在第3天（股票价格=5）的时候卖出,这笔交易所能获得利润=5-1=4。随后，在第4天（股票
    

    • 

  • 力扣134-加油站（java题解）
立志成为coding大牛的菜鸟.
leetcodejava算法

    题目链接：134.加油站-力扣（LeetCode）前情提要：因为本人最近都来刷贪心类的题目所以该题就默认用贪心方法来做。贪心方法：局部最优推出全局最优。如果一个题你觉得可以用局部最优推出全局最优，并且没有反例来反驳的话就可以用贪心来试试。题目思路：该题入手，你可能知道，当总容量减去总消耗量大于等于0，那么该路程一定是可以环路行驶一周的，但是怎么确认出发的加油站编号呢？我们用贪心的思路来想想。将每个
    

    • 

  • 【java中static最全解析】（static概念，内存原理，为什么要使用static修饰符）
立志成为coding大牛的菜鸟.
java学习之路java开发语言

    【java中static最全解析】（static概念，内存原理，为什么要使用static修饰符）一、static的概念（什么是static）static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量1.1静态变量被static修饰的变量特点：可以被该类所有的对象所共享不属于对象，属于类随着类的加载而加载，优先于对象存在调用方式：类名调用（通常用这个）方法名调用在这里我定义了一个st
    

    • 

  • jdk动态代理与cglib动态代理：
爱为斯坦
JAVAjava开发语言动态代理

    最近在用java实现redis，在使用动态代理时遇到了一点问题，即使用jdk动态代理（Invocationhandler）时，如果代理对象是一个接口的实现类，那么此时动态代理获取到的method对象是接口中的，而不是实现类的，现象是：我在实现类中对接口方法上新增了注解，但是此刻method反射获取不到注解信息，于是大概整理了一下这两者的区别JDK动态代理：获取的是接口中的方法信息，因此如果注解是在
    

    • 

  • java 单利模式
sparkzyq

    publicclassSingletion{privatestaticclassInnerSingletion{privatestaticSingletionsingle=newSingletion();}publicstaticSingletiongetInstance(){returnInnerSingletion.single;}}
    

    • 

  • 力扣45-跳跃游戏II （java详细题解）
立志成为coding大牛的菜鸟.
重生之我在lc刷算法leetcodejava算法

    题目链接：45.跳跃游戏II-力扣（LeetCode）前情提要：建议大家在做本题前先将力扣55-跳跃游戏先做了，具体题解在这力扣55-跳跃游戏（java详细题解）-CSDN博客。因为本人最近都来刷贪心类的题目所以该题就默认用贪心方法来做。贪心方法：局部最优推出全局最优。如果一个题你觉得可以用局部最优推出全局最优，并且没有反例来反驳的话就可以用贪心来试试。题目思路：本题相对于力扣45要难上不少，因为
    

    • 

  • java设计模式（六）代理模式（Proxy Pattern）
FM_南风
java设计模式java设计模式代理模式

    1、模式介绍：代理模式（ProxyPattern）是一种结构型设计模式，它允许你在不改变客户端代码的情况下，向某个对象提供一个代理，以控制对该对象的访问。代理对象通常会在实际对象的方法调用前后添加一些附加逻辑，如权限控制、懒加载、日志记录等。代理模式涉及以下几个角色：接口（Subject）：定义了代理类和真实类共同的接口。真实类（RealSubject）：实现了接口的具体类，它是真正执行操作的对象
    

    • 

  • [黑洞与暗粒子]没有光的世界
comsci

         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界....
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的
&nbs
    

    • 

  • jQuery Lazy Load 图片延迟加载
aijuans
jquery

    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。
版本：
jQuery v1.4.4+
jQuery Lazy Load v1.7.2
注意事项：
需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    

    • 

  • 使用Jodd的优点
Kai_Ge
jodd

    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。
 
使用方法简介
    

    • 

  • jpa Query转hibernate Query
120153216
Hibernate

    public List<Map> getMapList(String hql,
Map map) {
org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
if (null != map) {
for (String parameter : map.keySet()) {
jp
    

    • 

  • Django_Python3添加MySQL/MariaDB支持
2002wmj
mariaDB

    现状
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案
首先据MySQL文档[3]说，自从MySQL
    

    • 

  • 在SQLSERVER中查找消耗IO最多的SQL
357029540
SQL Server

    返回做IO数目最多的50条语句以及它们的执行计划。
select top 50  
(total_logical_reads/execution_count) as avg_logical_reads, 
(total_logical_writes/execution_count) as avg_logical_writes, 
(tot
    

    • 

  • spring UnChecked 异常 官方定义！
7454103
spring

      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！
public static boolean isCheckedException(Throwable ex)
{
return !(ex instanceof RuntimeExcep
    

    • 

  • mongoDB 入门指南、示例
adminjun
javamongodb操作

    一、准备工作
1、 下载mongoDB
下载地址：http://www.mongodb.org/downloads
选择合适你的版本
相关文档：http://www.mongodb.org/display/DOCS/Tutorial
2、 安装mongoDB
A、 不解压模式：
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    

    • 

  • CUDA 5 Release Candidate Now Available
aijuans
CUDA

    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    

    • 

  • Essential Studio for WinRT网格控件测评
Axiba
JavaScripthtml5

    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。
网格控件功能
1、
    

    • 

  • java 获取windows系统安装的证书或证书链
bewithme
windows

     
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。
有关证书链的解释可以查看此处 。
 
public static void main(String[] args) {
SunMSCAPI providerMSCAPI = new SunMSCAPI();
S
    

    • 

  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
bijian1013
redis数据库NoSQL

    4.sets类型
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。
        sadd：向名称为key的set中添加元
    

    • 

  • 异常捕获何时用Exception，何时用Throwable
bingyingao

    用Exception的情况
try {
       //可能发生空指针、数组溢出等异常
        } catch (Exception e) {
         
    

    • 

  • 【Kafka四】Kakfa伪分布式安装
bit1129
kafka

    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤
 
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    

    • 

  • Project Euler
bookjovi
haskell

    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。
    看看problem 1吧：
Add all the natural num
    

    • 

  • Java-Collections Framework学习与总结-ArrayDeque
BrokenDreams
Collections

            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。
        这篇要看一下java.util.ArrayDeque。从命名上看
    

    • 

  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    

    • 

  • Maven学习(一)
chenyu19891124
Maven私服

        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    

    • 

  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
comsci
算法工作PHP搜索引擎嵌入式

    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点
节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法)
需要解决的问题：已知分支
    

    • 

  • Linux中用shell获取昨天、明天或多天前的日期
daizj
linuxshell上几年昨天获取上几个月

    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年
# 获取昨天
date -d 'yesterday'  # 或 date -d 'last day'
# 获取明天
date -d 'tomorrow'   # 或 date -d 'next day'
# 获取上个月
date -d 'last month'
# 
    

    • 

  • 我所理解的云计算
dongwei_6688
云计算

          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说：
       Cloud computing is a phrase used to describe a variety of computing co
    

    • 

  • YII CMenu配置
dcj3sjt126com
yii

    Adding id and class names to CMenu
We use the id and htmlOptions to accomplish this. Watch.
//in your view
$this->widget('zii.widgets.CMenu', array(
'id'=>'myMenu',
'items'=>$this-&g
    

    • 

  • 设计模式之静态代理与动态代理
come_for_dream
设计模式

    静态代理与动态代理
       代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    

    • 

  • 【转】理解Javascript 系列
gcc2ge
JavaScript

    理解Javascript_13_执行模型详解
摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    

    • 

  • Subsets II
hcx2013
set

    Given a collection of integers that might contain duplicates, nums, return all possible subsets.
Note:
Elements in a subset must be in non-descending order.
The solution set must not conta
    

    • 

  • Spring4.1新特性——Spring缓存框架增强
jinnianshilongnian
spring4

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • shell嵌套expect执行命令
liyonghui160com

     
 
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧.
  系统:centos 5.x
 
1.先安装expect
yum -y install expect
 
2.脚本内容:
cat auto_svn.sh
 
#!/bin/bash

    

    • 

  • Linux实用命令整理
pda158
linux

    0. 基本命令 　　linux 基本命令整理 　
　1. 压缩 解压 　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz 　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a 　
　2. vim小结 　　2.1 vim替换 　　:m,ns/word_1/word_2/gc  
    

    • 

  • 独立开发人员通向成功的29个小贴士
shoothao
独立开发

    
概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。
明白你从事独立开发的原因和目的。
保持坚持制定计划的好习惯。
万事开头难，第一份订单是关键。
培养多元化业务技能。
提供卓越的服务和品质。
谨小慎微。
营销是必备技能。
学会组织，有条理的工作才是最有效率的。
“独立
    

    • 

  • JAVA中堆栈和内存分配原理
uule
java

    1、栈、堆
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    

    •