实验3：工厂方法模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解工厂方法模式的动机，掌握该模式的结构；

2、能够利用工厂方法模式解决实际问题。

[实验任务一]：加密算法

目前常用的加密算法有DES（Data Encryption Standard）和IDEA（International Data Encryption Algorithm）国际数据加密算法等，请用工厂方法实现加密算法系统。

实验要求：

1. 画出对应的类图；

2. 提交该系统的代码，该系统务必是一个可以能够直接使用的系统，查阅资料完成相应加密算法的实现；

DES截图

IDEA截图

代码

//MethodFactory:
package com.hua.jiami;  
public interface MethodFactory {  
public Method produceMethod();  
}  
package com.hua.jiami;  
public interface Method {  
public abstract void work(String str, String password);  
}  
package com.hua.jiami;  
public class DESFactory implements MethodFactory {  
public DES produceMethod() {  
System.out.println("使用DES算法");  
return new DES();  
}  
}  


package com.hua.jiami;  
public class IDEAFactory implements MethodFactory {  
public IDEA produceMethod() {  
System.out.println("使用IDEA算法");  
return new IDEA();  
}  
}  


package com.hua.jiami;  
import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
public class DES implements Method {  
public void work(String str, String password) {  
String codeStringBegin = "20214165高振华"; // 要加密的明文  
String codeStringEnd = null; // 加密后的密文  
String decodeString = null; // 密文解密后得到的明文  
System.out.println("要加密的明文:" + codeStringBegin);  
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();  
}  
}  
public static void main(String[] args) {  
// TODO Auto-generated method stub  
System.out.println("DES加密算法");  
DES des = new DES();  
try {  
des.work("8787878787878787", "0E329232EA6D0D73");  
} catch (Exception e) {  
System.out.println(e.getMessage());  
}  
}  
}  



package com.hua.jiami;  
import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
import org.apache.commons.codec.binary.Base64;  
import org.bouncycastle.jce.provider.BouncyCastleProvider;  
import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
import javax.crypto.spec.SecretKeySpec;  
import java.security.Key;  
import java.security.Security;  
public class IDEA implements Method {  
public static final String KEY_ALGORITHM = "IDEA";  
public static final String CIPHER_ALGORITHM = "IDEA/ECB/ISO10126Padding";  
public static byte[] initkey() throws Exception {  
// 加入bouncyCastle支持  
Security.addProvider(new BouncyCastleProvider());  
// 实例化密钥生成器  
KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);  
// 初始化密钥生成器，IDEA要求密钥长度为128位  
kg.init(128);  
// 生成密钥  
SecretKey secretKey = kg.generateKey();  
// 获取二进制密钥编码形式  
return secretKey.getEncoded();  
}  
/** 
* 转换密钥 
* 
* @param key 
*            二进制密钥 
* @return Key 密钥 
*/  
private static Key toKey(byte[] key) throws Exception {  
// 实例化DES密钥  
// 生成密钥  
SecretKey secretKey = new SecretKeySpec(key, KEY_ALGORITHM);  
return secretKey;  
}  
/** 
* 加密数据 
* 
* @param data 
*            待加密数据 
* @param key 
*            密钥 
* @return byte[] 加密后的数据 
*/  
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {  
// 加入bouncyCastle支持  
Security.addProvider(new BouncyCastleProvider());  
// 还原密钥  
Key k = toKey(key);  
// 实例化  
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
// 初始化，设置为加密模式  
cipher.init(Cipher.ENCRYPT_MODE, k);  
// 执行操作  
return cipher.doFinal(data);  
}  
/** 
* 解密数据 
* 
* @param data 
*            待解密数据 
* @param key 
*            密钥 
* @return byte[] 解密后的数据 
*/  
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {  
// 加入bouncyCastle支持  
Security.addProvider(new BouncyCastleProvider());  
// 还原密钥  
Key k = toKey(key);  
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
// 初始化，设置为解密模式  
cipher.init(Cipher.DECRYPT_MODE, k);  
// 执行操作  
return cipher.doFinal(data);  
}  
public static String getKey() {  
String result = null;  
try {  
result = Base64.encodeBase64String(initkey());  
} catch (Exception e) {  
e.printStackTrace();  
}  
return result;  
}  
public static String ideaEncrypt(String data, String key) {  
String result = null;  
try {  
byte[] data_en = encrypt(data.getBytes(), Base64.decodeBase64(key));  
result = Base64.encodeBase64String(data_en);  
} catch (Exception e) {  
e.printStackTrace();  
}  
return result;  
}  
public static String ideaDecrypt(String data, String key) {  
String result = null;  
try {  
byte[] data_de = decrypt(Base64.decodeBase64(data), Base64.decodeBase64(key));  
;  
result = new String(data_de);  
} catch (Exception e) {  
e.printStackTrace();  
}  
return result;  
}  
public void work(String str, String password) {  
String data = "20214165高振华";  
String key = getKey();  
System.out.println("要加密的原文：" + data);  
System.out.println("密钥：" + key);  
String data_en = ideaEncrypt(data, key);  
System.out.println("密文：" + data_en);  
String data_de = ideaDecrypt(data_en, key);  
System.out.println("原文：" + data_de);  
}  
public static void main(String[] args) {  
// TODO Auto-generated method stub  
System.out.println("IDEA加密算法");  
IDEA idea = new IDEA();  
try {  
idea.work("8787878787878787", "0E329232EA6D0D73");  
} catch (Exception e) {  
System.out.println(e.getMessage());  
}  
}  
}  



package com.hua.jiami;  
import java.util.Scanner;  
public class zhuhanshu {  
public static void main(String[] args) {  
DES des = new DES();  
IDEA idea = new IDEA();  
try {  
int n = 0;  
Scanner in = new Scanner(System.in);  
while (n != 3) {  
System.out.println("请选择要使用的加密算法 1.DES加密算法 2.IDEA加密算法");  
System.out.println("3.退出");  
System.out.println("请选择：");  
if (in.hasNextInt()) {  
n = in.nextInt();  
} else {  
System.out.println("输入的不是整数，请重新输入：");  
continue;  
}  
switch (n) {  
case 1: {  
des.work("1787878787878787", "0E329232EA6D0D73");  
break;  
}  
case 2: {  
idea.work("8787878787878787", "0E329232EA6D0D73");  
break;  
}  
}  
}  
}  
catch (Exception e) {  
System.out.println(e.getMessage());  
}  
}  
}