Java编程珠玑(202205)

stream groupBy 分组

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

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

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

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

// 同上，异曲同工，优点是value允许为null
Map<String, Score> 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<ResultVo>() {
     @Override
     public ResultVo doInTransaction(TransactionStatus status) {
         return invokeXxx();
     }
 });
 或lamdba表达式：
 ResultVo result = transactionTemplate.execute(status -> {
    return invokeXxx();
 });

事务管理器

/**
 * 事务管理器构造 抽象父类
 * 继承 AbstractPlatformTransactionManager
 */
public abstract class AbstractMyTransactionManagerBuilder{
    /**
     * 前置校验
     * @param context 业务上下文
     * @return 是否需要加入事务管理器
     */
    public abstract boolean valid(MyContext context);

    /**
     * 处理
     * @param context 业务上下文
     * @return
     */
    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;
    }

    /**
     * 获取事务
     * @return
     * @throws TransactionException
     */
    @Override
    protected Object doGetTransaction() throws TransactionException {
        return context;
    }

    /**
     * 开始事务
     * @param transaction
     * @param definition
     * @throws TransactionException
     */
    @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");
        }
    }

    /**
     * 提交事务
     * @param status
     * @throws TransactionException
     */
    @Override
    protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
        // TODO do something ...
    }

    /**
     * 回滚事务
     * @param status
     * @throws TransactionException
     */
    @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<AbstractMyTransactionManagerBuilder> abstractMyTransactionManagerBuilders;

// 多事务管理
private ChainedTransactionManager buildChainedTransactionManager(MyContext context){
    List<PlatformTransactionManager> 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]));
}

/**
  * 使用入口
  * @param context
  */
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();
     });
 }