[JAVA] J'ai essayé de vérifier ceci et celui de Spring @ Transactional

«@ Transactional» de Spring est une annotation pratique qui revient automatiquement lorsqu'une exception se produit. Cependant, (je) ne vérifie pas la restauration dans le test unitaire, et parfois je me demande si cela fonctionne vraiment.

J'ai donc essayé de vérifier le mouvement de @ Transactional de différentes manières.

** Environnement de confirmation ** JDK 1.8.0 Spring Boot 2.0.5.RELEASE Doma2.0

@ Transactional ne fonctionne que s'il est attaché à une méthode appelée directement depuis la classe DI

Procédure de vérification

1. Appelez la méthode A dans le service qui est DI à partir du contrôleur.
2. Appelez la méthode B avec «@ Transactional» à partir de la méthode A.
3. Soulevez une exception immédiatement après avoir inséré un enregistrement dans la base de données avec la méthode B.

code de vérification

manette

public class TestController {

    @Autowired
    TestService testService;

    @PostMapping("/post")
    public void postTest() {
        testService.insertMethodA();
    }
}

un service

@Service
public class TestService {

    @Autowired
    ItemDao itemDao;

    public void insertMethodA() {
        insertMethodB();
    }

    @Transactional
    public void insertMethodB() {

        //Insérer un enregistrement prêt
        Item item = new Item();
        item.setItemCd("1");
        item.setItemName("hoge");
        item.setSellFlg("0");

        //Insérer un enregistrement
        itemDao.insert(item);

        //Il y a une exception
        throw new RuntimeException();
    }
}

Résultat d'exécution

Il a été inséré sans être annulé.

mysql> select * from item;
+---------+-----------+----------+
| ITEM_CD | ITEM_NAME | SELL_FLG |
+---------+-----------+----------+
| 1       | hoge      | 0        |
+---------+-----------+----------+

Correction de code

Ajoutez @ Transactional à la méthode A.

    @Transactional
    public void insertMethodA() {
        insertMethodB();
    }

    public void insertMethodB() {

        //Insérer un enregistrement prêt
        Item item = new Item();
        item.setItemCd("1");
        item.setItemName("hoge");
        item.setSellFlg("0");

        //Insérer un enregistrement
        itemDao.insert(item);

        //Il y a une exception
        throw new RuntimeException();
    }

** Résultat d'exécution **

mysql> select * from item;
Empty set (0.00 sec)

Il a été annulé. Oui ok ~.

Si vous ajoutez @ Transactinal à une classe, il sera attaché à toutes les méthodes de la classe.

L'ajout de «@ Transactional» à une classe ajoute implicitement «@ Transactional» à toutes les méthodes de la classe.

Procédure de vérification

1. Ajoutez @ Transactional à la classe de service
2. Appelez la méthode A depuis le contrôleur sans ajouter @ Transactional

code de vérification

Le contrôleur est le même que celui ci-dessus (appelez la méthode A depuis la classe de service).

un service

@Service
@Transactional
public class TestService {

    @Autowired
    ItemDao itemDao;

    public void insertMethodA() {
        insertMethodB();
    }

    public void insertMethodB() {

        //Insérer un enregistrement prêt
        Item item = new Item();
        item.setItemCd("1");
        item.setItemName("hoge");
        item.setSellFlg("0");

        //Insérer un enregistrement
        itemDao.insert(item);

        //Il y a une exception
        throw new RuntimeException();
    }
}

Résultat d'exécution

Il a été annulé. L'appel de la méthode B à partir du contrôleur a également été annulé.

mysql> select * from item;
Empty set (0.00 sec)

Une exception est levée lorsque vous essayez de manipuler un enregistrement avec l'attribut readonly défini sur true

@ Transactinal a un attribut appelé readonly, et si vous le définissez sur true, il lèvera une exception lors de l'exécution du processus d'opération d'enregistrement.

code de vérification

Le contrôleur utilisé ci-dessus.

un service

@Service
public class TestService {

    @Autowired
    ItemDao itemDao;

    @Transactional(readOnly = true)
    public void insertMethodA() {
        insertMethodB();
    }

    public void insertMethodB() {

        //Insérer un enregistrement prêt
        Item item = new Item();
        item.setItemCd("1");
        item.setItemName("hoge");
        item.setSellFlg("0");

        //Insérer un enregistrement
        itemDao.insert(item);
    }
}

Résultat d'exécution

java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

Il est préférable de le définir comme un service d'acquisition qui n'est pas censé être mis à jour.

Vous pouvez définir une exception d'occurrence de cible d'annulation avec l'attribut rollbackFor

Par défaut, les exceptions annulées sont «RuntimeException» et ses sous-classes. L'attribut rollbackFor remplace la classe d'exception définie dans la valeur et ses sous-classes par l'exception levée à restaurer.

code de vérification

Déclenche une exception ʻExceptiondans l'état par défaut sansrollbackFor`.

@Service
public class TestService {

    @Autowired
    ItemDao itemDao;

    @Transactional
    public void insertMethodA() throws Exception{
        insertMethodB();
    }

    public void insertMethodB() throws Exception{

        //Insérer un enregistrement prêt
        Item item = new Item();
        item.setItemCd("1");
        item.setItemName("hoge");
        item.setSellFlg("0");

        //Insérer un enregistrement
        itemDao.insert(item);

        //Il y a une exception
        throw new Exception();
    }
}

Résultat d'exécution

Il ne sera pas annulé.

mysql> select * from item;
+---------+-----------+----------+
| ITEM_CD | ITEM_NAME | SELL_FLG |
+---------+-----------+----------+
| 1       | hoge      | 0        |
+---------+-----------+----------+

Changement de code

Définissez rollbackFor sur ʻException.class`.

    @Transactional(rollbackFor = Exception.class)
    public void insertMethodA() throws Exception{
        insertMethodB();
    }

Résultat de l'exécution (après modification)

Il est maintenant annulé.

mysql> select * from item;
Empty set (0.00 sec)

@ Transactional attaché à la classe externe ne s'applique pas à la classe interne

Le @ Transactional attaché à la classe externe ne s'applique pas à la classe interne, il doit donc être attaché à la classe interne séparément. Soyez prudent lorsque vous utilisez des classes internes dans Junit pour superposer des classes de test.

code de vérification

manette

public class TestController {

    @Autowired
    TestService testService;

    @Autowired
    TestService.TestInnerService testInnerService;

    @PostMapping("/post")
    public void postTest() throws Exception{
       testInnerService.insertMethodA();
    }
}

un service

@Service
@Transactional
public class TestService {

    @Autowired
    ItemDao itemDao;

    @Service
    public class TestInnerService{

        public void insertMethodA() throws Exception{
            insertMethodB();
        }

        public void insertMethodB(){

            //Insérer un enregistrement prêt
            Item item = new Item();
            item.setItemCd("1");
            item.setItemName("hoge");
            item.setSellFlg("0");

            //Insérer un enregistrement
            itemDao.insert(item);

            //Il y a une exception
            throw new RuntimeException();
        }
    }
}

Résultat d'exécution

Non annulé.

mysql> select * from item;
+---------+-----------+----------+
| ITEM_CD | ITEM_NAME | SELL_FLG |
+---------+-----------+----------+
| 1       | hoge      | 0        |
+---------+-----------+----------+

Changement de code

Ajoutez @ Transactinal à la classe interne.

    @Service
    @Transactional
    public class TestInnerService{

Résultat de l'exécution (après modification)

Il a été annulé.

mysql> select * from item;
Empty set (0.00 sec)