栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

23种设计模式笔记(上)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

23种设计模式笔记(上)

设计模式介绍

设计模式分为三种类型,共23种

  • 创建型模式:单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。

  • 结构型模式:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

  • 行为型模式:模版方法模式、命令模式、访问者模式、选代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)。

单例模式 基本介绍

所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)

比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这是就会使用到单例模式。

单例设计模式八种方式:

  1. 饿汉式(静态常量)
  2. 饿汉式(静态代码块)
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全,同步方法)
  5. 懒汉式(线程安全,同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举
饿汉式(静态常量)

步骤如下:

  • 构造器私有化(防止 new )
  • 类的内部创建对象
  • 向外暴露一个静态的公共方法。getInstance
  • 代码实现
public class SingletonOne {

  
  private SingletonOne () {}

  
  private final static SingletonOne instance = new SingletonOne();

  
  public static SingletonOne getInstance() {
    return instance;
  }
}

//  测试
class Test01Main {
  public static void main(String[] args) {
    SingletonOne instance01 = SingletonOne.getInstance();
    SingletonOne instance02 = SingletonOne.getInstance();
    System.out.println(instance01 == instance02); // true
  }
}

优缺点说明:

  • 优点: 这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同
    步问题。
  • 缺点: 类装载的时候就完成实例化,没有达到Lazy Loading(懒加载)的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费
  • 这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载
    时就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到lazy loading(懒加载)的效果
  • 结论: 这种单例模式可用,可能造成内存浪费
饿汉式(静态代码块)
public class SingletonTwo {

  
  private SingletonTwo () {}

  
  private static SingletonTwo instance;

  static { // 在静态代码块中 创建
    instance  = new SingletonTwo();
  }

  
  public static SingletonTwo getInstance() {
    return instance;
  }
}

优缺点说明:

  • 这种方式和上面的方式其定类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
  • 结论:这种单例模式可用,但是可能造成内存浪费
懒汉式(线程不安全)
public class SingletonThree {

  private static SingletonThree instance;

  private SingletonThree() {}

  
  public static SingletonThree getInstance() {
    if (instance == null) {
      instance  = new SingletonThree();
    }
    return instance;
  }
}

优缺点说明:

  • 起到了Lazy Loading的效果,但是只能在单线程下使用。
  • 如果在多线程下,一个转现进入if(singleton == nul)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
  • 结论:在实际开发中,不要使用这种方式.
懒汉式(线程安全,同步方法)
public class SingletonThree {

  private static SingletonThree instance;

  private SingletonThree() {}

  
  public static synchronized SingletonThree getInstance() {
    if (instance == null){
      instance  = new SingletonThree();
    }
    return instance;
  }
}

优缺点说明:

  • 解决了线程不安全问题
  • 效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行
    间步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低
  • 结论:在实际开发中,不推荐使用这种方式
懒汉式(线程安全,同步代码块)
public class SingletonThree {

  private static SingletonThree instance;

  private SingletonThree() {}

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

优缺点说明:

  • 这种方式,本意是想对第四种实现方式的改进,因为前面同步方法效率太低,改为同步产生实例化的的代码块
  • 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致,假如一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例
  • 结论:在实际开发中,不能使用这种方式
双重检查
public class SingletonFour {

  
  private SingletonFour () {}

  
  private static volatile SingletonFour instance;

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

优缺点说明:

  • Double-Check概念是多线程开发中常使用到的,如代码中所示,我们进行了两次if(singleton == null)检查,这样就可以保证线程安全了。
  • 这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == null),
    直接return实例化对象工也避免的反复进行方法同步.
  • 线程安全;延迟加载:效率较高
  • 结论:在实际开发中,推荐使用这种单例设计模式
静态内部类
public class SingletonFive {

  
  private SingletonFive() {}

  
  private static class SingletonInstance {
    private static final SingletonFive instance = new SingletonFive();
  }

  
  public static SingletonFive getInstance() {
    return SingletonInstance.instance;
  }
}

优缺点说明:

  • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  • 静态内部类方式在singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载Singletoninstance类,从而完成Singleton的实例化。
  • 类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
  • **优点:**避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
  • **结论:**推荐使用
枚举
public enum SingletonSix {
  INSTANCE;
  public void sayOK() {
    System.out.println("OK");
  }
}

class MainTest02 {
  public static void main(String[] args) {
    SingletonSix singletonSix01 = SingletonSix.INSTANCE;
    SingletonSix singletonSix02 = SingletonSix.INSTANCE;
    System.out.println(singletonSix01 == singletonSix02); // true
  }
}

优缺点说明:

  • 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
  • 结论:推荐使用
源码分析

单例模式在JDK应用的源码分析
我们JDK中,java.lang.Runtime就是经典的单例模式


public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    
    private Runtime() {}

    // 饿汉式
注意事项和细节说明
  • 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
  • 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
  • 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如教据源、session工厂等)
工厂模式 简单工厂模式

看一个具体的需求:

披萨的项目:要便于披萨种类的扩展,要便于维护

  1. 披萨的种类很多(比如GreekPizz,CheesePizz等)
  2. 披萨的制作有Prepare,bake,cut,box
  3. 完成披萨店订购功能
传统实现方式


披萨抽象类

@Data
public abstract class Pizza {

  
  protected String name;

  
  public abstract void prepare();

  
  public void bake() {
    System.out.println(name + "baking;");
  }

  
  public void cut() {
    System.out.println(name + "cutting;");
  }

  
  public void box() {
    System.out.println(name + "boxing;");
  }
}

具体的披萨

public class CheesePizza extends Pizza {

  
  @Override
  public void prepare() {
    System.out.println("CheesePizza类准备原材料");
  }
}
public class GreekPizza extends Pizza {

  
  @Override
  public void prepare() {
    System.out.println("GreekPizza类准备原材料");
  }
}

订购披萨

public class OrderPizza {

  OrderPizza() {
    Pizza pizza = null;
    String type = this.getType(); // 获取披萨的类型
    do {
      if ("cheese".equals(type)) {
        pizza = new CheesePizza();
        pizza.setName("cheese");
      } else if ("greek".equals(type)) {
        pizza = new GreekPizza();
        pizza.setName("greek");
      } else {
        break;
      }
    } while (true);
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.bake();
  }

  // 获取控制台输入
  public String getType() {
    return new Scanner(System.in).nextLine();
  }
}


class PizzaStore {
  public static void main(String[] args) {
    new OrderPizza();
  }
}
传统方式优缺点分析
  • 优点: 是比较好理解,简单易操作

  • 缺点: 是违反了设计模式的OCP原则,即对扩展开发,对修改关闭.当我们给类增加新功能时候,尽量不修改diamagnetic,或者尽可能少修改代码

  • 改进的思路分析
    分析:修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,往往有多处。
    思路:把创建Pizza对象封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了.>简单工厂模式

简单工厂模式基本介绍
  • 简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
  • 简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行
    为(代码)
  • 在软件开发中,当我们会用到大量的创建某种、某类或者某批对象时,就会
    使用到工厂模式.
代码改进

新增简单工厂类

public class SimpleFactory {

  
  public Pizza createPizza(String type) {
    Pizza pizza = null;
    if ("cheese".equals(type)) {
      pizza = new CheesePizza();
      pizza.setName("cheese");
    } else if ("greek".equals(type)) {
      pizza = new GreekPizza();
      pizza.setName("greek");
    }
    return pizza;
  }
}

更改订购披萨类

public class OrderPizza {

  // 工厂对象
  private SimpleFactory simpleFactory;

  OrderPizza(SimpleFactory simpleFactory) {
    this.simpleFactory = simpleFactory;
  }

  public void getPizza() {
    String type = "";
    Pizza pizza = null;
    do {
      pizza = simpleFactory.createPizza(type);
      if (pizza != null) {
        pizza.prepare();
        pizza.setName(type);
        pizza.bake();
        pizza.box();
        pizza.cut();
        break;
      } else {
        System.out.println("创建披萨失败,请重新输入");
      }
    }while (true);
  }
}


class PizzaStore {
  public static void main(String[] args) {
    OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
    orderPizza.getPizza();
  }
}
工厂方法模式

看一个新的需求:
披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza.

思路1
使用简单工厂模式,创建不同的简单工厂类,比如BJPizzaSimpleFactory.
LDPizzaSimpleFactory 等等.从当前这个案例来说,也是可以的,但是考虑到项目的规模,以及软件的可维护性、可扩展性并不是特别好

思路2
使用工厂方法模式

工厂方法模式基本介绍

**工厂方法模式设计方案 **: 将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现。
工厂方法模式 :定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

披萨类

@Data
public abstract class Pizza {

  
  protected String name;

  
  public abstract void prepare();

  
  public void bake() {
    System.out.println(name + "baking;");
  }

  
  public void cut() {
    System.out.println(name + "cutting;");
  }

  
  public void box() {
    System.out.println(name + "boxing;");       
  }
}

// 北京的披萨类
public class BJCheesePizza extends Pizza {

  
  @Override
  public void prepare() {
    System.out.println("北京CheesePizza类准备原材料");
  }
}

class BJGreekPizza extends Pizza {

  
  @Override
  public void prepare() {
    System.out.println("北京GreekPizza类准备原材料");
  }
}
// 伦敦披萨类
public class LDCheesePizza extends Pizza {
  @Override
  public void prepare() {
    System.out.println("伦敦CheesePizza类准备原材料");
  }
}
class LDGreekPizza extends Pizza {
  
  @Override
  public void prepare() {
    System.out.println("伦敦GreekPizza类准备原材料");
  }
}

工厂类

public interface SimpleFactory {

  
  Pizza createPizza(String type);
}
// 伦敦工厂类
public class LDSimpleFactory implements SimpleFactory {
  @Override
  public Pizza createPizza(String type) {
    Pizza pizza = null;
    if ("cheese".equals(type)) {
      pizza = new LDCheesePizza();
      pizza.setName("cheese");
    } else if ("greek".equals(type)) {
      pizza = new LDGreekPizza();
      pizza.setName("greek");
    }
    return pizza;
  }
}
// 北京工厂类
public class BJSimpleFactory implements SimpleFactory {
  @Override
  public Pizza createPizza(String type) {
    Pizza pizza = null;
    if ("cheese".equals(type)) {
      pizza = new BJCheesePizza();
      pizza.setName("cheese");
    } else if ("greek".equals(type)) {
      pizza = new BJGreekPizza();
      pizza.setName("greek");
    }
    return pizza;
  }
}
JDK工厂模式源码分析
Calendar类 日历类

    
    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }
工厂模式小结
  1. 工厂模式的意义
    将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
  2. 三种工厂模式:简单工厂模式,工厂方法模式,工厂抽象模式
  3. 设计模式的依赖抽象原则
    创建对象实例时,不要直接new 类,而是把这个new类的动作放在一个工厂的方法中,并返回。有的书上说,变量不要直接持有具体类的引用。
    不要让类继承具体类,而是继承抽象类或者是实现interface(接口)不要覆盖基类中已经实现的方法。
原型模式

看一个具体的需求:

现在有一只羊tom,姓名为tom,年龄为:1,颜色为:白色,请编写程序创建和tom属性完全相同的10只羊;

传统实现方式

 @Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepEntity {

  
  private String name;

  
  private Integer age;

  
  private String colour;
}

public static void main(String[] args) {
    SheepEntity sheep = new SheepEntity("tom", 1, "白色");
    SheepEntity sheep1 = new SheepEntity(sheep.getName(), sheep.getAge(), sheep.getColour());
    SheepEntity sheep2 = new SheepEntity(sheep.getName(), sheep.getAge(), sheep.getColour());
    SheepEntity sheep3 = new SheepEntity(sheep.getName(), sheep.getAge(), sheep.getColour());
    SheepEntity sheep4 = new SheepEntity(sheep.getName(), sheep.getAge(), sheep.getColour());
  }
传统方式优缺点分析
  • 优点是比较好理解,简单易操作。

  • 在创建新的对象时,总是需要重新获取原始对象的属性,如果创建的对象比较复杂时,效率较低

  • 总是需要重新初始化对象,而不是动态地获得对象运行时的状态,不够灵活

  • 改进的思路分析:

  • 思路: Java中Object类是所有类的根类,Object类提供了一个clone()方法,该方法可以将一个Java对象复制一份,但是需要实现clone的Java类必须要实现一个接口Cloneable,该接口表示该类能够复制且具有复制的能力=>原型模式

基本介绍
  • 原型模式(Prototype模式)是指:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象
  • 原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的细节
  • 工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建,即对象.clone()
  • 形象的理解:孙大圣披出猴毛,变出其它孙大圣

原理结构图说明:

Prototype: 原型类,声明一个克隆自己的接口

ConcretePrototype: 具体的原型类,实现一个克隆自己的操作

Client: 让一个原型对象克隆自己,从而创建一个新的对象(属性一样)

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepEntity implements Cloneable {

  
  private String name;

  
  private Integer age;

  
  private String colour;

  // 克隆该实例 使用默认的克隆clone()方法来完成
  @Override
  public SheepEntity clone() {
    SheepEntity sheep = null;
    try {
      sheep = (SheepEntity) super.clone();
      System.out.println(sheep);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return sheep;
  }
}


  public static void main(String[] args) {
    SheepEntity sheep = new SheepEntity("tom", 1, "白色");
    SheepEntity clone1 = sheep.clone(); // 克隆
    SheepEntity clone2 = sheep.clone(); // 克隆
    SheepEntity clone3 = sheep.clone(); // 克隆
  }
深拷贝和浅拷贝 浅拷贝
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepEntity implements Cloneable {
  
  private String name;

  private Integer age;

  private String colour;

  
  private SheepEntity friend;

  // 克隆该实例 使用默认的克隆clone()方法来完成
  @Override
  public SheepEntity clone() {
    SheepEntity sheep = null;
    try {
      sheep = (SheepEntity) super.clone();
      System.out.println(sheep);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return sheep;
  }
}

  • 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象。
  • 对于数据类型是引用数据类型的成员变量,比如说成员变量是某个数组、某个类的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。
  • 在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
  • 前面我们克隆羊就是浅拷贝
  • 浅拷贝是使用默认的clone()方法来实现sheep = (Sheep) super.clone();
深拷贝
  • 复制对象的所有基本教据类型的成员变量值
  • 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对整个对象进行拷贝
  • 深拷贝实现方式:
  • 1:重写clone方法来实现深拷贝深拷贝实现方式
  • 2:通过对象序列化实现深拷贝
深拷贝实现方式1
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepEntity implements Cloneable, Serializable {

  public String name;

  public Integer age;

  public String colour;

  // 克隆该实例 使用默认的克隆clone()方法来完成
  @Override
  public SheepEntity clone() {
    SheepEntity sheep = null;
    try {
      sheep = (SheepEntity) super.clone();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return sheep;
  }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepProtoType implements Cloneable, Serializable {

  
  public String name;

  
  public SheepEntity sheep;

  @Override
  public SheepProtoType clone() {
    // 完成基本数据类型 的拷贝
    SheepProtoType sheepProtoType = null;
    try {
      sheepProtoType = (SheepProtoType) super.clone();
      // 完成引用数据类型的 拷贝
      sheepProtoType.sheep = sheep.clone();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return sheepProtoType;
  }
  
}
深拷贝实现方式2
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SheepProtoType implements Cloneable, Serializable {

  
  public String name;

  
  public SheepEntity sheep;


  @Override
  public SheepProtoType clone() {
    // 创建字节流对象
    ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null;
    try {
      // 序列化
      bos = new ByteArrayOutputStream();
      oos = new ObjectOutputStream(bos);
      oos.writeObject(this); // 当前这个对象以流的方式输出
      // 反序列化
      bis = new ByteArrayInputStream(bos.toByteArray());
      ois = new ObjectInputStream(bis);
      SheepProtoType clone = (SheepProtoType) ois.readObject();
      return clone;
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        bos.close();
        oos.close();
        bis.close();
        ois.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    return null;
  }

}
原型模式小结
  • 创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率
  • 不用重新初始化对象,而是动态地获得对象运行时的状态
  • 如果原始对象发生变化(增加或者减少属性),其它克隆对象的也会发生相应的变化无需修改代码
  • 在实现深克隆的时候可能需要比较复杂的代码
  • 缺点: 需要为每一个类配备一个克隆方法,这对全新的类来说不是很难,但对已有的类进行改造时,需要修设其源代码,违背了OCP原则
建造者模式

盖房项目需求:

  1. 需要建房子:这一过程为打桩、砌墙、封顶
  2. 房子有各种各样的,比如普通房,高楼,别墅,各种房子的过程虽然一样,但是要求不要相同的.
  3. 请编写程序,完成需求
传统实现方式

public abstract class AbstractHouse {


  
  public abstract void buildBasic();

  
  public abstract void buildWalls();

  
  public abstract void roofed();

  public void build() {
    this.buildBasic();
    this.buildWalls();
    this.roofed();
  }
}

public class CommonHouse extends AbstractHouse {

  @Override
  public void buildBasic() {
    System.out.println("平房打地基");
  }

  @Override
  public void buildWalls() {
    System.out.println("平房砌墙");
  }

  @Override
  public void roofed() {
    System.out.println("平房封顶");
  }
  public static void main(String[] args) {
    CommonHouse commonHouse = new CommonHouse();
    commonHouse.build();
  }
}
  • 优点是比较好理解,简单易操作,
  • 设计的程序结构,过于简单,没有设计缓存层对象,程序的扩展和维护不好.也就是说,这种设计方案。把产品(即:房子)和创建产品的过程(即:建房子流程)封装在一起。耦合性增强了。
  • 解决方案:将产品和产品建造过程解耦=>建造者模式.
基本介绍
  • Product(产品角色) :一个具体的产品对象。
  • Builder(抽象建造者) :创建一个Product对象的各个部件指定的接口/抽象类。
  • concreteBuilder(具体建造者) :实现接口,构建和装配各个部件
  • Director(指挥者) : 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用,一是:隔离了客户与对象的生产过程,二是:负责控制产品对象的生产过程。

// 产品
@Data
public class House {

  private String baise;

  private String wall;

  private String roofed;
}
// 抽象建造者
public abstract class HouseBuilder {

  protected House house = new House();

  
  public abstract void buildBasic(House house);

  
  public abstract void buildWalls(House house);

  
  public abstract void roofed(House house);

  public House build() {
    return house;
  }
}
// 具体建造者
public class HighBuilder extends HouseBuilder {
  @Override
  public void buildBasic(House house) {
    house.setBaise("高楼打地基");
  }

  @Override
  public void buildWalls(House house) {
    house.setWall("高楼砌墙");
  }

  @Override
  public void roofed(House house) {
    house.setRoofed("高楼砌墙");
  }
}
// 具体建造者
public class CommonHouse extends HouseBuilder {

  @Override
  public void buildBasic(House house) {
    house.setBaise("平房打地基");
  }

  @Override
  public void buildWalls(House house) {
    house.setWall("平房砌墙");
  }

  @Override
  public void roofed(House house) {
    house.setRoofed("平房封顶");
  }
}
// 指挥者
public class HouseDirector {

  protected HouseBuilder houseBuilder;

  HouseDirector(HouseBuilder houseBuilder) {
    this.houseBuilder = houseBuilder;
  }

  // 如何处理建造房子的流程 交给指挥者
  public House createHouse() {
    houseBuilder.buildBasic(houseBuilder.house);
    houseBuilder.buildWalls(houseBuilder.house);
    houseBuilder.roofed(houseBuilder.house);
    return houseBuilder.build();
  }
}
// 客户端
public class Client {
  public static void main(String[] args) {
    HouseDirector director = new HouseDirector(new HighBuilder());
    House house = director.createHouse();
    System.out.println(house);
  }
}
JDK建筑者模式源码分析

java.lang,StringBuilder中的建造者模式

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    
    static final long serialVersionUID = 4383685877147921099L;

    
    char[] value;

    
    int count;

    
    AbstractStringBuilder() {
    }

    
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
public interface Appendable {

    
    Appendable append(CharSequence csq) throws IOException;
  • Appendable : 接口定义了多个append方法(抽象方法),即Appendable 为抽象建造者,定义了抽象方法
  • AbstractstringBuilder: 实现了Appendable接口方法,这里的AbstractStringBuilder已经是建造者,只是不能实例化
  • StringBuilder : 即充当了指挥者角色,同时充当了具体的建造者,建筑方法的实现是由AbstractstringBuilder来完成,而StringBuilder继承了AbstractstringBuilder
建造者模式的注意事项和细节
  • 客户端(使用程序)不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,便得相同的创建过程可以创建不同的产品对象

  • 每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者,用户使用不同的具体建造者即可得到不同的产品对象

  • 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程

  • 增加新的具体建造者无须修改原有类库的代码,指挥者类针对抽象建造者类编程,系统扩展方便,符合“开闭原则”

  • 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。

  • 如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大,因此在这种情况下,要考虑是否选择建造者模式.

    抽象工厂模式VS建造者模式
    抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式不需要关心构建过程,只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品

适配器模式 基本介绍
  • 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是容件 让原本因接口不匹配不能一起工作的两个类可以协同工作。 其别名为包装器(Wrapper)
  • 适配器模式属子结构型模式
  • 主要分为三类:类适配器模式、对象适配器模式、接口适配器模式

类适配器模式 基本介绍

Adapter类通过继承src类,实现dst类接口,完成src>dst的适配

应用实例说明

以生活中的充电器的例子来讲解适配器,充电器本身相当于适配器,220V交流电相当于src(即被适配器),我们的目标dst是sv直流电

// 被适配者
public class Voltage220V {

  public String output220V() {
    String src = "220";
    System.out.println("电压=" + src);
    return src;
  }

}
// 最终需要的输出
public interface VoltageSV {

  public int output5V();

}
// 适配器
public class VoltageAdapter extends Voltage220V implements VoltageSV {

  @Override
  public int output5V() {
    String src220V = super.output220V();
    Integer int220V = Integer.parseInt(src220V);
    int dct5V = int220V / 44;
    return dct5V;
  }

}
// 使用者
public class Photo {

  // 依赖接口
  public void run(VoltageSV sv) {
    int v = sv.output5V();
    if (v == 5) {
      System.out.println("手机使用电压为:" + v);
    } else {
      System.out.println("电压异常,使用失败!");
    }
  }
   // 运行使用
  public static void main(String[] args) {
    Photo photo = new Photo();
    photo.run(new VoltageAdapter());
  }
}
类适配器模式注意事项和细节
  • Java是单继承机制,所以类适配器需要继承src类这一点算是一个缺点,因为这要求dst必须是接口,有一定局限性;
  • src类的方法在Adapter中都会暴露出来,也增加了使用的成本。
  • 由于其继承了src类,所以它可以根据需求重写src类的方法,使得Adapter的灵活性增强了。
对象适配器模式 基本介绍

基本思路和类的适配器模式相同,只是将Adapter类作修改,不是继承src类,而是持有src类的实例,以解决兼容性的问题。即:持有stc类,实现 dst类接口,完成src>dst的适配
根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系。对象适配器模式是适配器模式常用的一种

应用实例
// 被适配者
public class Voltage220V {

  public String output220V() {
    String src = "220";
    System.out.println("电压=" + src);
    return src;
  }

}
// 最终需要的输出
public interface VoltageSV {

  public int output5V();

}
// 适配器
public class VoltageAdapter implements VoltageSV {

  private Voltage220V voltage220V;

  VoltageAdapter(Voltage220V voltage220V) {
    this.voltage220V = voltage220V;
  }

  @Override
  public int output5V() {
    String src220V = voltage220V.output220V();
    Integer int220V = Integer.parseInt(src220V);
    int dct5V = int220V / 44;
    return dct5V;
  }

}
// 使用者
public class Photo {

  public void run(VoltageSV sv) {
    int v = sv.output5V();
    if (v == 5) {
      System.out.println("手机使用电压为:" + v);
    } else {
      System.out.println("电压异常,使用失败!");
    }
  }
  public static void main(String[] args) {
    Photo photo = new Photo();
    photo.run(new VoltageAdapter(new Voltage220V()));
  }
}
类适配器模式注意事项和细节
  • 对象适配器和类适配器其实算是同一种思想,只不过实现方式不同。
  • 根据合成复用原则。使用组合替代继承,所以它解决了类适配器必须继承src的局限性伺题,也不再要求dst必须是接口
  • 使用成本更低。更灵活。
接口适配器模式 基本介绍
  • 一些书籍称为:适配器模式(Default Adapter Pattern)或 缺省适配器模式。
  • 当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
  • 适用于一个接口不想使用其所有的方法的情况。
应用实例
// 被适配者
public class Voltage220V {

  public String output220V() {
    String src = "220";
    System.out.println("电压=" + src);
    return src;
  }

}
// 最终需要的输出
public interface VoltageSV {

  // 此次不需要使用的方法
  public int output4V();

  // 需要使用的方法
  public int output5V();

  // 此次不需要使用的方法
  public int output16V();
}
// 抽象类实现接口,并为该接口中每个方法提供一个默认实现
public class AbstractVoltageSV implements VoltageSV {

  @Override
  public int output4V() {
    return 0;
  }

  @Override
  public int output5V() {
    return 0;
  }

  @Override
  public int output16V() {
    return 0;
  }
}
// 适配器类有选择的重新父类方法 则可以避免不想使用其所有的方法的情况
public class VoltageAdapter extends AbstractVoltageSV {

  private Voltage220V voltage220V;

  VoltageAdapter(Voltage220V voltage220V) {
    this.voltage220V = voltage220V;
  }

  @Override
  public int output5V() {
    String src220V = voltage220V.output220V();
    Integer int220V = Integer.parseInt(src220V);
    int dct5V = int220V / 44;
    return dct5V;
  }

}
// 使用者
public class Photo {

  public void run(VoltageSV sv) {
    int v = sv.output5V();
    if (v == 5) {
      System.out.println("手机使用电压为:" + v);
    } else {
      System.out.println("电压异常,使用失败!");
    }
  }
    
  public static void main(String[] args) {
    Photo photo = new Photo();
    photo.run(new VoltageAdapter(new Voltage220V()));
  }
}
SpringMVC源码分析

SpringMVC中的HandlerAdapter,就使用了适配器模式

public class DispatcherServlet extends FrameworkServlet {
    
	@Nullable
	private List handlerAdapters;
    ....
        
     
     protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// 拿到具体的HandlerAdapter
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                ...
                    // 执行对应的handler方法
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            }
            
   	
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}
// 适配器接口
public interface HandlerAdapter {

	boolean supports(Object handler);

	@Nullable
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

	long getLastModified(HttpServletRequest request, Object handler);

}
// 适配器实现类
public class HttpRequestHandlerAdapter implements HandlerAdapter {

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		((HttpRequestHandler) handler).handleRequest(request, response);
		return null;
	}

	@Override
	public long getLastModified(HttpServletRequest request, Object handler) {
		if (handler instanceof LastModified) {
			return ((LastModified) handler).getLastModified(request);
		}
		return -1L;
	}

}
自定义SpringMVC简易版适配器
// Controller
public interface Controller {

}

class HttpController implements Controller {
  public void doHttpHandler() {
    System.out.println("http..");
  }
}

class SimpleController implements Controller {
  public void doSimpleHandler() {
    System.out.println("simple..");
  }
}

class AnnotationController implements Controller {
  public void doAnnotationHandler() {
    System.out.println("annotation..");
  }
}

适配器

// 适配器接口
public interface HandlerAdapter {

  boolean supports(Object handler);

  void handler(Object handler);
}
// HttpHandlerAdapter适配器
class HttpHandlerAdapter implements HandlerAdapter {
  // 判断handler的类型
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof HttpController);
  }
  // 调用对应controller的方法
  @Override
  public void handler(Object handler) {
    ((HttpController) handler).doHttpHandler();
  }
}
// SimpleHandlerAdapter适配器
class SimpleHandlerAdapter implements HandlerAdapter {
  // 判断handler的类型
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof SimpleController);
  }
  // 调用对应controller的方法
  @Override
  public void handler(Object handler) {
    ((SimpleController) handler).doSimpleHandler();
  }
}
// AnnotationHandlerAdapter适配器
class AnnotationHandlerAdapter implements HandlerAdapter {
  // 判断handler的类型
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof AnnotationController);
  }
  // 调用对应controller的方法
  @Override
  public void handler(Object handler) {
    ((AnnotationController) handler).doAnnotationHandler();
  }
}

DispatcherServlet

public class DispatcherServlet {

  // 注入适配器接口
  private static List handlerAdapters;

  static {
    handlerAdapters = new ArrayList<>();
    handlerAdapters.add(new HttpHandlerAdapter());
    handlerAdapters.add(new SimpleHandlerAdapter());
    handlerAdapters.add(new AnnotationHandlerAdapter());
  }

  // springMVC核心方法doDispatch
  public void doDispatch() {
    // 此处模拟springMVC从request取handler对象
    // 适配器可以获取到希望的controller
    HttpController httpController = new HttpController();
    // 得到对应的适配器
    HandlerAdapter handler = getHandler(httpController);
    // 通过适配器执行对应的controller方法
    handler.handler(httpController);
  }

  public HandlerAdapter getHandler(Controller handler) {
      // 遍历所有适配器
    for (HandlerAdapter adapter : handlerAdapters) {
      if (adapter.supports(handler)) {
        return adapter;
      }
    }
    throw new RuntimeException("未获取到对应的handler对象");
  }

}
适配器模式的注意事项和细节
  • 三种命名方式,是根据 src是以怎样的形式给到Adapter (在Adapter里的形式)来命名的。

  • 1.类适配器:以类给到,在Adapter里,就是将src当做类,继承
    2.对象适配器:以对象给到,在Adapter里,将src作为一个对象,持有

    3.接口适配器:以接口给到,在Adapter里,将src作为一个接口,实现

  • Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作。实际开发中,实现起来不拘泥于我们讲解的三种经典形式

桥接模式

手机问题

  • 扩展性问题(类爆炸),如果我们再增加手机的样式(旋转式),就需要增加各个品牌手机的类,同样如果我们增加一个手机品牌,也要在各个手机样式类下增加。
  • 违反了单一职责原则,当我们增加手机样式时,要同时增加所有品牌的手机,这样增加了代码维护成本
  • 解决方案-使用桥接模式
基本介绍
  • 桥接模式(Bridge模式)是指:将实现与抽象放在两个不同的类层次中,使两个层次可以独立改变。
  • 是一种结构型设计模式
  • Bridge模式基于类的最小设计原则,通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(implementation)分离开来,从而可以保持各部分的独立性以及应对他们的功能扩展

桥接模式主要包含如下几个角色:

  • Client类:桥接模式调用者
  • 抽象类Abstraction : 维护了Implementor及它的实现类 (聚合关系)
  • RefinedAbstraction :扩展抽象类
  • Implementor : 行为实现类的接口
  • ConcreteImplementor: 具体行为实现类 。
应用实例

使用桥接模式解决手机问题

// 品牌
public interface Brand {
  // 打电话
  void call();
}

class Vivo implements Brand {
  @Override
  public void call() {
    System.out.println("Vivo打电话");
  }
}

class Iphone implements Brand {
  @Override
  public void call() {
    System.out.println("iphone打电话");
  }
}

class XiaoMi implements Brand {
  @Override
  public void call() {
    System.out.println("XiaoMi打电话");
  }
}
//
public class Phone {

  // 注入品牌
  private Brand brand;

  Phone(Brand brand) {
    this.brand = brand;
  }

  public void call() {
    brand.call();
  }
}
// 样式1
class FoldedPhone extends Phone {

  FoldedPhone(Brand brand) {
    super(brand);
  }

  @Override
  public void call() {
    System.out.println("折叠式执行");
    super.call();
  }
}
// 样式2
class UpRightPhone extends Phone {

  UpRightPhone(Brand brand) {
    super(brand);
  }

  @Override
  public void call() {
    System.out.println("直立式执行");
    super.call();
  }

}
// 客户端
public class Client {
  public static void main(String[] args) {
    // 获取手机 样式 + 品牌
    Phone phone = new FoldedPhone(new Iphone());
    phone.call();
  }
}
桥接模式的注意事项和细节
  • 实现了抽象和实现部分的分离,从而极大的提供了系统的灵活性,让抽象部分和实现部分独立开来,这有助于系统进行分层设计,从而产生更好的结构化系统。
  • 对于系统的高层部分,只需要知道抽象部分和实现部分的接口就可以了,其它的部分由具体业务来完成。
  • 桥接模式替代多层继承方案,可以减少子类的个数,降低系统的管理和维护成本。
  • 桥接模式的引入 增加了系统的理解和设计难度,由于聚合关联关系建立在抽象层,要求开发者针对抽象进行设计和编程
  • 桥接模式要求 正确识别出系统中两个独立变化的维度,因此其使用范围有一定的局限性,即需要有这样的应用场景。
常见应用场景
  1. 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统,桥接模式尤为适用.

  2. 常见的应用场景:

    JDBC驱动程序
    银行转账系统
    转账分类:网上转账,柜台转账,AMT转账
    转账用户类型:普通用户,银卡用户,金卡用户…-消息管理
    消息类型:即时消息,延时消息
    消息分类:手机短信,邮件消息,QQ消息…

装饰者模式

星巴克咖啡订单项目

星巴克咖啡订单项目(咖啡馆):
1)咖啡种类/单品咖啡:Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)
2)调料:Milk、 Soy(豆浆)、Chocolate
3)要求在扩展 新的咖啡种类 时,具有良好的扩展性、改动方便、维护方便
4)使用OO的来计算不同种类咖啡的 费用: 客户可以点单品咖啡,也可以单品咖啡+调料组合。

基本介绍
  • 装饰者模式:动态的将新功能附加到对象上。在对象功能扩展方面,它比继承更有弹性,装饰者模式也体现了开闭原则(ocp)
  • 这里提到的动态的将新功能附加到对象和ocp原则
  • 装饰者模式就像打包一个快递
  • 主体: 比如陶瓷,衣服,// 被装饰者
  • 包装: 比如报纸填充,塑料泡沫 // 装饰者
应用实例
// 被装饰者
@Data
public abstract class Drink {

  public String des; // 描述
  private float price = 0.0F;

  // 计算费用的抽象方法 子类来实现
  public abstract float cost();
}

// 单品咖啡
public class Coffee extends Drink {

  @Override
  public float cost() {
    return super.getPrice();
  }

}
// 意大利咖啡
class Espresso extends Coffee {
  Espresso() {
    super.setDes("意大利咖啡");
    super.setPrice(6.6F);
  }
}
// 美式咖啡
class LongBlack extends Coffee {
  LongBlack() {
    super.setDes("美式咖啡");
    super.setPrice(8.1F);
  }
}
// 无因咖啡
class Decaf extends Coffee {
  Decaf() {
    super.setDes("无因咖啡");
    super.setPrice(2.5F);
  }
}

// 装饰者
public class Decorator extends Drink {

  // 咖啡
  private Drink drink;

  Decorator(Drink drink) {
    this.drink = drink;
  }

  @Override
  public float cost() {
    return super.getPrice() + drink.getPrice();
  }

  @Override
  public String getDes() {
    return super.getDes() + ":" + super.getPrice() + "&&" + drink.getDes();
  }

}
// 巧克力
class Chocolate extends Decorator {

  Chocolate(Drink drink) {
    super(drink);
    setDes("巧克力");
    setPrice(3.3F);
  }
}
// 牛奶
class Milk extends Decorator {
  Milk(Drink drink) {
    super(drink);
    setDes("牛奶");
    setPrice(2.3F);
  }
}
// 豆浆
class Soy extends Decorator {
  Soy(Drink drink) {
    super(drink);
    setDes("豆浆");
    setPrice(4.3F);
  }
}
// 测试
public class Client {
  public static void main(String[] args) {
    // 点一份美食咖啡
    Drink drink = new LongBlack();
    System.out.println("费用=" + drink.cost());
    System.out.println("描述=" + drink.getDes());
    // 加入一份牛奶
    drink = new Milk(drink);
    System.out.println("费用=" + drink.cost());
    System.out.println("描述=" + drink.getDes());
    // 加入 一份巧克力
    drink = new Chocolate(drink);
    System.out.println("费用=" + drink.cost());
    System.out.println("描述=" + drink.getDes());
  }
}
装饰者模式在JDK 应用的源码分析

Java 的IO 结构,FilterInputStream 就是一个装饰者

public abstract class InputStream implements Closeable{} //是一个抽象类,即Component
public class FilterInputStream extends InputStream { //是一个装饰者类Decorator
protected volatile InputStream in //被装饰的对象}
class DataInputStream extends FilterInputStream implements DataInput { //FilterInputStream 子类,也继承了被装饰的对象in }
  • InputStream 是抽象类, 类似我们前面讲的Drink
  • FileInputStream 是InputStream 子类,类似我们前面的DeCaf, LongBlack
  • FilterInputStream 是InputStream 子类:类似我们前面的Decorator 修饰者
  • DataInputStream 是FilterInputStream 子类,具体的修饰者,类似前面的Milk, Soy 等
  • FilterInputStream 类有protected volatile InputStream in; 即含被装饰者
组合模式

学校院系展示需求

看一个学校院系展示需求
编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系。如图:

----清华大学----
----计算机学院----
计算机科学与技术
软件工程
网络工程
----信息工程学院----
通信工程
信息工程
基本介绍
  • 组合模式(Composite Pattern),又叫部分整体模式,它创建了对象组的树形结构,将对象组合成树状结构以表示“整体-部分”的层次关系。
  • 组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式。
  • 组合模式使得用户对单个对象和组合对象的访问具有一致性,即:组合能让客户以一致的方式处理个别对象以及组合对象
组合模式的结构

  1. 抽象构件(Component)角色:它的主要作用是为树叶构件和树枝构件声明公共接口,并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口;在安全式的组合模式中不声明访问和管理子类的接口,管理工作由树枝构件完成。(总的抽象类或接口,定义一些通用的方法,比如新增、删除)
  2. 树叶构件(Leaf)角色:是组合中的叶节点对象,它没有子节点,用于继承或实现抽象构件。
  3. 树枝构件(Composite)角色 / 中间构件:是组合中的分支节点对象,它有子节点,用于继承和实现抽象构件。它的主要作用是存储和管理子部件,通常包含 Add()、Remove()、GetChild() 等方法。
组合模式解决的问题

组合模式解决这样的问题,当我们的要处理的对象可以生成一颗树形结构,而我们要对树上的节点和叶子进行操作时,它能够提供一致的方式,而不用考虑它是节点还是叶子

应用实例

@Data
@AllArgsConstructor
public abstract class OrganizationComponent {

  private String name; // 名称
  private String des; // 描述

  // 默认实现
  protected void add(OrganizationComponent organizationComponent) {
    throw new UnsupportedOperationException();
  }

  protected void remove(OrganizationComponent organizationComponent) {
    throw new UnsupportedOperationException();
  }
  // 打印
  protected abstract void print();

}


// 学校
public class University extends OrganizationComponent {

  // 院系
  List colleges = new ArrayList<>();

  public University(String name, String des) {
    super(name, des);
  }

  @Override
  protected void add(OrganizationComponent organizationComponent) {
    colleges.add(organizationComponent);
  }

  @Override
  protected void remove(OrganizationComponent organizationComponent) {
    colleges.remove(organizationComponent);
  }

  // 打印 学校包含的学院
  @Override
  protected void print() {
    System.out.println("学校:" + this.getName());
    for (OrganizationComponent college : colleges) {
      System.out.println("院系:" + college.getName());
    }
  }

}

// 院系
public class College extends OrganizationComponent {

  // 专业
  List departments = new ArrayList<>();

  public College(String name, String des) {
    super(name, des);
  }

  @Override
  protected void add(OrganizationComponent organizationComponent) {
    departments.add(organizationComponent);
  }

  @Override
  protected void remove(OrganizationComponent organizationComponent) {
    departments.remove(organizationComponent);
  }

  @Override
  protected void print() {
    System.out.println("院系:" + this.getName());
    for (OrganizationComponent department : departments) {
      System.out.println("专业:" + department.getName());
    }
  }
}

// 专业
public class Department extends OrganizationComponent {

  public Department(String name, String des) {
    super(name, des);
  }

  @Override
  protected void print() {
    System.out.println("专业:" + this.getName());
  }
}


public class Client {
  public static void main(String[] args) {
    University 北京大学 = new University("北京大学", "");

    College 计算机学院 = new College("计算机学院", "");
    College 信息工程学院 = new College("信息工程学院", "");

    北京大学.add(计算机学院);
    北京大学.add(信息工程学院);

    Department 软件工程 = new Department("软件工程", "");
    Department 网络工程 = new Department("网络工程", "");
    Department 计算机科学与技术 = new Department("计算机科学与技术", "");
    计算机学院.add(软件工程);
    计算机学院.add(网络工程);
    计算机学院.add(计算机科学与技术);

    Department 通信工程 = new Department("通信工程", "");
    Department 信息工程 = new Department("信息工程", "");

    信息工程学院.add(通信工程);
    信息工程学院.add(信息工程);
  }
}
组合模式的注意事项和细节
  • 简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。
  • 具有较强的扩展性。当我们要更改组合对象时,我们只需要调整内部的层次关系,客户端不用做出任何改动.
  • 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节,容易添加节点或者叶子从而创建出复杂的树形结构
  • 需要遍历组织机构,或者处理的对象具有树形结构时,非常适合使用组合模式.要求较高的抽象性,如果节点和叶子有很多差异性的话,比如很多方法和属性都不一样,不适合使用组合模式
外观模式

影院管理项目

组建一个家庭影院:
DVD播放器、投影仪、自动屏幕、环晓立体声、爆米花机,要求完成使用家庭影院的功能,其过程为:

  • 直接用遥控器,统筹各设备开关

  • 再爆米花机

  • 放下屏幕。

  • 开投影仪。

  • 开音响

  • 开DVD。选dvd。

  • 去拿爆米花

  • 调增灯光。

  • 播放

  • 观影结束后,关院各种设备

基本介绍

外观模式(Facade),也叫 过程模式

外观模式为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这子系统更加容易使用
外观模式通过定义一个一致的接口,用以屏蔽内部子系统的细节,使得调用端只需跟这个接口发生调用,而无需关心这个子系统的内部细节

  1. 外观(Facade)角色:为多个子系统对外提供一个共同的接口。
  2. 子系统(Sub System)角色:实现系统的部分功能,客户可以通过外观角色访问它。
  3. 客户(Client)角色:通过一个外观角色访问各个子系统的功能。
应用实例
// DVD
public class DvDPlayer {

  // 使用单例模式 饿汉式
  private static DvDPlayer instance = new DvDPlayer();

  private DvDPlayer() {}

  public static DvDPlayer getInstance() {
    return instance;
  }

  public void on() {
    System.out.println("dvd on..");
  }

  public void off() {
    System.out.println("dvd off..");
  }

  public void play() {
    System.out.println("dvd play..");
  }

  public void pause() {
    System.out.println("dvd pause..");
  }

}
// 爆米花
public class Popcorn {

  // 使用单例模式 饿汉式
  private static Popcorn instance = new Popcorn();

  private Popcorn() {}

  public static Popcorn getInstance() {
    return instance;
  }

  public void on() {
    System.out.println("popcorn on..");
  }

  public void off() {
    System.out.println("popcorn off..");
  }

  public void play() {
    System.out.println("popcorn play..");
  }

  public void pause() {
    System.out.println("popcorn pause..");
  }

}
// 投影仪
public class Projector {

  // 使用单例模式 饿汉式
  private static Projector instance = new Projector();

  private Projector() {}

  public static Projector getInstance() {
    return instance;
  }

  public void on() {
    System.out.println("Projector on..");
  }

  public void off() {
    System.out.println("Projector off..");
  }

  public void focus() {
    System.out.println("Projector focus..");
  }

}
// 屏幕
public class Screen {

  // 使用单例模式 饿汉式
  private static Screen instance = new Screen();

  private Screen() {}

  public static Screen getInstance() {
    return instance;
  }

  public void up() {
    System.out.println("Screen on..");
  }

  public void down() {
    System.out.println("Screen off..");
  }

}
// 音响
public class Stereo {

  // 使用单例模式 饿汉式
  private static Stereo instance = new Stereo();

  private Stereo() {}

  public static Stereo getInstance() {
    return instance;
  }

  public void on() {
    System.out.println("Stereo on..");
  }

  public void off() {
    System.out.println("Stereo off..");
  }
}
// 灯光
public class TheaterLight {

  // 使用单例模式 饿汉式
  private static TheaterLight instance = new TheaterLight();

  private TheaterLight() {}

  public static TheaterLight getInstance() {
    return instance;
  }

  public void on() {
    System.out.println("TheaterLight on..");
  }

  public void off() {
    System.out.println("TheaterLight off..");
  }


}


// 外观类 整合所有操作
public class HomeTheaterFacade {

  private DvDPlayer dvDPlayer;
  private Popcorn popcorn;
  private Projector projector;
  private Screen screen;
  private Stereo stereo;
  private TheaterLight theaterLight;

  HomeTheaterFacade() {
    this.dvDPlayer = DvDPlayer.getInstance();
    this.popcorn = Popcorn.getInstance();
    this.projector = Projector.getInstance();
    this.screen = Screen.getInstance();
    this.stereo = Stereo.getInstance();
    this.theaterLight = TheaterLight.getInstance();
  }

  public void play() {
    dvDPlayer.play();
    popcorn.play();
    projector.on();
    screen.down();
    stereo.on();
    theaterLight.on();
  }

  public void on() {
    dvDPlayer.on();
  }

  public void end() {
    dvDPlayer.off();
    popcorn.off();
    projector.off();
    screen.up();
    stereo.off();
    theaterLight.off();
  }

}
// 客户端
class Client {
  public static void main(String[] args) {
    HomeTheaterFacade facade = new HomeTheaterFacade();
    facade.play();
    facade.on();
    facade.end();
  }
}
外观模式的注意事项和细节
  • 外观模式对外屏蔽了子系统的细节,因此外观模式降低了客户端对子系统使用的复杂性
  • 外观模式对客户端与子系统的耦合关系,让子系统内部的模块更易维护和扩展通过合理的使用外观模式,可以帮我们 更好的划分访问的层次
  • 当系统需要进行分层设计时,可以考虑使用Facade模式
  • 在维护一个遗留的大型系统时,可能这个系统已经变得非常难以维护和扩展,此时可以考虑为新系统开发一个Facade类,来提供遗留系统的比较清晰简单的接口,让新系统与Facade类交互,提高复用性
  • 不能过多的或者不合理的使用外观模式,使用外观模式好,还是直接调用模块好。要以让系统有层次,利于维护为目的。
享元模式

展示网站项目需求

小型的外包项目,给客户A做一个产品展示网站,客户A的朋友感觉效果不错,也希望做这样的产品展示网站,但是要求都有些不同:
1)有客户要求以新闻的形式发布
2)有客户人要求以博客的形式发布

3)有客户希望以微信公众号的形式发布

基本介绍
  • 享元模式(Flyweight Pattern)也叫蝇量模式:运用共享技术有效地支持大量细粒度的对象
  • 常用于系统底层开发,解决系统的性能问题。像数据库连接池,里面都是创建好的连接对象,在这些连接对象中有我们需要的则直接拿来用,避免重新创建,如果没有我们需要的,则创建一个
  • 享元模式能够 解决重复对象的内存浪费的问题 ,当系统中有大量相似对象,需要缓冲池时。不需总是创建新对象,可以从缓冲池里拿。这样可以降低系统内存,同时提高效率
  • 享元模式经典的应用场景就是 池技术了,String常量池、数据库连接池、缓冲池等等都是享元模式的应用,享元模式是池技术的重要实现方式

  • UnsharedConcreteFlyweight 是非享元角色,一般不会出现在享元工厂类里
  • Flyweight 是抽象享元角色,里面包含了享元方法 operation(UnsharedConcreteFlyweight state),非享元的外部状态以参数的形式通过该方法传入;
  • ConcreteFlyweight 是具体享元角色,包含了关键字 key,它实现了抽象享元接口;
  • FlyweightFactory 是享元工厂角色,用于构建一个池容器(集合),并提供从池中获取对象的方法
应用实例
// 网站抽象类 Flyweight
public abstract class WebSite {

  protected abstract void use();

}
// 具体网站实现类 ConcreteFlyweight 是具体享元角色,包含了关键字 key
public class ConcreteWebSite extends WebSite {

  // 网站发布形式 共享部分
  private String type;

  public ConcreteWebSite(String type) {
    this.type = type;
  }

  @Override
  protected void use() {
    System.out.println("网站发布形式是:" + type);
  }
}
// 网站工厂类 根据需求返回一个网站 FlyweightFactory 享元工厂角色
public class WebSiteFactory {

  // 集合充当池的作用
  private Map map = new HashMap<>();

  // 根据网站的类型 返回一个网站类 如果没有则创建一个 并放入池中
  public WebSite getWebSite(String type) {
    if (map.containsKey(type)) {
      return map.get(type);
    } else {
      ConcreteWebSite webSite = new ConcreteWebSite(type);
      map.put(type, webSite);
      return webSite;
    }
  }

  // 获取网站分类的总数
  public int count() {
    return map.size();
  }
}

class Client {
  public static void main(String[] args) {
    // 创建工厂
    WebSiteFactory factory = new WebSiteFactory();
    // 输入类型
    WebSite app = factory.getWebSite("App");
    // 获取具体实例
    app.use();
    // 获取池的数量
    factory.count();
  }
}
享元模式在JDK底层源码分析

在Integer中使用到了享元模式

   
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
// 如果传入的值在-127-128之间 则从池中取 如果不在 则创建一个
享元模式的注意事项和细节
  • 在享元模式这样理解,“享”就表示共享,“元”表示对象
  • 系统中有大量对象,这些对象消耗大量内存,并且对象的状态大部分可以外部化时,我们就可以考虑选用享元模式
  • 用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象,用HashMap/HashTable存储
  • 享元模式大大减少了对象的创建,降低了程序内存的占用,提高效率
  • 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态,而外部状态具有固化特性,不应该随着内部状态的改变而改变,这是我们使用享元模式需要注意的地方.
  • 使用享元模式时,注意划分内部状态和外部状态,并且需要有一个工厂类加以控制。享元模式经典的应用场景是需要缓冲池的场景,比如String常量池、数据库连接池
代理模式 基本介绍
  • 代理模式:为一个对象提供一个替身,以控制对这个对象的访问。即通过代理对原访问目标对象这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
  • 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
  • 代理模式有不同的形式,主要有三种 静态代理、动态代理 和 Cglib代理。

代理模式的主要角色如下。

  1. 抽象主题(Subject)类:通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  2. 真实主题(Real Subject)类:实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。
  3. 代理(Proxy)类:提供了与真实主题相同的接口,其内部含有对真实主题的引用,它可以访问、控制或扩展真实主题的功能。
静态代理基本介绍

静态代理在使用时,需要定义接口或耆父类,被代理对象(即目标对象)与代理对象一起实现相同的接或者是继承相同父类

应用实例

  • 定义一个接口: lTeacherDao
  • 目标对象TeacherDAO实现接口ITeacherDAo
  • 使用静态代理方式,就需要在代理对象TeacherDAOProxy中也实现ITeacherDAo调用的时候通过调用代理对象的方法来调用目标对象.
  • 特别提醒:代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法。
// 静态代理
public interface lTeacherDao {
  // 授课
  void teach();
}
// 被代理对象
class TeacherDAO implements lTeacherDao {
  @Override
  public void teach() {
    System.out.println("老师授课中");
  }
}
// 代理对象
class TeacherDAOProxy implements lTeacherDao {

  // 聚合被代理对象
  private lTeacherDao iTeacherDao;

  public TeacherDAOProxy(lTeacherDao iTeacherDao) {
    this.iTeacherDao = iTeacherDao;
  }

  @Override
  public void teach() {
    System.out.println("代理对象开始");
    iTeacherDao.teach();
    System.out.println("代理对象结束");
  }
}
// 客户端调用
class Client {
  public static void main(String[] args) {
    // 创建代理对象
    TeacherDAOProxy proxy = new TeacherDAOProxy(new TeacherDAO());
    proxy.teach();
  }
}
静态代理优缺点分析
  • 优点:在不修改目标对象的功能前提下,能通过代理对象对目标功能扩展
  • 缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类一旦接口增加方法,目标对象与代理对象都要维护
动态代理基本介绍

代理对象,不需要实现接口,但是目标对象要实现接口,否则不能用动态代理代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象
动态代理也叫做:JDK代理、接口代理

JDK中生产代理对象API

代理类所在包: java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:
static Object newProxylnstance(ClassLoader loader, Class[] interfaces, InwocationHandler h )

应用实例

// 动态代理
public interface lTeacherDao {
  // 授课
  void teach();
}
// 被代理对象
class TeacherDAO implements lTeacherDao {
  @Override
  public void teach() {
    System.out.println("老师授课中");
  }
}
// 代理对象
class ProxyFactory {

  // 被代理对象
  private Object target;

  public ProxyFactory(Object target) {
    this.target = target;
  }

  // 给目标对象生成一个代理对象
  public Object getProxyInstance() {
    
    // 获取类加载器
    ClassLoader loader = target.getClass().getClassLoader();
    // 获取类实现的所有接口
    Class[] interfaces = target.getClass().getInterfaces();
    return Proxy.newProxyInstance(loader, interfaces, (proxy, method, args) -> {
      System.out.println("JDK动态代理开始");
      // 执行被代理对象的方法
      Object invoke = method.invoke(target, args);
      System.out.println("JDK动态代理结束");
      return invoke;
    });
  }
}
// 客户端
class Client {
  public static void main(String[] args) {
    // 被代理对象
    TeacherDAO target = new TeacherDAO();
    // 代理对象 强转接口
    lTeacherDao proxy = (lTeacherDao) new ProxyFactory(target).getProxyInstance();
    proxy.teach();
  }
}
Cglib代理基本介绍
  • 静态代理和JDK代理模式都要求目标对象是实现一个接口 ,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是Cglib代理

  • Cglib代理也叫作 子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展,有些书也将 Cglib代理归属到动态代理。

  • Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP,实现方法拦截

  • 在AOP编程中如何选择代理模式:

    1.目标对象需要实现接口,用JDK代理

    2.目标对象不需要实现接口,用Cglib代理

  • Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

应用实例

导入依赖

        
            org.ow2.asm
            asm
            9.1
        
        
            org.ow2.asm
            asm
            9.1
        
        
            org.ow2.asm
            asm
            9.1
        
        
            cglib
            cglib
            3.3.0
        
// 被代理对象 不需要实现接口
class TeacherDAO {
  public void teach() {
    System.out.println("老师授课中");
  }
}

// Cglib代理
public class ProxyFactory implements MethodInterceptor {

  // 被代理对象
  private Object target;

  public ProxyFactory(Object target) {
    this.target = target;
  }

  // 给目标对象生成一个代理对象
  public Object getProxyInstance() {
    // 创建一个工具类
    Enhancer enhancer = new Enhancer();
    // 设置父类 设置被代理对象
    enhancer.setSuperclass(target.getClass());
    // 设置回调函数 传入实现MethodInterceptor的类
    enhancer.setCallback(this);
    // 创建子对象 即代理对象
    return enhancer.create();
  }

  // 事件处理,只想被代理对象的方法时 会出发事件处理方法
  @Override
  public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println("Cglib代理开始");
    Object invoke = method.invoke(target, args);
    System.out.println("Cglib代理结束");
    return invoke;
  }
}

class Client {
  public static void main(String[] args) {
      // 创建被代理对象
    TeacherDAO target = new TeacherDAO();
      // 获取代理对象
    TeacherDAO proxyInstance = (TeacherDAO) new ProxyFactory(target).getProxyInstance();
    proxyInstance.teach();
  }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/956462.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号