Java常用设计模式

什么是设计模式?

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式的分类？

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

并发型模式和线程池模式。

 

本文涉及的常用设计模式有：

①单例模式(懒汉式、饿汉式)

②代理模式(静态代理、jdk动态代理、cglib代理)

 

 

单例模式

简而言之就是所在jvm中只存在一个对象的实例。

之前我写过一篇文章介绍了《单例模式》，此处不再重写了。

 

 

代理模式分为：静态代理和动态代理(jdk代理和cglib代理)

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

举个例子，我们生活中经常到火车站去买车票，但是人一多的话，就会非常拥挤，于是就有了代售点，我们能从代售点买车票了。这其中就是代理模式的体现，代售点代理了火车站对象，提供购买车票的方法。

静态代理模式

创建房子接口

interface House{
	void getHouse();
}

 

package cn.itcats.proxy;



/**
 * 买房的人
 * @author fatah
 */
class Buyer implements House{
	public void getHouse() {
		System.out.println("买主买到房子............");
	}
}


/**
 * 静态代理类
 * @author fatah
 */
public class StaticProxy implements House{
	//获得买主对象
	private Buyer buyer;
	
	//添加代理类构造(参数为买主)
	public StaticProxy(Buyer buyer){
		this.buyer = buyer;
	}
	
	public void getHouse() {
		System.out.println("中介联系卖家");
		buyer.getHouse();
		System.out.println("中介完成交易");
	}
	
	
	/**
	 * 测试
	 */
	public static void main(String[] args) {
		House house = new StaticProxy(new Buyer());
		house.getHouse();
	}
}

运行结果：

中介联系卖家
买主买到房子............
中介完成交易

 

总结静态代理的优缺点：

这种代理方式需要生成代理对象且代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：

1. 冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
2. 不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

 

动态代理

jdk动态代理(实现InvocationHandler)

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

• 静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
• 动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

 

JDK中生成代理对象主要涉及的类有

• java.lang.reflect Proxy，主要方法为

static Object    newProxyInstance(ClassLoader loader,  //指定当前目标对象使用类加载器

 Class<?>[] interfaces,    //目标对象实现的接口的类型
 InvocationHandler h      //事件处理器
) 
//返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

• java.lang.reflect InvocationHandler，主要方法为

 Object invoke(Object proxy, Method method, Object[] args) 
// 在代理实例上处理方法调用并返回结果。

具体代码实现：

package cn.itcats.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * JDK动态代理
 * @author fatah
 */
public class JdkDynamicProxy implements InvocationHandler{
	//此处跟静态代理一致,声明成员变量target,为了通用就不写Buyer了
	private Object target;
	//代理类构造函数(参数 obj)
	public JdkDynamicProxy(Object target){
		this.target = target;
	}
	
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("中介联系卖家");
		Object invokeObject = method.invoke(target, args);
		System.out.println("中介完成交易");
		return invokeObject;
	}
	
	public static void main(String[] args) {
		Buyer buyer = new Buyer();
		JdkDynamicProxy proxy = new JdkDynamicProxy(buyer);
		House house = (House) Proxy.newProxyInstance(buyer.getClass().getClassLoader(), buyer.getClass().getInterfaces(),proxy);
		house.getHouse();
	}
}

 

cglib代理(实现MethodInterceptor)

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点

• JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
  如果想代理没有实现接口的类，就可以使用CGLIB实现。
• CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
  它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
• CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
  不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与jdk动态代理最大的区别就是

JDK动态代理只能对实现了接口的类生成代理，而不能对类进行代理

CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承）

Spring使用JDK还是CGlib的依据：

   (1)当Bean实现接口时，Spring就会用JDK的动态代理

   (2)当Bean没有实现接口时，Spring使用CGlib是实现

   (3)可以强制使用CGlib（在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）

 

 Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。    

JDK动态代理只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（应用Java的反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用invokeHandler方法来处理。    

CGLib动态代理需要依赖asm包，把被代理对象类的class文件加载进来，修改其字节码生成子类。

 

CGlib比JDK快？

　 (1)使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。唯一需要注意的是，CGlib不能对声明为final的方法进行代理，因为cglib原理是动态生成被代理类的子类。

　 (2)在对JDK动态代理与CGlib动态代理的代码实验中看，1W次执行下，JDK7及8的动态代理性能比CGlib要好20%左右。

　　

 

package cn.itcats.proxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;


/**
 * 买房的人
 * @author fatah
 */
class Buyer1{
	public void getHouse() {
		System.out.println("买主买到房子............");
	}
}

/**
 * cglib动态代理类
 * @author fatah
 */
public class CglibProxy implements MethodInterceptor{

	public Object intercept(Object target, Method method, Object[] arrays, MethodProxy methodProxy) throws Throwable {
		System.out.println("中介联系卖家");
		Object invokeSuper = methodProxy.invokeSuper(target, arrays);
		System.out.println("中介完成交易");
		return invokeSuper;
	}
	
	public static void main(String[] args) {
		Buyer1 buyer = new Buyer1();
		CglibProxy cglib = new CglibProxy();
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(Buyer1.class);
		enhancer.setCallback(cglib);
		House house = (House) enhancer.create();
		house.getHouse();
	}
	
}

五、总结

1. 静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
2. JDK动态代理需要目标对象实现业务接口，而cglib代理不需要目标对象实现业务接口。
3. 静态代理在编译时产生class字节码文件，可以直接使用，效率高。
4. jdk动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
5. cglib目标对象无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

 

本文参考：https://segmentfault.com/a/1190000011291179