Spring及工厂模式概述

在 Spring 框架出现之前，Java 开发者使用的主要是传统的 Java EE（Java Enterprise Edition）平台。Java EE 是一套用于开发企业级应用程序的规范，其中包含了众多的标准和 API，如 Servlet、JSP、EJB、JPA 等。

在 Java EE 平台中，应用程序通常是基于各种不同的技术和规范进行构建的，这些技术和规范的配置和集成往往需要大量的手工工作和复杂的部署过程。开发者需要手动管理对象的生命周期和依赖关系，并编写大量的样板代码来处理框架和平台所要求的要求。

Spring 框架的出现改变了这种开发方式。它引入了依赖注入和面向切面编程等新概念，通过 IOC 容器来管理对象的创建和依赖关系，简化了应用程序的开发和配置。

Spring 的设计目标之一是提供一种轻量级的框架，使得开发者能够更加专注于业务逻辑的实现而不是框架的配置和集成。

因此，Spring 的出现引领了一种新的开发范式，简化了企业级应用程序的开发流程，提供了更高效和灵活的开发方式，深受 Java 开发者的喜爱。

Spring 身世

2002年，Rob Johnson 撰写了一本名为《J2EE设计和开发》的书。本书主要概括了当时Java企业应用程序开发的现状以及指出了JavaEE规范中EJB框架的缺陷，并在书中基于普通Java类和设计模式提出了更为简单的解决防范。

同年在《J2EE Devlopment Without EJB》一书中，进一步扩展了 Interface21的代码，衍生而来了一个轻量级J2EE开发解决方案----Spring。

2004年3月在Sourceforge正式发布了Spring框架的第一个版本。

什么是 Spring

Spring是⼀个轻量级的JavaEE解决⽅案，整合众多优秀的设计模式

• 轻量级
  • 对于运行环境是没有额外要求的
  • 代码移植性高 不需要实现额外接口

• 整合设计模式
  • 工厂设计模式
  • 代理设计模式
  • 模板设计模式
  • 策略设计模式

什么是设计模式

1. ⼴义概念 ⾯向对象设计中，解决特定问题的经典代码
2. 狭义概念 GOF4⼈帮定义的23种设计模式：⼯⼚、适配器、装饰器、⻔⾯、代理、模板…
   
   

工厂设计模式

什么是工厂设计模式

1. 概念：通过⼯⼚类，创建对象

   //	反例
   User user = new User(); 
   
   UserDAO userDAO = new UserDAOImpl(); 
   1
   2
   3
   4

2. 好处：解耦合

   • 耦合：指定是代码间的强关联关系，⼀⽅的改变会影响到另⼀⽅

   • 问题：不利于代码维护

   • 简单：把接⼝的实现类，硬编码在程序中

     //	硬编码
     UserService userService = new UserServiceImpl(); 
     1
     2

简单的工厂设计模式

1. 最初的硬编码

//	这个硬编码是有耦合的
UserService userService = new UserServiceImpl(); 
1
2

2. 简单工厂模式设计

public class BeanFactory{
	public UserService getUserService(){
		return new UserServiceImpl();
	}
}
1
2
3
4
5

用 BeanFactory 获取：解耦合

UserService userService = BeanFactory.getUserService(); 
1

3. 第2步的简单工厂 BeanFactory 里的 getUserService() 方法其实还是有耦合（解耦不彻底）

改造 BeanFactory 通过反射去获取其对象.

public class BeanFactory{
   
   public UserService getUserService(){
       UserService userService = null;
       try {
           Class clazz =
               Class.forName("com.snow.service.UserServiceImpl");
           userService = (UserService) clazz.newInstance();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       }
       return userService;
   }
   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 第3步的类路径其实还是有耦合

可以继续改造第3步，将类路径字符型放在配置文件中。

public class BeanFactory{
    
    private static Properties env = new Properties();
    
    static{
        try {
            //第⼀步 获得IO输⼊流
            InputStream inputStream =
                BeanFactory.class.getResourceAsStream("/applicationContext.properties"
                                                     );
            //第⼆步 ⽂件内容 封装 Properties集合中 
            //key = userService value = com.snow.service.UserServiceImpl
            env.load(inputStream);
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
	public UserService getUserService(){
        UserService userService = null;
        try {
            //	该路径是从配置文件读取来的
            Class clazz = Class.forName(env.getProperty("userService"));
            userService = (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userService;
	}
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

通用的工厂设计

回顾 上一步 简单工厂模式，发现当需要获取多个对象时，就需要多个工厂，这就会造成的大量的代码冗余。

SO , 我们来改造下,通过传入对象的 key, 来获得其对象.

public class BeanFactory{
    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();
        }
        return ret;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

总结

总结起来，Spring 的灵魂就是工厂模式的应用.