几种常见的设计模式

1.单例模式

    单例模式保证某个类只存在一个实例。在设计某些工具类的时候，不需要属性，只有方法。

要点1.构造函数私有化   2.提供创建实例的方法  3.依赖自身。常见的实现有饿汉式与懒汉式两种

饿汉式

//饿汉式 类被加载后创建，在内存中生命周期较长
public class MySingleTon {
    private static MySingleTon my = new MySingleTon();
    private MySingleTon(){}
    public static MySingleTon getInstance(){
        return my;
    }
}

懒汉式（使用DCL,线程安全、高效率）

public class MySingletonLazy {
    private static volatile MySingletonLazy my;
    private MySingletonLazy(){}
    public static MySingletonLazy getInstance(){
        if(my==null){
            synchronized(MySingletonLazy.class){
                if(my==null)
                    my = new MySingletonLazy();
            }
        }
        return my;
    }
}

2.工厂模式

java中最常用的设计模式之一，提供了创建对象的最佳模式，不对客户端暴露创建类的逻辑，通过共同的接口指向新创建的对象。工厂模式要解决的问题：使调用者与被调用者解耦，面向接口编程，将创建对象的工作转移到了工厂中，Spring框架使用工厂来解决创建对象，Java.util.Calendar,ResourceBundle和 NumberFormat中使用了工厂方法模式，valueOf()在包装类中也使用了工厂方法模式

3.代理模式

    为对象提供一种代理来控制对象的访问，常用来实现日志以及缓存操作。

   静态代理，代理类与被代理类实现同一个Subject接口，Proxy实际中调用被代理对象的方法。

动态代理，代理对象的类是通过动态方式来自动生成的，这样的好处是，我们不需要每次为被代理对象单独创建代理类，JDK API 中，对动态代理模式提供了支持java.lang.reflect.Proxy:生成动态代理类和对象；
java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现对真实角色的代理访问。
每次通过 Proxy 生成的代理类对象都要指定对应的处理器对象。

package design.dymProxy;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
public class TicketProxy implements  InvocationHandler{
    Object target;

    Object create(Object target){
        this.target = target;
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
        return proxy;
    }
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        method.invoke(target);
        return null;
    }
}

CGLIB实现动态代理
CGLIB是高性能的代码生成包。可以为没有实现接口的类提供代理，是JDK动态代理必须要有接口的补充。
通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。
CGLIB作为一个开源项目，代码托管在github，地址为：https://github.com/cglib/cglib