habit_learning
habit_learning

@DateTimeFormat 实现原理

上一篇，我们探讨了@JsonFormat的实现原理，本篇我们来一起探讨和它功能一样的注解@DateTimeFormat的实现原理。

前端Content-Type 为application/json的请求时，我们使用@JsonFormat来进行转化，如果为表单，则应该使用@DateTimeFormat。
现在我们修改下上一篇文章的栗子：
Controller层：

@RestController
public class HelloWorldController {

    @GetMapping("/hello-world")
    public QueryParams helloWorld(QueryParams queryParams){
        return queryParams;
    }
}

实体类QueryParams：

public class QueryParams {

    /**
     * 开始时间
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd HH")
    private Date startTime;

    /**
     * 名称
     */
    private String name;

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

现在是典型的 form 表单接收参数的形式了，我们来看看@DateTimeFormat是如何实现对时间的转化的。

由于我们是表单接收参数的形式，于是在处理请求参数的逻辑是在ServletModelAttributeMethodProcessor#resolveArgument方法上：

public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

        String name = ModelFactory.getNameForParameter(parameter);
        ...
        Object attribute = null;
        BindingResult bindingResult = null;
        if (bindingResult == null) {
            // Bean property binding and validation;
            // skipped in case of binding failure on construction.
            WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
            if (binder.getTarget() != null) {
                if (!mavContainer.isBindingDisabled(name)) {
                    bindRequestParameters(binder, webRequest);
                }
                validateIfApplicable(binder, parameter);
                if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                    throw new BindException(binder.getBindingResult());
                }
            }
            // Value type adaptation, also covering java.util.Optional
            if (!parameter.getParameterType().isInstance(attribute)) {
                attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
            }
            bindingResult = binder.getBindingResult();
        }

        // Add resolved attribute and BindingResult at the end of the model
        Map bindingResultModel = bindingResult.getModel();
        mavContainer.removeAttributes(bindingResultModel);
        mavContainer.addAllAttributes(bindingResultModel);

        return attribute;
    }

对请求参数进行绑定的操作是在bindRequestParameters(binder, webRequest)方法，于是我们直接看ServletModelAttributeMethodProcessor#bindRequestParameters方法：

protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
        ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
        Assert.state(servletRequest != null, "No ServletRequest");
        ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
        servletBinder.bind(servletRequest);
    }

public void bind(ServletRequest request) {
        MutablePropertyValues mpvs = new ServletRequestParameterPropertyValues(request);
        MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
        if (multipartRequest != null) {
            bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
        }
        addBindValues(mpvs, request);
        doBind(mpvs);
    }

该方法会把请求参数的名称以及值封装为MutablePropertyValues对象，此时MutablePropertyValues的值是转化前的。然后调用doBind(mpvs)方法进行绑定：

public class WebDataBinder extends DataBinder {

protected void doBind(MutablePropertyValues mpvs) {
        checkFieldDefaults(mpvs);
        checkFieldMarkers(mpvs);
        super.doBind(mpvs);
    }
}

public class DataBinder implements PropertyEditorRegistry, TypeConverter {
    protected void doBind(MutablePropertyValues mpvs) {
        checkAllowedFields(mpvs);
        checkRequiredFields(mpvs);
        applyPropertyValues(mpvs);
    }
}

经过一系列对参数进行校验之后，调用applyPropertyValues(mpvs)方法根据MutablePropertyValues对象对请求参数进行赋值：

protected void applyPropertyValues(MutablePropertyValues mpvs) {
        try {
            // Bind request parameters onto target object.
            getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields());
        }
        catch (PropertyBatchUpdateException ex) {
            // Use bind error processor to create FieldErrors.
            for (PropertyAccessException pae : ex.getPropertyAccessExceptions()) {
                getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult());
            }
        }
    }

protected ConfigurablePropertyAccessor getPropertyAccessor() {
        return getInternalBindingResult().getPropertyAccessor();
    }

首先获取ConfigurablePropertyAccessor配置属性访问类，我们直接看getInternalBindingResult()方法：

public class DataBinder implements PropertyEditorRegistry, TypeConverter {

    private final Object target;

    private final String objectName;

    @Nullable
    private AbstractPropertyBindingResult bindingResult;  

    ...  

    protected AbstractPropertyBindingResult getInternalBindingResult() {
        if (this.bindingResult == null) {
            initBeanPropertyAccess();
        }
        return this.bindingResult;
    }

    public void initBeanPropertyAccess() {
        Assert.state(this.bindingResult == null,
                "DataBinder is already initialized - call initBeanPropertyAccess before other configuration methods");
        this.bindingResult = createBeanPropertyBindingResult();
    }

    protected AbstractPropertyBindingResult createBeanPropertyBindingResult() {
        BeanPropertyBindingResult result = new BeanPropertyBindingResult(getTarget(),
                getObjectName(), isAutoGrowNestedPaths(), getAutoGrowCollectionLimit());

        if (this.conversionService != null) {
            result.initConversion(this.conversionService);
        }
        if (this.messageCodesResolver != null) {
            result.setMessageCodesResolver(this.messageCodesResolver);
        }

        return result;
    }
}

首先判断DataBinder#bindingResult是否有值，如果没有则初始化一个。一开始DataBinder#bindingResult是没赋值的，只知道target请求参数对象即QueryParams，objectName请求参数对象实例为queryParams。于是会生成一个BeanPropertyBindingResult，然后调用BeanPropertyBindingResult#getPropertyAccessor方法ConfigurablePropertyAccessor配置属性访问类：

public final ConfigurablePropertyAccessor getPropertyAccessor() {
        if (this.beanWrapper == null) {
            this.beanWrapper = createBeanWrapper();
            this.beanWrapper.setExtractOldValueForEditor(true);
            this.beanWrapper.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
            this.beanWrapper.setAutoGrowCollectionLimit(this.autoGrowCollectionLimit);
        }
        return this.beanWrapper;
    }

该方法生成了BeanWrapperImpl对象，作为配置属性方法类，然后调用其父类AbstractPropertyAccessor#setPropertyValues(propertyValues, ignoreUnknown, ignoreInvalid)方法给属性赋值：

public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
            throws BeansException {

        List propertyAccessExceptions = null;
        List propertyValues = (pvs instanceof MutablePropertyValues ?
                ((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
        for (PropertyValue pv : propertyValues) {
            try {
                // This method may throw any BeansException, which won't be caught
                // here, if there is a critical failure such as no matching field.
                // We can attempt to deal only with less serious exceptions.
                setPropertyValue(pv);
            }
            catch (NotWritablePropertyException ex) {
                if (!ignoreUnknown) {
                    throw ex;
                }
                // Otherwise, just ignore it and continue...
            }
            catch (NullValueInNestedPathException ex) {
                if (!ignoreInvalid) {
                    throw ex;
                }
                // Otherwise, just ignore it and continue...
            }
            catch (PropertyAccessException ex) {
                if (propertyAccessExceptions == null) {
                    propertyAccessExceptions = new LinkedList<>();
                }
                propertyAccessExceptions.add(ex);
            }
        }

        // If we encountered individual exceptions, throw the composite exception.
        if (propertyAccessExceptions != null) {
            PropertyAccessException[] paeArray = propertyAccessExceptions.toArray(new PropertyAccessException[0]);
            throw new PropertyBatchUpdateException(paeArray);
        }
    }

该方法将PropertyValues对象转化为单个请求参数对象PropertyValue的集合，然后遍历该集合，逐个调用BeanWrapperImpl#setPropertyValue(pv)方法对请求参数进行赋值：

public void setPropertyValue(PropertyValue pv) throws BeansException {
        PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
        if (tokens == null) {
            String propertyName = pv.getName();
            AbstractNestablePropertyAccessor nestedPa;
            try {
                nestedPa = getPropertyAccessorForPropertyPath(propertyName);
            }
            catch (NotReadablePropertyException ex) {
                throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Nested property in path '" + propertyName + "' does not exist", ex);
            }
            tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
            if (nestedPa == this) {
                pv.getOriginalPropertyValue().resolvedTokens = tokens;
            }
            nestedPa.setPropertyValue(tokens, pv);
        }
        else {
            setPropertyValue(tokens, pv);
        }
    }

首先会判断PropertyValue#resolvedTokens是否有值，显然一开始PropertyValue只有属性名称和属性值，没有resolvedTokens，于是会生成一个PropertyTokenHolder对象，该对象只保存属性名称，如果属性名称含有[和]符号时，会拆分属性名称并赋值PropertyTokenHolder#keys。然后调用nestedPa.setPropertyValue(tokens, pv)方法进行参数赋值操作：

protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
        if (tokens.keys != null) {
            processKeyedProperty(tokens, pv);
        }
        else {
            processLocalProperty(tokens, pv);
        }
    }

private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
        PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
        ...
        Object oldValue = null;
        try {
            Object originalValue = pv.getValue();
            Object valueToApply = originalValue;
            if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                if (pv.isConverted()) {
                    valueToApply = pv.getConvertedValue();
                }
                else {
                    if (isExtractOldValueForEditor() && ph.isReadable()) {
                        try {
                            oldValue = ph.getValue();
                        }
                        catch (Exception ex) {
                            if (ex instanceof PrivilegedActionException) {
                                ex = ((PrivilegedActionException) ex).getException();
                            }
                            if (logger.isDebugEnabled()) {
                                logger.debug("Could not read previous value of property '" +
                                        this.nestedPath + tokens.canonicalName + "'", ex);
                            }
                        }
                    }
                    valueToApply = convertForProperty(
                            tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
                }
                pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
            }
            ph.setValue(valueToApply);
        }
        ...

    }

该方法会判断PropertyTokenHolder#keys是否有值，显然我们的参数没有[和]符号，则直接走processLocalProperty(tokens, pv)方法，第一步，它会调用getLocalPropertyHandler(tokens.actualName)方法生成PropertyHandler属性处理器对象：

protected BeanPropertyHandler getLocalPropertyHandler(String propertyName) {
        PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName);
        return (pd != null ? new BeanPropertyHandler(pd) : null);
    }

private CachedIntrospectionResults getCachedIntrospectionResults() {
        if (this.cachedIntrospectionResults == null) {
            this.cachedIntrospectionResults = CachedIntrospectionResults.forClass(getWrappedClass());
        }
        return this.cachedIntrospectionResults;
    }

public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyAccessor {

    @Nullable
    Object wrappedObject;

    private String nestedPath = "";

    @Nullable
    Object rootObject;

public final Class getWrappedClass() {
        return getWrappedInstance().getClass();
    }

public final Object getWrappedInstance() {
        Assert.state(this.wrappedObject != null, "No wrapped object");
        return this.wrappedObject;
    }
}

首先调用getWrappedClass()获取封装实体类 Class，即QueryParams的 Class，然后调用CachedIntrospectionResults.forClass(getWrappedClass())方法，生成CachedIntrospectionResults缓存的内省结果：

public class CachedIntrospectionResults {
    /** The BeanInfo object for the introspected bean class */
    private final BeanInfo beanInfo;

    /** PropertyDescriptor objects keyed by property name String */
    private final Map propertyDescriptorCache;

    static CachedIntrospectionResults forClass(Class beanClass) throws BeansException {
        CachedIntrospectionResults results = strongClassCache.get(beanClass);
        if (results != null) {
            return results;
        }
        results = softClassCache.get(beanClass);
        if (results != null) {
            return results;
        }

        results = new CachedIntrospectionResults(beanClass);
        ConcurrentMap, CachedIntrospectionResults> classCacheToUse;

        if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||
                isClassLoaderAccepted(beanClass.getClassLoader())) {
            classCacheToUse = strongClassCache;
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
            }
            classCacheToUse = softClassCache;
        }

        CachedIntrospectionResults existing = classCacheToUse.putIfAbsent(beanClass, results);
        return (existing != null ? existing : results);
    }

    private CachedIntrospectionResults(Class beanClass) throws BeansException {
        try {
            ...
            this.propertyDescriptorCache = new LinkedHashMap<>();

            // This call is slow so we do it once.
            PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor pd : pds) {
                if (Class.class == beanClass &&
                        ("classLoader".equals(pd.getName()) ||  "protectionDomain".equals(pd.getName()))) {
                    // Ignore Class.getClassLoader() and getProtectionDomain() methods - nobody needs to bind to those
                    continue;
                }
            
                pd = buildGenericTypeAwarePropertyDescriptor(beanClass, pd);
                this.propertyDescriptorCache.put(pd.getName(), pd);
            }
      ...
    }

该方法把QueryParams类的 Class 对象传给CachedIntrospectionResults的构造器，从而生成CachedIntrospectionResults对象，同时会取该对象的GenericBeanInfo#properties的值，其类型是PropertyDescriptor对象集合，保存了属性的名称以及get、set 方法。
然后遍历PropertyDescriptor集合，通过buildGenericTypeAwarePropertyDescriptor(beanClass, pd)方法，为每个属性生成一个GenericTypeAwarePropertyDescriptor对象，并放入属性描述器缓存CachedIntrospectionResults#propertyDescriptorCache，其 key 为参数名称，value 为 GenericTypeAwarePropertyDescriptor对象。

拿到CachedIntrospectionResults对象之后，接着调用CachedIntrospectionResults#getPropertyDescriptor方法，来获取PropertyDescriptor对象：

PropertyDescriptor getPropertyDescriptor(String name) {
        PropertyDescriptor pd = this.propertyDescriptorCache.get(name);
        if (pd == null && StringUtils.hasLength(name)) {
            // Same lenient fallback checking as in Property...
            pd = this.propertyDescriptorCache.get(StringUtils.uncapitalize(name));
            if (pd == null) {
                pd = this.propertyDescriptorCache.get(StringUtils.capitalize(name));
            }
        }
        return (pd == null || pd instanceof GenericTypeAwarePropertyDescriptor ? pd :
                buildGenericTypeAwarePropertyDescriptor(getBeanClass(), pd));
    }

直接根据属性名称从属性描述器缓存中取PropertyDescriptor，显然我们上面已经保存了，于是直接拿到的是GenericTypeAwarePropertyDescriptor对象。然后把GenericTypeAwarePropertyDescriptor对象作为BeanPropertyHandler构造器的参数，生成BeanPropertyHandler对象，从而完成AbstractNestablePropertyAccessor#processLocalProperty的第一步操作。

然后就可以对参数进行转换操作了AbstractNestablePropertyAccessor#convertForProperty(tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor())，tokens.canonicalName就是属性名，oldValue为开启了安全管理器SecurityManager之后才有的值，我们默认是没有开启的，所以为null，originalValue为属性原值（转换前的），那么我们看ph.toTypeDescriptor()方法：

public TypeDescriptor toTypeDescriptor() {
            return new TypeDescriptor(property(this.pd));
        }

private Property property(PropertyDescriptor pd) {
        GenericTypeAwarePropertyDescriptor gpd = (GenericTypeAwarePropertyDescriptor) pd;
        return new Property(gpd.getBeanClass(), gpd.getReadMethod(), gpd.getWriteMethod(), gpd.getName());
    }

public TypeDescriptor(Property property) {
        Assert.notNull(property, "Property must not be null");
        this.resolvableType = ResolvableType.forMethodParameter(property.getMethodParameter());
        this.type = this.resolvableType.resolve(property.getType());
        this.annotatedElement = new AnnotatedElementAdapter(property.getAnnotations());
    }

这里根据BeanPropertyHandler#pd属性PropertyDescriptor对象的值，有请求参数所在类 Class，请求参数get、set方法，请求参数名称，生成Property对象，然后根据Property对象生成TypeDescriptor类型描述器对象，我们主要看property.getAnnotations()方法：

public final class Property {

    private static Map annotationCache = new ConcurrentReferenceHashMap<>();

    private final Class objectType;

    @Nullable
    private final Method readMethod;

    @Nullable
    private final Method writeMethod;

    private final String name;

    private final MethodParameter methodParameter;

    @Nullable
    private Annotation[] annotations;

    Annotation[] getAnnotations() {
        if (this.annotations == null) {
            this.annotations = resolveAnnotations();
        }
        return this.annotations;
    }

    private Annotation[] resolveAnnotations() {
        Annotation[] annotations = annotationCache.get(this);
        if (annotations == null) {
            Map, Annotation> annotationMap = new LinkedHashMap<>();
            addAnnotationsToMap(annotationMap, getReadMethod());
            addAnnotationsToMap(annotationMap, getWriteMethod());
            addAnnotationsToMap(annotationMap, getField());
            annotations = annotationMap.values().toArray(new Annotation[0]);
            annotationCache.put(this, annotations);
        }
        return annotations;
    }
}

由于刚才创建的Property对象没有给annotations赋值，于是直接走resolveAnnotations方法，该方法会需找参数字段以及get、set方法上的注解信息，并赋值给Property#annotations。于是startTime字段上的@DateTimeFormat注解信息存入了该Property对象中。随后将注解信息赋值给TypeDescriptor对象。

我们继续看AbstractNestablePropertyAccessor#convertForProperty方法：

protected Object convertForProperty(
            String propertyName, @Nullable Object oldValue, @Nullable Object newValue, TypeDescriptor td)
            throws TypeMismatchException {

        return convertIfNecessary(propertyName, oldValue, newValue, td.getType(), td);
    }

private Object convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue,
            @Nullable Object newValue, @Nullable Class requiredType, @Nullable TypeDescriptor td)
            throws TypeMismatchException {

        Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
        try {
            return this.typeConverterDelegate.convertIfNecessary(propertyName, oldValue, newValue, requiredType, td);
        }
        catch (ConverterNotFoundException | IllegalStateException ex) {
            PropertyChangeEvent pce =
                    new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
            throw new ConversionNotSupportedException(pce, requiredType, ex);
        }
        catch (ConversionException | IllegalArgumentException ex) {
            PropertyChangeEvent pce =
                    new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
            throw new TypeMismatchException(pce, requiredType, ex);
        }

public  T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
            @Nullable Class requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {

        // Custom editor for this type?
        PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);

        ConversionFailedException conversionAttemptEx = null;

        // No custom editor but custom ConversionService specified?
        ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
        if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
            TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
            if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
                try {
                    return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
                }
                catch (ConversionFailedException ex) {
                    // fallback to default conversion logic below
                    conversionAttemptEx = ex;
                }
            }
        }

        Object convertedValue = newValue;
        ...
        return convertedValue;
    }

如果conversionService.canConvert(sourceTypeDesc, typeDescriptor)条件成立，即时间格式能被转化，则执行转化操作conversionService.convert(newValue, sourceTypeDesc, typeDescriptor)，newValue就是要转化的值，sourceTypeDesc为要转化值的类型，这里是String，typeDescriptor就是上面生成含有@DateTimeFormat注解信息的TypeDescriptor类型描述器。

转化完成之后，则执行AbstractNestablePropertyAccessor#processLocalProperty方法的第三步，给PropertyHandler赋值ph.setValue(valueToApply)：

public void setValue(final @Nullable Object value) throws Exception {
            final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
                    ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
                    this.pd.getWriteMethod());
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction) () -> {
                    ReflectionUtils.makeAccessible(writeMethod);
                    return null;
                });
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction) () ->
                            writeMethod.invoke(getWrappedInstance(), value), acc);
                }
                catch (PrivilegedActionException ex) {
                    throw ex.getException();
                }
            }
            else {
                ReflectionUtils.makeAccessible(writeMethod);
                writeMethod.invoke(getWrappedInstance(), value);
            }
        }
 
 
显然，这里用反射机制，调用参数的set方法，从而将转化后的值赋值给参数。
 
 
至此，@DateTimeFormat 实现原理已经讲解完毕，让我们来总结一下：
 
 
     
  
  1. 请求参数的名称以及值封装为MutablePropertyValues对象。
    2.  
  
  2. 获取ConfigurablePropertyAccessor配置属性访问类，根据MutablePropertyValues对象生成PropertyValue对象集合。
    3.  
  
  3. 遍历PropertyValue对象集合，执行设置操作。
    4.  
  
  4. 为每个请求参数生成BeanPropertyHandlerBea属性处理器对象。
    5.  
  
  5. 获取请求参数上的注解信息，并生成TypeDescriptor(含有注解信息)。
    6.  
  
  6. 根据生成的TypeDescriptor类型描述器对请求参数进行转化，随后利用反射机制执行参数的set方法，从而对参数进行赋值。
    7.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(@DateTimeFormat 实现原理)

        

            

                
    
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • 【编程底层原理】HashMap Hashtable ConcurrentHashMap
                        Dylanioucn
开发语言后端java
                        
    在Java的不同版本中，集合的实现原理有所变化，尤其是在HashMap、Hashtable和ConcurrentHashMap这三种实现中。以下是它们的一些关键区别和实现原理：一、HashMapJDK1.7：HashMap使用数组和链表的组合来解决冲突。当一个桶（数组的每个位置）中的元素超过一定数量时，会使用链表来存储这些元素。HashMap在JDK1.7中不是线程安全的。JDK1.8：进行了优化
    
                    
    • 
                    
  • vue 表格左右拖拽调整列宽_vue中实现拖动调整左右两侧div的宽度的示例代码
                        weixin_40008969
vue表格左右拖拽调整列宽
                        
    写在最前最近在使用vue的时候，遇到一个需求，实现左右div可通过中间部分拖拽调整宽度，类似于这样这是我最终的实现效果还是老话，因为我不是专业的前端工程师，只是兼职写一些简单的前端，所以这个功能的实现得益于以下博客，《vue拖动调整左右两侧div的宽度》、《vuejs中拖动改变元素宽度实现宽度自适应大小》，而我只是针对于他们提供的代码，加了亿点点自己所需要的细节。实现原理如上图所示，我们需要将要实
    
                    
    • 
                    
  • Stream 流 根据对象属性去重
                        abments
jdk1.8新特性pythonpandas数据分析
                        
    目录前言一、实现原理二、实现过程三、filter过滤器的原理总结前言这篇文章介绍一种通过stream流对集合中的对象根据key值去重的简便方法。一、实现原理通过Stream流中的filter方法实现对数据的去重，具体操作是构造一个Predict对象，在Predict中通过检查数据是否存在返回断言中的布尔值。二、实现过程代码如下：publicstaticPredicatedistinctPredic
    
                    
    • 
                    
  • Redisson分布式锁实现原理和使用
                        牧竹子
springboot#redisRedissonredis
                        
    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
    
                    
    • 
                    
  • 深入学习-Gradle-自动化构建技术（五）Gradle-插件架构实现原理剖析-
                        2401_84002294
2024年程序员学习学习自动化架构
                        
    6、AndroidGradlePluginV3.0.0（2017年10月）7、AndroidGradlePluginV2.3.0（2017年2月）三、Gradle构建核心流程解析1、LoadSettings2、Configure3、TaskGraph4、RunTasks5、Finished四、关于Gradle中依赖实现的原理1、通过MethodMissing机制，间接地调用DefaultDepen
    
                    
    • 
                    
  • Java面试必问之Hashmap底层实现原理(JDK1.7)
                        当我遇上你csy
Java基础javahashmap面试源码
                        
    1.前言Hashmap可以说是Java面试必问的，一般的面试题会问:Hashmap有哪些特性？Hashmap底层实现原理(get\put\resize)Hashmap怎么解决hash冲突？Hashmap是线程安全的吗？…今天就从源码角度一探究竟。笔者的源码是OpenJDK1.72.构造方法首先看构造方法的源码//默认初始容量staticfinalintDEFAULT_INITIAL_CAPACIT
    
                    
    • 
                    
  • 写一个图片裁剪的js，JavaScript图片裁剪插件PlusCropper
                        微特尔普拉斯
javascriptnodevuejavascript开发语言ecmascript
                        
    在前端开发中，图片裁剪是一个常见的需求。本文将深入解析一个功能完善的JavaScript图片裁剪插件——PlusCropper，带你一步步了解其实现原理和使用方法。一、插件概述PlusCropper是一个轻量级的JavaScript插件，它允许用户在网页上交互式地裁剪图片。它提供了以下功能：可拖拽和缩放的裁剪框:用户可以通过鼠标或触摸操作来调整裁剪区域的大小和位置。图片旋转:支持图片的顺时针和逆时
    
                    
    • 
                    
  • 全面解析MeiliSearch及其Go语言实现
                        寻找09之夏
Meilisearchgolang开发语言后端Meilisearch
                        
    前言随着互联网的发展和数字化进程的加速，无论是企业还是个人用户，都需要面对海量的信息。在这个背景下，搜索技术的重要性日益凸显。MeiliSearch是一款开源搜索引擎，它的出现为开发者提供了一个高效、灵活的选择。本文将从多个角度探讨MeiliSearch的特性、使用方法及其实现原理，并通过Go语言示例展示如何构建一个高性能的搜索系统。一、MeiliSearch特性MeiliSearch之所以受到欢
    
                    
    • 
                    
  • el-table日期格式化处理2种方式
                        c28n07
elementui
                        
    关于el-table总结[toc]1.方式一：采用filters//template{{props.row.time|dateTimeFormat}}//script->filtersfilters:{dateTimeFormat(dateTime){if(!dateTime){returndateTime;}returnmoment(dateTime).format("YYYY-MM-DD");
    
                    
    • 
                    
  • call/apply 的实现原理是什么？
                        65649e6a691f

                        
    call和apply的功能相同，都是改变this的执行，并立即执行函数。区别在于传参方式不同。func.call(thisArg,arg1,arg2,...)：第一个参数是this指向的对象，其它参数依次传入。func.apply(thisArg,[argsArray])：第一个参数是this指向的对象，第二个参数是数组或类数组。一起思考一下，如何模拟实现call？首先，我们知道，函数都可以调用c
    
                    
    • 
                    
  • 深入解析C++单例模式：从基础到线程安全的高效实现
                        shuai_258
c++全套攻略c++c++多线程开发语言c++qt
                        
    引言在C++开发中，单例模式（SingletonPattern）是一种常见且重要的设计模式。它确保类的实例在整个程序生命周期中唯一，并提供一个全局访问点。这在日志管理、配置管理等场景中尤为常见。本篇博客将带你深入了解单例模式的实现原理，并介绍如何在多线程环境下实现线程安全的单例模式。什么是单例模式？单例模式是一种设计模式，其核心思想是确保某个类只能有一个实例，并提供一个全局的访问点。其应用场景包括
    
                    
    • 
                    
  • 淘宝/天猫获取sku详细信息 API
                        weixin_43841111
apipythonjavaphpjavascript大数据数据库架构
                        
    在电商领域，准确获取商品的SKU详细信息至关重要。对于商家来说，它有助于管理库存、制定营销策略和优化商品展示。对于开发者和第三方平台而言，可以通过获取SKU详细信息实现商品信息整合、价格比较、订单管理等功能。例如，一个电商数据分析平台可以利用该API收集不同商品的SKU信息，进行市场趋势分析和销售预测。一、技术实现原理接口调用方式：通常采用RESTfulAPI风格，通过发送HTTP请求来获取SKU
    
                    
    • 
                    
  • Element-UI 组件实现面包屑导航栏
                        你不讲 wood
uijavascriptvue.js前端elementui
                        
    Element-UI组件实现面包屑导航栏面包屑导航栏是一种辅助导航系统，它显示用户当前位置在网站或应用层次结构中的位置，可以帮助用户了解他们当前页面的位置，并且可以方便地返回到上级页面或首页。面包屑导航栏的实现原理：路径记录与解析：当用户浏览网站时，面包屑导航记录用户经过的路径，通常是从主页到当前页面的一系列链接。每当用户访问一个新的页面时，面包屑导航会根据当前页面的路径信息更新显示的内容。路由匹
    
                    
    • 
                    
  • Spring 源码学习(九) Transaction 事务
                        带鱼真好吃

                        
    spring系列转载自掘金VipAugushttps://juejin.cn/user/2348212565601415/postsSpringTransaction事务的使用和实现原理前言业务系统的数据，一般最后都会落入到数据库中，例如MySQL、Oracle等主流数据库，不可避免的，在数据更新时，有可能会遇到错误，这时需要将之前的数据更新操作撤回，避免错误数据。Spring的声明式事务能帮我们
    
                    
    • 
                    
  • 第 2-2 课：深入探究底层原理，应用更加得心应手
                        Java大联盟
案例上手Spring全家桶SpringSpringBootSpringCloudSpringMVCSpringSpringBootSpring
                        
    前言上一讲我们学习了SpringMVC框架的使用，为了更好地理解这个框架，本讲来仿写一个SpringMVC框架，用到的技术比较简单，只需要XML解析+反射就可以完成，不需要JDK动态代理。自己手写框架的前提是必须理解框架的底层原理和运行机制，因此我们还是先来回顾一下SpringMVC的实现原理。SpringMVC实现原理SpringMVC的核心组件和工作流程的内容具体可以参考第2-1讲的内容，通过
    
                    
    • 
                    
  • 深入理解Redis原理：缓存雪崩/击穿/穿透/预热/降级
                        Hey 锡瑞
Redis缓存
                        
    目录1、缓存雪崩1.1、什么是缓存雪崩1.2、解决缓存雪崩2、缓存击穿2.1、什么是缓存击穿2.2、解决缓存击穿3、缓存穿透3.1、什么是缓存穿透3.2、解决缓存穿透3.3、基于RedisBloom实现布隆过滤器4、缓存预热4.1、什么是缓存预热4.2、解决缓存预热5、缓存降级5.1、什么是缓存降级下一篇：redis5种数据结构及底层实现原理1、缓存雪崩1.1、什么是缓存雪崩如果缓在某一个时刻出现
    
                    
    • 
                    
  • 图灵机和人脑的基础算法分析
                        深巷卖樱桃
程序人生机器学习改行学it人工智能
                        
    图灵机是计算机的原型，图灵机的实现原理是计算机cpu的原理。因此，我们来深入剖析一下图灵机的原理借此一窥cpu的核心功能。以实现加法功能2+3为例：一.首先是目的：计算什么：2+3二.其次是资源准备：1.硬件资源：无限延伸的纸带纸带，读写头2.软件资源：要计算的数字3.条件资源：这里需要用到读写头，用来感知和执行三.最后是方法，指令对照表如下：（二进制）01q11Rq21Rq1q20Lq31Rq2
    
                    
    • 
                    
  • Redis 事务揭秘：如何确保数据一致性
                        加勒比海涛
Redis入门实践redis数据库缓存
                        
    Redis事务揭秘：如何确保数据一致性一.认识Redis事务二.事务相关的命令三.watch的实现原理Hello,大家好,这个专栏给大家带来的是Redis系列!本篇文章给大家讲解的是Redis中的事务.Redis的事务是一个用于将多个命令打包在一起执行的特性,它可以保证这些命令要么全部执行,要么全部不执行,从而确保数据的一致性.我们可以看一下Redis中的事务是如何实现的本专栏旨在为初学者提供一个
    
                    
    • 
                    
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
                        RemusrickCat

                        
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    
                    
    • 
                    
  • 多线程与线程池的理解
                        Ronaldinho Gaúch
后端java
                        
    线程操作系统能够运算调度的最小单位，被包含于进程直至，是进程的实际运作单位进程程序基本执行实体可以这么理解，微信是一个进程，里面的朋友圈和视频号为线程，即软件中互相独立，可以同时运行的功能，若该软件中独立的功能很多，那就是多线程多线程实现原理：利用CPU等待的空闲时间在不同程序间进行切换线程池存放线程的容器当线程池为空时，若有任务需要完成，线程池会自动生成一个线程，以该线程去执行任务，执行完了该线
    
                    
    • 
                    
  • C++玩转模板之——函数萃取function traits
                        东川路徐先生
c++
                        
    目录前言一、实现原理（一）可调用类型萃取（二）成员函数萃取二、完整代码总结前言当笔者在实现一个类似函数包装器的类模板时（代码示意如下），希望能够传入一个可调用对象来构造，并自动推导出模板（C++17及以上）。但是，如何自动推导出任意一个可调用类型的返回值和参数类型，却成了一个问题。templateclassfunction{};templateclassfunction{std::function
    
                    
    • 
                    
  • React Native通讯原理
                        zbl_zbl
androidReactNativ
                        
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    
                    
    • 
                    
  • ConcurrentHashMap实现原理
                        CodeMaster_37714848
线程安全的hashMap
                        
    ConcurrentHashMap是Java中的一个并发集合类，它用于在多线程环境下高效地存储和操作键值对。它的实现原理旨在提供高效的并发访问，确保线程安全，同时保持较高的性能。下面是ConcurrentHashMap的一些核心实现原理：1.分段锁（SegmentLocking）ConcurrentHashMap的早期实现使用了分段锁（SegmentLocking）。这个策略将整个哈希表划分为多个
    
                    
    • 
                    
  • java reactor模式例子_Netty Reactor模式实现原理详解
                        weixin_39923623
javareactor模式例子
                        
    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    
                    
    • 
                    
  • python如何快速生成一个requirements.txt
                        钎散
pythonpythonwindowslinuxpip
                        
    python如何快速生成一个requirements.txt一、使用方法二、实现原理一、文件夹遍历二、获取导入名三、获取安装名四、获取版本结束一、使用方法先安装pipinstallrequirementsGet-ihttps://pypi.tuna.tsinghua.edu.cn/simple/然后在你要生成requirements.txt的项目根目录下新建一个文件[make_requiremen
    
                    
    • 
                    
  • html字体如何设置渐变,CSS 实现文字渐变色
                        甄公子
html字体如何设置渐变
                        
    CSS实现文字渐变，有下面两种方法：1.background属性.text-gradient{background-image:linear-gradient(toright,orange,purple);-webkit-background-clip:text;color:transparent;font-size:30px;}文字渐变效果如下：实现原理：background-image属性为该
    
                    
    • 
                    
  • 大厂Java面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？
                        技术范王有志
大厂Java面试题mybatisjava面试后端
                        
    大家好，我是王有志。今天给大家带来的是一道来自京东的关于MyBatis实现分页功能的面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？通常，分页的方式可以分为两种：逻辑（内存）分页物理分页逻辑（内存）分页指的是数据库返回全部符合条件的数据，然后再通过程序代码对数据结果进行分页处理；物理分页指的是通过SQL语句查询，由数据库返回分页后的查询结果。逻辑（内存）分页和物理分页各有优缺点，
    
                    
    • 
                    
  • OPENAI中RAG实现原理以及示例代码用PYTHON来实现
                        dzend
aigcpython开发语言ai
                        
    OPENAI中RAG实现原理以及示例代码用PYTHON来实现1.引言在当今人工智能领域，自然语言处理（NLP）是一个非常重要的研究方向。近年来，OPENAI发布了许多创新的NLP模型，其中之一就是RAG（Retrieval-AugmentedGeneration）模型。RAG模型结合了检索和生成两种方法，可以用于生成与给定问题相关的高质量文本。本文将介绍RAG模型的实现原理，并提供使用Python
    
                    
    • 
                    
  • python内置的四大高阶函数
                        挑灯望美人。
python开发语言
                        
    python内置的四大高阶函数为map,reduce,filter,sorted实现原理：map函数：接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素。如果传入了多个iterable参数，function必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。reduce函数：reduce方法，顾名思义就是减少，假设你有一个由数字组成的可迭代对象，并希望将其
    
                    
    • 
                                
  • 对于规范和实现，你会混淆吗？
                                    yangshangchuan
HotSpot
                                    
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： 
 
 JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
    
                                
    • 
                                
  • android 网络
                                    百合不是茶
网络
                                    
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat 
  
服务器代码;  servlet的使用需要在xml中注册 
package servlet;

import java.io.IOException;
import java.util.Arr
    
                                
    • 
                                
  • [读书笔记]读法拉第传
                                    comsci
读书笔记
                                    
     
 
      1831年的时候,一年可以赚到1000英镑的人..应该很少的... 
 
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成 
 
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
    
                                
    • 
                                
  • 随机数的产生
                                    沐刃青蛟
随机数
                                    
    c++中阐述随机数的方法有两种： 
  
一是产生假随机数（不管操作多少次，所产生的数都不会改变） 
  
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 
  
	//默认种子
	for (int i = 0; i < 5; i++)
	{
		cout<<
    
                                
    • 
                                
  • PHP检测函数所在的文件名
                                    IT独行者
PHP函数
                                    
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 
代码： 
     
[php]   
view plain 
copy    
 
 // Filename: functions.php    
 <?php&nbs
    
                                
    • 
                                
  • 银行各系统功能简介
                                    文强chu
金融
                                    
    银行各系统功能简介     　   业务系统   核心业务系统     业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等       清分清算系统     以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程       国际结算系
    
                                
    • 
                                
  • Python学习1(pip django 安装以及第一个project)
                                    小桔子
pythondjangopip
                                    
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 
第二部：解压这个压缩文件，会看到一个setup.p
    
                                
    • 
                                
  • php 数组
                                    aichenglong
PHP排序数组循环多维数组
                                    
    1 php中的创建数组 
 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 
 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 
 $numbers=range(1,10,
    
                                
    • 
                                
  • 安装python2.7
                                    AILIKES
python
                                    
    安装python2.7 
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 
2、复制解压 
#mkdir -p /opt/usr/python 
#cp  /opt/soft/Python-2
    
                                
    • 
                                
  • java异常的处理探讨
                                    百合不是茶
JAVA异常
                                    
    //java异常  
/* 
1，了解java 中的异常处理机制，有三种操作 
a,声明异常  
b,抛出异常  
c,捕获异常 
2，学会使用try-catch-finally来处理异常 
3，学会如何声明异常和抛出异常 
4，学会创建自己的异常 
  
*/ 
  
//2，学会使用try-catch-finally来处理异常 
  
    
                                
    • 
                                
  • getElementsByName实例
                                    bijian1013
element
                                    
    实例1： 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/x
    
                                
    • 
                                
  • 探索JUnit4扩展：Runner
                                    bijian1013
java单元测试JUnit
                                    
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。 
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
    
                                
    • 
                                
  • [MongoDB学习笔记二]MongoDB副本集
                                    bit1129
mongodb
                                    
    1. 副本集的特性 
  1)一台主服务器(Primary),多台从服务器(Secondary) 
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 
  
2
    
                                
    • 
                                
  • 【Spark八十一】Hive in the spark assembly
                                    bit1129
assembly
                                    
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 
 
  1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
    
                                
    • 
                                
  • Nginx问题定位之监控进程异常退出
                                    ronin47

                                    
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 
比如，这是一个异常退出的情况： 
$grep signal error.log

2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
    
                                
    • 
                                
  • No grammar constraints (DTD or XML schema).....两种解决方法
                                    byalias
xml
                                    
    方法一：常用方法   关闭XML验证 
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 
 
方法二：（个人推荐） 
添加 内容如下 
<?xml version=
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline
                                    bylijinnan
netty
                                    
    package com.ljn.channel;

/**
 * ChannelPipeline采用的是Intercepting Filter 模式
 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
 * 
 * 下面对ChannelPipeline作一个模拟，只模拟关键代码：
 */
public class Pipeline {
 
    
                                
    • 
                                
  • MYSQL数据库常用备份及恢复语句
                                    chicony
mysql
                                    
      
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 
 
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
    
                                
    • 
                                
  • 小白谈谈云计算--基于Google三大论文
                                    CrazyMizzz
Google云计算GFS
                                    
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。 
    我先说说GFS 
  &n
    
                                
    • 
                                
  • hadoop 平衡空间设置方法
                                    daizj
hadoopbalancer
                                    
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： 
<property> 
  <name>dfs.balance.bandwidthPerSec</name> 
    <value>10485760</value> 
    <description&g
    
                                
    • 
                                
  • Eclipse程序员要掌握的常用快捷键
                                    dcj3sjt126com
编程
                                    
       判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。     程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
    
                                
    • 
                                
  • Android学习之路
                                    dcj3sjt126com
Android学习
                                    
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 
下面说说我学习Android的感受，我学Android首先是看MARS的视
    
                                
    • 
                                
  • java 遍历Map的四种方法
                                    eksliang
javaHashMapjava 遍历Map的四种方法
                                    
    转载请出自出处： 
http://eksliang.iteye.com/blog/2059996 
 
package com.ickes;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 遍历Map的四种方式

    
                                
    • 
                                
  • 【精典】数据库相关相关
                                    gengzg
数据库
                                    
    package C3P0; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.beans.PropertyVetoException; 
import com.mchange.v2.c3p0.ComboPooledDataSource; 
public class DBPool{       
    
                                
    • 
                                
  • 自动补全
                                    huyana_town
自动补全
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
    
                                
    • 
                                
  • jquery在线预览PDF文件，打开PDF文件
                                    天梯梦
jquery
                                    
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。 
  
核心代码 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
    
                                
    • 
                                
  • ViewPager刷新单个页面的方法
                                    lovelease
androidviewpagertag刷新
                                    
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
    
                                
    • 
                                
  • 利用按位取反（~）从复合枚举值里清除枚举值
                                    草料场
enum
                                    
    以 C# 中的 System.Drawing.FontStyle 为例。  
  
如果需要同时有多种效果， 
如：“粗体”和“下划线”的效果，可以用按位或（|） 
FontStyle style = FontStyle.Bold | FontStyle.Underline; 
  
如果需要去除 style 里的某一种效果， 
    
                                
    • 
                                
  • Linux系统新手学习的11点建议
                                    刘星宇
编程工作linux脚本
                                    
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 
 
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
    
                                
    • 
                                
  • hibernate dao层应用之HibernateDaoSupport二次封装
                                    wangzhezichuan
DAOHibernate
                                    
    /** 
 * <p>方法描述:sql语句查询 返回List<Class> </p> 
 * <p>方法备注: Class 只能是自定义类 </p> 
 * @param calzz 
 * @param sql 
 * @return 
 * <p>创建人：王川</p> 
 * <p>创建时间：Jul
    
                                
    •