工厂类设计

1、典型代码

User：

public class User {
    private String username;
    private String password;
	...

UserService：

public interface UserService {
    //注册
    public void register(User user);
    //登录
    public void login(String username, String password);
}

UserServiceImpl：

public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();
    @Override
    public void register(User user) {
        userDao.save(user);
    }

    @Override
    public void login(String username, String password) {
        userDao.select(username, password);
    }
}

UserDao：

public interface UserDao {
    //保存
    public void save(User user);
    //查询
    public void select(String username, String password);
}

UserDaoImpl：

//只用于演示
public class UserDaoImpl implements UserDao{
    @Override
    public void save(User user) {
        System.out.println(user);
    }

    @Override
    public void select(String username, String password) {
        System.out.println(username + " " + password);
    }
}

测试：

public class UserServiceImplTest {

    @Test
    public void test1() {
        UserService userService = new UserServiceImpl();
        userService.login("张三","123");

        User user = new User("李四","456");
        userService.register(user);
    }
}

2、使用工厂类创建对象

在测试的代码中，存在耦合

UserService userService = new UserServiceImpl();

当 UserServiceImpl 改变时，会使调用者跟着改变

这时，我们使用工厂设计模式，让工厂去创建对象

BeanFactory：

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

更改测试代码

测试：

public class UserServiceImplTest {

    @Test
    public void test1() {
        //UserService userService = new UserServiceImpl();
        UserService userService = BeanFactory.getUserService();
        userService.login("张三","123");

        User user = new User("李四","456");
        userService.register(user);
    }
}

可以看出在测试代码中，耦合被消除

但在工厂类中，还是通过 new 来创建对象，要怎消除工厂类的耦合呢？

3、工厂类的设计

怎么消除工厂类的耦合呢

我们创建对象的方法除了 new 一个对象，还可以通过反射的方式创建对象，而反射的方式创建对象是可以解耦合的

BeanFactory：

public class BeanFactory {
    public static UserService getUserService() {

        UserService userService = null;
        try {
            Class clazz = Class.forName("com.dong.UserServiceImpl");
            userService = (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userService;
    }
}

但我们还是没有彻底消除耦合，因为存在全限定类名 com.dong.UserServiceImpl ，当我们更换类名时，forName 中的全限定类名也必须更换，还是要进行再次编译

该怎么解决这一问题呢？

我们可以使用小配置文件，替换代码中的字符串

在 resource 目录下，创建 application.properties 文件

application.properties：

userService = com.dong.UserServiceImpl

但是，我们将全限定类名写入小配置文件，又该怎么读入工厂类呢？

我们可以将 properties 文件封装进 properties 集合中，properties 集合的 key value 都是字符串类型

将小配置文件中 userService 当作 properties 集合中的 key，com.dong.UserServiceImpl 当作集合中的 value

再使用 properties 集合中的 properties.getProperty("key") 就可以进行文件内容的读取

BeanFactory：

public class BeanFactory {
    private static Properties properties = new Properties();

    static {
        try {
            //1.获得IO输入流
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/application.properties");
            //2.将文件内容封装到Properties集合中
            properties.load(inputStream);

            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static UserService getUserService() {
        UserService userService = null;
        try {
            Class clazz = Class.forName(properties.getProperty("userService"));
            userService = (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userService;
    }
}

因为要尽量避免重复的打开IO流，我们在启动程序时，就一次性加载完所有资源，所以写在静态代码块中

resource 目录和 Java 目录是同一等级目录，都是项目的根目录

4、通用工厂类设计

我们已经实现了代码之间的解耦合

但是，我们需要创建多少对象，那里有耦合，就要在BeanFactory中写多少个获取对象的方法，这是很难不方便的

能不能用一种通用的创建对象的方法，只用一种方法，就可以创建所有对象，或是大部分对象

BeanFactory：

public static Object getBean(String objectName) {
    Object obj = null;
    try {
        Class clazz = Class.forName(properties.getProperty(objectName));
        obj = clazz.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return obj;
}

将要创建的对象在小配置文件中的key当做参数，传入方法

完整工厂类：

public class BeanFactory {
    private static Properties properties = new Properties();

    static {
        try {
            //1.获得IO输入流
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/application.properties");
            //2.将文件内容封装到Properties集合中
            properties.load(inputStream);

            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Object getBean(String objectName) {
        Object obj = null;
        try {
            Class clazz = Class.forName(properties.getProperty(objectName));
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}