1. Exemples de scénarios d'utilisation
Avant de comprendre comment @Transactional est utilisé, nous devons d'abord savoir ce que @Transactional est utile. Permettez-moi de vous donner un coup de pouce: par exemple, il y a de nombreux membres dans un département, et ces deux sont stockés dans la table du département et le tableau des membres respectivement. Lors de la suppression d'un certain département, supposons que nous supprimons les membres correspondants par défaut. Cependant, cela peut se produire lors de l'exécution. Nous supprimons d'abord le département, puis supprimons les membres. Cependant, le ministère l'a supprimé avec succès et une exception s'est produite lors de la suppression des membres. Pour le moment, nous espérons que si la suppression du membre échoue, le département supprimé précédemment annulera également la suppression. Ce scénario peut être annulé à l'aide de choses @transactionnelles.
2. Exception vérifiée et exception non contrôlée
La raison pour laquelle nous faisons connaître tout le monde les concepts des exceptions vérifiées et des exceptions incontrôlées est que:
Spring utilise le traitement des transactions déclaratives. Par défaut, si une exception non contrôlée se produit dans la méthode de fonctionnement de la base de données annotée, toutes les opérations de base de données seront en retour; Si l'exception se produit est une exception vérifiée, les opérations de base de données seront toujours soumises par défaut.
Exception vérifiée:
Invalide, pas prévisible dans le programme. Par exemple, l'entrée utilisateur non valide, le fichier n'existe pas, les erreurs de liaison de base ou de base de données. Ce sont toutes des raisons externes et ne sont pas contrôlées par le programme.
Doit être géré explicitement dans le code. Par exemple, le traitement des blocs d'essais ou jetez l'exception à la couche précédente de la pile d'appels avec la description des lancers.
Hérité de java.lang.exception (sauf java.lang.runtimeException).
Exception non contrôlée:
Indique une erreur, la logique du programme est erronée. Il s'agit d'une sous-classe de RuntimeException, comme illégalArgumentException, NullPointerException et illégalStateException.
Il n'est pas nécessaire de prendre explicitement des exceptions non contrôlées dans le code de traitement.
Hérité de java.lang.runtimeException (et java.lang.runtimeException hérite de java.lang.exception).
En regardant le diagramme de structure anormal ci-dessous, il peut être plus en couches:
3. Exemple d'utilisation de @Transactional
Cet exemple utilise Eclipse + Maven. Maven n'est géré que comme un pot, et même les amis de Maven qui ne comprennent pas peuvent le comprendre.
3.1. Fichier de configuration de ressort
L'espace de noms TX doit être configuré en premier comme suit:
Afin d'utiliser la gestion des transactions basée sur @ transactionnelle, la configuration suivante est requise à Spring:
<bean id = "AppTransActionManager"> <propriété name = "dataSource" ref = "dataSource" /> </ank> <tx: annotation-proxy-target-class = "false" transaction-manager = "apptRansactionManager" />
L'ensemble du fichier de configuration de printemps du blogueur:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/context" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: aop/schema/aop " xsi: schemalocation = "http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/bans http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/springframework.org/schema/aop://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0. Fichier de configuration JDBC -> <bean id = "propriétéConfigurer"> <propriété name = "Locations"> <sist> <value> classPath: Properties / *. Propriétés </salue> <! - S'il existe plusieurs fichiers de configuration, continuez simplement pour les ajouter ici -> </sist> </parewet> </pan> <! <! - Configurer les propriétés -> <! - Configurer les propriétés -> <! - <propriété name = "driverclassname" value = "com.mysql.jdbc.driver" /> <propriété name = "url" value = "jdbc: mysql: // localhost: 3306 / apprenti Value = "Christmas258 @" /> -> <! - Utilisez des propriétés pour configurer -> <propriété name = "DriverClassName"> <value> $ {jdbc_driverclassname} </value> </ propriété> <propriété name = "URL"> <value> $ {jdbc_url} </value> </prophe <value> $ {jdbc_username} </value> </ propriété> <propriété name = "mot de passe"> <value> $ {jdbc_password} </value> </ propriété> </ bean> <bean id = "AppTransactionManager"> <propriété name = "DataSource" Ref = "Datasource" /> </EAND> <TX: annotation-driven " Proxy-Target-Class = "false" Transaction-Manager = "AppTransActionManager" /> <! - Annuez automatiquement tous les fichiers d'interface de mappeur correspondant à xxxxmapper.xml, afin que vous n'ayez pas besoin de configurer manuellement le mappage de mpper par un. Tant que la classe d'interface du mappeur et le fichier de mappage de mappel correspondent les uns aux autres. -> <an bean> <propriété name = "basepackage" value = "com.luo.dao" /> </-bean> <! - Configurez le fichier mybatis, Mappenlocations Configure ** MAPPER.XML Fichier Emplacement, configlocation Configurer MyBatis-Config Fichier Location -> <Bean Id = "SQLSessionFactory"> <Propriété Nom = "DataSource" Ref = "Datasource" name = "mapperlocations" value = "classpath: mappe / *. xml" /> <propriété name = "configLocation" value = "classpath: mybatis / mybatis-clonfig.xml" /> <! <Context: Component-Scan Base-Package = "com.luo.service" /> </ beans>3.2. Utilisez @Transactional pour ajouter des annotations à la méthode de la classe d'implémentation de l'utilisateur
@Transactional (propagation = propagation.Required) public void addUser (utilisateur utilisateur) {userdao.adDuser (utilisateur); String string = null; if (string.equals ("")) {int i = 0; }}Dans la méthode ci-dessus, je l'ai délibérément fait avoir une exception de pointeur nul et les choses reviendront
3.3. Exécutez la classe de test unitaire
@Test public void AddUserTest () {utilisateur utilisateur = new user (); user.setUsername ("LuoguoHUi1"); user.SetUserPassword ("LuoguoHUI1"); userService.adDuser (utilisateur);}J'ai trouvé qu'il ne pouvait pas être inséré, mais si @Transactional est supprimé, le code est le suivant. Bien qu'une exception se produise, il y a toujours des données correspondantes ajoutées à la base de données:
3.4. Téléchargement du code source
Téléchargez le code source final de cet article: premier_maven_project_jb51.rar
4. Les concepts que @transactionnels au printemps doivent être compris
@Transactional in Spring est basé sur le mécanisme de proxy dynamique et fournit un mécanisme de gestion des transactions transparente pour faciliter et résoudre rapidement les problèmes rencontrés dans le développement.
Généralement, il s'agit de commenter des méthodes ou des interfaces ou des classes via le code suivant:
@Transactional (propagation = propagation.not_supported)
La propagation prend en charge 7 mécanismes de propagation différents:
Obligatoire: Si une transaction existe, la transaction actuelle est prise en charge. S'il n'y a pas de transaction, une nouvelle transaction est démarrée.
Soutien: Si une transaction existe, la transaction actuelle est prise en charge. S'il n'y a pas de transaction, l'exécution de la non-transaction. Cependant, pour les gestionnaires de transactions de synchronisation des transactions, Propagation_Supports est légèrement différent de ne pas utiliser de transactions.
NOT_SUPPORTED: EXÉCUTEZ TOUJOURS TRANSATIVALEMENT ET SUPPENSEZ TOUTE TRANSACTION EXISTANT.
ExigeNew: Démarrez toujours une nouvelle transaction. Si une transaction existe déjà, la transaction existante est suspendue.
Obligatoire: si une transaction existe déjà, soutenez la transaction actuelle. S'il n'y a pas de transaction active, une exception est lancée.
Jamais: toujours exécuter non transactionnel, s'il existe une transaction active, une exception est jetée
Nested: Si une transaction active existe, elle s'exécute dans une transaction imbriquée. S'il n'y a pas de transaction active, appuyez sur la propriété requise pour s'exécuter.
Voici quelques choses à noter, qui doivent être lues, sinon, si vous rencontrez divers pièges, le blogueur ne vous a pas rappelé:
Voici quelques choses à noter, qui doivent être lues, sinon, si vous rencontrez divers pièges, le blogueur ne vous a pas rappelé:
Voici quelques choses à noter, qui doivent être lues, sinon, si vous rencontrez divers pièges, le blogueur ne vous a pas rappelé:
Ajoutez une annotation @transactionnelle où la gestion des transactions est requise. @Transactional Annotations peut être appliquée aux définitions d'interface et aux méthodes d'interface, aux définitions de classe et aux méthodes publiques des classes.
@Transactional Annotations ne peut être appliquée qu'aux méthodes avec visibilité publique. Si vous utilisez une annotation @transactionnelle sur les méthodes protégées, privées ou visibles à package, elle ne signalera pas d'erreur, mais cette méthode annotée n'affichera pas les paramètres de transaction configurés.
Notez que l'occurrence de l'annotation @transactionnelle ne suffit pas pour permettre le comportement de transaction, ce n'est qu'une sorte de métadonnées. L'élément de configuration doit être utilisé dans le fichier de configuration pour vraiment activer le comportement de transaction.
Contrôle si un proxy basé sur une interface ou basé sur les classes est créé via la valeur d'attribut "proxy-ciblement de proxy" de l'élément. Si la valeur de genre "proxy-ciblement" est définie sur "vrai", le proxy basé sur la classe fonctionnera (cela est nécessaire pour cglib.jar dans ClassPath). Si la valeur de genre "proxy-ciblement" est définie sur "false" ou si cette propriété est omise, le proxy basé sur l'interface JDK standard fonctionnera.
L'équipe de printemps recommande d'utiliser @Transactional Annotation sur des classes spécifiques (ou des méthodes de classes) plutôt que sur les interfaces que la classe souhaite implémenter. L'utilisation de l'annotation @transactionnelle sur une interface ne prendra effet que lorsque vous configurez un proxy basé sur l'interface. Étant donné que les annotations ne peuvent pas être héritées, cela signifie que si un proxy basé sur la classe est utilisé, les paramètres de transaction ne seront pas reconnus par le proxy basé sur la classe et l'objet ne sera pas enveloppé par le proxy de transaction.
La transaction de Transactional est activée, une interface ou un proxy basé sur la classe est créée. Ainsi, dans la même classe, une méthode appelle une autre méthode avec les transactions, la transaction ne fonctionnera pas.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.