Java 工厂模式与应用
摘要
本文通过对静态工厂进行简单的介绍。并介绍与实现其与其他两种设计模式——单例模式与享元模式，的组合实现，以达到特定的功能实现。
一. 简单工厂模式简介
简单工厂模式是在面向对象编程中一种常用的设计模式。该设计模式 “重塑” 了对象的创建过程，使得能够对象的创建、控制、管理得到了便利。
但请注意，简单工厂模式与方法设计模式并不是完全相同的，这分别是两种设计模式
一般情况下，创建一个对象时需要通过 new 操作使用对象类的构造函数来进行对象的创建
测试类
public class Person {
private String name;
private int age;
public Person(String name,int age) {
this.name = name;
this.age = age;
}
//以下是私有成员变量的 set 与 get 方法
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public void setName(Sring name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
-
一般的对象创建
public class Main { public static void main(String[] args) { Person p = new Person("Fxtack", 20); } } -
使用工厂设计模式的对象创建
首先要设计工厂类
简单工厂模式的主要特征就是，其功能由一个（或多个）静态工厂方法来实现对象的创建
public class PersonFactory() { //简单工厂模式的一大特征是使用静态工厂方法 public Person static getPersonBean(String name,int age) { return new Person(name,age); } }
创建对象时，通过调用 PersonFactory 中的静态工厂方法来获取 Person 对象
public class Main {
public static void main(String[] args) {
Person p = PersonFactory.getPersonBean();
}
}
看似使用工厂模式只是将 new 的操作套娃到一个静态方法中了而已。但实际上，上述的例子只是一个最基础的例子，只展现了工厂模式的思想。接下来详细讲述工厂模式的优劣与应用。
二. 简单工厂模式
通过使用简单工厂模式，使得通过一个工厂，得到不同所需的对象。
所有可获取类的父接口
public interface Person {
void login();
void exit();
}
接口的两种实现类
public class User implements Person {
private String name;
public User() {}
public User(String name) {
this.name = name;
}
@Override
public void login() {
System.out.println("The User login.");
}
@Override
public void exit() {
System.out.println("The User exit.");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
public class Administrator implements Person {
private String name;
public Administrator() {}
public Administrator(String name) {
this.name = name;
}
@Override
public void login() {
System.out.println("The administrator login.");
}
@Override
public void exit() {
System.out.println("The administrator exit.");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
静态工厂类
public class PersonFactory {
//通过静态方法获取对象时，需要传入 beanName 参数来确定所需的对象
public Person static getBean(String beanName) {
//通过 if 语句判断所需的对象，并返回对象
if(beanName.equals("user")) {
return new User();
}else if(beanName.equals("administrator")) {
return new Administrator();
}else {
//若 beanName 参数无法与任何类型对象匹配，则返回为 null
//此处也可以抛出一个异常来表示对象获取失败
return null;
}
}
}
//注意，本例中使用字符串来决定返回类型。也可以使用枚举类型
使用工厂获取对象
public class Main {
public static void main(String[] args) {
//使用工厂方法获取对象时需要进行强制类型转换，因为工厂方法放回的是 Person 类型
//获取 User 对象
User u = (User) PersonFactory.getBean("user");
//获取 Administrator 对象
Administrator a = (Administrator) PersonFactory.getBean("administrator")
}
}
显然，通过工厂，我们可以获取任何 Person 接口具体实现类的对象。这也正是工厂模式的一大优点。
三. 静态工厂模式 + 单例模式
由于工厂的存在，使得我们可以在工厂方法内对对象的创建进行操作、控制、管理。顺理成章的，我们可以通过工厂模式与单例模式进行组合，来达到特定的需求。
工厂模式 + 单例模式
public class PersonFactory {
//存储单例的对象
private static User user;
private static Administrator administrator;
public Person static getBean(String beanName) {
if(beanName.equals("user")) {
//若成员 user 为 null 则创建该对象，不为 null 则返回先前创建的 User 对象
if(user == null) {
return this.user = new User();
}else{
return user;
}
}else if(beanName.equals("administrator")) {
//若成员 administrator 为 null 则创建该对象，
//不为null则返回先前创建的 Administrator 对象
if(user == null) {
return this.administrator = new Administrator();
}else{
return administrator;
}
}else {
return null;
}
}
}
可见，通过再一层的 if 判断，实现了从工厂中获取对象时，获取的对象保持单例的状态。这保证了工厂模式在创建重量级对象（创建时要消耗大量资源）时，可以避免不必要的系统开销。
在工厂模式与单例模式的组合中，也可见，并不是每次调用工厂方法都会创建一个对象。与之相似的是工厂模式与享元模式的组合
四. 静态工厂模式 + 享元模式
享元模式，我们可以通俗的认为就是就是对象池。比如 Java 中的 String 对象就存在于一个 String 对象的池中管理。通过对象池，可以更好的管理对象，提升性能。
工厂模式 + 享元模式
import java.util.HashMap;
import java.util.Map;
public class UserFactory {
//以HashMap为池来进行对象管理
Map<String, User> map = new HashMap<String, User>();
//注意，此处的 userName 与上文中的 beanName 意义不同
public User static getBean(String userName) {
//如果 userName 的 key 所对应的值为 null 则创建该对象并返回
//若 userName 的 key 所对应的的 User 对象值存在，则返回该对象
if(map.get(userName) == null) {
User u = new User(userName);
map.put(userName, u);
return u;
}else {
return map.get(userName)
}
}
}
测试 UserFactory
public class Main {
public static void main(String[] args) {
User u1 = UserFactory.getBean("Bob");
User u2 = UserFactory.getBean("Dave");
User u3 = UserFactory.getBean("Bob");
System.out.println(u1);
System.out.println(u2);
System.out.println(u3);
}
}
测试结果
User@4554617c
User@74a14482
User@4554617c
可见，两次使用参数 “Bob” 来获取 User 对象获得的是同一个对象的引用，并且也可以创建其他的 User 对象，实现了 User 对象的池化管理。
但本例中使用 HashMap 直接作为对象池，在管理轻量对象时性能并不高（JVM 对轻量对象的管理将更高效），并且也缺乏对对象池大小的限制。若采用这种方式作为对象池，可以在静态工厂方法中加入更多的逻辑。
总结 [1]
优点
通过上述案例，我们可以得知工厂模式和其与其他模式的组合存在以下优点。
- 使用简单工厂模式创建对象时，可以根据多个不同名称或方法签名的静态工厂方法进行调用。
一般构造方法在创建对象时，可进行重载。若两个构造方法签名一致，但是表达的意思不同，则无法书写两个不一样的构造方法。
构造方法签名一致，但意思不同的情况
public class User {
private String name;
private String password;
private String adress;
// 这种构造方法的写法是错误的，这不符合方法重写的规范
public User(String name, String password) {
this.name = name;
this.password = password;
this.address = "";
}
public User(String name, String adress) {
this.name = name;
this.password = name + adress;
this.adress = adress;
}
}
因为简单工厂模式中的静态工厂方法可以有多种名称，因此避免了这个问题。
-
每次对静态工厂方法的调用不一定都会创建一个新对象
在本文中三四节对简单工厂模式与单例模式和享元模式的组合中可以证实这一点。 -
通过简单工厂模式可以获取原返回类型的任何子类型对象，使对象的创建灵活性更强
在本文第二节实现了该点。通过对静态工厂方法传入参数不同，可以任意获取 Person 接口的实现类对象。 -
简单工厂模式中静态工厂方法返回的对象可以根传入据静态工厂方法的参数不同而不同
这点与总结的第一点类似。不过该点是针对同一个类的对象。
缺点
-
该模式添加新的对象时需要直接修改静态工厂方法中的逻辑，这样的扩展不利于后期维护。违反了开放封闭原则（OCP，Open Closed Principle）
-
该模式的静态工厂方法由于是静态方法，无法进行重载与重写。可扩展性差
-
在使用该模式获取对象时，需要依赖一定的上下文规范
例如本文第二节，需要对静态工厂方法传入 “user” 才能成功创建对象，而不是 “USER” 或 “User” 。这是一种上下文规范，在使用工厂时，必须充分了解该规范，才能正确使用工厂。在 spring 中这种规范是自定义的。
参考文献
[1] Joshua Bloch.Effective Java.机械工业出版社:,2019:6-8.
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
