牛客过第二遍

1、spring事务管理

Spring事务管理

声明式事务：

1 通过XML配置，声明某方法的事务特征

2、通过注解，声明某方法的事务特征，注解@Transactional 

@Transactional 注解参数讲解

isolation ：隔离级别；propagation ：传播机制

传播机制比较难理解，这里粗略说一下

假如在A方法中，调用了B方法，而B方法是事务操作，则A为B的外部事务。

编程式事务：

通过TransactionTemplate管理事务，并通过它执行数据库的操作

package com.nowcoder.community.service;
 
import com.nowcoder.community.dao.AlphaDao;
import com.nowcoder.community.dao.DiscussPostMapper;
import com.nowcoder.community.dao.UserMapper;
import com.nowcoder.community.entity.DiscussPost;
import com.nowcoder.community.entity.User;
import com.nowcoder.community.util.CommunityUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.Date;
 
@Service
//@Scope("prototype")
public class AlphaService {
 
    @Autowired
    private AlphaDao alphaDao;
 
    @Autowired
    private UserMapper userMapper;
 
    @Autowired
    private DiscussPostMapper discussPostMapper;
 
    @Autowired
    private TransactionTemplate transactionTemplate;
 
    public AlphaService() {
//        System.out.println("实例化AlphaService");
    }
 
    @PostConstruct
    public void init() {
//        System.out.println("初始化AlphaService");
    }
 
    @PreDestroy
    public void destroy() {
//        System.out.println("销毁AlphaService");
    }
 
    public String find() {
        return alphaDao.select();
    }
 
    // REQUIRED: 支持当前事务(外部事务),如果不存在则创建新事务.
    // REQUIRES_NEW: 创建一个新事务,并且暂停当前事务(外部事务).
    // NESTED: 如果当前存在事务(外部事务),则嵌套在该事务中执行(独立的提交和回滚),否则就会REQUIRED一样.
    
    //isolation 隔离性 propagation 传播机制
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public Object save1() {
        // 新增用户
        User user = new User();
        user.setUsername("alpha");
        user.setSalt(CommunityUtil.generateUUID().substring(0, 5));
        user.setPassword(CommunityUtil.md5("123" + user.getSalt()));
        user.setEmail("[email protected]");
        user.setHeaderUrl("http://image.nowcoder.com/head/99t.png");
        user.setCreateTime(new Date());
        userMapper.insertUser(user);
 
        // 新增帖子
        DiscussPost post = new DiscussPost();
        post.setUserId(user.getId());
        post.setTitle("Hello");
        post.setContent("新人报道!");
        post.setCreateTime(new Date());
        discussPostMapper.insertDiscussPost(post);
 
        Integer.valueOf("abc");
 
        return "ok";
    }
//通过TransactionTemplate进行局部的事务回滚
    public Object save2() {
        transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
 
        return transactionTemplate.execute(new TransactionCallback