在上一篇文章里我通过具体场景总结了“.net面向对象的设计原则”，其中也多次提到一些设计模式方面的技术，可想而知，设计模式在我们的开发过程中也是必不可少的。今天我们就来简单交流下设计模式。对于设计模式的介绍呢，网上流行这么一句话“想要搞好对象，必须要熟知套路”，所以百度中说设计模式简介时“设计模式一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结”一点也没错，在开发过程中通过渗入一些设计模式，我们的设计效果又会怎么样呢？话不多说，直接进入正题吧！
一、设计模式的分类
gof一共总结了23套设计模式，大致可以分为以下三类：
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活，该类型包括：单件模式、抽象工厂、建造者模式、工厂方法模式和原型模式等5种。
这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式，该类型包括：适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式和代理模式等7种。
这些设计模式特别关注对象之间的通信。分为职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法、访问者模式等11种。
二、设计模式解析
常用设计模式浅析：
1、单件模式
结构图 ： 
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用性 ：
示意性代码：
我要评论
1 //单件模式示意性代码
2 public class singleton
3 {
4 //创建私有对象，保证只有一个对象
5 private static singleton _instance;
6
7 //保护类型的构造函数，子类化可扩展
8 protected singleton() { }
9
10 //提供公共访问点
11 public static singleton instance()
12 {
13
14 // 使用 'lazy initialization'，为对象实例化
15 if (_instance == null)
16 {
17 _instance = new singleton();
18 }
19
20 return _instance;
21 }
22 }
特点总结：实例对外唯一、子类可以扩展并且提供 一个公共的访问点访问。
实际应用：
1 /// <summary>
2 /// 投票选举
3 /// </summary>
4 public class loadbalancer
5 {
6 //实例唯一
7 private static loadbalancer instance;
8 //选举人
9 private arraylist servers = new arraylist();
10 //随机数
11 private random random = new random();
12 //用于异步
13 private static object synclock = new object();
14 //保护构造函数，创建时添加选举人
15 protected loadbalancer()
16 {
17 servers.add("serveri");
18 servers.add("serverii");
19 servers.add("serveriii");
20 servers.add("serveriv");
21 servers.add("serverv");
22 }
23 //公共访问点，初始化投票对象
24 public static loadbalancer getloadbalancer()
25 {
26 if (instance == null)
27 {
28 lock (synclock)
29 {
30 if (instance == null)
31 {
32 instance = new loadbalancer();
33 }
34 }
35 }
36
37 return instance;
38 }
39 public string server
40 {
41 get
42 {
43 int r = random.next(servers.count);
44 return servers[r].tostring();
45 }
46 }
47 }
1 public class singletonmain
2 {
3 static void main()
4 {
5 loadbalancer b1 = loadbalancer.getloadbalancer();
6 loadbalancer b2 = loadbalancer.getloadbalancer();
7 loadbalancer b3 = loadbalancer.getloadbalancer();
8 loadbalancer b4 = loadbalancer.getloadbalancer();
9
10 if (b1 == b2 && b2 == b3 && b3 == b4)
11 {
12 console.writeline("same instance\n");
13 }
14
15 // load balance 15 server requests
16 for (int i = 0; i < 15; i++)
17 {
18 console.writeline(b1.server);
19 }
20
21 console.readkey();
22 }
23 }
2、抽象工厂
结构图：
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性 ：
示意性代码：
1 public abstract class abstractfactory
2 {
3 public abstract abstractproducta createproducta();
4 public abstract abstractproductb createproductb();
5 }
6 public abstract class abstractproducta { }
7 public abstract class abstractproductb
8 {
9 public abstract void interact(abstractproducta a);
10 }
11 public class concretefactory1 : abstractfactory
12 {
13 public override abstractproducta createproducta()
14 {
15 return new producta1();
16 }
17 public override abstractproductb createproductb()
18 {
19 return new productb1();
20 }
21 }
22 public class concretefactory2 : abstractfactory
23 {
24 public override abstractproducta createproducta()
25 {
26 return new producta2();
27 }
28 public override abstractproductb createproductb()
29 {
30 return new productb2();
31 }
32 }
33 public class producta1 : abstractproducta { }
34 public class producta2 : abstractproducta { }
35 public class productb1 : abstractproductb
36 {
37 public override void interact(abstractproducta a)
38 {
39 console.writeline(this.gettype().name + " interacts with " +
40 a.gettype().name);
41 }
42 }
43 public class productb2 : abstractproductb
44 {
45 public override void interact(abstractproducta a)
46 {
47 console.writeline(this.gettype().name + " interacts with " +
48 a.gettype().name);
49 }
50 }
1 public class client
2 {
3 private abstractproducta _abstractproducta;
4 private abstractproductb _abstractproductb;
5
6 // constructor
7 public client(abstractfactory factory)
8 {
9 _abstractproductb = factory.createproductb();
10 _abstractproducta = factory.createproducta();
11 }
12
13 public void run() => _abstractproductb.interact(_abstractproducta);
14 }
1 class abstractfactorymain
2 {
3 public static void main()
4 {
5 // abstract factory #1
6 abstractfactory factory1 = new concretefactory1();
7 client c1 = new client(factory1);
8 c1.run();
9
10 // abstract factory #2
11 abstractfactory factory2 = new concretefactory2();
12 client c2 = new client(factory2);
13 c2.run();
14
15 console.readkey();
16 }
17 }
特点总结：抽象，多态，一系列相关关联。
3、代理模式
结构图：
意图：为其他对象提供一种代理以控制对这个对象的访问。
适用性 ：
示意性代码：
1 public abstract class subject
2 {
3 public abstract void request();
4 }
5
6 public class realsubject : subject
7 {
8 public override void request()
9 {
10 console.writeline("called realsubject.request()");
11 }
12 }
13
14 public class proxy : subject
15 {
16 realsubject realsubject;
17
18 public override void request()
19 {
20 // use 'lazy initialization'
21 if (realsubject == null)
22 {
23 realsubject = new realsubject();
24 }
25
26 realsubject.request();
27 }
28 }
实际应用：
1 /// <summary>
2 /// subject接口
3 /// </summary>
4 public interface imath
5 {
6 //加法操作
7 double add(double x, double y);
8 //减法操作
9 double sub(double x, double y);
10 //乘法操作
11 double mul(double x, double y);
12 //除法操作
13 double div(double x, double y);
14 }
15
16 /// <summary>
17 /// 具体实现类
18 /// </summary>
19 public class math : imath
20 {
21 public double add(double x, double y)
22 {
23 return x + y;
24 }
25 public double sub(double x, double y)
26 {
27 return x - y;
28 }
29 public double mul(double x, double y)
30 {
31 return x * y;
32 }
33 public double div(double x, double y)
34 {
35 return x / y;
36 }
37 }
38 /// <summary>
39 /// 代理类
40 /// </summary>
41 public class mathproxy : imath
42 {
43 math math;
44 public mathproxy() { math = new math(); }
45
46 public double add(double x, double y) { return math.add(x, y); }
47 public double sub(double x, double y) { return math.sub(x, y); }
48 public double mul(double x, double y) { return math.mul(x, y); }
49 public double div(double x, double y) { return math.div(x, y); }
50 }
4、观察者模式
结构图：
意图：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
适用性 ：
当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用
当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
示意性代码：
1 /// <summary>
2 /// 操作抽象类
3 /// </summary>
4 public abstract class subject
5 {
6 //观察者数组
7 private arraylist observers = new arraylist();
8 //添加观察者
9 public void attach(observer observer) => observers.add(observer);
10 //删除观察者
11 public void detach(observer observer) => observers.remove(observer);
12 //通知观察者们
13 public void notify()
14 {
15 foreach (observer o in observers)
16 {
17 o.update();
18 }
19 }
20 }
21 /// <summary>
22 /// 具体操作类
23 /// </summary>
24 public class concretesubject : subject
25 {
26 // property
27 public string subjectstate { get; set; }
28 }
29 /// <summary>
30 /// 观察者类
31 /// </summary>
32 public abstract class observer
33 {
34 //更新
35 public abstract void update();
36 }
37
38 /// <summary>
39 /// 具体的观察者
40 /// </summary>
41 public class concreteobserver : observer
42 {
43 private string name;
44 private string observerstate;
45
46 // constructor
47 public concreteobserver(concretesubject subject, string name)
48 {
49 this.subject = subject;
50 this.name = name;
51 }
52
53 public override void update()
54 {
55 observerstate = subject.subjectstate;
56 console.writeline("observer {0}'s new state is {1}", name,
57 observerstate);
58 }
59
60 // property
61 public concretesubject subject { get; set; }
62 }
实际应用：
1 /// <summary>
2 /// 拍卖类
3 /// </summary>
4 public abstract class stock
5 {
6 protected string symbol;
7 protected double price;
8 private arraylist investors = new arraylist();
9
10 public stock(string symbol, double price)
11 {
12 this.symbol = symbol;
13 this.price = price;
14 }
15
16 public void attach(investor investor)
17 {
18 investors.add(investor);
19 }
20 public void detach(investor investor)
21 {
22 investors.remove(investor);
23 }
24
25 public void notify()
26 {
27 foreach (investor investor in investors)
28 {
29 investor.update(this);
30 }
31 console.writeline("");
32 }
33
34 // properties
35 public double price
36 {
37 get
38 {
39 return price;
40 }
41 set
42 {
43 price = value;
44 notify();
45 }
46 }
47
48 public string symbol
49 {
50 get
51 {
52 return symbol;
53 }
54 set
55 {
56 symbol = value;
57 }
58 }
59 }
60 /// <summary>
61 /// ibm拍卖
62 /// </summary>
63 public class ibm : stock
64 {
65 public ibm(string symbol, double price) : base(symbol, price)
66 {
67 }
68 }
69 /// <summary>
70 /// 投资商接口
71 /// </summary>
72 interface iinvestor { void update(stock stock); }
73 /// <summary>
74 /// 投资商
75 /// </summary>
76 public class investor : iinvestor
77 {
78 private string name; private stock stock;
79
80 public investor(string name)
81 {
82 this.name = name;
83 }
84
85 public void update(stock stock)
86 {
87 console.writeline("notified {0} of {1}'s " + "change to {2:c}", name,
88 stock.symbol, stock.price);
89 }
90
91 public stock stock
92 {
93 get { return stock; }
94 set { stock = value; }
95 }
96 }
特点总结：抽象，依赖，一个方面依赖于另一方面。
好了，今天就总结到这里了欢迎纠错，谢谢！！！
如对本文有疑问， 点击进行留言回复！！
【面试题】研究过tomcat的NioEndpoint源码吗？请阐述下Reactor多线程模型在tomcat中的实现。
荐 厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略
网友评论