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
161
162
163
164
165
166
167
|
package com.fasterxml.jackson.annotation;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import javax.swing.text.html.HTMLDocument;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* Annotation that can be used to either only include serialization of
* properties (during serialization), or only include processing of
* JSON properties read (during deserialization).
* <p>
* Example:
* <pre>
* // to only include specified fields from being serialized or deserialized
* // (i.e. only include in JSON output; or being set even if they were included)
* @JsonIncludeProperties({ "internalId", "secretKey" })
* </pre>
* <p>
* Annotation can be applied both to classes and
* to properties. If used for both, actual set will be union of all
* includes: that is, you can only add properties to include, not remove
* or override. So you can not remove properties to include using
* per-property annotation.
*
* @since 2.12
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotation
public @interface JsonIncludeProperties
{
/**
* Names of properties to include.
*/
public String[] value() default {};
/*
/**********************************************************
/* Value class used to enclose information, allow for
/* merging of layered configuration settings.
/**********************************************************
*/
/**
* Helper class used to contain information from a single {@link JsonIncludeProperties}
* annotation, as well as to provide possible overrides from non-annotation sources.
*
* @since 2.12
*/
public static class Value implements JacksonAnnotationValue<JsonIncludeProperties>, java.io.Serializable
{
private static final long serialVersionUID = 1L;
/**
* Default instance has no explicitly included fields
*/
protected final static JsonIncludeProperties.Value ALL = new JsonIncludeProperties.Value(null);
/**
* Name of the properties to include.
* Null means that all properties are included, empty means none.
*/
protected final Set<String> _included;
protected Value(Set<String> included)
{
_included = included;
}
public static JsonIncludeProperties.Value from(JsonIncludeProperties src)
{
if (src == null) {
return ALL;
}
return new Value(_asSet(src.value()));
}
public static JsonIncludeProperties.Value all()
{
return ALL;
}
@Override
public Class<JsonIncludeProperties> valueFor()
{
return JsonIncludeProperties.class;
}
public Set<String> getIncluded()
{
return _included;
}
/**
* Mutant factory method to override the current value with an another, merging the included fields.
*/
public JsonIncludeProperties.Value withOverrides(JsonIncludeProperties.Value overrides) {
if (overrides == null || overrides.getIncluded() == null) {
return this;
}
if (_included == null) {
return overrides;
}
HashSet<String> included = new HashSet<String>(_included);
Iterator<String> iterator = included.iterator();
while (iterator.hasNext()) {
if (!overrides.getIncluded().contains(iterator.next())) {
iterator.remove();
}
}
return new JsonIncludeProperties.Value(new HashSet<String>(included));
}
@Override
public String toString() {
return String.format("JsonIncludeProperties.Value(included=%s)",
_included);
}
@Override
public int hashCode() {
return (_included == null ? 0 : _included.size())
;
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null) return false;
return (o.getClass() == getClass())
&& _equals(this, (Value) o);
}
private static boolean _equals(Value a, Value b)
{
return a._included == null ? b._included == null :
// keep this last just because it can be expensive
a._included.equals(b._included)
;
}
private static Set<String> _asSet(String[] v)
{
if (v == null || v.length == 0) {
return Collections.emptySet();
}
Set<String> s = new HashSet<String>(v.length);
for (String str : v) {
s.add(str);
}
return s;
}
}
}
|
