Adnotacje w Javie na przykładzie własnego konwertera JSON

Hej, dziś pokażę jak działają adnotacje w Javie na przykładzie prostego konwertera obiektu do formatu JSON.

Po co nam adnotacje? To wygodny sposób na konwertowanie danych, albo sterowanie zachowaniem programu po podstawie oznaczeń na polach, klasach i metodach. Zapewne spotkałeś/aś się z adnotacjami podczas implementowania bibliotek ORM (np. Hibernate) albo Jersey lub miałeś do czynienia z frameworkiem Spring Boot.

Ten wpis nie wyjaśni ci pojęcia refleksji w Javie, ale jeśli zostawisz like’a na stronie FB, lub zapiszesz się na newsletter, to na pewno nie ominie cię wpis o refleksach w Javie, który zamierzam napisać 🙂

Od razu przejdę do konkretów i utworzę klasę reprezentującą model danych:

public class Movie {
  
  private String title;
  private String author;
  private String yearOfProduction;
  
  public String getTitle() {
    return title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public String getAuthor() {
    return author;
  }

  public void setAuthor(String author) {
    this.author = author;
  }

  public String getYearOfProduction() {
    return yearOfProduction;
  }

  public void setYearOfProduction(String yearOfProduction) {
    this.yearOfProduction = yearOfProduction;
  }

  public String[] getTags() {
    return tags;
  }

  public void setTags(String[] tags) {
    this.tags = tags;
  }

public class Movie {

private String title;

private String author;

private String yearOfProduction;

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

public String getYearOfProduction() {

return yearOfProduction;

}

public void setYearOfProduction(String yearOfProduction) {

this.yearOfProduction = yearOfProduction;

}

public String[] getTags() {

return tags;

}

public void setTags(String[] tags) {

this.tags = tags;

}

Jak widać powyżej, jest to zwykła klasa modelowa Movie, która posiada pola prywatne oraz getter i settery.

Teraz zajmę się tworzeniem kilku klas reprezentujących adnotacje. Chciałbym oznaczać klasy modelowe i wskazywać w ten sposób zasoby, które podlegają konwersji na JSON:


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ModelToJson {
}

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface ModelToJson {

}

Objaśnienie linijka po linijce:

@Retention(RetentionPolicy.RUNTIME) oznacza, że adnotacja ma być czytana podczas kompilacji programu.

@Target(ElementType.TYPE) dotyczy miejsca, które może zostać oznaczone naszą adnotacją. TYPE oznacza klasę. Jeszcze jest m.in METHOD oraz FIELD co jasno oznacza przeznaczenie adnotacji.

public @interface ModelToJson to inicjalizacja klasy, która jest interfejsem. Adnotacje dodatkowo mają przedrostek @ przed słowem kluczowym interface.

Reasumując, adnotacja @ModelToJson będzie używana do oznaczania klasy modelowej przeznaczonej do konwersji.

Poniżej tworzę adnotację, która będzie oznaczać pole klasy, jako biorące udział w konwersji na format JSON. Innymi słowy, pole nie oznaczone tą adnotacją zostanie pominięte podczas konwersji modelu na JSON.


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface JsonElement {
  public String key() default "";
}

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface JsonElement {

public String key() default "";

}

Dodałem abstrakcyjna metodę String key() i oznaczyłem ją domyślnie na wartość pustego stringa. Dzięki temu, będzie można zmienić nazwę konwertowanego pola na dowolną zawartą w adnotacji.

Dorzucam klasę własnego wyjątku, choć nie jest to niezbędne:


public class JsonSerializationException extends RuntimeException {

  public JsonSerializationException(String message) {
    super(message);
  }
}

public class JsonSerializationException extends RuntimeException {

public JsonSerializationException(String message) {

super(message);

}

Teraz czas na implementację logiki konwertera, czyli metody, które przekonwertują model Movie na stringowego JSONa. Poniżej pojedyncze metody z yjaśnieniem działania, a na samym dole cała klasa już „sklejona” 🙂

metoda: checkIfSerializable():


private void checkIfSerializable(Object object) {
    if (Objects.isNull(object)) {
      throw new JsonSerializationException("Can't serialize a null object");
    }
    Class<?> clazz = object.getClass();
    if (!clazz.isAnnotationPresent(ModelToJson.class)) {
      throw new JsonSerializationException("The class " + clazz.getSimpleName() + " is not annotated with JsonSerializable");
    }
  }

private void checkIfSerializable(Object object) {

if (Objects.isNull(object)) {

throw new JsonSerializationException("Can't serialize a null object");

}

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

if (!clazz.isAnnotationPresent(ModelToJson.class)) {

throw new JsonSerializationException("The class " + clazz.getSimpleName() + " is not annotated with JsonSerializable");

}

Powyższa metoda przyjmuje ogólny obiekt jako parametr i za pomocą refleksji sprawdza, czy posiada adnotację @ModelToJson.

Metoda getJsonString():

private String getJsonString(Object object) throws IllegalArgumentException, IllegalAccessException {
    Class<?> clazz = object.getClass();
    Map<String, String> jsonElementsMap = new HashMap<>();

    for (Field field : clazz.getDeclaredFields()) {
      field.setAccessible(true);

      if (field.isAnnotationPresent(JsonElement.class)) {
          jsonElementsMap.put(getKey(field), (String) field.get(object));
        }
      }

    String jsonString = jsonElementsMap.entrySet().stream()
        .map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")
        .collect(Collectors.joining(","));

    return "{" + jsonString + "}";
  }

private String getJsonString(Object object) throws IllegalArgumentException, IllegalAccessException {

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

Map<String, String> jsonElementsMap = new HashMap<>();

for (Field field : clazz.getDeclaredFields()) {

field.setAccessible(true);

if (field.isAnnotationPresent(JsonElement.class)) {

jsonElementsMap.put(getKey(field), (String) field.get(object));

}

String jsonString = jsonElementsMap.entrySet().stream()

.map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")

.collect(Collectors.joining(","));

return "{" + jsonString + "}";

}

Powyższa metoda przyjmuje ogólny objekt jako parametr i za pomocą refleksji pobiera dane o polach klasy oraz spradza, czy pole posiada adnotację @JsonElement, jeśli posiada, to konwertuje tworząc stringa z kluczy (nazwa pola) i wartości (wartość pola).

Metoda getKey() sprawdza, czy nazwa pola musi zostać zmieniona na wartość z adnotacji, jeśli nie, to zostawia oryginalną nazwę pola.


private String getKey(Field field) {
    String value = field.getAnnotation(JsonElement.class).key();
    return value.isEmpty() ? field.getName() : value;
  }

private String getKey(Field field) {

String value = field.getAnnotation(JsonElement.class).key();

return value.isEmpty() ? field.getName() : value;

}

Metoda convertToJson() służy jako główna metoda konwersji i będzie wywoływana wraz z przekazaniem modelu. Wykorzystałem tutaj również wyjątek rzucany podczas błędu konwersji. Obecna implementacja nie rozwiązuje problemu konwersji tablic na JSON, dlatego ten wyjątek się przyda 🙂

 
public String convertToJson(Object object) throws JsonSerializationException {
    try {
      checkIfSerializable(object);
      return getJsonString(object);
    } catch (Exception e) {
      throw new JsonSerializationException(e.getMessage());
    }
  }

public String convertToJson(Object object) throws JsonSerializationException {

try {

checkIfSerializable(object);

return getJsonString(object);

} catch (Exception e) {

throw new JsonSerializationException(e.getMessage());

}

Poniżej cała klasa ClassToJsonConverter:


import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

public class ClassToJsonConverter {

  public String convertToJson(Object object) throws JsonSerializationException {
    try {
      checkIfSerializable(object);
      return getJsonString(object);
    } catch (Exception e) {
      throw new JsonSerializationException(e.getMessage());
    }
  }

  private void checkIfSerializable(Object object) {
    if (Objects.isNull(object)) {
      throw new JsonSerializationException("Can't serialize a null object");
    }
    Class<?> clazz = object.getClass();
    if (!clazz.isAnnotationPresent(ModelToJson.class)) {
      throw new JsonSerializationException("The class " + clazz.getSimpleName() + " is not annotated with JsonSerializable");
    }
  }

  private String getJsonString(Object object) throws IllegalArgumentException, IllegalAccessException {
    Class<?> clazz = object.getClass();
    Map<String, String> jsonElementsMap = new HashMap<>();

    for (Field field : clazz.getDeclaredFields()) {
      field.setAccessible(true);

      if (field.isAnnotationPresent(JsonElement.class)) {
        jsonElementsMap.put(getKey(field), (String) field.get(object));
      }
    }

    String jsonString = jsonElementsMap.entrySet().stream()
        .map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")
        .collect(Collectors.joining(","));

    return "{" + jsonString + "}";
  }

  private String getKey(Field field) {
    String value = field.getAnnotation(JsonElement.class).key();
    return value.isEmpty() ? field.getName() : value;
  }
}

import java.lang.reflect.Field;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import java.util.stream.Collectors;

public class ClassToJsonConverter {

public String convertToJson(Object object) throws JsonSerializationException {

try {

checkIfSerializable(object);

return getJsonString(object);

} catch (Exception e) {

throw new JsonSerializationException(e.getMessage());

}

private void checkIfSerializable(Object object) {

if (Objects.isNull(object)) {

throw new JsonSerializationException("Can't serialize a null object");

}

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

if (!clazz.isAnnotationPresent(ModelToJson.class)) {

throw new JsonSerializationException("The class " + clazz.getSimpleName() + " is not annotated with JsonSerializable");

}

private String getJsonString(Object object) throws IllegalArgumentException, IllegalAccessException {

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

Map<String, String> jsonElementsMap = new HashMap<>();

for (Field field : clazz.getDeclaredFields()) {

field.setAccessible(true);

if (field.isAnnotationPresent(JsonElement.class)) {

jsonElementsMap.put(getKey(field), (String) field.get(object));

}

String jsonString = jsonElementsMap.entrySet().stream()

.map(entry -> "\"" + entry.getKey() + "\":\"" + entry.getValue() + "\"")

.collect(Collectors.joining(","));

return "{" + jsonString + "}";

}

private String getKey(Field field) {

String value = field.getAnnotation(JsonElement.class).key();

return value.isEmpty() ? field.getName() : value;

}

Mam nadzieję, że zachęciłem cię do dalszej zabawy z konwerterem oraz refleksą w Javie. Pamiętaj o FB 🙂

Tutaj znajdziesz kod w repozytorium do powyższego przykładu.

Powodzenia 🙂

[vicomi_feelbacks]