Java中常用的设计模式（观察者，单例，工厂，装饰器）和代理模式

1 代理模式有哪些？

静态代理：在程序运行之前，提前写好被代理方法的代理类，编译后运行，在程序运行之前，class类已经存在

JDK动态代理：通过反射机制，在运行是动态生成所需要的的class。与静态代理一样，需要提前定义接口

CGLIB动态代理：采用底层的字节码代理技术，原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截技术，拦截所有父类方法的调用，顺势植入横切逻辑。JDK动态代理和CGLIB动态代理实实现Spring AOP的基础。

代理类生成代理对象的生成过程：
	1>生成代理类的二进制字节码文件
	2>通过class.forName加载二进制字节码文件，生成Class对象
	3>通过反射获取机制获取实例构造，初始化代理类对象。
	

2 设计模式的定义，分类

设计模式：是代码可用性的延伸。

分类：创建型模式，行为型模式，结构型模式

3.JDK中几个常用的设计模式？

1>单例模式：饿汉式，懒汉式，synchronized和volatile双重锁

2>观察者模式 (时间监听)

3>工厂模式：简单工厂模式，工厂模式，抽象工厂模式

5>装修设计模式（用于多个Java I/O中）

3.1 单例模式

单例模式：java中最简单的设计模式，这种类型的设计模式属于创建型模式，他提供一中创建对象的最佳方式。

目的：保证一个类只有一个实例，并提供一个全局访问点。主要解决全局使用的类频繁的创建与销毁。

懒汉式加载：线程安全

package DesignPattern;
//懒汉式  用的时候，没有这个实例才会加载
public class Singleton1{
    private static Singleton1 instance;
    private Singleton1(){}
    public static synchronized Singleton1 getInstance(){
        if(instance==null){
            instance = new Singleton1();
        }
        return instance;
    }
}

饿汉式：线程安全

package DesignPattern;
//饿汉子
public class SIngleton2 {
    private static SIngleton2 instance = new SIngleton2();

    private SIngleton2() {
    }
    public static synchronized SIngleton2 getInstance(){
        return instance;
    }
}

双重锁+volatile关键字

package DesignPattern;
//饿汉子
public class SIngleton2 {
    private static SIngleton2 instance = new SIngleton2();

    private SIngleton2() {
    }
    public static synchronized SIngleton2 getInstance(){
        return instance;
    }
}

测试用例

package DesignPattern;
//饿汉子
public class SIngleton2 {
    private static SIngleton2 instance = new SIngleton2();

    private SIngleton2() {
    }
    public static synchronized SIngleton2 getInstance(){
        return instance;
    }
}

测试结果：

3.2 工厂模式

工厂模式属于创建型模式，属于创建对象的最佳方式

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

**主要解决：**接口选择问题

我们先创建一个Shape接口和一个他的实现类，然后在定义一个工厂类ShapeFactory。

1.定义一个接口

package DesignPattern.Factory;
//1.定义一个接口
public interface Shape {
    public void draw();
}

2 定义一个实现类

package DesignPattern.Factory;
//2 定义一个实现类
public class Rectangle implements Shape {

    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

package DesignPattern.Factory;
//2 定义一个实现类
public class Square implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

3 定义一个工厂。生成给定信息的实体类

package DesignPattern.Factory;
// 3定义一个工厂。生成给定信息的实体类
public class ShapeFactory{
    //定义一个方法获取形状类的对象
    public Shape getShape(String shapeType){
        if(shapeType==null){
            return null;
        }
        shapeType = shapeType.toLowerCase();
        switch (shapeType){
            case "rectangle":
                return new Rectangle();
            case "square":
                return new Square();
            default:
                return null;
        }
    }
}

4 使用该工厂根据传入信息生成形状类对象

package DesignPattern.Factory;
//4 使用该工厂根据传入信息生成形状类对象
public class FactoryDemo{
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        Shape shape = shapeFactory.getShape("RECTANGLE");
        shape.draw();
        Shape shape1 = shapeFactory.getShape("SQUARE");
        shape1.draw();
    }

}

5 验证输出

3.3 观察者模式

当对象间存在一对多的关系时，则使用观察者模式。
比如，当一个对象被修饰时，则会自动通知他的依赖对象。属于行为型模式。

**目标：**一个对象状态概念给其他对象通知的问题，而且要考虑易用和低耦合，保证高度的协作。

说明：观察者模式使用三个类Subject, Observer, 和Client。 Subject对象带有绑定观察者到Client对象和从Client对象解绑观察者的方法。我们创建Subject类，Observer抽象类和扩展了的抽象类的Observer的实体类。

1，设计一个被观察者 Subject类

package DesignPattern.ObServer;

import java.util.ArrayList;
import java.util.List;


public class Subject{
    private List<Observer> observers = new ArrayList<>();
    private  int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }
    public void attach(Observer observer)
    {
        observers.add(observer);
    }
    public void notifyAllObservers(){
        for(Observer observer:observers){
            observer.update();
        }
    }


}

2. 设计一个抽象类 Observer （观察者母类）

package DesignPattern.ObServer;
public abstract class Observer{
    protected Subject subject;
    public abstract void update();
}

3.设置三个观察者

BinaryObserver

package DesignPattern.ObServer;
//实体观察者
public class BinaryObserver extends Observer{
    public BinaryObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        System.out.println("Biary String: "+Integer.toBinaryString(subject.getState()));
    }
}

HexObserver

package DesignPattern.ObServer;

import java.net.Inet4Address;

public class HexObserver extends Observer{
    public HexObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Hex Observer: "+ Integer.toHexString(subject.getState()));
    }
}

OctalObserver

package DesignPattern.ObServer;

public class OctalObserver extends Observer{
    public OctalObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Octal Observer: "+Integer.toOctalString(subject.getState()));
    }
}

4 .ObserverPatternDemo 使用 Subject 和实体观察者对象

package DesignPattern.ObServer;
//使用 Subject 和实体观察者对象
public class ObserverPatternDemo{
    public static void main(String[] args) {
        Subject subject = new Subject();
        new BinaryObserver(subject);
        new OctalObserver(subject) ;
        new HexObserver(subject);
        System.out.println("first state change 15");
        subject.setState(15);
        System.out.println();

        System.out.println("second state change 10");
        subject.setState(10);

    }

}

测试结果

3.4 装修器设计模式

装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构，这种是设计模式属于结构性模式，他是对现有类的一个包装。

**目的：**动态的给对象添加一些额外的功能职责。就添加功能来说，装饰器模式相比于生成子类更为灵活。

**主要解决：**一般的，我们会为了扩展一个类，经常使用继承的方式实现，由于继承引入静态特征，并且随着扩展功能的增多，子类会越来越膨胀。