【Spring】循序渐进理解工厂设计模式

缺乏、安全感 2022-09-10 03:13 149阅读 0赞

**什么是设计模式？**

*  ⼴义概念：面向对象设计中，解决特定问题的经典代码。
 *  狭义概念：GOF4人帮定义的23种设计模式：工厂、适配器、装饰器、门面、代理、模板…

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

### 文章目录 ###

*  一、工厂设计模式
 *  二、不使用工厂模式创建对象
 *  三、简单工厂设计
 *   *  3.1 简单工厂——直接创建对象
     *  3.2 改进工厂1——反射创建对象
     *  3.3 改进工厂2——反射与配置文件创建对象
 *  四、通用工厂设计
 *  五、总结

# 一、工厂设计模式 #

什么是工厂设计模式？

**概念**：通过工厂类，创建对象；

**好处**：**解耦合**（耦合：指定是代码间的强关联关系，⼀方的改变会影响到另⼀方。）

如果不理解的话，继续往下看。

# 二、不使用工厂模式创建对象 #

以`UserDao`、`UserService`的创建为例，`UserDao`模拟数据库的登录操作，`UserService`模拟相关的登录业务。

**UserDao接口**

public interface UserDao { 
        void login(String name, String password);
    }

**UserDaoImpl实现UserDao接口**

public class UserDaoImpl implements UserDao{ 
        @Override
        public void login(String name, String password) { 
            System.out.println("User login, name=" + name + ", password=" + password);
        }
    }

**UserService接口**

public interface UserService { 
        void login(String name, String password);
    }

**UserServiceImpl实现UserService接口**

public class UserServiceImpl implements UserService{ 
        UserDao userDao = new UserDaoImpl();
    
        @Override
        public void login(String name, String password) { 
            System.out.println("处理登录业务！");
            userDao.login(name, password);
        }
    }

对上面创建好的Service进行测试。

@Test
    public void testService() { 
        // 假设这有很多代码
    
        // 创建对象
        UserService userService = new UserServiceImpl();
        // 调用方法
        userService.login("钢铁侠", "xxxxx");
    
        // 假设这有很多代码
    }

运行结果为：

处理登录业务！
    User login, name=钢铁侠, password=xxxxx

在测试文件中，需要选择`UserService`的实例化方法，此处存在代码耦合，如果换用其他的实例化方法那么此处就要修改。比如，此时想要换用实例化方法`UserServiceImpl2()`，那么这段创建对象的语句就要改为：

UserService userService = new UserServiceImpl2();

此时我们想要修改它确实很简答，只需要把实例化的方法换一下啊。但是如果代码非常庞大，就需要在海量代码中找到这一段进行修改，这会变得十分麻烦。

如何不修改这段代码的情况下改变实例化方法呢？此处就需要引入**工厂模式**。

# 三、简单工厂设计 #

## 3.1 简单工厂——直接创建对象 ##

此时，需要创建一个工厂类，并在工程类中创建一个静态方法用于返回一个实现类。

工厂类设计

public class BeanFactory { 
        public static UserService getUserService() { 
            return new UserServiceImpl();
        }
    }

创建测试代码，此时通过工厂类中的`getUserService()`获得`UserService`对象。

@Test
    public void testService2() { 
        // 假设这有很多代码
    
        // 创建对象
        UserService userService = BeanFactory.getUserService();
        // 调用方法
        userService.login("钢铁侠", "xxxxx");
    
        // 假设这有很多代码
    }

运行结果如下：

处理登录业务！
    User login, name=钢铁侠, password=xxxxx

这就解决了上面存在的耦合问题，如果换用其他的实现方法，只需要修改工厂类中的返回的对象。

但是，这就将耦合转移到了工厂类中，需要在工厂类中修改的对象。

## 3.2 改进工厂1——反射创建对象 ##

下面对工厂类进行改进，**通过反射创建对象**，达到解耦的效果。

public class BeanFactory { 
        public static UserService getUserService() { 
            UserService userService = null;
            try { 
                Class clazz = Class.forName("com.zqc.basic.UserServiceImpl");
                userService = (UserService) clazz.newInstance();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return userService;
        }
    }

通过反创造对象，代码依然存在耦合，`com.zqc.basic.UserServiceImpl`以字符串的形式耦合在工厂类中。如何解决这个问题呢？

## 3.3 改进工厂2——反射与配置文件创建对象 ##

需要在文件中添加配置类，将`com.zqc.basic.UserServiceImpl`写在配置类中，接着对工厂类进行修改。

创建properties配置文件，该配置文件是一种特殊的Map，形式为**key=value**。

文件名：applicationContext.properties（放在Maven项目下的resources目录下）

userService = com.zqc.basic.UserServiceImpl

修改工厂类：

public class BeanFactory { 
        private static Properties env = new Properties();
    
        // 静态代码块读取配置文件
        static { 
            try { 
                // 获取IO输入流
                InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
                // 文件内容封装在Properties集合中，对文件进行读取
                env.load(inputStream);
                // 关闭流
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        public static UserService getUserService() { 
            UserService userService = null;
            try { 
                // 通过配置文件以及反射获取对象
                Class clazz = Class.forName(env.getProperty("userService"));
                userService = (UserService) clazz.newInstance();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return userService;
        }
    }

首先，通过流读取配置文件。然后，通过读取配置文件中的`userService`获取全限定类名，并通过反射创建该对象。  
![在这里插入图片描述][fc0554acf2694c0dada4908d36fcfea8.png]  
至此，就将耦合问题解决完毕。当我们想要更改实例化方法时，只需要修改配置文件。

# 四、通用工厂设计 #

针对于上面的`UserService`，我们在`BeanFactory`工厂类中创建了`getUserService()`方法。如果需要`OrderService`，我们还需要创建`getOrderService`，如果需要`ChartService`，我们还需要创建`getChartService`。这样每出现一个Service就要相对应创建一个工厂方法，这是十分麻烦的。

简单工厂需要创建大量的工厂方法，代码冗余，且这些方法很多部分都是重复的，所以需要把这些方法转换为通用的方法。

下面创建通用的工厂代码：

public class BeanFactory { 
        private static Properties env = new Properties();
    
        // 静态代码块读取配置文件
        static { 
            try { 
                // 获取IO输入流
                InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
                // 文件内容封装在Properties集合中，对文件进行读取
                env.load(inputStream);
                // 关闭流
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
        
        
        public static Object getBean(String key){ 
            Object ret = null;
            try { 
                // 通过配置文件以及反射获取对象
                Class clazz = Class.forName(env.getProperty(key));
                ret = clazz.newInstance();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            // 返回的是Object类型
            return ret;
        }
    }

读取配置文件的方法不变，只是此时创建对象的类型为Object，返回对象的类型也为Object。在程序中调用getBean返回对象时，需要对其进行类型的强转。如：

UserService userService = (UserService) BeanFactory.getBean("userService");

修改测试文件：

public class MyTest { 
        @Test
        public void testService() { 
            // 假设这有很多代码
    
            // 创建对象
            UserService userService = (UserService) BeanFactory.getBean("userService");
            // 调用方法
            userService.login("钢铁侠", "xxxxx");
    
            // 假设这有很多代码
        }
    }

# 五、总结 #

1.  工厂设计模式解决代码直接的耦合问题。
2.  通用的工厂模式有配置文件+反射共同解决。

Spring的本质就是工厂：ApplicationContext，由applicationContext.xml进行配置。

[fc0554acf2694c0dada4908d36fcfea8.png]: /images/20220829/580d25dd529640e29fa36180339711a4.png