Programmatic এবং Declarative Transaction Management

iBATIS (MyBatis), যদিও এটি একটি SQL Mapping framework, তবুও এটি transaction management জন্য programmatic এবং declarative পদ্ধতি সাপোর্ট করে। Transaction Management খুবই গুরুত্বপূর্ণ কারণ এটি নিশ্চিত করে যে ডেটাবেস অপারেশনগুলো সঠিকভাবে সম্পাদিত হচ্ছে এবং সিস্টেমে কোনো ইনকনসিস্টেন্সি না আসে।

iBATIS (MyBatis) এর মাধ্যমে আপনি programmatic এবং declarative transaction management করতে পারবেন। এখানে এই দুই ধরনের পদ্ধতির বিস্তারিত আলোচনা করা হলো।

1. Programmatic Transaction Management in iBATIS (MyBatis)

Programmatic Transaction Management-এ আপনি transaction এর কার্যক্রম কনফিগারেশন কোডের মাধ্যমে নিয়ন্ত্রণ করেন, যেমন SqlSession এর মাধ্যমে। এই পদ্ধতিতে, আপনি commit এবং rollback ম্যানুয়ালি কল করেন।

Steps for Programmatic Transaction Management:

1. Open a session using SqlSessionFactory.
2. Start the transaction using the session.
3. Perform the database operations (insert, update, delete).
4. Commit the transaction if everything goes as expected.
5. If any exception occurs, you can rollback the transaction.
6. Close the session after the operations are complete.

Example: Programmatic Transaction Management

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;

public class ProgrammaticTransactionExample {

    public static void main(String[] args) {
        SqlSessionFactory sqlSessionFactory = null;
        SqlSession session = null;

        try {
            // Step 1: Initialize SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));

            // Step 2: Open a new SqlSession
            session = sqlSessionFactory.openSession();

            // Step 3: Get the mapper
            EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);

            // Step 4: Perform the database operations
            Employee employee = new Employee();
            employee.setName("John Doe");
            employee.setEmail("john.doe@example.com");

            // Insert a new employee
            employeeMapper.insertEmployee(employee);

            // Step 5: Commit the transaction
            session.commit();  // Commit the transaction if no exception occurs

        } catch (Exception e) {
            // Step 6: Rollback in case of an error
            if (session != null) {
                session.rollback();
            }
            e.printStackTrace();
        } finally {
            // Step 7: Close the session
            if (session != null) {
                session.close();
            }
        }
    }
}

Explanation:

• session.commit(): যখন সমস্ত অপারেশন সঠিকভাবে সম্পন্ন হয়, তখন commit কল করা হয়।
• session.rollback(): যদি কোনো ত্রুটি ঘটে, তাহলে সমস্ত অপারেশন রোলব্যাক করা হয়।
• session.close(): সেশন শেষ হওয়ার পর সেশনটি বন্ধ করা হয়।

2. Declarative Transaction Management in iBATIS (MyBatis)

Declarative Transaction Management-এ, Spring এর মতো frameworks ব্যবহার করে ট্রানজেকশন ম্যানেজমেন্ট পরিচালনা করা হয়। এখানে আপনি @Transactional অ্যানোটেশন ব্যবহার করে বা Spring configuration দিয়ে ট্রানজেকশন পরিচালনা করতে পারেন।

Steps for Declarative Transaction Management:

1. Enable Spring Transaction Management.
2. Define a transactional method using @Transactional annotation.
3. Spring automatically manages the commit and rollback.

Example: Declarative Transaction Management with Spring and MyBatis

Step 1: Add Spring and MyBatis Dependencies

<dependencies>
    <!-- Spring Core and Data JPA for Declarative Transaction Management -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.8</version>
    </dependency>

    <!-- MyBatis Spring Integration -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>

    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
</dependencies>

Step 2: Configure applicationContext.xml for Transaction Management

In Spring, you can enable transaction management using annotation-driven configuration.

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- Enable annotation-driven transaction management -->
    <tx:annotation-driven transaction-manager="transactionManager" />

    <!-- Define a DataSource (MySQL example) -->
    <bean id="dataSource" class="org.apache.tomcat.jdbc.pool.DataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/your_database" />
        <property name="username" value="root" />
        <property name="password" value="password" />
    </bean>

    <!-- Define SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.apache.ibatis.session.SqlSessionFactoryBuilder">
        <constructor-arg ref="dataSource"/>
    </bean>

    <!-- Define the Mapper interface -->
    <bean id="employeeMapper" class="com.yourpackage.mapper.EmployeeMapper"/>

    <!-- Define Transaction Manager -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

Step 3: Create a Service Method with @Transactional Annotation

In the service layer, you can use the @Transactional annotation to enable declarative transaction management.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class EmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;

    @Transactional
    public void addEmployee(Employee employee) {
        // Insert employee
        employeeMapper.insertEmployee(employee);
        
        // If there was a problem here, the transaction will be rolled back automatically
    }
}

Explanation:

• @Transactional: Spring automatically manages the commit and rollback based on whether an exception occurs inside the method. If an exception occurs, it will roll back the transaction; otherwise, it will commit the changes.
• The EmployeeService class method addEmployee is automatically wrapped in a transaction.

Step 4: Create EmployeeMapper Interface and Mapper XML

You will need an EmployeeMapper interface for the actual SQL operations:

public interface EmployeeMapper {
    void insertEmployee(Employee employee);
}

And the corresponding Mapper XML:

<mapper namespace="com.yourpackage.mapper.EmployeeMapper">
    <insert id="insertEmployee" parameterType="Employee">
        INSERT INTO employees (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>

Advantages of Declarative vs Programmatic Transaction Management

• Programmatic Transaction Management gives you full control over transactions and is often used when you need to manage complex or customized transaction behaviors.
• Declarative Transaction Management simplifies transaction handling by automatically managing commits and rollbacks using annotations, making it ideal for standard operations and working with Spring-based applications.

For iBATIS (MyBatis) users, both transaction management approaches are supported. You can choose between them based on your application's requirements, complexity, and framework usage (e.g., Spring).