【单例模式和代理模式】

单例模式

单例模式：就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个获取其对象实例的方法。

比如Hibernate的SessionFactory，它充当数据存储源的代理，并且负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这就是单例模式。

单例模式的八种写法：
①饿汉式（静态常量）
②+饿汉式（静态代码块）
③懒汉式（线程不安全）
④懒汉式（线程安全，同步方法）
⑤懒汉式（线程安全，同步代码块）
⑥双重检查
⑦静态内部类
⑧枚举

饿汉式（静态常量）应用案例
步骤如下：
①构造器私有化
②类的内部创建对象
③向外暴露一个公有的静态方法
④代码实现

代码举例：
class singleton{
    // ①构造器私有化
    private singleton(){}
    // ②类的内部创建对象
    private static singleton instance=new singleton();
    // ③向外暴露一个公有静态方法
    public static singleton getInstance(){
        return instance;
    }

}

该方法的优缺点：单例模式可用，可能会造成内存的浪费。

优点：①写法简单，在类加载时候就完成了实例化，避免了线程同步问题。
缺点：①在类加载时候就完成实例化，没有达到lazy loading的效果，如果从未使用过这个实例，则会造成内存的浪费。

饿汉式（静态代码块）应用案例
步骤如下：
①构造器私有化，外部能new
②本类内部创建实例对象
③提供一个公有的静态方法，返回实例对象

代码示例：
//饿汉式（静态代码块）应用案例
//        步骤如下：
//        ①构造器私有化，外部能new
//        ②本类内部创建实例对象
//        ③提供一个公有的静态方法，返回实例对象
//        ④代码实现
class singleton{
    // ①构造器私有化,外部能new
    private singleton(){

    }
    // ②本类内部创建实例对象
    private static singleton instance;

    static {
        // 在静态代码块中创建单例对象；
        instance=new singleton();
    }
    // ③向外暴露一个公有静态方法
    public static singleton getInstance(){

        return instance;
    }

}

优缺点：和静态常量相同，只不过将类实例化的过程放在了静态代码块中。
单例模式可用，但是可能造成浪费。

懒汉模式1（线程不安全）

代码示例：

class singleton{
    // ②本类内部创建实例对象
    private static singleton instance;
    // ①构造器私有化,外部能new
    private singleton(){
    }

    // ③向外暴露一个公有静态方法
    public static singleton getInstance(){
        if (instance==null){
            instance=new singleton();

        }

        return instance;
    }

}

优缺点说明：
①起到了lazy loading效果，但只能在单线程下使用。
②如果在多线程下，会引发多线程安全问题产生多个实例，所以只能在单线程模式使用。
③实际开发中不要使用这种方法！

懒汉式（线程安全，同步方法）
    相比于第一种不安全的写法，加入了同步处理避免线程安全问题：
代码示例：
class singleton1 {
    // ②本类内部创建实例对象
    private static singleton1 instance;
    // ①构造器私有化,外部能new
    private singleton1(){
    }

    // ③向外暴露一个公有静态方法,加入了synchronized关键字，同步处理方法；
    public static synchronized singleton1 getInstance(){
        if (instance==null){
            instance=new singleton1();

        }

        return instance;
    }

}
小结：该写法解决了线程不安全问题但是同步效率太低了，其实这个方法只要执行一次实例化代码就行了，开发中不推荐使用这种写法。

 
懒汉式（线程安全，同步代码块）
不能解决线程安全问题，在开发中不能用这个写法。
代码示例：
class singleton2 {
    // ②本类内部创建实例对象
    private static singleton2 instance;
    // ①构造器私有化,外部能new
    private singleton2(){
    }

    // ③向外暴露一个公有静态方法,
    public static  singleton2 getInstance(){
        if (instance==null){
            //将同步处理加入代码块不能起到解决线程安全问题，开发中不能使用！
            synchronized (singleton2.class){
            instance=new singleton2();}

        }

        return instance;
    }

}

双重检查（推荐使用）：
关键字volatile：能让修改立即更新到主存。
class singleton2 {
    // ②本类内部创建实例对象，volatile能让修改立即返回主存
    private static volatile singleton2 instance;
    // ①构造器私有化,外部能new
    private singleton2(){
    }

    // ③向外暴露一个公有静态方法,加入关键字 synchronized 和双重检查代码，解决了线程安全问题同时解决了懒加载问题
    public static synchronized singleton2 getInstance() {
        if (instance == null) {
            //将同步处理加入代码块，提高效率
            synchronized (singleton2.class) {
                if (instance == null) {
                    instance = new singleton2();
                }

            }

        }
        return instance;

    }
}
小结：double-check（双重检查）是多线程开发里面经常用到的写法，进行了两次if（singleton==null）检查，就可以保证线程安全了。
同时实例化代码块只用执行一次，再次访问时，判断if（singleton==null）会直接return实例化对象，避免反复进行同步。
线程安全，延迟加载，效率较高，推荐使用。

静态内部类应用实例：

class singleton2 {
    // ②本类内部创建实例对象，volatile能让修改立即返回主存
    private static volatile singleton2 instance;

    // ①构造器私有化,外部能new
    private singleton2() {
    }

    private static class singleton2Instance {
// 写一个静态内部类，该类有一个静态属性singleton2
        private static final singleton2 INSTANCE = new singleton2();

    }

    //  ③向外暴露一个公有静态方法,加入关键字 synchronized
    public static synchronized singleton2 getInstance() {

        return singleton2Instance.INSTANCE;

    }
}

小结：
①这种方式采用了类加载的机制来保证初始化实例时只有一个线程。
②静态内部类在singleton类被加载时并不会立即被实例化，而是在需要实例化的时候调用getInstance方法才会装在singletonInstance类，从而完成singleton的实例化。
③类的静态属性只会在第一次加载类的时候初始化，所以在这里JVM帮助我们保证了线程的安全性，在类进行初始化的时候，别的线程无法进入。
④避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。推荐使用。

枚举方式：
代码示例：
enum singleton{
    INSTANCE;
    public void sayOK(){
        System.out.println("OK~");
    }

}
小结：
①借助jdk1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题而且还能防止反序列化重新创建对象。
②推荐使用
 

单例模式：在jdk中，runtime就是经典的单例模式。

代理模式：

反射应用。

①原理：代理模式给一个对象提供一个替身，可以控制对这个对象的访问。即通过代理对象访问目标对象。

②好处：可以在实现目标对象的基础上增强额外的功能操作，即扩展对象的功能。

③：被代理的对象可以是远程对象、创建开销大的对象或者需要安全控制的对象。
④代理模式又是那种不同的的形式：静态代理、动态代理和Cglib代理。

动态代理：jdk代理，接口代理
Cglib代理：可以在内存动态创建对象，而不需要实现接口。

⑤静态代理：在使用静态代理时需要定义接口或者父类，被代理对象即目标对象与代理对象一起实现相同的接口或是继承相同父类。
 jdk中生成代理对象的API：

①代理类所在的包：java.lang.reflect.proxy

②jdk实现代理只需要使用newProxyInstance方法，该方法需要接受三个参数，完整写法是：

static object newProxyInstance（ClassLoad loader，Class<?>[]interfaces, InvocationHandler h）

Cglib代理：

Cglib代理也叫子类代理，他是在内存中构建一个子类对象从而实现对目标对象的功能扩展（d动态代理）
Cglib是一个强大的代码生成包，他可以在运行期扩展java类实现java接口，它广泛的被许多AOP的框架广泛使用，例如Spring AOP,实现方法拦截。

在AOP编程汇总如何选择代理模式：

①目标对象需要接口实现用jdk代理
②目标对象不需要接口实现，用Cglib代理。

注：
①Cglib的底层是通过使用字节码处理框架ASM来转换字节码来生成新的类。
②不能代理final类
 
几种变体：
①防火墙代理
通过代理穿透防火墙，实现对公网的访问。

②缓存代理
当请求图片文件资源时，先到缓存代理取，如果取到资源就OK反之再到公网数据库取并且缓存。

③远程代理
把远程对象当本地对象用。

④同步代理
应用于多线程编程，完成多线程间同步工作。