常用设计模式(继续更新中...)

1. 设计模式七大原则

1.1 单一职责原则

1.2 接口隔离原则

1.3 依赖倒转原则

1.4 里氏替换原则

1.5 开闭原则

1.6 迪米特原则

1.7 合成复用原则

2. UML类图

2.1 依赖关系

2.2 泛化(继承)关系

2.3 实现关系

2.4 关联关系

2.5 聚合关系

2.6 组合关系

3. 设计模式

3.1 单例模式

饿汉式

class Singleton{
    //1.构造器私有，外部不能new对象
    private Singleton(){}
    //2.本类内部创建对象实例
    private final static Singleton instance=new Singleton();
    //3.提供静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }

懒汉式（线程不安全，一般不使用）

class Singleton{
    private static Singleton instance;
    private Singleton(){}
    //当使用方法时，才去创建对象，懒汉式
    public static Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

懒汉式（线程安全，同步方法，不推荐使用）

class Singleton{
    private static Singleton instance;
    private Singleton(){}
    //当使用方法时，才去创建对象，懒汉式，解决线程安全问题
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

双重检查（推荐使用）

//双重检查,解决线程安全问题，同时解决懒加载问题
class Singleton{
    private static volatile Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
    }

静态内部类（推荐使用）

//静态内部类实现
class Singleton{
    //构造器私有
    private Singleton(){}
    //静态内部类，有静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE=new Singleton();
    }
    //提供静态的公有方法，直接返回实例
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

使用说明

3.2 代理模式

静态代理

public interface ITeacherDao {
    void teach();
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师授课中");
    }
}

public class TeacherDaoProxy implements ITeacherDao {
    //目标对象，通过接口聚合
    private ITeacherDao target;

    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("开始代理");
        target.teach();
        System.out.println("代理结束");
    }
}

public class Client {
    public static void main(String[] args) {
        //创建目标对象（被代理对象）
        TeacherDao teacherDao = new TeacherDao();
        //创建代理对象，同时将被代理对象传给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
        //通过代理对象，调用被代理对象的方法
        //执行的是代理对象的方法，代理对象再调用目标对象的方法
        teacherDaoProxy.teach();
    }
}

动态代理（JDK代理，接口代理）

public interface ITeacherDao {
    void teach();
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("teaching...");
    }
}

public class ProxyFactory {
    private Object target;
    //构造器，对target初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }
    //给目标对象生成代理对象
    public Object getProxyInstance(){
        //参数1 指定当前目标对象使用的类加载器
        //参数2 目标对象实现的接口类型
        //参数3 增强方法
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("jdk代理开始");
                //反射机制调用目标对象的方法
                Object val = method.invoke(target, args);
                System.out.println("jdk代理结束");
                return val;
            }
        });
    }
}

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        ITeacherDao target = new TeacherDao();
        //为目标对象创建代理对象
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
        //class com.sun.proxy.$Proxy0 动态生成代理对象
        System.out.println(proxyInstance.getClass());
        proxyInstance.teach();

    }
}

运行结果

cglib代理

public class TeacherDao {
    public void teach(){
        System.out.println("teaching...cglib..no interfaces");
    }
}

public class ProxyFactory implements MethodInterceptor {
    private Object target;
    //构造器，传入一个被代理对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before");
        method.invoke(target,args);
        System.out.println("after");
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        ProxyFactory proxy = new ProxyFactory(new TeacherDao());
        TeacherDao dao = (TeacherDao) Enhancer.create(TeacherDao.class, proxy);
        dao.teach();
    }
}

运行结果