DynamicRelations

Relations dynamiques

Dans chaque base de données relationnelle, vous devez toujours savoir quelles relations sont possibles à vos entités. Mais parfois, ces relations sont inconnues ou pourraient changer à tout moment. Avec des relations dynamiques, vous pouvez ajouter ou supprimer des relations personnalisées entre les entités pendant l'exécution.

Qu'est-ce qu'une relation dynamique?

Une relation dynamique peut être considérée comme un graphique dirigé avec une entrée fixe (sourceObject) et une sortie dynamique (cible).

 Organigramme LR
    dynamicrélation subgraph
    Direction LR
    SourceObject -> cible
    fin

Par exemple avec les entités suivantes:

• Personne
• Chien
• Document

Une personne peut avoir un chien et les deux intimes pourraient avoir des documents (documents d'information de la personne et documents d'informations sur le chien). Maintenant, vous pouvez ajouter des relations dynamiques à toutes les entités qui pourraient ressembler à ceci:

 graphique TD;
    Personne -> chien;
    Personne -> Person_Document
    Chien -> dog_document;

Chaque connexion est une relation dynamique et les relations suivantes seront générées:

• Relation de la personne avec la personne SourceObject
• Person_Document Relation avec SourceObject Person_Document
• Relation du chien avec SourceObject Dog
• Relation dog_document avec SourceObject Dog_Document

Chaque relation a obtenu une cible dynamique, ce qui signifie que vous pouvez créer une relation avec toute autre entité.

Dans ce scénario, une personne a un chien et les deux ont obtenu des documents, vous pouvez maintenant changer la relation pendant l'exécution (aucune modification de vos entités ou modèles). Par exemple, vous pouvez supprimer un Person_Document (Got Lost):

 graphique TD;
    Personne -> chien;
    Chien -> dog_document;

Dépendance Maven

 <dependency>
  <groupId>io.github.Mom0aut</groupId>
  <artifactId>dynamic-relations</artifactId>
  <version>1.0.4</version>
</dependency>

Comment utiliser

• Ajoutez la @relation à votre entité
• Mettre en œuvre la relationté
• Importer le module de configuration pour la numérisation des composants
• Utilisez le Relatement Service

Ajouter la @relation

Ajoutez simplement la @relation à votre entité existante et l'entité de relations dynamiques nécessaire sera générée. Les relations dynamiques ne travaillent qu'avec une classe qui est annotée avec @entity !

 @ Relation ( sourceClass = Person . class )
@ Entity
@ Getter
@ Setter
public class Person implements RelationIdentity {

    @ Id
    @ GeneratedValue ( strategy = GenerationType . IDENTITY )
    private Long id ;

    @ Override
    public String getType () {
        return "PersonType" ;
    }
}

Mettre en œuvre la relationté

Implémentez la relation Identity, chaque relation dynamique a besoin d'un long ID et d'un type de chaîne que vous pouvez définir.

 @ Relation ( sourceClass = Person . class )
@ Entity
@ Getter
@ Setter
public class Person implements RelationIdentity {

    @ Id
    @ GeneratedValue ( strategy = GenerationType . IDENTITY )
    private Long id ;

    @ Override
    public String getType () {
        return "PersonType" ;
    }
}

Importer le module de configuration pour la numérisation des composants

Importez le DRMConfig dans votre application Spring Boot, afin que vous puissiez utiliser le RelatingService

 @ SpringBootApplication
@ Import ( DrmConfig . class )
public class App {
    public static void main ( String [] args ) {
        SpringApplication . run ( App . class , args );
    }
}

Utilisez le Relatement Service

Créer une relation

 @ Autowired 
private RelationService relationService ;

        void createRelation () {
            Person person = new person ();
            personDao . save ( person );
    
            Dog dog = new Dog ();
            dogDao . save ( dog );
    
            //Dynamic Relation can only be created with persisted Entities!
            RelationLink relationLinkPersonToDog = relationService . createRelation ( person , dog );
        }

La relation dynamique ne peut être créée qu'avec des entités persistantes!

Supprimer la relation

 @ Autowired 
private RelationService relationService ;

        void deleteRelation () {
            relationService . deleteRelation ( relationToBeDeleted );
        }

Trouver des relations

 @ Autowired 
private RelationService relationService ;

        void findRelations () {
            Person person = new person ();
            personDao . save ( person );
    
            Dog dog = new Dog ();
            dogDao . save ( dog );
    
            Document document = new Document ();
            documentDaio . save ( document );
    
            //Dynamic Relation can only be created with persisted Entities!
            RelationLink relationLinkPersonToDog = relationService . createRelation ( person , dog );
            RelationLink relationLinkPersonToDocument = relationService . createRelation ( person , document );
            RelationLink relationLinkDogToDocument = relationService . createRelation ( dog , document );
    
            //Return 1 Relation person -> dog
            RelationLink foundRelation = relationService . findRelationBySourceObjectAndRelationIdentity ( person , dog );
            //Returns 2 Relations person -> dog and person -> document
            List < RelationLink > relationBySourcePerson = relationService . findRelationBySourceObject ( person );
            //Returns 2 Relations from person -> document and dog -> document
            Set < RelationLink > relationByTargetDocument = relationService . findRelationByTargetRelationIdentity ( document );
        }

Obtenez le SourceObject par relation

 @ Autowired 
private RelationService relationService ;

        void getSourceObject () {
            RelationLink foundRelation = relationService . findRelationBySourceObjectAndRelationIdentity ( person , dog );
            //Can be cast to Person because we know it is from Person.class
            Person sourceObject = ( Person ) foundRelation . getSourceObject ();
        }

Limites

• Java avec printemps
• Base de données SQL (testée avec Postgres)

Contributeurs

Contribution

Chaque contribution est la bienvenue, veuillez suivre les directives de contribution

Code de conduite

Voir notre code de conduite