Design Pattern

SOLID

1. Single Responsiblity
2. Open Closed
3. Liskov Substitution
4. Inteface Segregation 专门的接口比总的接口好 更细化接口的继承！
5. Dependency Inversion 高层模块不应依赖底层模块 “依赖倒置” 大家都应该依赖于抽象

Agile

最初先做个基本的prototype，然后迭代改进 每个版本新增一个完整的功能。

Design Pattern

设计模式的作用：

1. 设计模式以一种标准的方式供广大开发人员使用，为开发者的沟通提供了一套机制，帮助开发者更好地明白和更清晰地描述一段被给出的代码。
2. 设计模式可以使人们更加方便简单复用成功的设计模式和结构。
3. 设计模式可以使人们深入理解面向对象的设计思想，提高软件的开发效率，节约设计成本。

重点

单例模式

Lazy initialization vs Eager initialization

违反单例模式的情况

• 序列化 + 反序列化后 产生不同的对象

  • 通过重写readResolve改变反序列化行为

• clone 类似第二个情况

  • 建议直接抛出异常：不支持克隆
  • 或者重写clone 返回唯一的实例

• 反射修改constructor权限构建新实例

• multiple threads access + lazy init

  • 双重检验锁 + volatile 解决缓存不一致问题 + “happens-before rule”: a change to a volatile variable happens before read

  • private static volatile Singleton soleInstance = null;
    public static Singleton getInstance() {
      //double checked locking
      if(soleInstance == null) {
        synchronized(Singleton.class) {
          soleInstance = new Singleton();
        }
      }
      return soleInstance;
    }

  • 只使用双重检验锁不够， 因为可能出现线程1new Singleton( )过程中 “只初始化了一半” 被中断切换到线程2 线程2会返回一个没初始化完的单例

  • 静态内部类holder

  • public static Singleton getInstance() {
      return Holder.INSTANCE;
    }
    static class Holder {
      static final Singleton INSTANCE = new Singleton();
    }

  • 最高安全级别：使用枚举类 addresses all the concerns above

  • enum Singleton {
      INSTANCE;
      public String getConfiguration(){return "xxx";}
    }

• multiple class loaders + eager init:

  • no exact solution, can add check.

工厂模式

简单工厂

public class SimpleFactory {
    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}

工厂方法模式

父类决定实例生成方式，但不决定要生成的具体类，具体处理全部交给子类负责

用模版方法模式来构成生成实例的工厂

public abstract class Factory {
    abstract public Product factoryMethod();
}
public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}
public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}

抽象工厂

定义模版方法将抽象零件组装成抽象产品 = 抽象工厂

public abstract class AbstractProductA {}
public class ProductA1 extends AbstractProductA {}
public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() { return new ProductA1(); }
    AbstractProductB createProductB() { return new ProductB1(); }
}

代理模式

使用一个中间代理去控制对其他对象的访问 Remote Method Invocation (RMI) 两个JVM之间

其他

模版方法模式

将具体处理交给子类：抽象类 抽象方法 去定义“模版” 子类要实现的东西

Builder模式

封装一个对象的构造过程，并允许按步骤构造。 StringBuilder

Prototype模式

通过复制一个原型实例来创建新对象。 Object.clone( )

迭代器模式

提供一个遍历集合的东西 但不暴露集合内容

适配器模式

加个适配器类以便于复用现有类 Arrays.asList

Decorator模式

添加功能与对象本体功能分离：为对象动态添加功能。 类似继承。
FileInputStream - BufferedInputStream
没有缓存区，read一次 = 发送一次IO操作；
有缓存区，第一次read时，会一下读取x个字节放入缓存区，然后后续的read都会从缓存中读取, 当read到缓存区末尾时，会再次读取x个字节放入缓存区

MVC

A very popular architecture for web application.

Model

• data related logic
• interact with database sql / nosql
• communicates with controller
• can sometimes update the view (depends on framework)

View

• What the end user sees (UI)
• HTML/CSS
• communicates with controller
• can be passed dynamic values from the controller
• template engines

Controller

• receives input (from browser / view, url)
• processes requests (GET POST PUT DELETE)
• get data from model
• passes data to the view

AOP Aspect Oriented Programming

• Cross cutting concerns
  • having a common functionality such as logging, transaction, security
  • do we create a new class ?
  • No, we create an agent
  • define a aspect configuration: which aspect applies to which classes - dependency injection in spring

打赏