Java编程珠玑(202205)

List list = Lists.newArrayList(new Score().setNo("001").setNum(1), 
			new Score().setNo("001").setNum(1), 
			new Score().setNo("002").setNum(1));

// 按照key分组，value为集合
Map> map = list.stream().collect(Collectors.groupingBy(e -> e.getNo()));

// 按照key分组，key唯一； 
// 注意此时key不能重复，否则出现key冲突； 注意此时value不能为null，否则抛出空指针
Map map1 = list.stream()
			.collect(Collectors.toMap(e -> e.getNo(), Function.identity());

// 按照key分组； 
// 此时，我们指定了冲突合并函数
// 注意此时value不能为null，否则抛出空指针
Map map2 = list.stream()
			.collect(Collectors.toMap(e -> e.getNo(), Function.identity(), (o, n) -> n));

// 同上，异曲同工，优点是value允许为null
Map map3 = list.stream()
			.collect(HashMap::new, (m, v) -> m.put(v.getNo(), v), HashMap::putAll);

@Autowired
private TransactionTemplate transactionTemplate;

// 事务模版执行，防止自调用切面失效
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
     @Override
     protected void doInTransactionWithoutResult(TransactionStatus status) {
         invokeXxx();
     }
 });	

// 事务模版执行，防止自调用切面失效
// 有返回值
 ResultVo result = transactionTemplate.execute(new TransactionCallback() {
     @Override
     public ResultVo doInTransaction(TransactionStatus status) {
         return invokeXxx();
     }
 });
 或lamdba表达式：
 ResultVo result = transactionTemplate.execute(status -> {
    return invokeXxx();
 });

public abstract class AbstractMyTransactionManagerBuilder{
    
    public abstract boolean valid(MyContext context);

    
    protected abstract AbstractPlatformTransactionManager doBuild(MyContext context);

    public final AbstractPlatformTransactionManager build(MyContext context) {
		return doBuild( context);	
	}
}

@Slf4j
public class Demo1TransactionManager extends AbstractPlatformTransactionManager {

    @Component
    public static class Builder extends AbstractMyTransactionManagerBuilder{
        @Autowired
        private DemoService demoService;
        
        @Override
        public boolean valid(MyContext context) {
            if (context == null) {
                return false;
            }
            return true;
        }

        @Override
        protected AbstractPlatformTransactionManager doBuild(MyContext context) {
            return new Demo1TransactionManager(demoService, context);
        }
    }


    private final DemoService demoService;
    private final MyContext context;

    public Demo1TransactionManager(OrderUserRightsService demoService, MyContext context) {
        this.demoService = demoService;
        this.context = context;
    }

    
    @Override
    protected Object doGetTransaction() throws TransactionException {
        return context;
    }

    
    @Override
    protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
        MyContext context = (MyContext)transaction;
        try {
            demoService.doXxx(context);
        } catch (Exception e) {
            log.error("xxx");
            throw new RuntimeException("xxx");
        }
    }

    
    @Override
    protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
        // TODO do something ...
    }

    
    @Override
    protected void doRollback(DefaultTransactionStatus status) throws TransactionException {
        MyContext context = (MyContext)status.getTransaction();
        try {
            demoService.doXxx(context);
        } catch (Exception e) {
            log.error("xxx");
            throw new RuntimeException("xxx");
        }
    }
    
}

// 实际使用

@Autowired
private PlatformTransactionManager transactionManager;

@Autowired
private List abstractMyTransactionManagerBuilders;

// 多事务管理
private ChainedTransactionManager buildChainedTransactionManager(MyContext context){
    List transactionManagers = new ArrayList<>();
    transactionManagers.add(transactionManager);
    //构建多事务管理器链
    abstractMyTransactionManagerBuilders.forEach(builder->{
        if(builder.valid(context)){
            transactionManagers.add(builder.build(context));
        }
    });
    //多事务管理
    return new ChainedTransactionManager(transactionManagers.toArray(new PlatformTransactionManager[0]));
}


public void submitWithTransaction(MyContext context) {
     TransactionTemplate transactionTemplate = new TransactionTemplate(buildChainedTransactionManager(context));
     // 事务传播机制
     transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
     // 事务级别
     transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
     // 启动事务
     OrderDTO order = transactionTemplate.execute(status -> {
         return invokeXxx();
     });
 }