在应用层实现触发器
在应用层实现触发器
背景
企业应用开发过程中经常面对一些非功能型需求，如：自动收集和设置审计信息、索引和关系约束，有些非功能需求当然可以用数据库自带的功能，如索引约束，但是应用层视乎也有必要重复一次，因为当违背这种约束的时候我们希望提示给用户友好的信息，如：‘xxx已经存在，xxx必须唯一’，这篇文章我就介绍一个简单的方案应对这种需求。
思路
我觉得数据库的触发器是个好东西，应用层完全可以借用一下，我还认为如果我在应用层实现了触发器，像一些前置条件和后置条件验证也可以用触发器实现（这块我不是很清楚设计的是否合理，还是要引入另外一个继承体系）。
实现
核心类
核心代码
DefaultTriggerService.cs
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6
7 using Microsoft.Practices.ServiceLocation;
8
9 using Happy.Domain;
10
11 namespace Happy.Application.Trigger.Internal
12 {
13 internal sealed class DefaultTriggerService : ITriggerService
14 {
15 public void ExecuteBeforeInsert<TAggregateRoot> (TAggregateRoot aggregate)
16 where TAggregateRoot : AggregateRoot
17 {
18 var triggers = ServiceLocator
19 .Current
20 .GetAllInstances<ICreateTrigger<TAggregateRoot>> ();
21
22 foreach ( var trigger in triggers)
23 {
24 trigger.BeforeInsert(aggregate);
25 }
26 }
27
28 public void ExecuteAfterInsert<TAggregateRoot> (TAggregateRoot aggregate)
29 where TAggregateRoot : AggregateRoot
30 {
31 var triggers = ServiceLocator
32 .Current
33 .GetAllInstances<ICreateTrigger<TAggregateRoot>> ();
34
35 foreach ( var trigger in triggers)
36 {
37 trigger.AfterInsert(aggregate);
38 }
39 }
40
41 public void ExecuteBeforeUpdate<TAggregateRoot> (TAggregateRoot aggregate)
42 where TAggregateRoot : AggregateRoot
43 {
44 var triggers = ServiceLocator
45 .Current
46 .GetAllInstances<IUpdateTrigger<TAggregateRoot>> ();
47
48 foreach ( var trigger in triggers)
49 {
50 trigger.BeforeUpdate(aggregate);
51 }
52 }
53
54 public void ExecuteAfterUpdate<TAggregateRoot> (TAggregateRoot aggregate)
55 where TAggregateRoot : AggregateRoot
56 {
57 var triggers = ServiceLocator
58 .Current
59 .GetAllInstances<IUpdateTrigger<TAggregateRoot>> ();
60
61 foreach ( var trigger in triggers)
62 {
63 trigger.AfterUpdate(aggregate);
64 }
65 }
66
67 public void ExecuteBeforeDelete<TAggregateRoot> (TAggregateRoot aggregate)
68 where TAggregateRoot : AggregateRoot
69 {
70 var triggers = ServiceLocator
71 .Current
72 .GetAllInstances<IDeleteTrigger<TAggregateRoot>> ();
73
74 foreach ( var trigger in triggers)
75 {
76 trigger.BeforeDelete(aggregate);
77 }
78 }
79
80 public void ExecuteAfterDelete<TAggregateRoot> (TAggregateRoot aggregate)
81 where TAggregateRoot : AggregateRoot
82 {
83 var triggers = ServiceLocator
84 .Current
85 .GetAllInstances<IDeleteTrigger<TAggregateRoot>> ();
86
87 foreach ( var trigger in triggers)
88 {
89 trigger.AfterDelete(aggregate);
90 }
91 }
92 }
93 }
自动管理树形节点的路径信息
代码
ITreeNode.cs
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6
7 namespace Happy.Domain.Feature
8 {
9 /// <summary>
10 /// 树的节点。
11 /// </summary>
12 public interface ITreeNode
13 {
14 /// <summary>
15 /// 节点ID。
16 /// </summary>
17 Guid Id { get ; set ; }
18
19 /// <summary>
20 /// 父节点ID。
21 /// </summary>
22 Guid ParentId { get ; set ; }
23
24 /// <summary>
25 /// 节点在树中的路径，如：/A/B/C/D，包含自己。
26 /// </summary>
27 string NodePath { get ; set ; }
28 }
29 }
TreeNodeTrigger.cs
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6
7 using Happy.ExtensionMethod;
8 using Happy.Domain;
9 using Happy.Domain.Feature;
10 using Happy.Application.Trigger;
11
12 namespace Happy.EntityFramework.Trigger
13 {
14 public class TreeNodeTrigger<TUnitOfWork, TAgggregateRoot> : TriggerBase<TUnitOfWork, TAgggregateRoot>
15 where TUnitOfWork : UnitOfWork
16 where TAgggregateRoot : AggregateRoot, ITreeNode
17 {
18 public override void BeforeInsert(TAgggregateRoot aggregate)
19 {
20 var parentNodePath = this .GetParentNodePath(aggregate);
21
22 aggregate.NodePath = parentNodePath + " / " + aggregate.Id;
23 }
24
25 public override void BeforeUpdate(TAgggregateRoot aggregate)
26 {
27 var newParentNodePath = this .GetParentNodePath(aggregate);
28 var newNodePath = newParentNodePath + " / " + aggregate.Id;
29 var oldNodePath = aggregate.NodePath;
30
31 if (oldNodePath == newNodePath)
32 {
33 return ;
34 }
35
36 aggregate.NodePath = newNodePath;
37
38 var table = typeof (TAgggregateRoot).Name.ToPluralize();
39 var sql = string .Format( " UPDATE {0} SET NodePath = REPLACE(NodePath, {{0}}, {{1}}) WHERE NodePath LIKE {{2}} " , table);
40 this .UnitOfWork.Database.ExecuteSqlCommand(sql, oldNodePath, newNodePath, oldNodePath + " /% " );
41 }
42
43 public override void BeforeDelete(TAgggregateRoot aggregate)
44 {
45 var table = typeof (TAgggregateRoot).Name.ToPluralize();
46 var sql = string .Format( " DELETE FROM {0} WHERE NodePath LIKE {{0}} " , table);
47 this .UnitOfWork.Database.ExecuteSqlCommand(sql, aggregate.NodePath + " /% " );
48 }
49
50 private string GetParentNodePath(TAgggregateRoot aggregate)
51 {
52 var table = typeof (TAgggregateRoot).Name.ToPluralize();
53 var sql = string .Format( " SELECT NodePath FROM {0} WHERE Id = {{0}} " , table);
54 return this .UnitOfWork.Database.SqlQuery< string > (sql, aggregate.ParentId).FirstOrDefault();
55 }
56 }
57 }
运行效果
备注
这种触发器我在项目中有用过，虽然有所不足，如批量操作性能不高，但是在很多场景下，也减少了不少的重复代码。
抽象工厂模式
在工厂方法模式中，我们使用一个工厂创建一个产品，也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。
在讲解抽象工厂模式之前，我们需要厘清两个概念：
产品等级结构。产品的等级结构也就是产品的继承结构。例如一个为空调的抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个抽象类空调和他的子类就构成了一个产品等级结构。
产品族。产品族是在抽象工厂模式中的。在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调。海尔冰箱，那么海尔空调则位于空调产品族中。
产品等级结构和产品族结构示意图如下：
一、基本定义
抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。
抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。
二、模式结构
抽象工厂模式的UML结构图如下：
模式结构说明。
AbstractFactory：抽象工厂。抽象工厂定义了一个接口，所有的具体工厂都必须实现此接口，这个接口包含了一组方法用来生产产品。
ConcreteFactory：具体工厂。具体工厂是用于生产不同产品族。要创建一个产品，客户只需要使用其中一个工厂完全不需要实例化任何产品对象。
AbstractProduct：抽象产品。这是一个产品家族，每一个具体工厂都能够生产一整组产品。
Product：具体产品。
三、模式实现
依然是披萨店。为了要保证每家加盟店都能够生产高质量的披萨，防止使用劣质的原料，我们打算建造一家生产原料的工厂，并将原料运送到各家加盟店。但是加盟店都位于不同的区域，比如纽约、芝加哥。纽约使用一组原料，芝加哥使用另一种原料。在这里我们可以这样理解，这些不同的区域组成了原料家族，每个区域实现了一个完整的原料家族。
首先创建一个原料工厂。该工厂为抽象工厂，负责创建所有的原料。
PizzaIngredientFactory.java
1 public interface PizzaIngredientFactory {
2 /*
3 * 在接口中，每个原料都有一个对应的方法创建该原料
4 */
5 public Dough createDough();
6
7 public Sauce createSauce();
8
9 public Cheese createCheese();
10
11 public Veggies[] createVeggies();
12
13 public Pepperoni createPepperoni();
14
15 public Clams createClams();
16 }
原料工厂创建完成之后，需要创建具体的原料工厂。该具体工厂只需要继承PizzaIngredientFactory，然后实现里面的方法即可。
纽约原料工厂：NYPizzaIngredientFactory.java。
1 public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
2
3 @Override
4 public Cheese createCheese() {
5 return new ReggianoCheese();
6 }
7
8 @Override
9 public Clams createClams() {
10 return new FreshClams();
11 }
12
13 @Override
14 public Dough createDough() {
15 return new ThinCrustDough();
16 }
17
18 @Override
19 public Pepperoni createPepperoni() {
20 return new SlicedPepperoni();
21 }
22
23 @Override
24 public Sauce createSauce() {
25 return new MarinaraSauce();
26 }
27
28 @Override
29 public Veggies[] createVeggies() {
30 Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RefPepper()};
31 return veggies;
32 }
33
34 }
重新返回到披萨。在这个披萨类里面，我们需要使用原料，其他方法保持不变，将prepare()方法声明为抽象，在这个方法中，我们需要收集披萨所需要的原料。
Pizza.java
1 public abstract class Pizza {
2 /*
3 * 每个披萨都持有一组在准备时会用到的原料
4 */
5 String name;
6 Dough dough;
7 Sauce sauce;
8 Veggies veggies[];
9 Cheese cheese;
10 Pepperoni pepperoni;
11 Clams clams;
12
13 /*
14 * prepare()方法声明为抽象方法。在这个方法中，我们需要收集披萨所需要的原料，而这些原料都是来自原料工厂
15 */
16 abstract void prepare();
17
18 void bake(){
19 System.out.println("Bake for 25 munites at 350" );
20 }
21
22 void cut(){
23 System.out.println("Cutting the pizza into diagonal slices" );
24 }
25
26 void box(){
27 System.out.println("Place pizza in official PizzaStore box" );
28 }
29
30 public String getName() {
31 return name;
32 }
33
34 public void setName(String name) {
35 this .name = name;
36 }
37
38 }
CheesePizza.java
1 public class CheesePizza extends Pizza{
2 PizzaIngredientFactory ingredientFactory;
3
4 /*
5 * 要制作披萨必须要有制作披萨的原料，而这些原料是从原料工厂运来的
6 */
7 public CheesePizza(PizzaIngredientFactory ingredientFactory){
8 this .ingredientFactory = ingredientFactory;
9 prepare();
10 }
11
12 /**
13 * 实现prepare方法
14 * prepare 方法一步一步地创建芝士比萨，每当需要原料时，就跟工厂要
15 */
16 void prepare() {
17 System.out.println("Prepareing " + name);
18 dough = ingredientFactory.createDough();
19 sauce = ingredientFactory.createSauce();
20 cheese = ingredientFactory.createCheese();
21 }
22
23 }
Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，它只需要知道如何制作披萨即可。这里，Pizza和区域原料之间被解耦。
ClamPizza.java
1 public class ClamPizza extends Pizza{
2
3 PizzaIngredientFactory ingredientFactory;
4
5 public ClamPizza(PizzaIngredientFactory ingredientFactory){
6 this .ingredientFactory = ingredientFactory;
7 }
8
9 @Override
10 void prepare() {
11 System.out.println("Prepare " + name);
12 dough = ingredientFactory.createDough();
13 sauce = ingredientFactory.createSauce();
14 cheese = ingredientFactory.createCheese();
15 clams = ingredientFactory.createClams();
16 }
17
18 }
做完披萨后，需要关注披萨店了。
在披萨店中，我们依然需要关注原料，当地的披萨店需要和本地的原料工厂关联起来。
PizzaStore.java
1 public abstract class PizzaStore {
2 public Pizza orderPizza(String type){
3 Pizza pizza;
4 pizza = createPizza(type);
5
6 pizza.prepare();
7 pizza.bake();
8 pizza.cut();
9 pizza.box();
10
11 return pizza;
12 }
13
14 /*
15 * 创建pizza的方法交给子类去实现
16 */
17 abstract Pizza createPizza(String type);
18 }
纽约的披萨店：NYPizzaStore.java
1 public class NYPizzaStore extends PizzaStore{
2
3 @Override
4 Pizza createPizza(String type) {
5 Pizza pizza = null ;
6 // 使用纽约的原料工厂
7 PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
8 if ("cheese" .equals(type)){
9 pizza = new CheesePizza(ingredientFactory);
10 pizza.setName("New York Style Cheese Pizza" );
11 }
12 else if ("veggie" .equals(type)){
13 pizza = new VeggiePizza(ingredientFactory);
14 pizza.setName("New York Style Veggie Pizza" );
15 }
16 else if ("clam" .equals(type)){
17 pizza = new ClamPizza(ingredientFactory);
18 pizza.setName("New York Style Clam Pizza" );
19 }
20 else if ("pepperoni" .equals(type)){
21 pizza = new PepperoniPizza(ingredientFactory);
22 pizza.setName("New York Style Pepperoni Pizza" );
23 }
24 return pizza;
25 }
26 }
下图是上面的UML结构图。
其中PizzaIngredientFactory是抽象的披萨原料工厂接口，它定义了如何生产一个相关产品的家族。这个家族包含了所有制作披萨的原料。
NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是两个具体披萨工厂类，他们负责生产相应的披萨原料。
NYPizzaStore是抽象工厂的客户端。
四、模式优缺点
优点
1、 抽象工厂隔离了具体类的生成，是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
2、 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
缺点
添加新的行为时比较麻烦。如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。
五、模式使用场景
1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
2.系统中有多于一个的产品族，而每次只使用其中某一产品族。
3. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
4. 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
六、总结
1、 抽象工厂模式中主要的优点在于具体类的隔离，是的客户端不需要知道什么被创建了。其缺点在于增加新的等级产品结构比较复杂，需要修改接口及其所有子类。
分类: 程序设计---设计模式
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息