常见的几种设计模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 @author maxu
 @date 2018/11/3
优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步
*	 问题。
缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到
*	  这个实例，但是它也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。
*/
public class Singleton {

    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}  

1
2
3
4
5
6
7
8
9
10
11
12
public class Singleton {

    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (null == instance) {
            instance = new Singleton();
        }
        return instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (null == instance) {
            synchronized (Singleton.class) {
                if (null == instance) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
* 这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同
* 的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时
* 并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类，从而完成Singleton的实例化。
* 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
* 优点：避免了线程不安全，延迟加载，效率高。
*/
public class Singleton {


    private Singleton() {
    }

    private static class Sinletonleader {
        private static Singleton singleton = new Singleton();
    }

    public Singleton getInstance() {
        return Sinletonleader.singleton;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* SingletonEnum.instance.method();
* 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，
* 而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中
* 很少见人这么写过，这种方式也是最好的一种方式，如果在开发中JDK满足要求的情况下建议使用这种方式。
*/
public enum Singleton {
    instance;

    private Singleton() {
    }

    public void method() {
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
/**
* @author maxu
* @date 2018/11/3
* 抽象者被观察者方法
*/
public interface Observerable {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObserver();

}

1
2
3
4
5
6
7
8
9
10
/**
* @author maxu
* @date 2018/11/3
* 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
* 观察者
*/
public interface Observer {
    void update(String message);
}

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
/**
* @author maxu
* @date 2018/11/3
*/
public class WechatServer implements Observerable {
    /**
     * 注意到这个List集合的泛型是Observer
     */
    // 这里保存着所有注册的观察者
    private List<Observer> list;
    private String message;

    public WechatServer() {
        list = new ArrayList<>();
    }

	// 注册观察者
    @Override
    public void registerObserver(Observer observer) {
        list.add(observer);
    }

    // 移除观察者
    @Override
    public void removeObserver(Observer observer) {
        if (!list.isEmpty()) {
            list.remove(observer);
        }
    }

    // 通知所有的观察者的具体实现
    @Override
    public void notifyObserver() {
        for (Observer observer : list) {
            observer.update(message);
        }
    }

    /**
     * 发布消息，并通知给所有观察者
     * @param message
     */
    public void setInfomation(String message) {
        this.message = message;
        notifyObserver();
    }
}

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
/**
* @author maxu
* @date 2018/11/3
* 观察者
*/
public class User implements Observer {
    private String name;
    private String message;

    public User(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        this.message = message;
        read();
    }

    public void read(){
        System.out.println(name + "收到的消息" + message);
    }
}
/**
* @author maxu
* @date 2018/11/3
*/
public class Test {
    public static void main(String[] args) {
        WechatServer server = new WechatServer();
        Observer user1 = new User("张山");
        Observer user2 = new User("小马");
        Observer user3 = new User("小白");

        server.registerObserver(user1);
        server.registerObserver(user2);
        server.registerObserver(user3);

        server.setInfomation("java是最好的语言");

        System.out.println("----------------------------------");
        server.removeObserver(user1);
        server.setInfomation("php是最好的语言");
    }
}

1
2
3
4
5
6
public class Adapter extends Adaptee implements Target {
	public void request() {
		specificRequest();
	}
}

1
2
3
4
5
6
7
8
9
10
11
public class Adapter extends Target{
    
	private Adaptee adaptee;
	public Adapter(Adaptee adaptee){
		this.adaptee=adaptee;
	}
	public void request(){
		adaptee.specificRequest();
	}
}

1
2
3
4
5
6
7
8
9
10
11
public abstract class Handler{
	protected Handler successor;
    
	public void setSuccessor(Handler successor){
		this.successor=successor;
	}
	
	public abstract void handleRequest(String request);
} 

1
2
3
4
5
6
7
8
9
10
11
12
public class ConcreteHandler extends Handler {
    
	public void handleRequest(String request) {
		if(请求request满足条件) {
			......  //处理请求；
		} else {
			this.successor.handleRequest(request); //转发请求
		}
	}
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Proxy implements Subject {
    // 创建真实对象
    private RealSubject realSubject = new RealSubject();
    
    public void preRequest(){...}
    public void request(){
        preRequest();
        realSubject.request();
        postRequest();
    }
    public void afterRequest(){...}
}