org.apache.shardingsphere.transaction.core.TransactionTypeHolder Java Examples

@Test
public void assertShardingTransactionSkipAutoCommit() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.setAutoCommit(true);
        assertFalse(actual.getShardingTransactionManager().isInTransaction());
    } finally {
        TransactionTypeHolder.clear();
    }
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.setAutoCommit(false);
        assertTrue(actual.getShardingTransactionManager().isInTransaction());
        assertThat(XAShardingTransactionManagerFixture.getInvocations().size(), is(1));
        actual.setAutoCommit(false);
        assertThat(XAShardingTransactionManagerFixture.getInvocations().size(), is(1));
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Override
public void processFailure() throws SQLException {
    System.out.println("-------------------- Process Start ---------------------");
    TransactionTypeHolder.set(TransactionType.XA);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.rollback();
        System.out.println("INSERT 10 orders failed");
    } finally {
        TransactionTypeHolder.clear();
    }
    int quantity = selectAll();
    System.out.printf("Rollback, expect:0, actual:%d \n", quantity);
    printData();
    System.out.println("-------------------- Process End -----------------------");
}
 

@Override
public void processSuccess() throws SQLException {
    System.out.println("-------------------- Process Start ---------------------");
    TransactionTypeHolder.set(TransactionType.XA);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.commit();
        System.out.println("INSERT 10 orders success");
    } finally {
        TransactionTypeHolder.clear();
    }
    int quantity = selectAll();
    System.out.printf("Commit, expect:10, actual:%d \n", quantity);
    printData();
    System.out.println("-------------------- Process End -----------------------");
}
 

@Test
public void assertShardingTransactionAutoCommit() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.createStatement().executeQuery(sql);
        actual.setAutoCommit(false);
        actual.createStatement().executeQuery(sql);
        assertTrue(actual.getShardingTransactionManager().isInTransaction());
        Multimap<String, Connection> cachedConnections = getCachedConnections(actual);
        assertThat(cachedConnections.size(), is(1));
        for (Connection each : cachedConnections.values()) {
            assertTrue(each.getAutoCommit());
        }
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Test
public void assertGetXaConnectionThenGetLocalConnection() throws SQLException {
    DataSource dataSource = mockDataSource(DatabaseTypes.getActualDatabaseType("MySQL"));
    Map<String, DataSource> dataSourceMap = new HashMap<>(1, 1);
    dataSourceMap.put("ds", dataSource);
    TransactionTypeHolder.set(TransactionType.XA);
    ShardingSphereDataSource shardingSphereDataSource = createShardingSphereDataSource(dataSourceMap);
    ShardingSphereConnection connection = shardingSphereDataSource.getConnection();
    assertThat(connection.getDataSourceMap().size(), is(1));
    assertThat(connection.getTransactionType(), is(TransactionType.XA));
    assertThat(connection.getShardingTransactionManager(), instanceOf(XAShardingTransactionManagerFixture.class));
    TransactionTypeHolder.set(TransactionType.LOCAL);
    connection = shardingSphereDataSource.getConnection();
    assertThat(connection.getConnection("ds"), is(dataSource.getConnection()));
    assertThat(connection.getDataSourceMap(), is(dataSourceMap));
    assertThat(connection.getTransactionType(), is(TransactionType.LOCAL));
    assertThat(connection.getShardingTransactionManager() == null, is(true));
}
 

/**
 * Execute XA with exception.
 *
 * @throws SQLException SQL exception
 */
void insertFailed() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.rollback();
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Test
public void assertShardingTransactionType() {
    TransactionType preTransactionType = TransactionTypeHolder.get();
    mockService.executeLocal();
    assertThat(TransactionTypeHolder.get(), is(preTransactionType));
    mockService.executeBase();
    assertThat(TransactionTypeHolder.get(), is(preTransactionType));
    mockService.execute();
    assertThat(TransactionTypeHolder.get(), is(preTransactionType));
}
 

@Override
public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
    ShardingTransactionType shardingTransactionType = getAnnotation(methodInvocation);
    Objects.requireNonNull(shardingTransactionType, "could not found sharding transaction type annotation");
    TransactionType preTransactionType = TransactionTypeHolder.get();
    TransactionTypeHolder.set(shardingTransactionType.value());
    try {
        return methodInvocation.proceed();
    } finally {
        TransactionTypeHolder.clear();
        if (null != preTransactionType) {
            TransactionTypeHolder.set(preTransactionType);
        }
    }
}
 

/**
 * Execute XA.
 *
 * @param count insert record count
 * @return transaction type
 */
@Transactional
@ShardingTransactionType(TransactionType.XA)
public TransactionType insert(final int count) {
    return jdbcTemplate.execute("INSERT INTO t_order (user_id, status) VALUES (?, ?)", (PreparedStatementCallback<TransactionType>) preparedStatement -> {
        doInsert(count, preparedStatement);
        return TransactionTypeHolder.get();
    });
}
 

@Override
@GlobalTransactional(name = "dubbo-purchase")
public void purchase(){
    TransactionTypeHolder.set(TransactionType.BASE);
    OrderEntity orderEntity = new OrderEntity();
    orderEntity.setOrderId(123);
    orderEntity.setStatus("seata");
    orderEntity.setUserId(123);
    orderService.insertOrder(orderEntity);
    System.out.println("XID:"+ RootContext.getXID());
    throw new RuntimeException("回滚测试");
}
 

/**
 * Execute XA.
 *
 * @param count insert record count
 * @return transaction type
 */
@Transactional
@ShardingTransactionType(TransactionType.XA)
public TransactionType insert(final int count) {
    return jdbcTemplate.execute("INSERT INTO t_order (user_id, status) VALUES (?, ?)", (PreparedStatementCallback<TransactionType>) preparedStatement -> {
        doInsert(count, preparedStatement);
        return TransactionTypeHolder.get();
    });
}
 

/**
 * Execute XA.
 *
 * @throws SQLException SQL exception
 */
void insert() throws SQLException {
    TransactionTypeHolder.set(TransactionType.BASE);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.commit();
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

/**
 * Execute XA with exception.
 *
 * @throws SQLException SQL exception
 */
void insertFailed() throws SQLException {
    TransactionTypeHolder.set(TransactionType.BASE);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.rollback();
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

/**
 * Execute XA.
 *
 * @throws SQLException SQL exception
 */
void insert() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO t_order (user_id, status) VALUES (?, ?)");
        doInsert(preparedStatement);
        connection.commit();
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@After
public void clear() {
    try {
        connection.close();
        TransactionTypeHolder.clear();
        XAShardingTransactionManagerFixture.getInvocations().clear();
        BASEShardingTransactionManagerFixture.getInvocations().clear();
    } catch (final SQLException ignored) {
    }
}
 

/**
 * Execute XA.
 *
 * @param count insert record count
 * @return transaction type
 */
@Transactional
@ShardingTransactionType(TransactionType.BASE)
public TransactionType insert(final int count) {
    return jdbcTemplate.execute("INSERT INTO t_order (user_id, status) VALUES (?, ?)", (PreparedStatementCallback<TransactionType>) preparedStatement -> {
        doInsert(count, preparedStatement);
        return TransactionTypeHolder.get();
    });
}
 

@Test
public void assertShardingTransactionCommit() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.commit();
        assertTrue(XAShardingTransactionManagerFixture.getInvocations().contains(TransactionOperationType.COMMIT));
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Test
public void assertShardingTransactionForceCommit() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.setAutoCommit(false);
        actual.setAutoCommit(true);
        assertTrue(XAShardingTransactionManagerFixture.getInvocations().contains(TransactionOperationType.COMMIT));
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Test
public void assertShardingTransactionRollback() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.rollback();
        assertTrue(XAShardingTransactionManagerFixture.getInvocations().contains(TransactionOperationType.ROLLBACK));
    } finally {
        TransactionTypeHolder.clear();
    }
}
 

@Test
public void assertCloseShouldNotClearTransactionType() throws SQLException {
    TransactionTypeHolder.set(TransactionType.XA);
    TransactionType currentTransactionType = TransactionTypeHolder.get();
    try (ShardingSphereConnection actual = getShardingSphereDataSource().getConnection()) {
        actual.createStatement().executeQuery(sql);
    }
    assertThat(TransactionTypeHolder.get(), is(currentTransactionType));
}
 

@Test
public void assertGetXaConnection() throws SQLException {
    DataSource dataSource = mockDataSource(DatabaseTypes.getActualDatabaseType("MySQL"));
    Map<String, DataSource> dataSourceMap = new HashMap<>(1, 1);
    dataSourceMap.put("ds", dataSource);
    TransactionTypeHolder.set(TransactionType.XA);
    ShardingSphereDataSource shardingSphereDataSource = createShardingSphereDataSource(dataSourceMap);
    assertThat(shardingSphereDataSource.getDataSourceMap().size(), is(1));
    ShardingSphereConnection connection = shardingSphereDataSource.getConnection();
    assertThat(connection.getDataSourceMap().size(), is(1));
}
 

@Test
public void assertChangeTransactionTypeInClass() {
    testService.testChangeTransactionTypeInClass();
    assertThat(TransactionTypeHolder.get(), is(TransactionType.LOCAL));
}
 

@ShardingTransactionType
public void testChangeTransactionTypeToLOCAL() {
    assertThat(TransactionTypeHolder.get(), is(TransactionType.LOCAL));
}
 

@ShardingTransactionType(TransactionType.XA)
public void testChangeTransactionTypeToXA() {
    assertThat(TransactionTypeHolder.get(), is(TransactionType.XA));
}
 

@ShardingTransactionType(TransactionType.BASE)
public void testChangeTransactionTypeToBASE() {
    assertThat(TransactionTypeHolder.get(), is(TransactionType.BASE));
}
 

public void testChangeTransactionTypeInClass() {
    assertThat(TransactionTypeHolder.get(), is(TransactionType.XA));
}
 

@Test
public void assertChangeTransactionTypeToXA() {
    testService.testChangeTransactionTypeToXA();
    assertThat(TransactionTypeHolder.get(), is(TransactionType.LOCAL));
}
 

@After
public void tearDown() {
    TransactionTypeHolder.set(TransactionType.LOCAL);
}
 

@Test
public void assertChangeTransactionTypeToBASE() {
    testService.testChangeTransactionTypeToBASE();
    assertThat(TransactionTypeHolder.get(), is(TransactionType.LOCAL));
}
 

@Test
public void assertChangeTransactionTypeToLocal() {
    TransactionTypeHolder.set(TransactionType.XA);
    testService.testChangeTransactionTypeToLOCAL();
    assertThat(TransactionTypeHolder.get(), is(TransactionType.LOCAL));
}