Java中的设计模式一

一、单例设计模式(Singleton)

1、懒汉模式2、饿汉模式3、内部类模式4、反射5、枚举类型模式6、反序列化机制7、单例模式举例 二、工厂方法模式（Factory Method）

1、原代码，之后要对该代码进行重构。2、第一次改造3、第二次改造4、源码中的应用

模式定义：保证一个类只有一个实例，并且提供一个全局访问点
场景：重量级的对象，不需要多个实例，如线程池、数据库连接池

延迟加载，只有真正使用的时候，才开始实例化。
1）多线程的情况下，线程不安全

2）线程安全，加锁，性能损耗，目的：保证一个类只有一个对应的实例，不管实例有没有初始化都要加锁。

3）线程安全，加锁
double check加锁优化
编译器（JIT），cpu有可能对指令进行重排序，导致使用到尚未初始化的实列，可以通过添加volatile关键字进行修饰，对于volatile修饰的字段，可以防止指令重排。

问题：1）线程安全问题；2）double check加锁优化

类加载的初始化阶段就完成了实例的初始化。本质上就是借助于JVM类加载机制，保证实例的唯一性
类加载过程：
１、加载二进制数据到内存中，生成对应的Class数据结构
2、连接： a、验证 b、准备（给类的静态成员变量赋默认值） c、解析
3、初始化：给类的静态变量赋初值
只有在真正使用对应的类时，才会触发初始化 如（当前类是启动类即main函数所在类，直接进行new操作，访问静态属性、访问静态方法，用反射访问类，初始化一个类的子类）

1）本质上是利用类的加载机制来保证线程安全
2）只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一种形式。

反射攻击，通过反射创建的实例和通过InnerClassSingleton创建的实例不是同一个。

public class SingletonTest {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //通过反射创建的实例
        Constructor  declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();

        //通过内部类创建的实例
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(instance == innerClassSingleton);
    }
}

//内部类实现模式
class InnerClassSingleton {

    private static class InnerClassHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    private InnerClassSingleton() {

    }

    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.instance;
    }
  }

为了防止反射攻击需要构造函数中加上判断

枚举类不能通过反射创建实例

通过反序列化机制创建的实例与序列化之前的实例不是一个实例，以InnerClassSingleton为例，InnerClassSingleton需要实现 Serializable接口 。


解决方案：序列化和反序列化的类中添加版本号和Object readResolve() throws ObjectStreamException;方法（在Serializable接口的源码中有说明），加了版本号之后，即使对类进行了修改（比如添加一个方法、添加一个变量等），对修改前序列化的对象，进行反序列，还是同一个对象。


对类进行修改之后，反序列化，反序列化结果仍然是true


枚举类是一个天然能够支持反序列化的，序列化前和序列化后是同一个对象。（原因，可以看Enum类型的反序列化源码）

1）Runtime：是典型的饿汉模式

2）currency 实现序列化机制，添加了 private Object readResolve()；方法。

3）懒汉模式 double check

模式定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使得一个类的实例化延迟到子类。

应用场景：1）当你不知道使用对象的确切类型的时候；2）当你希望为库或者框架提供扩展其内部组件的方法时；
主要优点：1）将具体产品和创建者解耦； 2）符合单一职责原则； 3）符合开闭原则

package study.model.factory;


public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        ProductA product = application.getObject();
        product.method1();
    }

}
class ProductA {
    public void method1(){
        System.out.println("ProductA.method1 executed.");
    }

}
class Application {
    private ProductA createProduct(){
        //其他逻辑代码
        //....
        return new ProductA();
    }

    ProductA getObject(){
        ProductA product = createProduct();
        //....
        return product;
    }
}

package study.model.factory;


public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        Product product = application.getObject("0");
        product.method1();
    }
}

interface Product {
    public void method1();
}
class ProductA implements  Product{
    public void method1(){
        System.out.println("ProductA.method1 executed.");
    }
}
class ProductA1 implements  Product{
    public void method1(){
        System.out.println("ProductA1.method1 executed.");
    }
}
class SimpleFactory {
    public static Product createProduct(String type){
        if(type.equals("0")){
            return new ProductA();
        } else if(type.equals("1")){
            return new ProductA1();
        } else {
            return null;
        }
    }
}
class Application {
    private Product createProduct(String type){
        //其他逻辑代码
        //....
        return SimpleFactory.createProduct(type);
    }

    Product getObject(String type){
        Product product = createProduct(type);
        //....
        return product;
    }
}

package study.model.factory;


public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new ConcreateProductA();
        Product product = application.getObject();
        product.method1();
    }
}

interface Product {
    public void method1();
}
class ProductA implements  Product{
    public void method1(){
        System.out.println("ProductA.method1 executed.");
    }
}
class ProductA1 implements  Product{
    public void method1(){
        System.out.println("ProductA1.method1 executed.");
    }
}
class SimpleFactory {
    public static Product createProduct(String type){
        if(type.equals("0")){
            return new ProductA();
        } else if(type.equals("1")){
            return new ProductA1();
        } else {
            return null;
        }
    }
}
abstract class Application {
    abstract Product createProduct();

    Product getObject(){
        Product product = createProduct();
        //....
        return product;
    }
}
class ConcreateProductA extends Application{

    @Override
    Product createProduct(){
        //....
        return new ProductA();
    }
}
class ConcreateProductA1 extends Application{

    @Override
    Product createProduct(){
        //....
        return new ProductA1();
    }
}

//Java API
//静态工厂方法
Calendar.getInstance();
java.text.NumberFormat.getInstance();
java.util.ResourceBundle.getBundle();

//工厂方法
java.net.URL.StreamHandlerFactory;
javax.xml.bind.JAXBContext.createMarshaller;