web-dev-qa-db-fra.com

@Annotation transitoire, @ org.springframework.data.annotation.Annotation transitoire, stockage transitoire des mots clés et des mots de passe

Actuellement, j'apprends le framework Spring, en me concentrant principalement sur son module de sécurité. J'ai regardé certains guides en lien avec l'inscription et la connexion. J'ai vu cette utilisation courante du mot-clé transient ou de l'annotation @ Transient dans le champ de mot de passe de la classe ser.

Mon application factice utilise Spring Boot + Spring MVC + Spring Security + MySQL.

Je le sais

Le mot clé transient de Java est utilisé pour indiquer qu'un champ ne doit pas être sérialisé.

JPA @ Annotation transitoire ...

... spécifie que la propriété ou le champ n'est pas persistant. Il est utilisé pour annoter une propriété ou un champ d'une classe d'entité, d'une superclasse mappée ou d'une classe intégrable.

et de org.springframework.data.annotation @ Annotation transitoire ...

Marque un champ comme étant transitoire pour le cadre de mappage. Ainsi, la la propriété ne sera pas conservée et non plus inspectée par le cadre de mappage.

Dans ma base de données MySQL, j'ai mon schéma spring_demo qui a 3 tables:

+-----------------------+
| Tables_in_spring_demo |
+-----------------------+
| role                  |
| user                  |
| user_role             |
+-----------------------+

Lorsque j'utilise le mot clé transient dans le champ de mot de passe de la classe User, il ne serait pas stocké dans la base de données MySQL. (exemple: test01)

mysql> select * from user;
+----+--------+------------------+----------+
| id | active | email            | username |
+----+--------+------------------+----------+
|  1 |      1 | [email protected] | test01   |
+----+--------+------------------+----------+
1 row in set (0,00 sec)

Lorsque j'utilise l'annotation javax.persistence @Transient sur le champ de mot de passe dans la classe User, elle ne serait pas non plus stockée dans la base de données MySQL. (exemple: test02)

Mais ... lorsque j'utilise l'annotation org.springframework.data.annotation @Transient dans le champ de mot de passe de la classe User, elle est stockée dans la base de données MySQL. (exemple: test03) Pourquoi ça?

mysql> select * from user;
+----+--------+------------------+----------+--------------------------------------------------------------+
| id | active | email            | username | password                                                     |
+----+--------+------------------+----------+--------------------------------------------------------------+
|  1 |      1 | [email protected] | test02   |                                                              |
|  2 |      1 | [email protected] | test03   | $2a$10$UbvmdhfcKxSNr/I4CjOLtOkKGX/j4/xQfFrv3FizxwEVk6D9sAoO  |
+----+--------+------------------+----------+--------------------------------------------------------------+
2 rows in set (0,00 sec)

Mes principales questions sont, lorsque j'utilise l'annotation @Transient basée sur spring.data, le champ de mot de passe a persisté. Pourquoi? Et pourquoi devrais-je utiliser une annotation @Transient sur un champ de mot de passe?

Merci pour vos conseils et votre aide à l'avance!

jpaspring-securityspring-dataspring-annotationstransient
13
F3R1

Dans Spring Framework, vous pouvez utiliser Mapping Framework pour convertir d'un formulaire à un autre. Dites par exemple que votre printemps Java application côté serveur doit envoyer des informations utilisateur à un client (page Web, application mobile) au format JSON.

@Entity
public class User {

@Id
private long id;

@Column(name = "username")
private String username;

@Column(name = "email")
private String email;

@Column(name = "password")
private String password;

}

Maintenant, pour mapper cet Java au format JSON, vous pouvez soit utiliser un cadre de mappage (par exemple jackson: com.fasterxml.jackson.databind.ObjectMapper) ou faites-le manuellement.

La sortie au format JSON que vous obtiendriez lors de la conversion d'un objet utilisateur 2 en JSON est:

{
   "id": 2,
   "email": "[email protected]",
   "username": "test03",
   "password": "$2a$10$UbvmdhfcKxSNr/I4CjOLtOkKGX/j4/xQfFrv3FizxwEVk6D9sAoO"
}

Maintenant, si vous avez ajouté:

@org.springframework.data.annotation.Transient
@Column(name = "password")
private String password;

puis utilisé le Mapping Framwwork pour générer à nouveau le JSON pour l'entité utilisateur 2 que vous obtiendriez:

{
   "id": 2,
   "email": "[email protected]",
   "username": "test03",
}

Notez que le champ de mot de passe est absent de votre sortie JSON. C'est parce que @org.springframework.data.annotation.Transient indique spécifiquement au framework Spring que le mappeur d'objets que vous utilisez ne doit pas inclure cette valeur lors de la conversion de Java Object en JSON).

Notez également que si vous tentiez de conserver l'entité ci-dessus dans la base de données, elle l'enregistrerait toujours dans la base de données car @org.springframework.data.annotation.Transient s'applique uniquement aux frameworks de mappage d'objets et non à JPA.

Donc, pour récapituler:

transient est pour toutes les sérialisations (sur le fil, sauvegarde sur disque, sauvegarde sur db)
javax.persistence.Transient est spécifiquement pour la sérialisation JPA DB @org.springframework.data.annotation.Transient est pour les sérialisations d'ObjectMapping Framework utilisées dans Spring

19
Shivam Sinha