1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
package com.fasterxml.jackson.databind.introspect;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.type.SimpleType;
public class BasicClassIntrospector
extends ClassIntrospector
{
/* We keep a small set of pre-constructed descriptions to use for
* common non-structured values, such as Numbers and Strings.
* This is strictly performance optimization to reduce what is
* usually one-time cost, but seems useful for some cases considering
* simplicity.
*/
protected final static BasicBeanDescription STRING_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(String.class, null, null);
STRING_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(String.class), ac);
}
protected final static BasicBeanDescription BOOLEAN_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Boolean.TYPE, null, null);
BOOLEAN_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Boolean.TYPE), ac);
}
protected final static BasicBeanDescription INT_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Integer.TYPE, null, null);
INT_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Integer.TYPE), ac);
}
protected final static BasicBeanDescription LONG_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Long.TYPE, null, null);
LONG_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Long.TYPE), ac);
}
/*
/**********************************************************
/* Life cycle
/**********************************************************
*/
public final static BasicClassIntrospector instance = new BasicClassIntrospector();
public BasicClassIntrospector() { }
/*
/**********************************************************
/* Factory method impls
/**********************************************************
*/
@Override
public BasicBeanDescription forSerialization(SerializationConfig cfg,
JavaType type, MixInResolver r)
{
// minor optimization: for JDK types do minimal introspection
BasicBeanDescription desc = _findCachedDesc(type);
if (desc == null) {
desc = BasicBeanDescription.forSerialization(collectProperties(cfg, type, r, true));
}
return desc;
}
@Override
public BasicBeanDescription forDeserialization(DeserializationConfig cfg,
JavaType type, MixInResolver r)
{
// minor optimization: for JDK types do minimal introspection
BasicBeanDescription desc = _findCachedDesc(type);
if (desc == null) {
desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
}
return desc;
}
@Override
public BasicBeanDescription forCreation(DeserializationConfig cfg,
JavaType type, MixInResolver r)
{
BasicBeanDescription desc = _findCachedDesc(type);
if (desc == null) {
desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
}
return desc;
}
@Override
public BasicBeanDescription forClassAnnotations(MapperConfig<?> cfg,
JavaType type, MixInResolver r)
{
boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(),
(useAnnotations ? cfg.getAnnotationIntrospector() : null), r);
return BasicBeanDescription.forOtherUse(cfg, type, ac);
}
@Override
public BasicBeanDescription forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type, MixInResolver r)
{
boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
AnnotationIntrospector ai = cfg.getAnnotationIntrospector();
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(type.getRawClass(),
(useAnnotations ? ai : null), r);
return BasicBeanDescription.forOtherUse(cfg, type, ac);
}
/*
/**********************************************************
/* Overridable helper methods
/**********************************************************
*/
protected POJOPropertiesCollector collectProperties(MapperConfig<?> config,
JavaType type, MixInResolver r, boolean forSerialization)
{
boolean useAnnotations = config.isAnnotationProcessingEnabled();
AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(),
(useAnnotations ? config.getAnnotationIntrospector() : null), r);
return constructPropertyCollector(config, ac, type, forSerialization).collect();
}
/**
* Overridable method called for creating {@link POJOPropertiesCollector} instance
* to use; override is needed if a custom sub-class is to be used.
*/
protected POJOPropertiesCollector constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass ac, JavaType type,
boolean forSerialization)
{
return new POJOPropertiesCollector(config, forSerialization, type, ac);
}
/**
* Method called to see if type is one of core JDK types
* that we have cached for efficiency.
*/
protected BasicBeanDescription _findCachedDesc(JavaType type)
{
Class<?> cls = type.getRawClass();
if (cls == String.class) {
return STRING_DESC;
}
if (cls == Boolean.TYPE) {
return BOOLEAN_DESC;
}
if (cls == Integer.TYPE) {
return INT_DESC;
}
if (cls == Long.TYPE) {
return LONG_DESC;
}
return null;
}
}
|
