设计模式初探之二

设计模式

  原型设计模式：相当于简历辅助问题，可以用clone方法直接clone出一个对象，这只是浅层复制，对于对象里面的对象应用是没用的，还是同一个指针，要想clone出来的对象的里面的对象引用也分别是不同的话，你只能自定义实现clone方法new个对象了

建造器模式

  当我们想让制作出来的对象的流程能够标准化，不需要由客户端程序来控制的时候，因为客户端容易遗漏，这时候就需要建造器模式，结果分别抽象产品，抽象建造者，抽象指挥者，其中产品有各种不同产品的实现，建造者定义很多方法去加工抽象产品，而抽象指挥者定义建造者需要怎么用建造者的方法去建造产品，用的顺序如何

模板方法

   其实就是充分利用抽象类，在抽象类可以调用抽象方法形成一个逻辑，子类可以具体实现抽象方法，公用的逻辑继承上层

观察者模式

 当我们需要通知订阅某一主题所有的人的时候，就需要观察者模式。结构分为抽象观察者（其中有个update方法，也可以有个主题的应用），抽象的主题（定义观察者的list，还有添加者和移除观察者的方法，还有通知方法调用抽象观察者的update方法）

这是标准的观察者模式，但是这种模式有个缺点就是主题依赖观察者，当没有具体实现抽象观察者的观察者的时候，是调用失败的，而且观察者还必须要写死方法名和主题互相配合，那如何解决呢？在其他语言里面有事件委托机制，可以把方法传给主题的eventHandler来动态处理，java里面是通过反射实现的。具体代码如下：

public class GoodNotifier extends Notifier {   
	  
    @Override  
    public void addListener(Object object, String methodName, Object... args) {   
        System.out.println("有新的同学委托尽职尽责的放哨人!");   
        EventHandler handler = this.getEventHandler();
        handler.addEvent(object, methodName, args);   
    }   
  
    @Override  
    public void notifyX() {   
        System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
        try{   
            this.getEventHandler().notifyX();   
        }catch(Exception e){   
            e.printStackTrace();   
        }   
    }   
  
}   
/**
 * 通知者的 抽象类
 * @author xujun
 *
 */
public abstract class Notifier {
	private EventHandler eventHandler = new EventHandler();

	public EventHandler getEventHandler() {
		return eventHandler;
	}

	public void setEventHandler(EventHandler eventHandler) {
		this.eventHandler = eventHandler;
	}

	/**
	 * 增加需要帮忙 放哨 的 学生
	 * 
	 * @param object 要执行方法的对象
	 * @param methodName 执行方法 的方法名
	 * @param args   执行方法的参数
	 */
	public abstract void addListener(Object object, String methodName,
			Object... args);

	/**
	 * 告诉所有要帮忙放哨的学生：老师来了
	 */
	public abstract void notifyX();
}
/**
 * 事件的 处理者
 * @author Administrator
 *
 */
public class EventHandler {   
    //是用一个List   
    private List<Event> objects;   
       
    public EventHandler(){   
        objects=new ArrayList<Event>();   
    }   
    //添加某个对象要执行的事件，及需要的参数   
    public void addEvent(Object object,String methodName,Object...args){   
        objects.add(new Event(object,methodName,args));   
    }   
    //通知所有的对象执行指定的事件   
    public void notifyX() throws Exception{   
        for(Event e : objects){   
            e.invoke();   
        }   
    }   
} 
/**
 * 事件对象的封装类
 * @author Administrator
 *
 */
public class Event {   
    //要执行方法的对象   
    private Object object;   
    //要执行的方法名称   
    private String methodName;   
    //要执行方法的参数   
    private Object[] params;   
    //要执行方法的参数类型   
    private Class[] paramTypes;   
       
    public Event(){   
           
    }   
    
    public Event(Object object,String methodName,Object...args){   
        this.object=object;   
        this.methodName=methodName;   
        this.params=args;   
        contractParamTypes(this.params);   
    }   
    //根据参数数组生成参数类型数组   
    private void contractParamTypes(Object[] params){   
        this.paramTypes=new Class[params.length];   
        for(int i=0;i<params.length;i++){   
            this.paramTypes[i]=params[i].getClass();   
        }   
    }   
       
       
    public Object getObject() {
		return object;
	}

  //这里省略了若干get和set方法

	/**
	 * 根据该对象的方法名，方法参数，利用反射机制，执行该方法  
	 * @throws Exception
	 */
    public void invoke() throws Exception{   
        Method method=object.getClass().getMethod(this.getMethodName(),
                         this.getParamTypes());   
        if(null==method){   
            return;   
        }   
        method.invoke(this.getObject(), this.getParams());   
    }   
}

 单例模式

             使用私有静态内部类就行

多线程通信

          wait和notify一定要和synchronized联合使用，最好不要用本身类对应的锁，在类的内部new的对象，用这个对象当锁，其中wait是暂停线程并且释放锁，notify是唤醒线程但是不释放锁的

          concurrentHashMap/concurrentSkipListMap 是并发安全的，前者对应hashMap 后者对应treemap，只不过是把锁的粒度细化了，加了分段锁，最多分16段，每段都是线程安全加了锁

          那些线程安全的集合类如vector和hashtable不要以为一直都是线程安全的，在复合操作就线程不安全，如同时做迭代和删除操作就可能线程不安全，单一操作还是安全的

          cpoyOnWrite的list和set就是读写分离的一种模式，当这种容器遇到写的操作时会复制一个新的容器把写的内容放进去，读还是读原来的，这样读写就分离了，当写的操作完成后，指针指向新的容器

canal

          阿里开发的一种模拟mysql的slave的组件，监控mysql的binlog的行模式，你可以用docker安装一个服务端监控mysql的改变，然后代码集成canal的客户端，把收到的sql语句做处理，你可以放到任何地方。当然cannal提供直接适配，你可以在服务端配置直接输出到消息队列/kafka/es等