会上树的程序猿
会上树的程序猿

spring容器之bean加载策略之构造函数注入模式

在上节spring容器之创建bean实例中我们看了# createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)完成了bean的初始化,虽然那个方法有点长,但我们最后总结发现,spring是通过不同的策略模式来完成bean的初始化如:

  • 通过回调#obtainFromSupplier(final String beanName, final RootBeanDefinition mbd) 方法来初始化
  • 通过工厂方法的方式:#instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs)
  • 还有一种就是通过构造函数自动注入的方式:#autowireConstructor(final String beanName, final RootBeanDefinition mbd, Constructor[] chosenCtors, final Object[] explicitArgs)来实现bean的初始化
  • 最后一种是默认构造函数的方式:#instantiateBean(final String beanName, final RootBeanDefinition mbd)的方法来实现bean的初始化工作

关于前面的两种我们已经说了,这里就不在重复了,我们来看后两种:

通过构造函数自动注入的方式
AbstractAutowireCapableBeanFactory.java
protected BeanWrapper autowireConstructor(
        String beanName, RootBeanDefinition mbd, @Nullable Constructor[] ctors, @Nullable Object[] explicitArgs) {

    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}



public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
        @Nullable Constructor[] chosenCtors, @Nullable Object[] explicitArgs) {
    //准备一个BeanWrapperImpl用于bean实例的封装
    BeanWrapperImpl bw = new BeanWrapperImpl();
    //初始化bw
    this.beanFactory.initBeanWrapper(bw);
    //1.获取constructorToUse argsHolderToUse和argsToUse参数
    Constructor constructorToUse = null;//所使用的的构造函数
    ArgumentsHolder argsHolderToUse = null;//构造参数
    Object[] argsToUse = null;
    //2.通过explicitArgs参数来决定实例化bean所使用的构造函数及构造参数
    //explicitArgs为通过getBean传入的,如果在调用的过程中指定构造函数和参数那么直接使用
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    }
    //2.1.这里表示没有指定那么会从配置文件中去解析获取
    else {
        Object[] argsToResolve = null;
        synchronized (mbd.constructorArgumentLock) {
            //尝试着从缓存中获取工厂方法或者构造函数
            constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                // Found a cached constructor...
                //从缓存中获取构造参数
                argsToUse = mbd.resolvedConstructorArguments;
                if (argsToUse == null) {
                    //从缓存中没获取到,则从原先准备的构造参数缓存中获取
                    argsToResolve = mbd.preparedConstructorArguments;
                }
            }
        }
        //2.2.如果缓存中
        //解析保存在beanDefinition中的参数
        //如给定方法的构造函数 A(int ,int )，则通过此方法后就会把配置文件中的("1","1")转换为 (1,1)
        //缓存中的值可能是原始值也有可能是最终值
        if (argsToResolve != null) {
            argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
        }
    }
    //2.3.没有被缓存
    if (constructorToUse == null || argsToUse == null) {
        // Take specified constructors, if any.

        //如果chosenCtors没有被传入,那么获取构造函数
        Constructor[] candidates = chosenCtors;
        if (candidates == null) {
            Class beanClass = mbd.getBeanClass();
            try {
                candidates = (mbd.isNonPublicAccessAllowed() ?
                        beanClass.getDeclaredConstructors() : beanClass.getConstructors());
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                        "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
            }
        }
        //2.4.使用默认的构造函数初始化bean实例
        //因为这里构造参数不存在
        if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
            Constructor uniqueCandidate = candidates[0];
            if (uniqueCandidate.getParameterCount() == 0) {
                synchronized (mbd.constructorArgumentLock) {
                    mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                    mbd.constructorArgumentsResolved = true;
                    mbd.resolvedConstructorArguments = EMPTY_ARGS;
                }
                //封装初始化之后的bean
                bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                return bw;
            }
        }

        // Need to resolve the constructor.
        //2.5.是否需要解析器
        boolean autowiring = (chosenCtors != null ||
                mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
        //用于承载解析后的构造函数参数的值
        ConstructorArgumentValues resolvedValues = null;
        int minNrOfArgs;
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        }
        else {
            //获取配置文件构造参数
            ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
            resolvedValues = new ConstructorArgumentValues();
            //解析构造参数
            minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
        }
        //3.对构造函数进行排序
        //public构造函数优先,非public次之
        AutowireUtils.sortConstructors(candidates);
        //最小参数的权重
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set> ambiguousConstructors = null;
        LinkedList causes = null;
        //遍历candidates 获取构造函数的参数类型
        for (Constructor candidate : candidates) {
            Class[] paramTypes = candidate.getParameterTypes();
            // 如果已经找到选用的构造函数或者需要的参数个数小于当前的构造函数参数个数，则终止。
            //因为，已经按照参数个数降序排列了
            if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
                // Already found greedy constructor that can be satisfied ->
                // do not look any further, there are only less greedy constructors left.
                break;
            }
            //这里表示参数的个数不相等,那么继续
            if (paramTypes.length < minNrOfArgs) {
                continue;
            }
            //参数的持有者对象
            ArgumentsHolder argsHolder;
            if (resolvedValues != null) {
                try {
                    //获取注解上的参数名称
                    String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
                    if (paramNames == null) {
                        //获取构造参数的探索器
                        ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
                            //通过探测器获取参数名称
                            paramNames = pnd.getParameterNames(candidate);
                        }
                    }
                    //根据bean的名称和构造参数以及构造函数来创建参数持有者ArgumentsHolder对象
                    argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                            getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                }//如果是UnsatisfiedDependencyException异常则添加到causes中
                catch (UnsatisfiedDependencyException ex) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                    }
                    // Swallow and try next constructor.
                    if (causes == null) {
                        causes = new LinkedList<>();
                    }
                    causes.add(ex);
                    continue;
                }
            }
            //resolvedValues为null的情况下
            else {
                // Explicit arguments given -> arguments length must match exactly.
                //构造函数没有参数的情况下
                if (paramTypes.length != explicitArgs.length) {
                    continue;
                }
                //通过explicitArgs来创建ArgumentsHolder
                argsHolder = new ArgumentsHolder(explicitArgs);
            }
            //isLenientConstructorResolution主要是判断解析构造函数的时候是否以宽松模式还是严格模式
            //严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
            //宽松模式：使用具有"最接近的模式"进行匹配
            //typeDiffWeight：类型差异权重
            int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                    argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
            // Choose this constructor if it represents the closest match.
            //如果它代表着当前最接近的匹配则选择作为构造函数
            if (typeDiffWeight < minTypeDiffWeight) {
                constructorToUse = candidate;
                argsHolderToUse = argsHolder;
                argsToUse = argsHolder.arguments;
                minTypeDiffWeight = typeDiffWeight;
                ambiguousConstructors = null;
            }
            //类型差异权重等于参数最小权重,将constructorToUse进行保存
            else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                if (ambiguousConstructors == null) {
                    ambiguousConstructors = new LinkedHashSet<>();
                    ambiguousConstructors.add(constructorToUse);
                }
                ambiguousConstructors.add(candidate);
            }
        }
        //没有可以执行的构造器函数或工厂方法,直接抛UnsatisfiedDependencyException异常
        if (constructorToUse == null) {
            if (causes != null) {
                UnsatisfiedDependencyException ex = causes.removeLast();
                for (Exception cause : causes) {
                    this.beanFactory.onSuppressedException(cause);
                }
                throw ex;
            }
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Could not resolve matching constructor " +
                    "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
        }
        else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Ambiguous constructor matches found in bean '" + beanName + "' " +
                    "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                    ambiguousConstructors);
        }
        //4.将解析的参数进行保存
        if (explicitArgs == null && argsHolderToUse != null) {
            argsHolderToUse.storeCache(mbd, constructorToUse);
        }
    }

    Assert.state(argsToUse != null, "Unresolved constructor arguments");
    //5.实例化bean并封装在bw中
    bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
    return bw;
}

关于构造函数创建bean实例的过程中,我们发现跟#instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) 方法一样,关于详细部分这里不再深究可以去看我的上一篇文章,接下来我们看看一个重要的部分就是创建完的bean是如何完成初始化的过程.

初始化过程

在#autowireConstructor()方法的末尾我们看到的是最后将创建完的bean通过方法# instantiate(String beanName, RootBeanDefinition mb Constructor constructorToUse, Object[] argsToUse)来实现的,跟踪代码发现:

private Object instantiate(
        String beanName, RootBeanDefinition mbd, Constructor constructorToUse, Object[] argsToUse) {

    try {
        InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
        if (System.getSecurityManager() != null) {
            return AccessController.doPrivileged((PrivilegedAction) () ->
                    strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse),
                    this.beanFactory.getAccessControlContext());
        }
        else {
            return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean instantiation via constructor failed", ex);
    }
}




该方法我们在上篇文章中讲过了这里不再啰嗦,发现这里并不是真正的核心处理方法,接着看:




public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
        final Constructor ctor, Object... args) {
    //判断是否有方法需要重载
    if (!bd.hasMethodOverrides()) {
        if (System.getSecurityManager() != null) {
            // use own privileged to change accessibility (when security is on)
            //设置访问权限
            AccessController.doPrivileged((PrivilegedAction) () -> {
                ReflectionUtils.makeAccessible(ctor);
                return null;
            });
        }
        //1.通过 BeanUtils直接使用构造器对象实例化Bean对象
        return BeanUtils.instantiateClass(ctor, args);
    }
    else {
        //2初始化CGLB对象
        return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
    }
}




在该方法中,首先设置对访问权限的设置,首先是通过构造器来实例化bean对象




  BeanUtils.java
public static  T instantiateClass(Constructor ctor, Object... args) throws BeanInstantiationException {
    Assert.notNull(ctor, "Constructor must not be null");
    try {
        //设置构造器可访问的权限
        ReflectionUtils.makeAccessible(ctor);
        //通过构造函数创建对象
        if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
            return KotlinDelegate.instantiateClass(ctor, args);
        }
        else {
            //获取构造函数的参数类型
            Class[] parameterTypes = ctor.getParameterTypes();
            Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
            //初始化新的参数长度
            Object[] argsWithDefaultValues = new Object[args.length];
            //循环处理构造参数的类型
            for (int i = 0 ; i < args.length; i++) {
                if (args[i] == null) {
                    //如果参数是isPrimitive类型的,保存其对应的值在argsWithDefaultValues数组中
                    Class parameterType = parameterTypes[i];
                    argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
                }
                //用来构建实例的参数不为null时
                else {
                    argsWithDefaultValues[i] = args[i];
                }
            }
            //通过够构造函数来创建对象
            return ctor.newInstance(argsWithDefaultValues);
        }
    }
    //对各种异常进行封装,统一抛出BeanInstantiationException异常
    catch (InstantiationException ex) {
        throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
    }
    catch (IllegalAccessException ex) {
        throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
    }
    catch (IllegalArgumentException ex) {
        throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
    }
    catch (InvocationTargetException ex) {
        throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
    }
}





上述方法主要是通过构造函数来创建对象,主要的区别在于:




    

  • 如果我们传入的构造参数存在,则直接创建
    • 

  • 反之是对构造参数的解析获取,最后利用反射和内省机制来构建bean实例
    • 





在2我们可以看到是初始化cglb实例,接着看:




protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
        BeanFactory owner, @Nullable Constructor ctor, Object... args) {

    throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}





该方法为空实现,主要是由子类org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy 来实现,具体来看代码:




CglibSubclassingInstantiationStrategy.java
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    return instantiateWithMethodInjection(bd, beanName, owner, null);
}

@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
        @Nullable Constructor ctor, Object... args) {

    // Must generate CGLIB subclass...
    //<>生成一个CGLB子类对象
    return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
}


/**
 * An inner class created for historical reasons to avoid external CGLIB dependency
 * in Spring versions earlier than 3.2.
 */
private static class CglibSubclassCreator {

    private static final Class[] CALLBACK_TYPES = new Class[]
            {NoOp.class, LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class};

    private final RootBeanDefinition beanDefinition;

    private final BeanFactory owner;

    CglibSubclassCreator(RootBeanDefinition beanDefinition, BeanFactory owner) {
        this.beanDefinition = beanDefinition;
        this.owner = owner;
    }





上述为创建CGLB实例的过程,在<>处我们可以看到还是通过#instantiate(@Nullable Constructor ctor, Object... args)方法来完成实例的初始化过程,代码如下:




/**
     * Create a new instance of a dynamically generated subclass implementing the
     * required lookups.
     * @param ctor constructor to use. If this is {@code null}, use the
     * no-arg constructor (no parameterization, or Setter Injection)
     * @param args arguments to use for the constructor.
     * Ignored if the {@code ctor} parameter is {@code null}.
     * @return new instance of the dynamically generated subclass
     */
    public Object instantiate(@Nullable Constructor ctor, Object... args) {
        //创建一个cglb的代理类
        Class subclass = createEnhancedSubclass(this.beanDefinition);
        Object instance;
        //如果当前构造器不存在,通过BeanUtils调用默认构造器来创建
        if (ctor == null) {
            instance = BeanUtils.instantiateClass(subclass);
        }
        else {
            try {
                //获取代理对象的构造器
                Constructor enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                //创建实例
                instance = enhancedSubclassConstructor.newInstance(args);
            }
            catch (Exception ex) {
                throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
                        "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
            }
        }
        // SPR-10785: set callbacks directly on the instance instead of in the
        // enhanced class (via the Enhancer) in order to avoid memory leaks.
        Factory factory = (Factory) instance;
        factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
                new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
                new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
        return instance;
    }





在获代码中我们可以看到,创建CGLB对象的过程,首先是获取代理对象,如果当前构造器不存在则则使用默认无参的,最后完成bean的创建,这就是关于CGLB实例创建的过程




小结




关于#createBeanInstance()的过程,spring对于不同创建都会选择其对应的策略模式来完成,关于策略模式有以下几种:




    

  • 通过Supplier回调方式的方式来实现bean的创建
    • 

  • 通过工厂方法来完成bean的创建
    • 

  • 通过构造器自动注入的方式来完成bean的创建
    • 

  • 最后一种是通过默认构造器的方式
    • 





在以上4中的策略模式中,其中工厂方法和构造器自动注入的方式最为复杂,简友们可以仔细的看看,哈哈哈,代码有点长哦!其两者的方式很接近,当然我们在最后衍生出了CGLiB实例的创建的过程,发现spring是通过#bd.hasMethodOverrides()来判断是否有覆盖的方法,如果有则只能通过cglib的方式来实例化,反之利用反射的方式来创建.






关于createBeanInstance()的详细拆分就到这里了


























你可能感兴趣的:(spring容器之bean加载策略之构造函数注入模式)






    

  • 机器学习与深度学习间关系与区别
ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python

    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    

    • 

  • 【iOS】MVC设计模式
Magnetic_h
iosmvc设计模式objective-c学习ui

    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    

    • 

  • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    

    • 

  • 扫地机类清洁产品之直流无刷电机控制
悟空胆好小
清洁服务机器人单片机人工智能

    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    

    • 

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    

    • 

  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
测评君高省

    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    

    • 

  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
小鹿_33

    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    

    • 

  • 《大清方方案》| 第二话
谁佐清欢

    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    

    • 

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    

    • 

  • 网易严选官方旗舰店，优质商品，卓越服务
高省_飞智666600

    网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
    

    • 

  • 《庄子.达生9》
钱江潮369

    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    

    • 

  • 直返最高等级与直返APP：无需邀请码的返利新体验
古楼

    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    

    • 

  • 高端密码学院笔记285
柚子_b4b4

    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    

    • 

  • 2020-04-12每天三百字之连接与替代
冷眼看潮

    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    

    • 

  • 使用Apify加载Twitter消息以进行微调的完整指南
nseejrukjhad
twittereasyui前端python

    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
    

    • 

  • 东南林氏之九牧林候选父系
祖缘树TheYtree

    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    

    • 

  • 大伟说成语之唉声叹气
求索大伟

    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    

    • 

  • Python快速入门 —— 第三节：类与对象
孤华暗香
Python快速入门python开发语言

    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    

    • 

  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
高省APP珊珊

    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    

    • 

  • libyuv之linux编译
jaronho
Linuxlinux运维服务器

    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    

    • 

  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
高省_飞智666600

    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    

    • 

  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？
高省APP大九

    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
    

    • 

  • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    

    • 

  • 锁之缘
尘缘诗词原创作品

    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    

    • 

  • ARM驱动学习之基础小知识
JT灬新一
ARM嵌入式arm开发学习

    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    

    • 

  • ARM驱动学习之5 LEDS驱动
JT灬新一
嵌入式C底层arm开发学习单片机

    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    

    • 

  • ARM驱动学习之4小结
JT灬新一
嵌入式C++arm开发学习linux

    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    

    • 

  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
GPJnCrbBdl
python开发语言

    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    

    • 

  • C++ | Leetcode C++题解之第409题最长回文串
Ddddddd_158
经验分享C++Leetcode题解

    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    

    • 

  • 直返APP是什么?直返APP是干嘛的
氧惠帮朋友一起省

    直返是一种电商购物模式，其核心特点是用户购买商品后可以获得直接返利。具体来说，用户在直返电商平台购买商品时，不仅可以获得商品本身的优惠，还可以获得一定的现金返利或者积分奖励。返利的金额可以提现到用户的账户余额，或者用于下次购物时抵扣。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万
    

    • 

  • java线程Thread和Runnable区别和联系
zx_code
javajvmthread多线程Runnable

    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。
模拟窗口买票，第一例子继承thread，代码如下
package thread;
public class ThreadTest {
public static void main(String[] args) {
Thread1 t1 = new Thread1(
    

    • 

  • 【转】JSON与XML的区别比较
丁_新
jsonxml

    1.定义介绍
(1).XML定义
扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。
XML是标
    

    • 

  • c++ 实现五种基础的排序算法
CrazyMizzz
C++c算法

    #include<iostream>
using namespace std;
//辅助函数，交换两数之值
template<class T>
void mySwap(T &x, T &y){
T temp = x;
x = y;
y = temp;
}
const int size = 10;
//一、用直接插入排
    

    • 

  • 我的软件
麦田的设计者
我的软件音乐类娱乐放松

         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
    

    • 

  • linux awk命令详解
被触发
linux awk

    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息
awk处理过程: 依次对每一行进行处理，然后输出
awk命令形式:
awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file
[-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
    

    • 

  • 各种语言比较
_wy_
编程语言

                        Java Ruby PHP 擅长领域                  
    

    • 

  • oracle 中数据类型为clob的编辑
知了ing
oracle clob

    public void updateKpiStatus(String kpiStatus,String taskId){
Connection dbc=null;
Statement stmt=null;
PreparedStatement ps=null;
try {
dbc = new DBConn().getNewConnection();
//stmt = db
    

    • 

  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据
矮蛋蛋
zookeeper

    原文地址：
http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/
安装和配置详解
本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
    

    • 

  • tomcat数据源
alafqq
tomcat

    数据库
JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。
没有使用JNDI时我用要这样连接数据库：
03.  Class.forName("com.mysql.jdbc.Driver"); 
04.  conn
    

    • 

  • 遍历的方法
百合不是茶
遍历

                                                          遍历
在java的泛
    

    • 

  • linux查看硬件信息的命令
bijian1013
linux

    linux查看硬件信息的命令
一.查看CPU：
cat /proc/cpuinfo
 
二.查看内存：
free
 
三.查看硬盘：
df
 
linux下查看硬件信息
1、lspci 列出所有PCI 设备；
lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
    

    • 

  • java常见的ClassNotFoundException
bijian1013
java

    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
    

    • 

  • 【Gson五】日期对象的序列化和反序列化
bit1129
反序列化

    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：
 
1. 序列化时，Date对象序列化的字符串日期格式如何
2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题
3. Date A -> str -> Date B,A和B对象是否equals
  默认序列化和反序列化
 
 
import com
    

    • 

  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream
bit1129
Stream

      1. DStream的类说明文档：
 
/**
* A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous
* sequence of RDDs (of the same type) representing a continuous st
    

    • 

  • 通过nginx获取header信息
ronin47
nginx header

    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面，
if ( $http_cookie ~* "(.*)$") {
        set $all_cookie $1;
}
    变量$all_cookie就获得了cookie的值，可以用于运算了

    

    • 

  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
bylijinnan
java

    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984
写了个java版的：
public class Print_1_To_NDigit {
/**
* Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
* 1.使用字符串
    

    • 

  • Netty源码学习-ReplayingDecoder
bylijinnan
javanetty

    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看
http://bylijinnan.iteye.com/blog/1982618
API说，ReplayingDecoder简化了操作，比如：
FrameDecoder在decode时，需要判断数据是否接收完全：
public class IntegerH
    

    • 

  • js特殊字符过滤
cngolon
js特殊字符js特殊字符过滤

    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
    

    • 

  • hibernate使用sql查询
ctrain
Hibernate

    
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.Hibernate;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transa
    

    • 

  • linux shell脚本中切换用户执行命令方法
daizj
linuxshell命令切换用户

    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：
 
1、执行单个命令：su - user -c "command"
如：下面命令是以test用户在/data目录下创建test123目录
[root@slave19 /data]# su - test -c "mkdir /data/test123" 
    

    • 

  • 好的代码里只要一个 return 语句
dcj3sjt126com
return

    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
    

    • 

  • Android动画效果学习
dcj3sjt126com
android

    1、透明动画效果
方法一：代码实现
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
View rootView = inflater.inflate(R.layout.fragment_main, container, fals
    

    • 

  • linux复习笔记之bash shell (4)管道命令
eksliang
linux管道命令汇总linux管道命令linux常用管道命令

    转载请出自出处：
http://eksliang.iteye.com/blog/2105461  
  bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。
    上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？
    答：非常的经典的一句话，记住了，何为管
    

    • 

  • Android系统中自定义按键的短按、双击、长按事件
gqdy365
android

    在项目中碰到这样的问题：
由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成：
1、单击事件：就是普通key的单击；
2、双击事件：500ms内同一按键单击两次；
3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）；
4、组合按键：两个以上按键同时按住； 
    

    • 

  • asp.net获取站点根目录下子目录的名称
hvt
.netC#asp.nethovertreeWeb Forms

    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下：
<asp:ListBox runat="server" ID="lbKeleyiFolder" />
 
那么在页面上显示根目录子文件夹的代码如下：
string[] m_sub
    

    • 

  • Eclipse程序员要掌握的常用快捷键
justjavac
javaeclipse快捷键ide

      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
    

    • 

  • c++编程随记
lx.asymmetric
C++笔记

     为了字体更好看，改变了格式……
 
&&运算符：
 
#include<iostream>
using namespace std;
int main(){
     int a=-1,b=4,k;
     k=(++a<0)&&!(b--
    

    • 

  • linux标准IO缓冲机制研究
音频数据
linux

    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
    

    • 

  • 随想 生活
暗黑小菠萝
生活

    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。
 
毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
    

    • 

  • 我认为POJO是一个错误的概念
windshome
javaPOJO编程J2EE设计

     
            这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。
   &
    

    •