何为代理模式？代理，顾名思义可联想到代理人，代理人是干啥子的，帮别人做某件事的，且可能会根据一些具体的情况，做一些具体的处理。大概如此吧。

定义与作用

它提供了对目标对象另外的访问方式;即通过代理对象访问目标对象。代理对象是对目标对象的扩展,并会调用目标对象。

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

实现

静态代理

简而言之，就是代理对象与被代理对象都实现同一接口，在代理对象中，调用被代理对象的相应方法，并加上一些自定义的其它操作，要使用被代理对象的方法时，只需要调用代理对象的相应方法即可。

缺点：如果增加接口中的方法，那么代理对象以及被代理对象都需要进行相应的修改，难以维护。

动态代理

不需要实现接口，利用JDK的API，在内存中动态地创建代理对象。代理对象不需要实现接口,但是被代理对象一定要实现接口,否则不能用动态代理。

代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
其中三个参数的含义依次为:

• ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
• Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
• InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

代码示例:

接口类IUserDao.java以及接口实现类,目标对象UserDao是一样的,没有做修改.在这个基础上,增加一个代理工厂类(ProxyFactory.java),将代理类写在这个地方,然后在测试类(需要使用到代理的代码)中先建立目标对象和代理对象的联系,然后代用代理对象的中同名方法

代理工厂类:ProxyFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

   //给目标对象生成代理对象
    public Object getProxyInstance(){
        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("开始事务2");
                        //执行被代理对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }

}

测试类:App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.save();
    }
}

其实对于上面的写法，有一个小小的疑问，如果接口中存在多个函数，那么这种做法是会为很一个函数都执行相同的附加操作，如果对每个函数做不同的操作呢？利用Method的属性加以区别，然后对每个函数做分别处理？这样处理可以不。。

参考：https://www.cnblogs.com/cenyu/p/6289209.html

有很多关于单例模式的博客，书上也有些介绍，了解它也算挺久了。但是部觉得少了点什么，怕自己记了，也怕自己后面找起来麻烦，所以还是写一篇博客来记录一下吧。

单例模式的概念

我的认识是这样，可能不是非常标准，一点自己的想法，不想copy而已：

1. 只有一个实例
2. 构造方法为private， 无法被直接实例化；类中持有一个本类的静态私有对象，并提供静态方法给外界提供访问。

实现方式

不同的方式有不同应用场景，可以按需要选择。其实我还是有个小小的疑问，就是关于饿汉式，instance实例化的时机是当前类被引用的时候，可以认为是在调用getInstance()的时候 ，此时类中的变量按照相应的初始化顺序，依次初始化。这样的话，就和懒汉式的效果是一样的了=.=可能是我的想法不太对吧

饿汉式

即初始化类的时候就创建好实例，不用担心多线程的环境下出现问题，但是有可能浪费资源。

1
2
3
4
5
6
7

public class SingletonHangry {
    private static SingletonHangry instance;
    private SingletonHangry(){}
    public static SingletonHangry getInstance(){
        return instance;
    }
}

懒汉式

即在被需要时才创建实例，这在并发的环境下会出现一些问题。

• 不加任何措施
  脑洞一下，都知道这个不一定是只有一个实例。

  1 2 3 4 5 6 7 8 9

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

• 加上同步锁
  虽然这样就保证了只有一个实例，但是这个同步锁在每次调用getInstance()时都会工作，而显然这些同步工作中非常大的一部分是不需要的。所以在性能上必定会有所损失。

  1 2 3 4 5 6 7 8 9

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

• Double Check Lock（DCL）
  说起这个，我刚开始的时候只了解到这有两个if。后来才知道这就是大名鼎鼎的DCL，失敬失敬！

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  class SingletonLazy { private SingletonLazy(){} private static volatile SingletonLazy instance; public static SingletonLazy getInstance(){ if (instance == null) { // 使用这个if是为了在instance已被初始化之后，避免同步 synchronized (SingletonLazy.class) { if (instance == null) { // 这个if是为了因为，如果同时有两个进程A,B执行了getInstance()，它们是都会有机会通过第1个if， // 也就是说会依次执行同步锁里面的内容。因此没有这个if也是有可能不能保证单例的。 instance = new SingletonLazy(); } } } return instance; } }

  至于那个关键字volatile，与Java中的内存模型有关，加上了这个才能保证单例。它大致做的事情是这样的：
  instance = new SingletonLazy()并非是原子操作，事实上在JVM中这句话做了三件事：

1.给instance分配内存
2.调用SingletonLazy()的构造函数来初始化成员变量
3.将instance对象指向分配的空间（执行完这一步instance就不为null）

但是在JVM的即时编译器中存在指令重排序的优化，也就是说上面的第二步和第三步是不能保证顺序的，最终执行的顺序可能是1-2-3或者是1-3-2。如果是后者，则在3执行完毕，2执行之前，被线程2抢占了，这时instance已经是非null了（但却没有初始化），所以线程2会直接返回instance，然后使用，然后会报错。使用了volatile就保证了：取操作必须在执行完1-2-3之后或者1-3-2之后，不存在执行到1-3然后取到值的情况。

• 静态内部类
  因为类的初始化是虚拟机保证只加载一次，因此是线程安全的。

  1 2 3 4 5 6 7 8 9

  class SingletonStaticInnerClass { static class SingletonHolder { private final static SingletonStaticInnerClass instance = new SingletonStaticInnerClass(); } private SingletonStaticInnerClass(){} private static SingletonStaticInnerClass getInstance(){ return SingletonHolder.instance; } }

• 枚举
  枚举的相信息：http://blog.csdn.net/u013256816/article/details/50562905

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  enum SingletonEnum { INSTANCE1, INSTANCE2; class Singleton { private Singleton(){} } private Singleton instance; private SingletonEnum(){ instance = new Singleton(); } public Singleton getInstance() { return instance; } } public static void main(String[] args) { SingletonEnum.INSTANCE1.getInstance(); SingletonEnum.INSTANCE2.getInstance(); }

容器

这个有点迷