精华内容
下载资源
问答
  • 7种数据库事务传递性代码实例详解

    千次阅读 2017-09-24 20:28:08
    1、PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的设置。 2、PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不...

    首先MySQL建立测试表,只是测试用所以比较简单

    test_isolation

    +-------+---------+------+-----+---------+-------+
    | Field | Type    | Null | Key | Default | Extra |
    +-------+---------+------+-----+---------+-------+
    | id    | int(11) | YES  |     | NULL    |       |
    | num   | int(11) | YES  |     | NULL    |       |
    +-------+---------+------+-----+---------+-------+
    
    test_propagation

    +-------+---------+------+-----+---------+-------+
    | Field | Type    | Null | Key | Default | Extra |
    +-------+---------+------+-----+---------+-------+
    | id    | int(11) | YES  |     | NULL    |       |
    | num   | int(11) | YES  |     | NULL    |       |
    +-------+---------+------+-----+---------+-------+
    

    项目采用maven+maven创建,junit单元测试运行测试

    概念

    本地事务

           数据库事务,默认事务为自动提交,因此如果一个业务逻辑类中有多次数据库操作将无法保证事务的一致性。

    Spring事务

           对本地事务操作的一次封装,相当于把使用JDBC代码开启、提交、回滚事务进行了封装。

    上述两个概念会在demo中用到,以方便大家理解代码。

    事务传播性:

    1、PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的设置。

    2、PROPAGATION_SUPPORTS自身不会开启事务,在事务范围内则使用相同事务,否则不使用事务。‘

    3、PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。

    4、PROPAGATION_REQUIRES_NEW:创建新事务,无论当前存不存在事务,都创建新事务。

    5、PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

    6、PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。

    7、PROPAGATION_NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与PROPAGATION_REQUIRED类似的操作。


    Junit单元测试类

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration({"classpath:applicationContext.xml"})
    public class TestPropagation {
    
    
        @Autowired
        private ITestIsolationService isolationService;
    
        @Autowired
        private ITestPropagationService propagationService;
    
        @Test
        public void testPropagation() {
            isolationService.add("insert test_isolation values(1,1)");
        }
    }

    业务层代码都是使用spring的JdbcTemplate操作

    PROPAGATION_REQUIRED

        // TestIsolationServiceImpl
        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
    
            propagationService.add("insert test_propagation values(1,1)");
    
            throw new RuntimeException();
        }

        // TestPropagationServiceImpl
        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
        }

    经测试无论在isolationservice还是propagationservice如果不抛出异常,那么数据提交成功,如果抛出异常,数据提交失败。这说明isolationservice和propagationservice使用的是同一个事务,并且只要方法被调用就开启事务。


    PROPAGATION_REQUIRES_NEW

        // TestIsolationServiceImpl
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
    
            propagationService.add("insert test_propagation values(1,1)");
    
            throw new RuntimeException();
        }

        // TestPropagationServiceImpl
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
        }

    经测试如果在isolationservice中抛出异常,isolationservice数据不能正确提交,propagationservice被正确提交。说明isolationservice和propagationservice是在两个独立的事务中运行,并且只要方法被调用就开启事务。

    PROPAGATION_SUPPORTS

        // TestIsolationServiceImpl
        @Transactional(propagation = Propagation.SUPPORTS)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
    
            propagationService.add("insert test_propagation values(1,1)");
    
            throw new RuntimeException();
        }

        // TestPropagationServiceImpl
        @Transactional(propagation = Propagation.SUPPORTS)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
        }

    经测试如果在isolationservice中抛出异常,isolationservice和propagationservice都被正确提交。说明isolationservice和propagationservice没有被spring管理和开启事务,而是使用了本地事务,由于本地事务默认自动提交因此数据都提交成功,但它们使用的却不是同一个事务,一旦出现异常将导致数据的不一致。


    PROPAGATION_NOT_SUPPORTED

        // TestIsolationServiceImpl
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        @Override
        public void add(String sql) {
            jdbcTemplate.execute(sql);
    
            throw new RuntimeException();
        }

    经测试如果在isolationservice中抛出异常,isolationservice正确提交。说明isolationservice没有被spring管理和开启事务,而是使用了本地事务,由于本地事务默认自动提交因此数据都提交成功。


    其他几种大家可以自行测试,demo代码已经上传至git,其中demo中还有zookeeper,dubbo,rabbitmq,webservice,aop,等等一系列的测试用力,大家可以参考

    代码地址:https://git.coding.net/scott-huo/product.git,git@git.coding.net:scott-huo/product.git

    有问题可以加群询问,共同探讨学习


    展开全文
  • 2 持久性:事务提交了,这次记录将永久的保存在数据库中 3 一致性:一个查询发起后,不管数据发生了多少变化 多少事务,查询结果应当为发起查询时间一致的数据 4 隔离型: 事务的隔离级别: 未提交读: (读到另...

    事务的特性

    1 原子性:Atomicity    一个事务 要么完全提交 要么完全回滚,不会介于2者之间。

    2 持久性:事务提交了,这次记录将永久的保存在数据库中

    3 一致性:一个查询发起后,不管数据发生了多少变化 多少事务,查询结果应当为发起查询时间一致的数据

    4 隔离型: 事务的隔离级别:

    未提交读: (读到另一个事务未提交的信息)

    产生的问题: 脏读

    比如事务A在操作一个信息的同时,事务B操作了这条信息,而事务B还没有提交此次事务,也就是说,这个修改还没被确定,就被读取。

    就比如你正在给其他人转钱,而还没确认在他人的账户上增加钱,你的钱就已经被转走了

    已提交读:读到已提交的信息

    产生的问题:不可重复读(删改导致的数据不一致)

    可重复读:记录快照,在快照中查询值 ---- (行级锁)

    产生的问题:幻读(insert)

    事务1修改,事务2insert ,事务1 发现多了一些数据

    序列化: 锁表:锁定事务A的表(锁表) ; 对性能消耗很大


    具体理解例子见此博客

    http://blog.csdn.net/fg2006/article/details/6937413

    展开全文
  • 数据库三大范式 第一范式:原子性,每列都不可再分。举例:省市&地址,地址不够具体,无法按照省、市进行分类和查找 第二范式:唯一性,不存在部分依赖,每张表中都只能包含“一种”信息,举例:一张表...

    数据库三大范式

    • 第一范式:原子性,每列都不可再分。举例:省市&地址,地址不够具体,无法按照省、市进行分类和查找

    • 第二范式:唯一性,不存在部分依赖,每张表中都只能包含“一种”信息,举例:一张表中存在学生、课程和分数三个属性,存在冗余,可以分为学生表、课程表和成绩表三个表

    • 第三范式:直接性,不存在传递依赖,每一列都应该和主键直接相关,不能包含其它表中的非主键列的信息。举例:一张表中存在学生、学校、学校地址三个属性,学校地址和学校直接相关,不和学生直接相关,存在冗余

    存储过程

    • 存储过程是指完成一个特定功能的sql语句集,经过编译之后存放在数据库中,用户根据过程名称和参数调用相应的过程。

    • 存储过程是可编程的函数,在数据库中创建并保存,由sql语句和控制语句组成。想在不同应用程序或平台执行相同的函数或者封装特定功能的时候是非常有用的,是面向对象的一种模拟实现。

    • 优点

      • 提高sql的灵活性和表达能力:程序过程是sql语句和控制语句的结合

      • 标准的组件化编程:一次编译,到处调用

      • 提高执行效率:与批处理相比,只需要一次编译和一次优化,执行效率更快

      • 较少网络运输量:只需要传输过程语句,不需要传输数据库操作结果

      • 安全保证:通过限制存储过程的执行权限来保证安全性

    数据库事务&ACID&隔离级别

    • 数据库事务:事务是并发控制的基本单位,由一系列的操作指令构成

    • 事务的四大特性:ACID

      • 原子性(Atomicity):事务中包含的所有操作要么全部执行成功,要么执行失败回滚

      • 一致性(Cinsistency):事务执行前和执行后都必须处于一致性的状态

      • 隔离性(Isolation):一个事务在执行过程中,不能被其它事务干扰,多个并发事务之间要相互隔离

      • 持久性(Durability):已提交的事务的操作对数据库中的数据的影响是永久的

    • 不考虑隔离性可能带来的问题

      • 丢失更新:多个事务同时修改一条数据,后面事务的修改结果会覆盖前面事务的修改

      • 脏读:一个事务处理过程中读取了另外一个未提交事务中的数据

      • 不可重复读:一个事务处理过程中需要多次读相同的内容,多次读内容时读取了另外一个已提交事务更新后的数据,导致前后读取的数据不一致

      • 幻读:一个事务的操作需要多次读取相同的数据,多次读的过程中读取到了另一个事务已提交的新插入后的数据,导致读取的数据数量不同

    • 隔离级别

      • Read Uncommited:读取未提交的内容,可能导致脏读、不可重复读、幻读。读的时候不加锁,写的时候加行级写锁。

      • Read Committed:读取提交的内容,可能导致不可重复读、幻读;大多数数据库默认的隔离级别。读的时候加行级读锁,读完该行释放,写的时候加行级写锁,事务结束后释放。

      • Repeated Read:可重读,可能导致幻读;MySQL默认的隔离级别;可以通过多版本并发控制解决幻读的问题。读的时候加行级读锁,事务结束后释放,写的时候加行级写锁,事务结束后释放。

      • Serializable:序列化,最高的隔离级别,强制事务排序,在每个数据行上加上共享锁,解决幻读问题;可能导致大量的超时现象和锁竞争。读的时候加表级读锁,事务结束后释放,写的时候加表级写锁,事务结束后释放。

    锁机制

    • 按粒度划分

      • 行级锁:开销大、加锁慢、会导致死锁、加锁粒度最小、锁冲突概率最低、并发度最高

      • 表级锁:开销小、加锁快、不会导致死锁、加锁粒度最大、锁冲突概率最高、并发度最低

      • 页级锁:各项性能介于行级锁和表级锁之间,会发生死锁

    • 按级别划分

      • 读锁:阻塞写锁,不会阻塞读锁

      • 写锁:同时阻塞读锁和写锁

    • InnoDB存储引擎使用行锁和表锁,行级锁机制依赖与索引,默认使用行级锁

      MyISAM存储引擎使用表级锁

    索引

    • 索引是建立在数据表列上的数据结构,可以用来存储特定列的值并排序

    • 优点是加快检索速率,并且可以保证数据的唯一性,加速表的连接等等;缺点是索引的建立和维护需要时间开销,同时也会占用物理内存,因此需要进行范围查找、需要排序、需要频繁查找以及主键的列建立索引提高查询和检索的效率

    • 常见的索引的数据结构:B+树、hash索引

    • InnoDB查询引擎的索引和MyISAM查询引擎的索引

      • InnoDB的主索引中数据文件本身是索引文件,可以提供非常快速的主键查找性能;辅助索引中数据文件是主键,需要再根据主索引表进行内容查找,所以主键不要设置太大而且最好自增,方便B+树的顺序查找

      • MyISAM的主索引和辅助索引差别不大,数据和索引是分开的,叶子结点的数据域存储的是指向实际数据的地址

    • 索引类型:普通索引、唯一索引(值必须唯一)、主键索引(会为主键自动创建索引)、全文索引、组合索引(最左前缀)

    • 联合索引最左前缀原则

      • 联合索引中区分度最高的要放最左边

      • 存在等号和非等号混合判断条件时,在建立索引时,把等号条件的列前置

    • 不建议使用索引的情况

      • 记录数量比较少

      • 索引的选择性比较低

    • 优化策略:使用前缀索引(短索引)

      • 短索引可以提高查询速度,节省磁盘空间和IO操作,减少索引文件的维护开销

    • 磁盘I/O分析:

      • 索引在内存,O(logn)时间忽略不计

      • 用二叉树存储,O(log_{2}n)

      • 用B+树存储,O(log_{N}n),通常InnoDB的B+树为2~4层,一般情况下根节点常驻内存,因此需要1~3次磁盘IO

    视图

    • 在基本表上建立的表,是对基本表的一种抽象和在逻辑意义上建立的新关系

    • 优点:方便操作;提高安全性,只能查询和修改能看到的数据;逻辑上的独立性,屏蔽了真实表结构带来的影响

    • 缺点:性能下降;无法通过复杂的视图修改表中的数据

    分区

    • 某个表数据量太大,查询速度会变慢,因此将表的文件分割成为许多小块

    • 这样可以分别在多个磁盘上存储,对某些时间相关的应用,可以按时间分区

    分库分表

    • 垂直分表和水平分表联合使用的方式

    读写分离

    • 读写分离解决的是数据库的写入影响了数据库查询效率的问题

    • 读写分离的实现基础是主从复制,主数据库执行写操作,从数据库执行读操作,然后主数据库利用主从复制将自身数据的改变同步到从数据库中

    • 可以部署多个从服务器提高读的速度,同时提供了冗余数据的功能,服务器宕机可以尽快恢复

    explain执行计划

    • 可以模拟优化器执行SQL查询语句,分析select语句或表结构的性能瓶颈,得到select查询效率低下的原因,从而进行改进

    • 字段信息:ID、查询类型(普通查询/联合查询/子查询)、表、索引、索引长度、访问类型(const/ref/range)

    show profiles

    • 查询最近执行的SQL语句的运行状态,包括状态和耗时等

    通用查询日志分析和慢查询日志分析

    • 慢查询日志:执行时间超过指定阈值的SQL语句,可能是表太大或者没有建立索引导致的

    数据库优化

    • 优化SQL语句

      • 通用查询日志和慢查询日志分析定位执行效率低的SQL语句

      • explain执行计划分析低效的SQL执行计划

      • show profiles分析SQL执行情况

      • 写统一的SQL语句;尽量使用索引,避免做全表的搜索;尽量使用别名;尽量避免大事务操作/尽量避免向客户端返回大量数据

    • 索引优化:使用短前缀

    • 尽量少join;尽量少排序;尽量避免select*;尽量用join代替子查询;尽量少or;尽量避免类型转换

    • 表结构优化:字符类型;数字类型;时间类型等

    存储引擎

    InnoDB

    • 聚簇索引,使用B+树作为索引结构,主索引的叶子结点即数据文件,因此基于主键查找速度非常快,辅助索引的叶子结点是主键,因此使用辅助索引进行查找需要先查找到主键,在基于主索引查找,需要两次查找,由于辅助索引存储的内容是主键,因此基于InnoDB的数据库表的主键应该小一些并且最好自增
    • 提供事务支持,包括事务回滚、提交和ACID特性,以及提供系统崩溃后的修复
    • 默认使用行级锁,当查询命中索引时使用行级锁,当查询未命中索引时使用表级锁,因为行级锁并没有锁到物理表上,而是锁到了索引上
    • 提供MVCC的行级锁,提高并发操作性能,它的CPU效率基本高于其它所有的基于磁盘的关系型数据库存储引擎,是MySQL默认的存储引擎
    • 提供外键支持
    • 不使用一个单独的变量保存表的具体行数,因为不同事物看到的表的数量是不同的

    MyISAM

    • 非聚簇索引,使用B+树作为索引结构,数据文件和叶子结点分开存储,叶子结点存储的是指向数据节点的指针,主索引和辅助索引没有太大的区别
    • 不支持事务
    • 使用表级锁完成并发控制
    • 不提供外键支持
    • 用一个单独变量保存表的总行数,加速select*操作

    适用场景

    • InnoDB适用于并发要求高,写密集和需要事务支持以及外键支持的表
    • MyISAM适用于读密集且不需要事务支持的表,适用于主从分离数据库中的从数据库

    SQL注入

    SQL注入是一种将SQL代码添加到输入参数中,传递到服务器解析并执行的一种攻击手法

    预防SQL注入

    • 严格检查输入变量的类型和格式,如对字符串变量使用正则表达式进行过滤
    • 过滤和转义特殊字符
    • 利用MySQL的预编译机制,一次编译多次执行,提高效率,保证安全性

    on和where

    on和where都是筛选条件,on在表连接的过程中筛选,对left join来说无论on的条件是否为真,都会返回左表中的内容,where是对表连接之后得到的临时表进行筛选

    group by和having

    group by是分组,having是按照分组后的结果进行统计和过滤

    char和varchar

    char长度固定,存取速度更快,varchar长度可变,节省空间,但是存取速度更慢一些

    SQL语句

    select* from items where DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= date(createtime)

     

    展开全文
  • 数据库事务(二)

    2021-04-04 22:22:23
    如果JDBC连接处于自动提交模式,默认情况下,则每个SQL语句在完成后都会提交到数据库。 要启用手动事务支持,需要使用Connection对象的setAutoCommit()方法。如果将boolean false传递给setAutoCommit(),则关闭自动...

    买瓜前装模作样拍一拍,是对西瓜最起码的尊重。—吃货语录

    一、在JDBC中事务的应用

    1. 如果JDBC连接处于自动提交模式,默认情况下,则每个SQL语句在完成后都会提交到数据库。
    2. 要启用手动事务支持,需要使用Connection对象的setAutoCommit()方法。如果将boolean false传递给setAutoCommit(),则关闭自动提交。另外,可以传递一个布尔值true来重新打开它。
    try{
    	//Connection conn = dataSource.getConnection(); 
    	conn.setAutoCommit(false); 
    	
    	Statement statement = conn.createStatement(); 
    	String SQL1 = "INSERT INTO Employees values (106, 20, 'Rita')"; 
    	statement.executeUpdate(SQL1); 
    	
    	//Submit a wrong SQL statement that breaks 
    	String SQL2 = "INSERTED IN Employees VALUES (107, 22, 'Sita')";
    	statement.executeUpdate(SQL2); 
    	
    	// If there is no error. 
    	conn.commit();
    }catch(SQLException e){ 
    	// If there is any error. 
    	conn.rollback(); 
    }
    

    二、SavePoints
    定义:可以理解为游戏中的中途存档点的意思,在游戏中死去不会重头开始,数据会回滚到存档点的位置。
    Connection对象有两种新的方法来管理保存点 -

    • setSavepoint(String savepointName):定义新的保存点。它还返回一个Savepoint对象。
    • releaseSavepoint(Savepoint savepointName):删除保存点。请注意,它需要一个Savepoint
      对象作为参数。此对象通常是由setSavepoint()方法生成的保存点。
    Savepoint savepoint = null;
    try{
    	//Connection conn = dataSource.getConnection(); 
    	conn.setAutoCommit(false); 
    	Statement statement = conn.createStatement(); 
    	
    	String SQL1 = "INSERT INTO Employees VALUES (106, 20, 'Rita')"; 
    	statement.executeUpdate(SQL1); 
    	savepoint = conn.setSavepoint("savepoint");
    	
    	//Submit a wrong SQL statement that breaks 
    	String SQL2 = "INSERTED IN Employees VALUES (107, 22, 'Sita')"; 
    	statement.executeUpdate(SQL2); 
    	conn.commit();
    	
    }catch(SQLException se){ 
    	conn.rollback(savepoint); 
    	// 回到保存点后,进行数据提交,只会进行第一个语句的插入
    	conn.commit();
    }
    

    三、实际案例中一定要进行事务的操作:转账
    A账户的金额增加,与B账户的金额减少,必须同时成功,或者同时失败
    因此,是否设置自动提交为false,要结合具体的业务要求

    try{
    	conn.setAutoCommit(false);
    	Statement statement = conn.createStatement(); 
    	
    	String SQL1 = "update money set cash=cash-100 where userid=1"; 
    	statement.executeUpdate(SQL1); 
    
    	String SQL2 = "update money set cash=cash+100 where userid=2"; 
    	statement.executeUpdate(SQL2); 
    	conn.commit();
    	
    }catch(SQLException e){ 
    	conn.rollback(); 
    }
    

    四、批处理
    批量处理允许我们将相关的SQL语句分组到批处理中,并通过对数据库的一次调用提交它们。
    当一次向数据库发送多个SQL语句时,可以减少连接数据库的开销,从而提高性能。
    两种方式的批处理:

    1. 状态通道
    2. 预状态通道

    Statement
    只要是增删改,都可以进行事务的提交

    try{
    	//Connection conn = dataSource.getConnection(); 
    	conn.setAutoCommit(false); 
    	
    	Statement statement = conn.createStatement(); 
    	String SQL1 = "insert into Employees values (106, 20, 'Rita')"; 
    	statement.addBatch(SQL1); 
    	
    	String SQL2 = "insert into Employees values (107, 22, 'Sita')";
    	statement.addBatch(SQL2); 
    	
    	String SQL3 = "insert into Employees values (108, 23, 'Pika')";
    	statement.addBatch(SQL3); 
    	// 返回一个batch中,受影响行数的数组
    	int[] ints = statement.executeBatch();
    	
    	// If there is no error. 
    	conn.commit();
    }catch(SQLException e){ 
    	// If there is any error. 
    	conn.rollback(); 
    }
    

    PreparedStatement

    try{
    	//Connection conn = dataSource.getConnection(); 
    	conn.setAutoCommit(false); 
    	
    	String sql = "insert into teacher(tname) values (?)";
    	PreparedStatement statement = conn.prepareStatement(sql); 
    
    	statement.setString(1,"张三1");
    	statement.addBatch();
    	
    	statement.setString(1,"张三2");
    	statement.addBatch();
    	
    	statement.setString(1,"张三3");
    	statement.addBatch();
    	
    	int[] ints = statement.executeBatch();
    	
    	// If there is no error. 
    	conn.commit();
    }catch(SQLException e){ 
    	// If there is any error. 
    	conn.rollback(); 
    }
    
    展开全文
  • 事务的操作如果成功就必须完全应用到数据库,如果失败就不能对数据库有任何影响。 consistency 一致性:事务必须使数据库从一个一致性状态变换到另一个一致性状态中。(A和B两者的钱加起来是5000,不管如何转帐,转...
  • Spring事务传递传播属性什么是事务传播属性Spring定义的7种类传播行为实现1. REQUIRED2. REQUIRES_NEW3. 其他几种同理**事务的隔离级别****数据库事务并发问题****脏读****不可重复读****幻读**事物隔离级别读未提交...
  • Atitti 数据库事务处理attilax总结 1.1. 为什么要传递Connection?1 1.2. 两种事务处理方式,一种是编程式事务处理;一种是声明...2 1.3. 事务隔离级别2 1.4. 事务传播行为2 1.5. 事务的回滚规则3 1.6. 声明式...
  • 概述  事务传播行为定义了事务的作用范围的:是否需要事务、事务是否可以传递、...数据库事务拥有许多语义概念,它们是你进行事务编程和事务管理的基础,只有掌握好数据库事务的基础知识,才能深刻理解数据库事务
  • Spring的事务,也就是数据库事务操作,符合ACID标准,也具有标准的事务隔离级别。 但是Spring事务有自己的特点,也就是事务传播机制。 所谓事务传播机制,也就是在事务在多个方法的调用中是如何传递的,是重新...
  • <p>Usually I split my web projects in domains and each domain has a service (business layers) and repository (data access layer). I am creating a project where I have two domains (Jobs and Headers...
  • 参考文章 ...数据库事务(Transaction) ,是指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操...
  • 一: /* * 创建一个能对所有类实例进行动态代理的代理工具类, 这里的泛型类型T 必须是接口类型 */ public class DynamicProxy2 implements ... * 构造方法 传递一个被代理对象 */ public DynamicProxy2(T targ
  • 第三,流式处理将数据处理的层次提示到了新高度,消息系统只会传递数据。kafka的流式处理能力可以让我们用很少的代码就能动态的处理派生流和数据集。所以,kafka不仅仅是个消息中间件 kafka不仅仅是个消息中间件,...
  • Spring 事务传递与隔离

    2019-10-27 14:53:08
    Spring 事务传递与隔离 本文讨论下Spring注解@Transactional 及其隔离(isolation)和传播(propagation)属性的设置. 1. @Transactional注解 @Transactional注解可以用在数据库事务操作的方法上。并可以设置事务的相关...
  • 分布式查询和分布式事务 SQLServer数据库引擎允许创建与OLEDB数据源(称为链接服务器)的链接。链接到OLEDB数据源之后,可以: 在Transact-SQL语句中作为表引用OLEDB数据源中的行集。 将命令传递给OLEDB数据源...
  • 数据库三范式 & 事务

    2020-12-14 16:09:10
    数据库三范式具体如下: 1、 第一范式(1st NF -列都是不可再分) 第一范式的目标是确保每列的原子性: 如果每列都是不可再分的最小数据单元(也称为最小的原子单元),则满足第一范式(1NF) 2、第二范式(2nd NF -...
  • 200202-SpringBoot系列教程之事务传递属性 对于mysql而言,关于事务的主要知识点可能几种在隔离级别上;在Spring体系中,使用事务的时候,还有一个知识点事务的传递属性同样重要,本文将主要介绍7中传递属性的使用...
  • 数据库

    2020-04-23 09:29:56
    2.数据库事务 事务是数据库操作的一个执行单元,要么全部执行成功,要么全部执行失败。 数据库事务特性 ①原子性:事务具有原子性,即数据修改时,要么全执行,要么全不执行,不允许事务部分执行。事务是最小的逻...
  • 数据库三范式: 1NF:列不可再分(确保每一列的原子性);... 数据库事务(Database Transaction) ,是指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。 事务处理可...
  • 通过驱动管理类的静态方法传递数据库的url来获取一个连接对象(connection)。有三个重载的方法,第一个user和password都追加在url后(类似于get传参);第二种用逗号将user和passowrd隔开作为第二个和...
  • 在“事务传递Connection参数案例”中,我们必须传递Connection对象,才可以完成整个事务操作。如果不传递参数,是否可以完成? 在JDK中给我们提供了⼀个⼯具类:ThreadLocal,此类可以在当前线程中共享数据。 java....
  • 数据库设计三范式: 定义:设计数据库的时候所依据的规范,共有三个规范; 第一范式:要求有主键,数据库中不能出现重复记录,每一个... 第三范式:建立在第二范式基础之上,要求非主键字段不能产生传递依赖...
  • 数据库_表设计范式_事务_隔离级别三大范式事务隔离级别MySQLOracle 三大范式 第一范式 每一列属性都是不可再分的属性值,确保每一列的原子性. 第二范式 每一行的数据只能与其中一列相关,即一行数据只做一件事。只要...
  • 数据库面试

    2019-09-22 13:29:08
    1.数据库三范式是什么? 第一范式:表中每个字段都不能再分。 第二范式:满足第一范式并且表中的非主键...数据库事务是指:几个SQL语句,要么全部执行成功,要么全部执行失败。比如银行转账就是事务的典型场景。 ...
  • 数据库杂记

    2018-04-24 11:11:27
    数据库事务,在一个事务中所有操作要么都执行失败,要么执行失败回滚。 事务有ACID特性 A:原子性,即一个事务是不可分割的一个原子单位 C:一致性。数据库的数据总能从一个一致性状态转到另一个...
  • 数据库常见问题

    2019-04-12 10:59:39
    1.数据库的三范式是什么? 第一范式:表中的每个字段都不能再分; 第二范式:满足第一范式并且表中的非主关键字字段都依赖于主键字段; 第三范式:满足第二范式并且表中的非主关键字必须...数据库事务的三个常用指令...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 773
精华内容 309
关键字:

数据库事务传递