1、单例模式：
确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
单例模式有以下几个要素：
- 私有的构造方法
- 指向自己实例的私有静态引用
- 以自己实例为返回值的静态的公有的方法
单例模式根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。
饿汉式：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
Singleton_Simple {
private
static
final
Singleton_Simple simple =
new
Singleton_Simple();
private
Singleton_Simple(){}
public
static
Singleton_Simple getInstance(){
return
simple;
}
}
|
懒汉式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//双锁机制
class
Singleton {
private
volatile
static
Singleton singleton;
public
static
Singleton getInstance() {
if
(singleton ==
null
) {
synchronized
(Singleton.
class
) {
// 由于每次调用都需要进行同步，所以可以在前面进行判断即可提高效率，同时注意使用的是Singleton.class的类锁
if
(singleton ==
null
) {
singleton =
new
Singleton();
}
}
}
return
singleton;
}
}
|
为了提高效率。我们可以用double check机制，现在来看两个问题：
（1）为何用double check的检测机制？
由于两个线程都可以通过第一重的判断 ，进入后，由于存在锁机制，所以会有一个线程进入同步块和第二重判断，而另外的一个线程在同步块处阻塞。
当第一个线程退出同步代码块后，第二个进入，没有经过第二重判断，保证了单例。所以这里必须要使用双重检查锁定。
其实没有第一重的判断，我们也可以实现单例，只是为了考虑性能问题。
（2）为何要对实例变量加volatile关键字？
1.为对象分配内存
2.初始化实例对象
3.把引用instance指向分配的内存空间
ps:对象创建可参看《深入理解Java虚拟机》第44页
这个三个步骤并不能保证按序执行，处理器会进行指令重排序优化，存在这样的情况：
优化重排后执行顺序为：1,3,2, 这样在线程1执行到3时，instance已经不为null了，线程2此时判断instance!=null，则直接返回instance引用，但现在实例对象还没有初始化完毕，此时线程2使用instance可能会造成程序崩溃。
现在要解决的问题就是怎样限制处理器进行指令优化重排。
volatile的作用：
（1）volatile变量不会以被缓存到寄存器或者对其它处理器不可见的地方，因此在读取volatile类型的变量时总是返回最新写入的值。
（2）volatile关键字能够通过提供内存屏障，来保证某些指令顺序处理器不能够优化重排，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。
JVM会对分配内存空间的动作进行同步处理。
（1）可能实际上采用CAS（Compare And Set）配上失败重试的方式保证更新操作的原子性
（2）把内存分配的动作按照线程划分在不同的空间之中进行。就是每个线程在Java堆中预先分配一小块内存，
参考Java虚拟机第45页
其实还有种写法，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
Singleton {
private
static
class
SingletonClassInstance {
// 私有静态内部类
// 可能是final解决了并发的问题，基本类型声明就可，但是对象类型时，这个对象不能有状态，
// 如果有状态，则一定要声明为final,例如String类就是一个不可变类
private
static
final
Singleton instance =
new
Singleton();
}
public
static
Singleton getInstance() {
return
SingletonClassInstance.instance;
// 只在这里调用了静态内部类，私有属性让他人无法使用这个类型
}
private
Singleton() { }
}
|
由于Singletom没有static属性且SingletonClassInstance是私有静态内部类，不会被其他类调用，所以不会被提前初始化，实现了懒汉式的构造实例。
重点要知道为什么静态内部类能保证单例：因为只有一个线程去初始化这个类，在初始化后static final就是一个常量了，当然线程安全了。
其在实际中有重要的应用，如：
2、迭代器模式：
提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
interface
Iterable{
public
Iterator iterator();
}
interface
Aggregate
extends
Iterable{
public
void
add(Object obj);
public
void
remove(Object obj);
public
Iterator iterator();
}
class
ConcreteAggregate
implements
Aggregate {
private
List list =
new
ArrayList();
public
void
add(Object obj) {
list.add(obj);
}
public
Iterator iterator() {
return
new
ConcreteIterator(list);
}
public
void
remove(Object obj) {
list.remove(obj);
}
}
|
调用iterator()方法后返回一个Iterator迭代器，实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
interface
Iterator {
public
Object next();
public
boolean
hasNext();
}
class
ConcreteIterator
implements
Iterator {
private
List list =
new
ArrayList();
private
int
cursor =
0
;
public
ConcreteIterator(List list) {
this
.list = list;
}
public
boolean
hasNext() {
if
(cursor == list.size()) {
return
false
;
}
return
true
;
}
public
Object next() {
Object obj =
null
;
if
(
this
.hasNext()) {
obj =
this
.list.get(cursor++);
}
return
obj;
}
}
|
测试一下：
|
1
2
3
4
5
6
7
8
9
|
Aggregate ag =
new
ConcreteAggregate();
ag.add(
"小明"
);
ag.add(
"小红"
);
ag.add(
"小刚"
);
Iterator it = ag.iterator();
while
(it.hasNext()) {
String str = (String) it.next();
System.out.println(str);
}
|
3、组合设计模式：
蜜蜂是昆虫：继承实现
蜜蜂有向前移动后攻击人的行为：组合实现
昆虫：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class
Insect {
private
String name;
public
Insect(String name) {
this
.name = name;
}
public
String getName() {
return
name;
}
public
void
setName(String name) {
this
.name = name;
}
}
|
攻击行为：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
interface
Attack {
public
void
move();
public
void
attack();
}
class
AttackImpl
implements
Attack {
private
String move;
private
String attack;
public
Attack Impl(String move, String attack) {
this
.move = move;
this
.attack = attack;
}
@Override
public
void
move() {
System.out.println(move);
}
@Override
public
void
attack() {
move();
System.out.println(attack);
}
}
|
蜜蜂是昆虫，有向前一步攻击人的属性：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class
Bee
extends
Insect
implements
Attack {
private
Attack attack;
public
Bee(String name, Attack attack) {
super
(name);
this
.attack = attack;
}
public
void
move() {
attack.move();
}
public
void
attack() {
attack.attack();
}
}
|
由于继承机制太过依赖于父类的实现细节，如果父类变动，则子类也会跟着变动，这是糟糕的。
4、策略设计模式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
// Different types of function objects:
interface
Combiner<T> {
T combine(T x, T y);
}
public
class
Functional {
// Calls the Combiner object on each element to combine
// it with a running result, which is finally returned:
public
static
<T> T reduce(Iterable<T> seq, Combiner<T> combiner) {
Iterator<T> it = seq.iterator();
if
(it.hasNext()) {
T result = it.next();
while
(it.hasNext()){
result = combiner.combine(result, it.next());
}
return
result;
}
// If seq is the empty list:
return
null
;
// Or throw exception
}
// To use the above generic methods, we need to create
// function objects to adapt to our particular needs:
static
class
IntegerAdder
implements
Combiner<Integer> {
public
Integer combine(Integer x, Integer y) {
return
x + y;
}
}
static
class
IntegerSubtracter
implements
Combiner<Integer> {
public
Integer combine(Integer x, Integer y) {
return
x - y;
}
}
static
class
BigIntegerAdder
implements
Combiner<BigInteger> {
public
BigInteger combine(BigInteger x, BigInteger y) {
return
x.add(y);
}
}
public
static
void
main(String[] args) {
// Generics, varargs & boxing working together:
List<Integer> li = Arrays.asList(
1
,
2
,
3
,
4
,
5
,
6
,
7
);
Integer result = reduce(li,
new
IntegerAdder());
print(result);
// 28
result = reduce(li,
new
IntegerSubtracter());
print(result);
// Use the prime-generation facility of BigInteger:
List<BigInteger> lbi =
new
ArrayList<BigInteger>();
BigInteger bi = BigInteger.valueOf(
11
);
for
(
int
i =
0
; i <
11
; i++) {
lbi.add(bi);
bi = bi.nextProbablePrime();
}
print(lbi);
BigInteger rbi = reduce(lbi,
new
BigIntegerAdder());
print(rbi);
}
}
|
如上例子参考了Java编程思想关于泛型实现策略模式的例子。
5、原型设计模式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
class
bottle
implements
Cloneable {
public
Wine wine;
public
bottle(Wine wn) {
this
.wine = wn;
}
// 覆写clone()方法
protected
Object clone()
throws
CloneNotSupportedException {
bottle newBottle = (bottle)
super
.clone();
newBottle.wine = (Wine) wine.clone();
return
newBottle;
}
}
class
Wine
implements
Cloneable {
int
degree;
String name=
"法国白兰地"
;
// 字符串虽然是引用类型，但是新对象中修改时并不会影响到原对象值
public
int
getDegree() {
return
degree;
}
public
void
setDegree(
int
degree) {
this
.degree = degree;
}
// 覆写clone()方法
protected
Object clone()
throws
CloneNotSupportedException {
return
super
.clone();
}
}
|
下面来总结一下各个设计模式在Java中的具体应用。
| 结构型模式 | |
| 单例模式（Single Pattern） | 1、Log4j中将日志输出到一个文件中必须使用单例模式，否则会覆盖文件的原有内容 2、数据库连接池中的应用 |
| 工厂模式（Factory） | Spring工厂模式：通过XML文件或Java注解来表示Bean之间的依赖关系，很少直接new一个类进行代码编写 |
| 建造者模式（Builder） | Struts2中创建容器（Container）对象 |
| 原型模式（Protype） | Java的克隆clone() |
| 结构型模式 | |
| 适配器模式（Adapter） | 1、在Java的I/O类库中，StringReader将一个String类适配到Reader接口，InputStreamReader将InputStream适配到Reader类。 2、在Spring中的AOP中，由于Advisor需要的是MethodInterceptor对象，所以每一个Advisor中的Advice都要配成对应的MethodInterceptor对象。 |
| 桥接模式（Bridge） |
|
| 装饰模式（Decorator） | 1、Collections.synchronizedList例子也是一个装饰器模式 2、装饰器在Junit中的应用。TestDecorator是Test的装饰类，其TestDecorator有一些扩展功能的子类。如RepeatedTest类，TestSetup类等 3、一般情况下，需要使用FileReader和StringReader，如果要增加缓存功能的类有很多，那么子类也就需要很多，所以Java就使用了装饰模式，BufferedReader就是这样的装饰类。其实Java I/O 库中的所有输入流、输出流的类都采用了装饰器模式，它们可以无限次地进行装饰转换，转换的目的就是得到自己想要的数据类型的流对象
优点：动态扩展类功能属性，而无需通过继承层次结构实现，更方便灵活给类添加职责 |
| 组合模式（Composite） |
|
| 外观模式（Façade） | 1、在Spring中已经提供了很好的封装，在org.springframework.jdbc.support包下提供的JdbcUtils类就是这样的工具类 2、在Hibernate的配置工作中，有一个Configuration类，负责管理运行时需要的一些信息 |
| 享元模式（Flyweight） | 1、数据据连接池是享元模式的重要应用 2、在Java中，对于基本类型和字符串类型的实现就采用了享元模式 |
| 代理模式（Proxy） | 1、在Spring中已经提供了很好的封装，在org.springframework.jdbc.support包下提供的JdbcUtils类就是这样的工具类 2、在Hibernate的配置工作中，有一个Configuration类，负责管理运行时需要的一些信息 |
| 行为型模式 | |
| 模版方法模式（Template Method） | 1、在Junit中的TestCase类中 2、在MVC框架的HttpServlet中 3、Spring采用开放式的处理方式，在使用JpaTemplate时，只需要处理具体的SQL语句即可，而创建连接、关闭连接等方法都不需要编写代码，因为不管理是哪种持久层的操作应运，其创建和关闭连接都是一致的，按照相同的顺序执行，这就是模板方法模式的应用 |
| 命令模式（Command ）
| 命令模式在Struts２中的应用。其中action就是命令模式中命令接口，ActionInvocation就是命令模式中命令的调用者 |
| 迭代器模式（Iterator ） | java中的Collection、List、Set、Map等，这些集合都有自己的迭代器。 |
| 观察者模式（Oberver Pattern） |
|
| 中介者模式（Mediator） |
|
| 备忘录模式（Memento） |
|
| 解释器模式（Interpreter） |
|
| 状态模式（State） |
|
| 职责链模式（Chain of Responsibility） | 责任链在Struts2中的拦截器上有重要应用 |
| 策略模式（Strategy） | 1、策略模式允许在程序执行时选择不同的算法.比如在排序时,传入不同的比较器(Comparator),就采用不同的算法 2、Spring的Resource实现思想是典型的策略模式的应用 |
| 访问者模式（Visitor） | 1、javac中关于语法树各个节点的语义分析就使用访问者模式来实现的 |
扫一扫
592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
