我的技术笔记

持续热爱！

CAP定理

Consistency，一致性。Availability，可用性。Partition tolerance，分区容错性。
CAP指出在分布式系统中，不可能同时满足以上三点。

Partition tolerance 分区容错性

在一个分布式系统中，如果一个数据只存在于一个节点上，那么原本连通的网络可能会因为某些问题无法连通到该节点。此时系统就不具有分区容错性。而如果要考虑分区容错性，就要将一份数据复制到多个节点上。

Consistency 一致性

一致性指的是在访问一个分布式系统时（无论哪一个节点），所得到的数据是同样的、最新的数据。
在基于分区容错性的基础上，不同节点间的数据需要同步。而这个同步操作需要一定的时间。才能达到最终的一致。

Avaliability 可用性

可用性指的是在访问一个分布式系统时，在满足响应时间的前提下得到响应。

为什么说CAP三者不能兼得？

首先一个分布式系统，必然是要考虑P的，即通过将数据复制到多个节点来提高容错性。
- 在P的基础上如果选择了C，即数据的一致性，而数据在不同的结点上的同步操作是需要一定时间的，在数据在所有结点完全同步完之前，这些结点都不会响应用户，这个时候就不保证可用性了。
- 而若在P的基础上选择了A，即可用性，那么就必须以快速响应用户为目标，不能保证所有结点的数据同步完成。
而如果要选择A、C，放弃P，不将数据备份到多个节点。那么当然，不用考虑不同结点间数据的同步，一致性就不存在了，而不用考虑一致性问题，能够保证响应时间及时响应用户，可用性问题也就解决了。

数据库三范式

1NF

每个属性都不可再分。即每个列不可再分。 1NF是所有关系型数据库的最基本要求。

2NF

2NF在1NF的基础之上，消除了非主属性对于码的部分函数依赖。出现的概念：非主属性，码，部分函数依赖。

函数依赖

简单来说，就是通过x可以唯一的确定y，比如身份证号可以唯一的确定人名。那么，就称x函数确定y或y函数依赖于x。记作 x→y。
x称为这个函数依赖的决定属性组，也称为决定因素。
若 x→y，y→x，则记作 x←→y。若y函数不依赖于x，则记作

平凡函数依赖于非平凡函数依赖

若 x→y ，但y不是x的子集，则称 x→y 是非平凡的函数依赖。若 x→y ，但y是x的子集，则称 x→y 是平凡的函数依赖。
例子，以学生学号sno，课程编号cno，学生课程成绩grade为例。
- 非平凡函数依赖：(sno, cno) → grade
- 平凡函数依赖：(sno, cno) → sno ; (sno, cno) → cno 。

完全函数依赖与部分函数依赖

完全函数依赖

若 x → y，且 x 的任何一个真子集 x'，都不可能 x' → y，则称 y 对 x 完全函数依赖。记作
比如通过学生学号sno，课程编号cno可以确定学生该课程的成绩grade。但无法从(sno, cno)的任何真子集中如sno确定学生某一课程的成绩。则称grade对(sno, cno)完全函数依赖。

部分函数依赖

若 x → y，但 y 不完全函数依赖于 x，则称 y 对 x 部分函数依赖。记作
比如身份证号码id和手机号码phone可以确定姓名name。但存在存在 id → name，即部分函数依赖。

传递函数依赖与直接依赖

传递函数依赖

若 x → y，y → z。（y 不是 x 的子集，且不存在 y → x）
如学号sno → 系名dept_name，系名dept_name → 系主任dept_manager_name。且dept_name 不是 → sno，不是sno的子集。所以dept_manager_name传递函数依赖于sno。

直接依赖

若 x → y，y → z。且 y → x，即 y ←→ x。则 z 直接依赖为 x。

码

若
则称k为候选码（Candidate Key）。若候选码多于一个，则选定其中一个作为主码（Primary Key，主键）。
如身份证号码id、学号sno都能确定学生的姓名sname，如下表。那么id、sno为码。若选择id为主键，即主码。

id	sno	sname

主属性与非主属性

包含在任何一个候选码中的属性，称为主属性。不包含在任何码中的属性称为非主属性。
如下表。显然（cno, sno）为主码，即 cno、sno 为主属性。而 grade 为非主属性。

cno（课程号）	sno（学号）	grade（学生课程成绩）

全码

整个属性组是码，称为全码（All-key）

外码

即外键

2NF

回到定义上来：2NF在1NF的基础之上，消除了非主属性对于码的部分函数依赖。
首先想想主属性对于码的函数依赖是什么，如（a,b）是主键，那a部分函数依赖于（a,b）。这种关系不用消除。

例子

非主属性对于码的部分函数依赖，如下表。sdept 可以通过 sno 来确定，且 sdept 是非主属性，这就叫存在非主属性的部分函数依赖。这种关系很明显会导致数据冗余。如一个学生选了多门课程，每门课程都对应一行记录，每行记录都要去存储重复的sdept。

cno（课程号）	sno（学号）	grade（学生课程成绩）	sdept（学生系名）

2NF就是消除下图中的虚线。

符合2NF的设计

cno（课程号）	sno（学号）	grade（学生课程成绩）

sno（学号）	sdept（学生系名）

3NF

3NF在2NF的基础上，消除了非主属性对于码的传递函数依赖。

例子

如下表，sno是码，sno → sdept，sdept → sloc，且符合传递依赖的定义，所以 sloc 传递依赖于 sno。
这种情况，同样会造成数据的大量冗余，由于同一个系的学生的地址是一样的。

sno（学号）	sdept（学生系名）	sloc（学生宿舍地址，同一个系的学生一个地址）

符合3NF的设计

sno（学号）	sdept（学生系名）

sdept（学生系名）	sloc（学生宿舍地址，同一个系的学生一个地址）

Spring 事务传播行为

简介

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，不属于事务实际提供方即数据库的行为。

事务传播行为类型	说明
REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。
SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常。
REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则创建一个事务。

准备

POM


x
 代码解读复制代码<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>fun.roran</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- lombok start -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- lombok end -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

application.yml


xxxxxxxxxx
 代码解读复制代码server:
  port: 80
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
    username: root
    password: 123456

sql


xxxxxxxxxx
 代码解读复制代码CREATE TABLE `tx` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `value` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

DAO

TxDAO


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.dao;
public interface TxDAO {
    void a();
    void b();
}

TxDAOImpl


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.dao.impl;
import fun.roran.demo.dao.TxDAO;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
@Repository
public class TxDAOImpl implements TxDAO {
    @Resource
    JdbcTemplate jdbcTemplate;
    @Override
    public void a() {
        jdbcTemplate.execute("INSERT INTO tx (value) VALUES ('a')");
    }
    @Override
    public void b() {
        jdbcTemplate.execute("INSERT INTO tx (value) VALUES ('b')");
    }
}

Service

TxServiceA


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service;
public interface TxServiceA {
    void a();
}

TxServiceAImpl


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service.impl;
import fun.roran.demo.dao.TxDAO;
import fun.roran.demo.service.TxServiceA;
import fun.roran.demo.service.TxServiceB;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class TxServiceAImpl implements TxServiceA {
    @Resource
    private TxDAO txDAO;
    @Resource
    private TxServiceB txServiceB;
    @Override
    public void a() {
        txDAO.a();
        txServiceB.b();
    }
}

TxServiceB


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service;
public interface TxServiceB {
    void b();
}

TxServiceBImpl


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service.impl;
import fun.roran.demo.dao.TxDAO;
import fun.roran.demo.service.TxServiceB;
import javax.annotation.Resource;
public class TxServiceBImpl implements TxServiceB {
    @Resource
    private TxDAO txDAO;
    @Override
    public void b() {
        txDAO.b();
    }
}

REQUIRED

如果当前没有事务，就新建一个事务。如果已经存在一个事务中，加入到这个事务中。
默认为该级别。

情况1：`a()`开启事务

以上文代码为例，在a()开启事务的情况下，a()、b()相当于处于同一个事务。它们要么全都提交，要么全都不提交。
只要b()抛出异常，a()、b()会一起回滚。注意，即使b()的异常被a()捕获，仍是要一起回滚的。
a()调用完b()后抛出异常回滚，b()也会回滚。

情况2：`a()`不开启事务

若a()不开启事务，b()开启事务。
若a()调用完b()后抛出异常，b()自然不会回滚。同样若b()抛出异常回滚，也不会影响a()已经执行过的代码。

SUPPORTS

支持当前事务，如果当前没有事务，就以非事务方式执行。

情况1：`a()`开启事务

在a()开启事务的情况下，b()会加入a()的事务。二者属于同一事务。
只要b()抛出异常，a()、b()会一起回滚。注意，即使b()的异常被a()捕获，仍是要一起回滚的。
若a()调用b()后抛出异常，则b()也会回滚。

情况2：`a()`不开启事务

若a()不开启事务，则a()、b()都处在非事务环境下。

MANDATORY

使用当前的事务，如果当前没有事务，就抛出异常。

情况1：`a()`开启事务

在a()开启事务的情况下，b()会加入a()的事务。二者属于同一事务。
只要b()抛出异常，a()、b()会一起回滚。注意，即使b()的异常被a()捕获，仍是要一起回滚的。
若a()调用b()后抛出异常，则b()也会回滚。

情况2：`a()`不开启事务

调用b()时会抛出异常。

异常


xxxxxxxxxx
 代码解读
复制代码org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

REQUIRES_NEW

新建事务，如果当前存在事务，把当前事务挂起。

情况1：`a()`开启事务

a()开启事务，执行b()时，会将a()的事务挂起，b()创建一个自己的事务。
b()抛出异常回滚，若a()没有对异常进行补获，则也要回滚。若a()捕获了异常，则a()不用回滚。
a()调用完b()后抛出异常，a()回滚，b()不用回滚（因为b()的事务已经提交了）。

情况2：`a()`不开启事务

即b()会开启一个自身的事务。 b()若发生异常回滚不会影响到a()已执行操作，a()调用完b()后抛出异常自然不会影响到b()。

NOT_SUPPORTED

以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

情况1：`a()`开启事务

a()开启事务，但在执行b()的过程中，a()的事务被挂起且b()是无事务方式执行的。
若a()调用b()后抛出异常，则b()不会被回滚（除了其他b()的其它操作可以回滚）。
若b()执行中抛出异常，则b()已经执行的操作也不会回滚。同时若a()没有捕获b()抛出的异常，a()也会被回滚。若a()捕获了，则不会被回滚。
总而言之，不管a()、b()哪个操作抛出异常且未捕获，a()一定会被回滚，b()一定不会回滚。

情况2：`a()`不开启事务

a()、b()都处于无事务状态。

NEVER

以非事务方式执行，如果当前存在事务，则抛出异常。

情况1：`a()`开启事务

调用b()抛出异常。

异常


xxxxxxxxxx
 代码解读
复制代码org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'

情况2：`a()`不开启事务

a()、b()都处于无事务状态。

NESTED

如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则创建一个事务。

情况1：`a()`开启事务

调用b()时，开启一个事务，这个事务是a()的子事务。
当b()抛出异常并回滚时。该异常若被a()捕获，则a()不会回滚，否则a()回滚。
a()调用b()后抛出异常，则a()、b()一起回滚。

情况2：`a()`不开启事务

相当于只有b()开启了事务。

总结

事务传播失效

同一个类中事务传播失效

如果将上文的a()、b()方法写在同一个类中，那么事务传播行为将失效。
因为事务传播行为的实现是通过代理对象实现的。而原来的对象是没有事务传播行为功能的。

代码示例


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service.impl;
import fun.roran.demo.dao.TxDAO;
import fun.roran.demo.service.TxServiceA;
import fun.roran.demo.service.TxServiceB;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service
public class TxServiceAImpl implements TxServiceA {
    @Resource
    private TxDAO txDAO;
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void a() {
        txDAO.a();
        b();
    }
    @Transactional(propagation = Propagation.NEVER, rollbackFor = Exception.class)
    @Override
    public void b() {
        txDAO.b();
    }
}

调用a()方法，发现能够正常运行，不抛出异常。
原因：根据TxServiceAImpl对象生产代理对象后，代理对象底层还是调用TxServiceAImpl对象的b()方法，而这个方法是不支持事务传播功能的。

解决方法

不通过this调用方法，而是通过注入代理对象类调用。

代码示例


xxxxxxxxxx
 代码解读复制代码package fun.roran.demo.service.impl;
import fun.roran.demo.dao.TxDAO;
import fun.roran.demo.service.TxServiceA;
import fun.roran.demo.service.TxServiceB;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service
public class TxServiceAImpl implements TxServiceA {
    @Resource
    private TxDAO txDAO;
    @Resource
    private TxServiceA txServiceA;
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void a() {
        txDAO.a();
        txServiceA.b();
    }
    @Transactional(propagation = Propagation.NEVER, rollbackFor = Exception.class)
    @Override
    public void b() {
        txDAO.b();
    }
}

非`public`方法

@Transactional只能用于 public 的方法上，否则事务失效。如果要用在非public方法上，可以开启 AspectJ 代理模式。

我的技术笔记

CAP定理

Partition tolerance 分区容错性

Consistency 一致性

Avaliability 可用性

为什么说CAP三者不能兼得？

数据库三范式

1NF

2NF

函数依赖

平凡函数依赖于非平凡函数依赖

完全函数依赖与部分函数依赖

完全函数依赖

部分函数依赖

传递函数依赖与直接依赖

传递函数依赖

直接依赖

码

主属性与非主属性

全码

外码

2NF

例子

符合2NF的设计

3NF

例子

符合3NF的设计

Spring 事务传播行为

简介

准备

POM

application.yml

sql

DAO

TxDAO

TxDAOImpl

Service

TxServiceA

TxServiceAImpl

TxServiceB

TxServiceBImpl

REQUIRED

情况1：a()开启事务

情况2：a()不开启事务

SUPPORTS

情况1：a()开启事务

情况2：a()不开启事务

MANDATORY

情况1：a()开启事务

情况2：a()不开启事务

异常

REQUIRES_NEW

情况1：a()开启事务

情况2：a()不开启事务

NOT_SUPPORTED

情况1：a()开启事务

情况2：a()不开启事务

NEVER

情况1：a()开启事务

异常

情况2：a()不开启事务

NESTED

情况1：a()开启事务

情况2：a()不开启事务

总结

事务传播失效

同一个类中事务传播失效

代码示例

解决方法

代码示例

非public方法

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

情况1：`a()`开启事务

情况2：`a()`不开启事务

非`public`方法