Spring 事务失效

/**
 * 【Spring 独有】使用后端数据库默认的隔离级别
 *
 * MySQL 默认采用的 REPEATABLE_READ隔离级别
 * Oracle 默认采用的 READ_COMMITTED隔离级别
 */
int ISOLATION_DEFAULT = -1;

/**
 * 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
 */
int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;

/**
 * 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
 */
int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
/**
 * 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
 */
int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
/**
 * 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。
 *
 * 但是这将严重影响程序的性能。通常情况下也不会用到该级别。
 */
int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;

// ========== 支持当前事务的情况 ========== 

/**
 * 如果当前存在事务，则使用该事务。
 * 如果当前没有事务，则创建一个新的事务。
 */
int PROPAGATION_REQUIRED = 0;
/**
 * 如果当前存在事务，则使用该事务。
 * 如果当前没有事务，则以非事务的方式继续运行。
 */
int PROPAGATION_SUPPORTS = 1;
/**
 * 如果当前存在事务，则使用该事务。
 * 如果当前没有事务，则抛出异常。
 */
int PROPAGATION_MANDATORY = 2;

// ========== 不支持当前事务的情况 ========== 

/**
 * 创建一个新的事务。
 * 如果当前存在事务，则把当前事务挂起。
 */
int PROPAGATION_REQUIRES_NEW = 3;
/**
 * 以非事务方式运行。
 * 如果当前存在事务，则把当前事务挂起。
 */
int PROPAGATION_NOT_SUPPORTED = 4;
/**
 * 以非事务方式运行。
 * 如果当前存在事务，则抛出异常。
 */
int PROPAGATION_NEVER = 5;

// ========== 其他情况 ========== 

/**
 * 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行。
 * 如果当前没有事务，则等价于 {@link TransactionDefinition#PROPAGATION_REQUIRED}
 */
int PROPAGATION_NESTED = 6;

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMapper orderMapper;

    @Transactional
    @Override
    public void parent() {
        try {
            this.child();

        } catch (Exception e) {
            log.error("插入异常", e);
        }


        Order order = new Order();
        order.setOrderNo("parent");
        order.setStatus("0");
        order.setTitle("parent");
        order.setAmount("1000");
        orderMapper.insert(order);
    }


    @Transactional
    @Override
    public void child() {

        Order order = new Order();
        order.setOrderNo("child");
        order.setStatus("0");
        order.setTitle("child");
        order.setAmount("2000");
        orderMapper.insert(order);

        throw new RuntimeException();
    }
}

    @Autowired
    private ApplicationContext context;

    private OrderService orderService;

    @PostConstruct
    public void init() {
        orderService = context.getBean(OrderService.class);
    }


    @Transactional
    @Override
    public void parent() {
        try {
            //获取代理对象，通过代理对象调用child()
            orderService.child();

　　　　　　　//获取代理对象
            //OrderService orderService = (OrderService) AopContext.currentProxy();
            //orderService.child();
        } catch (Exception e) {
            log.error("插入异常", e);
        }


        Order order = new Order();
        order.setOrderNo("parent");
        order.setStatus("0");
        order.setTitle("parent");
        order.setAmount("1000");
        orderMapper.insert(order);
    }

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void child() {

	Order order = new Order();
	order.setOrderNo("child");
	order.setStatus("0");
	order.setTitle("child");
	order.setAmount("2000");
	orderMapper.insert(order);

	throw new RuntimeException();
}