设计模式

1.什么是设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

本教程将通过 Java 实例，一步一步向您讲解设计模式的概念。+

2.spring中用到的设计模式.

工厂模式

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

可以自己决定实例化哪个类，而不暴露内在的创建逻辑

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

**意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

**如何解决：**让其子类实现工厂接口，返回的也是一个抽象的产品。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

代码实例：

1.首先创建接口，

package factory;

public interface Colour {
    void getColour ();
}

2.创建实体类来继承接口，并实现方法

public class Red implements Colour {
    @Override
    public void getColour() {
        System.out.println("Red");
    }
}

public class Yellow implements Colour {
    @Override
    public void getColour() {
        System.out.println("Yellow");
    }
}

3.
创建一个工厂，按照输入的信息，来创建并返回相应的实体类的实例

public class Factory {

    public Colour getColour(String colour)
    {
        if(colour=="red")
        {
            return new Red();

        }
        if(colour=="yellow")
        {
            return new Yellow();

        }
        return null;
    }

    public static void main(String[] args) {
        String str1="red";
        String str2="yellow";
        Factory factory=new Factory();
       Colour colour1= factory.getColour(str1);
       Colour colour2=factory.getColour(str2);
       colour1.getColour();
       colour2.getColour();
    }

}

使用场景 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

工厂模式由一个接口类加一个对应的工厂类实现的，接口类提供所有要创建出来的实体所需要的方法，工厂类只负责一件事：创建实现类的对象的方法。

先提供出接口类和实现类：

public interface ICar {
    void getBrand();
}

public class Audi implements ICar {
    public void getBrand() {
        System.out.printf("My brand is %s \n", Audi.class.getSimpleName());
    }
}

public class Benz implements ICar {
    public void getBrand() {
        System.out.printf("My brand is %s \n", Benz.class.getSimpleName());
    }
}

实现类会把类名打出来，我们现在要写个工厂类负责构造实现类的对象。

public class SimpleFactory2 {
    public ICar createCar(Class<? extends  ICar> carClass){
        try {
            return carClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    public static void main(String[] args) {
        SimpleFactory2 carFactory = new SimpleFactory2();
        ICar audi = carFactory.createCar(Audi.class);
        audi.getBrand();
        ICar benz = carFactory.createCar(Benz.class);
        benz.getBrand();
    }

工厂类的实现是根据实体类的Class的类型来自动生成实例，这种方式极大了提升了程序的扩展性，后续工厂类不需要做任何更改，只要加让实体类实现ICar接口，那么就能通过工厂类生产出相应的车辆。

现在最热门的Spring框架的IOC就是基于工厂模式，IOC通过DI（依赖注入）的方式将bean的创建交给了Spring Container，Spring Container 自动帮我们创建对象，我们只需要使用即可。

下面将采用Spring提供的一些组件来实现一个简单工厂，首先原有的实体类需要做下改造，类上加了@Component注解：

@Component
public class Audi implements ICar {
    public void getBrand() {
        System.out.printf("My brand is %s \n", Audi.class.getSimpleName());
    }
}

public class SpringFactory {
    public ICar createCar(String carName){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.discover.amazing.model");
        return (ICar) context.getBean(carName);
    }
 
    public static void main(String[] args) {
        SpringFactory springFactory = new SpringFactory();
        ICar carBean = springFactory.createCar("audi");
        carBean.getBrand();
    }
}

Spring 这个工厂和前面的两种实现方式有没有本质区别呢，必须有，毕竟Spring 这么强大的世界级框架能被成千上万的企业使用有其道理。前面已经提示了，Spring 框架有Spring 容器，Spring 容器在启动的时候已经创建了，所有被@Component注解标注的实体类都会被扫描到放入容器中，下次使用是直接从容器中取出对象，不会再new新的对象。

可见，理解设计模式非常重要，通过设计模式，我们才能更深入的理解各种框架，理解了框架本质和思想，才能利用框架写出高质量的代码。

3.单例模式

Spring 中 bean 的默认作用域就是 singleton(单例)的，spring中单例可谓是随处可见了。

饿汉式

public class Singleton{
private static Singleton instance=new Singleton();
private Singleton (){}

public Singleton getSingleton()
{ return instance;}

}

4.观察者模式

观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。

二、模式的定义与特点
​ 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

主要优点

降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
目标与观察者之间建立了一套触发机制。

它的主要缺点如下：

目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。

当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

单例设计模式有几种哪种不安全