设计模式随笔

六大原则

单一原则，开闭原则，里氏代换，依赖倒置，接口隔离，迪米特原则

1. 开闭原则是目标，里氏代换原则是基础，依赖倒转原则是手段
2. 里氏替换，迪米特原则可增加程序的扩展性
3. 依赖倒置，接口隔离可增加程序的灵活性
4. 主要的目标就是实现程序的解耦，同时增加程序的内聚性

设计模式

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

单例的七种模式

双重校验模式

public class Singleton{
    private static Singleton instance;
    private Singleton() {}
    public static synchronized Singleton getInstance();
    if (instance == null){
        synchronized(Singleton.class){
            if (instance==null){
                instance = new Singleton();
            }
        }
    }
    return instance;
}

枚举模式

public enum Singleton{
    INSTANCE;
    public void whatevermethod(){}
}

除了上述的两种方法，还有一些例如饿汉模式，饱汉模式等等，可一一了解。

代理模式

代理模式主要指通过继承与被代理类相同的接口，并通过反射的方式验证被代理类，生成代理对象。从而是的代理对象可以实现与代理类一样的功能。同时还可以在代理功能的基础上进行额外的操作

静态代理模式

//学生借口类
public interface Person {
    public void giveMoney();
}

//学生类
public class Student implements Person{
    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name+"交了班费！");
    }
}

//静态代理类
public class StudentProxy implements Person {
    Student person;

    public StudentProxy(Student person) {
        if (person.getClass() == Student.class) {
            this.person = person;
        }
    }

    @Override
    public void giveMoney() {
        person.giveMoney();
    }

}

//测试类
public class TestStudentProxy {
    public static void main(String[] args) {
        Student person=new Student("张三");

        StudentProxy monitor = new StudentProxy(person);
        monitor.giveMoney();
    }
}

动态代理模式

//学生借口类
public interface Person {
    public void giveMoney();
}

//学生类
public class Student implements Person{
    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name+"交了班费！");
    }
}

//动态代理类
public class StuInvocationHandler<T> implements InvocationHandler {
    T targat;

    public StuInvocationHandler(T targat) {
        this.targat = targat;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("----代理开启---");
        method.invoke(targat, args);
        return null;
    }
}

//测试类
public class TestStudentProxy {
    public static void main(String[] args) {
        Student person=new Student("张三");

        InvocationHandler stuHandler = new StuInvocationHandler<Student>(person);
        Student stuProxy = (Student) Proxy.newProxyInstance(Student.class.getClassLoader(), new Class<?>[]{Student.class}, stuHandler);
        stuProxy.giveMoney();
    }
}

我们上面静态代理的例子中，代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。当然，在代理过程中，我们在真正执行被代理对象的方法前加入自己其他处理。这也是++Spring中的AOP实现++的主要原理，这里还涉及到一个很重要的关于java反射方面的基础知识。