常见设计模式—单例模式/代理模式/责任链模式

单例模式

定义： 保证一个类仅有一个实例，并提供一个访问它的全局访问点

目的：通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。比如数据库连接，Spring上下文

要点：某个类只能有一个实例；它必须自行创建这个实例；它必须自行向整个系统提供这个实例

实现: 构造函数私有化；自己持有一个静态私有成员变量；给外界提供一个访问该成员变量的函数

实现一：

public class SingletonClass {
	private SingletonClass() {
	}

	private static SingletonClass instance;

	/*
	 * public static SingletonClass getInstance() { synchronized (instance) { if
	 * (instance == null) { instance = new SingletonClass(); } return instance;
	 * } }
	 */

	public static SingletonClass getInstance() {
		if (instance == null) {
			synchronized (instance) {
				if (instance == null)
					instance = new SingletonClass();
				return instance;
			}
		}
		return instance;
	}
}

实现二：

public enum Singleton {
	INSTANCE;
	
	public void doSomething(){
		System.out.println("do something");
	}
}

代理模式

定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

目的：1.不适合直接访问对象，这是可以设置代理对象。比如权限控制

   2.需要在逻辑执行前后加上其他的处理逻辑，如权限检查，日志记录等

组成：抽象角色：通过抽象类或接口声明真实角色要实现的业务方法
    真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用
    代理对象：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加上自己的操作

代码实现：

抽象角色：

public interface AbstractObject {
	public  void doSomething();
}

真实角色：

public class RealObject implements AbstractObject{

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("do something");
	}
}

静态代理实现：

代理对象：

public class ProxyObject implements AbstractObject {
	RealObject realObject = new RealObject();

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("-----before-----");
		if (isAccess())
			realObject.doSomething();
		System.out.println("-----after-----");
	}

	/**
	 * 权限检查
	 * @return
	 */
	private boolean isAccess() {
		// TODO Auto-generated method stub
		return true;
	}
}

测试：

public static void main(String[] args) throws IOException {
		AbstractObject object = new ProxyObject();
		object.doSomething();
	}

动态代理实现：

public class ProxyObject implements InvocationHandler {
	Object target;

	public Object blind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		before();
		Object result = method.invoke(target, args);
		after();
		return result;
	}

	private void after() {
		// TODO Auto-generated method stub
		System.out.println("------after------");
	}

	private void before() {
		// TODO Auto-generated method stub
		System.out.println("-------before-----");
	}
}

测试：

public static void main(String[] args) throws IOException {
		AbstractObject ao = (AbstractObject) new ProxyObject()
				.blind(new RealObject());
		ao.doSomething();
	}

责任链模式

定义：责任链模式在面向对象程序设计里是一种软件设计模式，它包含了一些命令对象和一系列的处理对象。每一个处理对象决定它能处理哪些命令对象，它也知道如何将它不能处理的命令对象传递给该链中的下一个处理对象。该模式还描述了往该处理链的末尾添加新的处理对象的方法。

目的：当请求来临时，使多个请求接收者者对象都有机会处理，从而避免请求发送者与接收者的耦合。将这些请求接收者对象连成一条链，并让请求沿着链传递，直到有一个接受收者处理请求。