Spring学习笔记：工厂模式与反射机制实现解耦

1.什么是Spring?

spring是一个开源轻量级的java开发应用框架，可以简化企业级应用开发

轻量级

1.轻量级(对于运行环境没有额外要求)

2.代码移植性高(不需要实现额外接口)

JavaEE的解决方案

Spring更像是一种解决方案，对于控制层，它有Spring MVC，对于Service层，有对应的Aop可以解决service中的事务控制和日志处理的问题，现有的持久化方案像jdbc、mybatis作整合解决Dao的问题。最大的特点就是每个层次都可以有对应的解决方案。

2.设计模式

1.广义概念

面向对象设计中，解决特定问题的经典代码

2.狭义概念

GOF4人定义的23种设计模式:工厂、适配器、装饰器、门面、代理、模板等

3.工厂设计模式

3.1什么是工厂设计模式

1.概念:通过工厂类、创建对象

User user=new User()

UserDao userDao=new UserDaoImpl();

2.好处:解耦合

耦合:指定是代码间的强关联的关系，一方的改变会影响到另一方

问题：不利于代码维护

简单理解：把接口的实现类，硬编码在程序中

通过建立工厂的方式和反射机制创建对象解耦合

public class BeanFactory {
    /*
        对象创建的方式
        1.直接调用构造方法 创建对象 UserService userService = new UserServiceImpl();
        2.通过反射的形式 创建对象 解耦合
            Class clazz=CLass.forName("basic.UserServiceImpl");
            UserService userService=(UserService)clazz.newInstance();
     */
    public static UserService getUserService() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class clazz=Class.forName("basic.UserServiceImpl");
        UserService userService=(UserService)clazz.newInstance();
        return userService;
    }
}

通过创建工厂和反射机制的方式创建对象，可以解耦合，减少代码的关联性，可以发现，Class.forName(字符串)可以通过配置文件的方式解耦合，这样代码发生变化时，仅仅只需要更改配置文件中的值。

package basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class BeanFactory {
    /*
        对象创建的方式
        1.直接调用构造方法 创建对象 UserService userService = new UserServiceImpl();
        2.通过反射的形式 创建对象 解耦合
            Class clazz=CLass.forName("basic.UserServiceImpl");
            UserService userService=(UserService)clazz.newInstance();
     */
    private static Properties properties;
    static{
        //仅仅需要加载一次 读取application.properties文件
        //第一步回去输入流
        InputStream resourceAsStream = BeanFactory.class.getResourceAsStream("/application.properties");
        //第二部 文件内容封装到Properties
        properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    public static UserService getUserService() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class clazz=Class.forName(properties.getProperty("userService"));
        UserService userService=(UserService)clazz.newInstance();
        return userService;
    }
}

该方法通过读取配置文件的方式，对字符串进行解耦合。如果我们在创建一个UserDao的方式也解决了耦合，但是会发现，当我有一个对象需要解耦合，我们就要提供一个对应的方法。我们希望能够设计一个通用工厂的方式。

配置文件展示

package basic;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeanFactory {
    /*
        对象创建的方式
        1.直接调用构造方法 创建对象 UserService userService = new UserServiceImpl();
        2.通过反射的形式 创建对象 解耦合
            Class clazz=CLass.forName("basic.UserServiceImpl");
            UserService userService=(UserService)clazz.newInstance();
     */
    private static Properties properties;
    static{
        //仅仅需要加载一次 读取application.properties文件
        //第一步回去输入流
        InputStream resourceAsStream = BeanFactory.class.getResourceAsStream("/application.properties");
        //第二部 文件内容封装到Properties
        properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
//    public static UserService getUserService() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//        Class clazz=Class.forName(properties.getProperty("userService"));
//        UserService userService=(UserService)clazz.newInstance();
//        return userService;
//    }

    /*
        通用工厂
     */
    public static Object getBean(String beanName) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class clazz=Class.forName(properties.getProperty(beanName));
        return clazz.newInstance();
    }
}

至此，可以发现，我们提供的工厂方法可以被任意对象所调用，并创建通用的对象，这样我们解决代码耦合性的同时，也解决了一个对象创建一个工厂的问题，减少了代码的冗余。