• 事务工作单元
    • 保存一个实体
    • 保存多个实体
    • 新增实体
    • 更新实体
    • 删除实体
    • 刷新实体
    • 手工启动事务 beginTransaction
    • 执行失败事务回滚 rollBack
    • 事务包裹在闭包中 transaction
    • 事务包裹在闭包中失败回滚 transaction
    • 设置根实体 setRootEntity
    • 更改数据库连接 setConnect
    • 无实体执行 flush 什么都不做
    • 实体实体支持缓存
    • 重新保存已删除的实体实体
    • 注册更新的实体不能重新被创建
    • 注册删除的实体不能重新被创建
    • 注册替换的实体不能重新被创建
    • 不能多次创建同一个实体

    事务工作单元

    用事务工作单元更好地处理数据库相关工作。

    引入相关类

    • use Leevel\Database\Ddd\Entity;
    • use Leevel\Database\Ddd\IUnitOfWork;
    • use Leevel\Database\Ddd\UnitOfWork;
    • use Tests\Database\DatabaseTestCase as TestCase;
    • use Tests\Database\Ddd\Entity\CompositeId;
    • use Tests\Database\Ddd\Entity\Guestbook;
    • use Tests\Database\Ddd\Entity\GuestbookRepository;
    • use Tests\Database\Ddd\Entity\Relation\Post;
    • use Throwable;

      保存一个实体

    1. public function testBaseUse()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $post = new Post([
    9.         'title'   => 'hello world',
    10.         'user_id' => 1,
    11.         'summary' => 'post summary',
    12.     ]);
    14.     $this->assertNull($post->id);
    16.     $work->persist($post);
    18.     $work->flush();
    20.     $this->assertSame('1', $post->id);
    21.     $this->assertSame('1', $post['id']);
    22.     $this->assertSame('1', $post->getId());
    23.     $this->assertSame(1, $post->userId);
    24.     $this->assertSame('post summary', $post->summary);
    25. }

    ::: tip
    通过 persist 方法保存一个实体，并通过 flush 将实体持久化到数据库。
    :::

    保存多个实体

    1. public function testPersist()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $post = new Post([
    9.         'title'   => 'hello world',
    10.         'user_id' => 1,
    11.         'summary' => 'post summary',
    12.     ]);
    14.     $this->assertNull($post->id);
    16.     $post2 = new Post([
    17.         'title'   => 'hello world',
    18.         'user_id' => 2,
    19.         'summary' => 'foo bar',
    20.     ]);
    22.     $this->assertNull($post2->id);
    24.     $work->persist($post);
    25.     $work->persist($post2);
    27.     $work->flush();
    29.     $this->assertSame('1', $post->id);
    30.     $this->assertSame('1', $post['id']);
    31.     $this->assertSame('1', $post->getId());
    32.     $this->assertSame(1, $post->userId);
    33.     $this->assertSame('post summary', $post->summary);
    35.     $this->assertSame('2', $post2->id);
    36.     $this->assertSame('2', $post2['id']);
    37.     $this->assertSame('2', $post2->getId());
    38.     $this->assertSame(2, $post2->userId);
    39.     $this->assertSame('foo bar', $post2->summary);
    40. }

    ::: tip
    底层会开启一个事务，只有全部保存成功才会真正持久化到数据库。
    :::

    新增实体

    1. public function testCreate()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $post = new Post([
    9.         'title'   => 'hello world',
    10.         'user_id' => 1,
    11.         'summary' => 'post summary',
    12.     ]);
    14.     $post2 = new Post([
    15.         'title'   => 'hello world',
    16.         'user_id' => 2,
    17.         'summary' => 'foo bar',
    18.     ]);
    20.     $this->assertNull($post->id);
    21.     $this->assertNull($post2->id);
    22.     $this->assertFalse($work->created($post));
    23.     $this->assertFalse($work->created($post2));
    24.     $this->assertFalse($work->registered($post));
    25.     $this->assertFalse($work->registered($post2));
    27.     $work->create($post);
    28.     $work->create($post2);
    30.     $this->assertTrue($work->created($post));
    31.     $this->assertTrue($work->created($post2));
    32.     $this->assertTrue($work->registered($post));
    33.     $this->assertTrue($work->registered($post2));
    35.     $work->flush();
    37.     $this->assertFalse($work->created($post));
    38.     $this->assertFalse($work->created($post2));
    39.     $this->assertFalse($work->registered($post));
    40.     $this->assertFalse($work->registered($post2));
    42.     $this->assertSame('1', $post->id);
    43.     $this->assertSame('1', $post['id']);
    44.     $this->assertSame('1', $post->getId());
    45.     $this->assertSame(1, $post->userId);
    46.     $this->assertSame('post summary', $post->summary);
    48.     $this->assertSame('2', $post2->id);
    49.     $this->assertSame('2', $post2['id']);
    50.     $this->assertSame('2', $post2->getId());
    51.     $this->assertSame(2, $post2->userId);
    52.     $this->assertSame('foo bar', $post2->summary);
    53. }

    ::: tip
    底层执行的是 insert 语句，只有全部保存成功才会真正持久化到数据库。
    :::

    更新实体

    1. public function testUpdate()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $this->assertSame('2', $connect->
    19.     table('post')->
    20.     insert([
    21.         'title'   => 'hello world',
    22.         'user_id' => 2,
    23.         'summary' => 'foo bar',
    24.     ]));
    26.     $post = Post::find(1);
    28.     $post2 = Post::find(2);
    30.     $this->assertInstanceof(Entity::class, $post);
    31.     $this->assertInstanceof(Entity::class, $post2);
    32.     $this->assertInstanceof(Post::class, $post);
    33.     $this->assertInstanceof(Post::class, $post2);
    35.     $this->assertSame('1', $post->id);
    36.     $this->assertSame('1', $post['id']);
    37.     $this->assertSame('1', $post->getId());
    38.     $this->assertSame('1', $post->userId);
    39.     $this->assertSame('post summary', $post->summary);
    40.     $this->assertSame('hello world', $post->title);
    42.     $this->assertSame('2', $post2->id);
    43.     $this->assertSame('2', $post2['id']);
    44.     $this->assertSame('2', $post2->getId());
    45.     $this->assertSame('2', $post2->userId);
    46.     $this->assertSame('foo bar', $post2->summary);
    47.     $this->assertSame('hello world', $post2->title);
    49.     $this->assertFalse($work->updated($post));
    50.     $this->assertFalse($work->updated($post2));
    51.     $this->assertFalse($work->registered($post));
    52.     $this->assertFalse($work->registered($post2));
    54.     $post->title = 'new post title';
    55.     $post->summary = 'new post summary';
    57.     $post2->title = 'new post2 title';
    58.     $post2->summary = 'new post2 summary';
    60.     $work->update($post);
    61.     $work->update($post2);
    63.     $this->assertTrue($work->updated($post));
    64.     $this->assertTrue($work->updated($post2));
    65.     $this->assertTrue($work->registered($post));
    66.     $this->assertTrue($work->registered($post2));
    68.     $work->flush();
    70.     $this->assertFalse($work->updated($post));
    71.     $this->assertFalse($work->updated($post2));
    72.     $this->assertFalse($work->registered($post));
    73.     $this->assertFalse($work->registered($post2));
    75.     $this->assertSame('1', $post->id);
    76.     $this->assertSame('1', $post['id']);
    77.     $this->assertSame('1', $post->getId());
    78.     $this->assertSame('1', $post->userId);
    79.     $this->assertSame('new post title', $post->title);
    80.     $this->assertSame('new post summary', $post->summary);
    82.     $this->assertSame('2', $post2->id);
    83.     $this->assertSame('2', $post2['id']);
    84.     $this->assertSame('2', $post2->getId());
    85.     $this->assertSame('2', $post2->userId);
    86.     $this->assertSame('new post2 title', $post2->title);
    87.     $this->assertSame('new post2 summary', $post2->summary);
    88. }

    ::: tip
    底层执行的是 update 语句，只有全部保存成功才会真正持久化到数据库。
    :::

    删除实体

    1. public function testDelete()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $this->assertSame('2', $connect->
    19.     table('post')->
    20.     insert([
    21.         'title'   => 'hello world',
    22.         'user_id' => 2,
    23.         'summary' => 'foo bar',
    24.     ]));
    26.     $post = Post::find(1);
    28.     $post2 = Post::find(2);
    30.     $this->assertInstanceof(Entity::class, $post);
    31.     $this->assertInstanceof(Entity::class, $post2);
    32.     $this->assertInstanceof(Post::class, $post);
    33.     $this->assertInstanceof(Post::class, $post2);
    35.     $this->assertSame('1', $post->id);
    36.     $this->assertSame('1', $post['id']);
    37.     $this->assertSame('1', $post->getId());
    38.     $this->assertSame('1', $post->userId);
    39.     $this->assertSame('post summary', $post->summary);
    40.     $this->assertSame('hello world', $post->title);
    42.     $this->assertSame('2', $post2->id);
    43.     $this->assertSame('2', $post2['id']);
    44.     $this->assertSame('2', $post2->getId());
    45.     $this->assertSame('2', $post2->userId);
    46.     $this->assertSame('foo bar', $post2->summary);
    47.     $this->assertSame('hello world', $post2->title);
    49.     $this->assertFalse($work->deleted($post));
    50.     $this->assertFalse($work->deleted($post2));
    51.     $this->assertFalse($work->registered($post));
    52.     $this->assertFalse($work->registered($post2));
    54.     $work->delete($post);
    55.     $work->delete($post2);
    57.     $this->assertTrue($work->deleted($post));
    58.     $this->assertTrue($work->deleted($post2));
    59.     $this->assertTrue($work->registered($post));
    60.     $this->assertTrue($work->registered($post2));
    62.     $work->flush();
    64.     $this->assertFalse($work->deleted($post));
    65.     $this->assertFalse($work->deleted($post2));
    66.     $this->assertFalse($work->registered($post));
    67.     $this->assertFalse($work->registered($post2));
    69.     $postAfter = Post::find(1);
    71.     $post2After = Post::find(2);
    73.     $this->assertNull($postAfter->id);
    74.     $this->assertNull($postAfter['id']);
    75.     $this->assertNull($postAfter->getId());
    76.     $this->assertNull($postAfter->userId);
    77.     $this->assertNull($postAfter->title);
    78.     $this->assertNull($postAfter->summary);
    80.     $this->assertNull($post2After->id);
    81.     $this->assertNull($post2After['id']);
    82.     $this->assertNull($post2After->getId());
    83.     $this->assertNull($post2After->userId);
    84.     $this->assertNull($post2After->title);
    85.     $this->assertNull($post2After->summary);
    86. }

    ::: tip
    底层执行的是 delete 语句，只有全部保存成功才会真正持久化到数据库。
    :::

    刷新实体

    1. public function testRefresh()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $post = new Post([
    19.         'id'      => 1,
    20.         'title'   => 'old',
    21.         'summary' => 'old',
    22.     ], true);
    24.     $this->assertSame(1, $post->getId());
    25.     $this->assertSame('old', $post->getSummary());
    26.     $this->assertSame('old', $post->getTitle());
    28.     $work->persist($post);
    29.     $work->refresh($post);
    31.     $this->assertSame('1', $post->getId());
    32.     $this->assertSame('post summary', $post->getSummary());
    33.     $this->assertSame('hello world', $post->getTitle());
    35.     $work->flush();
    37.     $post = Post::find(1);
    39.     $this->assertInstanceof(Entity::class, $post);
    40.     $this->assertInstanceof(Post::class, $post);
    42.     $this->assertSame('1', $post->id);
    43.     $this->assertSame('1', $post['id']);
    44.     $this->assertSame('1', $post->getId());
    45.     $this->assertSame('1', $post->userId);
    46.     $this->assertSame('post summary', $post->summary);
    47.     $this->assertSame('hello world', $post->title);
    48. }

    ::: tip
    底层执行的是 select 语句，这个操作会读取数据库最新信息并刷新实体的属性。
    :::

    手工启动事务 beginTransaction

    1. public function testBeginTransaction()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $work->beginTransaction();
    20.     $post = Post::find(1);
    21.     $work->update($post);
    23.     try {
    24.         $post->title = 'new title';
    26.         $work->flush();
    27.         $work->commit();
    28.     } catch (Throwable $e) {
    29.         $work->close();
    30.         $work->rollBack();
    31.     }
    33.     $this->assertSame('1', $post->getId());
    34.     $this->assertSame('new title', $post->getTitle());
    35. }

    ::: tip
    通常来说事务工作单元会自动帮你处理事务，可以通过手工 beginTransaction，成功 commit 或者失败 rollBack，系统提供了 API 让你也手工开启事务处理。
    :::

    执行失败事务回滚 rollBack

    1. public function testFlushButRollBack()
    2. {
    3.     $this->expectException(\Leevel\Database\DuplicateKeyException::class);
    4.     $this->expectExceptionMessage(
    5.         'SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry \'1\' for key \'PRIMARY\''
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $post = new Post([
    11.         'id'      => 1,
    12.         'title'   => 'old',
    13.         'summary' => 'old',
    14.     ]);
    16.     $post2 = new Post([
    17.         'id'      => 1,
    18.         'title'   => 'old',
    19.         'summary' => 'old',
    20.     ]);
    22.     $work->create($post);
    23.     $work->create($post2);
    25.     $work->flush();
    26. }

    ::: tip
    底层会自动运行一个事务，如果执行失败自动回滚，不会更新数据库。
    :::

    事务包裹在闭包中 transaction

    1. public function testTransaction()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $work->transaction(function ($w) {
    19.         $post = Post::find(1);
    20.         $w->update($post);
    22.         $post->title = 'new title';
    23.     });
    25.     $newPost = Post::find(1);
    27.     $this->assertSame('1', $newPost->getId());
    28.     $this->assertSame('new title', $newPost->getTitle());
    29. }

    ::: tip
    可以将事务包裹在一个闭包中，如果执行失败自动回滚，不会更新数据库。
    :::

    事务包裹在闭包中失败回滚 transaction

    1. public function testTransactionAndRollBack()
    2. {
    3.     $this->expectException(\Leevel\Database\DuplicateKeyException::class);
    4.     $this->expectExceptionMessage(
    5.         'SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry \'1\' for key \'PRIMARY\''
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $this->assertInstanceof(UnitOfWork::class, $work);
    11.     $this->assertInstanceof(IUnitOfWork::class, $work);
    13.     $connect = $this->createDatabaseConnect();
    15.     $work->transaction(function ($w) {
    16.         $post = new Post([
    17.             'id'      => 1,
    18.             'title'   => 'old',
    19.             'summary' => 'old',
    20.         ]);
    22.         $post2 = new Post([
    23.             'id'      => 1,
    24.             'title'   => 'old',
    25.             'summary' => 'old',
    26.         ]);
    28.         $w->create($post);
    29.         $w->create($post2);
    30.     });
    32.     $this->assertSame(0, $connect->table('post')->findCount());
    33. }

    ::: tip
    可以将事务包裹在一个闭包中，执行失败自动回滚测试，不会更新数据库。
    :::

    设置根实体 setRootEntity

    1. public function testSetRootEntity()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $post = Post::find(1);
    20.     $work->setRootEntity($post);
    22.     $work->update($post);
    24.     $post->title = 'new title';
    26.     $work->flush();
    28.     $this->assertSame('1', $post->getId());
    29.     $this->assertSame('new title', $post->getTitle());
    31.     $newPost = Post::find(1);
    33.     $this->assertSame('1', $newPost->getId());
    34.     $this->assertSame('new title', $newPost->getTitle());
    35. }

    ::: tip
    系统默认读取基础的数据库配置来处理数据相关信息，设置跟实体可以更改事务处理的数据库连接。
    :::

    更改数据库连接 setConnect

    1. public function testSetConnectNotFoundWillUseDefault()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $this->assertInstanceof(UnitOfWork::class, $work);
    6.     $this->assertInstanceof(IUnitOfWork::class, $work);
    8.     $connect = $this->createDatabaseConnect();
    10.     $this->assertSame('1', $connect->
    11.     table('post')->
    12.     insert([
    13.         'title'   => 'hello world',
    14.         'user_id' => 1,
    15.         'summary' => 'post summary',
    16.     ]));
    18.     $post = Post::find(1);
    20.     $work->setConnect('hello');
    22.     $work->update($post);
    24.     $post->title = 'new title';
    26.     $work->flush();
    28.     $this->assertSame('1', $post->getId());
    29.     $this->assertSame('new title', $post->getTitle());
    31.     $newPost = Post::find(1);
    33.     $this->assertSame('1', $newPost->getId());
    34.     $this->assertSame('new title', $newPost->getTitle());
    35. }

    ::: tip
    如果没有存在的连接，则会使用默认的连接。
    :::

    无实体执行 flush 什么都不做

    1. public function testFlushButNotFoundAny()
    2. {
    3.     $work = UnitOfWork::make(new Post());
    5.     $this->assertNull($work->flush());
    6. }

    ::: tip
    实际上什么也不会发生。
    :::

    实体实体支持缓存

    1. public function testPersistStageManagedEntityDoNothing()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $connect = $this->createDatabaseConnect();
    7.     $post = new Post([
    8.         'id'      => 1,
    9.         'title'   => 'old',
    10.         'summary' => 'old',
    11.     ]);
    13.     $work->persist($post, 'create');
    14.     $work->persist($post, 'create');
    16.     $work->flush();
    18.     $this->assertSame(1, $connect->table('post')->findCount());
    19. }

    ::: tip
    保存两个一样的实体，第二个实体并不会被添加。
    :::

    重新保存已删除的实体实体

    1. public function testPersistStageRemovedEntity()
    2. {
    3.     $work = UnitOfWork::make();
    5.     $connect = $this->createDatabaseConnect();
    7.     $this->assertSame('1', $connect->
    8.     table('post')->
    9.     insert([
    10.         'title'   => 'hello world',
    11.         'user_id' => 1,
    12.         'summary' => 'post summary',
    13.     ]));
    15.     $post = Post::find(1);
    17.     $this->assertSame('1', $post->getId());
    18.     $this->assertSame('hello world', $post->getTitle());
    19.     $this->assertSame('post summary', $post->getSummary());
    21.     $work->delete($post);
    23.     $work->persist($post);
    25.     $work->flush();
    27.     $this->assertSame(1, $connect->table('post')->findCount());
    28. }

    ::: tip
    这样被删除的实体并不会被删除。
    :::

    注册更新的实体不能重新被创建

    1. public function testCreateButAlreadyInUpdates()
    2. {
    3.     $this->expectException(\InvalidArgumentException::class);
    4.     $this->expectExceptionMessage(
    5.         'Updated entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $post = new Post(['id' => 5, 'title' => 'foo']);
    12.     $work->update($post);
    14.     $work->create($post);
    15. }

    注册删除的实体不能重新被创建

    1. public function testCreateButAlreadyInDeletes()
    2. {
    3.     $this->expectException(\InvalidArgumentException::class);
    4.     $this->expectExceptionMessage(
    5.         'Deleted entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $post = new Post(['id' => 5]);
    12.     $work->delete($post);
    14.     $work->create($post);
    15. }

    注册替换的实体不能重新被创建

    1. public function testCreateButAlreadyInReplaces()
    2. {
    3.     $this->expectException(\InvalidArgumentException::class);
    4.     $this->expectExceptionMessage(
    5.         'Replaced entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for create.'
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $post = new Post(['id' => 5]);
    12.     $work->replace($post);
    14.     $work->create($post);
    15. }

    不能多次创建同一个实体

    1. public function testCreateManyTimes()
    2. {
    3.     $this->expectException(\InvalidArgumentException::class);
    4.     $this->expectExceptionMessage(
    5.         'Entity `Tests\\Database\\Ddd\\Entity\\Relation\\Post` cannot be added for twice.'
    6.     );
    8.     $work = UnitOfWork::make();
    10.     $connect = $this->createDatabaseConnect();
    12.     $post = new Post(['title' => 'foo']);
    14.     $work->create($post);
    15.     $work->create($post);
    16. }