简书徐小耳
简书徐小耳

源码分析：doCreateBean

spring的ioc创建bean的最核心代码 我们来看看他具体做了啥 怎么做

整体的逻辑

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

    BeanWrapper ，包含了真正的bean对象和bean的class，以及PropertyDescriptor集合
        BeanWrapper instanceWrapper = null;
单例的情况下尝试从factoryBeanInstanceCache获取 instanceWrapper 
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
如果没有则需要自己创建
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class beanType = instanceWrapper.getWrappedClass();
如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

    这边主要是寻找几个meta，@PostConstruct,@Autowire,@Value,@Resource，@PreDestory等
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

如果当前bean是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，
这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean，getEarlyBeanReference可以对返回的bean进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        
        Object exposedObject = bean;
        try {
填充bean的属性
            populateBean(beanName, mbd, instanceWrapper);
初始化bean
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }
如果earlySingletonExposure，尝试从缓存获取该bean（一般存放在singletonFactories对象通过调用getObject 把对象存入earlySingletonObjects），分别从singletonObjects和earlySingletonObjects获取对象
        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
如果获取到对象了
            if (earlySingletonReference != null) {
当exposedObject （初始化之后的bean等于原始的bean，说明不是proxy），则把缓存中的bean赋值给exposedObject 
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
检测该bean的dependon的bean是否都已经初始化好了
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName,
                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                "] in its raw version as part of a circular reference, but has eventually been " +
                                "wrapped. This means that said other beans do not use the final version of the " +
                                "bean. This is often the result of over-eager type matching - consider using " +
                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        
        try {
注册DisposableBean
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

createBeanInstance的源码分析

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    获取beanclass
        Class beanClass = resolveBeanClass(mbd, beanName);
如果beanclass为空，且beanclass不是public 且没有权限访问构造函数和方法则抛出异常
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
Supplier类似于factoryBean，然后从Supplier.get()的bean，并把bean包装成BeanWrapper，然后初始化BeanWrapper
        Supplier instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
尝试从factoryMethod获取instanceSupplier
        if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        这边是相当于检测是否曾经创建过这个bean，如果是查看下具体采用哪个方法
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
说明曾经解析过构造函数或者factoryMethod
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
如果autowireNecessary为true说明是采用构造函数注入
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
如果已经解析过了则按照逻辑选择
        if (resolved) {
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

    说明是第一次创建该bean   根据SmartInstantiationAwareBeanPostProcessor获取构造函数，目前看基本上都是空的实现，除了AutowiredAnnotationBeanPostProcessor
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
开始生成实例
            return autowireConstructor(beanName, mbd, ctors, args);
        }

采用普通的方式生成实例
        return instantiateBean(beanName, mbd);
    }
AutowiredAnnotationBeanPostProcessor的determineCandidateConstructors

寻找被@Autowired的构造函数，如果没有就返回null


我们的lookup就是在这边通过反射发现的（其他的xml形式的replace-method和lookup在BeanDefinitionParserDelegate中）
        if (!this.lookupMethodsChecked.contains(beanName)) {
            try {
                ReflectionUtils.doWithMethods(beanClass, method -> {
                    Lookup lookup = method.getAnnotation(Lookup.class);
                    if (lookup != null) {
                        Assert.state(beanFactory != null, "No BeanFactory available");
                        LookupOverride override = new LookupOverride(method, lookup.value());
                        try {
                            RootBeanDefinition mbd = (RootBeanDefinition) beanFactory.getMergedBeanDefinition(beanName);
                            mbd.getMethodOverrides().addOverride(override);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(beanName,
                                "Cannot apply @Lookup to beans without corresponding bean definition");
                        }
                    }
                });
            }
            catch (IllegalStateException ex) {
                throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
            }
            this.lookupMethodsChecked.add(beanName);
        }

    检测缓存中是否已经存在对应的构造函数
        Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
        if (candidateConstructors == null) {
            双重检测
            synchronized (this.candidateConstructorsCache) {
                candidateConstructors = this.candidateConstructorsCache.get(beanClass);
                if (candidateConstructors == null) {
                    Constructor[] rawCandidates;
                    try {
获取声明的构造函数
                        rawCandidates = beanClass.getDeclaredConstructors();
                    }
                    catch (Throwable ex) {
                        throw new BeanCreationException(beanName,
                                "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                                "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
                    }
                    List> candidates = new ArrayList<>(rawCandidates.length);
                    Constructor requiredConstructor = null;
                    Constructor defaultConstructor = null;
这个只对Kotlin有用 对于java 一般默认的返回null
                    Constructor primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
                    int nonSyntheticConstructors = 0;
                    for (Constructor candidate : rawCandidates) {
如果不是合成，则nonSyntheticConstructors加1
                        if (!candidate.isSynthetic()) {
                            nonSyntheticConstructors++;
                        }
                        else if (primaryConstructor != null) {
                            continue;
                        }
                        AnnotationAttributes ann = 
寻找构造上是否存在@Autowired，@Value，@Inject，如果存在就返回required=true，一个bean的构造函数如果超过一个@Autowired就抛出异常
findAutowiredAnnotation(candidate);
如果没有
                        if (ann == null) {
一般都是返回class本身，如果是cglib就返回原始的类
                            Class userClass = ClassUtils.getUserClass(beanClass);
                            if (userClass != beanClass) {
                                try {
获取带有参数的构造函数
                                    Constructor superCtor =
                                            userClass.getDeclaredConstructor(candidate.getParameterTypes());
继续寻找是否携带了上面三个注解
                                    ann = findAutowiredAnnotation(superCtor);
                                }
                                catch (NoSuchMethodException ex) {
                                    // Simply proceed, no equivalent superclass constructor found...
                                }
                            }
                        }
ann！=null 代表找到了
                        if (ann != null) {
如果requiredConstructor  不为null 说明重复定义
                            if (requiredConstructor != null) {
                                throw new BeanCreationException(beanName,
                                        "Invalid autowire-marked constructor: " + candidate +
                                        ". Found constructor with 'required' Autowired annotation already: " +
                                        requiredConstructor);
                            }
这边只是确认下required返回的是true还是false
                            boolean required = determineRequiredStatus(ann);
如果required是true
                            if (required) {
但是candidates不为空说明重复了
                                if (!candidates.isEmpty()) {
                                    throw new BeanCreationException(beanName,
                                            "Invalid autowire-marked constructors: " + candidates +
                                            ". Found constructor with 'required' Autowired annotation: " +
                                            candidate);
                                }
                                requiredConstructor = candidate;
                            }
                            candidates.add(candidate);
                        }
                        else if (candidate.getParameterCount() == 0) {
                            defaultConstructor = candidate;
                        }
                    }
                    if (!candidates.isEmpty()) {
                        // Add default constructor to list of optional constructors, as fallback.
                        if (requiredConstructor == null) {
                            if (defaultConstructor != null) {
                                candidates.add(defaultConstructor);
                            }
                            else if (candidates.size() == 1 && logger.isWarnEnabled()) {
                                logger.warn("Inconsistent constructor declaration on bean with name '" + beanName +
                                        "': single autowire-marked constructor flagged as optional - " +
                                        "this constructor is effectively required since there is no " +
                                        "default constructor to fall back to: " + candidates.get(0));
                            }
                        }
                        candidateConstructors = candidates.toArray(new Constructor[0]);
                    }
                    else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
                        candidateConstructors = new Constructor[] {rawCandidates[0]};
                    }
                    else if (nonSyntheticConstructors == 2 && primaryConstructor != null
                            && defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
                        candidateConstructors = new Constructor[] {primaryConstructor, defaultConstructor};
                    }
                    else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
                        candidateConstructors = new Constructor[] {primaryConstructor};
                    }
                    else {
                        candidateConstructors = new Constructor[0];
                    }
                    this.candidateConstructorsCache.put(beanClass, candidateConstructors);
                }
            }
        }
        return (candidateConstructors.length > 0 ? candidateConstructors : null);
initBeanWrapper
初始BeanWrapperImpl，设置ConversionService
（可以查看每个类型是否可以转换成其他类型，并提供转换的方法）和注册
一些列的ResourceEditor到bw，比如    doRegisterEditor(registry, 
Resource.class, baseEditor);如果遇到Resource类型的使用baseEditor，进
行编辑。
protected void initBeanWrapper(BeanWrapper bw) {
        bw.setConversionService(getConversionService());
        registerCustomEditors(bw);
    }

    protected void registerCustomEditors(PropertyEditorRegistry registry) {
        PropertyEditorRegistrySupport registrySupport =
                (registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
        if (registrySupport != null) {
            registrySupport.useConfigValueEditors();
        }
        if (!this.propertyEditorRegistrars.isEmpty()) {
            for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
                try {
                    registrar.registerCustomEditors(registry);
                }
                catch (BeanCreationException ex) {
                    Throwable rootCause = ex.getMostSpecificCause();
                    if (rootCause instanceof BeanCurrentlyInCreationException) {
                        BeanCreationException bce = (BeanCreationException) rootCause;
                        String bceBeanName = bce.getBeanName();
                        if (bceBeanName != null && isCurrentlyInCreation(bceBeanName)) {
                            if (logger.isDebugEnabled()) {
                                logger.debug("PropertyEditorRegistrar [" + registrar.getClass().getName() +
                                        "] failed because it tried to obtain currently created bean '" +
                                        ex.getBeanName() + "': " + ex.getMessage());
                            }
                            onSuppressedException(ex);
                            continue;
                        }
                    }
                    throw ex;
                }
            }
        }
如果存在用户自定义的类型转换 也设置
        if (!this.customEditors.isEmpty()) {
            this.customEditors.forEach((requiredType, editorClass) ->
                    registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass)));
        }
    }
MergedBeanDefinitionPostProcessors---AutowiredAnnotationBeanPostProcessor
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
获取@Autowired注解的属性
        InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
校验
        metadata.checkConfigMembers(beanDefinition);
    }


private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) {
    获取cacheKey
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());

        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
如果metadata为空，或者clazz！=metadata.targetClass则说明没有缓存无效，重新buildAutowiringMetadata，然后把结果缓存起来
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
分别从class的field和method获取@Autowired，并放入缓存（会迭代查询其父类class）
                    metadata = buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }





public void checkConfigMembers(RootBeanDefinition beanDefinition) {
        Set checkedElements = new LinkedHashSet<>(this.injectedElements.size());
        for (InjectedElement element : this.injectedElements) {
把method或者field放入externallyManagedConfigMembers缓存中
            Member member = element.getMember();
            if (!beanDefinition.isExternallyManagedConfigMember(member)) {
                beanDefinition.registerExternallyManagedConfigMember(member);
                checkedElements.add(element);
                if (logger.isDebugEnabled()) {
                    logger.debug("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
                }
            }
        }
        this.checkedElements = checkedElements;
    }
填充属性-populateBean--先对于unsatisfiedNonSimpleProperties（未在xml配置该property 该property是一个特殊的对象（普通的javabean的类））属性进行处理，在对一些注解注入的属性处理，最终对自动注入的属性（即包含set方法的）属性进行处理
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
如果实力为空但是还有属性，抛出异常
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
        直接返回
                return;
            }
        }

    
        boolean continueWithPropertyPopulation = true;
这边主要是根据InstantiationAwareBeanPostProcessor 判断是否继续给该bean配置属性
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }

        if (!continueWithPropertyPopulation) {
            return;
        }
设置PropertyValues 
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
如果该bean是支持按照名字或者类型自动注入的，
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
深度拷贝PropertyValues，当然对于对象来说只能公用一个
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

    按照名称开始注入（这边不是真正的注入，只是寻找可注入的bean）
必须有set方法
必须不能是忽略的类型或者接口
spring配置的properties中没有改属性
该属性不能是 a primitive, an enum, a String or other CharSequence, a Number, a Date,
     * a URI, a URL, a Locale or a Class.
     其中primitive（ boolean, byte,
     * char, short, int, long, float, or double）或者其包装类
     如果class是array 其元素也不能是上述属性
     -------
     
     也就是说自动注入的时候 如果不显示的配置 对于非对象的类型是不会注入的，但是对于对象是会主动去寻找的
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

按照类型开始注入（这边不是真正的注入，只是寻找可注入的bean）
必须有set方法
必须不能是忽略的类型或者接口
spring配置的properties中没有改属性
该属性不能是 a primitive, an enum, a String or other CharSequence, a Number, a Date,
     * a URI, a URL, a Locale or a Class.
     其中primitive（ boolean, byte,
     * char, short, int, long, float, or double）或者其包装类
     如果class是array 其元素也不能是上述属性
     -------
     
     也就是说自动注入的时候 如果不显示的配置 对于非对象的类型是不会注入的，但是对于对象是会主动去寻找的
            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);
如果存在InstantiationAwareBeanPostProcessors或者有依赖检测
        if (hasInstAwareBpps || needsDepCheck) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
获得一组PropertyDescriptor，filterPropertyDescriptorsForDependencyCheck
---获取该bean下面的所有属性和方法
---删除如果是cglib的本身的属性和方法
---删除如果是ignoredDependencyTypes
---删除如果是set方法且需要忽略的（即实现了xxawared接口的)也需要删除
---最终保留的属性可以自动注入
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
对@Autowired,@Resource等属性的注入
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
依赖检测
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }
对自动注入的时候 set方法的注入
        if (pvs != null) {
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }
初始化bean-initializeBean

第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作

第二种是：通过 在xml中定义init-method 和 destory-method方法

第三种是： 通过bean实现InitializingBean和 DisposableBean接口
三种销毁方式都是把bean转换成DisposableBean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
首先调用回调方法xxxaware
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }
调用spring的扩展点 在初始化之前调用
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
先调用InitializingBean的afterPropertiesSet，在调用我们定义的init方法
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
调用spring的扩展点 在初始化之后调用，注意这边就是生成我们配置的动态代理对象的关键代码
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }


注册registerDisposableBeanIfNecessary


protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
只有非原型且是DisposableBean，或者有destroy method  或者注册了 DestructionAwareBeanPostProcessors.
最终在缓存中存放beanName和DisposableBean的映射关系，然后注册钩子的时候调用
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
针对单例或者scope注册
            if (mbd.isSingleton()) {
    最终在缓存中存放beanName和DisposableBean的映射关系，然后注册钩子的时候调用
                registerDisposableBean(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
            else {
                // A bean with a custom scope...
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
注册了一个回调，根据scope的类型（比如是一个线程，一个request，servlet，事务）当这几种结束的时候回调这个DisposableBeanAdapter的destory方法
                scope.registerDestructionCallback(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }


























你可能感兴趣的:(源码分析：doCreateBean)






    

  • JVM源码分析之堆外内存完全解读
HeapDump性能社区

    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    

    • 

  • Golang Channel
PandaSkr
golang

    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
"小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为

    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    

    • 

  • Java高并发编程详解系列-深入理解Thread构造
nihui123
高并发Java高并发Java高并发

    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    

    • 

  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程

    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    

    • 

  • Jetpack LiveData源码分析
xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析

    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    

    • 

  • ExoPlayer架构详解与源码分析（17）——TrackSelector
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（12）——Cache
山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码

    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    

    • 

  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
2401_83740189
程序员架构

    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    

    • 

  • 【HarmonyOS】- 常见算法简单写法
数的羊都睡了
HarmonyOSArkTS鸿蒙

    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    

    • 

  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
nangonghen
dockerdocker

    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    

    • 

  • dispatch_once源码分析
福伟_Y

    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    

    • 

  • jQuery Easyui 源码分析之combo组件
90后北京程序员
前端-easyuieasyui之combobox

    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    

    • 

  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
RemusrickCat

    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    

    • 

  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
Colourful．
Java集合java集合

    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    

    • 

  • React Native通讯原理
zbl_zbl
androidReactNativ

    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    

    • 

  • [linux 驱动]增加一个文件节点控制led灯亮灭
嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动

    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    

    • 

  • 【QT教程】QT6对话框编程
QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程

    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
    

    • 

  • 鸿蒙轻内核M核源码分析系列十二 事件Event
OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发

    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    

    • 

  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核

    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    

    • 

  • 鸿蒙轻内核M核源码分析系列五 时间管理
OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式

    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    

    • 

  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件

    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    

    • 

  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件

    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    

    • 

  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2)
OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信

    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
    

    • 

  • 鸿蒙原生开发——轻内核A核源码分析系列三 物理内存（2）
OpenHarmony_小贾
鸿蒙开发HarmonyOSOpenHarmonyharmonyosopenharmony移动开发程序人生鸿蒙开发

    3.1.2.3函数OsVmPhysLargeAlloc当执行到这个函数时，说明空闲链表上的单个内存页节点的大小已经不能满足要求，超过了第9个链表上的内存页节点的大小了。⑴处计算需要申请的内存大小。⑵从最大的链表上进行遍历每一个内存页节点。⑶根据每个内存页的开始内存地址，计算需要的内存的结束地址，如果超过内存段的大小，则继续遍历下一个内存页节点。⑷处此时paStart表示当前内存页的结束地址，接下来
    

    • 

  • JsonCpp源码分析——Reader
哎呦，帅小伙哦
#jsoncppjson

    1、与Writer模块功能相反，可以将Reader理解成一个反序列化的工具，Writer的作用主要是将Value对象转成string或者流式的结构，Reader的作用主要是将流式的结构转成Value类型的对象。Reader类的主要职责有3个，解析JSON字符串：将JSON格式的字符串读取并解析成相应的C++数据结构。处理不同的数据类型，支持解析JSON对象、数组、字符串、数字、布尔值和null。处
    

    • 

  • vue源码分析-挂载流程和模板编译
yyzzabc123
vue.js

    前面几节我们从newVue创建实例开始，介绍了创建实例时执行初始化流程中的重要两步，配置选项的资源合并,以及响应式系统的核心思想，数据代理。在合并章节，我们对Vue丰富的选项合并策略有了基本的认知，在数据代理章节我们又对代理拦截的意义和使用场景有了深入的认识。按照Vue源码的设计思路，初始化过程还会进行很多操作，例如组件之间创建关联，初始化事件中心，初始化数据并建立响应式系统等，并最终将模板和数据
    

    • 

  • 鸿蒙内核解析,鸿蒙内核源码分析(内存概念篇)|解读鸿蒙源码
刘轩鸿
鸿蒙内核解析

    提示：本文基于开源鸿蒙内核分析，官方源码【kernel_liteos_a】官方文档【docs】参考文档【HuaweiLiteOS】本文作者：鸿蒙内核发烧友，用生活场景讲故事的方式去解构内核，一窥究竟，让神秘的内核栩栩如生，浮现眼前。博文全部原创，持续更新，敬请关注。内容仅代表个人观点，错误之处，欢迎大家指正完善。本系列全部文章进入鸿蒙源码分析(总目录)查看目录最难讲的章节坦白讲内存是整个系列里面最
    

    • 

  • 鸿蒙轻内核A核源码分析系列七 进程管理 (3)
OpenHarmony_小贾
OpenHarmony鸿蒙开发HarmonyOSharmonyos嵌入式硬件OpenHarmony鸿蒙嵌入式鸿蒙开发鸿蒙内核进程关联

    本文记录下进程相关的初始化函数，如OsSystemProcessCreate、OsProcessInit、OsProcessCreateInit、OsUserInitProcess、OsDeInitPCB、OsUserInitProcessStart等。1、LiteOS-A内核进程创建初始化通用函数先看看一些内部函数，不管是初始化用户态进程还是内核态进程，都会使用这些函数，包含进程控制块初始化函数
    

    • 

  • 多线程编程之理财
周凡杨
java多线程生产者消费者理财

          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    

    • 

  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
bit1129
zookeeper

    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容
Created /zoo-739160015
CONNECTEDCONNECTED
.............CONNECTEDCONNECTED
CONNECTEDCLOSEDCLOSED

    

    • 

  • SecureCRT快捷键
daizj
secureCRT快捷键

    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    

    • 

  • Java 子类与父类这间的转换
周凡杨
java 父类与子类的转换

        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。
 
    代码：
            
    

    • 

  • 可视化swing界面编辑
朱辉辉33
eclipseswing

          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    

    • 

  • web报表工具FineReport常用函数的用法总结（文本函数）
老A不折腾
finereportweb报表工具报表软件java报表

    文本函数
CHAR
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。
示例:
CHAR(88)等于“X”。
CHAR(45)等于“-”。
 
CODE
CODE(text):计算文本串中第一个字
    

    • 

  • mysql安装出错
林鹤霄
mysql安装

    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    

    • 

  • linux下编译libuv
aigo
libuv

    下载最新版本的libuv源码，解压后执行：
./autogen.sh
 
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）：
# yum -y install automake
# yum -y install libtool
 
 
如果提示错误：make: *** No targe
    

    • 

  • 中国行政区数据及三级联动菜单
alxw4616

    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的!
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上.
哎,自己没办法动手写吧.
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用
  文件说明
lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    

    • 

  • 哈夫曼加密文件
百合不是茶
哈夫曼压缩哈夫曼加密二叉树

     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤;
 
加密步骤:
 1,统计文件中字节出现的次数,作为权值
 
2,创建节点和哈夫曼树
 
3,得到每个子节点01串
 
4,使用哈夫曼编码表示每个字节
 

    

    • 

  • JDK1.5 Cyclicbarrier实例
bijian1013
javathreadjava多线程Cyclicbarrier

    CyclicBarrier类
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。
CyclicBarrier支持一个可选的 Runnable 命令，
    

    • 

  • 九项重要的职业规划
bijian1013
工作学习

    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    

    • 

  • 【Java范型四】范型方法
bit1129
java

    范型参数不仅仅可以用于类型的声明上，例如
 
package com.tom.lang.generics;
import java.util.List;
public class Generics<T> {
private T value;
public Generics(T value) {
this.value = 
    

    • 

  • 【Hadoop十三】HDFS Java API基本操作
bit1129
hadoop

     
package com.examples.hadoop;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    

    • 

  • ua实现split字符串分隔
ronin47
lua split

    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    

    • 

  • java-从先序遍历和中序遍历重建二叉树
bylijinnan
java

    
public class BuildTreePreOrderInOrder {
/**
* Build Binary Tree from PreOrder and InOrder
* _______7______
/ \
__10__ ___2
/ \ /
4
    

    • 

  • openfire开发指南《连接和登陆》
开窍的石头
openfire开发指南smack

    第一步
    官网下载smack.jar包
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack
第二步
    把smack里边的jar导入你新建的java项目中
开始编写smack连接openfire代码
p
    

    • 

  • [移动通讯]手机后盖应该按需要能够随时开启
comsci
移动

        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎
     但是，对于手机的新设计，有几点我们也要注意
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    

    • 

  • 20款国外知名的php开源cms系统
cuiyadll
cms

    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。
1. Wordpress
WordPress的是一个功能强大且易于使用的内容管
    

    • 

  • Java生成全局唯一标识符
darrenzhu
javauuiduniqueidentifierid

    How to generate a globally unique identifier in Java
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log
http://stackoverflow
    

    • 

  • php安装模块检测是否已安装过, 使用的SQL语句
dcj3sjt126com
sql

    
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern']
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    

    • 

  • 5天学会一种 web 开发框架
dcj3sjt126com
Web框架framework

    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路
建议把本文
    

    • 

  • Gson使用三(Map集合的处理,一对多处理)
eksliang
jsongsonGson mapGson 集合处理

    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例
package com.ickes.json;
import java.lang.refl
    

    • 

  • cordova实现“再点击一次退出”效果
gundumw100
android

    基本的写法如下：
document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
//navigator.splashscreen.hide();
document.addEventListener("b
    

    • 

  • openldap configuration leaning note
iwindyforest
configuration

    hostname // to display the computer name
hostname <changed name> // to change
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately
dont forget to change /etc/hosts
    

    • 

  • Nullability and Objective-C
啸笑天
Objective-C

    https://developer.apple.com/swift/blog/?id=25
 
http://www.cocoachina.com/ios/20150601/11989.html
 
http://blog.csdn.net/zhangao0086/article/details/44409913
 
http://blog.sunnyxx
    

    • 

  • jsp中实现参数隐藏的两种方法
macroli
JavaScriptjsp

    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    

    • 

  • Bootstrap A标签关闭modal并打开新的链接解决方案
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象

    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。
 
<a href="#/group-buy" class="btn bt
    

    • 

  • 二维数组在Java和C中的区别
流淚的芥末
javac二维数组数组

    Java代码：
 
public class test03 {
public static void main(String[] args) {
int[][] a = {{1},{2,3},{4,5,6}};
System.out.println(a[0][1]);
}
}
 运行结果：
Exception in thread "mai
    

    • 

  • systemctl命令用法
wmlJava
linuxsystemctl

    对比表，以 apache / httpd 为例 任务 旧指令 新指令 使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h
    

    •