_事务基础知识

Posted 陌上人如玉এ

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了_事务基础知识相关的知识，希望对你有一定的参考价值。

第13章_事务基础知识

1. 数据库事务概述

1.1 存储引擎支持情况

SHOW ENGINES 命令来查看当前 mysql 支持的存储引擎都有哪些，以及这些存储引擎是否支持事务。

能看出在 MySQL 中，只有InnoDB 是支持事务的。

1.2 基本概念

事务：一组逻辑操作单元，使数据从一种状态变换到另一种状态。

事务处理的原则：保证所有事务都作为 一个工作单元 来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交( commit )，那么这些修改就 永久 地保 存下来；要么数据库管理系统将 放弃 所作的所有 修改 ，整个事务回滚( rollback )到最初状态。

# 案例：AA用户给BB用户转账100
update account set money = money - 100 where name = 'AA';
# 服务器宕机
update account set money = money + 100 where name = 'BB';

1.3 事物的ACID特性

  • 原子性（atomicity）：

原子性是指事务是一个不可分割的工作单位，要么全部提交，要么全部失败回滚。即要么转账成功，要么转账失败，是不存在中间的状态。如果无法保证原子性会怎么样？就会出现数据不一致的情形，A账户减去100元，而B账户增加100元操作失败，系统将无故丢失100元。

  • 一致性（consistency）：

（国内很多网站上对一致性的阐述有误，具体你可以参考 Wikipedia 对Consistency的阐述）

根据定义，一致性是指事务执行前后，数据从一个 合法性状态 变换到另外一个 合法性状态 。这种状态是 语义上 的而不是语法上的，跟具体的业务有关。

那什么是合法的数据状态呢？满足 预定的约束 的状态就叫做合法的状态。通俗一点，这状态是由你自己来定义的（比如满足现实世界中的约束）。满足这个状态，数据就是一致的，不满足这个状态，数据就 是不一致的！如果事务中的某个操作失败了，系统就会自动撤销当前正在执行的事务，返回到事务操作 之前的状态。

举例1：A账户有200元，转账300元出去，此时A账户余额为-100元。你自然就发现此时数据是不一致的，为什么呢？因为你定义了一个状态，余额这列必须>=0。

举例2：A账户有200元，转账50元给B账户，A账户的钱扣了，但是B账户因为各种意外，余额并没有增加。你也知道此时的数据是不一致的，为什么呢？因为你定义了一个状态，要求A+B的总余额必须不变。

举例3：在数据表中我们将姓名字段设置为唯一性约束，这时当事务进行提交或者事务发生回滚的时候，如果数据表的姓名不唯一，就破坏了事物的一致性要求。

  • 隔离型（isolation）：

事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能相互干扰。

如果无法保证隔离性会怎么样？假设A账户有200元，B账户0元。A账户往B账户转账两次，每次金额为50 元，分别在两个事务中执行。如果无法保证隔离性，会出现下面的情形：

UPDATE accounts SET money = money - 50 WHERE NAME = 'AA';
UPDATE accounts SET money = money + 50 WHERE NAME = 'BB';

持久性（durability）：

持久性是指一个事务一旦被提交，它对数据库中数据的改变就是 永久性的 ，接下来的其他操作和数据库 故障不应该对其有任何影响。

持久性是通过 事务日志 来保证的。日志包括了 重做日志 和 回滚日志 。当我们通过事务对数据进行修改 的时候，首先会将数据库的变化信息记录到重做日志中，然后再对数据库中对应的行进行修改。这样做 的好处是，即使数据库系统崩溃，数据库重启后也能找到没有更新到数据库系统中的重做日志，重新执 行，从而使事务具有持久性。

总结

ACID是事务的四大特征，在这四个特性中，原子性是基础，隔离性是手段，一致性是约束条件， 而持久性是我们的目的。

数据库事务，其实就是数据库设计者为了方便起见，把需要保证原子性、隔离性、一致性和持久性的一个或多个数据库操作称为一个事务。

1.4 事务的状态

我们现在知道 事务 是一个抽象的概念，它其实对应着一个或多个数据库操作，MySQL根据这些操作所执 行的不同阶段把 事务 大致划分成几个状态：

  • 活动的（active）

    事务对应的数据库操作正在执行过程中时，我们就说该事务处在 活动的 状态。

  • 部分提交的（partially committed）

    当事务中的最后一个操作执行完成，但由于操作都在内存中执行，所造成的影响并 没有刷新到磁盘 时，我们就说该事务处在 部分提交的 状态。

  • 失败的（failed）

    当事务处在 活动的 或者 部分提交的 状态时，可能遇到了某些错误（数据库自身的错误、操作系统 错误或者直接断电等）而无法继续执行，或者人为的停止当前事务的执行，我们就说该事务处在 失 败的 状态。

  • 中止的（aborted）

    如果事务执行了一部分而变为 失败的 状态，那么就需要把已经修改的事务中的操作还原到事务执 行前的状态。换句话说，就是要撤销失败事务对当前数据库造成的影响。我们把这个撤销的过程称之为 回滚 。当 回滚 操作执行完毕时，也就是数据库恢复到了执行事务之前的状态，我们就说该事 务处在了 中止的 状态。

    举例：

    UPDATE accounts SET money = money - 50 WHERE NAME = 'AA';

UPDATE accounts SET money = money + 50 WHERE NAME = 'BB';

  • 提交的（committed）

    当一个处在 部分提交的 状态的事务将修改过的数据都 同步到磁盘 上之后，我们就可以说该事务处在了 提交的 状态。

    一个基本的状态转换图如下所示：

    图中可见，只有当事物处于提交的或者中止的状态时，一个事务的生命周期才算是结束了。对于已经提交的事务来说，该事务对数据库所做的修改将永久生效，对于处于中止状态的事物，该事务对数据库所做的所有修改都会被回滚到没执行该事物之前的状态。

2. 如何使用事务

使用事务有两种方式，分别为 显式事务 和 隐式事务 。

2.1 显式事务

步骤1： START TRANSACTION 或者 BEGIN ，作用是显式开启一个事务。

mysql> BEGIN;
#或者
mysql> START TRANSACTION;

START TRANSACTION 语句相较于 BEGIN 特别之处在于，后边能跟随几个 修饰符 ：

① READ ONLY ：标识当前事务是一个 只读事务 ，也就是属于该事务的数据库操作只能读取数据，而不能修改数据。

补充：只读事务中只是不允许修改那些其他事务也能访问到的表中的数据，对于临时表来说（我们使用 CREATE TMEPORARY TABLE 创建的表），由于它们只能再当前会话中可见，所有只读事务其实也是可以对临时表进行增、删、改操作的。

② READ WRITE ：标识当前事务是一个 读写事务 ，也就是属于该事务的数据库操作既可以读取数据， 也可以修改数据。

③ WITH CONSISTENT SNAPSHOT ：启动一致性读。

比如：

START TRANSACTION READ ONLY; # 开启一个只读事务

START TRANSACTION READ ONLY, WITH CONSISTENT SNAPSHOT # 开启只读事务和一致性读

START TRANSACTION READ WRITE, WITH CONSISTENT SNAPSHOT # 开启读写事务和一致性读

注意：

  • READ ONLY和READ WRITE是用来设置所谓的事物访问模式的，就是以只读还是读写的方式来访问数据库中的数据，一个事务的访问模式不能同时即设置为只读的也设置为读写的，所以不能同时把READ ONLY和READ WRITE放到START TRANSACTION语句后边。
  • 如果我们不显式指定事务的访问模式，那么该事务的访问模式就是读写模式

步骤2：一系列事务中的操作（主要是DML，不含DDL）

步骤3：提交事务 或 中止事务（即回滚事务）

# 提交事务。当提交事务后，对数据库的修改是永久性的。
mysql> COMMIT;

# 回滚事务。即撤销正在进行的所有没有提交的修改
mysql> ROLLBACK;

# 将事务回滚到某个保存点。
mysql> ROLLBACK TO [SAVEPOINT]

其中关于SAVEPOINT相关操作有：

# 在事务中创建保存点，方便后续针对保存点进行回滚。一个事务中可以存在多个保存点。
SAVEPOINT 保存点名称;

# 删除某个保存点
RELEASE SAVEPOINT 保存点名称;

2.2 隐式事务

MySQL中有一个系统变量 autocommit ：

mysql> SHOW VARIABLES LIKE 'autocommit';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    |  ON   |
+---------------+-------+
1 row in set (0.01 sec)

当然，如果我们想关闭这种 自动提交 的功能，可以使用下边两种方法之一：

  • 显式的的使用 START TRANSACTION 或者 BEGIN 语句开启一个事务。这样在本次事务提交或者回滚前会暂时关闭掉自动提交的功能。

  • 把系统变量 autocommit 的值设置为 OFF ，就像这样：

    SET autocommit = OFF;
#或
SET autocommit = 0;

2.3 隐式提交数据的情况

  • 数据定义语言（Data definition language，缩写为：DDL）

    数据库对象，指的就是数据库、表、视图、存储过程等结构。当我们CREATE、ALTER、DROP等语句去修改数据库对象时，就会隐式的提交前边语句所属于的事物。即：

    BEGIN;

SELECT ... # 事务中的一条语句
UPDATE ... # 事务中的一条语句
... # 事务中的其他语句

CREATE TABLE ... # 此语句会隐式的提交前边语句所属于的事务

  • 隐式使用或修改mysql数据库中的表

    当我们使用ALTER USER、CREATE USER、DROP USER、GRANT、RENAME USER、REVOKE、SET PASSWORD等语句时也会隐式的提交前边语句所属于的事务。

  • 事务控制或关于锁定的语句

    ① 当我们在一个事务还没提交或者回滚时就又使用 START TRANSACTION 或者 BEGIN 语句开启了另一个事务时，会隐式的提交上一个事务。即：

    BEGIN;

SELECT ... # 事务中的一条语句
UPDATE ... # 事务中的一条语句
... # 事务中的其他语句

BEGIN; # 此语句会隐式的提交前边语句所属于的事务

    ② 当前的 autocommit 系统变量的值为 OFF ，我们手动把它调为 ON 时，也会 隐式的提交前边语句所属的事务。

    ③ 使用 LOCK TABLES 、 UNLOCK TABLES 等关于锁定的语句也会 隐式的提交 前边语句所属的事务。

  • 加载数据的语句

    使用LOAD DATA语句来批量往数据库中导入数据时，也会隐式的提交前边语句所属的事务。

  • 关于MySQL复制的一些语句

    使用START SLAVE、STOP SLAVE、RESET SLAVE、CHANGE MASTER TO等语句会隐式的提交前边语句所属的事务

  • 其他的一些语句

    使用ANALYZE TABLE、CACHE INDEX、CAECK TABLE、FLUSH、LOAD INDEX INTO CACHE、OPTIMIZE TABLE、REPAIR TABLE、RESET等语句也会隐式的提交前边语句所属的事务。

2.4 使用举例1：提交与回滚

我们看下在 MySQL 的默认状态下，下面这个事务最后的处理结果是什么。

情况1：

CREATE TABLE user(name varchar(20), PRIMARY KEY (name)) ENGINE=InnoDB;

BEGIN;
INSERT INTO user SELECT '张三';
COMMIT;

BEGIN;
INSERT INTO user SELECT '李四';
INSERT INTO user SELECT '李四';
ROLLBACK;

SELECT * FROM user;

运行结果（1 行数据）：

mysql> commit;
Query OK, 0 rows affected (0.00 秒)

mysql> BEGIN;
Query OK, 0 rows affected (0.00 秒)

mysql> INSERT INTO user SELECT '李四';
Query OK, 1 rows affected (0.00 秒)

mysql> INSERT INTO user SELECT '李四';
Duplicate entry '李四' for key 'user.PRIMARY'
mysql> ROLLBACK;
Query OK, 0 rows affected (0.01 秒)

mysql> select * from user;
+--------+
| name   |
+--------+
| 张三    |
+--------+
1 行于数据集 (0.01 秒)

情况2：

CREATE TABLE user (name varchar(20), PRIMARY KEY (name)) ENGINE=InnoDB;

BEGIN;
INSERT INTO user SELECT '张三';
COMMIT;

INSERT INTO user SELECT '李四';
INSERT INTO user SELECT '李四';
ROLLBACK;

运行结果（2 行数据）：

mysql> SELECT * FROM user;
+--------+
| name   |
+--------+
| 张三    |
| 李四    |
+--------+
2 行于数据集 (0.01 秒)

情况3：

CREATE TABLE user(name varchar(255), PRIMARY KEY (name)) ENGINE=InnoDB;

SET @@completion_type = 1;
BEGIN;
INSERT INTO user SELECT '张三';
COMMIT;

INSERT INTO user SELECT '李四';
INSERT INTO user SELECT '李四';
ROLLBACK;

SELECT * FROM user;

运行结果（1 行数据）：

mysql> SELECT * FROM user;
+--------+
| name   |
+--------+
| 张三    |
+--------+
1 行于数据集 (0.01 秒)

当我们设置 autocommit=0 时，不论是否采用 START TRANSACTION 或者 BEGIN 的方式来开启事 务，都需要用 COMMIT 进行提交，让事务生效，使用 ROLLBACK 对事务进行回滚。

当我们设置 autocommit=1 时，每条 SQL 语句都会自动进行提交。 不过这时，如果你采用 START TRANSACTION 或者 BEGIN 的方式来显式地开启事务，那么这个事务只有在 COMMIT 时才会生效， 在 ROLLBACK 时才会回滚。

2.5 使用举例2：测试不支持事务的engine

CREATE TABLE test1(i INT) ENGINE=InnoDB;

CREATE TABLE test2(i INT) ENGINE=MYISAM;

针对于InnoDB表

BEGIN;
INSERT INTO test1 VALUES(1);
ROLLBACK;

SELECT * FROM test1;

结果：没有数据

针对于MYISAM表：

BEGIN;
INSERT INTO test1 VALUES(1);
ROLLBACK;

SELECT * FROM test2;

结果：有一条数据

2.6 使用举例3：SAVEPOINT

创建表并添加数据：

CREATE TABLE account(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(15),
balance DECIMAL(10,2)
);

INSERT INTO account(NAME,balance)
VALUES
('张三',1000),
('李四',1000);

BEGIN;
UPDATE account SET balance = balance - 100 WHERE NAME = '张三';
UPDATE account SET balance = balance - 100 WHERE NAME = '张三';
SAVEPOINT s1; # 设置保存点
UPDATE account SET balance = balance + 1 WHERE NAME = '张三';
ROLLBACK TO s1; # 回滚到保存点

结果：张三：800.00

ROLLBACK;

结果：张三：1000.00

3. 事务隔离级别

MySQL是一个 客户端／服务器 架构的软件，对于同一个服务器来说，可以有若干个客户端与之连接，每 个客户端与服务器连接上之后，就可以称为一个会话（ Session ）。每个客户端都可以在自己的会话中 向服务器发出请求语句，一个请求语句可能是某个事务的一部分，也就是对于服务器来说可能同时处理多个事务。事务有 隔离性 的特性，理论上在某个事务 对某个数据进行访问 时，其他事务应该进行排队 ，当该事务提交之后，其他事务才可以继续访问这个数据。但是这样对 性能影响太大 ，我们既想保持事务的隔离性，又想让服务器在处理访问同一数据的多个事务时 性能尽量高些 ，那就看二者如何权衡取 舍了。

3.1 数据准备

CREATE TABLE student (
    studentno INT,
    name VARCHAR(20),
    class varchar(20),
    PRIMARY KEY (studentno)
) Engine=InnoDB CHARSET=utf8;

然后向这个表里插入一条数据：

INSERT INTO student VALUES(1, '小谷', '1班');

现在表里的数据就是这样的：

mysql> select * from student;
+-----------+--------+-------+
| studentno | name   | class |
+-----------+--------+-------+
|      1    |   小谷  | 1班   |
+-----------+--------+-------+
1 row in set (0.00 sec)

3.2 数据并发问题

针对事务的隔离性和并发性，我们怎么做取舍呢？先看一下访问相同数据的事务在 不保证串行执行 （也 就是执行完一个再执行另一个）的情况下可能会出现哪些问题：

1. 脏写（ Dirty Write ）

对于两个事务 Session A、Session B，如果事务Session A 修改了 另一个 未提交 事务Session B 修改过 的数据，那就意味着发生了 脏写，示意图如下：

Session A 和 Session B 各开启了一个事务，Sesssion B 中的事务先将studentno列为1的记录的name列更新为’李四’，然后Session A中的事务接着又把这条studentno列为1的记录的name列更新为’张三’。如果之后Session B中的事务进行了回滚，那么Session A中的更新也将不复存在，这种现象称之为脏写。这时Session A中的事务就没有效果了，明明把数据更新了，最后也提交事务了，最后看到的数据什么变化也没有。这里大家对事务的隔离性比较了解的话，会发现默认隔离级别下，上面Session A中的更新语句会处于等待状态，这里只是跟大家说明一下会出现这样的现象。

2. 脏读（ Dirty Read ）

对于两个事务 Session A、Session B，Session A 读取 了已经被 Session B 更新 但还 没有被提交 的字段。 之后若 Session B 回滚 ，Session A 读取 的内容就是 临时且无效 的。

Session A和Session B各开启了一个事务，Session B中的事务先将studentno列为1的记录的name列更新 为’张三’，然后Session A中的事务再去查询这条studentno为1的记录，如果读到列name的值为’张三’，而 Session B中的事务稍后进行了回滚，那么Session A中的事务相当于读到了一个不存在的数据，这种现象就称之为 脏读 。

3. 不可重复读（ Non-Repeatable Read ）

对于两个事务Session A、Session B，Session A 读取了一个字段，然后 Session B 更新了该字段。 之后 Session A 再次读取 同一个字段， 值就不同 了。那就意味着发生了不可重复读。

我们在Session B中提交了几个 隐式事务 （注意是隐式事务，意味着语句结束事务就提交了），这些事务 都修改了studentno列为1的记录的列name的值，每次事务提交之后，如果Session A中的事务都可以查看到最新的值，这种现象也被称之为 不可重复读 。

4. 幻读（ Phantom ）

对于两个事务Session A、Session B, Session A 从一个表中 读取 了一个字段, 然后 Session B 在该表中 插 入 了一些新的行。 之后, 如果 Session A 再次读取 同一个表, 就会多出几行。那就意味着发生了幻读。

Session A中的事务先根据条件 studentno > 0这个条件查询表student，得到了name列值为’张三’的记录； 之后Session B中提交了一个 隐式事务 ，该事务向表student中插入了一条新记录；之后Session A中的事务 再根据相同的条件 studentno > 0查询表student，得到的结果集中包含Session B中的事务新插入的那条记 录，这种现象也被称之为 幻读 。我们把新插入的那些记录称之为 幻影记录 。

3.3 SQL中的四种隔离级别

上面介绍了几种并发事务执行过程中可能遇到的一些问题，这些问题有轻重缓急之分，我们给这些问题 按照严重性来排一下序：

脏写 > 脏读 > 不可重复读 > 幻读

我们愿意舍弃一部分隔离性来换取一部分性能在这里就体现在：设立一些隔离级别，隔离级别越低，并发问题发生的就越多。 SQL标准 中设立了4个 隔离级别 ：

  • READ UNCOMMITTED ：读未提交，在该隔离级别，所有事务都可以看到其他未提交事务的执行结 果。不能避免脏读、不可重复读、幻读。
  • READ COMMITTED ：读已提交，它满足了隔离的简单定义：一个事务只能看见已经提交事务所做 的改变。这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。可以避免脏读，但不可 重复读、幻读问题仍然存在。
  • REPEATABLE READ ：可重复读，事务A在读到一条数据之后，此时事务B对该数据进行了修改并提 交，那么事务A再读该数据，读到的还是原来的内容。可以避免脏读、不可重复读，但幻读问题仍 然存在。这是MySQL的默认隔离级别。
  • SERIALIZABLE ：可串行化，确保事务可以从一个表中读取相同的行。在这个事务持续期间，禁止 其他事务对该表执行插入、更新和删除操作。所有的并发问题都可以避免，但性能十分低下。能避 免脏读、不可重复读和幻读。

SQL标准 中规定，针对不同的隔离级别，并发事务可以发生不同严重程度的问题，具体情况如下：

脏写 怎么没涉及到？因为脏写这个问题太严重了，不论是哪种隔离级别，都不允许脏写的情况发生。

不同的隔离级别有不同的现象，并有不同的锁和并发机制，隔离级别越高，数据库的并发性能就越差，4 种事务隔离级别与并发性能的关系如下：

3.4 MySQL支持的四种隔离级别

MySQL的默认隔离级别为REPEATABLE READ，我们可以手动修改一下事务的隔离级别。

# 查看隔离级别，MySQL 5.7.20的版本之前：
mysql> SHOW VARIABLES LIKE 'tx_isolation';
+---------------+-----------------+
| Variable_name | Value           |
+---------------+-----------------+
| tx_isolation  | REPEATABLE-READ |
+---------------+-----------------+
1 row in set (0.00 sec)
# MySQL 5.7.20版本之后，引入transaction_isolation来替换tx_isolation

# 查看隔离级别，MySQL 5.7.20的版本及之后：
mysql> SHOW VARIABLES LIKE 'transaction_isolation';
+-----------------------+-----------------+
| Variable_name         | Value           |
+-----------------------+-----------------+
| transaction_isolation | REPEATABLE-READ |
+-----------------------+-----------------+
1 row in set (0.02 sec)

#或者不同MySQL版本中都可以使用的：
SELECT @@transaction_isolation;

3.5 如何设置事务的隔离级别

通过下面的语句修改事务的隔离级别：

SET [GLOBAL|SESSION] TRANSACTION ISOLATION LEVEL 隔离级别;
#其中，隔离级别格式：
> READ UNCOMMITTED
> READ COMMITTED
> REPEATABLE READ
> SERIALIZABLE

或者：

SET [GLOBAL|SESSION] TRANSACTION_ISOLATION = '隔离级别'
#其中，隔离级别格式：
> READ-UNCOMMITTED
> READ-COMMITTED
> REPEATABLE-READ
> SERIALIZABLE

关于设置时使用GLOBAL或SESSION的影响：

  • 使用 GLOBAL 关键字（在全局范围影响）：

    SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE;
#或
SET GLOBAL TRANSACTION_ISOLATION = 'SERIALIZABLE';

    则：

    • 当前已经存在的会话无效
    • 只对执行完该语句之后产生的会话起作用

  • 使用 SESSION 关键字（在会话范围影响）：

    SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
#或
SET SESSION TRANSACTION_ISOLATION = 'SERIALIZABLE';

    则：

    • 对当前会话的所有后续的事务有效
    • 如果在事务之间执行，则对后续的事务有效
    • 该语句可以在已经开启的事务中间执行，但不会影响当前正在执行的事务

如果在服务器启动时想改变事务的默认隔离级别，可以修改启动参数transaction_isolation的值。比如，在启动服务器时指定了transaction_isolation=SERIALIZABLE，那么事务的默认隔离界别就从原来的REPEATABLE-READ变成了SERIALIZABLE。

小结：

数据库规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

3.6 不同隔离级别举例

初始化数据：

TRUNCATE TABLE account;
INSERT INTO account VALUES (1,'张三','100'), (2,'李四','0');

演示1. 读未提交之脏读

设置隔离级别为未提交读：

脏读就是指当前事务就在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问了这个数据，然后使用了这个数据。

演示2：读已提交

演示3. 不可重复读

设置隔离级别为可重复读，事务的执行流程如下：

当我们将当前会话的隔离级别设置为可重复读的时候，当前会话可以重复读，就是每次读取的结果集都相同，而不管其他事务有没有提交。但是在可重复读的隔离级别上会出现幻读的问题。

演示4：幻读

4. 事务的常见分类

从事务理论的角度来看，可以把事务分为以下几种类型：

  • 扁平事务（Flat Transactions）
  • 带有保存点的扁平事务（Flat Transactions with Savepoints）
  • 链事务（Chained Transactions）
  • 嵌套事务（Nested Transactions）
  • 分布式事务（Distributed Transactions）

spring测试

一、Spring基础知识及IOC_选择题

1. 下面关于spring描述错误的是：（C ）

A Spring支持可插入的事务管理器，使事务划分更轻松，同时无需处理底层的问题。

B Spring事务管理的通用抽象层还包括JTA策略和一个JDBC DataSource。

C 与JTA或EJB CMT一样，Spring的事务支持依赖于Java EE环境。

D Spring事务语义通过AOP应用于 POJO，通过XML或Java SE 5注释进行配置。

 

2. 下面选项哪个不是Spring中接口注入的方式？（D ）

A 接口注入

B 构造子注入

C 设值注入

D 指针注入

 

3. 下列关于Spring特性中IoC描述错误的是：（A）

A IoC就是指程序之间的关系由程序代码直接操控。

B 所谓“控制反转”,是指控制权由应用代码转到外部容器，控制权的转移，

C IoC将控制创建的职责搬进了框架中；并把它从应用代码脱离开来

D 当使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC容器会根据XML配置数据提供给它。

 

二、Spring基础知识及IOC_简答题

1. 请简述Spring的工作机制？

参考答案：Spring的工作机制可从以下几点来描述：

（1）spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。

（2）DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller。（3）DispatcherServlet请请求提交到目标Controller

（4）Controller进行业务逻辑处理后，会返回一个ModelAndView

（5）Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象（6）视图对象负责渲染返回给客户端。

 

2. 请回答你为什么用Spring的工作机制？

参 考答案：Spring能有效的组织你的中间层对象，不管你是否选择使用了EJB。如果你仅仅使用了strus或其他为j2ee的API特性的 framework，spring致力于解决剩下的问题。Spring能够消除在许多工程中常见的对singleton的过多的使用。这个是一个很大的问 题，它降低了系统的可测试性和面向对象的程度。通过把对接口编程而不是对类编程的代价几乎减少到没有，spring能够促进良好的变成习惯的养成。

 

3. 请简述Spring是什么？

参考答案：Spring是一个轻型的容器，是J2EE规范的轻量级实现，是企业应用的“一站式”解决方案。其中的核心就是bean工厂，用以构造我们需要的Model，spring是非侵入式的，Spring的应用中的对象不依赖于Spring的特定类。

 

4. 简述spring的组成？

参考答案：Spring主要由以下六个部分组成

① SpringCore：核心容器，BeanFactory提供了组件生命周期的管理，组件的创建，装配，销毁等功能。

SpringContext：ApplicationContext，扩展核心容器，提供事件处理、国际化等功能。它提供了一些企业级服务的功能，提供了JNDI，EJB，RMI的支持。

②Spring AOP：提供切面支持。

③ Spring DAO：提供事务支持，JDBC，DAO支持。

④ Spring ORM：对流行的O/RMapping封装或支持。

⑤ Spring Web：提供Web应用上下文，对Web开发提供功能上的支持，如请求，表单，异常等。

⑥ Spring Web MVC：全功能MVC框架，作用等同于Struts。

 

5.简述Spring容器提供了哪些功能？

参考答案：Spring容器提供了对对象的管理，如Spring容器负责生成、组装、销毁组件，，另外Spring容器还提供了对持久化的支持，对事务的支持。另外Spring容器提供了国际化等功能。

 

6. 在Spring中，bean的注入有几种方式，各是什么？

参考答案：Spring中，Bean的注入有两中方式，分别是Setter注入和构造器注入。

 

7. 请简述：Spring bean的作用域？

参考答案：在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称prototype）,Spring2.0以后，增加了session、request、global 。session 三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对Bean的类型的 设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean类型，满足实际应用需 求。

 

8. 请叙述设值注入的优点？

参 考答案：设置注入的优点：

（1）与传统的JavaBean的写法更相似，程序开发人员更容易了解和接受。通过setter方法设定依赖关系显得更加直观、 自然。

（2）对于有复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建bean实例时，需要同时实例化其依赖的全部 实例，因而导致性能的下降，而使用设值注入能够解决这些问题。

（3）尤其是某些属性可选的情况下，多参数的构造器更加笨重。

 

9. 请叙述构造注入的优点？

参 考答案：构造注入的优点：

（1）可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入。

（2）对于依赖关系无须变化的bean，构造注入更加有用 处。因为没有setter方法，所有的依赖关系全部在构造器内设定，因此，无须担心后续的代码对依赖关系产生破坏。

（3）依赖关系只能在构造器中设定，则 只有组建的创建者才能改变组建的依赖关系。对组建的调用者而言，组建内部的依赖关系完全透明，更符合高内聚的原则。

 

10. 说出bean工厂创建bean的三种方式？

参考答案:Bean工厂创建bean的三种方式分别是：

（1）直接构造，需要一个default constructor和相应的setters/getters方法。

要注意的是,我们可以为getter/setter方法传递参数(用preperties标签),也可以为构造函数传递参数

（2）采用静态工厂方法，如:

<bean id="exampleBean"class="examples.ExampleBean2" factory-method="createInstance"/>

这里要求examples.ExampleBean2类有个静态方法createInstance

（3）非静态工厂方法

<bean id="myFactoryBean" class="..."> </bean>

<bean id="exampleBean" factory-bean="myFactoryBean" factory-method="createInstance"/>

在这里,必须没有class标签,factory-bean是BeanFactory,factory-method是它的非静态方法，myFactoryBean可以通过容器来管理和配置。

 

11. 请写出bean的生命周期的方法？

参 考答案：

（1）通过设置bean的init-method属性指定初始化的方法，他的限制是方法无法接受任何参数，方法可以为static。

（2）实现 InitializingBean接口的afterPrioertiesSet（）方法。（3）销毁对象可以通过disposableBean的 destroy的实现。

 

12. 请简述你对IOC的理解？

参考答案：IOC即Inversion of  Control，就是反转控制，Ioc将控制创建的职责搬进了框架之中，并把它从应用代码中分隔开来，使用Ioc容器则需要指出组件需要什么对象在运行时容器会提供给它，容器是通过查看对象的参数表做到的，也可能根据配置数据如xml。

 

13. 请回答：IoC最大的好处是什么？

参考答案：IoC最大的好处是降低了对象的耦合性，实现了应用的松散耦合。因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变成很简单（一般这样的对象都是现实于某种接口的），只要修改XML就可以了。

 

14. 简述IoC的类型？

参考答案：IOC可以分为三种注入类型，分别是构造函数注入、属性注入和接口注入。Spring主要支持构造函数注入和属性注入。

 

15. Spring中依赖注入与传统编程之间的差别是什么？

参 考答案：在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转；创 建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。依赖注入的主要作用是起到解耦合的作用。

 

三、.AOP_简答题

1. 说出Spring的通知类型有哪些？

参考答案：Spring的通知类型有(1) MethodBeforeAdvice (2) AfterReturningAdvice (3) MethodInterceptor (4)ThrowsAdvice

 

2. 谈谈目标对象实现接口与目标对象不实现接口有什么区别？

参考答案：目标对象实现接口与目标对象不实现接口主要有以下几点区别：

（1）如果目标对象实现了接口,默认采用JDK的动态代理机制实现AOP

（2）如果目标对象实现了接口,可以强制spring采用CGLIB实现代理

（3） 如果目标对象没有实现接口,必须采用CGLIB实现代理,spring会自动的在CGLIB和JDK动态代理之间切换

 

3. 请描述JDK动态代理和CGLI代理的区别？

参考答案：JDK 的动态代理只能对实现了接口的目标类进行代理，而不实现接口的类就不能使用 JDK 的动态代理 CGLIB是针对类来实现代理，当没有实现接口的类需要代理时就需要通过 CGLIB

来实现代理了，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但是因为采用的是继承，所以不能对 finall类进行继承。二者在某些特殊场合需混合使用

 

4. 简述ProxyFactoryBean的作用是什么？

参考答案：ProxyFactoryBean的作用是依照配置信息，将切面应用到目标对象，生成动态代理对象。

 

5. 叙述Spring中的自动代理的原理？

参考答案：Spring在生成代理对象的时候，默认情况下，会使用被代理对象的接口来生成代理对象。如果被代理对象没有实现接口，此时，Spring会使用CGLIB生成代理对象，此时该代理对象是被代理对象的子类。

 

5. 写出创建代理对象需指定的三要素是什么？

参考答案：创建代理对象需要指定的三要素是：target：设定目标对象（只能是一个）；proxyInterfaces：设定代理接口（目标对象所实现的接口）；interceptorNames：设定拦截器的名字（各个advice或advisor bean的列表）

 

6. 写出代理的两种方式分别是什么？

参考答案：代理的两种方式是：静态代理和动态代理，其中静态代理针对每个具体类分别编写代理类；针对一个接口编写一个代理类。而动态代理针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理

 

7. 请简述：什么是AOP？

参考答案：将程序中的交叉业务逻辑提取出来，称之为切面。将这些切面动态织入到目标对象，然后生成一个代理对象的过程。

 

8. 简述AOP核心？

参考答案：AOP核心主要包括以下内容：（1）Aspect（切面），（2）Joinpoint（连接点），（3）Advice（通知），（4）Pointcut（切入点），（5）Introduction（引入），（6）Weaving（织入），（7）Target（目标对象），（8）Proxy（代理对象）

 

9. 请叙述AOP事务的含义？

参考答案：Spring中进行事务管理的通常方式是利用AOP（面向切片编程）的方式，为普通java类封装事务控制，它是通过动态代理实现的，由于接口是延迟实例化的，spring在这段时间内通过拦截器，加载事务切片。

 

四、Spring对持久化的支持_简答题

1. 请叙述Spring对持久层支持所采用的策略？

参 考答案：Spring对持久层采取了很好的支持，这些支持策略主要有：

（1）Spring对持久层“不发明重复的轮子”，即没有重新实现新的持久层方案， 对现有持久层方案做封装，更利于使用。

（2）采用DAO模式。

（3）提供了大量的模板类来简化编程 （HibernateDaoSupport，JdbcTemplate等）

（4）重新设计了一套完善的异常体系结构：①类型丰富，细化异常类型。② 全都是运行时异常（RuntimeException）。

 

2. 请问Spring如何简化事务配置？

参 考答案：pring简化事务配置有两种方式：第一种方式就是使用TransactionProxyFactoryBean创建事务代理（通常事务代理以 Service层为目标bean）配置hibernate的事务管理器，使用HibernateTransactionManager类，该类实现了 PlatformTransactionManager接口,针对hibernate持 久化连接的特定实现。第二种方式使用自动创建代理简化事务配置使用BeanNameAutoProxyCreator和 DefaultAdvisorAutoProxyCreator创建代理时，并不一定是创建事务代理，关键在于传入的拦截器，如果传入事务拦截器，将可自 动生成事务代理

 

3. 请简述Spring的事务机制？

参 考答案：Spring对事务的支持很丰富，除了编程式的处理事务，Spring还支持声明式事务。其次Spring使用事务服务代理和事务管理器（如 HibernateTransactionManager）来支持事务服务。另外Spring对事务的边界多了一种嵌套事务。

 

4．请回答：Spring API中的getCurrentSession()和openSession()两个方法的区别？

参 考答案：getCurrentSession()和openSession()两个方法主要有两点的区别：

（1）采用 getCurrentSession（）创建的session会绑定到当前线程中，而采用openSession（）创建的session则不会。

（2） 采用getCurrentSession（）创建的session在commit或者rollback后会自动关闭，而采用openSession的方式 需要手动进行关闭。

 

5. 请叙述Spring中使用Hibernate事务的步骤？

参考答案：Spring中使用Hibernate事务的步骤为：

（1）配置数据源

（2）配置sessionfactory

（3）配置事务管理器

（4）创建事务服务代理

 

6. 请叙述关于Spring的声明式事务处理？

参 考答案：Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要 我们在与事务相关的方法中处理大量的try?catch?finally代码。我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。 事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。

 

7. 请叙述Spring的事务传播属性与隔离级别？

参 考答案：在使用Spring时，大部分会用到他的声明式事务，简单的在配置文件中进行一些规则配置，利用Spring的AOP功能就能轻松搞定事务问题； 这里面就涉及到一个事务的传播属性问题Propagation，它在TransactionDefinition接口中定义，以供 PlatfromTransactionManager使用,PlatfromTransactionManager是spring事务管理的核心接口。

在TransactionDefinition接口中定义了五个不同的事务隔离级别，ISOLATION_DEFAULT这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应，ISOLATION_READ_UNCOMMITTED这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

 

五、Spring+Struts+Hibernate

1. Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理？

参 考答案：Hibernate是最优秀的ORM框架，Spring对其提供了很好的支持，那么在Spring中使用Hibernate时要：

（1）为每一个 bean写hibernate映射文件，配置datasourse，hibernateDaoTemplate，sessionFactory，把 datasourse和映射文件注入到sessionFactory

（2） 每个dao都继承spring容器中提供的一个类HibernateDaoSupport，为每个dao注入 hibernateDaoTemplate

（3）在dao中使用getHibernateDaoTemplate（）的方法。Spring中可以把需要进 行事务控制的Biz注入到transactionProxy，为biz方法配置transactionAttribute

 

2．请比较一下Spring framework与Struts？

参考答案：Struts只是一个MVC框架（Framework），用于快速的开发Java Web应用。Struts实现的重点在C（Controller），包括Actionservlet/RequestProcessor和我们定制的Action，也为V（View）提供了一系列的标签（Custom Tag）。而Spring是一个轻型容器，其中核心是bean工厂（beanfactory），用以构造我们所需的Model。在此基础上，spring提供了AOP（面向切面编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂 的扩展ApplicationContext更加方便我们实现j2ee的应用；Dao/ORM的实现方便我们进行数据库的开发；Web

MVC和Spring Web提供了java Web应用的框架或与其他流行的Web框架进行集成。两者进行结合在一起使用是最好的方式。

 

3. 请叙述编写业务逻辑的方法？

参考答案：继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是HibernateSession 的轻量级封装。默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的。编写业务逻辑方法时，最好将异常 一直向上抛出，在表示层（struts）处理。关于事务边界的设置，通常设置到业务层，不要添加到Dao上。

 

4. 在Web分层架构中业务层为什么都选择Spring？

参考答案：因为Service层需要处理业务逻辑和交叉业务逻辑，处理事务，日志，安全等，而这些与Spring的IoC特性，AOP等不谋而合。

 

----------------------------------------------------------------------------------------------------------

Spring考试试卷 （题库）

1. 下列关于AOP的说法错误的是（ ）。

A．AOP将散落在系统中的“方面”代码集中实现

B．AOP有助于提高系统的可维护性

C．AOP已经表现出了将要替代面向对象的趋势

D．AOP是一种设计模式，Spring为其提供了一种实现

 

2. 在SSH整合时，事务隔离级别是由（B ）实现的。

A．Java应用程序

B．Hibernate

C．数据库系统

D．JDBC驱动程序

 

3. 下列（ BC）不是Spring的依赖注入方式。【选两项】

A．setter注入

B．getter注入

C．接口注入

D．构造注入

 

4. 在Spring框架中，面向方面编程（AOP）的目标在于（A ）。

A．编写程序时不用关心其依赖组件的实现

B．将程序中涉及的公用问题集中解决

C．封装JDBC访训数据库的代码，简化数据访训层的得复性代码

D．实现画面的“无刷新”

 

5. 关于Spring 与 Hibernate集成，下列说法错误的是（A ）。

A．Spring提供了HibernateDaoSupport类来简化Hibernate的使用

B．在Spring配置文件中，可以通过Spring提供的LocalSessionFactoryBean来获得SessionFactory的实例

C．通过集成Spring和Hibernate，用Spring管理程序的依赖关系，将SessionFactory注入到DataSource中

D．通过Spring，可以在Biz层代码中无需直接实例化DAO类，而是通过注入得到

 

6. 在Spring中，下列关于依赖注入的说法，正确的是（A ）。

A．依赖注入的目标是在代码之外管理程序组建间的依赖关系（组件？组建？）

B．依赖注入即“面向接口”的编程

C．依赖注入是面向对象技术的替代品

D．依赖注入的使用会增大程序的规模

 

7. 下列关于Spring的说法错误的是（ C）。

A．Spring是一个轻量级JAVA EE的框架集合

B．Spring是“依赖注入”模式的实现

C．使用Spring可以实现声明事务

D．Spring提供了AOP方式的日志系统

 

8. 在Spring 中，配置Hibernate 事务管理器（Hibernate TransactionManager）时，需要注入的属性名称是（B）。

A．dataSource

B．sessionFactory

C．baseHibernateDao

D．transactionProxyFactoryBean

 

9. 下列（C ）不是Spring AOP中的通知类型。

A．前置通知 B．后置通知 C．代理通知 D．异常通知

 

10. 关于Spring与Hibernate集成，下列说法错误的是（ ）。

A．Spring提供了HibernateDaoSupport类来简化Hibernate的使用

B．在Spring配置文件中，可以通过Spring提供的LocalSessionFactoryBean来获得SessionFactory的实例

C．通过集成Spring和Hibernate，用Spring管理程序的依赖关系，将SessionFactory注入到DataSource中

D．通过Spring，无须在Biz层代码中直接实例化DAO类，而是可以通过注入得到

 

11. 在Spring中，关于依赖注入，下列说法错误的是（ B）。

A．依赖注入是一种设计开发模式

B．依赖注入使组件之间相互依赖、相互制约

C．依赖注入提倡使用接口编程

D．依赖注入可以独立开发各组件，然后根据组件间的依赖关系进行组装

 

12. 关于Spring，下列说法不正确的是（D ）。

A．运用Spring，可以通过一个setter方法暴露一个类的任何依赖关系

B．Spring解决依赖性问题的方法即反向控制或依赖注入

C．Spring从配置方面来解决依赖性问题，无须编写一个数据库连接

D．Spring从配置方面来解决依赖性问题，同时也需要编写一个数据库连接

 

13. 下列对Spring的7个模块的说法，正确的有（AC ）。【选两项】

A．各模块（或组件）可以单独存在

B．各模块（或组件）不可以单独存在，必须要一起使用

C．核心模块的BeanFactory使Spring成为框架

D．上下文模块使Spring成为容器

 

14. Spring以Bean的方式管理所有的组件，此处的Bean指的是（B ）。

A． 必须符合JavaBean

B． 任何Java对象以及Java组件都视为Bean

C． 必须要有getter方法和setter方法

D． EJB组件

 

15. 在Spring中，Bean属性中的autowire包括（ ABCE）。【选四项】

A．byName

B．byType

C．constructor

D．bySet

E．no

 

16. 在Spring中，Bean属性中的dependency-check包括（ ）。【选三项】

A．no B．objects C．simple D．all

 

17. 在Spring中，下列关于Bean属性中的singleton的说法，正确的有（CD ）。【选两项】

A．用于定义Bean是否为Singleton

B．默认为false

C．默认为true

D．在BeanFactory作用范围内，仅维护此Bean的一个实例

 

18. Spring包括两种不同的容器，分别是（ ）。【选两项】

A．BeanFactory

B．FileSystemXmlApplicationContext

C．ClassPathXmlApplicationContext

D．ApplicationContext

 

19. 下列能够判断Spring容器是否包含ID为proBean的Bean的代码为（ ）。

A．boolean flag = beanFactory.containsBean("proBean");

B．PropertiesBean propertiesBean= (PropertiesBean)beanFactory.getBean("proBean");

C．Class classType = beanFactory.getType("proBean");

D．PropertiesBean propertiesBean= (PropertiesBean)beanFactory.getBean("proBean", PropertiesBean.class);

 

20. 在Spring中，ApplicationContext继承了BeanFactory接口，提供BeanFactory的所有功能，同时具有部分新功能，包括（ABC ）。【选三项】

A．提供国际化的支持 B．资源访问 C．事务传递 D．载入多个配置文件

 

21. Spring常见的注入方式有（ AD）。【选两项】

A．setter注入 B．getter注入 C．接口注入 D．构造注入

 

22. 在Spring中，设值注入的优点包括（ ）。【选三项】

A．对于习惯了传统JavaBean开发的程序员而言，通过setter方法设定依赖关系更加直观自然

B．当依赖关系（或继承关系）较复杂时，构造注入方式的构造函数相当庞大。此时若使用设值注入的方式，则简单快捷

C．某些第三方类库要求组件必须提供默认的构造函数，此时构造注入方式的依赖注入机制会突显其局限性，难以完成期望功能

D．在构造期即能创建完整、合法的对象

 

23. 在Spring中，构造注入的优点包括（ ）。【选三项】

A．将创建完整、合法对象的工作任务转交给构造函数外的其他方法

B．避免了编写繁琐的setter方法，所有的依赖关系都在构造函数中设定

C．由于不存在setter方法，而是在构造时由容器一次性设定依赖关系，因而组件在创建之后即处于相对不变的稳定状态，无须担心上层代码在调用过程中执行setter方法时破坏组件之间的依赖关系

D．通过构造子注入，可以在构造函数中决定依赖关系的注入顺序？？？？？？？？？

 

24. 在Spring中，关于IOC的理解，下列说法正确的有（ ）。【选两项】

A. 控制反转

B. 对象被动地接受依赖类

C. 对象主动地寻找依赖类

D. 一定要用接口

 

25. 下列关于在Spring中配置Bean的id属性的说法，正确的有（ ）。【选两项】

A. id属性值可以重复

B. id属性值不可以重复

C. id属性是必须的，没有id属性会报错

D. id属性不是必须的

 

26. 在Spring中，关于依赖注入，下列选项中说法错误的是（ ）。

A. 依赖注入能够独立开发各组件，然后根据组件间的关系进行组装

B. 依赖注入使组件之间相互依赖、相互制约

C. 依赖注入提倡使用接口编程

D. 依赖注入指对象在使用时动态注入

 

27. 在Spring中，下列关于setter注入和构造注入的说法，正确的有（ ）。【选两项】

A．执行效果完全相同

B．注入依赖关系注入时机不同

C．setter注入方式依赖对象先注入

D．构造注入方式依赖对象先注入

 

28. 在Spring中，下列关于AOP的说法正确的是（ ）。

A．AOP为OOP的补充和完善

B．AOP为OOA的补充和完善

C．AOP将逐渐代替OOP

D．AOP将逐渐代替OOA

 

29. 在Spring中，AOP将软件系统分为两个部分，分别是( )。【选两项】

A．切面 B．业务处理 C．核心关注点 D．横切关注点

 

30. 在Spring中，实现AOP代理时，下列说法正确的有（ ）。【选三项】

A．Spring默认使用用于接口的JDK动态代理

B．Spring只能使用JDK动态代理

C．Spring也可以使用CGLIB代理

D．Spring主要使用JDK动态代理

 

31. 在Spring中，使用Java实现代理方式需实现InvocationHandler接口，且必须实现

invoke(Object proxy, Method method, Object[] args)方法，则下列说法正确的有（ ）。【选三项】

A．第一个参数是目标类

B．第二个参数Method由被代理接口的方法调用

C．第三个参数是方法调用的参数

D．当程序调用代理的目标方法时，会自动变为调用invoke方法

 

32. 在Spring中，Proxy.newProxyInstance(mobile.getClass().getClassLoader(),mobile.getClass().getInterfaces(), this) 方法根据接口数组动态创建代理类实例，下列说法不正确的是（ ）。

A．第一个参数用于创建动态代理的ClassLoader对象

B．第二个参数为代理对象

C．第三个参数为代理包含的处理实例

D．第二个参数为接口数组

 

33. Spring的环绕通知必须实现的接口是（ ）。

A．InvocationHandler

B．MethodInterceptor

C．MethodBeforeAdvice

D．AfterReturningAdvice

 

34. Spring的后置通知必须实现的接口是（ ）。

A．InvocationHandler

B．MethodInterceptor

C．MethodBeforeAdvice

D．AfterReturningAdvice

 

35. 在Spring中，ProxyFactoryBean继承了父类ProxyCreatorSupport的所有配置属性，同时添加了部分独有属性interceptorNames，下列说法正确的有（ ）。【选两项】

A．可以通过该属性指定多个将织入目标对象的Advice

B．采用类似ProxyFactory的addAdvice方法来逐一添加

C．采用类似ProxyFactory的addAdvisor方法来逐一添加

D．此属性属于Collection类型，可以通过配置元素<list>添加需要的拦截器名称

 

36. 在Spring中，下列关于AOP的理解，正确的有（ ）。【选两项】（A/B选项不完整）

A. 面向纵向的 B. 面向横向的 C. AOP关注的是面 D. AOP关注的是点

 

37. 在Spring框架中，面向方面编程（AOP）的目标在于（ ）。

A. 编写程序时无须关注其依赖组件的实现

B. 封装JDBC访问数据库的代码，简化数据访问层的重复性代码

C. 将程序中涉及的公共问题集中解决

D. 可以通过Web服务调用

 

38. 在Spring中，下面的代码定义了一个前置通知类，则下列选项中，说法错误的是（ ）。

public class LogAdvice implements MethodBeforeAdvice{

　　public void before(Method m,Object[]arges,Object target) throws Throwable{

　　System.out.println(m.getName()+"(" + Arrays.toString(args) +")";

}

}

A. 方法before是MethodBeforeAdvice接口中定义的方法

B. 参数m是被通知的目标方法

C. 参数args是调用方法的参数

D. 参数target是代理类

 

39. 通过Spring构建Hibernate，存在的优点有（ ）。【选三项】

A．测试简单

B．异常封装

C．通用的代码管理

D．综合的事务管理

 

40. 在SSH整合时，findByExample(Account instance)方法的作用是（ ）。

A．根据一个属性的值查询

B．将传入的对象状态设置为Transient状态

C．根据对象查询，查询条件为对象的属性值

D．添加与修改，类似于saveOrUpdate

 

41. 在Spring和Hibernate的整合过程中，各对象注入的顺序是（ ）。（空格）

A．DataSource->SessionFactory-> Biz -> DAO

B．SessionFactory -> DataSource ->DAO->Biz

C．DataSource->SessionFactory->DAO->Biz

D．SessionFactory -> DataSource -> Biz -> DAO

 

42. 在Spring包装Hibernate后，能够用于保存数据的方法有（ ）。【选三项】

A. save B. load C. saveOrUpdate D. merge

 

43. 关于Spring与Hibernate集成，下列说法错误的是（ ）。

A. 通过集成Spring与Hibernate，以Spring管理程序的依赖关系，将SessionFactory

注入DataSource

B. 通过Spring，在Biz层代码中无须直接实例化DAO类，而是通过注入获得

C. 通过Spring，在DAO类中无须实例化SessionFactory，而是通过注入获得

D. Spring提供HibernateDaoSupport类来简化Hibernate的使用

 

44. Spring整合Hibernate后，下列关于findByCriteria方法的说法正确的是（ ）。

A. 参数是HQL

B. 参数是Retrictions对象

C. 参数是DetachedCriteria对象

D. 该方法不支持分页

 

45. 关于Spring对Hibernate提供的支持，下列说法错误的是（ ）。

A. 提供了综合的事务管理 B. 提供了统一的异常继承体系

C. 便于测试 　　　　　　D. 没有给查询提供良好的支持

 

46. 在Spring中，下列说法正确的是（ ）。

A. Spring DAO需要注入DataSource 　　B. Spring DAO需要注入SessionFactory

C. DataSource需要注入SessionFactory D. Spring DAO无须注入SessionFactory

 

47. 在Web启动时创建ApplicationContext，下列选项错误的是（ ）。

A. <listener>

　　<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

B. <servlet>

　　<servlet-name>context</servlet-name>

　　<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>

</servlet>

C. <context-param>

　　<param-name>contextConfigLocation</param-name>

　　<param-value>

　　　　/WEB-INF/classes/applicationContext.xml,（逗号去掉否）

　　　　/WEB-INF/classes/applicationContext_biz.xml

　　</param-value>

</context-param>

<listener>

　　<listener-class>org.springframework.web.context.ContextLoaderListener </listener-class>

</listener>

D. <context-param>

　　<param-name>contextConfigLocation</param-name>

　　<param-value> classpath*:applicationContext.xml</param-value>

</context-param>

<listener>

　　<listener-class>org.springframework.web.context.ContextLoaderListener </listener-class>

</listener>

 

48. Spring IOC容器管理Action的方式有（ ）。【选两项】

A．使用org.springframework.web.struts.DelegatingRequestProcessor

B．使用org.springframework.web.struts.DelegatingActionProxy

C．使用org.springframework.web.context.ContextLoaderListener

D．使用org.springframework.web.context.ContextLoaderServlet

 

49. 使用org.springframework.web.struts.DelegatingActionProxy时，需要什么配置？（ ）

A．需要在struts-config.xml中配置

<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"> </controller>

B．需要在web.xml中配置

<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"> </controller>

C．需要在hibernate.cfg.xml中配置

<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"> </controller>

D．需要在applicationContext.xml中配置

<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"> </controller>

 

50. SSH整合的优点有（ ）。【选两项】

A．实现了视图、控制器与模型的彻底分离

B．实现了业务逻辑层与持久层的分离

C．具有可扩展性

D．具有可维护性

 

51. 在Spring中，BeanFactory由org.springframework.beans.factory.BeanFactory接口定义，是工厂模式的实现，其作用包括（ ）。【选三项】

A．负责创建和管理Bean

B．负责在实例化Bean之前创建Bean之间的联系

C．创建及分发Bean

D．参与到Bean生命周期中，调用对象的初始化函数及析构函数

 

52. Spring的优点包括（ ）。【选三项】

A．低入侵式设计，代码污染低

B．独立于各种服务器，真正实现Write Once、Run Anywhere

C．Spring的AOP机制降低了业务对象替换的复杂性

D．Spring的高度开放性，不强制要求应用完全依赖于Spring

 

53. Spring实现了（ ）两种基本设计模式。【选两项】

A．门面模式 B．工厂模式 C．单态模式 D．多态模式

 

54. 单态模式的优势不包括（ ）。

A．尽量减少Java对象的创建和销毁时的开销

B．避免Java类的频繁实例化

C．让相同类的全部实例共享同一内存区

D．无须要求一个类只有一个实例

 

55. Spring的核心机制是（ ）。

A．依赖注入 B．AOP C．声明式事务 D．资源访问

 

56. Spring依赖注入对调用者和被调用者是否有要求？（ ）

A．对调用者有要求

B．对被调用者有要求

C．对调用者和被调用者都没有要求

D．以上说法都不正确

 

57. Spring以Bean的方式管理所有的组件，此处的Bean不包括（ ）。

A．任何Java对象

B．任何Java组件

C．任何JavaBean

D．必须符合规范的JavaBean

 

58. 在Spring中，用于产生Bean工厂的是（ ）。

A．Spring的BeanFactory

B．Spring的AOP

C．Spring的资源

D．Spring的核心库

 

59. 对应web应用，无须在代码中手动实例化ApplicationContext，可通过ContextLoader声明式地创建。ContextLoader有两个实现类，分别是（ ）。【选两项】

A．ContextLoaderListener

B．ContextWebListener

C．ContextLoaderServlet

D．ContextWebServlet

 

60. 在Spring中，AOP框架具有的两个主要特征是（ ）。【选两项】

A．各部分之间良好的隔离性

B．可维护性

C．源代码无关性

D．可扩展性

 

////end

 

以上是关于_事务基础知识的主要内容，如果未能解决你的问题，请参考以下文章

java数据库学习路线和必学知识点！

MySQL-事务

MYSQL进阶学习笔记九：MySQL事务的应用！（视频序号：进阶_21-22)

mysql数据库事务详细剖析

Java面试 —— MySQL相关

Java面试 —— MySQL相关