public class Task221124_1 {
    public static void main(String[] args) {
        int[] arr = {3, 5, 7, 9, 11};
        int result = modifyArray(arr);
        System.out.println(result);
        System.out.println(arr[1]);
    }

    public static int modifyArray(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] % 2 == 0 ? array[i] / 2 : array[i] * 2;
            sum += array[i];
        }
        return sum;
    }
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

    @Transactional
    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        // Операции с базой данных
        debitAccount(fromAccountId, amount);
        creditAccount(toAccountId, amount);
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика снятия средств
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика зачисления средств
    }
}
В этом примере все операции внутри метода transferMoney выполняются в одной транзакции. Если любая операция завершится сбоем, все изменения будут откатаны.

@Transactional(
    propagation = Propagation.REQUIRES_NEW,
    isolation = Isolation.SERIALIZABLE,
    timeout = 30,
    rollbackFor = {RuntimeException.class},
    readOnly = false
)
public void processTransaction() {
    // Логика транзакции
}

@Transactional(rollbackFor = Exception.class)
public void updateDatabase() throws Exception {
    // Если возникает Exception, транзакция будет откатана
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class OrderService {

    public void createOrder() {
        // Операции в транзакции
    }

    public void cancelOrder() {
        // Операции в транзакции
    }
}

@Service
public class ExampleService {

    @Transactional
    public void method1() {
        method2(); // method2 вызван напрямую, @Transactional не применяется
    }

    @Transactional
    public void method2() {
        // Логика method2
    }
}
Только публичные методы: Аннотация работает только на публичных методах. Внутренние вызовы приватных или protected методов не активируют транзакцию.

// Транзакция 1
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

// Транзакция 2 (до фиксации транзакции 1)
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 1
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 2
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

// Транзакция 1 (повторное чтение)
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 1
SELECT * FROM orders WHERE amount > 100;

// Транзакция 2
INSERT INTO orders (id, amount) VALUES (10, 150);

// Транзакция 1 (повторное чтение)
SELECT * FROM orders WHERE amount > 100;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void processOrder() {
        // Логика обработки заказа
    }
}

public class Task251124_1 {
    public static void main(String[] args) {
        String str = "aabbccddeeff";
        String result = str.replace("aa", "x")
                           .replace("ee", "y")
                           .replace("xx", "z")
                           .replace("dd", "w");
        System.out.println(result);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ManualTransactionService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void performManualTransaction() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setName("CustomTransaction");
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Выполнение операций в транзакции
            performDatabaseOperation1();
            performDatabaseOperation2();

            // Фиксация транзакции
            transactionManager.commit(status);
        } catch (Exception ex) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw ex;
        }
    }

    private void performDatabaseOperation1() {
        // Логика операции 1
    }

    private void performDatabaseOperation2() {
        // Логика операции 2
    }
}
В этом примере транзакция начинается вручную, и ее выполнение зависит от логики программы. Если возникает ошибка, транзакция откатывается.

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

@Service
public class TemplateTransactionService {

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void executeInTransaction() {
        transactionTemplate.execute(status -> {
            try {
                performDatabaseOperation1();
                performDatabaseOperation2();
            } catch (Exception ex) {
                status.setRollbackOnly(); // Указание на откат транзакции
                throw ex;
            }
            return null;
        });
    }

    private void performDatabaseOperation1() {
        // Логика операции 1
    }

    private void performDatabaseOperation2() {
        // Логика операции 2
    }
}

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

COMMIT;
В этом случае изменения будут сохранены в базе данных.

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

ROLLBACK;
В этом случае все изменения будут отменены.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ManualTransactionService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Дебет с одного счета
            debitAccount(fromAccountId, amount);

            // Кредит на другой счет
            creditAccount(toAccountId, amount);

            // Подтверждение транзакции
            transactionManager.commit(status);
        } catch (Exception ex) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw ex;
        }
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика дебетовой операции
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика кредитной операции
    }
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

    @Transactional
    public void processPayment(Long orderId) {
        try {
            // Обновление информации о заказе
            updateOrder(orderId);

            // Обновление платежной информации
            updatePayment(orderId);
        } catch (Exception e) {
            // Логика обработки исключения
            throw new RuntimeException("Ошибка при обработке платежа");
        }
    }

    private void updateOrder(Long orderId) {
        // Логика обновления заказа
    }

    private void updatePayment(Long orderId) {
        // Логика обновления платежа
    }
}
Если возникает RuntimeException, Spring автоматически откатывает транзакцию.

import org.springframework.transaction.interceptor.TransactionAspectSupport;

public void performOperation() {
    try {
        // Код операции
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

public class Task261124_1 {
    public static void main(String[] args) {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Index error");
            throw new RuntimeException("Runtime exception thrown");
        } finally {
            System.out.println("Finally block");
        }
    }
}