设计模式笔记

工厂模式

解释: (这种说法存在疑问: 因为abs抽象类可以直接去掉, 等到后面看spring源码的时候在说), 快速创建同一个类的不同的实现的, 并隐藏该类的创建过程, 直接获取, 随着类的越来越多, 分类的越来越复杂, 工厂开始专业化, 因此出现了工厂的分类, 因此出现了工厂的分类, 抽象工厂模式

abstractFactory {
    getA()
    getB()
    getC()
}

factory extends abstractFactory {
    getA(){...}
    getB(){...}
    getC(){...}
}

这里使用抽象类的主要原因是, 抽象类中可以实现一些公共的逻辑, 又
可以添加继承类必须要实现的方法, 这种模式是在spring中使用的最多的;

单例模式

主要是保证在项目中只有一个实例, 保证线程的安全, 同时系统节省开销.

饿汉式

不论用不用都先new出来, 这种的可以保证线程安全, 但是增加系统开销
但是使用序列化和反序列化的时候, 还是可以获取到两个实例, 可以在类中添加

readResolve() {
    return a;
}

方法来避免;

class A {
    private A () {}
    private static final A a = new A()
    public static A getInstance() {
    return a;
}

}

懒汉式

用的时候在new, 会存在线程安全问题, 和指令重排序问题

class A {
    private V () {}
    private static final A a = null
    public static A getInstance() {
        if(a == null) {
            return new A();
        }
        return a;
    }
}

解决的方法:
a). 使用double check+volatile
b). 或者使用静态内部类: 主要是因为静态内部类不论外部类被加载
多少次, 他只加载一次(可以使用反射来多次获取)

class A {
    private V () {}
    public static A getInstance() {
        return B.a
    }

    private static class B {
        private static final A a = new A()
    }
}

注册式单例

将对象向同一个容器中注册, 下次使用时直接从容器中获取, spring中使用的就是注册式单例, 需要使用currentHashMap();

原型模式

深复制和浅复制问题
深复制可以使用字节码来实现, readObject

代理模式(spring实现AOP的主要方法)

a). 普通的代理模式(缺点, 只能帮有限的对象进行代理, 存在局限性)

class son {
    findLove()
}

class proxy {
    proxy() {
        son传入
    }
    findLove() {
        ...
        son.findLove
        ...
    }
}

b). jdk的动态代理

class son implement Person{
    findLove()
}

class Proxy implement InvocationHandler {
    Proxy () {
        传入对象son
    }
    invoke(...) {
        ...
        method.invoke(son, args)
        ...
    }
}

使用方法

Son son = new Son()
Proxy proxy = new Proxy(son)
Person person = (Person)Proxy.newProxyInstance(son.getClass.getClassLoader,son.getClass.getInterfaces,proxy)
person.findLove()

实现的原理

就是使用重新生成类的字节码方法, 获取到被代理类的引用, 然后使用代理类, 重新生成字节码, 并在字节码中加入要实现的方法;

c). cjlib代理方法

public class Dao {
    public void update() {
        System.out.println("PeopleDao.update()");
    }

    public void select() {
        System.out.println("PeopleDao.select()");
    }
}

public class DaoProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object object, Method method, Object\[\] objects, MethodProxy proxy) throws Throwable {
        System.out.println("Before Method Invoke");
        proxy.invokeSuper(object, objects);
        System.out.println("After Method Invoke");
        return object;
    }
}

使用方法

DaoProxy daoProxy = new DaoProxy();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Dao.class);
enhancer.setCallback(daoProxy);
Dao dao = (Dao)enhancer.create();
dao.update();
dao.select();

策略模式及模板模式(待补充)

委派模式和适配器模式

委派模式 : 是静态代理的一种特殊情况, Delegate和dispacher开头的是委派模式
实现方式

class ServletDispacher {

    //list中保存了需要被委派的对象
    ArrayList<Handler> handlers = new ArrayList<>();
    doDispacher () {
        //该方法中, 进行相关的逻辑判断, 来选择要让哪个Handler来去执行这个任务
    }

    class Handler {
        ...
    }
}

java Web中的Servlet就是使用的这种模式来接受请求, 并发送给对应的controller去执行的相关请求;

适配器模式

可以想象成一种电源转化器, 主要是在不改变原有功能的基础上, 对当下的业务做兼容,实现的方法

class Login {
    login(){}
}

class ThirdLogin extends Login{
    webLogin () {
        //处理相关逻辑
        super.login()
    }
    qqLogin () {
        //处理相关逻辑
        super.login()
    }
}

装饰者模式和观察者模式

装饰者模式

和适配器模式优点类似, 装饰者模式应用最典型的是java的inputStream和outputStream,而和适配器模式根本区别就是, 不论新对象如何装饰, 他们的顶层都是实现了InputStream的接口, 而且在实现的时候, 可以覆盖原来的方法, 是方法功能更强大, 可以将装饰者模者模式理解成特别的适配器模式;

观察者模式

顾名思义: 就是一个观察者, 在监听一个主题, 当这个主题发生改变或者发出消息时, 将消息发送给已经订阅该主题的订阅者

class Subject {
    List observer ...;
    add(){}
    remove(){}
    advice() {
        //遍历observer
        //然后observer.update()
    }
}

//具体的主题

class ConcreteSubject {
    dosomeThing () {
        ...
        super.advice() {}
    }
}

interface Observer {
    update()
}

具体的观察者

class ConcreteObserver implement Observer{
    uodate () {
        ...
    }
}

使用方法

Observer observer = new ConcreteObserver()
Subject subject = new ConcreteSubject()
subject.add(observer)
subject.dosomeThing();

这段代码有代码的入侵, 可以考虑使用动态代理来减少代码的侵入, 降低
耦合度;

以上内容只是一个大概的目录, 后续会继续修改;