### 单例模式:

单例模式，顾名思义就是只有一个实例，并且她自己负责创建自己的对象，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

单例模式，属于创建类型



实际代码我放在了Github: https://github.com/liangtengyu/DesignPatterns-for-Java

### 应用场景:

学习一个设计模式之前 我们先了解它的使用场景能够帮我们更快的理解它,

单例模式只允许创建一个对象，因此更节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等.如： 

* 需要频繁实例化然后销毁的对象。 
*  创建对象时耗时过多或者耗资源过多，但又经常用到的对象。 
* 有状态的工具类对象。 
* 频繁访问数据库或文件的对象。



### 实现方式:

#### 饿汉式

```java
public class Singleton_3 {
    //使用饿汉式   线程安全
    private static Singleton_3 instance = new Singleton_3() ;

    private Singleton_3() {
    }

    public  static Singleton_3 getInstance() {

        return instance;
    }
}
```

#### 懒汉式 - 线程安全

```java
public class Singleton_2 {
    //使用懒汉式  线程安全 不建议使用
    private static Singleton_2 instance =null ;

    private Singleton_2() {
    }

    public synchronized static Singleton_2 getInstance() {
        if (instance !=null) return instance;
        return new Singleton_2();
    }
}
```

#### 懒汉式 - 非线程安全

```java
public class Singleton_1 {
    //使用懒汉式  非线程安全
    private static Singleton_1 instance =null ;

    private Singleton_1() {
    }

    public static Singleton_1 getInstance() {
        if (instance !=null) return instance;
        return new Singleton_1();
    }
}
```

#### 静态类方式

```java
public class sigleton0 {       //使用静态类方式实现单例
    private static ConcurrentHashMap cache = new ConcurrentHashMap();

}
```

#### 内部类方式

```java
public class Singleton_4 {
    //使用内部类方式构造单例, 线程安全并且懒加载
    private AtomicInteger id = new AtomicInteger(0);


    private Singleton_4() {
    }

     public static  Singleton_4 getInstance(){
        return SingletonCreator.singleton_4;
    }

    private static class SingletonCreator{
        static  Singleton_4 singleton_4 = new Singleton_4();

    }
    public Integer getIncrementId(){
        return this.id.getAndIncrement();
    }
```



#### 双重校验锁方式

```java
public class Singleton_5 {
    //使用双重锁校验 线程安全
    private static Singleton_5 instance =null ;
    //满足懒加载
    private Singleton_5() {
    }

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

#### 原子类方式

```java
public class Singleton_6 {
    //使用atomicrefence  使用CAS方式  支持懒加载
    private static AtomicReference<Singleton_6> INSTANCE = new AtomicReference<Singleton_6>();

    private Singleton_6() {
    }

    public static Singleton_6 getInstance(){
        for (; ; ) {
            Singleton_6 singleton_6 = INSTANCE.get();
            if (null != singleton_6)return singleton_6;
            INSTANCE.compareAndSet(null, new Singleton_6());
            return INSTANCE.get();
        }

    }
```



### 实验

每次获取单例对象的结果实际都是同一个对象

```java
public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
        //获取实例
        Singleton_4 instance = Singleton_4.getInstance();
        //输出地址
        System.out.println("实例的地址:" + instance);
        //获取id
        System.out.println(instance.getIncrementId());
        System.out.println("-------------------------------------------------");
    }
}
```



结果 :



```java
实例的地址:Singleton_4@63947c6b
0
-------------------------------------------------
实例的地址:Singleton_4@63947c6b
1
-------------------------------------------------
实例的地址:Singleton_4@63947c6b
2
-------------------------------------------------
实例的地址:Singleton_4@63947c6b
3
-------------------------------------------------
  .....
```



设计模式之单例模式Singleton

### 工厂模式:

> 当创建逻辑比较复杂时，就可以考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

工厂模式，属于创建类型



实际代码我放在了Github: https://github.com/liangtengyu/DesignPatterns-for-Java

### 应用场景:

学习一个设计模式之前 我们先了解它的使用场景能够帮我们更快的理解它,
相对于直接 new 来创建对象，用工厂模式来创建究竟有什么好处呢？

 主要有两种情况:

* 第一种情况是类似规则配置解析的例子，代码中存在 if-else 分支判断，动态的根据不同的类型创建不同的对象。针对这种情况，我们就可以考虑使用工厂模式，将这一大块的 if-else 创建对象的代码抽离出来，放到工厂类中。

* 还有一种情况是，尽管我们不需要根据不同的类型创建不同的对象，但是，单个对象本身的创建过程比较复杂，我们也可以考虑使用工厂模式。

好处:由于工厂模式是依靠抽象架构的，它把实例化产品的任务交由实现类完成，扩展性比较好。也就是说，当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。通俗的讲就是降低代码改变对产品功能的影响.

### 实现方式:

#### 简单工厂（Simple Factory）

首先，我们来看，什么是简单工厂模式。我们通过一个例子来解释一下。

[简单工厂模式](https://github.com/liangtengyu/DesignPatterns-for-Java/blob/master/factory/src/main/java/simpleFactory)



```java
public class Cocacola implements Cola {
    public String getCola() {
        return "可口可乐";
    }
}
```


```java
public class ColaFactory {

    public static Cola getInstance(Integer  colaType) {
        if (1 == colaType) {
            return new Cocacola();
        } else if (2 == colaType) {
            return new Pepsicola();
        } else {
            return new Fakecola();
        }
    }

}
```



```java
 public static void main(String[] args) {
        String drink = ColaFactory.getInstance(1).drink();
        System.out.println(drink);
    }
    //可口可乐
```

尽管简单工厂模式的代码实现中，有多处 if 分支判断逻辑，违背开闭原则，但权衡扩展性和可读性，这样的代码实现在大多数情况下是没有问题的。 



#### 工厂方法（Factory Method）

工厂方法是简单工厂的进一步的延伸，这样说是因为简单工厂违反了开闭原则，而此时工厂方法却可以完美的解决这个问题！接下来看看它是怎么解决的吧！

[工厂方法 - 项目](file:/Users/tengyu/IdeaProjects/designs/factory/src/main/java/factoryMethod)

对于规则配置文件解析这个应用场景来说，工厂模式需要额外创建诸多 Factory 类，也会增加代码的复杂性，而且，每个 Factory 类只是做简单的 new 操作，功能非常单薄（只有一行代码），也没必要设计成独立的类，所以，在这个应用场景下，`简单工厂模式`好用，比`工厂方法模式`更加合适



```java
public interface ColaFactory {//工厂接口
    Cola getCola();
}
```



```java
public class CocaColaFactoryImpl implements ColaFactory {//实现可口可乐工厂
    public Cola getCola() {
        return  new Cocacola();
    }
}
```

 

```java
public static void main(String[] args) {
    //工厂方法需要一个可乐时,直接去对应的工厂拿,而是不像简单工厂那样 都是从一个工厂中根据判断来拿
    //每一种可乐都对应一个工厂
    ColaFactory pepsiColaFactory = new PepsiColaFactoryImpl();
    Cola cola = pepsiColaFactory.getCola();
    cola.getCola();
}
```

### 什么时候该用工厂方法模式，而非简单工厂模式呢？

​		之所以将某个代码块剥离出来，独立为函数或者类，原因是这个代码块的逻辑过于复杂，剥离之后能让代码更加清晰，更加可读、可维护。

​		但是，如果代码块本身并不复杂，就几行代码而已，我们完全没必要将它拆分成单独的函数或者类。基于这个设计思想，当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。而使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂。

​		除此之外，在某些场景下，如果对象不可复用，那工厂类每次都要返回不同的对象。如果我们`使用简单工厂模式来实现`，`就只能选择第一种包含 if 分支逻辑的实现方式`。如果我们还想避免烦人的 if-else 分支逻辑，这个时候，我们就推荐使用工厂方法模式。

#### 抽象工厂（Abstract Factory）

抽象工厂模式的应用场景比较特殊，没有前两种常用，我们简单了解一下

简单工厂只是对可乐产品进行了抽象,工厂方法是对可乐工厂进行抽象,抽象工厂是对工厂方法的再次抽象

光从概念可能不好理解,我们来个实例

需求:现在产品线调整了,我们生产的可乐 虽然有各自的品牌但是都是透明瓶子,我们要做出自己的特点.需要给不同品牌的可乐喷涂不同的颜色瓶身.

思考:如果此时我们将可乐的生产和颜色的喷涂都耦合在工厂方法的代码中,后续调整会很麻烦,也违背了开闭原则,对拓展开放,对修改关闭,那么此时我们使用抽象工厂就比较合适了



```java
public abstract class ColaAbstractFactory {//创建抽象工厂类
    abstract ColaFactory getCola(String cola);
    abstract ColorFactory getColor(String color);
}
```



```java
public class ColaAbstractFactoryImpl extends ColaAbstractFactory {

		//实现抽象类
   public ColaFactory getCola(String cola) {
        if ("cocacola".equals(cola)) {
            return new CocaColaFactoryImpl();
        } else if ("fake".equals(cola)) {
            return new FakeColaFactoryImpl();
        } else if ("pepsi".equals(cola)) {
            return new PepsiColaFactoryImpl();
        } else
            return null;
    }

    public ColorFactory getColor(String color) {
        if ("yellow".equals(color)) {
            return new YellowColorFactoryImpl();
        } else if ("blue".equals(color)) {
            return new BlueColorFactoryImpl();
        } else if ("red".equals(color)) {
            return new RedColorFactoryImpl();
        } else
            return null;
    }
}
```

```java
public class RedColorFactoryImpl implements ColorFactory {//对不同颜色的需求进行喷涂.其它颜色类似就不重复贴了
    public String getColor() {
        System.out.println("喷涂红色瓶身");
        return "红色瓶子";
    }
}
```

最终我们想要获得可乐+红色瓶身

```java
public static String getColaAndColor(String cola,String color){
    ColaAbstractFactoryImpl colaAbstractFactory = new ColaAbstractFactoryImpl();

    ColaFactory cola = colaAbstractFactory.getCola(cola);
    ColorFactory red = colaAbstractFactory.getColor(color);

    Cola col = cola.getCola();
    String colo = red.getColor();
    return col.getCola()+"-"+colo;
}
```



```java
public static void main(String[] args) {
    String colaAndColor = FactoryProducer.getColaAndColor("cocacola", "red");
    System.out.println(colaAndColor);

}
//output:
喷涂红色
生产可口可乐
可口可乐-红色瓶子
```



设计模式之工厂模式Factory

 

### 原型模式:

> 基于原型复制替代对象的创建,用来节省时间.

原型模式，属于创建类型



实际代码我放在了Github: https://github.com/liangtengyu/DesignPatterns-for-Java

### 应用场景:

学习一个设计模式之前 我们先了解它的使用场景能够帮我们更快的理解它,实现方式:

从概念中我们知道,基于原型复制替代对象的创建,那么什么对象是适合复制的呢? 有以下几种情况:

* 当一个类需要大量计算获得
* RPC 获得
* 网络IO 获得
* 数据库 获得

用来节省获取对象的时间消耗.有以上几种情况,可考虑使用原型模式.

 

### 实现方式:

```java
public  class DatabaseDao {
    //模拟数据库获取数据操作
    public static List<Entity> getList() {

        List<Entity> entityList = new LinkedList<>();
        for (int i = 0; i < 2; i++) {
            entityList.add(new Entity()
                    .setName("name" + i)
                    .setId(i)
                    .setJsonData("{'key':'value'}")
                    .setReferenceData(new ReferenceData("dataname",i+""))
            );
        }
        return entityList;
    }

}
```



```java
public class Entity {
    private int id;
    private String name;
    private String jsonData;
    private ReferenceData referenceData;

    public ReferenceData getReferenceData() {
        return referenceData;
    }

    public Entity setReferenceData(ReferenceData referenceData) {
        this.referenceData = referenceData;
        return this;
    }

    public int getId() {
        return id;
    }

    public Entity setId(int id) {
        this.id = id;
        return this;
    }

    public String getName() {
        return name;
    }

    public Entity setName(String name) {
        this.name = name;
        return this;
    }

    public String getJsonData() {
        return jsonData;
    }

    public Entity setJsonData(String jsonData) {
        this.jsonData = jsonData;
        return this;
    }

    @Override
    public String toString() {
        return "Entity{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", jsonData='" + jsonData + '\'' +
                ", referenceData=" + referenceData +
                '}';
    }
}
```



```java
public class ReferenceData {
    private String data;
    private String data2;

    public ReferenceData(String data, String data2) {
        this.data = data;
        this.data2 = data2;
    }

    public String getData2() {
        return data2;
    }

    public void setData2(String data2) {
        this.data2 = data2;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "ReferenceData{" +
                "data='" + data + '\'' +
                ", data2='" + data2 + '\'' +
                '}';
    }
}
```



```java
@Test
public void test(){
    List<Entity> list = DatabaseDao.getList();
    //输出从数据库中获取的数据
    System.out.println("数据库中获取的数据为:"+list);

    List<Entity> copyList = new ArrayList<>(list);
    System.out.println("复制的数据为:" + copyList);

    list.remove(0);//删除原始List的第一个
    System.out.println("删除后数据库中获取的数据为:"+list);

    System.out.println("删除后复制的数据为:" + copyList);
}

/**
数据库中获取的数据为:[Entity{id=0, name='name0', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='0'}}, Entity{id=1, name='name1', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='1'}}]
复制的数据为:[Entity{id=0, name='name0', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='0'}}, Entity{id=1, name='name1', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='1'}}]
删除后数据库中获取的数据为:[Entity{id=1, name='name1', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='1'}}]
删除后复制的数据为:[Entity{id=0, name='name0', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='0'}}, Entity{id=1, name='name1', jsonData='{'key':'value'}', referenceData=ReferenceData{data='dataname', data2='1'}}]
**/
```



###  

### 深浅拷贝

> 浅拷贝:浅拷贝是将原对象的信息拷贝，拷贝后的对象和原对象指向同一块空间。



> 深拷贝：原对象的修改不会影响拷贝后的对象。一般有2种常用方式

* 利用序列化，序列化后,将二进制字节流内容写到一个媒介（文本或字节数组），然后从这个媒介读取数据，原对象写入这个媒介后拷贝给clone对象，原对象的修改不会影响clone对象

* 通过递归拷贝





#### 拓展: 

`copy on write 思想` 写时复制

概念: 复制对象时,先是基于共享引用,当一方需要修改数据时,才真正复制数据,创建新对象并修改

场景: 读多写少的情况 , 读写分离

缺点:

- 1. 频繁修改数据会导致复制多份造成GC压力
- 1. 数据一致性有保证了,但是实时性没有保证

设计模式之原型模式 prototype

 

### 建造者模式:

> 创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。通俗的讲就是 创建可装配的复杂对象

建造者模式，属于创建类型



实际代码我放在了Github: https://github.com/liangtengyu/DesignPatterns-for-Java

### 应用场景:

学习一个设计模式之前 我们先了解它的使用场景能够帮我们更快的理解它,实现方式:


- 当使用new()时 参数过多容易导致混乱和BUG的产生
  - 使用set方法赋值时 会创建一个可变对象,即对象创建完后还可以使用set方法改变变量,此时应该使用builer
  - 使用new关键字创建对象时,对于入参的校验比较混乱
  - 使用set方法时,对于入参的校验比较分散,不容易集中管理
  - **当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。**
  
- 使用Builder的好处
  - 将入参的校验逻辑都封装到build()方法中,进行统一的处理,处理完成才创建对象,否则不创建对象,方便管理校验逻辑
  - 使用build方法创建对象后,对象无法通过set方法进行修改参数,保证了对象的不可变

 

### 实现方式:

例:

```java
public class ResourceConfig {


    private String name;
    private int maxTotal;
    private int maxIdle;
    private int minIdle;

    private ResourceConfig(ResourceConfigBuilder builder) {
        this.name = builder.name;//使用static 内部类可以直接拿属性
        this.maxTotal = builder.getMaxTotal();//也可以通过get方法获取
        this.maxIdle = builder.getMaxIdle();
        this.minIdle = builder.getMinIdle();
    }

    public String getName() {
        return name;
    }

    public int getMaxTotal() {
        return maxTotal;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public int getMinIdle() {
        return minIdle;
    }

    @Override
    public String toString() {
        return "ResourceConfig{" +
                "name='" + name + '\'' +
                ", maxTotal=" + maxTotal +
                ", maxIdle=" + maxIdle +
                ", minIdle=" + minIdle +
                '}';
    }




    public static class ResourceConfigBuilder {
        private static final  int DEF_MAX_TOTAL = 8 ;
        private static final  int DEF_MAX_IDLE=0;
        private static final  int DEF_MIN_IDLE=0;

        private String name;
        private int maxTotal=DEF_MAX_TOTAL;
        private int maxIdle = DEF_MAX_IDLE;
        private int minIdle = DEF_MIN_IDLE;

        public ResourceConfigBuilder setName(String name) {
            this.name = name;
            return this;//返回this 能够实现链式调用
        }

        public ResourceConfigBuilder setMaxTotal(int maxTotal) {
            this.maxTotal = maxTotal;
            return this;
        }

        public ResourceConfigBuilder setMaxIdle(int maxIdle) {
            this.maxIdle = maxIdle;
            return this;
        }

        public ResourceConfigBuilder setMinIdle(int minIdle) {
            this.minIdle = minIdle;
            return this;
        }

        public String getName() {
            return name;
        }

        public int getMaxTotal() {
            return maxTotal;
        }

        public int getMaxIdle() {
            return maxIdle;
        }

        public int getMinIdle() {
            return minIdle;
        }

        public ResourceConfig build(){
            //校验逻辑放到build()方法之前,先校验 再 创建
            if (minIdle > maxTotal) {
                throw new IllegalArgumentException("无效的参数, cause : minIdle > maxTotal");
            }
            return new ResourceConfig(this);
        }
    }
}
```

### 总结-抽象理解


创建对象我们可以通过工厂方法和builder

*  工厂方法相当于对同类工厂抽象,如:披萨 汉堡 同是KFC的产品. 定向生产这2种产品工厂,披萨工厂 汉堡工厂

*  Builder相当于对于一种类的创建过程繁琐的抽象,如 披萨 我们在创建过程中想用什么肉类,什么蔬菜,甜还是咸,创建之前统一进行处理,到最终创建完成



