简单工厂模式:
简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式(同属于创建型模式的还有工厂方法模式,抽象工厂模式,单例模式,建造者模式)。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
简单工厂模式由三部分组成:具体工厂、具体产品和抽象产品。
工厂类(Creator)角色:担任这个角色的是简单工厂模式的核心,含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象,它往往由一个具体Java类实现。
抽象产品(AbstractProduct)角色:担任这个角色的类是由简单工厂模式所创建的对象的父类,或它们共同拥有的接口。抽象产品角色可以用一个Java接口或者Java抽象类实现。
具体产品(ConcreteProduct)角色:简单工厂模式所创建的任何对象都是这个角色的实例,具体产品角色由一个具体Java类实现
模式优点
工厂类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的责任,而仅仅“消费”产品;简单工厂模式通过这种做法实现了对责任的分割,它提供了专门的工厂类用于创建对象。
客户端无须知道所创建的具体产品类的类名,只需要知道具体产品类所对应的参数即可,对于一些复杂的类名,通过简单工厂模式可以减少使用者的记忆量。
通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。
当需要引入新的产品是不需要修改客户端的代码,只需要添加相应的产品类并修改工厂类就可以了,所以说从产品的角度上简单工厂模式是符合“开-闭”原则的。
模式缺点
由于工厂类集中了所有产品创建逻辑,工厂类一般被我们称作“全能类”或者“上帝类”,因为所有的产品创建他都能完成,这看似是好事,但仔细想想是有问题的。比如全国上下所有的事情都有国家主义一个人干会不会有问题,当然有!一旦不能正常工作,整个系统都要受到影响。
使用简单工厂模式将会增加系统中类的个数,在一定程序上增加了系统的复杂度和理解难度。
系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能造成工厂逻辑过于复杂,不利于系统的扩展和维护。所以说从工厂的角度来说简单工厂模式是不符合“开-闭”原则的。
简单工厂模式由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构。
简单工厂模式 + 模板方法模式
public interface DataOperation<K, V> {
/**
* 类的描述
* @return
*/
String getClassDescription();
/**
* 插入数据
* @param k
* @param v
*/
void insertData(K k,V v);
/**
* 根据value查找key
* @param v
* @return
*/
K findKey(V v);
/**
* 根据value查找key
* @param k
* @return
*/
V findValue(K k);
/**
* 删除key
* @param k
*/
void deleteKey(K k);
}
public abstract class AbstractDataOperation<K,V> implements DataOperation<K,V>,Serializable{
/**
* 类的描述
* @return
*/
@Override
public String getClassDescription(){
return this.getClass().getName();
}
/**
* 插入数据
* @param k
* @param v
*/
@Override
public void insertData(K k,V v){
init();
insertDataChild(k,v);
}
/**
* 根据value查找key
* @param v
* @return
*/
@Override
public K findKey(V v){
init();
return findKeyChild(v);
}
/**
* 根据value查找key
* @param k
* @return
*/
@Override
public V findValue(K k){
init();
return findValueChild(k);
}
/**
* 删除key
* @param k
*/
@Override
public void deleteKey(K k){
init();
deleteKeyChild(k);
}
private void init(){
System.out.println("SuperHakce\n");
}
public abstract void insertDataChild(K k,V v);
public abstract K findKeyChild(V v);
public abstract V findValueChild(K k);
public abstract void deleteKeyChild(K k);
}
@Transactional
@SuppressWarnings("uncheck")
public class RedisOperation<K,V> extends AbstractDataOperation<K,V> implements Serializable{
/**
* 插入数据
* @param k
* @param v
*/
public void insertDataChild(K k,V v){
}
/**
* 根据value查找key
* @param v
* @return
*/
public K findKeyChild(V v){
return null;
}
/**
* 根据value查找key
* @param k
* @return
*/
public V findValueChild(K k){
return null;
}
/**
* 删除key
* @param k
*/
public void deleteKeyChild(K k){
}
}
@Component
public class DataOperationFactory<K,V>{
public static final String REDIS = "Redis";
public static final String MONGODB = "MongoDB";
public final DataOperation<K,V> getDataOperation(String dataType){
switch (dataType){
case REDIS: {
return new RedisOperation<K,V>();
}
case MONGODB: {
return new RedisOperation<K,V>();
}
default:{
return new RedisOperation<K,V>();
}
}
}
}