几种设计模式的作用及实现

￡神魔★判官ぃ 2023-06-06 04:59 5阅读 0赞

# 工厂 #

工厂模式主要是为了**解耦**，A类想要调用B类，但是实例化B对象比较复杂，所以我们就把B对象的创建放到工厂里面统一管理。由于B对象的创建已经统一了起来，所以即使业务逻辑发生变化，我们也只需要修改工厂类，而不需要寻找每个创建B对象的地方去修改。

例如，我们项目可能会使用多个数据库源，但是他们的JDBC配置是不同的，所以我们就可以使用工厂模式来统一，也减少了使用者出错的概率。

**使用场景：**

精确数据计算，获取Jdbc连接，或者类似的通讯连接

**实现：**

## **简单工厂：** ##

首先创建一个接口

public interface Operation {
     
        public double getResult(double numberA,double numberB) throws Exception;
     
    }

然后是加减乘除的实现类

public class Add implements Operation{
     
        // 加法计算
        public double getResult(double numberA, double numberB) {
     
            return numberA + numberB;
        }
    }
    
    // 减  Sub 
    // 乘  Mul 
    // 除  Div

然后是简单工厂

public class EasyFactory {
     
        // 简单工厂，根据字符串创建相应的对象
        public static Operation createOperation(String name) {
            Operation operationObj = null;
            switch (name) {
                case "+":
                    operationObj = new Add();
                    break;
                case "-":
                    operationObj = new Sub();
                    break;
                case "*":
                    operationObj = new Mul();
                    break;
                case "/":
                    operationObj = new Div();
                    break;
            }
            return operationObj;
        }
    }

调用：

public class Client {
     
        public static void main(String[] args) throws Exception {
     
            Operation add = EasyFactory.createOperation("+");
            Operation sub = EasyFactory.createOperation("-");
            Operation mul = EasyFactory.createOperation("*");
            Operation div = EasyFactory.createOperation("/");
     
            System.out.println(add.getResult(1, 1));
            System.out.println(sub.getResult(1, 1));
            System.out.println(mul.getResult(1, 1));
            System.out.println(div.getResult(1, 1));
        }
    }

## 工厂模式 ##

工厂方法模式是对**简单工厂模式进一步的解耦**，因为在工厂方法模式中是**一个子类对应一个工厂类**，而这些工厂类都实现于一个抽象接口。这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。

实现：

首先定义工厂接口：

import com.ljy.Mode.Operation;
     
    public interface Factory {
     
        public Operation createOperation() ;
     
    }

然后是工厂实现类

// 加法类工厂
    public class AddFactory implements Factory{
     
        public Operation createOperation() {
            System.out.println("加法运算");
            return new Add();
        }
    }
     
    // 减法类工厂
    public class SubFactory implements Factory{
     
        public Operation createOperation() {
            System.out.println("减法运算");
            return new Sub();
        }
    }
    ........

调用：

public class Client {
     
        public static void main(String[] args) throws Exception {
     
            // 使用反射机制实例化工厂对象，因为字符串是可以通过变量改变的
            Factory addFactory = (Factory) Class.forName("com.ljy.mode.factory.AddFactory").newInstance();
            Factory subFactory=(Factory) Class.forName("com.ljy.mode.factory.SubFactory").newInstance();
     
            // 通过工厂对象创建相应的实例对象
            Operation add = addFactory.createOperation();
            Operation sub = subFactory.createOperation();
     
            System.out.println(add.getResult(1, 1));
            System.out.println(sub.getResult(1, 1));
        }
    }

## 抽象工厂模式 ##

抽象工厂与工厂方法模式的区别在于：**抽象工厂是可以生产多个产品的，**它围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

说白了，就是创建一个抽象工厂，然后建立其他工厂类实现。

实现就不写了 有点麻烦，以后补充。

# 单例 #

单例设计模式，就是有一个准则，那就是**只有一个对象被创建！！！**，而且单例也是最简单的设计模式了

单例模式的作用很明显，首先，节省内存，因为我只有一个对象，其次，我能保证数据的唯一性。

为了保证对象唯一性，所以我们首先要确定**构造方法的私有性**，这样的话就不能通过new的方式创建对象了，然后我们可以在内部创建自身对象，但是**对象必须是私有**的，然后，我们需要一个**静态的公开的方法**，来让外部类获取对象。

## 饿汉模式 ##

饿汉，一直在叫着“我好饿啊”，啥都想吃，所以，这种设计模式，是在一开始就已经把对象创建好了，但是，会造成内存浪费啊，就算没用到他，也会在哪里占着浪费内存。

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

## 懒汉模式 ##

懒汉啥样的，那当然是懒啊，所以懒汉模式，就意味着，只有等到需要这个对象的时候，才回去创建对象

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

但是这种设计模式，有个很大的缺点，那就是线程不安全！！！一旦多个线程同时进来，那就会创建多个对象，违反我们的原则了。

那要是线程不安全咋办呢，简单啊，那就加锁呗。

## 饿汉模式（同步方法） ##

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

但是加锁一时爽，效率太差了啊，那么多线程都在方法外面等着呢啊

## 饿汉模式（双重检查） ##

既然加锁方法会造成效率低下，那咱们就把加锁的位置改一下吧，放在方法里面

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

但是，一想想，不对啊  这样还是会造成线程不安全啊，导致出现两个对象啊，不行不行，那咋办呢  要不再加个锁？可是锁加在哪里呢？

## 饿汉模式（双重锁） ##

于是，我们就加了个锁，将这个锁加载了声明对象的时候，使用了volatile，这个版本也是非常完美的版本的，面试推荐哦

public class Singleton {  
        private volatile static Singleton singleton;  
        private Singleton (){}  
        public static Singleton getSingleton() {  
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                    if (singleton == null) {  
                        singleton = new Singleton();  
                    }  
                }  
            }  
            return singleton;  
        }  
    }

那么我们总想着懒汉饿汉，是不是还有其他方式呢（**注意，上面任意一种方式，都是无法阻止反射的！！！或者通过序列化 ，我们也是可以获得两个对象**），其实是有的，那就是**枚举**，枚举是天生的单例，而且可以阻止反射哦

## 枚举 ##

public enum  EnumSingleton {
        INSTANCE;
        public EnumSingleton getInstance(){
            return INSTANCE;
        }
    }

看，是不是，非常简单，代码量也很少

# 装饰器 #

装饰器模式的定义是**允许向一个现有的对象添加新的功能，同时又不改变其结构**。就像是，我下个单，中间可能会有打折，可能会有运费，价格就会变动，所以我们就可以通过装饰器模式来实现。

至于实现的话，其实也是主要靠**继承**与**子类重写父类**方法的原理来实现

首先一个接口是肯定的了：

public interface Component {
    	public void biu();
    }

然后接口实现类：

public class ConcretComponent implements Component {
    
    	public void biu() {
            
            System.out.println("biubiubiu");
        }
    }

接下来是装饰器的接口：

//装饰类
    public class Decorator implements Component {
    
      public Component component;
      
      public Decorator(Component component) {
          
          this.component = component;
      }
      
      public void biu() {
          
          this.component.biu();
      }
    }

最后就是装饰器接口实现类：

//具体装饰类
    public class ConcreteDecorator extends Decorator {
    
      public ConcreteDecorator(Component component) {
          super(component);
      }
      public void biu() {
          System.out.println("fire in the hole");
          this.component.biu();
      }
    }

说白了是不是感觉很简单的，不就是多态么。

具体调用是这样的：

public class Client {
    	public static void main(String[] args) {
    		//使用装饰器
    		Component component = new ConcreteDecorator(new ConcretComponent());
    		component.biu();
    	}
    }

# 代理 #

代理，一说起代理我们就可以联想到代理商，代理商干嘛的，那不就是帮助别人做事的么，例如什么猎头啊，中介啊，类似的，都是代理的体现。而且我们还可以借助代理类再次增加一些功能，而不需要修改原有代码。符合**开闭原则**。

至于到项目开发中，我们总会遇见一些事情，是我们不想让我们的实现类实现的，例如，日志啊，缓存啊，我们想在这个实现类执行的前后执行另外的一些操作，这就用到了我们的代理模式了。

同时代理模式和装饰器模式是不一样的！！！。

**装饰器模式和代理模式的区别：**

**装饰器模式关注于在一个对象上动态的添加方法**，然而**代理模式关注于控制对对象的访问**。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

代理分为**静态代理**和**动态代理。**

## 静态代理 ##

静态代理是在运行前，代理类的class文件就已经创建好了。但是呢，静态代理也有缺点，我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。** **

首先是接口：

package com.ljy.util.designMode.proxy;
    
    public interface BuyHouse {
        void buyHosue();
    }

然后是实现类：

package com.ljy.util.designMode.proxy;
    
    public class BuyHouseImpl implements BuyHouse {
    
        @Override
        public void buyHosue() {
            System.out.println("我要买房");
        }
    }

然后就是静态代理类：

package com.ljy.util.designMode.proxy;
    
    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("买房后装修");
    
        }
    }

最后是测试类：

package com.ljy.util.designMode.proxy;
    
    public class ProxyTest {
        public static void main(String[] args) {
            BuyHouse buyHouse = new BuyHouseImpl();
            buyHouse.buyHosue();
            BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse);
            buyHouseProxy.buyHosue();
        }
    }

## 动态代理 ##

动态代理是在程序运行时通过**反射机制**动态创建的。

在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

首先让我们创建动态代理类：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * JDKDynamicProxy
     * jdkd动态代理
     *
     * @author
     * @create 2018-03-29 16:17
     **/
    public class JDKDynamicProxy implements InvocationHandler { // 一定要实现这个类哦
    
        private Object target;
    
        public JDKDynamicProxy(Object target) {
            this.target = target;
        }
    
        /**
         * 获取被代理接口实例对象
         * @param <T>
         * @return
         */
        public <T> T getProxy() {
            return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("买房前准备");
            Object result = method.invoke(target, args);
            System.out.println("买房后准备");
            return result;
        }
    }

然后就是测试类：

package com.ljy.util.designMode.proxy.dynamic;
    
    import com.ljy.util.designMode.proxy.BuyHouse;
    import com.ljy.util.designMode.proxy.BuyHouseImpl;
    
    /**
     * Client
     * client测试代码
     **/
    public class Client {
        public static void main(String[] args) {
            // 将JDK动态代理生成的class文件保存到本地
    //        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    //        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true"); // 或者是这个
    
            // jdk动态代理测试
        	BuyHouse buyHouse = new JDKDynamicProxy(new BuyHouseImpl()).getProxy();
        	buyHouse.buyHosue();
        }
    }

是不是，只需要一个动态代理类就可以实现了，还不需要针对每个实现类开发。

--------------------

未完待续。。。