[Java] Convertit le code DB en valeur de code à l'aide d'énum

Il s'agit d'un exemple qui convertit le code d'état enregistré dans la base de données en une valeur de code côté Java. Cela élimine le besoin de créer un maître qui définit la signification du code d'état. Le cadre est Spring Boot.

environnement

• OS：Windows10
• IDE：Eclipse2020-03
• Java：8
• MySQL：5.7
• Hibernate ORM：5.4
• Spring Boot：2.3.1

Aperçu

Le code de statut de l'étudiant (valeur entière) enregistré dans la table des étudiants est converti en la valeur de code correspondante à l'aide d'énumération côté Java.

Diagramme ER

Code d'état et valeur de code

Diagramme de configuration du package

enum-sample
     |
    src/main/java
     |----jp.co.high_school
     |               |---- app
     |               |     |---- controller
     |               |     |---- response
     |               |
     |               |---- domain
     |               |      |---- service
     |               |      |---- repository
     |               |      |---- model
     |               |  
     |               |---- constant
     |
    src/main/resources
     |----application.yml

Code source

1. DDL

Table des étudiants

CREATE TABLE `students` (
  `student_id` int(10) unsigned zerofill NOT NULL AUTO_INCREMENT COMMENT 'Carte d'étudiant',
  `student_name` varchar(300) COLLATE utf8mb4_bin DEFAULT NULL COMMENT 'Nom d'étudiant',
  `sex` tinyint(4) DEFAULT NULL COMMENT 'sexe',
  `school_year` tinyint(4) DEFAULT NULL COMMENT 'Année scolaire',
  `class` tinyint(4) DEFAULT NULL COMMENT 'classe',
  `student_status` tinyint(4) DEFAULT NULL COMMENT 'Statut d'étudiant',
  PRIMARY KEY (`student_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='étudiant';

2. Classe constante

Définissez et utilisez enum dans la classe constante. Vous pouvez créer une énumération en tant que classe, mais je l'ai définie dans la classe en supposant que le nombre augmentera. En faisant cela, vous pouvez gérer plusieurs énumérations avec un fichier de classe.

Constant.java

package jp.co.high_school.constant;

import java.util.stream.Collectors;
import java.util.stream.Stream;

import lombok.Getter;

/**
 *Classe constante
 * @author CHI-3
 * @Version 1.0
 */
public class Constant {

        /**
         * StudentStatus
         *Statut d'étudiant
         */
        @Getter
        public static enum StudentStatus {

            In(1, "Étudiant"),
            Rest(2, "En congé"),
            Out(3, "diplômé");

            private StudentStatus(int key, String value) {
                this.key = key;
                this.value = value;
            }


            private int key;

            private String value;

            //Renvoie toutes les valeurs de code
            public static Stream<StudentStatus> stream(){
                return Stream.of(StudentStatus.values());
            }

            //Renvoie la valeur de code qui correspond au code récupéré
            public static String getStatusValue(Byte code) {
            	return Stream.of(StudentStatus.values()).filter(v -> v.getKey() == code).map(v -> v.getValue()).collect(Collectors.joining());
            }

        }


        //Non utilisé cette fois: décrit comme la preuve que plusieurs énumérations peuvent être définies dans une classe
        /**
         * Grade
         *Grades
         */
        @Getter
        public static enum Grade{

            //Excellent, bon, acceptable sont les exigences minimales-sam, pas possible est la meilleure condition
            Excellent(1, "Yu", 90),
            Good(2, "Bien", 75),
            Passing(3, "Oui", 60),
            Failing(4, "Impossible", 59);


            private Grade(int key, String value, int order) {
                this.key = key;
                this.value = value;
                this.order = order;
            }

            private int key;

            private String value;

            private int order;

        }

}

3. Classe d'entité

Cette fois, il a été généré automatiquement à partir de la base de données à l'aide des outils Hibernate d'Eclipse.

Student.java

package jp.co.high_school.domain.model;

import java.io.Serializable;
import javax.persistence.*;


/**
 * The persistent class for the students database table.
 *
 */
@Entity
@Table(name="students")
@NamedQuery(name="Student.findAll", query="SELECT s FROM Student s")
public class Student implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="student_id")
	private Integer studentId;

	@Column(name="class")
	private Byte class_;

	@Column(name="school_year")
	private Byte schoolYear;

	private Byte sex;

	@Column(name="student_name")
	private String studentName;

	@Column(name="student_status")
	private Byte studentStatus;

	//bi-directional one-to-one association to Grade
	@OneToOne(mappedBy="student")
	private Grade grade;

	public Student() {
	}

	public Integer getStudentId() {
		return this.studentId;
	}

	public void setStudentId(Integer studentId) {
		this.studentId = studentId;
	}

	public Byte getClass_() {
		return this.class_;
	}

	public void setClass_(Byte class_) {
		this.class_ = class_;
	}

	public Byte getSchoolYear() {
		return this.schoolYear;
	}

	public void setSchoolYear(Byte schoolYear) {
		this.schoolYear = schoolYear;
	}

	public Byte getSex() {
		return this.sex;
	}

	public void setSex(Byte sex) {
		this.sex = sex;
	}

	public String getStudentName() {
		return this.studentName;
	}

	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}

	public Byte getStudentStatus() {
		return this.studentStatus;
	}

	public void setStudentStatus(Byte studentStatus) {
		this.studentStatus = studentStatus;
	}

	public Grade getGrade() {
		return this.grade;
	}

	public void setGrade(Grade grade) {
		this.grade = grade;
	}

}

4. Classe de référentiel

En spécifiant le numéro d'étudiant, les informations de l'étudiant correspondant sont acquises.

StudentRepository.java

package jp.co.high_school.domain.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import jp.co.test_shop.domain.model.Student;

/**
 *Classe de référentiel de manipulation de table des étudiants
 * @author CHI-3
 * @Version 1.0
 */
@Repository
public interface StudentRepository extends JpaRepository<Student, Integer>{

	/**
	 *méthode findByStudentId
	 *Obtenez l'étudiant correspondant à la carte d'étudiant
	 * @param studentId
	 * @retour étudiant
	 */
	public Student findByStudentId(Integer studentId);

}

5. Classe de service

Convertit le code de statut d'étudiant de l'étudiant acquis en code de statut correspondant et le renvoie.

StudentInformationService.java

package jp.co.high_school.domain.service;

import java.util.Optional;

import org.springframework.stereotype.Service;

import jp.co.test_shop.constant.Constant.StudentStatus;
import jp.co.test_shop.domain.model.Student;
import jp.co.test_shop.domain.repository.StudentRepository;
import lombok.RequiredArgsConstructor;

/**
 *Classe de service pour l'acquisition d'informations sur les étudiants
 * @author CHI-3
 * @version 1.0
 */
@Service
@RequiredArgsConstructor
public class StudentInformationService {

	private final StudentRepository studentRepository;

	/**
	 *méthode getStatus
	 *Obtenir le statut d'étudiant (valeur de code) de l'étudiant cible
	 * @param studentId ID étudiant
	 * @retourner le statut d'étudiant (valeur de code)
	 */
	public String getStatus(Integer studentId) throws Exception{

		Student student = studentRepository.findByStudentId(studentId);
		
		//Soulevez une exception si aucun étudiant n'est associé à la carte d'étudiant
		Optional.ofNullable(student).orElseThrow(Exception::new);
		
		String status = null;
		/*Code d'état → Valeur de code correspondante: commentaire en raison du changement de description par flux
		for(StudentStatus ss:StudentStatus.values()){
			if(ss.getKey() == student.getStudentStatus()) {
				status = ss.getValue();
				break;
			}
		}
		*/
		
		//Code d'état → Valeur de code correspondante
		status = StudentStatus.getStatusValue(student.getStudentStatus());

		return status;

	}

}

6. Classe de contrôleur

Formate et renvoie la valeur de code obtenue par la classe Service.

StudentInformationController.java

package jp.co.high_school.app.controller;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import jp.co.test_shop.app.response.StudentStatusResponse;
import jp.co.test_shop.domain.service.StudentInformationService;
import lombok.RequiredArgsConstructor;

/**
 *Classe de contrôleur pour l'acquisition d'informations sur les étudiants
 * @author CHI-3
 * @Version 1.0
 */
@RestController
@RequiredArgsConstructor
public class StudentInformationController {

	private final StudentInformationService studenInformationService;

	/**
	 *méthode getStatus
	 *Obtenez le statut d'étudiant
	 * @param studentId ID étudiant
	 * @return Response entity (valeur du code d'état + état HTTP)
	 */
	@GetMapping("/student-information/{studentId}")
	public ResponseEntity<StudentStatusResponse> getStatus(@PathVariable("studentId") Integer studentId){
		String status = studenInformationService.getStatus(studentId);
		StudentStatusResponse studentStatusReponse = StudentStatusResponse.builder().status(status).build();
		return new ResponseEntity<>(studentStatusReponse, HttpStatus.OK);
	}

}

7. Classe de réponse

StudentStatusResponse.java

package jp.co.high_school.app.response;

import lombok.Builder;
import lombok.Getter;

/**
 *Classe de réponse sur le statut d'étudiant
 *Utilisé pour façonner le statut d'étudiant
 * @author CHI-3
 * @Version 1.0
 */
@Getter
@Builder
public class StudentStatusResponse {

	private String status;

}

Contrôle de fonctionnement

Cette fois, nous vérifierons le fonctionnement dans l'environnement local.

Table des étudiants

Si la table des élèves a le contenu ci-dessus, le fait d'appuyer sur l'API (en utilisant Advanced Rest Client) renverra le résultat suivant. La valeur du code (pendant la fréquentation scolaire) correspondant au code d'état (1) est correctement prise.

modifier l'historique

--2020 / 07/13: Code d'état → Modifier la description du processus pour acquérir la valeur de code correspondante et la configuration du package de la classe constante

À la fin

Utiliser enum semble rendre la gestion des maîtres (DB) et des constantes (Java) beaucoup plus facile. Je veux bien l'utiliser.

référence

• Comment utiliser l'énumération Java que vous ne connaissez pas | Canal SE
• Exemple d'utilisation de base et de code de type enum (enum) | Qiita
• Comment utiliser enum (type d'énumération) dans Java | Narikiri Architect
• Java 8 --Filtering Map Samples | codeflow