设计模式（面试）

最新推荐文章于 2024-05-11 21:40:45 发布

-随_风-

最新推荐文章于 2024-05-11 21:40:45 发布

阅读量100

点赞数

分类专栏： java 文章标签：面试 java 单元测试

本文链接：https://blog.csdn.net/zhanlong11/article/details/118911969

版权

java 专栏收录该内容

109 篇文章 4 订阅

订阅专栏

设计模式原则

1.单一职责原则

一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

2.开闭原则

一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

3.里氏代换原则

子类可以扩展父类的功能，但不能改变父类原有功能。

4.接口隔离原则

使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

5.依赖倒置原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向实现编程。

6.迪米特法则

一个软件实体应当尽可能少地与其他实体发生相互作用。

7.合成复用原则

软件复用时，要尽量先使用组合或者聚合等关联实现，其次才考虑使用继承关系来实现。
优点：灵活性高，耦合度低。

设计模式

1.单例模式

定义：确保一个类最多只有一个实例，并提供一个全局访问点
单例模式可以分为两种：预加载（饿汉式）和懒加载（懒汉式）

1.1 预加载

顾名思义，就是预先加载。再进一步解释就是还没有使用该单例对象，但是，该单例对象就已经被加载到内存了。

//线程安全,对于贡献数据的操作带码不会产生不同步问题（只有一行）；
public class PreloadSingleton {
       
       public static PreloadSingleton instance = new PreloadSingleton();
   
       //其他的类无法实例化单例类的对象
       private PreloadSingleton() {
       };
       //通过此方法获取对象，优点就是可控！。你可以根据条件是否返回该实例
       public static PreloadSingleton getInstance() {
              return instance;
       }
}

缺点: 很明显，没有使用该单例对象，该对象就被加载到了内存，会造成内存的浪费。

1.2 懒加载

为了避免内存的浪费，我们可以采用懒加载，即用到该单例对象的时候再创建。

public class Singleton {
       
       private static Singleton instance=null;
       
       private Singleton(){
       };
       //懒加载不浪费内存，但是无法保证线程的安全。首先，if判断以及其内存执行代码是非原子性的。其次，new Singleton()无法保证执行的顺序性。
       public static Singleton getInstance()
       {
              if(instance==null)
              {
                     instance=new Singleton();
              }
              return instance;
              
       }
}

1.3保证懒加载线程安全

使用synchronized关键字

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

我们把sychronized加在if(instance==null)判断语句里面，保证instance未实例化的时候才加锁.

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

使用volatile保证线程安全

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

2.代理模式

定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

代理模式分为三种：1. 静态代理 2. 动态代理 3. CGLIB代理

2.1 静态代理

举例（买房），类图如下：
在这里插入图片描述
第一步：创建服务类接口

public interface BuyHouse {
    void buyHosue();
}

第二步：实现服务类接口

public class BuyHouseImpl implements BuyHouse {
       @Override
       public void buyHosue() {
              System.out.println("我要买房");
       }
}

第三步：创建代理类

public class BuyHouseProxy implements BuyHouse {
       private BuyHouse buyHouse;
       public BuyHouseProxy(final BuyHouse buyHouse) {
              this.buyHouse = buyHouse;
       }
       @Override
       public void buyHosue() {
              System.out.println("买房前准备");
              buyHouse.buyHosue();
              System.out.println("买房后装修");
       }
}

总结：
优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
缺点： 代理对象与目标对象要实现相同的接口，我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。

动态代理实现

动态代理实现有两种方式，一种是JDK实现，一种是CGLIB，两者本质区别为：JDK实现的情况下目标对象必须实现接口，动态代理与目标类属于同一级关系（苹果是水果，梨是水果，苹果不是梨）CGLIB 继承思想，创建的代理类为目标类的子类，对于目标类是否存在接口实现没有要求，目标类与动态代理类属于父子关系,spring中类实现接口的是JDK实现的代理，没有实现接口的是CGLIB。在springboot里面，默认的是CGLIB（如果需要换成JDK，那么需要手动在配置文件中设置）。不管类是否实现接口，都是CGLIB实现的代理。使用CGLIB的时候代理类不要使用final修饰。

2.2动态代理

动态代理有以下特点:

代理对象，不需要实现接口
代理对象的生成，是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)代理类不用再实现接口了。但是，要求被代理对象必须有接口。

动态代理实现：

Java.lang.reflect.Proxy类可以直接生成一个代理对象

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象
- 参数1:ClassLoader loader 代理对象的类加载器一般使用被代理对象的类加载器
- 参数2:Class<?>[] interfaces 代理对象的要实现的接口一般使用的被代理对象实现的接口
- 参数3:InvocationHandler h (接口)执行处理类
InvocationHandler中的invoke(Object proxy, Method method, Object[] args)方法：调用代理类的任何方法，此方法都会执行
- 参数3.1:代理对象(慎用)
- 参数3.2:当前执行的方法
- 参数3.3:当前执行的方法运行时传递过来的参数

第一步：编写动态处理器

public class DynamicProxyHandler implements InvocationHandler {
       private Object object;
       public DynamicProxyHandler(final Object object) {
              this.object = object;
       }
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              System.out.println("买房前准备");
              Object result = method.invoke(object, args);
              System.out.println("买房后装修");
              return result;
       }
}

第二步：编写测试类

public class DynamicProxyTest {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new
                Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
        proxyBuyHouse.buyHosue();
    }
}

动态代理总结：虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏（我们要使用被代理的对象的接口），因为它的设计注定了这个遗憾。

2.3 CGLIB代理

CGLIB代理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

CGLIB 底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

CGLIB缺点：对于final方法，无法进行代理。

CGLIB的实现步骤：

第一步：建立拦截器

public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 
        System.out.println("买房前准备");
 
        Object result = methodProxy.invoke(object, args);
 
        System.out.println("买房后装修");
 
        return result;
 
    }

参数： Object为由CGLib动态生成的代理类实例，Method为上文中实体类所调用的被代理的方法引用，Object[]为参数值列表，MethodProxy为生成的代理类对方法的代理引用。

返回：从代理实例的方法调用返回的值。

其中，proxy.invokeSuper(obj,arg) 调用代理类实例上的proxy方法的父类方法（即实体类TargetObject中对应的方法）。

第二步：生成动态代理类

public class CglibProxy implements MethodInterceptor {
    private Object target;
    public Object getInstance(final Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("买房前准备");
        Object result = methodProxy.invoke(object, args);
        System.out.println("买房后装修");
        return result;
    }
}

这里Enhancer类是CGLib中的一个字节码增强器，它可以方便的对你想要处理的类进行扩展，以后会经常看到它。

首先将被代理类TargetObject设置成父类，然后设置拦截器TargetInterceptor，最后执行enhancer.create()动态生成一个代理类，并从Object强制转型成父类型TargetObject。

第三步：测试

public class CglibProxyTest {
    public static void main(String[] args){
        BuyHouse buyHouse = new BuyHouseImpl();
        CglibProxy cglibProxy = new CglibProxy();
        BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) cglibProxy.getInstance(buyHouse);
        buyHouseCglibProxy.buyHosue();
    }
}

CGLIB代理总结： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

-随_风-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式（面试）

设计模式原则1.单一职责原则一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。2.开闭原则一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。3.里氏代换原则子类可以扩展父类的功能，但不能改变父类原有功能。4.接口隔离原则使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。5.迪米特法则一个软件实体应当尽可能少地与其他实体发生相互作用。6.依赖倒置原则高层模块不应该依赖低
复制链接

扫一扫

专栏目录