前置知识

面向方针(oo) => 功用模块[规划形式+算法(数据结构)] => 结构[多种规划形式] => 架构[服务器集群]

高内聚低耦合：重用性、可读性、可扩展性、可靠性

规划准则：

单一责任准则（Principle of Single Responsibility）- 交通东西比方
接口阻隔准则（Interface Segregation Principle）- A-I12-B/C-I13-D比方
依靠倒转准则（Dependence Inversion Principle）- 接口办法/结构办法/setter办法传递 Person-IReceiver-Email/Weinxin比方和电视问题
里氏替换准则（Liskov Substitution Principle）- 解决子类修正父类办法问题-原有承继去掉(依靠/聚合/组合)
敞开封闭准则（Open Close Principle）- 扩展敞开(供给方)，修正封闭(运用方)-GF.DrawShap/abstract Shape.draw();/yuan sanjiao比方
迪米特法则（最少知道准则）（Demeter Principle）- A依靠B(依靠关系B不能是局部变量)
组成复用准则 – 运用组成/聚合的办法，而不是运用承继

//依靠倒转案例
//第一种办法：接口传递
//开关的接口
interface IOpenAndClose {
    public void opoen(ITV tv);//笼统办法，接纳接口
}
interface ITV {//ITV接口
    public void play();
}
//完结接口
class OpenAndColse implements IOpenAndClose {
    @Override
    public void opoen(ITV tv) {
        tv.play();
    }
}
//办法二：结构办法传递
interface IOpenAndClose {
    public void open();//笼统办法
}
interface ITV {//ITV接口
    public void play();
}
class OpenAndClose implements IOpenAndClose {
    public ITV tv;//成员
    public OpenAndClose(ITV tv) {//结构办法
        this.tv = tv;
    }
    @Override
    public void open() {
        this.tv.play();
    }
}
//办法三：setter办法传递
interface IOpenAndClose {
    public void open();//笼统办法
}
interface ITV {//ITV接口
    public void play();
}
class OpenAndClose implements IOpenAndClose {
    private ITV tv;
    public void setTv(ITV tv) {
        this.tv = tv;
    }
    @Override
    public void open() {
        this.tv.play();
    }
}

UML类图——Unified modeling language UML(统一建模语言)，是一种用于软件系统剖析和规划的语言东西。【依靠、泛化(承继)、完结、关联、聚合与组合】

规划形式

单例形式

1)饿汉式(静态常量)

进程如下:
1)结构器私有化(防止new)
2)类的内部创立方针
3)向外暴露一个静态的公共办法。getInstance
4)代码完结

public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//饿汉式（静态常量）
class Singleton {
    //1、结构器私有化，外部不能new
    private Singleton() {}
    //2、本类内部创立方针实例
    private final static Singleton instance = new Singleton();
    //3、供给一个公有的静态办法，回来实例方针
    public static Singleton getInstance() {
        return instance;
    }
}

在类装载的时分就完结实例化，防止线程同步问题。没有到达Lazy Loading的效果，会形成内存浪费。
留意类加载时机：new一个方针、拜访类的静态成员、调用类的静态办法、给类的静态成员赋值、程序的主类、反射

2)饿汉式(静态代码块)

public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//饿汉式（静态代码块）
class Singleton {
    //1、结构器私有化，外部不能new
    private Singleton() {}
    //2、静态代码块
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    //3、供给一个公有的静态办法，回来实例方针
    public static Singleton getInstance() {
        return instance;
    }
}

3)懒汉式(线程不安全)

public class SingletonTest3 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//懒汉式（线程不安全）
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    //供给一个静态的公有办法，当运用到该办法时，才去创立instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

起到了Lazy Loading的效果，可是只能在单线程下运用。【不主张运用】

4)懒汉式(线程安全，同步办法)

public class SingletonTest4 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//懒汉式（线程安全，同步办法）
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    //供给一个静态的公有办法，参加同步处理的代码，解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

加锁synchronized，办法进行同步功率太低。【不推荐运用】

5)懒汉式(线程安全，同步代码块)

public class SingletonTest5 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//懒汉式（线程安全，同步代码块）
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

这种同步并不能起到线程同步的效果。【不能运用】

6)两层查看

public class SingletonTest6 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//两层查看
class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    //供给一个静态的公有办法，参加两层查看代码，解决线程安全问题，一起解决懒加载问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile和synchronized，线程安全；延迟加载；功率较高。【推荐运用】

7)静态内部类

public class SingletonTest7 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}
//静态内部类
class Singleton {
    private Singleton() {}
    //写一个静态内部类，该类中有一个静态特点Singleton
    private static class singleInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    //供给一个静态的公有办法，直接回来方针
    public static synchronized Singleton getInstance() {
        return singleInstance.INSTANCE;
    }
}

采用了类装载的机制来确保初始化实例时只有一个线程。静态内部类办法在Singleton类被装载时并不会当即实例化，而是在需求实例化时，调用getInstance办法，才会装载SingletonInstance类，然后完结Singleton的实例化。类的静态特点只会在第一次加载类的时分初始化，所以在这儿，JVM协助咱们确保了线程的安全性，在类进行初始化时，别的线程是无法进入的。
防止了线程不安全，利用静态内部类特点完结延迟加载，功率高。【推荐运用】

8)枚举

public class SingletonTest8 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        instance.sayOK();
    }
}
//运用枚举，能够完结单例
enum Singleton {
    INSTANCE;//特点
    public void sayOK() {
        System.out.println("ok");
    }
}

借助JDK1.5中添加的枚举来完结单例形式。不仅能防止多线程同步问题，而且还能防止反序列化从头创立新的方针。【推荐运用】

单例形式运用的场景：需求频频的进行创立和毁掉的方针、创立方针时耗时过多或耗费资源过多(即:重量级方针)，但又经常用到的方针、东西类方针、频频拜访数据库或义件的方针(比方数据源、session工厂等)

工厂形式

在软件开发中，当咱们会用到很多的创立某种、某类或许某批方针时，就会运用到工厂形式。

简略工厂形式

界说了一个创立方针的类，由这个类来封装实例化方针的行为(代码)。

//把Pizza类做成笼统类
public abstract class Pizza {
    private 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 void setName(String name) {
        this.name = name;
    }
}

// GreekPizza CheessPizza ... 披萨品种
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给GreekPizza预备原材料");
    }
}

public class OrderPizza {
    //结构办法
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订货披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName("GreekPizza");
            } else if (orderType.equals("cheess")) {
                pizza = new CheessPizza();
                pizza.setName("CheessPizza");
            } else {
                break;
            }
            //输出pizza制造进程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
    //写一个办法，能够获取客户期望订货的披萨品种
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = null;
            str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

//相当于客户端
public class OrderStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

改进的思路剖析：

剖析：修正代码能够承受，可是如果咱们在其它的当地也有创立Pizza的代码，就意味着，也需求修正，而创立Pizza的代码，往往有多处。
思路：把创立Pizza方针封装到一个类中，这样咱们有新的Pizza品种时，只需求修正该类就可，其它有创立到Pizza方针的代码就不需求修正了（运用简略工厂形式）。

//简略工厂类
public class SimpleFactory {
    //简略工厂形式，也叫静态工厂形式，能够用static润饰该办法
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("GreekPizza");
        } else if (orderType.equals("cheess")) {
            pizza = new CheessPizza();
            pizza.setName("CheessPizza");
        }
        //输出pizza制造进程
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

public class OrderPizza2 {
    //界说一个简略工厂方针
    SimpleFactory simpleFactory;
    //结构器
    public OrderPizza2(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }
    Pizza pizza = null;
    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = "";//用户输入的
        this.simpleFactory = simpleFactory;//设置简略工厂方针
        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            //输出pizza制造进程
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订货失利");
                break;
            }
        } while (true);
    }
    //写一个办法，能够获取客户期望订货的披萨品种
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = null;
            str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

//相当于客户端
public class OrderStore {    
  public static void main(String[] args) {        
    OrderPizza2 orderPizza = new OrderPizza2(new SimpleFactory());    
  }
}

工厂办法形式

工厂办法形式规划方案：将披萨项目的实例化功用笼统成笼统办法，在不同的口味点餐子类中详细完结。
工厂办法形式：界说了一个创立方针的笼统办法，由子类决定要实例化的类。工厂办法形式将方针的实例化推迟到子类。

public class BJCheessPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的CheessPizza");
        System.out.println("  北京的CheessPizza 预备原材料");
    }
}
public class BJPepperPizza extends Pizza {...}
public class LDCheessPizza extends Pizza {...}
public class LDPepperPizza extends Pizza {...}

public abstract class OrderPizza {
    //结构办法
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订货披萨的类型
        do {
            orderType = getType();
            //调用办法
            pizza = creatPizza(orderType); //让子类的笼统办法完结
            //输出pizza制造进程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
    //界说一个笼统办法，让各个工厂子类自己完结
    abstract Pizza creatPizza(String orderType);
    //写一个办法，能够获取客户期望订货的披萨品种
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = null;
            str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class BJOrderPizza  extends OrderPizza {
    @Override
    Pizza creatPizza(String orderType) {
        Pizza pizza=null;
        if (orderType.equals("Cheess")){
            pizza=new BJCheessPizza();  
        }else if(orderType.equals("Pepper")){
            pizza=new BJPepperPizza();
        }
        return pizza;
    }
}
public class LDOrderPizza extends OrderPizza {
    pizza = new LDCheessPizza();
    pizza = new LDPepperPizza();
}

//披萨店
public class PizzaStore {
    public static void main(String[] args) {
        new BJOrderPizza();//创立北京各种口味的披萨
        new LDOrderPizza();//创立伦敦各种口味的披萨
    }
}

笼统工厂形式

笼统工厂形式：界说了一个interface用于创立相关或有依靠关系的方针簇，而无需指明详细的类。

笼统工厂形式能够将简略工厂形式和工厂办法形式进行整合。从规划层面看，笼统工厂形式便是对简略工厂形式的改进(或许称为进一步的笼统)

将工厂笼统成两层，AbsFactory(笼统工厂)和详细完结的工厂子类。程序员能够根据创立方针类型运用对应的工厂子类。这样将单个的简略工厂类变成了工厂簇，更利于代码的维护和扩展。

//一个笼统工厂形式的笼统层（接口）
public interface AbsFactory {
    //让下面的工厂子类来详细完结
    Pizza createPizza(String orderType);
}

//这是一个工厂子类
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("Cheess")) {
            pizza = new BJCheessPizza();
        }
        if (orderType.equals("Pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}
public class LDFactory implements AbsFactory {
...
    pizza=new LDCheessPizza();
    pizza=new LDPepperPizza();
...
}

public class OrderPizza {
    AbsFactory factory;
    //结构器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }
    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = "";//用户输入
        this.factory = factory;
        do {
            orderType = getType();
            //factory可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.box();
                pizza.cut();
            } else {
                System.out.println("订货失利");
                break;
            }
        } while (true);
    }
    //写一个办法，能够获取客户期望订货的披萨品种
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = null;
            str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
        //new OrderPizza(new LDFactory());
    }
}

原型形式

Java中object类是一切类的根类，object类供给了一个clone()办法，该办法能够将一个Java方针仿制一份，可是需求完结clone的Java类必须要完结一个接口Cloneable，该接口表明该类能够仿制且具有仿制的才能 => 原型形式。

1)原型形式(Prototype形式)是指：用原型实例指定创立方针的品种，并且经过仿制这些原型，创立新的方针
2)原型形式是一种创立型规划形式，答应一个方针再创立别的一个可定制的方针，无需知道怎么创立的细节
3)作业原理是：经过将一个原型方针传给那个要发起创立的方针，这个要发起创立的方针经过恳求原型方针仿制它们自己来实施创立，即 方针.clone()

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
    //get、set办法
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ",\'' +
                '}';
    }
    //克隆该实例，运用默许的clone办法来完结
    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep)sheep.clone();
        //......
        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
    }
}

浅仿制
1)关于数据类型是根本数据类型的成员变量，浅仿制会直接进行值传递，也便是将该特点值仿制一份给新的方针。
2)关于数据类型是引证数据类型的成员变量，比方说成员变量是某个数组、某个类的方针等，那么浅仿制会进行引证传递，也便是仅仅将该成员变量的引证值（内存地址）仿制一份给新的方针。由于实际上两个方针的该成员变量都指向同一个实例。在这种情况下，在一个方针中修正该成员变量会影响到另一个方针的该成员变量值。
3)浅仿制是运用默许的clone()办法来完结sheep = (Sheep) super.clone(); 。

深仿制
1)仿制方针的一切根本数据类型的成员变量值。
2)为一切引证数据类型的成员变量中请存储空间，并仿制每个引证数据类型成员变量所引证的方针，直到该方针可达的一切方针。也便是说，方针进行深仿制要对整个方针进行仿制。
3)深仿制完结办法：重写clone办法来完结深仿制；经过方针序列化完结深仿制。

public class DeepCloneableTarget implements Serializable, Cloneable {
	private static final long serialVersionUID = 1L;
	private String cloneName;
	private String cloneClass;
	public DeepCloneableTarget(String cloneName, String cloneClass) {
		this.cloneName = cloneName;
		this.cloneClass = cloneClass;
	}
	//由于该类的特点都是String，因而咱们这儿运用默许的clone完结即可
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

public class DeepProtoType implements Serializable, Cloneable {
    public String name;
    public DeepCloneableTarget deepCloneableTarget;
    public DeepProtoType() {
        super();
    }
    //深仿制-办法1
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //完结对特点为根本数据类型和String的克隆
        deep = super.clone();
        //对特点为引证类型的独自处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
        return deepProtoType;
    }
    //深仿制-办法2
    public Object deepClone() {
        //创立流方针
        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);
            DeepProtoType copyObj = (DeepProtoType) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //封闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        DeepProtoType p = new DeepProtoType();
        p.name = "宋江";
        p.deepCloneableTarget = new DeepCloneableTarget("小明", "学生类");
        //测验，办法1
        DeepProtoType p1 = (DeepProtoType) p.clone();
        System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        System.out.println("p1.name=" + p.name + "p2.deepCloneableTarget=" + p1.deepCloneableTarget.hashCode());
        //测验，办法2
        DeepProtoType p2 = (DeepProtoType) p.deepClone();
        System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
        System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    }
}

制造者形式

1)制造者形式(Builder Pattern)又名生成器形式，是一种方针构建形式。它能够将杂乱方针的制造进程笼统出来（笼统类别)，使这个笼统进程的不同完结办法能够结构出不同体现（特点）的方针。
2)制造者形式是一步一步创立一个杂乱的方针，它答应用户只经过指定杂乱方针的类型和内容就能够构建它们，用户不需求知道内部的详细构建细节。【模块组装】

制造者形式的四个人物
1)Product (产品人物)：一个详细的产品方针。
2)Builder（笼统制造者)：创立一个Product方针的各个部件指定的接口。
3)ConcreteBuilder(详细制造者)：完结接口，构建和装配各个部件。
4) Director(指挥者):：构建一个运用Builder接口的方针。它主要是用于创立一个杂乱的方针。它主要有两个效果，一是:阻隔了客户与方针的生产进程，二是:负责操控产品方针的生产进程。

//产品-->Product
publicclassHouse{
privateStringbaise;
privateStringwall;
privateStringroofed;
    ...getter/setter
}

//笼统的制造者
publicabstractclassHouseBuilder{
protectedHousehouse=newHouse();
//将制造的流程写好，笼统的办法
publicabstractvoidbuildBasic();
publicabstractvoidbuildWalls();
publicabstractvoidroofed();
//制造房子后，将产品（房子）回来
publicHousebuildHouse(){
returnhouse;
}
}

publicclassCommonHouseextendsHouseBuilder{
@Override
publicvoidbuildBasic(){
System.out.println("一般房子打地基5米");
}
@Override
publicvoidbuildWalls(){
System.out.println("一般房子垒墙10cm");
}
@Override
publicvoidroofed(){
System.out.println("一般房子房顶");
}
}
publicclassHighBuildingextendsHouseBuilder{
@Override
publicvoidbuildBasic(){
System.out.println("楼房的打地基100米");
}
@Override
publicvoidbuildWalls(){
System.out.println("楼房的垒墙20cm");
}
@Override
publicvoidroofed(){
System.out.println("楼房的通明房顶");
}
}

//指挥者，指定制造流程
publicclassHouseDirector{
HouseBuilderhouseBuilder=null;
//经过结构器传入houseBuilder
publicHouseDirector(HouseBuilderhouseBuilder){
this.houseBuilder=houseBuilder;
}
//或许经过set办法传入houseBuilder
publicvoidsetHouseBuilder(HouseBuilderhouseBuilder){
this.houseBuilder=houseBuilder;
}
//怎么处理制造房子的流程？交给指挥者
publicHouseconstructHouse(){
houseBuilder.buildBasic();
houseBuilder.buildWalls();
houseBuilder.roofed();
returnhouseBuilder.buildHouse();
}
}

publicclassClient{
publicstaticvoidmain(String[]args){
CommonHousecommonHouse=newCommonHouse();//盖一般房子
//HighBuildinghighBuilding=newHighBuilding();//盖高房子
HouseDirectorhouseDirector=newHouseDirector(commonHouse);//创立房子的指挥者
Househouse=houseDirector.constructHouse();//完结盖房，回来产品（房子）
}
}

署理形式

署理形式:为一个方针供给一个替身，以操控对这个方针的拜访。即经过署理方针拜访方针方针。这样做的优点是:能够在方针方针完结的基础上,增强额定的功用操作,即扩展方针方针的功用。

署理形式有不同的形式,主要有三种静态署理、动态署理(JDK署理或接口署理)和cglib署理(在内存动态的创立方针，而不需求完结接口)。

静态署理

静态署理在运用时,需求界说接口或许父类,被署理方针(即方针方针)与署理方针一起完结相同的接口或许是承继相同父类。

publicinterfaceITeacherDao{
voidteach();//授课的办法
}

//被署理方针
publicclassTeacherDaoimplementsITeacherDao{
@Override
publicvoidteach(){
System.out.println("教师授课中...");
}
}

 //署理方针
 publicclassTeacherDaoProxyimplementsITeacherDao{
 privateITeacherDaoiTeacherDao;
 publicTeacherDaoProxy(ITeacherDaoiTeacherDao){
 this.iTeacherDao=iTeacherDao;
 }
@Override
publicvoidteach(){
System.out.println("教师备课");
iTeacherDao.teach();
System.out.println("教师完毕讲课");
}
}

 publicclassClient{
 publicstaticvoidmain(String[]args){
 //创立被署理方针（方针方针）
 TeacherDaoteacherDao=newTeacherDao();
 //创立署理方针，一起将被署理方针传递给署理方针
 TeacherDaoProxyteacherDaoProxy=newTeacherDaoProxy(teacherDao);
 //经过署理方针，调用到被署理方针的办法
 teacherDaoProxy.teach();
 }
}

优点:在不修正方针方针的功用前提下，能经过署理方针对方针功用扩展。
缺点:一旦接口添加办法,方针方针与署理方针都要维护。

动态署理－JDK署理

署理方针,不需求完结接口，可是方针方针要完结接口，不然不能用动态署理。
署理方针的生成，是利用JDK的API，动态的在内存中构建署理方针。【反射机制】
署理类地点包:java.lang.reflect.Proxy。JDK完结署理只需求运用newProxyInstance办法,可是该办法需求接纳三个参数,完好的写法是:
static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces, InvocationHandler h)

 importjava.lang.reflect.InvocationHandler;
 importjava.lang.reflect.Method;
 importjava.lang.reflect.Proxy;
 publicclassProxyFactory{
 privateObjecttarget;//方针方针
 publicProxyFactory(Objecttarget){
this.target=target;
}
//给方针方针生成一个署理方针
publicObjectgetProxyInstance(){
/**
*newProxyInstance办法参数阐明
 *第一个参数：指定当时方针方针运用的类加载器；
 *第二个参数：方针方针完结的接口类型；
*第三个参数：事情处理，履行方针方针的办法时，会触发事情处理器办法
*/
returnProxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
newInvocationHandler(){
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
System.out.println("教师备课");
//反射机制调用方针方针的办法
Objectinvoke=method.invoke(target,args);
System.out.println("教师讲完课了");
returninvoke;
}
}
);
}
}

public class Clinet {
    public static void main(String[] args) {
        // 创立方针方针
        ITeacherDao target = new TeacherDao();
        // 给方针方针 创立署理方针
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
        // 内存中动态生成署理方针 proxyInstance class com.sun.proxy.$Proxy0
        System.out.println("proxyInstance "+proxyInstance.getClass());
        // 经过署理方针 调用方针方针
        proxyInstance.teach();
    }
}

动态署理－CGlib署理

被署理方针不运用接口，运用办法拦截器。
在AOP编程中怎么挑选署理形式：

方针方针需求完结接口，用JDK署理
方针方针不需求完结接口，用cglib署理

cglib包的底层是经过运用字节码处理结构ASM来转换字节码并生成新的类。

asm.jar
asm-commons.jar
asm-tree.jar
cglib-2.2.jar

在内存中动态构建子类，留意署理的类不能为final，不然报错java.lang.lllegalArgumentException

publicclassTeacherDao{
publicvoidteach(){
System.out.println("教师授课中...");
}
}

 importnet.sf.cglib.proxy.Enhancer;
 importnet.sf.cglib.proxy.MethodInterceptor;
 importnet.sf.cglib.proxy.MethodProxy;
 importjava.lang.reflect.Method;
 publicclassProxyFactoryimplementsMethodInterceptor{
 privateObjecttarget;//维护一个方针方针
//结构器，传入被署理方针
publicProxyFactory(Objecttarget){
this.target=target;
}
//回来一个署理方针
publicObjectgetProxyInstance(){
//1、创立一个东西类
Enhancerenhancer=newEnhancer();
 //2、设置父类
enhancer.setSuperclass(target.getClass());
//3、设置回调函数
enhancer.setCallback(this);
//4、创立子类方针，即署理方针
returnenhancer.create();
}
@Override
publicObjectintercept(Objecto,Methodmethod,Object[]args,MethodProxymethodProxy)throwsThrowable{
 System.out.println("教师备课");
Objectinvoke=method.invoke(target,args);
System.out.println("教师讲完课了");
returninvoke;
}
}

publicclassClient{
publicstaticvoidmain(String[]args){
 //创立方针方针
TeacherDaoteacherDao=newTeacherDao();
//创立署理方针，回来被署理的方针方针（必须强制类型转换）
TeacherDaoproxyInstance=(TeacherDao)newProxyFactory(teacherDao).getProxyInstance();
proxyInstance.teach();
}
}

署理形式的变体：防火墙署理、缓存署理、远程署理、同步署理

观察者形式

观察者形式：方针之间多对一依靠的一种规划方案，被依靠的方针为Subject，依靠的方针为Observer，subject告诉Observer变化，比方这儿的奶站/气象局是subject，是1的一方。用户是Observer，是多的一方。

①subject
registerObserver() 注册
removeObserver() 移除
notifyObservers() 告诉一切的注册的用户，根据不同需求，能够是更新数据，让用户来取,也可能是实施推送,看详细需求定。
②Observer
update() 接纳输入更新

//接口, 让WeatherData 来完结【被观察者】 
public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

//观察者接口，由观察者来完结
public interface Observer {
    public void update(float temperature, float pressure, float humidity);
}

//观察者的完结1
public class CurrentConditions implements Observer {
    // 温度，气压，湿度
    private float temperature;
    private float pressure;
    private float humidity;
    // 更新 天气情况，是由 WeatherData 来调用，我运用推送形式
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }
    // 显现
    public void display() {
        System.out.println("***Today mTemperature: " + temperature + "***");
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
}

//观察者的完结2
public class BaiduSite implements Observer {
    // 温度，气压，湿度
    private float temperature;
    private float pressure;
    private float humidity;
    // 更新 天气情况，是由 WeatherData 来调用，我运用推送形式
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }
    // 显现
    public void display() {
        System.out.println("===百度网站====");
        System.out.println("***百度网站 气温 : " + temperature + "***");
        System.out.println("***百度网站 气压: " + pressure + "***");
        System.out.println("***百度网站 湿度: " + humidity + "***");
    }
}

public class WeatherData implements Subject {
    private float temperatrue;
    private float pressure;
    private float humidity;
    //观察者集合
    private ArrayList<Observer> observers;
    //参加新的第三方
    public WeatherData() {
        observers = new ArrayList<Observer>();
    }
    public float getTemperature() {
        return temperatrue;
    }	
    public float getPressure() {
        return pressure;
    }
    public float getHumidity() {
        return humidity;
    }
    public void dataChange() {
        //调用 接入方的 update
        notifyObservers();
    }
    //当数据有更新时，就调用 setData
    public void setData(float temperature, float pressure, float humidity) {
        this.temperatrue = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }
    //注册一个观察者
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    //移除一个观察者
    @Override
    public void removeObserver(Observer o) {
        if(observers.contains(o)) {
            observers.remove(o);
        }
    }
    //遍历一切的观察者，并告诉
    @Override
    public void notifyObservers() {
        for(int i = 0; i < observers.size(); i++) {
            observers.get(i).update(this.temperatrue, this.pressure, this.humidity);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        // 创立一个WeatherData
        WeatherData weatherData = new WeatherData();
        // 创立观察者
        CurrentConditions currentConditions = new CurrentConditions();
        BaiduSite baiduSite = new BaiduSite();
        // 注册到weatherData
        weatherData.registerObserver(currentConditions);
        weatherData.registerObserver(baiduSite);
        // 测验
        System.out.println("告诉各个注册的观察者, 看看信息");
        weatherData.setData(10f, 100f, 30.3f);
        weatherData.removeObserver(currentConditions);
        // 测验
        System.out.println();
        System.out.println("告诉各个注册的观察者, 看看信息");
        weatherData.setData(10f, 100f, 30.3f);
    }
}

//成果
告诉各个注册的观察者, 看看信息
***Today mTemperature: 10.0***
***Today mPressure: 100.0***
***Today mHumidity: 30.3***
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***
告诉各个注册的观察者, 看看信息
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***

观察者形式规划后，会以集合的办法来管理用户(Observer)，包含注册，移除和告诉。
这样，咱们添加观察者(这儿能够了解成一个新的公告板)，就不需求去修正核心类WeatherData不会修正代码，恪守了ocp准则。

参考资料

尚硅谷Java规划形式（图解+结构源码剖析）
规划形式的七大准则详解
java深仿制与浅仿制
规划形式-观察者形式

软件工程 | 设计模式Java版

前置知识

规划形式

单例形式

1)饿汉式(静态常量)

2)饿汉式(静态代码块)

3)懒汉式(线程不安全)

4)懒汉式(线程安全，同步办法)

5)懒汉式(线程安全，同步代码块)

6)两层查看

7)静态内部类

8)枚举

工厂形式

简略工厂形式

工厂办法形式

笼统工厂形式

原型形式

制造者形式

署理形式

静态署理

动态署理－JDK署理

动态署理－CGlib署理

观察者形式

参考资料

作者信息

推广

软件工程 | 设计模式Java版

前置知识

规划形式

单例形式

1)饿汉式(静态常量)

2)饿汉式(静态代码块)

3)懒汉式(线程不安全)

4)懒汉式(线程安全，同步办法)

5)懒汉式(线程安全，同步代码块)

6)两层查看

7)静态内部类

8)枚举

工厂形式

简略工厂形式

工厂办法形式

笼统工厂形式

原型形式

制造者形式

署理形式

静态署理

动态署理－JDK署理

动态署理－CGlib署理

观察者形式

参考资料

相关文章

能听懂语音的ChatGPT来了：10小时录音扔进去，想问什么问什么

ENVI基于大气校正方法反演Landsat 7地面温度

ServiceMesh究竟解决什么问题？

转转风控「违禁物品识别」 背后的那些事儿

作者信息

推广

转转风控「违禁物品识别」背后的那些事儿