1.定义:
简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
2.UML图:
3.代码:
package com.skiff.www.factory.simplefactory.fruit;
/**
* @author 一叶扁舟(skiff)
* @ClassName: AbstractFruit
* @Description:
* @create 2018-08-03 14:13
**/
//Product:抽象产品角色
public abstract class AbstractFruit {
public abstract void eat();
}
package com.skiff.www.factory.simplefactory.fruit;
/**
* @author 一叶扁舟(skiff)
* @ClassName: Apple
* @Description:
* @create 2018-08-03 14:14
**/
//ConcreteProduct:具体产品角色
public class Apple extends AbstractFruit {
@Override
public void eat() {
System.out.println("正在吃苹果。。。。。");
}
}
package com.skiff.www.factory.simplefactory.fruit;
/**
* @author 一叶扁舟(skiff)
* @ClassName: Orange
* @Description:
* @create 2018-08-03 14:17
**/
//ConcreteProduct:具体产品角色
public class Orange extends AbstractFruit {
@Override
public void eat() {
System.out.println("正在吃橘子。。。。。");
}
}
package com.skiff.www.factory.simplefactory.fruit;
/**
* @author 一叶扁舟(skiff)
* @ClassName: SimpleFactory
* @Description:
* 模式结构
简单工厂模式包含如下角色:
Factory:工厂角色
Product:抽象产品角色
ConcreteProduct:具体产品角色
* @create 2018-08-03 14:18
**/
//Factory:工厂角色
public class SimpleFactory {
/**
* 根据传入的参数,创建出具体的对象
* @param fruitName
* @return
*/
public static AbstractFruit getFruit1(String fruitName) throws Exception{
if(fruitName.equalsIgnoreCase("apple")){
return new Apple();
}else if(fruitName.equalsIgnoreCase("orange")){
return new Orange();
}else {
System.out.println("没有这个水果");
return null;
}
}
/**
* 利用反射获取对应的对象,特别要注意:这个传入的参数,一定是一个真实的类名
* @param fruitName
* @return
* @throws Exception
*/
public static AbstractFruit getFruit2(String fruitName) throws Exception{
Class fruit = Class.forName("com.skiff.www.factory.simplefactory.fruit." + fruitName);
return (AbstractFruit) fruit.newInstance();
}
}
package com.skiff.www.factory.simplefactory.fruit;
import org.junit.Test;
/**
* @author 一叶扁舟(skiff)
* @ClassName: TestSimpleFactory
* @Description:
* @create 2018-08-03 14:29
**/
public class TestSimpleFactory {
@Test
public void eatFruit1(){
try {
AbstractFruit apple = SimpleFactory.getFruit1("Apple");
apple.eat();
AbstractFruit orange = SimpleFactory.getFruit1("Orange");
orange.eat();
AbstractFruit branner = SimpleFactory.getFruit1("Branner");
branner.eat();
}catch (Exception e){
e.printStackTrace();
}
}
@Test
public void eatFruit2() throws Exception{
AbstractFruit apple = SimpleFactory.getFruit2("Apple");
apple.eat();
AbstractFruit orange = SimpleFactory.getFruit2("Orange");
orange.eat();
}
}
4.简单工厂优缺点:
(1)、简单工厂模式的优点
工厂类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的责任,而仅仅“消费”产品;简单工厂模式通过这种做法实现了对责任的分割,它提供了专门的工厂类用于创建对象。
(2)、简单工厂模式的缺点
由于工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都要受到影响。 使用简单工厂模式将会增加系统中类的个数,在一定程序上增加了系统的复杂度和理解难度。
系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能造成工厂逻辑过于复杂,不利于系统的扩展和维护。
5.简单工厂的应用:
模式适用环境 :
在以下情况下可以使用简单工厂模式: 工厂类负责创建的对象比较少:由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。
客户端只知道传入工厂类的参数,对于如何创建对象不关心:客户端既不需要关心创建细节,甚至连类名都不需要记住,只需要知道类型所对应的参数。
(1)、模式应用1
在JDK类库中广泛使用了简单工厂模式,如工具类java.text.DateFormat,它用于格式化一个本地日期或者时间
public final static DateFormat getDateInstance(); public final static DateFormat getDateInstance(int style); public final static DateFormat getDateInstance(int style,Locale locale); |
(2)、模式应用2
Java加密技术
//获取不同加密算法的密钥生成器 KeyGenerator keyGen=KeyGenerator.getInstance("DESede"); //创建密码器 Cipher cp=Cipher.getInstance("DESede"); |
例子:
package com.skiff.www.factory.simplefactory;
import org.junit.Test;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* @Auther: 一叶扁舟
* @Date: 2018/10/30 22:11
* @Description:
*/
public class JDKDate {
// public final static DateFormat getDateInstance();
// public final static DateFormat getDateInstance(int style);
// public final static DateFormat getDateInstance(int style, Locale locale);
//
@Test
public void testDate() {
DateFormat dateFormat = DateFormat.getDateInstance();
// 格式化日期:2018-10-30
String format = dateFormat.format(new Date());
System.out.println("格式化日期:" + format);
String format1 = DateFormat.getTimeInstance().format(new Date());
// 格式化日期时间:22:20:46
System.out.println("格式化时间:" + format1);
String format2 = new SimpleDateFormat().format(new Date());
System.out.println("使用simpleDateFormat:"+format2);
String format3 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date());
System.out.println("使用simpleDateFormat:"+format3);
}
}
例子:
package com.skiff.www.factory.simplefactory.encode;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* @Auther: 一叶扁舟
* @Date: 2018/10/30 21:58
* @Description:
*/
public class DESEncrypt {
public static void main(String args[])
{
String codeStringBegin="一叶扁舟(skiff)"; //要加密的明文
String codeStringEnd=null; //加密后的密文
String decodeString=null; //密文解密后得到的明文
String cipherType = "DESede"; //加密算法类型,可设置为DES、DESede、AES等字符串
try
{
//获取密钥生成器
KeyGenerator keyGen=KeyGenerator.getInstance(cipherType);
//初始化密钥生成器,不同的加密算法其密钥长度可能不同
keyGen.init(112);
//生成密钥
SecretKey key=keyGen.generateKey();
//得到密钥字节码
byte[] keyByte=key.getEncoded();
//输出密钥的字节码
System.out.println("密钥是:");
for(int i=0;i<keyByte.length;i++)
{
System.out.print(keyByte[i]+",");
}
System.out.println("");
//创建密码器
Cipher cp=Cipher.getInstance(cipherType);
//初始化密码器
cp.init(Cipher.ENCRYPT_MODE,key);
System.out.println("要加密的字符串是:"+ codeStringBegin);
byte[] codeStringByte=codeStringBegin.getBytes("UTF8");
System.out.println("要加密的字符串对应的字节码是:");
for(int i=0;i<codeStringByte.length;i++)
{
System.out.print(codeStringByte[i]+",");
}
System.out.println("");
//开始加密
byte[] codeStringByteEnd=cp.doFinal(codeStringByte);
System.out.println("加密后的字符串对应的字节码是:");
for(int i=0;i<codeStringByteEnd.length;i++)
{
System.out.print(codeStringByteEnd[i]+",");
}
System.out.println("");
codeStringEnd=new String(codeStringByteEnd);
System.out.println("加密后的字符串是:" + codeStringEnd);
System.out.println("");
//重新初始化密码器
cp.init(Cipher.DECRYPT_MODE,key);
//开始解密
byte[] decodeStringByteEnd=cp.doFinal(codeStringByteEnd);
System.out.println("解密后的字符串对应的字节码是:");
for(int i=0;i<decodeStringByteEnd.length;i++)
{
System.out.print(decodeStringByteEnd[i]+",");
}
System.out.println("");
decodeString=new String(decodeStringByteEnd);
System.out.println("解密后的字符串是:" + decodeString);
System.out.println("");
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
6.总结:
(1)、创建型模式对类的实例化过程进行了抽象,能够将对象的创建与对象的使用过程分离。 简单工厂模式又称为静态工厂方法模式,它属于类创建型模式。
(2)、在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
(3)、简单工厂模式包含三个角色:
工厂角色负责实现创建所有实例的内部逻辑;
抽象产品角色是所创建的所有对象的父类,负责描述所有实例所共有的公共接口;
具体产品角色是创建目标,所有创建的对象都充当这个角色的某个具体类的实例。
(4)、简单工厂模式的要点在于:
当你需要什么,只需要传入一个正确的参数,就可以获取你所需要的对象,而无须知道其创建细节。
简单工厂模式最大的优点在于实现对象的创建和对象的使用分离,将对象的创建交给专门的工厂类负责,但是其最大的缺点在于
工厂类不够灵活,增加新的具体产品需要修改工厂类的判断逻辑代码,而且产品较多时,工厂方法代码将会非常复杂。
简单工厂模式适用情况包括:工厂类负责创建的对象比较少;客户端只知道传入工厂类的参数,对于如何创建对象不关心。