public class Group {

    private Long       id;
    private String     name;
    private List<User> users = new ArrayList<User>();
}

public class User {

    private Long   id;
    private String name;
}

Group group = new Group();
group.setId(0L);
group.setName("admin");

User guestUser = new User();
guestUser.setId(2L);
guestUser.setName("guest");

User rootUser = new User();
rootUser.setId(3L);
rootUser.setName("root");

group.addUser(guestUser);
group.addUser(rootUser);

String jsonString = JSON.toJSONString(group);
System.out.println(jsonString);

Group bean = JSON.parseObject(jsonString, Group.class);

@JSONField(name="ID")
public int getId() {return id;}

// 配置date序列化和反序列使用yyyyMMdd日期格式
@JSONField(format="yyyyMMdd")
public Date date1;

// 不序列化
@JSONField(serialize=false)
public Date date2;

// 不反序列化
@JSONField(deserialize=false)
public Date date3;

// 按ordinal排序
@JSONField(ordinal = 2)
private int f1;

@JSONField(ordinal = 1)
private int f2;

@JSONType(alphabetic = false)
public static class B {
    public int f2;
    public int f1;
    public int f0;
}

ObjectMapper mapper = new ObjectMapper();

mapper.writeValue(new File("result.json"), myResultObject);
// or:
byte[] jsonBytes = mapper.writeValueAsBytes(myResultObject);
// or:
String jsonString = mapper.writeValueAsString(myResultObject);

ObjectMapper mapper = new ObjectMapper();

MyValue value = mapper.readValue(new File("data.json"), MyValue.class);
// or:
value = mapper.readValue(new URL("http://some.com/api/entry.json"), MyValue.class);
// or:
value = mapper.readValue("{\"name\":\"Bob\", \"age\":13}", MyValue.class);

Person p = new Person("Tom", 20);
Person p2 = new Person("Jack", 22);
Person p3 = new Person("Mary", 18);

List<Person> persons = new LinkedList<>();
persons.add(p);
persons.add(p2);
persons.add(p3);

Map<String, List> map = new HashMap<>();
map.put("persons", persons);

String json = null;
try {
 json = mapper.writeValueAsString(map);
} catch (JsonProcessingException e) {
 e.printStackTrace();
}

public class MyBean {
   private String _name;

   // without annotation, we'd get "theName", but we want "name":
   @JsonProperty("name")
   public String getTheName() { return _name; }

   // note: it is enough to add annotation on just getter OR setter;
   // so we can omit it here
   public void setTheName(String n) { _name = n; }
}

// means that if we see "foo" or "bar" in JSON, they will be quietly skipped
// regardless of whether POJO has such properties
@JsonIgnoreProperties({ "foo", "bar" })
public class MyBean {
   // will not be written as JSON; nor assigned from JSON:
   @JsonIgnore
   public String internal;

   // no annotation, public field is read/written normally
   public String external;

   @JsonIgnore
   public void setCode(int c) { _code = c; }

   // note: will also be ignored because setter has annotation!
   public int getCode() { return _code; }
}

public class CtorBean {
  public final String name;
  public final int age;

  @JsonCreator // constructor can be public, private, whatever
  private CtorBean(@JsonProperty("name") String name,
    @JsonProperty("age") int age)
  {
      this.name = name;
      this.age = age;
  }
}

@JsonPropertyOrder(alphabetic = true)
public class JacksonAnnotationBean {}

Gson gson = new Gson();
gson.toJson(1);            // ==> 1
gson.toJson("abcd");       // ==> "abcd"
gson.toJson(10L); // ==> 10
int[] values = { 1 };
gson.toJson(values);       // ==> [1]

int i1 = gson.fromJson("1", int.class);
Integer i2 = gson.fromJson("1", Integer.class);
Long l1 = gson.fromJson("1", Long.class);
Boolean b1 = gson.fromJson("false", Boolean.class);
String str = gson.fromJson("\"abc\"", String.class);
String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);

Gson gson = new GsonBuilder()
  .setPrettyPrinting()
  .setDateFormat("yyyy-MM-dd HH:mm:ss")
  .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT, Modifier.VOLATILE)
  .create();

public class VersionedClass {
  @Since(1.1) private final String newerField;
  @Since(1.0) private final String newField;
  private final String field;

  public VersionedClass() {
    this.newerField = "newer";
    this.newField = "new";
    this.field = "old";
  }
}

VersionedClass versionedObject = new VersionedClass();
Gson gson = new GsonBuilder().setVersion(1.0).create();
String jsonOutput = gson.toJson(versionedObject);
System.out.println(jsonOutput);
System.out.println();

gson = new Gson();
jsonOutput = gson.toJson(versionedObject);
System.out.println(jsonOutput);

private class SomeObject {
  @SerializedName("custom_naming") private final String someField;
  private final String someOtherField;

  public SomeObject(String a, String b) {
    this.someField = a;
    this.someOtherField = b;
  }
}

import org.nustaq.serialization.FSTConfiguration;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class FstDemo {

 private static FSTConfiguration DEFAULT_CONFIG = FSTConfiguration.createDefaultConfiguration();

 /**
  * 将对象序列化为 byte 数组
  *
  * @param obj 任意对象
  * @param <T> 对象的类型
  * @return 序列化后的 byte 数组
  */
 public static <T> byte[] writeToBytes(T obj) {
  return DEFAULT_CONFIG.asByteArray(obj);
 }

 /**
  * 将对象序列化为 byte 数组后，再使用 Base64 编码
  *
  * @param obj 任意对象
  * @param <T> 对象的类型
  * @return 序列化后的字符串
  */
 public static <T> String writeToString(T obj) {
  byte[] bytes = writeToBytes(obj);
  return new String(Base64.getEncoder().encode(bytes), StandardCharsets.UTF_8);
 }

 /**
  * 将 byte 数组反序列化为原对象
  *
  * @param bytes {@link #writeToBytes} 方法序列化后的 byte 数组
  * @param clazz 原对象的类型
  * @param <T>   原对象的类型
  * @return 原对象
  */
 public static <T> T readFromBytes(byte[] bytes, Class<T> clazz) throws IOException {
  Object obj = DEFAULT_CONFIG.asObject(bytes);
  if (clazz.isInstance(obj)) {
   return (T) obj;
  } else {
   throw new IOException("derialize failed");
  }
 }

 /**
  * 将字符串反序列化为原对象，先使用 Base64 解码
  *
  * @param str   {@link #writeToString} 方法序列化后的字符串
  * @param clazz 原对象的类型
  * @param <T>   原对象的类型
  * @return 原对象
  */
 public static <T> T readFromString(String str, Class<T> clazz) throws IOException {
  byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
  return readFromBytes(Base64.getDecoder().decode(bytes), clazz);
 }

}

long begin = System.currentTimeMillis();
for (int i = 0; i < BATCH_SIZE; i++) {
    TestBean oldBean = BeanUtils.initJdk8Bean();
    byte[] bytes = FstDemo.writeToBytes(oldBean);
    TestBean newBean = FstDemo.readFromBytes(bytes, TestBean.class);
}
long end = System.currentTimeMillis();
System.out.printf("FST 序列化/反序列化耗时：%s", (end - begin));

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
import org.objenesis.strategy.StdInstantiatorStrategy;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class KryoDemo {

 // 每个线程的 Kryo 实例
 private static final ThreadLocal<Kryo> kryoLocal = ThreadLocal.withInitial(() -> {
  Kryo kryo = new Kryo();

  /**
   * 不要轻易改变这里的配置！更改之后，序列化的格式就会发生变化，
   * 上线的同时就必须清除 Redis 里的所有缓存，
   * 否则那些缓存再回来反序列化的时候，就会报错
   */
  //支持对象循环引用（否则会栈溢出）
  kryo.setReferences(true); //默认值就是 true，添加此行的目的是为了提醒维护者，不要改变这个配置

  //不强制要求注册类（注册行为无法保证多个 JVM 内同一个类的注册编号相同；而且业务系统中大量的 Class 也难以一一注册）
  kryo.setRegistrationRequired(false); //默认值就是 false，添加此行的目的是为了提醒维护者，不要改变这个配置

  //Fix the NPE bug when deserializing Collections.
  ((DefaultInstantiatorStrategy) kryo.getInstantiatorStrategy())
   .setFallbackInstantiatorStrategy(new StdInstantiatorStrategy());

  return kryo;
 });

 /**
  * 获得当前线程的 Kryo 实例
  *
  * @return 当前线程的 Kryo 实例
  */
 public static Kryo getInstance() {
  return kryoLocal.get();
 }

 /**
  * 将对象序列化为 byte 数组
  *
  * @param obj 任意对象
  * @param <T> 对象的类型
  * @return 序列化后的 byte 数组
  */
 public static <T> byte[] writeToBytes(T obj) {
  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  Output output = new Output(byteArrayOutputStream);

  Kryo kryo = getInstance();
  kryo.writeObject(output, obj);
  output.flush();

  return byteArrayOutputStream.toByteArray();
 }

 /**
  * 将对象序列化为 byte 数组后，再使用 Base64 编码
  *
  * @param obj 任意对象
  * @param <T> 对象的类型
  * @return 序列化后的字符串
  */
 public static <T> String writeToString(T obj) {
  byte[] bytes = writeToBytes(obj);
  return new String(Base64.getEncoder().encode(bytes), StandardCharsets.UTF_8);
 }

 /**
  * 将 byte 数组反序列化为原对象
  *
  * @param bytes {@link #writeToBytes} 方法序列化后的 byte 数组
  * @param clazz 原对象的类型
  * @param <T>   原对象的类型
  * @return 原对象
  */
 @SuppressWarnings("unchecked")
 public static <T> T readFromBytes(byte[] bytes, Class<T> clazz) {
  ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
  Input input = new Input(byteArrayInputStream);

  Kryo kryo = getInstance();
  return (T) kryo.readObject(input, clazz);
 }

 /**
  * 将字符串反序列化为原对象，先使用 Base64 解码
  *
  * @param str   {@link #writeToString} 方法序列化后的字符串
  * @param clazz 原对象的类型
  * @param <T>   原对象的类型
  * @return 原对象
  */
 public static <T> T readFromString(String str, Class<T> clazz) {
  byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
  return readFromBytes(Base64.getDecoder().decode(bytes), clazz);
 }

}

long begin = System.currentTimeMillis();
for (int i = 0; i < BATCH_SIZE; i++) {
    TestBean oldBean = BeanUtils.initJdk8Bean();
    byte[] bytes = KryoDemo.writeToBytes(oldBean);
    TestBean newBean = KryoDemo.readFromBytes(bytes, TestBean.class);
}
long end = System.currentTimeMillis();
System.out.printf("Kryo 序列化/反序列化耗时：%s", (end - begin));

Student student = new Student();
student.setNo(101);
student.setName("HESSIAN");
//把student对象转化为byte数组
ByteArrayOutputStream bos = new ByteArrayOutputStream();
Hessian2Output output = new Hessian2Output(bos);
output.writeObject(student);
output.flushBuffer();
byte[] data = bos.toByteArray();
bos.close();
//把刚才序列化出来的byte数组转化为student对象
ByteArrayInputStream bis = new ByteArrayInputStream(data);
Hessian2Input input = new Hessian2Input(bis);
Student deStudent = (Student) input.readObject();
input.close();
System.out.println(deStudent);

@Getter @Setter private boolean employed = true;
@Setter(AccessLevel.PROTECTED) private String name;

private boolean employed = true;
private String name;

public boolean isEmployed() {
    return employed;
}

public void setEmployed(final boolean employed) {
    this.employed = employed;
}

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

@Getter @Setter @NonNull
private List<Person> members;

@NonNull
private List<Person> members;

public Family(@NonNull final List<Person> members) {
    if (members == null) throw new java.lang.NullPointerException("members");
    this.members = members;
}

@NonNull
public List<Person> getMembers() {
    return members;
}

public void setMembers(@NonNull final List<Person> members) {
    if (members == null) throw new java.lang.NullPointerException("members");
    this.members = members;
}

@ToString(callSuper=true,exclude="someExcludedField")
public class Foo extends Bar {
    private boolean someBoolean = true;
    private String someStringField;
    private float someExcludedField;
}

public class Foo extends Bar {
    private boolean someBoolean = true;
    private String someStringField;
    private float someExcludedField;

    @java.lang.Override
    public java.lang.String toString() {
        return "Foo(super=" + super.toString() +
            ", someBoolean=" + someBoolean +
            ", someStringField=" + someStringField + ")";
    }
}

@EqualsAndHashCode(callSuper=true,exclude={"address","city","state","zip"})
public class Person extends SentientBeing {
    enum Gender { Male, Female }

    @NonNull private String name;
    @NonNull private Gender gender;

    private String ssn;
    private String address;
    private String city;
    private String state;
    private String zip;
}

public class Person extends SentientBeing {

    enum Gender {
        /*public static final*/ Male /* = new Gender() */,
        /*public static final*/ Female /* = new Gender() */;
    }
    @NonNull
    private String name;
    @NonNull
    private Gender gender;
    private String ssn;
    private String address;
    private String city;
    private String state;
    private String zip;

    @java.lang.Override
    public boolean equals(final java.lang.Object o) {
        if (o == this) return true;
        if (o == null) return false;
        if (o.getClass() != this.getClass()) return false;
        if (!super.equals(o)) return false;
        final Person other = (Person)o;
        if (this.name == null ? other.name != null : !this.name.equals(other.name)) return false;
        if (this.gender == null ? other.gender != null : !this.gender.equals(other.gender)) return false;
        if (this.ssn == null ? other.ssn != null : !this.ssn.equals(other.ssn)) return false;
        return true;
    }

    @java.lang.Override
    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = result * PRIME + super.hashCode();
        result = result * PRIME + (this.name == null ? 0 : this.name.hashCode());
        result = result * PRIME + (this.gender == null ? 0 : this.gender.hashCode());
        result = result * PRIME + (this.ssn == null ? 0 : this.ssn.hashCode());
        return result;
    }
}

@Data(staticConstructor="of")
public class Company {
    private final Person founder;
    private String name;
    private List<Person> employees;
}

public class Company {
    private final Person founder;
    private String name;
    private List<Person> employees;

    private Company(final Person founder) {
        this.founder = founder;
    }

    public static Company of(final Person founder) {
        return new Company(founder);
    }

    public Person getFounder() {
        return founder;
    }

    public String getName() {
        return name;
    }

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

    public List<Person> getEmployees() {
        return employees;
    }

    public void setEmployees(final List<Person> employees) {
        this.employees = employees;
    }

    @java.lang.Override
    public boolean equals(final java.lang.Object o) {
        if (o == this) return true;
        if (o == null) return false;
        if (o.getClass() != this.getClass()) return false;
        final Company other = (Company)o;
        if (this.founder == null ? other.founder != null : !this.founder.equals(other.founder)) return false;
        if (this.name == null ? other.name != null : !this.name.equals(other.name)) return false;
        if (this.employees == null ? other.employees != null : !this.employees.equals(other.employees)) return false;
        return true;
    }

    @java.lang.Override
    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = result * PRIME + (this.founder == null ? 0 : this.founder.hashCode());
        result = result * PRIME + (this.name == null ? 0 : this.name.hashCode());
        result = result * PRIME + (this.employees == null ? 0 : this.employees.hashCode());
        return result;
    }

    @java.lang.Override
    public java.lang.String toString() {
        return "Company(founder=" + founder + ", name=" + name + ", employees=" + employees + ")";
    }
}

public void testCleanUp() {
    try {
        @Cleanup ByteArrayOutputStream baos = new ByteArrayOutputStream();
        baos.write(new byte[] {'Y','e','s'});
        System.out.println(baos.toString());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void testCleanUp() {
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            baos.write(new byte[]{'Y', 'e', 's'});
            System.out.println(baos.toString());
        } finally {
            baos.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private DateFormat format = new SimpleDateFormat("MM-dd-YYYY");

@Synchronized
public String synchronizedFormat(Date date) {
    return format.format(date);
}

private final java.lang.Object $lock = new java.lang.Object[0];
private DateFormat format = new SimpleDateFormat("MM-dd-YYYY");

public String synchronizedFormat(Date date) {
    synchronized ($lock) {
        return format.format(date);
    }
}

@SneakyThrows
public void testSneakyThrows() {
    throw new IllegalAccessException();
}

public void testSneakyThrows() {
    try {
        throw new IllegalAccessException();
    } catch (java.lang.Throwable $ex) {
        throw lombok.Lombok.sneakyThrow($ex);
    }
}

@Data
@Builder
public class BuilderDemo01 {

    private String name;

    public static void main(String[] args) throws JsonProcessingException {
        BuilderDemo01 demo01 = BuilderDemo01.builder().name("demo01").build();
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(demo01);
        BuilderDemo01 expectDemo01 = mapper.readValue(json, BuilderDemo01.class);
        System.out.println(expectDemo01.toString());
    }

}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BuilderDemo02 {

    private String name;

    public static void main(String[] args) throws JsonProcessingException {
        BuilderDemo02 demo02 = BuilderDemo02.builder().name("demo01").build();
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(demo02);
        BuilderDemo02 expectDemo02 = mapper.readValue(json, BuilderDemo02.class);
        System.out.println(expectDemo02.toString());
    }

}

@Data
@ToString(exclude = "age")
@EqualsAndHashCode(exclude = { "age", "sex" })
public class Person {

    protected String name;

    protected Integer age;

    protected String sex;

}

@Data
@EqualsAndHashCode(callSuper = true, exclude = { "address", "city", "state", "zip" })
public class EqualsAndHashCodeDemo extends Person {

    @NonNull
    private String name;

    @NonNull
    private Gender gender;

    private String ssn;

    private String address;

    private String city;

    private String state;

    private String zip;

    public EqualsAndHashCodeDemo(@NonNull String name, @NonNull Gender gender) {
        this.name = name;
        this.gender = gender;
    }

    public EqualsAndHashCodeDemo(@NonNull String name, @NonNull Gender gender,
        String ssn, String address, String city, String state, String zip) {
        this.name = name;
        this.gender = gender;
        this.ssn = ssn;
        this.address = address;
        this.city = city;
        this.state = state;
        this.zip = zip;
    }

    public enum Gender {
        Male,
        Female
    }

}

@Test
@DisplayName("测试 @EqualsAndHashCode")
public void testEqualsAndHashCodeDemo() {
    EqualsAndHashCodeDemo demo1 =
        new EqualsAndHashCodeDemo("name1", EqualsAndHashCodeDemo.Gender.Female, "ssn", "xxx", "xxx", "xxx", "xxx");
    EqualsAndHashCodeDemo demo2 =
        new EqualsAndHashCodeDemo("name1", EqualsAndHashCodeDemo.Gender.Female, "ssn", "ooo", "ooo", "ooo", "ooo");
    Assertions.assertEquals(demo1, demo2);

    Person person = new Person();
    person.setName("张三");
    person.setAge(20);
    person.setSex("男");

    Person person2 = new Person();
    person2.setName("张三");
    person2.setAge(18);
    person2.setSex("男");

    Person person3 = new Person();
    person3.setName("李四");
    person3.setAge(20);
    person3.setSex("男");

    Assertions.assertEquals(person2, person);
    Assertions.assertNotEquals(person3, person);
}

public class NotSameAttributeA {
    private long id;
    private String name;
    private Date date;

    // 省略getter/setter
}

public class NotSameAttributeB {
    private long id;
    private String value;
    private Date date;

    // 省略getter/setter
}

Mapper mapper = new DozerBeanMapper();
DestinationObject destObject =
    mapper.map(sourceObject, DestinationObject.class);

RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring/spring-dozer.xml"})
@TransactionConfiguration(defaultRollback = false)
public class DozerTest extends TestCase {
    @Autowired
    Mapper mapper;

    @Test
    public void testNotSameAttributeMapping() {
        NotSameAttributeA src = new NotSameAttributeA();
        src.setId(007);
        src.setName("邦德");
        src.setDate(new Date());

        NotSameAttributeB desc = mapper.map(src, NotSameAttributeB.class);
        Assert.assertNotNull(desc);
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface Mapping {
  String value() default "";
}

public class SourceBean {

    private Long id;

    private String name;

    @Mapping("binaryData")
    private String data;

    @Mapping("pk")
    public Long getId() {
        return this.id;
    }

    //其余getter/setter方法略
}

public class TargetBean {

    private String pk;

    private String name;

    private String binaryData;

    //getter/setter方法略
}

@Test
public void testAnnotationMapping() {
 SourceBean src = new SourceBean();
 src.setId(7L);
 src.setName("邦德");
 src.setData("00000111");

 TargetBean desc = mapper.map(src, TargetBean.class);
 Assert.assertNotNull(desc);
}

public class Source {
 private long id;
    private String info;
}

public class Dest {
 private long id;
    private Info info;
}

public class Info {
 private String content;
}

public class TestCustomConverter implements CustomConverter {

  public Object convert(Object destination, Object source,
      Class destClass, Class sourceClass) {
    if (source == null) {
      return null;
    }
    CustomDoubleObject dest = null;
    if (source instanceof Double) {
      // check to see if the object already exists
      if (destination == null) {
        dest = new CustomDoubleObject();
      } else {
        dest = (CustomDoubleObject) destination;
      }
      dest.setTheDouble(((Double) source).doubleValue());
      return dest;
    } else if (source instanceof CustomDoubleObject) {
      double sourceObj =
        ((CustomDoubleObject) source).getTheDouble();
      return new Double(sourceObj);
    } else {
      throw new MappingException("Converter TestCustomConverter "
          + "used incorrectly. Arguments passed in were:"
          + destination + " and " + source);
    }
  }