设计模式

一、单例模式Singleton

特点：

　　1、单例类只能有一个实例

　　2、单例类自己创建自己的唯一实例

　　3、单例类必须给整个系统提供这个实例

饿汉式：

public class Singleton {
    private static final Singleton singleton=new Singleton();
    private Singleton(){
    }
    public static Singleton getSingleton(){
        return singleton;
    }
}

　　优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题

　　缺点：没有延迟加载在类装载的时候就完成了实例化，如果没有使用过实例，就会造成内存浪费

懒汉式：线程不安全

　　1、构造函数私有化

　　2、类中初始化一个私有的静态常对象

　　3、通过get方法获取该实例

public class Singleton {
    private static final Singleton singleton=null;
    private Singleton(){
    }
    public static Singleton getSingleton(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

 

二、原型模式prototype：通过拷贝指定的原型实例，创建和该对象一样的新对象

深拷贝：不仅复制成员变量中 基本数据类型的值，还会给引用数据类型的成员变量申请存储空间，这样拷贝出来的新对象不会对原来造成影响

浅拷贝：1、当成员变量是基本数据类型时，复制值  2、当成员变量是引用数据类型，复制引用数据类型的地址值

【注】

　　1、Object类中提供的clone都是浅拷贝，可以把String当作基本类

　　2、使用clone方法，类的成员变量不能增加final关键字

实现Cloneable接口，当作原型

public class PrototypeClass implements Cloneable{
    @Override
    protected PrototypeClass clone() throws CloneNotSupportedException {
        PrototypeClass prototypeClass=null;
        prototypeClass= (PrototypeClass) super.clone();
        return prototypeClass;
    }
}

三、中介者模式Mediator：用一个中介对象封装一系列对象交互，使各对象不需要显示的相互作用，从而使其耦合松散

抽象中介者：定义同事类，定义对象之间交互的业务方法

public abstract class Mediator {
    protected ConcretedColleague1 c1;
    protected ConcretedColleague2 c2;

    public ConcretedColleague1 getC1() {
        return c1;
    }

    public void setC1(ConcretedColleague1 c1) {
        this.c1 = c1;
    }

    public ConcretedColleague2 getC2() {
        return c2;
    }

    public void setC2(ConcretedColleague2 c2) {
        this.c2 = c2;
    }
    //定义对象之间的交互
    public abstract void doSomething1();
    public abstract void doSomething2();
}

通用中介者：实现对象之间的交互

public class ConcreteMediator extends Mediator{
    @Override
    public void doSomething1() {
        super.c1.method1();
        super.c1.method2();
    }

    @Override
    public void doSomething2() {
        super.c2.method1();
        super.c2.method2();
    }
}

抽象同事类：每个同事都知道中介者

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

具体同事类：处理自己的业务逻辑 自己不能处理的交给中介者处理

public class ConcretedColleague1 extends Colleague{
    public ConcretedColleague1(Mediator mediator) {
        super(mediator);
    }

    public void method1() {
    }

    public void method2() {
    }
    public void deMethod1(){
        super.mediator.doSomething1();
    }
}

优点：减少了类间的依赖，只依赖中介者，同时降低了类间的耦合

缺点：中介者会很膨胀

四、责任链模式Handler：使多个对象都有机会处理请求，将对象连成一条链，并沿着这条链传递请求

抽象处理者实现三个职责，请求处理方法handleMessage，设置下一个处理者，定义具体请求者实现的方法包括：定义自己处理的级别和具体的处理任务

 

public abstract class Handler {
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    private Handler nextHandler;
    public final Response handleMessage(Request request){
        Response response=null;
        if(this.getHandlerLevel().equals(request.getRequestLevel())){
            response=echo(request);
        }
        else {
            if(this.nextHandler!=null){
                response=this.nextHandler.handleMessage(request);
            }
            else {
                //没有处理者
            }
        }
        return response;
    }
    protected abstract Level getHandlerLevel();
    protected abstract Response echo(Request request);

}

 

应用：HandlerExecutionChain

mappedHandler = getHandler(processedRequest);

每个Handler为HandlerExecutionChain 它为一个处理链，负责处理整个请求。HandlerExecutionChain主要负责请求的拦截器的执行和请求的处理，但是他本身不处理请求，只是将请求分配给在链上注册的处理器执行。HandlerExecutionChain维护了HandlerInterceptor(拦截器)的集合。

private final List<HandlerInterceptor> interceptorList = new ArrayList<>();

 

 

五、代理模式Proxy：为其他对象提供一种代理 以控制对这个对象的访问

（1）静态代理：在程序运行前，代理类和被代理类的关系已经确定。（组合关系）

  公共接口

public interface Service {
    public void add();
    public void remove();
    public void update();
    public void insert();
}

　被代理类：具体实现

public class ServiceImpl implements Service{
    @Override
    public void add() {
        System.out.println("添加了一个对象");
    }

    @Override
    public void remove() {
        System.out.println("删除了一个对象");
    }

    @Override
    public void update() {
        System.out.println("更新了一个对象");
    }

    @Override
    public void insert() {
        System.out.println("查询了一个对象");
    }
}

 静态代理类（组合）

public class Proxy implements Service{
    private ServiceImpl service;

    public void setService(ServiceImpl service) {
        this.service = service;
    }

    @Override
    public void add() {
        log("增加");
        service.add();
    }

    @Override
    public void remove() {
        service.remove();
    }

    @Override
    public void update() {
        service.update();
    }

    @Override
    public void insert() {
        service.insert();
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"操作");
    }
}

（2）动态代理

  1、JDK动态代理：基于接口

　生成动态代理类 ，通过invoke()方法来调用方法，通过Proxy.newProxyInstance来创建代理类对象

public class ProxyHandler implements InvocationHandler {
    private Service service;

    public void setService(Service service) {
        this.service = service;
    }
    //生成动态代理对象，利用反射，第一个参数是被代理类的类加载器，第二个参数是被代理类接口，第三个参数InvocationHandler的实现类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), service.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object res=method.invoke(service,args);
        return res;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}