常用的设计模式

Gentle0503

已于 2022-09-02 14:57:49 修改

阅读量216

点赞数

文章标签：设计模式 java 代理模式

于 2022-09-02 14:55:33 首次发布

本文链接：https://blog.csdn.net/qq_34654085/article/details/126661899

版权

单例模式

单例，即只有一个实例对象。这种模式普遍存在于开发过程中的工具封装。应用场景很多

如何设计单例？对象的生成考的是构造器，如果将构造器私有化，那么就无法生成对象，但是还要出现对象呢，怎么办？当然让类自己提供一个方法然他为我们返回单一实例对象就好了，代码：

/**
 *  懒汉模式
 * @author zcb
 */
public class Book {
    private static Book book = null;
    private Book() {
    }
    public static synchronized Book getInstance() {
        if (book == null) {
            book = new Book();
        }
        return book;
    }
}

该代码，上来会先判断对象是否存在，不存在就new 并给与静态变量，之后在获取的话这个对象就存在了，所以就会直接返回。

/**
 * 饿汉模式
 */
class Book{
    private static Book book = new Book();
    private Book() {
    }
    public static synchronized Book getInstance() {
        return book;
    }
}

这也是单例的，他上来就初始化，以保证执行效率。

工厂模式

工厂模式，就是我只关心调用者是谁，他的工厂类是谁，底层的实现不由我具体实现，这种隐藏了自类的特定模式，称之为工厂模式，这种模式，开发中也会经常见，它对于类型的封装就有保密性，涵盖类不同延伸类别的实现

如何实现一个工厂模式？首先，我们只关心我们的调用调用用的是工厂类，生成出的产品是什么由我们的具体对象来确定

public abstract class FactoryModule {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public abstract void test();
    public void cut(){
        System.out.println(name);
    }
}

class Test1 extends FactoryModule{
    @Override
    public void test() {
        System.out.println("这里是test1 的 test");
    }
}
class Test2 extends FactoryModule{
    @Override
    public void test() { 
        System.out.println("这里是test2 的 test");
    }
}

class Main{
    public static void main(String[] args) {
        FactoryModule module = new Test1();
        module.setName("test1 hhhhh");
        module.cut();
        module.test();
    }
}

首先，它有一个抽象的工厂类产生，其余的自雷回去继承并重写相对应的方法，在使用的时候，我们只需要用工厂对象去调用就完事了。相当舒服，看上去对象被掩盖在工厂之下

代例模式

代理模式，顾名思义，就是我不用具体操作，制定一个代理对象处理我所需要的操作步骤，该模式在Spring框架中应用很广。其中又分为静态代理和动态代理

如何设计一个代理模式？首先先讨论静态代理，分为基于接口的静态代理和基于继承的静态代理。都是从一个父接口产生的。

public interface ProxyInterface {
    public void test1();
    public void  test2();
}

基于接口的静态代理：

class AProxy implements ProxyInterface{
    @Override
    public void test1() {
        System.out.println("A 的test1");
    }
    @Override
    public void test2() {
        System.out.println("A 的test2");
    }
}

基于继承的静态代理

class ProxyInterfaceImp implements ProxyInterface{

    @Override
    public void test1() {
        System.out.println("实现接口的方法1");
    }

    @Override
    public void test2() {
        System.out.println("实现接口的方法2");
    }
}
class BProxy extends ProxyInterfaceImp{
    @Override
    public void test1() {
        super.test1();
    }

    @Override
    public void test2() {
        super.test2();
    }
}

就是 ProxyImp 实现接口方法，B又去继承 ProxyImp 的形式
他的缺点归纳一下：

缺点：每一个目标对象，都需要匹配一个代理类，并且目标对象方法变更，代理类必须同步更新。

目标对象：具体的业务

代理对象：执行的过程中真正运行的对象

我们经常听到过基于jdk 的动态代理，动态代理有什么好处？

public class DynmicProxy<T> implements InvocationHandler {
    /**
     * 声明一个目标对象
     */
    private T obj;

    /**
     * 获取代理对象
     *
     * @param target
     * @return
     */
    public T getProxyObj(T target) {
        obj = target;
        T proxyInstance = (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
        return proxyInstance;
    }

    /**
     * @ author:Administrator
     * @ description:目标对象的方法被调用的时候，自动执行invoke方法中的内容
     * @ param:[proxy, method, args]
     * @ return:java.lang.Object
     **/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("目标对象方法开始执行");
        //方法执行之前增强处理
        Object o = method.invoke(obj, args);
        //方法执行后增强处理
        System.out.println(method.getName());
        return o;
    }
}

 public static void main(String[] args) {
        //1创建目标对象，只能是接口类型，不然会报错
        ProxyInterface proxyInterface = new ProxyInterfaceImp();
        //2返回代理对象
        DynmicProxy<ProxyInterface> proxyClass = new DynmicProxy<>();
        ProxyInterface proxyObj = proxyClass.getProxyObj(proxyInterface);
        //3具体执行通过代理对象执行
        proxyObj.test1();
        proxyObj.test2();
    }