Transactions are an important part of many applications, especially those that involve database interactions. In Spring Framework, you can manage transactions declaratively using Spring's transaction management support.

Here's an overview of how transaction management works in Spring

Define a transaction manager:

Spring provides a number of transaction managers that you can use with different databases and transaction APIs. You can define a transaction manager in your Spring configuration file or as a bean in your application context.

Annotate your service methods:

You can use Spring's @Transactional annotation to mark methods that should be executed within a transaction. You can apply the annotation to individual methods or to entire classes.

Configure transaction properties:

You can configure properties for your transactions, such as isolation level, propagation behavior, and timeout, by setting the attributes of the @Transactional annotation.

Rollback on exceptions:

By default, Spring will roll back a transaction if an unchecked exception is thrown during its execution. You can customize this behavior by specifying which exceptions should trigger a rollback.

Here's an example of how to use transactions in Spring Framework:

                
    @Service
    @Transactional
    public class UserService {

        @Autowired
        private UserRepository userRepository;

        public User createUser(String name, String email) {
            User user = new User(name, email);
            return userRepository.save(user);
        }

        public List<User> getAllUsers() {
            return userRepository.findAll();
        }
    }
                
            

In this example, we have a UserService class that provides methods for creating and retrieving users. We've marked this class with the @Service annotation to indicate that it should be managed by Spring's application context. We've also marked the class with the @Transactional annotation to indicate that all methods in this class should be executed within a transaction.

We've injected a UserRepository instance using the @Autowired annotation. This repository provides methods for interacting with a database.

The createUser method creates a new user and saves it to the database using the userRepository.save method. Because this method is executed within a transaction, any changes made to the database will be rolled back if an exception is thrown during the method's execution.

The getAllUsers method retrieves all users from the database using the userRepository.findAll method. Because this method is also executed within a transaction, we can be sure that we're getting a consistent view of the database.

Overall, Spring's transaction management support provides a powerful way to manage transactions in your application, without having to write boilerplate code for transaction management. By using annotations to mark methods that should be executed within transactions, you can keep your code concise and focused on business logic, while leaving the transaction management details to Spring.