Spring 源码解析四：Bean 的构造装载、属性值解析、注解扫描

Spring 源码解析四：Bean 的构造装载、属性值解析、注解扫描

上一篇主要介绍了 Bean 的注册、解析、实例化，但留下一些点待解析：

  • ConstructorResolver.autowireConstructor 如何进行构造装载并实例化的
  • CglibSubclassingInstantiationStrategy.instantiate 如何动态实例化 bean 的
  • BeanDefinitionValueResolver.resolveValueIfNecessary 如何解析属性值的
  • MergedAnnotations.from 如何扫描注解的

这一节，就来解析这几个点

1. ConstructorResolver.autowireConstructor

ConstructorResolver
的主要功能是在构造时载入依赖的 bean 和用 factory-method 实例化 bean，这里只讲第一个：在构造时载入依赖的 bean ConstructorResolver.autowireConstructor

class ConstructorResolver {
    public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
            @Nullable Constructor[] chosenCtors, @Nullable Object[] explicitArgs) {
        // 实例化一个封装对象
        BeanWrapperImpl bw = new BeanWrapperImpl();

        // 需要使用的构造方法
        Constructor constructorToUse = null;
        // 需要使用的构造参数
        Object[] argsToUse = null;

        // 如果指定了参数，就使用指定的参数
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        }
        else {
            Object[] argsToResolve = null;
            // 并发处理
            synchronized (mbd.constructorArgumentLock) {
                // 获取定义中已解析的构造方法
                constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                    // 获取定义中已解析的参数，首先是resolvedConstructorArguments，其次是preparedConstructorArguments
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            if (argsToResolve != null) {
                // 把参数解析成实际要用的数据，如bean装配、属性载入
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
            }
        }

        // 如果没有指定的构造方法或参数
        if (constructorToUse == null || argsToUse == null) {
            Constructor[] candidates = chosenCtors;
            if (candidates == null) {
                // 如果传入的chosenCtors是空，则获取beanClass的构造方法
                Class beanClass = mbd.getBeanClass();
                try {
                    candidates = (mbd.isNonPublicAccessAllowed() ?
                            beanClass.getDeclaredConstructors() : beanClass.getConstructors());
                }
                catch (Throwable ex) {
                    // ... 代码省略
                }
            }

            // 如果只有一个构造方法，并且没有指定explicitArgs和constructorArgumentValues
            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;
                }
            }

            // 有构造方法，且构造模式为AUTOWIRE_CONSTRUCTOR，则需要自动装配bean
            boolean autowiring = (chosenCtors != null ||
                    mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
            ConstructorArgumentValues resolvedValues = null;

            // ... 代码省略


            // 选择一个参数数量、参数类型、参数顺序与需要实例化参数对象最接近的一个构造方法
            // 这里的计算比较复杂，有兴趣的朋友可以自行探索一下
            for (Constructor candidate : candidates) {
                // ... 代码省略
            }

            // ... 代码省略
        }

        // 实例化bean
        bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
        return bw;
    }

    // 实例化bean，默认使用CglibSubclassingInstantiationStrategy.instantiate来实例化
    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) {
            // ... 代码省略
        }
    }
} 
 
最终的实例化仍然需要CglibSubclassingInstantiationStrategy.instantiate来实现
 
 
2. CglibSubclassingInstantiationStrategy.instantiate
 
 
CglibSubclassingInstantiationStrategy
的主要功能是使用 cglib 的方式实例化 bean
 
 
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {}
 
 
我们先来看看 SimpleInstantiationStrategy
 
 
public class SimpleInstantiationStrategy implements InstantiationStrategy {
    // 用于调用factory-method
    private static final ThreadLocal currentlyInvokedFactoryMethod = new ThreadLocal<>();

    @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        // 没有方法需要重载
        if (!bd.hasMethodOverrides()) {
            Constructor constructorToUse;
            synchronized (bd.constructorArgumentLock) {
                // 首先获取已解析的构造方法
                constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    // 没有已解析的构造方法，则用beanClass获取
                    final Class clazz = bd.getBeanClass();
                    // 接口不能实例化
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
                        if (System.getSecurityManager() != null) {
                            constructorToUse = AccessController.doPrivileged(
                                    (PrivilegedExceptionAction>) clazz::getDeclaredConstructor);
                        }
                        else {
                            // 通过Class获取构造方法
                            constructorToUse = clazz.getDeclaredConstructor();
                        }
                        // 设为已解析的构造方法
                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    }
                    catch (Throwable ex) {
                        // 如果Class没有构造方法，报错
                    }
                }
            }
            // 调用Constructor..newInstance实例化
            return BeanUtils.instantiateClass(constructorToUse);
        }
        else {
            // 有方法需要重载，则需要用cglib生成一个新的子类
            return instantiateWithMethodInjection(bd, beanName, owner);
        }
    }

    // 方法注入实例化，留给子类实现
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
    }

    @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            final Constructor ctor, Object... args) {
        // 没有方法需要重载
        if (!bd.hasMethodOverrides()) {
            // ... 代码省略

            // 调用Constructor.newInstance实例化
            return BeanUtils.instantiateClass(ctor, args);
        }
        else {
            // 有方法需要重载，则需要用cglib生成一个新的子类
            return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
        }
    }

    // 方法注入实例化，留给子类实现
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
            BeanFactory owner, @Nullable Constructor ctor, Object... args) {
        throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
    }

    // 通过factory-method初始化
    @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            @Nullable Object factoryBean, final Method factoryMethod, Object... args) {

        try {
            // ... 代码省略

            // 直接调用Method.invoke实例化
            Object result = factoryMethod.invoke(factoryBean, args);
            // 如果为null，实例化一个NullBean
            if (result == null) {
                result = new NullBean();
            }
            return result;
        }
        catch (IllegalArgumentException ex) {
            // ... 代码省略
        }
        catch (IllegalAccessException ex) {
            // ... 代码省略
        }
        catch (InvocationTargetException ex) {
            // ... 代码省略
        }
    }
}
 
 
我们先来看看 CglibSubclassingInstantiationStrategy
 
 
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
    @Override
    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) {
        // 生成一个CglibSubclassCreator来实例化
        return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    }
}
 
 
CglibSubclassCreator是CglibSubclassingInstantiationStrategy的内部类
 
 
private static class CglibSubclassCreator {
    // 实例化一个构造函数
    public Object instantiate(@Nullable Constructor ctor, Object... args) {
        // 使用cglib Enhancer创建一个加强子类
        Class subclass = createEnhancedSubclass(this.beanDefinition);
        Object instance;
        if (ctor == null) {
            // 如果没有指定构造函数，调用Constructor.newInstance实例化
            instance = BeanUtils.instantiateClass(subclass);
        }
        else {
            try {
                // 获取与ctor参数匹配的子类构造函数，再调用Constructor.newInstance实例化
                Constructor enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                instance = enhancedSubclassConstructor.newInstance(args);
            }
            catch (Exception ex) {
                // ... 代码省略
            }
        }

        // ... 代码省略

        return instance;
    }

    // 使用cglib Enhancer创建一个加强子类
    private Class createEnhancedSubclass(RootBeanDefinition beanDefinition) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(beanDefinition.getBeanClass());
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        if (this.owner instanceof ConfigurableBeanFactory) {
            ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
            enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
        }
        enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
        enhancer.setCallbackTypes(CALLBACK_TYPES);
        return enhancer.createClass();
    }
}
 
 
3. BeanDefinitionValueResolver.resolveValueIfNecessary
 
 
BeanDefinitionValueResolver
的主要功能是将配置的属性值装载到 bean 中
 
 
class BeanDefinitionValueResolver {
    public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
        // 在运行时对其他bean的引用
        if (value instanceof RuntimeBeanReference) {
            RuntimeBeanReference ref = (RuntimeBeanReference) value;
            // 解析引用bean
            return resolveReference(argName, ref);
        }
        // 在运行时对其他bean name的引用
        else if (value instanceof RuntimeBeanNameReference) {
            String refName = ((RuntimeBeanNameReference) value).getBeanName();
            // 使用doEvaluate解析bean名字，执行SpEL表达式
            refName = String.valueOf(doEvaluate(refName));
            if (!this.beanFactory.containsBean(refName)) {
                // 没注册过bean name，报错
            }
            return refName;
        }
        // 包含别名的bean定义
        else if (value instanceof BeanDefinitionHolder) {
            BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
            // 解析内部bean
            return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
        }
        // bean定义
        else if (value instanceof BeanDefinition) {
            BeanDefinition bd = (BeanDefinition) value;
            // 内部bean名字
            String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
                    ObjectUtils.getIdentityHexString(bd);
            // 解析内部bean
            return resolveInnerBean(argName, innerBeanName, bd);
        }
        // 注入依赖描述(类、方法、属性)
        else if (value instanceof DependencyDescriptor) {
            Set autowiredBeanNames = new LinkedHashSet<>(4);
            // 解析依赖
            Object result = this.beanFactory.resolveDependency(
                    (DependencyDescriptor) value, this.beanName, autowiredBeanNames, this.typeConverter);
            for (String autowiredBeanName : autowiredBeanNames) {
                if (this.beanFactory.containsBean(autowiredBeanName)) {
                    // 注册依赖
                    this.beanFactory.registerDependentBean(autowiredBeanName, this.beanName);
                }
            }
            return result;
        }

        // ... 代码省略

        // 是字符类型的值
        else if (value instanceof TypedStringValue) {
            TypedStringValue typedStringValue = (TypedStringValue) value;
            // 使用evaluate解析bean名字，执行SpEL表达式
            Object valueObject = evaluate(typedStringValue);
            try {
                // 解析类型
                Class resolvedTargetType = resolveTargetType(typedStringValue);
                // 如果有类型，把valueObject转换成这个类型
                if (resolvedTargetType != null) {
                    return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
                }
                // 没有指定类型，则返回原本的
                else {
                    return valueObject;
                }
            }
            catch (Throwable ex) {
                // ... 代码省略
            }
        }
        // 如果是NullBean，返回null
        else if (value instanceof NullBean) {
            return null;
        }
        // 默认当成SpEL表达式解析了
        else {
            return evaluate(value);
        }
    }
}
 
 
BeanDefinitionValueResolver.resolveReference
解析引用 bean
 
 
class BeanDefinitionValueResolver {
    private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
            Object bean;
            // 获取bean类型
            Class beanType = ref.getBeanType();
            if (ref.isToParent()) {
                // 指明从父BeanFactory中获取
                BeanFactory parent = this.beanFactory.getParentBeanFactory();

                if (beanType != null) {
                    // 如果有beanType，直接通过类型获取bean
                    bean = parent.getBean(beanType);
                }
                else {
                    // 使用doEvaluate解析bean名字，执行SpEL表达式，然后根据名字查找bean
                    bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
                }
            }
            else {
                String resolvedName;
                if (beanType != null) {
                    // 如果有beanType，直接通过类型获取bean
                    NamedBeanHolder namedBean = this.beanFactory.resolveNamedBean(beanType);
                    bean = namedBean.getBeanInstance();
                    resolvedName = namedBean.getBeanName();
                }
                else {
                    // 使用doEvaluate解析bean名字，执行SpEL表达式，然后根据名字查找bean
                    resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
                    bean = this.beanFactory.getBean(resolvedName);
                }
                // 注册依赖
                this.beanFactory.registerDependentBean(resolvedName, this.beanName);
            }
            // 如果是NullBean，返回null
            if (bean instanceof NullBean) {
                bean = null;
            }
            return bean;
        }
        catch (BeansException ex) {
            // ... 代码省略
        }
    }

    // 调用beanFactory来解析bean名字，执行SpEL表达式
    private Object doEvaluate(String value) {
        return this.beanFactory.evaluateBeanDefinitionString(value, this.beanDefinition);
    }
}
 
 
BeanDefinitionValueResolver.resolveInnerBean
解析内部 bean
 
 
class BeanDefinitionValueResolver {
    private Object resolveInnerBean(Object argName, String innerBeanName, BeanDefinition innerBd) {
        RootBeanDefinition mbd = null;
        try {
            // 获取合并父bean定义的bean定义
            mbd = this.beanFactory.getMergedBeanDefinition(innerBeanName, innerBd, this.beanDefinition);

            String actualInnerBeanName = innerBeanName;
            if (mbd.isSingleton()) {
                // 如果同类型的bean被实例化多次，则使用后缀#1,#2...来命名之后的bean
                actualInnerBeanName = adaptInnerBeanName(innerBeanName);
            }
            // 把新生成的名字注册到beanFactory
            this.beanFactory.registerContainedBean(actualInnerBeanName, this.beanName);
            // 获取依赖
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) {
                    // 注册依赖
                    this.beanFactory.registerDependentBean(dependsOnBean, actualInnerBeanName);
                    // 确保加载
                    this.beanFactory.getBean(dependsOnBean);
                }
            }
            // 创建bean
            Object innerBean = this.beanFactory.createBean(actualInnerBeanName, mbd, null);
            // 如果bean实例是FactoryBean，则调用factory-method获取真正的bean
            if (innerBean instanceof FactoryBean) {
                boolean synthetic = mbd.isSynthetic();
                innerBean = this.beanFactory.getObjectFromFactoryBean(
                        (FactoryBean) innerBean, actualInnerBeanName, !synthetic);
            }
            // 如果是NullBean，返回null
            if (innerBean instanceof NullBean) {
                innerBean = null;
            }
            return innerBean;
        }
        catch (BeansException ex) {
            // ... 代码省略
        }
    }

    // 如果同类型的bean被实例化多次，则使用后缀#1,#2...来命名之后的bean
    private String adaptInnerBeanName(String innerBeanName) {
        String actualInnerBeanName = innerBeanName;
        int counter = 0;
        String prefix = innerBeanName + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR;
        while (this.beanFactory.isBeanNameInUse(actualInnerBeanName)) {
            counter++;
            actualInnerBeanName = prefix + counter;
        }
        return actualInnerBeanName;
    }
}
 
 
4. MergedAnnotations.from
 
 
MergedAnnotations.from
的底层实现其实是 TypeMappedAnnotations.from
 
 
TypeMappedAnnotations的主要功能就是搜索、操作注解
 
 
final class TypeMappedAnnotations implements MergedAnnotations {
    static MergedAnnotations from(AnnotatedElement element, SearchStrategy searchStrategy,
            RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter) {
        // 没有可用的注解，直接返回NONE
        if (AnnotationsScanner.isKnownEmpty(element, searchStrategy)) {
            return NONE;
        }
        return new TypeMappedAnnotations(element, searchStrategy, repeatableContainers, annotationFilter);
    }

    static MergedAnnotations from(@Nullable Object source, Annotation[] annotations,
            RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter) {
        // 没有要查找的注解，直接返回NONE
        if (annotations.length == 0) {
            return NONE;
        }
        return new TypeMappedAnnotations(source, annotations, repeatableContainers, annotationFilter);
    }
}
 
 
final class TypeMappedAnnotations implements MergedAnnotations {
    // 检查是否有annotationType
    @Override
    public  boolean isPresent(Class annotationType) {
        // 过滤器没通过，返回false
        if (this.annotationFilter.matches(annotationType)) {
            return false;
        }
        // 扫描目标元素(类、方法、属性)
        return Boolean.TRUE.equals(scan(annotationType,
                IsPresent.get(this.repeatableContainers, this.annotationFilter, false)));
    }

    // 检查是否有annotationType
    @Override
    public boolean isPresent(String annotationType) {
        // 过滤器没通过，返回false
        if (this.annotationFilter.matches(annotationType)) {
            return false;
        }
        // 扫描目标元素(类、方法、属性)
        return Boolean.TRUE.equals(scan(annotationType,
                IsPresent.get(this.repeatableContainers, this.annotationFilter, false)));
    }

    // 获取目标元素的annotationType注解对象
    @Override
    public  MergedAnnotation get(Class annotationType,
            @Nullable Predicate> predicate,
            @Nullable MergedAnnotationSelector selector) {
        // 过滤器没通过，返回空
        if (this.annotationFilter.matches(annotationType)) {
            return MergedAnnotation.missing();
        }
        // 扫描目标元素(类、方法、属性)
        MergedAnnotation result = scan(annotationType,
                new MergedAnnotationFinder<>(annotationType, predicate, selector));
        return (result != null ? result : MergedAnnotation.missing());
    }

    // 获取目标元素的annotationType注解对象
    @Override
    public  MergedAnnotation get(String annotationType,
            @Nullable Predicate> predicate,
            @Nullable MergedAnnotationSelector selector) {
        // 过滤器没通过，返回空
        if (this.annotationFilter.matches(annotationType)) {
            return MergedAnnotation.missing();
        }
        // 扫描目标元素(类、方法、属性)
        MergedAnnotation result = scan(annotationType,
                new MergedAnnotationFinder<>(annotationType, predicate, selector));
        return (result != null ? result : MergedAnnotation.missing());
    }

    // 扫描目标元素(类、方法、属性)
    private  R scan(C criteria, AnnotationsProcessor processor) {
        // 如果有传入的注解对象，就不扫描目标元素了
        if (this.annotations != null) {
            R result = processor.doWithAnnotations(criteria, 0, this.source, this.annotations);
            return processor.finish(result);
        }
        // 有目标元素和扫描策略，扫描目标元素
        if (this.element != null && this.searchStrategy != null) {
            return AnnotationsScanner.scan(criteria, this.element, this.searchStrategy, processor);
        }
        return null;
    }
}
 
 
TypeMappedAnnotations.scan 的底层实现是 AnnotationsScanner.scan
 
 
abstract class AnnotationsScanner {
    // 扫描注解
    static  R scan(C context, AnnotatedElement source, SearchStrategy searchStrategy,
            AnnotationsProcessor processor) {
        // 实际扫描处理
        R result = process(context, source, searchStrategy, processor);
        return processor.finish(result);
    }

    // 实际扫描处理
    private static  R process(C context, AnnotatedElement source,
            SearchStrategy searchStrategy, AnnotationsProcessor processor) {
        // 如果目标元素是类，按类处理
        if (source instanceof Class) {
            return processClass(context, (Class) source, searchStrategy, processor);
        }
        // 如果目标元素是方法，按方法处理
        if (source instanceof Method) {
            return processMethod(context, (Method) source, searchStrategy, processor);
        }
        // 不然按普通处理
        return processElement(context, source, processor);
    }
}
 
 
4.1. 按类处理
 
 
abstract class AnnotationsScanner {
    private static  R processClass(C context, Class source,
            SearchStrategy searchStrategy, AnnotationsProcessor processor) {

        switch (searchStrategy) {
            // 只搜索自身的注解，按普通处理
            case DIRECT:
                return processElement(context, source, processor);
            // 搜索自身与标记为@Inherited父类的注解
            case INHERITED_ANNOTATIONS:
                return processClassInheritedAnnotations(context, source, searchStrategy, processor);
            // 搜索自身与父类的注解
            case SUPERCLASS:
                return processClassHierarchy(context, source, processor, false, false);
            // 搜索自身、父类、接口的注解
            case TYPE_HIERARCHY:
                return processClassHierarchy(context, source, processor, true, false);
            // 搜索自身、父类、接口、getEnclosingClass()的注解
            case TYPE_HIERARCHY_AND_ENCLOSING_CLASSES:
                return processClassHierarchy(context, source, processor, true, true);
        }
        throw new IllegalStateException("Unsupported search strategy " + searchStrategy);
    }

    // 搜索自身与标记为@Inherited父类的注解
    private static  R processClassInheritedAnnotations(C context, Class source,
            SearchStrategy searchStrategy, AnnotationsProcessor processor) {
        try {
            // 如果除了自身以外，没有父类、接口、getEnclosingClass()的注解，按普通处理
            if (isWithoutHierarchy(source, searchStrategy)) {
                return processElement(context, source, processor);
            }
            Annotation[] relevant = null;
            int remaining = Integer.MAX_VALUE;
            int aggregateIndex = 0;
            Class root = source;

            // source对象还可以继续向父类上溯
            // 非Object，非Ordered，非"java."开头
            while (source != null && source != Object.class && remaining > 0 &&
                    !hasPlainJavaAnnotationsOnly(source)) {

                // 聚合处理，如果有了，直接返回（默认未实现）
                R result = processor.doWithAggregate(context, aggregateIndex);
                if (result != null) {
                    return result;
                }

                // 获取所有public的注解
                Annotation[] declaredAnnotations = getDeclaredAnnotations(source, true);

                // ... 代码省略

                // 处理器自定义处理
                result = processor.doWithAnnotations(context, aggregateIndex, source, declaredAnnotations);
                // 如果有了，返回
                if (result != null) {
                    return result;
                }
                // 上溯父类，继续扫描
                source = source.getSuperclass();
                aggregateIndex++;
            }
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
        return null;
    }

    // 搜索自身、父类、接口、getEnclosingClass()的注解
    private static  R processClassHierarchy(C context, int[] aggregateIndex, Class source,
            AnnotationsProcessor processor, boolean includeInterfaces, boolean includeEnclosing) {
        try {
            // 聚合处理，如果有了，直接返回（默认未实现）
            R result = processor.doWithAggregate(context, aggregateIndex[0]);
            if (result != null) {
                return result;
            }
            // 如果是Ordered或"java."开头，返回
            if (hasPlainJavaAnnotationsOnly(source)) {
                return null;
            }
            // 获取所有public的注解
            Annotation[] annotations = getDeclaredAnnotations(source, false);
            // 处理器自定义处理
            result = processor.doWithAnnotations(context, aggregateIndex[0], source, annotations);
            // 如果有了，返回
            if (result != null) {
                return result;
            }
            aggregateIndex[0]++;

            // 如果包括接口，继续搜索接口的
            if (includeInterfaces) {
                for (Class interfaceType : source.getInterfaces()) {
                    R interfacesResult = processClassHierarchy(context, aggregateIndex,
                        interfaceType, processor, true, includeEnclosing);
                    if (interfacesResult != null) {
                        return interfacesResult;
                    }
                }
            }

            // 如果有父类，继续搜索父类的
            Class superclass = source.getSuperclass();
            if (superclass != Object.class && superclass != null) {
                R superclassResult = processClassHierarchy(context, aggregateIndex,
                    superclass, processor, includeInterfaces, includeEnclosing);
                if (superclassResult != null) {
                    return superclassResult;
                }
            }

            // 如果包括getEnclosingClass()，继续搜索getEnclosingClass()的
            if (includeEnclosing) {
                try {
                    Class enclosingClass = source.getEnclosingClass();
                    if (enclosingClass != null) {
                        R enclosingResult = processClassHierarchy(context, aggregateIndex,
                            enclosingClass, processor, includeInterfaces, true);
                        if (enclosingResult != null) {
                            return enclosingResult;
                        }
                    }
                }
                catch (Throwable ex) {
                    // ... 代码省略
                }
            }
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
        return null;
    }
}
 
 
4.2. 按方法处理
 
 
abstract class AnnotationsScanner {
    private static  R processMethod(C context, Method source,
            SearchStrategy searchStrategy, AnnotationsProcessor processor) {

        switch (searchStrategy) {
            // 只搜索自身的注解
            case DIRECT:
            // 搜索自身与标记为@Inherited父类的注解
            case INHERITED_ANNOTATIONS:
                return processMethodInheritedAnnotations(context, source, processor);
            // 搜索自身与父类的注解
            case SUPERCLASS:
                return processMethodHierarchy(context, new int[] {0}, source.getDeclaringClass(),
                        processor, source, false);
            // 搜索自身、父类、接口的注解
            case TYPE_HIERARCHY:
            // 搜索自身、父类、接口、getEnclosingClass()的注解
            case TYPE_HIERARCHY_AND_ENCLOSING_CLASSES:
                return processMethodHierarchy(context, new int[] {0}, source.getDeclaringClass(),
                        processor, source, true);
        }
        throw new IllegalStateException("Unsupported search strategy " + searchStrategy);
    }

    // 搜索自身与标记为@Inherited父类的注解
    private static  R processMethodInheritedAnnotations(C context, Method source,
            AnnotationsProcessor processor) {

        try {
            // 聚合处理，如果有了，直接返回（默认未实现）
            // 不然，用processMethodAnnotations处理
            R result = processor.doWithAggregate(context, 0);
            return (result != null ? result :
                processMethodAnnotations(context, 0, source, processor));
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
        return null;
    }

    // 处理方法的注解
    private static  R processMethodAnnotations(C context, int aggregateIndex, Method source,
            AnnotationsProcessor processor) {

      // 获取所有public的注解
        Annotation[] annotations = getDeclaredAnnotations(source, false);
        // 处理器自定义处理
        R result = processor.doWithAnnotations(context, aggregateIndex, source, annotations);
        // 如果有了，返回
        if (result != null) {
            return result;
        }

        // ... 代码省略，桥接方法的处理

        return null;
    }

    // 搜索自身、父类、接口、getEnclosingClass()的注解
    private static  R processMethodHierarchy(C context, int[] aggregateIndex,
            Class sourceClass, AnnotationsProcessor processor, Method rootMethod,
            boolean includeInterfaces) {
        try {
            // 聚合处理，如果有了，直接返回（默认未实现）
            R result = processor.doWithAggregate(context, aggregateIndex[0]);
            if (result != null) {
                return result;
            }
            // 如果是Ordered或"java."开头，返回
            if (hasPlainJavaAnnotationsOnly(sourceClass)) {
                return null;
            }

            boolean calledProcessor = false;
            // 如果rootMethod是sourceClass的，直接处理
            if (sourceClass == rootMethod.getDeclaringClass()) {
                result = processMethodAnnotations(context, aggregateIndex[0],
                    rootMethod, processor);
                calledProcessor = true;
                if (result != null) {
                    return result;
                }
            }
            else {
                // 获取sourceClass的public方法
                for (Method candidateMethod : getBaseTypeMethods(context, sourceClass)) {
                    // 如果方法不是private，并且参数与rootMethod一直，直接处理
                    if (candidateMethod != null && isOverride(rootMethod, candidateMethod)) {
                        result = processMethodAnnotations(context, aggregateIndex[0],
                            candidateMethod, processor);
                        calledProcessor = true;
                        if (result != null) {
                            return result;
                        }
                    }
                }
            }
            // 如果rootMethod是private，返回null
            if (Modifier.isPrivate(rootMethod.getModifiers())) {
                return null;
            }

            // 如果包括接口，继续搜索接口的
            if (includeInterfaces) {
                for (Class interfaceType : sourceClass.getInterfaces()) {
                    R interfacesResult = processMethodHierarchy(context, aggregateIndex,
                        interfaceType, processor, rootMethod, true);
                    if (interfacesResult != null) {
                        return interfacesResult;
                    }
                }
            }

            // 如果有父类，继续搜索父类的
            Class superclass = sourceClass.getSuperclass();
            if (superclass != Object.class && superclass != null) {
                R superclassResult = processMethodHierarchy(context, aggregateIndex,
                    superclass, processor, rootMethod, includeInterfaces);
                if (superclassResult != null) {
                    return superclassResult;
                }
            }
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
        return null;
    }
}
 
 
4.3 按普通处理
 
 
abstract class AnnotationsScanner {
    private static  R processElement(C context, AnnotatedElement source,
            AnnotationsProcessor processor) {

        try {
            // 聚合处理，如果有了，直接返回（默认未实现）
            // 不然，调用getDeclaredAnnotations获取注解来处理
            R result = processor.doWithAggregate(context, 0);
            return (result != null ? result : processor.doWithAnnotations(
                context, 0, source, getDeclaredAnnotations(source, false)));
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
        return null;
    }
}
 
 
后续
 
 
更多博客，查看 https://github.com/senntyou/blogs
 
 
作者：深予之 (@senntyou)
 
 
版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(后端javaspring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
    
                    
    • 
                    
  • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化
                        xiaoli8748_软件开发
系统架构系统架构负载均衡nginx
                        
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
    
                    
    • 
                    
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署）
                        java毕设程序源码王哥
php课程设计vue.js
                        
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    
                    
    • 
                    
  • 微信小程序开发注意事项
                        jun778895
微信小程序小程序
                        
    微信小程序开发是一个融合了前端开发、用户体验设计、后端服务（可选）以及微信小程序平台特性的综合性项目。这里，我将详细介绍一个典型的小程序开发项目的全过程，包括项目规划、设计、开发、测试及部署上线等各个环节，并尽量使内容达到或超过2000字的要求。一、项目规划1.1项目背景与目标假设我们要开发一个名为“智慧校园助手”的微信小程序，旨在为学生提供一站式校园生活服务，包括课程表查询、图书馆座位预约、食堂
    
                    
    • 
                    
  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。
                        焚木灵
node.jsvue
                        
    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
    
                    
    • 
                    
  • uniapp实现动态标记效果详细步骤【前端开发】
                        2401_85123349
uni-app
                        
    第二个点在于实现将已经被用户标记的内容在下一次获取后刷新它的状态为已标记。这是什么意思呢？比如说上面gif图中的这些人物对象，有一些已被该用户添加为关心，那么当用户下一次进入该页面时，这些已经被添加关心的对象需要以“红心”状态显现出来。这个点的难度还不算大，只需要在每一次获取后端的内容后对标记对象进行状态更新即可。II.动态标记效果实现思路和步骤首先，整体的思路是利用动态类名对不同的元素进行选择。
    
                    
    • 
                    
  • 后端开发刷题 | 把数字翻译成字符串（动态规划）
                        jingling555
笔试题目动态规划java算法数据结构后端
                        
    描述有一种将字母编码成数字的方式：'a'->1,'b->2',...,'z->26'。现在给一串数字，返回有多少种可能的译码结果数据范围：字符串长度满足0=10&&num<=26){if(i==1){dp[i]+=1;}else{dp[i]+=dp[i-2];}}}returndp[nums.length()-1];}}
    
                    
    • 
                    
  • 第三十一节:Vue路由:前端路由vs后端路由的了解
                        曹老师

                        
    1.认识前端路由和后端路由前端路由相对于后端路由而言的,在理解前端路由之前先对于路由有一个基本的了解路由:简而言之,就是把信息从原地址传输到目的地的活动对于我们来说路由就是:根据不同的url地址展示不同的页面内容1.1后端路由以前咱们接触比较多的后端路由,当改变url地址时,浏览器会向服务器发送请求,服务器根据这个url,返回不同的资源内容后端路由的特点就是前端每次跳转到不同url地址,都会重新访
    
                    
    • 
                    
  • 如何建设数据中台（五）——数据汇集—打破企业数据孤岛
                        weixin_47088026
学习记录和总结中台数据中台程序人生经验分享
                        
    数据汇集——打破企业数据孤岛要构建企业级数据中台，第一步就是将企业内部各个业务系统的数据实现互通互联，打破数据孤岛，主要通过数据汇聚和交换来实现。企业采集的数据可以是线上采集、线下数据采集、互联网数据采集、内部数据采集等。线上数据采集主要载体分为互联网和移动互联网两种，对应有系统平台、网页、H5、小程序、App等，可以采用前端或后端埋点方式采集数据。线下数据采集主要是通过硬件来采集，例如：WiFi
    
                    
    • 
                    
  • 创建一个完整的购物商城系统是一个复杂的项目，涉及前端（用户界面）、后端（服务器逻辑）、数据库等多个部分。由于篇幅限制，我无法在这里提供一个完整的系统代码，但我可以分别给出一些关键部分的示例代码，涵盖几
                        uthRaman
前端ui服务器
                        
    前端（HTML/CSS/JavaScript）grsyzp.cnHTML页面结构（index.html）html购物商城欢迎来到购物商城JavaScript（Ajax请求商品数据，app.js）javascriptdocument.addEventListener('DOMContentLoaded',function(){fetch('/api/products').then(response=
    
                    
    • 
                    
  • 若依后端正常启动但是uniapp移动端提示后端接口异常
                        大可大可抖
uni-app
                        
    pc端能用模拟器也能正常连接接口，手机端真机调试连不上接口解决：1.先看config.js的填自己的ip地址module.exports={//baseUrl:'https://vue.ruoyi.vip/prod-api',baseUrl:"http://192.168.101.5:8080",}2.网络环境问题（防火墙）点击属性然后选择专用
    
                    
    • 
                    
  • Lombok：Java开发者的代码简化神器【后端 17】
                        终末圆
Java后端java开发语言mysql数据库后端springbootpython
                        
    Lombok：Java开发者的代码简化神器在Java开发中，我们经常需要编写大量的样板代码，如getter、setter、equals、hashCode、toString等方法。这些代码虽然基础且必要，但往往占据了大量开发时间，且容易在属性变更时引发错误。幸运的是，Lombok这个Java库通过注解的方式，为我们提供了一种高效的解决方案。本文将详细介绍Lombok的使用及其优势。什么是Lombok
    
                    
    • 
                    
  • 后端开发刷题 | 最长回文子串
                        jingling555
笔试题目java算法javascript数据结构后端
                        
    描述对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。数据范围：1≤n≤1000要求：空间复杂度O(1)，时间复杂度O(n2)进阶:空间复杂度O(n)，时间复杂度O(n)示例1输入："ababc"返回值：3说明：最长的回文子串为"aba"与"bab"，长度都为3示例2输入："abbba"返回值：5示例3输入："b"返回值：1思路分析：该题可以
    
                    
    • 
                    
  • 哪些网站用python开发
                        hakesashou
python基础知识python
                        
    国内的话，知乎，网易，腾讯，搜狐，金山，豆瓣这些属于用Python比较知名的。大型的项目的话，网易的许多游戏，腾讯的某些网站，搜狐的邮箱，金山的测试框架等等都是或多或少使用了Python。YouTube-视频分享网站，在某些功能上使用到python。Quora-社交问答网站。Google-谷歌在很多项目中用python作为网络应用的后端，如GoogleGroups、Gmail、GoogleMaps
    
                    
    • 
                    
  • 2019-05-29 vue-router的两种模式的区别
                        Kason晨

                        
    1、大家都知道vue是一种单页应用,单页应用就是仅在页面初始化的时候加载相应的html/css/js一单页面加载完成,不会因为用户的操作而进行页面的重新加载或者跳转,用javascript动态的变化html的内容优点:良好的交互体验,用户不需要刷新页面,页面显示流畅,良好的前后端工作分离模式,减轻服务器压力,缺点:不利于SEO,初次加载耗时比较多2、hash模式vue-router默认的是hash
    
                    
    • 
                    
  • 计算机毕设Node.js+Vue校园易购二手交易平台（程序+LW+部署）
                        Node程序源码强子
vue.js课程设计node.js
                        
    项目运行环境配置：Node.js最新版+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    
                    
    • 
                    
  • 锋哥写一套前后端分离Python权限系统 基于Django5+DRF+Vue3.2+Element Plus+Jwt 视频教程 ，帅呆了~~
                        java1234_小锋
Python权限系统django权限系统pythonweb权限系统djangoDRFVUE权限python
                        
    大家好，我是java1234_小锋老师，最近写了一套【前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt】视频教程，持续更新中，计划月底更新完，感谢支持。视频在线地址：打造前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt视频教程（火爆连载更新中..）_哔哩哔哩_bilibili项目介绍本课程采
    
                    
    • 
                    
  • 外卖霸王餐返利外卖会员卡小程序开发
                        闹小艾
good506070微信小程序小程序
                        
    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
    
                    
    • 
                    
  • Apache HBase基础（基本概述，物理架构，逻辑架构，数据管理，架构特点，HBase Shell）
                        May--J--Oldhu
HBaseHBaseshellhbase物理架构hbase逻辑架构hbase
                        
    NoSQL综述及ApacheHBase基础一.HBase1.HBase概述2.HBase发展历史3.HBase应用场景3.1增量数据-时间序列数据3.2信息交换-消息传递3.3内容服务-Web后端应用程序3.4HBase应用场景示例4.ApacheHBase生态圈5.HBase物理架构5.1HMaster5.2RegionServer5.3Region和Table6.HBase逻辑架构-Row7.
    
                    
    • 
                    
  • Java中的服务端点响应缓存：Spring Cache抽象
                        微赚淘客机器人开发者联盟@聚娃科技
java缓存spring
                        
    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
    
                    
    • 
                    
  • 解决前端导出excel文件，打开为乱码
                        荔枝，你让我拿什么荔枝！
vue前端elementuivue.js
                        
    前端开发中，导入和导出文件是比较常见的业务场景，常见的情况是：后端返回一个二进制的流文件，前端将其转化为excel文件即可。但是往往会出现转化后的excel文件内容位乱码的情况，本文中提供了两个解决方案：方案一：用户自定义上传方法添加附件添加附件代码解读：上述代码采用了element-ui的el-upload文件上传的组件。改组件有两种文件上传的方式：1.组件自带的上传方法，只需要给其设置acti
    
                    
    • 
                    
  • 【Java】如何将二进制转换成MultipartFile
                        Mxin5
Javajava开发语言
                        
    业务场景：前端发送请求到后端进行文件上传，后端接收文件并调用第三方接口进行文件处理，响应格式为二进制，然后我们需要将二进制进行转换为MultipartFile进行文件上传。如果你想要将File转换成MultipartFile，可以参考：【Java】如何将File转换成MultipartFile_javafile转multipartfile_MXin5的博客-CSDN博客1.传递二进制respons
    
                    
    • 
                    
  • 【Unity基础】如何选择脚本编译方式Mono和IL2CPP？
                        tealcwu
Unity基础unity游戏引擎
                        
    Edit->ProjectSettings->Player在Unity中，ScriptingBackend决定了项目的脚本编译方式，即如何将C#代码转换为可执行代码。Unity提供了两种主要的ScriptingBackend选项：Mono和IL2CPP。它们之间的区别影响了项目的性能、平台支持、编译时间和调试体验。以下是两者的详细对比：1.Mono简介:Mono是Unity最早使用的脚本后端，基于
    
                    
    • 
                    
  • Kubernetes——组件
                        窒息う
Kuberneteskubernetes容器
                        
    文章目录K8S的优势核心架构角色与功能集群图例K8S的优势能管理大量跨主机容器快速部署应用快速扩展应用无缝对接新的应用节省资源，优化硬件资源的使用核心架构master（管理节点）node（计算节点）images（镜像节点）角色与功能Master功能提供集群的控制对集群进行全局决策检测和响应集群事件Master节点核心组件APIServer是整个系统的对外接口，提供客户端和其他组件调用后端元数据存储
    
                    
    • 
                                
  • sql统计相同项个数并按名次显示
                                    朱辉辉33
javaoracle
                                    
    现在有如下这样一个表： 
A表 
ID Name time 
------------------------------ 
0001 aaa 2006-11-18 
0002 ccc 2006-11-18 
0003 eee 2006-11-18 
0004 aaa 2006-11-18 
0005 eee 2006-11-18 
0004 aaa 2006-11-18 
0002 ccc 20
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列-目录
                                    白糖_
JQuery Mobile
                                    
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。 
  
从现在起，往后一段时间，我打算
    
                                
    • 
                                
  • 如何给线程池命名
                                    daysinsun
线程池
                                    
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下： 
    
public class Named
    
                                
    • 
                                
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
                                    周凡杨
html解析errorreadyState
                                    
      
错误：  IE   中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"      
  
  
现象：  同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    
                                
    • 
                                
  • java上传
                                    g21121
java
                                    
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 
下面是servlet的代码： 
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    
                                
    • 
                                
  • SpringMVC配置学习
                                    510888780
springmvc
                                    
    spring MVC配置详解 
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 
 
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    
                                
    • 
                                
  • spring mvc-jfreeChart 柱图(1)
                                    布衣凌宇
jfreechart
                                    
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 
第二步：配置web.xml; 
web.xml代码如下 
<servlet> 
    <servlet-name>jfreechart</servlet-nam
    
                                
    • 
                                
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    
                                
    • 
                                
  • java 线程池使用 Runnable&Callable&Future
                                    antlove
javathreadRunnablecallablefuture
                                    
    1. 创建线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 
  
2. 执行一次线程，调用Runnable接口实现 
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    
                                
    • 
                                
  • XML语法元素结构的总结
                                    百合不是茶
xml树结构
                                    
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    
                                
    • 
                                
  • 改变eclipse编码格式
                                    bijian1013
eclipse编码格式
                                    
    1.改变整个工作空间的编码格式 
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。 
        Eclipse->window->preferences->General->workspace-
    
                                
    • 
                                
  • javascript中return的设计缺陷
                                    bijian1013
JavaScriptAngularJS
                                    
    代码1： 
<script>
var gisService = (function(window) 
{ 

    return
    {
        name:function ()
        {
            alert(1);
        }
    };

})(this);

gisService.name();
&l
    
                                
    • 
                                
  • 【持久化框架MyBatis3八】Spring集成MyBatis3
                                    bit1129
Mybatis3
                                    
    pom.xml配置 
Maven的pom中主要包括： 
 
 MyBatis 
 MyBatis-Spring 
 Spring 
 MySQL-Connector-Java 
 Druid 
 applicationContext.xml配置     
<?xml version="1.0" encoding="UTF-8"?>
&
    
                                
    • 
                                
  • java web项目启动时自动加载自定义properties文件
                                    bitray
javaWeb监听器相对路径
                                    
    创建一个类 
public class ContextInitListener implements ServletContextListener 
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 
 
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 
 

    <listener>
        <des
    
                                
    • 
                                
  • 用nginx区分文件大小做出不同响应
                                    ronin47

                                    
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    
                                
    • 
                                
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Random;

public class ContinuousPoker {

    /**
     * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
     * 2-10为数字本身，A为1，J为1
    
                                
    • 
                                
  • 翟鸿燊老师语录
                                    ccii
翟鸿燊
                                    
    一、国学应用智慧TAT之亮剑精神A 
1. 角色就是人格 
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。 
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    
                                
    • 
                                
  • [光速与宇宙]进行光速飞行的一些问题
                                    comsci
问题
                                    
     
 
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家 
    仅仅是猜想。。。未经官方证实 
 
 
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    
                                
    • 
                                
  • oracle undo解析
                                    cwqcwqmax9
oracle
                                    
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 
 
Undo是干嘛用的？         &nb
    
                                
    • 
                                
  • java中各种集合的详细介绍
                                    dashuaifu
java集合
                                    
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    
                                
    • 
                                
  • 卸载windows服务的方法
                                    dcj3sjt126com
windowsservice
                                    
    卸载Windows服务的方法 
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    
                                
    • 
                                
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
                                    dcj3sjt126com
iosxcode
                                    
           
      
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html 
Excerpt: 
 
 You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    
                                
    • 
                                
  • 2014之C++学习笔记（一）
                                    Etwo
C++EtwoEtwoiterator迭代器
                                    
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    
                                
    • 
                                
  • js跨越获取数据问题记录
                                    haifengwuch
jsonpjsonAjax
                                    
    js的跨越问题，普通的ajax无法获取服务器返回的值。 
 
  第一种解决方案，通过getson，后台配合方式，实现。 
Java后台代码： 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException { 
String ca
    
                                
    • 
                                
  • 蓝色jQuery导航条
                                    ini
JavaScripthtmljqueryWebhtml5
                                    
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    
                                
    • 
                                
  • linux部署jdk,tomcat,mysql
                                    kerryg
jdktomcatlinuxmysql
                                    
    1、安装java环境jdk: 
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。 
   1.1）、卸载： 
     （rpm -qa :查询已经安装哪些软件包； 
       rmp -q 软件包：查询指定包是否已
    
                                
    • 
                                
  • DOMContentLoaded VS onload VS onreadystatechange
                                    mutongwu
jqueryjs
                                    
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 
 
2. onload是最早支持的事件，要求所有资源加载完毕触发。 
 
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    
                                
    • 
                                
  • sql批量插入数据
                                    qifeifei
批量插入
                                    
    hi， 
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。 
   
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    
                                
    • 
                                
  • log4j打印日志文件 如何实现相对路径到 项目工程下
                                    thinkfreer
Weblog4j应用服务器日志
                                    
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 
 
 
需求： 
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    
                                
    • 
                                
  • linux下mysql-5.6.23.tar.gz安装与配置
                                    笑我痴狂
mysqllinuxunix
                                    
    1.卸载系统默认的mysql 
 
[root@localhost ~]# rpm -qa | grep mysql 
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    
                                
    •