[JAVA] [Jackson] Classe de conversion d'objet JSON

introduction

Notez que JSON est géré par l'API REST

environnement

maven

plein pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>trial</groupId>
	<artifactId>trial-json</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>trial-json</name>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
		<maven.compiler.target>${java.version}</maven.compiler.target>
		<maven.compiler.source>${java.version}</maven.compiler.source>
	</properties>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.8</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.4</version>
			<scope>provided</scope>
		</dependency>

		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<verbose>true</verbose>
					<source>${java.version}</source>
					<target>${java.version}</target>
					<encoding>${project.build.sourceEncoding}</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

Classe de conversion

package trial.json;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.util.Map;

/**
 *Chaîne JSON ⇔ classe de conversion d'objet.
 *
 * @param <T>Classe à convertir
 */
public class JsonConverter<T> {

    private ObjectMapper objectMapper;

    /**
     *constructeur.
     */
    public JsonConverter() {
        this.objectMapper = new ObjectMapper();
    }

    /**
     *Convertir de la chaîne JSON en objet Map.
     *
     * @param jsonStr Chaîne JSON
     * @renvoyer l'objet Map
     * @jette IOException si la conversion échoue
     */
    public Map<String, Object> convertToMap(String jsonStr) throws IOException {
        //Vérification des arguments
        validateJsonStr(jsonStr);

        return this.objectMapper.readValue(jsonStr, new TypeReference<Map<String, Object>>() {});
    }

    /**
     *Conversion de la chaîne JSON en objet auto-créé.
     *
     * @param jsonStr Chaîne JSON
     * @param clz Classe Homebrew
     * @retour Objet auto-fabriqué
     * @jette IOException si la conversion échoue
     */
    public T convertToDto(String jsonStr, Class<T> clz) throws IOException {
        //Vérification des arguments
        validateJsonStr(jsonStr);
        validateClass(clz);

        return this.objectMapper.readValue(jsonStr, clz);
    }

    /**
     *Convertir de l'objet Map en chaîne JSON.
     *
     * @objet de carte de param map
     * @retourne la chaîne JSON
     * @jette IOException si la conversion échoue
     */
    public String convertToStr(Map<String, Object> map) throws IOException {
        //Vérification des arguments
        validateMap(map);

        return this.objectMapper.writeValueAsString(map);
    }

    /**
     *Convertissez votre propre objet en chaîne JSON.
     *
     * @param obj Objet auto-fabriqué
     * @retourne la chaîne JSON
     * @jette IOException si la conversion échoue
     */
    public String convertToStr(T obj) throws IOException {
        //Vérification des arguments
        validateObj(obj);

        return this.objectMapper.writeValueAsString(obj);
    }

    /**
     *Vérifier la chaîne JSON.
     *
     * @param jsonStr Chaîne JSON
     */
    private void validateJsonStr(String jsonStr) {
        if (jsonStr == null) {
            throw new IllegalArgumentException("jsonStr is null.");
        }
        if (jsonStr.isEmpty()) {
            throw new IllegalArgumentException("jsonStr is empty.");
        }
    }

    /**
     *Vérification des objets de classe.
     *
     * @objet de classe param clz
     */
    private void validateClass(Class<T> clz) {
        if (clz == null) {
            throw new IllegalArgumentException("clz is null.");
        }
    }

    /**
     *Vérifier l'objet de la carte.
     *
     * @objet de carte de param map
     */
    private void validateMap(Map<String, Object> map) {
        if (map == null) {
            throw new IllegalArgumentException("map is null.");
        }
    }

    /**
     *Vérifiez vos propres objets.
     *
     * @param obj Objet auto-fabriqué
     */
    private void validateObj(T obj) {
        if (obj == null) {
            throw new IllegalArgumentException("obj is null.");
        }
    }
}

c'est tout