​

        <!--jpa内部依赖了spring-boot-starter-jdbc，jdbc内部默认依赖Hikari数据源-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

#配置数据源
spring:
  datasource:
    username: root
    password: root
    #mysql驱动8.0.5时，指定时区 serverTimezone. 同时 driver-class-name 也变成如下的新地址，不再是以前的 com.mysql.hdbc.Driver
    url: jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

#JPA配置
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
    #指定 JPA 底层的 hibernate方言，使用 InnoDB 作为存储引擎。否则默认 JPA 使用的是 MyISAM 存储引擎，此引擎不支持事务、不支持外键的
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

import javax.persistence.*;
import java.util.Date;
/**
 * Created by Administrator on 2019/2/27 0027.
 * 电视机实体。应用启动时自动，配置文件中配置 ddl-auto: update：如果数据库不存在，则自动新建，否则不再新建。
 */
@Entity
public class TV {
    //strategy 指定主键生成的方式，AUTO 可以指定 H2 数据库主键自动增长，IDENTITY 可以指定 mysql 主键自动增长
    @Id//标识为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer tvId;//电视id，主键

    /**
     * 下面没标识的属性都会以默认值和数据库表的字段进行映射对应
     * 如果修改默认值，又不属性的，可以参考：https://blog.csdn.net/wangmx1993328/article/details/82048775
     * 中的 "domain Area" 部分
     */
    @Column(length = 16)//长度为16个字符
    private String tvName;//电视名称
    private Float tvPrice;//电视价格
    private Date dateOfProduction;//生产日期

    //......
}

import com.wmx.entity.TV;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * Java 接口可以多继承
 * JpaRepository 中有常用的 CRUD 、分页、排序等方法
 * JpaSpecificationExecutor 可以实现任意的复杂查询
 */
public interface TVRepository extends JpaRepository<TV, Integer>, JpaSpecificationExecutor<TV> {
}

import com.wmx.entity.TV;
import java.util.List;
public interface TVService {
    //查询所有
    List<TV> findAll();

    //保存或更新
    void save(TV tv);

    //根据主键 tvId 删除
    void deleteById(int id);
}

import com.wmx.entity.TV;
import com.wmx.repository.TVRepository;
import com.wmx.service.TVService;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
@Service
public class TVServiceImpl implements TVService {
    @Resource
    private TVRepository tvRepository;

    @Override
    public List<TV> findAll() {
        //查询所有数据，并以主键 tvId 倒序排序
        return tvRepository.findAll(Sort.by(Sort.Direction.DESC, "tvId"));
    }

    //org.springframework.transaction.annotation.Transactional：事务管理
    //添加到哪个方法上，哪个方法就会进行事务管理
    @Transactional
    @Override
    public void save(TV tv) {
        tvRepository.save(tv);
        //故意制造一个数组下标越界异常，典型的运行时异常
        //如果没加 Transactional 则抛了异常，数据也会添加进数据库，加了Transactional，则会回滚。
        System.out.println("123".split(",")[1]);
    }

    @Override
    public void deleteById(int id) {
        tvRepository.deleteById(id);
    }
}

​

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    //当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器。
    @AliasFor("transactionManager")
    String value() default "";

    //当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器。
    //如 @Transactional(value = "jpaTransactionManager")
    @AliasFor("value")
    String transactionManager() default "";

    //事务的传播行为。默认如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务
    Propagation propagation() default Propagation.REQUIRED;

    //事务的隔离级。默认使用底层数据库自己的隔离级别
    Isolation isolation() default Isolation.DEFAULT;

    //事务超时时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。-1表示永不超时
    int timeout() default -1;

    //事务是否为只读事务，为了忽略那些不需要事务的方法,如读取数据，可以设置 read-only 为 true。
    boolean readOnly() default false;

    //用于指定能够触发事务回滚的异常类型，可以指定多个异常类型。
    Class<? extends Throwable>[] rollbackFor() default {};

    //用于指定能够触发事务回滚的异常名称，可以指定多个
    String[] rollbackForClassName() default {};

    //抛出指定的异常类型，不回滚事务，可以指定多个
    Class<? extends Throwable>[] noRollbackFor() default {};

    //抛出指定的异常名称，不回滚事务，可以指定多个。
    String[] noRollbackForClassName() default {};
}

 @Override
    public void save(TV tv) {
        deleteById(14);
        tv.setTvName(tv.getTvName());
        tvRepository.save(tv);
    }

    @Override
    public void deleteById(int id) {
        tvRepository.deleteById(id);
    }

    @Override
    public void save(TV tv) {
        deleteById(13);
        //故意制造一个数组下标越界异常，典型的运行时异常
        System.out.println("123".split(",")[1]);
        tv.setTvName(tv.getTvName() + "_xxx");
        tvRepository.save(tv);
    }

    @Override
    public void deleteById(int id) {
        tvRepository.deleteById(id);
    }

    //org.springframework.transaction.annotation.Transactional：事务管理
    //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void save(TV tv) {
        deleteById(12);
        //故意制造一个数组下标越界异常，典型的运行时异常
        System.out.println("123".split(",")[1]);
        tv.setTvName(tv.getTvName() + "_xxx");
        tvRepository.save(tv);
    }

    @Override
    public void deleteById(int id) {
        tvRepository.deleteById(id);
    }

 //org.springframework.transaction.annotation.Transactional：事务管理
    //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void save(TV tv) {
        deleteById(11);
        //故意制造一个数组下标越界异常，典型的运行时异常
        System.out.println("123".split(",")[1]);
        tv.setTvName(tv.getTvName() + "_xxx");
        tvRepository.save(tv);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
//    @Transactional(propagation = Propagation.NOT_SUPPORTED)
//    @Transactional(propagation = Propagation.NEVER)
    public void deleteById(int id) {
        tvRepository.deleteById(id);
    }

public interface TVServiceExt {
    //根据主键 tvId 删除
    void deleteByIdExt(int id);
}

import com.wmx.repository.TVRepository;
import com.wmx.service.TVServiceExt;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class TVServiceExtImpl implements TVServiceExt {
    @Resource
    private TVRepository tvRepository;

    @Override
    public void deleteByIdExt(int id) {
        tvRepository.deleteById(id);
    }
}

@Service
public class TVServiceImpl implements TVService {
    @Resource
    private TVRepository tvRepository;

    @Resource
    private TVServiceExt tvServiceExt;
    
    //其余方法省略不写了

    //org.springframework.transaction.annotation.Transactional：事务管理
    //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
    @Override
    public void save(TV tv) {
        tvServiceExt.deleteByIdExt(11);//调用其它类中的方法

        //故意制造一个数组下标越界异常，典型的运行时异常
        System.out.println("123".split(",")[1]);
        tv.setTvName(tv.getTvName() + "_xxx");
        tvRepository.save(tv);
    }
}

    //org.springframework.transaction.annotation.Transactional：事务管理
    //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
    @Override
    @Transactional
    public void save(TV tv) {
        tvServiceExt.deleteByIdExt(10);//调用其它类中的方法

        //故意制造一个数组下标越界异常，典型的运行时异常
        System.out.println("123".split(",")[1]);
        tv.setTvName(tv.getTvName() + "_xxx");
        tvRepository.save(tv);
    }

    //REQUIRES_NEW：表示新开一个事务，如果当前已经有事务，则会暂停
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deleteByIdExt(int id) {
        tvRepository.deleteById(id);
    }