fastjson源码解读

最新推荐文章于 2024-07-27 18:51:22 发布
最新推荐文章于 2024-07-27 18:51:22 发布
阅读量948 收藏 1
点赞数
分类专栏： 代码流程逻辑概览 文章标签： json java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40980455/article/details/109727583
版权

最近项目中采用fastJson解决了自己的需求，因此，打算看看fastJson的实现。
直接跟代码。
在这里插入图片描述
1.fastJson进行object转json的程序入口

 public static final String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
        SerializeWriter out = new SerializeWriter();

        try {
            JSONSerializer serializer = new JSONSerializer(out);
            for (com.alibaba.fastjson.serializer.SerializerFeature feature : features) {
                serializer.config(feature, true);
            }

            serializer.config(SerializerFeature.WriteDateUseDateFormat, true);

            setFilter(serializer, filters);

            serializer.write(object);

            return out.toString();
        } finally {
            out.close();
        }
    }

观察上述的代码，见名知意，我们先猜测filters其实是类似于web端的filter的机制的，观看SerializeFilter的设计图
在这里插入图片描述
目前跟踪就大概是这几个类，其中对应的几个方法如下：没有深入具体看每一个方法，但是可以根据名称大体明白是对属性，值以及转json前后的一些处理。这些均可供我们扩展
在这里插入图片描述
2.回归1中的主逻辑代码查看SerializerFeature，看这个可传入参数到底是个什么：com.alibaba.fastjson.serializer.SerializerFeature
我们发现其是一个枚举类

public enum SerializerFeature {
    QuoteFieldNames,
    /**
     * 
     */
    UseSingleQuotes,
    /**
     * 
     */
    WriteMapNullValue,
    /**
     * 
     */
    WriteEnumUsingToString,
    /**
     * 
     */
    UseISO8601DateFormat,
    /**
     * @since 1.1
     */
    WriteNullListAsEmpty,
    /**
     * @since 1.1
     */
    WriteNullStringAsEmpty,
    /**
     * @since 1.1
     */
    WriteNullNumberAsZero,
    /**
     * @since 1.1
     */
    WriteNullBooleanAsFalse,
    /**
     * @since 1.1
     */
    SkipTransientField,
    /**
     * @since 1.1
     */
    SortField,
    /**
     * @since 1.1.1
     */
    @Deprecated
    WriteTabAsSpecial,
    /**
     * @since 1.1.2
     */
    PrettyFormat,
    /**
     * @since 1.1.2
     */
    WriteClassName,

    /**
     * @since 1.1.6
     */
    DisableCircularReferenceDetect,

    /**
     * @since 1.1.9
     */
    WriteSlashAsSpecial,

    /**
     * @since 1.1.10
     */
    BrowserCompatible,

    /**
     * @since 1.1.14
     */
    WriteDateUseDateFormat,

    /**
     * @since 1.1.15
     */
    NotWriteRootClassName,

    /**
     * @since 1.1.19
     */
    DisableCheckSpecialChar,

    /**
     * @since 1.1.35
     */
    BeanToArray,

    /**
     * @since 1.1.37
     */
    WriteNonStringKeyAsString,
    
    /**
     * @since 1.1.42
     */
    NotWriteDefaultValue
    ;

    private SerializerFeature(){
        mask = (1 << ordinal());
    }

    private final int mask;

    public final int getMask() {
        return mask;
    }

    public static boolean isEnabled(int features, SerializerFeature feature) {
        return (features & feature.getMask()) != 0;
    }
    
    public static boolean isEnabled(int features, int fieaturesB, SerializerFeature feature) {
        int mask = feature.getMask();
        
        return (features & mask) != 0 || (fieaturesB & mask) != 0;
    }

    public static int config(int features, SerializerFeature feature, boolean state) {
        if (state) {
            features |= feature.getMask();
        } else {
            features &= ~feature.getMask();
        }

        return features;
    }
    
    public static int of(SerializerFeature[] features) {
        if (features == null) {
            return 0;
        }
        
        int value = 0;
        
        for (SerializerFeature feature: features) {
            value |= feature.getMask();
        }
        
        return value;
    }
}

见名知意猜测其是一些对不同值类型的策略处理。具体暂不研究，继续往下看1中主代码逻辑设置好所有的features进入到setFilter中

 private static void setFilter(JSONSerializer serializer, SerializeFilter... filters) {
        for (SerializeFilter filter : filters) {
            setFilter(serializer, filter);
        }
    }

添加进入一个个filter集合进行处理，引入菜鸟的过滤器设计模式可供参考对比理解https://www.runoob.com/design-pattern/filter-pattern.html，我们再一个复杂的业务代码中其实可以参考这个设计模式，特别是需要对数据进行一步步处理的时候来设计，不要仅仅使用模板方法做。可以结合起来进行处理。
进入1中的重头戏serializer.write(object);这才是我们生成json的最终方法，前期的filters与features可以理解为配置下到时候需要用的处理环境。

public final void write(Object object) {
        if (object == null) {
            out.writeNull();
            return;
        }

        Class<?> clazz = object.getClass();
        ObjectSerializer writer = getObjectWriter(clazz);

        try {
            writer.write(this, object, null, null, 0);
        } catch (IOException e) {
            throw new JSONException(e.getMessage(), e);
        }
    }

我们可以看到具体的write方法，与方法入口1相同均用final修饰，是作者硬规定的套路模板方法，不允许后来者肆意修改。提高执行效率。有兴趣可以百度。
到这一步之前与前边类似，我们可以看看com.alibaba.fastjson.serializer.SerializeWriter这个类的结构设计发现其为final类，
在这里插入图片描述
主要继承Writer类进行写的操作。
在write方法中发现ObjectSerializer 此类
在这里插入图片描述

均实现了此接口的write方法

Class<?> clazz = object.getClass();
ObjectSerializer writer = getObjectWriter(clazz);//获得对应obj的ObjectSerializer

在com.alibaba.fastjson.serializer.SerializeConfig类中找到此方法，根据名称发现其采用适配器模式来匹配到对应的类，代码里包含的instance又为工厂与单例的结合运用。此类中在static块中将所有的基本数据类型对应的java类的序列化与反序列化的细节实现。Map.class.isAssignableFrom(clazz)这种写法是为类关系推断，类似于obj instanceof Map 这种对象关系推断。

public ObjectSerializer getObjectWriter(Class<?> clazz) {
        ObjectSerializer writer = get(clazz);

        if (writer == null) {
            try {
                final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
                for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {
                    if (!(o instanceof AutowiredObjectSerializer)) {
                        continue;
                    }

                    AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
                    for (Type forType : autowired.getAutowiredFor()) {
                        put(forType, autowired);
                    }
                }
            } catch (ClassCastException ex) {
                // skip
            }

            writer = get(clazz);
        }

        if (writer == null) {
            final ClassLoader classLoader = JSON.class.getClassLoader();
            if (classLoader != Thread.currentThread().getContextClassLoader()) {
                try {
                    for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {

                        if (!(o instanceof AutowiredObjectSerializer)) {
                            continue;
                        }

                        AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
                        for (Type forType : autowired.getAutowiredFor()) {
                            put(forType, autowired);
                        }
                    }
                } catch (ClassCastException ex) {
                    // skip
                }

                writer = get(clazz);
            }
        }

        if (writer == null) {
            if (Map.class.isAssignableFrom(clazz)) {
                put(clazz, MapSerializer.instance);
            } else if (List.class.isAssignableFrom(clazz)) {
                put(clazz, ListSerializer.instance);
            } else if (Collection.class.isAssignableFrom(clazz)) {
                put(clazz, CollectionSerializer.instance);
            } else if (Date.class.isAssignableFrom(clazz)) {
                put(clazz, DateSerializer.instance);
            } else if (JSONAware.class.isAssignableFrom(clazz)) {
                put(clazz, JSONAwareSerializer.instance);
            } else if (JSONSerializable.class.isAssignableFrom(clazz)) {
                put(clazz, JSONSerializableSerializer.instance);
            } else if (JSONStreamAware.class.isAssignableFrom(clazz)) {
                put(clazz, JSONStreamAwareSerializer.instance);
            } else if (clazz.isEnum() || (clazz.getSuperclass() != null && clazz.getSuperclass().isEnum())) {
                put(clazz, EnumSerializer.instance);
            } else if (clazz.isArray()) {
                Class<?> componentType = clazz.getComponentType();
                ObjectSerializer compObjectSerializer = getObjectWriter(componentType);
                put(clazz, new ArraySerializer(componentType, compObjectSerializer));
            } else if (Throwable.class.isAssignableFrom(clazz)) {
                put(clazz, new ExceptionSerializer(clazz));
            } else if (TimeZone.class.isAssignableFrom(clazz)) {
                put(clazz, TimeZoneCodec.instance);
            } else if (Appendable.class.isAssignableFrom(clazz)) {
                put(clazz, AppendableSerializer.instance);
            } else if (Charset.class.isAssignableFrom(clazz)) {
                put(clazz, CharsetCodec.instance);
            } else if (Enumeration.class.isAssignableFrom(clazz)) {
                put(clazz, EnumerationSeriliazer.instance);
            } else if (Calendar.class.isAssignableFrom(clazz)) {
                put(clazz, CalendarCodec.instance);
            } else if (Clob.class.isAssignableFrom(clazz)) {
                put(clazz, ClobSeriliazer.instance);
            } else {
                boolean isCglibProxy = false;
                boolean isJavassistProxy = false;
                for (Class<?> item : clazz.getInterfaces()) {
                    if (item.getName().equals("net.sf.cglib.proxy.Factory")
                        || item.getName().equals("org.springframework.cglib.proxy.Factory")) {
                        isCglibProxy = true;
                        break;
                    } else if (item.getName().equals("javassist.util.proxy.ProxyObject")) {
                        isJavassistProxy = true;
                        break;
                    }
                }

                if (isCglibProxy || isJavassistProxy) {
                    Class<?> superClazz = clazz.getSuperclass();

                    ObjectSerializer superWriter = getObjectWriter(superClazz);
                    put(clazz, superWriter);
                    return superWriter;
                }

                if (Proxy.isProxyClass(clazz)) {
                    put(clazz, createJavaBeanSerializer(clazz));
                } else {
                    put(clazz, createJavaBeanSerializer(clazz));
                }
            }

            writer = get(clazz);
        }
        return writer;
    }

然后执行真正的write方法，

  writer.write(this, object, null, null, 0);

查看一个常用的map类的write过程com.alibaba.fastjson.serializer.MapSerializer

 public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        SerializeWriter out = serializer.getWriter();

        if (object == null) {
            out.writeNull();
            return;
        }

        Map<?, ?> map = (Map<?, ?>) object;

//        if (out.isEnabled(SerializerFeature.SortField)) {
//            if ((!(map instanceof SortedMap)) && !(map instanceof LinkedHashMap)) {
//                try {
//                    map = new TreeMap(map);
//                } catch (Exception ex) {
//                    // skip
//                }
//            }
//        }

        if (serializer.containsReference(object)) {
            serializer.writeReference(object);
            return;
        }

        SerialContext parent = serializer.getContext();
        serializer.setContext(parent, object, fieldName, 0);
        try {
            out.write('{');

            serializer.incrementIndent();

            Class<?> preClazz = null;
            ObjectSerializer preWriter = null;

            boolean first = true;

            if (out.isEnabled(SerializerFeature.WriteClassName)) {
                out.writeFieldName(JSON.DEFAULT_TYPE_KEY);
                out.writeString(object.getClass().getName());
                first = false;
            }

            for (Map.Entry entry : map.entrySet()) {
                Object value = entry.getValue();

                Object entryKey = entry.getKey();

                {
                    List<PropertyPreFilter> preFilters = serializer.getPropertyPreFiltersDirect();
                    if (preFilters != null && preFilters.size() > 0) {
                        if (entryKey == null || entryKey instanceof String) {
                            if (!FilterUtils.applyName(serializer, object, (String) entryKey)) {
                                continue;
                            }
                        } else if (entryKey.getClass().isPrimitive() || entryKey instanceof Number) {
                            String strKey = JSON.toJSONString(entryKey);
                            if (!FilterUtils.applyName(serializer, object, strKey)) {
                                continue;
                            }
                        }
                    }
                }
                
                {
                    List<PropertyFilter> propertyFilters = serializer.getPropertyFiltersDirect();
                    if (propertyFilters != null && propertyFilters.size() > 0) {
                        if (entryKey == null || entryKey instanceof String) {
                            if (!FilterUtils.apply(serializer, object, (String) entryKey, value)) {
                                continue;
                            }
                        } else if (entryKey.getClass().isPrimitive() || entryKey instanceof Number) {
                            String strKey = JSON.toJSONString(entryKey);
                            if (!FilterUtils.apply(serializer, object, strKey, value)) {
                                continue;
                            }
                        }
                    }
                }
                
                {
                    List<NameFilter> nameFilters = serializer.getNameFiltersDirect();
                    if (nameFilters != null && nameFilters.size() > 0) {
                        if (entryKey == null || entryKey instanceof String) {
                            entryKey = FilterUtils.processKey(serializer, object, (String) entryKey, value);
                        } else if (entryKey.getClass().isPrimitive() || entryKey instanceof Number) {
                            String strKey = JSON.toJSONString(entryKey);
                            entryKey = FilterUtils.processKey(serializer, object, strKey, value);
                        }
                    }
                }
                
                {
                    List<ValueFilter> valueFilters = serializer.getValueFiltersDirect();
                    if (valueFilters != null && valueFilters.size() > 0) {
                        if (entryKey == null || entryKey instanceof String) {
                            value = FilterUtils.processValue(serializer, object, (String) entryKey, value);
                        } else if (entryKey.getClass().isPrimitive() || entryKey instanceof Number) {
                            String strKey = JSON.toJSONString(entryKey);
                            value = FilterUtils.processValue(serializer, object, strKey, value);
                        }
                    }
                }
                
                if (value == null) {
                    if (!serializer.isEnabled(SerializerFeature.WriteMapNullValue)) {
                        continue;
                    }
                }

                if (entryKey instanceof String) {
                    String key = (String) entryKey;

                    if (!first) {
                        out.write(',');
                    }

                    if (out.isEnabled(SerializerFeature.PrettyFormat)) {
                        serializer.println();
                    }
                    out.writeFieldName(key, true);
                } else {
                    if (!first) {
                        out.write(',');
                    }

                    if (out.isEnabled(SerializerFeature.BrowserCompatible)
                        || out.isEnabled(SerializerFeature.WriteNonStringKeyAsString)) {
                        String strEntryKey = JSON.toJSONString(entryKey);
                        serializer.write(strEntryKey);
                    } else {
                        serializer.write(entryKey);
                    }

                    out.write(':');
                }

                first = false;

                if (value == null) {
                    out.writeNull();
                    continue;
                }

                Class<?> clazz = value.getClass();

                if (clazz == preClazz) {
                    preWriter.write(serializer, value, entryKey, null, 0);
                } else {
                    preClazz = clazz;
                    preWriter = serializer.getObjectWriter(clazz);

                    preWriter.write(serializer, value, entryKey, null, 0);
                }
            }
        } finally {
            serializer.setContext(parent);
        }

        serializer.decrementIdent();
        if (out.isEnabled(SerializerFeature.PrettyFormat) && map.size() > 0) {
            serializer.println();
        }
        out.write('}');
    }

所有的内容都输入进了SerializeWriter类，进入了下边方法

  public void write(char c) {
        int newcount = count + 1;
        if (newcount > buf.length) {
            if (writer == null) {
                expandCapacity(newcount);
            } else {
                flush();
                newcount = 1;
            }
        }
        buf[count] = c;
        count = newcount;
    }

我们看到了buf数组
回到入口方法

  public static final String toJSONString(Object object, SerializeFilter[] filters, SerializerFeature... features) {
        SerializeWriter out = new SerializeWriter();

        try {
            JSONSerializer serializer = new JSONSerializer(out);
            for (com.alibaba.fastjson.serializer.SerializerFeature feature : features) {
                serializer.config(feature, true);
            }

            serializer.config(SerializerFeature.WriteDateUseDateFormat, true);

            setFilter(serializer, filters);

            serializer.write(object);

            return out.toString();
        } finally {
            out.close();
        }
    }

进入out.toString观看

   public String toString() {
        return new String(buf, 0, count);
    }

指向了同一个buf数组，处理完成。

结束

大体流程如此，里边当然有许多优秀的细节由于技术功底问题没有看得到，哪里有理解的不对烦请大佬留言促进鄙人进步。

补充

着急下班撤退差点忘记将SerializerFeature与上边将的SerializerFilter的使用位置忘记将，直接进入上边的com.fastjson.serializer.MapSerializer的write方法中便可以发现其处理的过程

  if (out.isEnabled(SerializerFeature.WriteClassName)) {
                out.writeFieldName(JSON.DEFAULT_TYPE_KEY);
                out.writeString(object.getClass().getName());
                first = false;
            }

 List<PropertyFilter> propertyFilters = serializer.getPropertyFiltersDirect();
                    if (propertyFilters != null && propertyFilters.size() > 0) {
                        if (entryKey == null || entryKey instanceof String) {
                            if (!FilterUtils.apply(serializer, object, (String) entryKey, value)) {
                                continue;
                            }
                        } else if (entryKey.getClass().isPrimitive() || entryKey instanceof Number) {
                            String strKey = JSON.toJSONString(entryKey);
                            if (!FilterUtils.apply(serializer, object, strKey, value)) {
                                continue;
                            }
                        }
                    }

看这个apply出现了吧，进入观察

public static boolean apply(JSONSerializer serializer, Object object, String key, Object propertyValue) {
        List<PropertyFilter> propertyFilters = serializer.getPropertyFiltersDirect();

        if (propertyFilters == null) {
            return true;
        }

        for (PropertyFilter propertyFilter : propertyFilters) {
            if (!propertyFilter.apply(object, key, propertyValue)) {
                return false;
            }
        }

        return true;
    }

因此我们可以在其中添加自己的值，属性处理逻辑来控制结果的生成

米修斯的橘子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fastjson深度源码解析- 序列化(二) - 序列化字节和字符串解析
商宗海的博客
02-04 2167
SerializeWriter成员函数 序列化16进制字节数组 public void writeHex(byte[] bytes) { /** 计算总共字符长度, 乘以2 代表一个字符要占用2字节, 3代表要添加 x 和 前后添加' */ int newcount = count + bytes.length * 2 + 3;
fastjson源码
02-22
fastjson源码，
FastJson源码解读
yeshen.org
09-21 632
抽点时间接着写吧。 fastjson也是一个json的解析库，业内挺有名的。github地址是：https://github.com/alibaba/fastjson jar包地址下载地址可以是：http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22com.alibaba%22%20AND%20a%3A%22fastjson%22 简单用法是：
阿里巴巴fastjson升级到fastjson2之SerializerFeature无效解决方案
netuser1937的博客
05-06 1278
阿里巴巴fastjson升级到fastjson2之SerializerFeature无效解决方案
fastjson源码分析1-综述
qq_45946035的博客
09-11 797
2021SC@SDUSC 目录综合分析1.fastjson的简单介绍2.简单使用（1）将java对象转换为json格式（2）将json对象转回为java对象3.源代码主要结构源码结构JSON类主要类的类图fastjson工作方式的分析主要包的结构分析annotation包asm包小组分工情况 综合分析 1.fastjson的简单介绍 Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。 Fastjson 可以操作任何
fastjson源码解析-设计分析总结
qq_45946035的博客
09-11 1919
2021SC@SDUSC 简介 本篇是fastjson源码分析的最后一篇，本篇的主要内容是对之前分析过程中的流程做个总结，并总结在之前fastjson中分析到的设计模式； 类间关系 下面以类图的形式给出类间关系的总览： 图中的JSON抽象类是入口类，它提供了大量的静态方法；JSONObject类用于存储返回对象，继承自JSON抽象类；DefaultJSONParser类是解析器，它依赖于JSONObject类、JSONLexer接口、JSONLexerBase抽象类、ObjectDeserializer接
fastJSON源码分析综述
A1ex的博客
09-29 175
综述
fastJson的toJSONString解读
woqu000000的博客
06-15 6956
fastJson的toJSONString解读 先从一个小问题上我们抛砖引玉一下 首先我们先做准备工作 我们声明一个bean public class YunmiStoreStr { public String gome; ​ public YunmiStoreStr(String gome) { this.gome = gome; } ​ } ...
fastjson源码解析——反序列化特辑（一）
lllhhhyyy999的博客
10-27 397
2021SC@SDUSC 本文在个人博客同步发出，地址fastjson源码解析——反序列化特辑（一） 文章目录概要正式开始已注册的类型最后 概要 上篇fastjson源码解析——反序列化（三）详细介绍了fastjson如何创建无反序列化实例类的反序列化实例，介绍了如何通过java.lang.reflect查询到所有的Getter/Setter方法。 本期是一个特辑，专门介绍反序列化接口实现方法中，对已知类型类的反序列化实例的内部注册。 正式开始 在上期中，我提到了 对不同的Getter/Setter做
fastjson源码解析——反序列化特辑（二）
lllhhhyyy999的博客
11-05 859
2021SC@SDUSC 本文在个人博客同步发出，地址fastjson源码解析——反序列化特辑（二） 文章目录概要正式开始1. `BooleanCodec`反序列化2. `CharacterCodec`反序列化3. `IntegerCodec`反序列化4. `FloatCodec`反序列化5. `JavaBeanDeserializer`反序列化最后 概要 上一期特辑fastjson源码解析——反序列化特辑（一）详细列举了fastjson内部所有已经被注册的各类型的反序列化实例，同时惊奇地发现，所有的反
Fastjson源码分析—反序列化—Token的定义和解析(1)
qq_45854465的博客
10-06 1112
021SC@SDUSC 深度解析Fastjson中的TokenToken定义Token类型解析JSONLexerBase成员变量JSONLexerBase解析方法 Token定义 Token是Fastjson中定义的json字符串的同类型字段，即"{"、"["、数字、字符串等，用于分隔json字符串不同字段。 例如，{“姓名”：“张三”,“年龄”:“20”}是一个json字符串，在反序列化之前，需要先将其解析为 { 、 姓名、 ：、 张三、 ,、 年龄、 ：、 20、 }这些字段的Token流，随后再
fastjson-master源码
10-17
《深入解析Fastjson源码》 Fastjson是阿里巴巴开源的一款高性能的Java JSON库，它能够实现JSON和Java对象之间的快速转换。在Web开发中，数据交换格式的选择至关重要，JSON因其简洁、易于理解和处理的特性，成为了...
fastjson2 最新源码
06-16
fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码fastjson2 最新源码...
fastjson1.2.7含源码
05-28
Fastjson1.2.7是该库的一个版本，包含了源码，使得开发者可以深入理解其内部实现机制，进行定制化开发或者调试。 在Fastjson中，主要涉及以下几个核心概念和功能： 1. **JSON到Java对象转换**：Fastjson提供了`...
Cannot find module ‘html-webpack-plugin
qq_43071699的博客
07-26 381
安装。在Webpack配置文件中正确引用。清除缓存并重新安装依赖（如果需要）。确保Webpack版本与兼容。检查文件。按照这些步骤操作，你应该能够解决的问题。如果问题仍然存在，请提供更多信息，以便进一步诊断。
HTTP请求入参类型解读
Bekind2010的专栏
07-24 1074
在HTTP请求中，请求头用于指示资源的MIME类型，即请求体的媒体类型。它告诉服务器实际发送的数据类型是什么，以便服务器能够正确地解析和处理这些数据。可以有多种值，每种值都对应着不同的媒体类型。以下是一些常见的?enctypeenctypeform-datatext/plaintext/plaintext/htmltext/htmltext/xmltext/xmltext/xml每种都对应着不同的数据格式和用途，选择合适的对于确保数据被正确解析和处理至关重要。
PyCharm 常用 的插件
最新发布
u013934107的博客
07-27 168
PyCharm 常用 的插件
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 592
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值