Java设计模式

Java设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

Java设计模式分为三大类

• 创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。

• 结构型模式：把类或对象结合在一起形成一个更大的结构。

• 行为型模式：类和对象如何交互，及划分责任和算法。

一、设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

二、创建型模式

谈谈你对创建型模式的理解

1.单例设计模式：

一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫做单例设计模式

单例模式是创建对象的一种特殊方式，程序从始至终都只创建一个对象叫单例

1.1饿汉式单例

饿汉式的实现方式比较简单。在类加载的时候，instance 静态实例就已经创建并初始化好了，所以，instance 实例的创建过程是线程安全的。不过，这样的实现方式不支持延迟加载（在真正用到 的时候，再创建实例）。

缺点：因为不支持延迟加载，如果实例占用资源多（比如占用内存多）或初始化耗时长（比如需要加载各种配置文件），提前初始化实例是一种浪费资源的行为。

public class Student {
    //1、 饿汉式单例模式，  在类加载时创建一个对象
    private static Student student = new Student();

    // 2 构造器私有化
    private Student(){
    }
    // 3 提供返回类对象的静态方法
    public static Student getInstance(){
        if(student !=null){
            return student;
        }
         return null;
    }
}

1.2懒汉式单例

在真正需要使用对象的时候才会去创建该对象；

public class Lazy_Man {
    private static Lazy_Man lazyMan=null;
    private Lazy_Man(){}
    public static Lazy_Man getInstance(){
        if (lazyMan==null){
            lazyMan =new Lazy_Man();
        }
        return lazyMan;
    }
}

1.3双重检测锁

public class Lazy_Man2 {
    private volatile static Lazy_Man2 lazyMan=null;
    private Lazy_Man2(){}
    public static Lazy_Man2 getInstance(){
        if(lazyMan==null){
             synchronized (Lazy_Man2.class){
            if (lazyMan==null){
                //1.分配内存空间2．执行构造方法，实例化对象3.把这个对象赋值给这个空间
                //如果不加volatile会执行重排序13 2
                lazyMan =new Lazy_Man2();
            }
         }
        }
        return lazyMan;
    }
}

2.说说你在哪些框架中看到了单例的设计

1.Spring中的Bean对象，默认是单例模式

⒉.相关的工厂对象都是单例，比如:MyBatis中的SqlSessionFactory，Spring中的BeanFactory.

3.保存相关配置信息的都是单例，比如:MyBatis中的Configuration对象，SpringBoot中的各个XXAutoConfiguration对象等

4.应用程序的日志应用，一般都会通过单例来实现

5.数据库连接池的设计也是单例模式

2.工厂模式

创建对象的过程不再由当前类实例化，而是由工厂类完成，在工厂类中只需要告知对象类型即可。工厂模式中必须依赖接口

2.1简单工厂模式

2.2工厂方法模式

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。

总而言之：一个接口被多实现

//创建一个接口:
public interface Shape {
   void draw();
}
//创建实现接口的实体类
 public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Square implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
//创建一个工厂，生成基于给定信息的实体类的对象。
public class ShapeFactory {
    //创建一个工厂，生成基于给定信息的实体类的对象。
    //使用 getShape 方法获取形状类型的对象
    public Shape getShape(String shapeType){
        if(shapeType == null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }
}
//使用该工厂，通过传递类型信息来获取实体类的对象。
public class FactoryPatternDemo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory=new ShapeFactory();
        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        //调用 Circle 的 draw 方法
        shape1.draw();
        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        //调用 Rectangle 的 draw 方法
        shape2.draw();
        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = shapeFactory.getShape("SQUARE");
        //调用 Square 的 draw 方法
        shape3.draw();
    }
}

3.抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

//为 Color 和 Shape 对象创建抽象类来获取工厂。
public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape);
}
//创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
public class ColorFactory extends AbstractFactory {
   @Override
   public Shape getShape(String shapeType){ return null;}
   @Override
   public Color getColor(String color) {
      if(color == null){ return null;}        
      if(color.equalsIgnoreCase("RED")){ return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){return new Green();}
      return null;
   }
}
//创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}
//使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。
//获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
      //调用 Red 的 fill 方法
      color1.fill();
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("GREEN");
      //调用 Green 的 fill 方法
      color2.fill();

总结：对于简单工厂，工厂方法模式和抽象工厂的区别和用途

小结：

★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。

★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。

★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。

区别：

1、对于简单工厂，用于生产同一结构中的任意产品，对于新增产品不适用。

2、对于工厂方法，在简单工厂的基础上，生产同一等级结构中笃定产品，可以支持新增产品。

3、抽象工厂，用于生产不同种类（品牌）的相同类型（迷你，SUV），对于新增品牌可以，不支持新增类型

4.建造者模式

用来解决复杂对象创建的一种设计模式

建造者模式和工厂模式的区别：

• 建造者模式更加注重方法的调用顺序，工厂模式注重于创建对象。
• 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的都一样。
• 关注点不一样，工厂模式只需要把对象创建出来就行了，而建造者模式不仅要创建出这个对象，还要知道这个对象由哪些部分组成。
• 建造者模式根据建造过程中的顺序不一样，最终的对象部件组成也不一样。

5.原型模式

批量对象的创建

5.1浅克隆

​ 被复制对象的所有变是都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。0bject类提供的方法clone=只是拷贝本对象=，=其对象内部的数组、引用对象等都不拷贝=，还是指向原生对象的内部元素地址.
被克隆的对象必须Cloneable,Serializable这两个接口;

浅克隆的问题:虽然产生了两个完全不同的对象，但是被复制的对象的所有变是都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。

5.2深克隆

​ 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

三、结构型模式

1.代理模式

1.1代理模式的作用

​ 代理模式的作用是通过代理对象来增强目标对象的功能，利用AOP的切面思想。

1.2代理模式的实现方式

代理模式的实现方式有三种:静态代理，动态代理(JDK动态代理和CGLIB动态代理)

1.2.1静态代理

静态代理需要代理类与目标类有一样的继承父类和实现接口

public interface UserDao {
    public void addUser();

    public void deleteUser();
}
public class DbUser implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户操作");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户操作");
    }
}
public class StaticProxyUser implements UserDao {
    private DbUser target;

    public StaticProxyUser(DbUser dbUser) {
        target = dbUser;
    }
    @Override
    public void addUser() {
        System.out.println("添加前的操作");
        target.addUser();
        System.out.println("添加后的操作");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除前的操作");
        target.deleteUser();
        System.out.println("删除后的操作");
    }
}
public class MyTest {
    @Test
    public void demo() {
        StaticProxyUser staticProxyUser = new StaticProxyUser(new DbUser());
        staticProxyUser.addUser();
        staticProxyUser.deleteUser();
    }
}

静态代理总结:

1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

1.2.2 JDK动态代理

动态代理不用实现目标类的接口，不会出现大量代理类的现象，一般情况下创建一个代理类就可以了。
动态代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
动态代理也叫做:JDK代理,接口代理
动态代理需要使用newProxyInstance方法，该方法结构为static Object newProxyInstance(ClassLoader loader， Class<?>] interfaces,InvocationHandler h )，可以看到该方法需要三个参数
参数1：ClassLoader 需要一个类加载器，Java中常用的类加载器有三种类型
启动类加载器(Bootstrap ClassLoader):

这个类加载器负责将\lib目录下的类库加载到虚拟机内存中,用来加载java的核心库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用,代码是使用C++编写的.是虚拟机自身的一部分.

扩展类加载器(Extendsion ClassLoader):
　　　　这个类加载器负责加载\lib\ext目录下的类库,用来加载java的扩展库,开发者可以直接使用这个类加载器.

应用程序类加载器(Application ClassLoader):

这个类加载器负责加载用户类路径(CLASSPATH)下的类库,一般我们编写的java类都是由这个类加载器加载,这个类加载器是CLassLoader中的getSystemClassLoader()方法的返回值,所以也称为系统类加载器.一般情况下这就是系统默认的类加载器.

除此之外,我们还可以加入自己定义的类加载器,以满足特殊的需求,需要继承java.lang.ClassLoader类.
　　参数2：Class <?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
　　参数3：InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

//接口
public interface UserService {
    void addUser();
    void updateUser();
    void delUser();
}
//实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
  }
    @Override
    public void updateUser() {
        System.out.println("更新用户");
    }
    @Override
    public void delUser() {
        System.out.println("删除用户");
    }
}
//   代理类：
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object object){
        this.target=object;
    }
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(),//类加载器
                                      target.getClass().getInterfaces(), //目标对象实现的相关接口
                new InvocationHandler() {//代理对象的回调方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("开始事务2");
                Object invoke = method.invoke(target, args);
                System.out.println("提交事务2");
                return invoke;
            }
        });
    }
}
//测试
public class Mtytest {
    public static void main(String[] args) {
        UserService userService=new UserServiceImpl();
        UserService instance = (UserService) new ProxyFactory(userService).getProxyInstance();
        instance.addUser();
    }
}

笔试题:写一个 ArrayList 的动态代理类

public class ProxyTest {
    //写一个 ArrayList 的动态代理类
    public static void main(String[] args) {
        final List<String> list=new ArrayList<>();

        List<String> proxyInstance = (List<String>) Proxy.newProxyInstance(list.getClass().getClassLoader(), list.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object invoke = method.invoke(list, args);
                return invoke;
            }
        });
        proxyInstance.add("你好");
        System.out.println(list);
    }
}

1.2.3CGLIB代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

DK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

//接口和目标类同上
public class MyBeanFactory {
    //cglib代理
    public static UserService createUserService(){
        //目标类
        final UserService userService = new UserServiceImpl();
        /**
         * 代理类
         * 回掉函数中的intercept同jdk动态代理的invoke方法
         * 4个参数，前三个同jdk动态代理的参数
         * 第四个参数：methodProxy是目标类的方法的代理
         *
         */
        //1.1核心类
        Enhancer enhancer = new Enhancer();
        //1.2确定父类
        enhancer.setSuperclass(UserService.class);
        //1.3设置回掉函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行前");
                Object invoke = method.invoke(userService, objects);
                System.out.println("执行后");
                return invoke;
            }
        });
        UserService userService1 = (UserService) enhancer.create();
       return userService1;
    }
}

面试题一：JDK动态代理和CGLIB动态代理区别？

① JDK 动态代理本质上是实现了被代理对象的接口，而 CGLib 本质上是继承了被代理对象，覆盖其中的方法。
② JDK 动态代理只能对实现了接口的类生成代理，CGLib 则没有这个限制。但是 CGLib 因为使用继承实现，所以 CGLib 所以无法对 final 类、private 方法和 static方法进行代理。
③ JDK 动态代理是 JDK 里自带的，CGLib 动态代理需要引入第三方的 jar 包。
④ 在调用代理方法上，JDK动态代理是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用。（看过一篇文章，介绍说 FastClass 简单的理解，就是使用一个 index 下标作为入参，可以直接定位到要调用的方法直接，并进行调用）

在性能上，JDK1.7 之前，由于使用了 FastClass 机制，CGLib 在执行效率上比 JDK 快，但是随着 JDK 动态代理的不断优化，从 JDK 1.7 开始，JDK 动态代理已经明显比 CGLib 更快了。

2.适配器模式

适配器模式的作用是把两个不兼容的类/对象/接口通过适配器能够连接起来工作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MbmgJZOs-1667921061561)(C:\Users\xhd\AppData\Roaming\Typora\typora-user-images\image-20220912192231507.png)]

2.1类适配器模式

从下面的结构图可以看出，Adaptee类并没有method2()方法，而客户端则期待这个方法。为使客户端能够使用Adaptee类，我们把Adaptee与Target衔接起来。Adapter与Adaptee是继承关系，这决定了这是一个类适配器模式

//源：
public class Adaptee {
    public void method1() {
        System.out.println("老的方法实现");
    }
}
//目标：
public interface Target {
    void method1();
    void method2();
}
//适配器：
public class Adapter extends Adaptee implements Target {


    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void method2() {
        System.out.println("method2" + "新的方法");
    }
}

2.2对象适配器模式

从下面的结构图可以看出，Adaptee类并没有method2()方法，而客户端则期待这个方法。与类适配器模式一样，为使客户端能够使用Adaptee类，我们把Adaptee与Target衔接起来。但这里我们不继承Adaptee，而是把Adaptee封装进Adapter里。这里Adaptee与Adapter是组合关系。

//Target和Adaptee和上面的类适配器一样
public class Adapter1 implements Target {
    private Adaptee adaptee;

    public Adapter1(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void method1() {
        adaptee.method1();
    }

    @Override
    public void method2() {
        System.out.println("method2" + "新的方法");
    }
}

类适配器与对象适配器的区别
类适配器使用的是继承的方式，直接继承了Adaptee，所以无法对Adaptee的子类进行适配。
对象适配器使用的是组合的方式，·所以Adaptee及其子孙类都可以被适配。另外，对象适配器对于增加一些新行为非常方便，而且新增加的行为同时适用于所有的源。
基于组合/聚合优于继承的原则，使用对象适配器是更好的选择。

3.装饰者模式

3.1装饰者模式的作用

允许向一个现有的对象添加新的功能，同时又不改变其结构

装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

四、行为型模式

1.观察者模式

1.1观察者模式的作用

建立对象与对象之间的依赖关系，一个对象发生改变时，会自动通知其他对象。这个场景中，发生改变的对象被称为观察目标，被通知的对象称为观察者。一个观察目标可以有多个观察者，而这些观察者之间可以没有联系，可以根据需要增加或删除观察者。

public void method2() {
System.out.println(“method2” + “新的方法”);
}
}

**类适配器与对象适配器的区别**
 类适配器使用的是继承的方式，直接继承了Adaptee，所以无法对Adaptee的子类进行适配。
 对象适配器使用的是组合的方式，·所以Adaptee及其子孙类都可以被适配。另外，对象适配器对于增加一些新行为非常方便，而且新增加的行为同时适用于所有的源。
 基于组合/聚合优于继承的原则，使用对象适配器是更好的选择。



### 3.装饰者模式

#### 3.1装饰者模式的作用

允许向一个现有的对象添加新的功能，同时又不改变其结构

装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。



## 四、行为型模式

#### 1.观察者模式

##### 1.1观察者模式的作用

建立对象与对象之间的依赖关系，一个对象发生改变时，会自动通知其他对象。这个场景中，发生改变的对象被称为观察目标，被通知的对象称为观察者。一个观察目标可以有多个观察者，而这些观察者之间可以没有联系，可以根据需要增加或删除观察者。

![在这里插入图片描述](https://img-blog.csdnimg.cn/8c7b1aadf4334b0e960697081cd7e6b6.png#pic_center)