实验3：工厂方法模式

实验3：工厂方法模式

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

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

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

 

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

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

实验要求：

1. 画出对应的类图；

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

3.注意编程规范。

MethodFactory.java

package jiami;

public interface MethodFactory {

    public Method produceMethod();

}

 

MethodFactory.java

package jiami;

 

public class DESFactory implements MethodFactory {

    public DES produceMethod() {

        System.out.println("使用DES算法");

        return new DES();

    }

}

 

MethodFactory.java

package jiami;

 

public class IDEAFactory implements MethodFactory {

    public IDEA produceMethod() {

        System.out.println("使用IDEA算法");

        return new IDEA();

    }

}

 

Method.java

package jiami;

public interface Method {

    public abstract void work(String str, String password);

}

 

DES.java

package 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 = "信1605-320163432 张运涛"; // 要加密的明文

        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());

        }

    }

 

}

 

IDEA.java

package 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 = "20163432张运涛";

        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());

        }

    }

 

}

zhuhanshu.java

package 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());

        }

    }

}