设计模式梳理

2021-12-18

字数统计: 3.8k字 | 阅读时长≈ 16分

设计模式

一、单例模式

饿汉式

public class Singleton {
    private static final Singleton INSTANCE=new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

实现方式：在类加载的时候就对实例进行创建，实例在整个程序周期都存在。

优点：避免了多线程同步问题

缺点：不需要的时候就加载，会造成资源浪费

懒汉式

public class Singleton{  
      private static Singleton instance = null;  
      private Singleton(){}  
      public static Singleton newInstance(){  
          if(null == instance){  
              instance = new Singleton();  
          }  
          return instance;  
      }  
  }

实现方式：在需要的时候才会创建对象。如果对象已经被创建则不会再创建对象

优点：资源消耗少，

缺点：线程不安全，需要加同步方法。解决方法：加锁解决线程同步问题

1. 加synchronized关键字

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

实现方式：在调用方法上面加锁机制，实现同步操作

优点：解决线程安全问题

缺点：性能消耗损失较大

2. 用“双重检查加锁”

public class Singleton {

    private static volatile Singleton unsingleton;

    private Singleton(){}

    public static Singleton getInstance(){
        if(unsingleton==null){
            //只有当第一次访问的时候才会使用synchronized关键字
            synchronized (Singleton.class){
                if(unsinleton==null)unsingleton=new Singleton();
            }
        }
        return unsingleton;
    }
}

实现方式：不在每次调用的时候都进行同步加锁操作，只需要在第一次调用的时候进行加锁操作。并且通过volatile来保证数据的可见性

优点：保证了线程安全，并且降低了消耗

缺点：对java版本有要求。1.5以下版本用volatile可能会出现问题

volatule关键字详解：https://zhuanlan.zhihu.com/p/138819184

3. 用“静态内部类”

public class Singleton {
    private Singleton() {
    }

    private static Singleton instatnce;

    private static class SingletonHolder {
        private static Singleton instatnce = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instatnce;
    }
}

实现方式：在调用方法里面添加静态内部类

优点：外部类在加载的时候并不会立即加载内部类。性能好，无需加锁

缺点：由JVM类加载保证

二、工厂模式

简单工厂模式

public interface Moveable{
    void run();
}

public class Car implements Moveable(){
    public Car(){}; //构造方法，获得本类对象
    
    public void run(){
        System.out.println("汽车正在向前跑...");
    }
}

public abstract class VehicleFactory{
    public abstract Moveable create();
}

public class CarFactory extends VehicleFactory{
    @Override
    public Moveable create(){
        return new Car();
    }
}

public static void main(String[] args){
    VehicleFactory factory = new CarFactory();
    Moveable m = factory.create();
    m.run();
}

抽象工厂模式

/* test*/
public static void main(String[]args){
    AbstractFactory factory=new Factory1();
    Vehiche v=factory.createVehiche();
    Weapon w=factory.createWeapon();
    Food f=factory.createFood();
    
    v.run();
    w.fire();
    f.eat();
}

public abstract class Vehiche { /* 交通工具的抽象类*/
    public abstract void run();
}

public abstract class Weapon { /* 武器的抽象类*/
    public abstract void fire();
}

public abstract class Food { /* 食物的抽象类*/
    public abstract void eat();
}

public class Car extends Vehiche { /* 一种具体的交通工具*/
    @Override
    public void run() {
        System.out.println("小汽车启动...");
    }
}

public class AK47 extends Weapon { /* 一种具体的武器*/
    @Override
    public void fire() {
        System.out.println("哒哒哒...");
    }
}

public class Apple extends Food { /* 一种具体的食物*/
    @Override
    public void eat() {
        System.out.println("大口吃苹果...");
    }
} /* 抽象工厂*/

public abstract class AbstractFactory {
    public abstract Vehiche createVehiche();

    public abstract Weapon createWeapon();

    public abstract Food createFood();
} /* 抽象工厂的实现1*/

public class Factory1 extends AbstractFactory {
    @Override
    public Vehiche createVehiche() {
        return new Car();
    }

    @Override
    public Weapon createWeapon() {
        return new AK47();
    }

    @Override
    public Food createFood() {
        return new Apple();
    }
}

模拟Spring工厂实现

public static void main(String[] args) throws Exception{
    BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
    Vehiche v = (Vehiche) bf.getBean("v");
    v.run();
}

//BeanFactory的实现类
public class ClassPathXmlApplicationContext implements BeanFactory{
    
	private Map<String,Object> container = new HashMap<>(); // 用于存放bean对象的容器
    
    // 在构造方法中读取xml配置文件, 把bean对象都创建好并放入容器中
    public ClassPathXmlApplicationContext(String propAddr) throw Exception {
        SAXReader reader = new SAXReader();
        File file = new File(this.getClass().getClassLoader().getResource(propAddr).toURI());
        Document document = reader.read(file);
        Element root = document.getRootElement();
        List<Element> childElements = root.elements();
        
        for(Element child : childElements){
            Object bean = Class.forName(child.attributeValue("class")).newInstance();
            container.put(child.attributeValue("id"),bean);
        }
    }
    
    @Override
    public Object getBean(String beanId){
        return container.containsKey(beanId) ? container.get(beanId) : null;
    }
}

// 极简  BeanFactory
publice interface BeanFactory {
    Object getBean(String beanId);
}

// xml中配置的bean
<bean id = "v" class = "designPattern.factory.Car">
</bean>

模拟 IOC：

都说 Spring是个 bean容器, 以下的代码将展示它是如何生成 bean, 并把 bean放入容器中供用户获取的.
思路比较简单:

创建 BeanFactory工厂接口, 添加方法 getBean().
创建 BeanFactory的实现类 ClassPathXmlApplicationContext. 将在该实现类中展示 IOC的具体实现.
ClassPathXmlApplicationContext需要一个 container容器存放创建的 bean对象, 这里使用 HashMap实现.
在 ClassPathXmlApplicationContext的构造方法中读取 spring的配置文件, 这里使用到了 dom4j. 读取配置文件后根据 bean的 class属性使用反射创建出 bean对象. 然后把 id和 bean对象分别作为 key和 value添加到容器中.
当工厂被调用 getBean()方法时, 从容器中找到对应的 bean并返回.

三、代理模式

分类：

分类：

静态代理： 在编译时就已经实现，编译完成后代理类是一个实际的class文件

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

静态代理

public interface UserDao {    
  void save();     
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("正在保存用户...");
    }
}

public class TransactionHandler implements UserDao {
    //目标代理对象
    private UserDao target;
    //构造代理对象时传入目标对象
    public TransactionHandler(UserDao target) {
        this.target = target;
    }
    @Override
    public void save() {
        //调用目标方法前的处理
        System.out.println("开启事务控制...");
        //调用目标对象的方法
        target.save();
        //调用目标方法后的处理
        System.out.println("关闭事务控制...");
    }
}

public class Main {
    public static void main(String[] args) {
        //新建目标对象
        UserDaoImpl target = new UserDaoImpl();
        //创建代理对象, 并使用接口对其进行引用
        UserDao userDao = new TransactionHandler(target);
        //针对接口进行调用
        userDao.save();
    }
}

使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐

JDK动态代理

使用JDK动态代理的五大步骤：

通过实现InvocationHandler接口来自定义自己的InvocationHandler；
通过Proxy.getProxyClass获得动态代理类；
通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)；
通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入；
通过代理对象调用目标方法；

public interface IHello {
    void sayHello();
}

 public class HelloImpl implements IHello {
    @Override
    public void sayHello() {
        System.out.println("Hello world!");
    }
}


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
 
public class MyInvocationHandler implements InvocationHandler {
 
    /** 目标对象 */
    private Object target;
 
    public MyInvocationHandler(Object target){
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("------插入前置通知代码-------------");
        // 执行相应的目标方法
        Object rs = method.invoke(target,args);
        System.out.println("------插入后置处理代码-------------");
        return rs;
    }
}


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;

public class MyProxyTest {
    public static void main(String[] args)
            throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        // =========================第一种==========================
        // 1、生成$Proxy0的class文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        // 2、获取动态代理类
        Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
        // 3、获得代理类的构造函数，并传入参数类型InvocationHandler.class
        Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
        // 4、通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入
        IHello iHello1 = (IHello) constructor.newInstance(new MyInvocationHandler(new HelloImpl()));
        // 5、通过代理对象调用目标方法
        iHello1.sayHello();
 
        // ==========================第二种=============================
        /**
         * Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，
         *其方法签名为：newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)
         */
        IHello  iHello2 = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), // 加载接口的类加载器
                new Class[]{IHello.class}, // 一组接口
                new MyInvocationHandler(new HelloImpl())); // 自定义的InvocationHandler
        iHello2.sayHello();
    }
}

JDK静态代理与JDK动态代理之间有些许相似，比如说都要创建代理类，以及代理类都要实现接口等。

不同之处： 在静态代理中我们需要对哪个接口和哪个被代理类创建代理类，所以我们在编译前就需要代理类实现与被代理类相同的接口，并且直接在实现的方法中调用被代理类相应的方法；但是动态代理则不同，我们不知道要针对哪个接口、哪个被代理类创建代理类，因为它是在运行时被创建的。

一句话来总结一下JDK静态代理和JDK动态代理的区别：

JDK静态代理是通过直接编码创建的，而JDK动态代理是利用反射机制在运行时创建代理类的。

其实在动态代理中，核心是InvocationHandler。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时，将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke方法

对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的，而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。

CGLIB动态代理

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类

CGLIB代理实现如下：

首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
然后在需要使用的时候，通过CGLIB动态代理获取代理对象。

 public class HelloService {
 
    public HelloService() {
        System.out.println("HelloService构造");
    }
 
    /**
     * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
     */
    final public String sayOthers(String name) {
        System.out.println("HelloService:sayOthers>>"+name);
        return null;
    }
 
    public void sayHello() {
        System.out.println("HelloService:sayHello");
    }
}

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
 
import java.lang.reflect.Method;
 
/**
 * 自定义MethodInterceptor
 */
public class MyMethodInterceptor implements MethodInterceptor{
 
    /**
     * sub：cglib生成的代理对象
     * method：被代理对象方法
     * objects：方法入参
     * methodProxy: 代理方法
     */
    @Override
    public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("======插入前置通知======");
        Object object = methodProxy.invokeSuper(sub, objects);
        System.out.println("======插入后者通知======");
        return object;
    }
}

import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
 
public class Client {
    public static void main(String[] args) {
        // 代理类class文件存入本地磁盘方便我们反编译查看源码
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(HelloService.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        HelloService proxy= (HelloService)enhancer.create();
        // 通过代理对象调用目标方法
        proxy.sayHello();
    }
}

JDK代理要求被代理的类必须实现接口，有很强的局限性。

而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。

总结一下CGLIB在进行代理的时候都进行了哪些工作

生成的代理类继承被代理类。在这里我们需要注意一点：如果委托类被final修饰，那么它不可被继承，即不可被代理；同样，如果委托类中存在final修饰的方法，那么该方法也不可被代理
代理类会为委托方法生成两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法
当执行代理对象的方法时，会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;，如果存在，则将调用MethodInterceptor中的intercept方法

在intercept方法中，我们除了会调用委托方法，还会进行一些增强操作。在Spring AOP中，典型的应用场景就是在某些敏感方法执行前后进行操作日志记录

在CGLIB中，方法的调用并不是通过反射来完成的，而是直接对方法进行调用：通过FastClass机制对Class对象进行特别的处理，比如将会用数组保存method的引用，每次调用方法的时候都是通过一个index下标来保持对方法的引用

Fastclass机制

CGLIB采用了FastClass的机制来实现对被拦截方法的调用。

FastClass机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法

public class test10 {
  //这里，tt可以看作目标对象，fc可以看作是代理对象；首先根据代理对象的getIndex方法获取目标方法的索引，
  //然后再调用代理对象的invoke方法就可以直接调用目标类的方法，避免了反射
    public static void main(String[] args){
        Test tt = new Test();
        Test2 fc = new Test2();
        int index = fc.getIndex("f()V");
        fc.invoke(index, tt, null);
    }
}

class Test{
    public void f(){
        System.out.println("f method");
    }
    
    public void g(){
        System.out.println("g method");
    }
}
class Test2{
    public Object invoke(int index, Object o, Object[] ol){
        Test t = (Test) o;
        switch(index){
        case 1:
            t.f();
            return null;
        case 2:
            t.g();
            return null;
        }
        return null;
    }
    //这个方法对Test类中的方法建立索引
    public int getIndex(String signature){
        switch(signature.hashCode()){
        case 3078479:
            return 1;
        case 3108270:
            return 2;
        }
        return -1;
    }
}

三种代理方式之间对比

CGlib比JDK快？

使用CGLiB实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在jdk6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。
在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率。只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理，总之，每一次jdk版本升级，jdk代理效率都得到提升，而CGLIB代理消息确有点跟不上步伐。

Spring如何选择用JDK还是CGLIB？

当Bean实现接口时，Spring就会用JDK的动态代理。
当Bean没有实现接口时，Spring使用CGlib实现。
可以强制使用CGlib

本文作者： GHOSTLaycoo
本文链接： http://example.com/2021/12/18/设计模式/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！