[JAVA] [Jackson] JSON⇔Objekt-Konvertierungsklasse

Einführung

Beachten Sie, dass JSON von der REST-API verarbeitet wird

Umgebung

maven

volle 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>

Konvertierungsklasse

package trial.json;

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

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

/**
 *JSON-Zeichenfolge ⇔ Objektkonvertierungsklasse.
 *
 * @param <T>Zu konvertierende Klasse
 */
public class JsonConverter<T> {

    private ObjectMapper objectMapper;

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

    /**
     *Von JSON-Zeichenfolge in Map-Objekt konvertieren.
     *
     * @param jsonStr JSON-Zeichenfolge
     * @Map-Objekt zurückgeben
     * @löst IOException aus Wenn die Konvertierung fehlschlägt
     */
    public Map<String, Object> convertToMap(String jsonStr) throws IOException {
        //Argumentprüfung
        validateJsonStr(jsonStr);

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

    /**
     *Konvertieren Sie von einer JSON-Zeichenfolge in ein selbst erstelltes Objekt.
     *
     * @param jsonStr JSON-Zeichenfolge
     * @param clz Homebrew Klasse
     * @Selbst erstelltes Objekt zurückgeben
     * @löst IOException aus Wenn die Konvertierung fehlschlägt
     */
    public T convertToDto(String jsonStr, Class<T> clz) throws IOException {
        //Argumentprüfung
        validateJsonStr(jsonStr);
        validateClass(clz);

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

    /**
     *Vom Map-Objekt in eine JSON-Zeichenfolge konvertieren.
     *
     * @param map Kartenobjekt
     * @JSON-String zurückgeben
     * @löst IOException aus Wenn die Konvertierung fehlschlägt
     */
    public String convertToStr(Map<String, Object> map) throws IOException {
        //Argumentprüfung
        validateMap(map);

        return this.objectMapper.writeValueAsString(map);
    }

    /**
     *Konvertieren Sie Ihr eigenes Objekt in eine JSON-Zeichenfolge.
     *
     * @param obj Selbstgemachtes Objekt
     * @JSON-String zurückgeben
     * @löst IOException aus Wenn die Konvertierung fehlschlägt
     */
    public String convertToStr(T obj) throws IOException {
        //Argumentprüfung
        validateObj(obj);

        return this.objectMapper.writeValueAsString(obj);
    }

    /**
     *Überprüfen Sie die JSON-Zeichenfolge.
     *
     * @param jsonStr JSON-Zeichenfolge
     */
    private void validateJsonStr(String jsonStr) {
        if (jsonStr == null) {
            throw new IllegalArgumentException("jsonStr is null.");
        }
        if (jsonStr.isEmpty()) {
            throw new IllegalArgumentException("jsonStr is empty.");
        }
    }

    /**
     *Überprüfen von Klassenobjekten.
     *
     * @param clz Klassenobjekt
     */
    private void validateClass(Class<T> clz) {
        if (clz == null) {
            throw new IllegalArgumentException("clz is null.");
        }
    }

    /**
     *Überprüfen Sie das Kartenobjekt.
     *
     * @param map Kartenobjekt
     */
    private void validateMap(Map<String, Object> map) {
        if (map == null) {
            throw new IllegalArgumentException("map is null.");
        }
    }

    /**
     *Überprüfen Sie Ihre eigenen Objekte.
     *
     * @param obj Selbstgemachtes Objekt
     */
    private void validateObj(T obj) {
        if (obj == null) {
            throw new IllegalArgumentException("obj is null.");
        }
    }
}

das ist alles