# @Transactional

<br>

### What is @Transactional?

* When @Transactional is applied to a class or method, it guarantees that methods within that scope become transactional
* Also called **declarative transaction** because it facilitates management simply by declaration without having to directly create objects
* Especially in SpringBoot, the various settings needed for declarative transactions are already configured, making it even easier to use

<br>

### Is @Transactional(readOnly=true) Really Necessary?

* It is better to use it!
* Why?
  * Even when returning queried data, it prevents `unintended data changes` in advance
    * Prevents unexpected entity registration, modification, and deletion
  * When querying an Entity in `read-only` mode, there is no need to maintain a snapshot for change detection, and there is no need to flush the persistence context, allowing for performance optimization
    * When the `readOnly=true` option is given to a transaction, the Spring Framework sets the Hibernate session flush mode to MANUAL
      * This means no flush will occur unless a flush is explicitly called!
    * Therefore, even when committing the transaction, the persistence context is not flushed, so entity registration, modification, and deletion do not work
      * Also, since the persistence context does not keep snapshots for change detection in read-only mode, performance is improved
  * With this option, CUD operations do not work, and snapshot storage and dirty checking are not performed, improving performance
    * What is `Dirty check`?
      * State change detection
      * Connected to the persistence context
        * In JPA, at the point when a transaction ends, all entity objects with changes are automatically reflected in the database
        * In JPA, when an entity is queried, a snapshot of the initial query state is created
        * At the point when the transaction ends, this snapshot is compared, and if there are differences, an Update Query is sent to the database
  * In MySQL `dual configuration (Master - Slave)`, if the DB is divided into master and slave, cases with readOnly = true will call the slave for read-only operations instead of the master
    * Depending on the situation, it can reduce the load on the DB server and provide some optimization
  * If the @Transactional(readOnly=true) annotation is present, people encountering the code can intuitively expect that the method will only perform READ operations

<br>

### Spring @Transactional vs javax @Transactional

* javax @Transactional
  * Java standard extension package
  * Provided by default in Java
* Spring @Transactional
  * Provided by org.springframework
  * Managed by the Spring Container
* Reason to use `org.springframework.transaction.annotation.Transactional`
  * It provides many Options
    * `isolation`: the underlying database isolation level
    * `noRollbackFor` and `noRollbackForClassName`: the list of Java `Exception` classes that can be triggered without triggering a transaction rollback
    * `rollbackFor` and `rollbackForClassName`: the list of Java `Exception` classes that trigger a transaction rollback when being thrown
    * `propagation`: the transaction propagation type given by the `[Propagation](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/annotation/Propagation.html)` Enum. For instance, if the transaction context can be inherited (e.g., `REQUIRED`) or a new transaction context should be created (e.g., `REQUIRES_NEW`) or if an exception should be thrown if no transaction context is present (e.g., `MANDATORY`) or if an exception should be thrown if a current transaction context is found (e.g., `NOT_SUPPORTED`).
    * `readOnly`: whether the current transaction should only read data without applying any changes.
    * `timeout`: how many seconds should the transaction context be allowed to run until a timeout exception is thrown.
    * `value` or `transactionManager`: the name of the Spring `TransactionManager` bean to be used when binding the transaction context.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://chloe-codes1.gitbook.io/til/spring/spring-annotations/02_transactional.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.