设计模式(未完待续)

23中设计模式
一、创建型模式
   单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。
二、结构型模式
适配器模式、桥接模式、装饰者模式、组合模式、外观模式、享元模式、代理模式
三、行为型模式
    模版方法模式、命令模式、迭代模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式




单例模式(14)
  1.饿汉式单例模式
    public class SingletonDemo1{


    private SingletonDemo1(){}
private static SingletonDemo1 instance = new SingletonDemo1();
public static SingletonDemo1 getInstance(){
return instance;
}
    }
  2.懒汉式单例设计模式
    public class SingletonDemo2{


private SingletonDemo2(){}
private static SingletonDemo2 instance; 
public static  synchronized SingletonDemo2  getInstance(){
if(instance==null){
instance = new SingletonDemo2();
 }
return instance;
}
    }
   3.双重检查锁单例模式
     public class SingletonDemo3 { 


 private static SingletonDemo3 instance = null; 


 public static SingletonDemo3 getInstance() { 
   if (instance == null) { 
     SingletonDemo3 sc; 
     synchronized (SingletonDemo3.class) { 
       sc = instance; 
       if (sc == null) { 
         synchronized (SingletonDemo3.class) { 
           if(sc == null) { 
             sc = new SingletonDemo3(); 
           } 
         } 
         instance = sc; 
       } 
     } 
   } 
   return instance; 
 } 
 private SingletonDemo3() { 
 }  
    }
   4.静态内部类单例模式 
     public class SingletonDemo4 {
private static class SingletonClassInstance {
private static final SingletonDemo4 instance = new SingletonDemo4();
}
private SingletonDemo4(){
}
//方法没有同步，调用效率高！
public static SingletonDemo4  getInstance(){
return SingletonClassInstance.instance;
}
}
5.枚举式单例模式(没有延时加载) 
 public enum SingletonDemo5 {
//这个枚举元素，本身就是单例对象！
INSTANCE;
      }
    6.简单测试
      public class Client {

public static void main(String[] args) {
SingletonDemo4 s1 = SingletonDemo4.getInstance();
SingletonDemo4 s2 = SingletonDemo4.getInstance();

System.out.println(s1);
System.out.println(s2);

System.out.println(SingletonDemo5.INSTANCE==SingletonDemo5.INSTANCE);


}
} 
    6.测试反射和反序列化破解单例模式
      public class Client2 {

public static void main(String[] args) throws Exception {
SingletonDemo6 s1 = SingletonDemo6.getInstance();
SingletonDemo6 s2 = SingletonDemo6.getInstance();

System.out.println(s1);
System.out.println(s2);

//通过反射的方式直接调用私有构造器
//Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.bjsxt.singleton.SingletonDemo6");
//Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
//c.setAccessible(true);
//SingletonDemo6  s3 = c.newInstance();
//SingletonDemo6  s4 = c.newInstance();
//System.out.println(s3);
//System.out.println(s4);

//通过反序列化的方式构造多个对象 
FileOutputStream fos = new FileOutputStream("d:/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
System.out.println(s3);
  }
   }
7.测试多线程环境下五种创建单例模式的效率
 public class Client3 {

public static void main(String[] args) throws Exception {

long start = System.currentTimeMillis();
int threadNum = 10;
final CountDownLatch  countDownLatch = new CountDownLatch(threadNum);

for(int i=0;i<threadNum;i++){
new Thread(new Runnable() {
@Override
public void run() {

for(int i=0;i<1000000;i++){
//Object o = SingletonDemo4.getInstance();
Object o = SingletonDemo5.INSTANCE;
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await(); //main线程阻塞，直到计数器变为0，才会继续往下执行！

long end = System.currentTimeMillis();
System.out.println("总耗时："+(end-start));
}
}
8.懒汉式单例模式(如何防止反射和反序列化漏洞)
 public class SingletonDemo6 implements Serializable {
//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
private static SingletonDemo6 instance;  

private SingletonDemo6(){ //私有化构造器
if(instance!=null){
throw new RuntimeException();
}
}

//方法同步，调用效率低！
public static  synchronized SingletonDemo6  getInstance(){
if(instance==null){
instance = new SingletonDemo6();
}
return instance;
}

//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
private Object readResolve() throws ObjectStreamException {
return instance;
}

}


  总结：饿汉式线程安全，调用效率高，但是，不能延时加载
懒汉式线程安全，调用效率不高，但是，可以延时加载
其他：
双重检测锁式(由于JVM底层内部模型原因，偶尔会出问题)
静态内部类式(线程安全，调用效率高，并且可以延时加载)
枚举类(线程安全，调用效率高，不能延时加载，但是可以天然的防止反射和反序列化漏洞！)
  选用方式：
1.单例对象，占用资源少，不需要延时加载，用枚举式，好于饿汉式
2.单例对象，占用资源大，需要延时加载，静态内部类好于懒汉式
工厂模式(25)
   详细分类：
1.简单工厂模式(静态工厂模式)：对于增加新的类无能为力，不修改代码的话，是无法扩展的(不能满足OCP原则)
2.工厂方法模式：为了避免简单工厂模式的缺点，引入工厂方法模式。简单工厂模式只有一个工厂类，而工厂方法模式有一组实现了相同接口的工厂类
3.抽象工厂模式：用来生产不同产品族的全部产品.(对于增加新的产品无能为力，支持增加产品族)
总结：
      工厂模式实现了创建者和调用者的分离，1.简单工厂模式(静态工厂模式)虽然某种程度不符合设计原则，但实际使用最多。2.工厂方法模式，可以理解为简单工厂模式的升级版，  在不修改已有类的前提下，通过增加新的工厂类实现扩展。3.抽象工厂模式，不可以增加产品，但可以增加产品族
    应用场景：
      JDK中Calendar的getInstance方法
      JDBC中Connection对象的获取
      Spring中IOC容器创建管理bean对象
      反射中Class对象的newInstance()
适配器模式(24)
    将一个类的接口转换成客户希望的另外一个接口，Adapter模式使的原本由于接口不兼容而不能一起工作的那些类可以一起工作。
    适配器的两种方式：
      1.累适配器
        class Adapter extends Adaptee implements Target{
public void request(){
super.specificRequest();
}
        }
      2.对象适配器
       class Adapter implements Target{
private Adaptee adaptee;
public Adapter(Adaptee adaptee){
this.adaptee = adaptee;
}
public void request(){
this.adaptee.specificRequest();
}
       }
    应用举例：
     转换流
   java.io.InputStreamReader(InputStream);    
java.io.OutputStreamWriter(OutputStream);
外观模式(15)
    为子系统提供统一的入口，封装系统的复杂性，便于客户端调用，例如，JDBC封装后，commons提供的DBUtils类、Spring JDBC工具类等
策略模式(14)
    比较简单，这里作者略去，想要了解的可以上网查点资料，很容易学会的！！！