使用工厂模式、策略模式实现BASE64,MD5,SHA,HMAC,DES各种加密算法

最新推荐文章于 2024-07-20 18:25:34 发布
最新推荐文章于 2024-07-20 18:25:34 发布
阅读量356 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/sld880311/blog/1485936
版权

定义枚举类型，包含已经集成的加密算法

package com.sunld.manager_core.tools.encipher.enums;
/** * @author 孙辽东 
    * <p>createDate:2014年3月7日 上午11:30:44</p> 
    * @version V1.0 
*/
public enum EncipherEnum {
    BASE64, 
    MD5, 
    SHA, 
    HMAC, 
    DES
}

设计工厂模式,定义了加密和解密抽象方法，并且使用反射实例化具体的Factory

package com.sunld.manager_core.tools.encipher.factory;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.factory.FactoryInterface;
import com.sunld.manager_core.file.property.PropertyUtil;
import com.sunld.manager_core.tools.encipher.enums.EncipherEnum;
import com.sunld.manager_core.util.rtti.ClassUtils;


/** * <p>加密工厂类</p> 
    * @author 孙辽东 
    * <p>createDate:2014年3月7日 上午11:27:08</p> 
    * @version V1.0 
*/
public abstract class EncipherFactory implements FactoryInterface{
    protected static final String ENCIPHERKEY = PropertyUtil.getPropertyValue("SYSTEM.ENCIPHERKEY");
    /** 
      * <p>Protected constructor to prevent instantiation. 
      * Use {@link #newInstance}</p> 
      * <p>createDate:2014年3月7日 上午11:29:35</p> 
    */
    protected EncipherFactory(){}

    /** * 
        * @param encipherEnum {@link EncipherEnum} 
        * @return EncipherFactory 
        * <p>createDate:2014年3月7日 上午11:30:59</p> 
    */
    public static EncipherFactory newInstance(EncipherEnum encipherEnum){
        try {
            return (EncipherFactory) ClassUtils.forName(PropertyUtil.getPropertyValue("SYSTEM."+encipherEnum)).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            throw new BusinessException("很抱歉，名称为"+encipherEnum+"的获取加密算法的具体工厂还没创建！",e);
        } 
    }

    public abstract String encrypt(String str);
    public abstract String decrypt(String str);
}

具体实现

BASE64Encipher
package com.sunld.manager_core.tools.encipher.encipherstrategy;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.exception.ExceptionUtil;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
import com.sunld.manager_core.util.other.StringUtil;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;


/** 
  * <p>BASE64的加密解密是双向的，可以求反解。</p> 
  * @author 孙辽东 
  * <p>createDate:2014年3月7日 上午11:40:59</p> 
  * @version V1.0 
*/
public class BASE64Encipher extends EncipherFactory{

    public String encrypt(String str) {
        if(StringUtil.isNotNull(str)){
            byte[] b = null;
            try {
                b = (str+ENCIPHERKEY).getBytes("utf-8");//防止中文乱码utf-8,并且转换成对应的编码
            } catch (UnsupportedEncodingException e) {
                throw new BusinessException("采用BASE64算法加密失败："+ExceptionUtil.formatException(e),e);
            }
            return (new BASE64Encoder()).encodeBuffer(b);
        }else{
            return "";
        }
    }

    public String decrypt(String str) {
        if(StringUtil.isNotNull(str)){
            String result = "";
            try {
                byte[] b = (new BASE64Decoder()).decodeBuffer(str);
                result = new String(b,"utf-8");
                result = result.substring(0,result.indexOf(ENCIPHERKEY));
            } catch (IOException e) {
                throw new BusinessException("采用BASE64算法解密失败："+ExceptionUtil.formatException(e),e);
            }
            return result;
        }else{
            return "";
        }
    }

}
DESPlusEncipher
package com.sunld.manager_core.tools.encipher.encipherstrategy;
import java.security.Key;
import java.security.Security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.exception.ExceptionUtil;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
import com.sunld.manager_core.util.other.StringUtil;

/** 
  * <p>DES DES-Data Encryption Standard,即数据加密算法。DES算法的入口参数有三个:Key、Data、Mode。</p> 
  * <p>Key:8个字节共64位,是DES算法的工作密钥;</p> 
  * <p>Data:8个字节64位,是要被加密或被解密的数据;</p> 
  * <p>Mode:DES的工作方式,有两种:加密或解密。</p> 
  * @author 孙辽东 
  * <p>createDate:2014年3月7日 下午1:35:34</p> 
  * @version V1.0 
*/
public class DESPlusEncipher extends EncipherFactory{
    private Cipher encryptCipher = null;

    private Cipher decryptCipher = null;
    /** * 完成信息初始化 * <p>createDate:2014年3月7日 下午1:57:34</p> */
    public DESPlusEncipher(){
        Security.addProvider(new com.sun.crypto.provider.SunJCE());
        Key key = getKey(ENCIPHERKEY.getBytes());

        try{
            encryptCipher = Cipher.getInstance("DES");
            encryptCipher.init(Cipher.ENCRYPT_MODE, key);

            decryptCipher = Cipher.getInstance("DES");
            decryptCipher.init(Cipher.DECRYPT_MODE, key);
        }catch(Exception e){
            throw new BusinessException("构造DES加密器时出错！",e);
        }

    }
    public String encrypt(String str) {
        try {
            return StringUtil.byteArray2HexStr(encryptCipher.doFinal(str.getBytes()));
        } catch (IllegalBlockSizeException | BadPaddingException e) {
            throw new BusinessException("采用DES算法加密失败："+ExceptionUtil.formatException(e),e);
        } 
    }

    public String decrypt(String str) {
        try {
            return new String(decryptCipher.doFinal(StringUtil.hexStr2ByteArray(str)));
        } catch (IllegalBlockSizeException | BadPaddingException e) {
            throw new BusinessException("采用DES算法解密失败："+ExceptionUtil.formatException(e),e);
        }
    }
    /** 
      * <p>从指定字符串生成密钥，密钥所需的字节数组长度为8位 不足8位时后面补0，超出8位只取前8位</p> 
      * @param arrBTmp 
      * @return Key 
      * <p>createDate:2014年3月7日 下午1:59:01</p> 
    */
    private Key getKey(byte[] arrBTmp){
        // 创建一个空的8位字节数组（默认值为0）
        byte[] arrB = new byte[8];
        // 将原始字节数组转换为8位
        for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
            arrB[i] = arrBTmp[i];
        }
        // 生成密钥
        Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");
        return key;
    }

}
HMACEncipher
package com.sunld.manager_core.tools.encipher.encipherstrategy;
import java.math.BigInteger;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.exception.ExceptionUtil;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
import com.sunld.manager_core.util.other.StringUtil;

/** 
  * <p>HMAC是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。</p> 
  * <p>HMAC算法有一个密钥，增强了数据传输过程中的安全性，强化了算法外的不可控因素。</p> 
  * @author 孙辽东 
  * <p>createDate:2014年3月7日 下午1:21:57</p> 
  * @version V1.0 
*/
public class HMACEncipher extends EncipherFactory{

    private static final String MACKEY = "HmacMD5";

    public String encrypt(String str) {
        if(StringUtil.isNotNull(str)){
            String result = "";
            try{
                SecretKey secretKey = new SecretKeySpec(ENCIPHERKEY.getBytes(), MACKEY);
                Mac mac = Mac.getInstance(secretKey.getAlgorithm());
                mac.init(secretKey);
                byte[] b = mac.doFinal((str+ENCIPHERKEY).getBytes());
                result = (new BigInteger(b)).toString(16);
            }catch(Exception e){
                throw new BusinessException("采用HMAC算法加密失败："+ExceptionUtil.formatException(e),e);
            }
            return result;
        }else{
            return "";
        }
    }

    public String decrypt(String str) {
        throw new BusinessException("HMAC加密算法是单项的，不能进行反向解密");
    }

    /** 
      * 签名工具 
      * @return String 
      * <p>createDate:2014年3月7日 下午1:25:53</p> 
    */
    public  String initMacKey(){
        String key = "";
        try{
            KeyGenerator keyGenerator = KeyGenerator.getInstance(MACKEY);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] b = secretKey.getEncoded();
            String str = new String(b);
            key =  str;
        }catch(Exception e){
            throw new BusinessException("在使用HMAC加密算法获取密钥时出错："+ExceptionUtil.formatException(e),e);
        }
        return key;
    }

}
MD5Encipher
package com.sunld.manager_core.tools.encipher.encipherstrategy;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.exception.ExceptionUtil;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
import com.sunld.manager_core.util.other.StringUtil;

/** 
  * <p>MD5是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。</p> 
  * @author 孙辽东 
  * <p>createDate:2014年3月7日 下午1:05:16</p> 
  * @version V1.0 
*/
public class MD5Encipher extends EncipherFactory{

    public String encrypt(String str) {
        if(StringUtil.isNotNull(str)){
            String result = "";
            MessageDigest md;
            try {
                md = MessageDigest.getInstance("MD5");
                md.update((str+ENCIPHERKEY).getBytes());
                byte[] b = md.digest();
                result = StringUtil.byteArray2HexStr(b);
            } catch (NoSuchAlgorithmException e) {
                throw new BusinessException("采用MD5算法加密失败："+ExceptionUtil.formatException(e),e);
            }
            return result;
        }else{
            return "";
        }
    }
    public String decrypt(String str) {
        throw new BusinessException("MD5加密算法是单项的，不能进行反向解密");
    }

}
SHAEncipher
package com.sunld.manager_core.tools.encipher.encipherstrategy;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import com.sunld.manager_core.exception.BusinessException;
import com.sunld.manager_core.exception.ExceptionUtil;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
import com.sunld.manager_core.util.other.StringUtil;

/** 
  * <p>SHA是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。</p> 
  * @author 孙辽东 
  * <p>createDate:2014年3月7日 下午1:18:48</p> 
  * @version V1.0 
*/
public class SHAEncipher extends EncipherFactory{

    public String encrypt(String str) {
        if(StringUtil.isNotNull(str)){
            String result = "";
            MessageDigest md;
            try {
                md = MessageDigest.getInstance("SHA");
                md.update((str+ENCIPHERKEY).getBytes());
                byte[] b = md.digest();
                result = StringUtil.byteArray2HexStr(b);
            } catch (NoSuchAlgorithmException e) {
                throw new BusinessException("采用SHA算法加密失败："+ExceptionUtil.formatException(e),e);
            }
            return result;
        }else{
            return "";
        }
    }

    public String decrypt(String str) {
        throw new BusinessException("SHA加密算法是单项的，不能进行反向解密");
    }

}

根据不同的加密算法生成相关的key

KeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
import com.sunld.manager_core.factory.LogDefinitionFactory;

/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:37:18</p> 
  * @version V1.0 
*/
public interface KeyStrategy extends LogDefinitionFactory{
    public abstract String toKey(String paramString, Object paramObject);
}
AbstractKeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
import java.util.regex.Pattern;

import com.sunld.manager_core.tools.encipher.enums.EncipherEnum;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;
/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:41:04</p> 
  * @version V1.0 
*/
public abstract class AbstractKeyStrategy implements KeyStrategy{
    private static final int DEFAULT_MAX_KEY_LENGTH = 250;
    private static final Pattern CLEAN_PATTERN = Pattern.compile("\\s");
    private int maxKeyLength;
    public AbstractKeyStrategy(){
        this.maxKeyLength = DEFAULT_MAX_KEY_LENGTH; 
    }
    public String toKey(String regionName, Object key) {
        if (key == null) {
            throw new IllegalArgumentException("key must not be null");
        }
        String keyString = concatenateKey(regionName, transformKeyObject(key));
        if (keyString.length() > this.maxKeyLength) {
            return truncateKey(keyString);
        }
        String finalKey = CLEAN_PATTERN.matcher(keyString).replaceAll("");
        LOGGER.debug("Final cache key: [{" + finalKey + "}]");
        return finalKey;
    }
    protected abstract String transformKeyObject(Object paramObject);
    protected String truncateKey(String key){
        String keyHashCode = EncipherFactory.newInstance(EncipherEnum.MD5).encrypt(key);
        LOGGER.warn("Encoded key [{" + key + "}] to md5 hash [{" + keyHashCode + "}]. " + "Be sure to set cache region names whenever possible as the names Hibernate generates are really long.");
        return keyHashCode;
    }
    public int getMaxKeyLength() {
        return this.maxKeyLength;
    }
    public void setMaxKeyLength(int maxKeyLength) {
        this.maxKeyLength = maxKeyLength;
    }
    protected String concatenateKey(String regionName, Object key) {
        return regionName + ":" + String.valueOf(key);
    }
}
HashCodeKeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:40:28</p> 
  * @version V1.0 
*/
public class HashCodeKeyStrategy extends AbstractKeyStrategy{
    protected String transformKeyObject(Object key){
        int hashCode = key.hashCode();
        if (LOGGER.isInfoEnabled())
            LOGGER.info("Transformed key [{" + key + "}] to hashCode [{" + hashCode + "}]");
        return String.valueOf(hashCode);
    }
}
Md5KeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
import com.sunld.manager_core.tools.encipher.enums.EncipherEnum;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;



/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:49:13</p> 
  * @version V1.0 
*/
public class Md5KeyStrategy extends HashCodeKeyStrategy{
     protected String concatenateKey(String regionName, Object key){
        String longKey = super.concatenateKey(regionName, key);
        return EncipherFactory.newInstance(EncipherEnum.MD5).encrypt(longKey);
     }
}
Sha1KeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
import com.sunld.manager_core.tools.encipher.enums.EncipherEnum;
import com.sunld.manager_core.tools.encipher.factory.EncipherFactory;



/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:51:22</p> 
  * @version V1.0 
*/
public class Sha1KeyStrategy extends HashCodeKeyStrategy{
    protected String concatenateKey(String regionName, Object key){
        String longKey = super.concatenateKey(regionName, key);
        return EncipherFactory.newInstance(EncipherEnum.SHA).encrypt(longKey);
    }
}
StringKeyStrategy
package com.sunld.manager_core.tools.encipher.keystrategy;
/** 
  * @author 孙辽东 
  * <p>createDate:2014年5月29日 上午11:52:38</p> 
  * @version V1.0 
*/
public class StringKeyStrategy extends AbstractKeyStrategy{
    protected String transformKeyObject(Object key){
        String stringKey = String.valueOf(key);
        if (LOGGER.isInfoEnabled())
            LOGGER.info("Transformed key [{" + key + "}] to string [{" + stringKey + "}]");
        return stringKey;
    }
}

转载于:https://my.oschina.net/sld880311/blog/1485936

chensdag1989
关注
2-策略模式
文白的博客
03-15 692
策略模式（政策模式）定义一系列的算法，通过实现接口将其一个个封装起来，使它们可以相互替换。
设计模式解密（3）- 策略模式
Json_wangqiang的博客
07-03 311
  1、简介 定义：定义一组算法，将每个算法都封装起来，并且使他们之间可以互换。 策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。 英文：Strategy 类型：行为类模式 2、实例引入 背景：模拟商城的促销活动，旨在了解模式 先定义一个活动接口： package c...
策略模式设计文件加密解密应用
Carmelo_7的博客
03-30 1056
在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
策略模式
车的杂货铺
12-19 357
《Head First Design Patterns》策略模式学习练习： 没有采用书中给出的demo，以我们常见的“字符串加密解密”实体类为例。 选择理由：加密解密方式有很多种，像MD5加密，AES加密。而这些在后期可能会因为种种需求而进行调整或者切换。采用策略模式，可以使这些变化变得可控，而不会影响之前的代码。（具体代码附在最后） 大概设计： 接口Processor，接口具体实现AESP
策略模式封装的几个加密解密算法源码
08-02
在网络上看到几个加密解密算法，本着"取之于民用之于民"的方针测试一下，并用策略模式将这些算法封装共享。
加密算法（二）：Base64、MD5、SHA系列 、DES 和 HMAC
最新发布
总结复盘，才能不迷失自己！
07-20 867
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点，可以被加以破解，对于需要高度安全性的数据，专家一般建议改用其他算法，如SHA-2。
Vue-常用加密(MD5,DES,SHA256,BASE64,SHA1,RSA)
11-29
在 Vue 中，常见的加密算法包括 MD5、DES、SHA256、BASE64、SHA1、RSA 等。BASE64 只是一种编码格式，并不是加密算法，但常用于在 HTTP 环境下传递较长的标识信息。 加密算法的选择需要根据实际情况进行选择，考虑...
Python实现常见的几种加密算法(MD5，SHA-1，HMAC，DES/AES，RSA和ECC)
12-20
本文将探讨如何使用Python实现常见的几种加密算法，包括MD5、SHA-1、HMAC、DES、AES以及非对称加密算法RSA和ECC。 1. MD5（Message-Digest Algorithm 5）： MD5是一种广泛使用的散列函数，它能将任意长度的信息映射...
Java中常用的加密算法：BASE64, MD5, SHA, HMAC等
本文主要介绍了Java中常用的几种加密算法，包括BASE64、MD5、SHA、HMAC、DES、PBE、RSA、DH、DSA和ECC等，并提供了简单的编码和解码示例。 在计算机安全领域，加密算法扮演着至关重要的角色，用于保护数据的隐私性...
策略模式（Strategy）
Lunar_Queen的博客
05-29 346
设计模式之策略模式。 策略模式的主要作用是：整体地替换算法。 无论什么程序，其目的都是解决问题。而为了解决问题，我们需要编写特定的算法。使用Strategy模式可以整体地替换算法的实现部分。能够整体地替换算法，能让我们轻松地以不同的算法解决同一个问题，这种模式就是Strategy模式。 示例代码如下： #include&amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; using namespa...
Java设计模式-策略模式
cc_百川
03-16 322
最近学习到设计模式，现总结个人学习策略模式内容【结果一样关注过程，即注重的是行为】。 上一篇：Java设计模式-适配器模式 文章目录定义优缺点优点缺点实现代码测试 定义 在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。定义好各种不同行为【策略不同】，但是其最求目的相对稳定 优缺点 优点 扩展性好，不用添加策略对原有系统无影响。 策略可以自由选择。...
2、策略模式
是小光a~
06-18 675
策略模式： 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化（策略模式是对算法的包装，是把使用算法的责任和算法本身分割开，委派给不同的对象管理）。 使用策略模式可以把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略类( ConcreteStrategy)中提供。 由于算法和环境独立开来，算法的增减、修改都不会影响环境和客户端。当出现新的促销折扣或现有的折扣政策出现变化时，只需要实现新的
策略模式(一)
sidongxue2的专栏
06-06 988
策略模式:定义一系列算法,把它们一个个封装起来,并且使他们可以相互替换. 在某些设计中,一些类的设计人员经常遇到这样的问题:由于用户需求的变化,导致经常需要修改类中的某个方法,即需要不断的改变算法. 面对这样的问题,不用担心,面向对象编程有一个很好的设计原则"面向抽象编程",该原则的核心就是将类中经常需要变化的部分分割出来, 并且把每种可能的变化对应的交给抽象类的一个子类去负责,从而让类的设
JAVA设计模式之【策略模式】
ganyang_的博客
01-28 941
工厂模式是解耦对象的创建和使用，观察者模式是解耦观察者和被观察者。策略模式跟两者类似，也能起到解耦的作用，解耦的是策略的定义、创建、使用这三部分。 通常的使用方式 ** 1.策略定义 ** 一个策略接口和一组实现这个接口的策略类。因为所有的策略类都实现相同的接口，所以，客户端代码基于接口而非实现编程，可以灵活地替换不同的策略。 public interface Strategy { void algorithm(); } public class StrategyA implements Strate
策略模式实现
一个喜欢诗和远方的程序媛
03-29 503
23种设计模式之策略模式
设计模式系列-策略模式-Strategy
独 coding 乐不如众 coding 乐
06-28 237
本文我们将讨论策略模式，是非常常用的一个模式，我们应该熟悉掌握，策略模式的定义：定义一系列算法，每个都封装起来可换着使用，策略使算法独立于使用它的客户端而变化。使用策略模式可以使我们的代码设计高内聚、松耦合。 策略模式介绍 在应用开发中，你将经常编写一些利用不同算法来满足一些业务需求的对象。一个常见的例子是支持数字排序的类，可以用冒泡排序、合并排序和快排。类似的，一个文件压缩类可以支持不同的压缩算法，比如ZIP,GZIP,LZ4 或者一个定制的压缩算法。另一个例子是数据加密类可以用不同的加密算法，例如AES
「设计模式(一) - 策略模式」
我有一壶酒，足以慰风尘
01-15 194
「设计模式(一) - 策略模式」 一、从if-else说起 代码中if-else的出现频率不必多说，几乎的逻辑实现都离不这个组合。但是带来了方便的同时，也带来了多重嵌套代码块。套用重构的一句话，这些都是代码的坏味道。过多的条件判断必然增加了系统不稳定性，同时也给扩展带来了不便因素。当然优化的方式多种多样，策略模式Strategy仅仅只是其中简单的一种。 二、策略模式 Strategy 行为模式的一种，定义了一系列平行的算法，将实现与责任相分离并加以封装，当然各个策略之间是可以相互转化的。由客户端决定使用何
趣谈设计模式 | 策略模式(Strategy)：你还在使用冗长的if-else吗？
凌桓丶的博客
10-31 1144
文章目录案例：指挥官AI策略模式配合工厂模式总结完整代码与文档 案例：指挥官AI 案例可能不符合实际逻辑，仅用于表述设计模式的思想，勿介意 假设我们开发了一款类似全面战争的即时战略游戏，为了能够增加玩家的对抗体验，我们决定设计一个指挥官AI，与以往的无脑人机不同，指挥官会根据战况以及玩家的操作，来指定克制玩家的计策。 例如当玩家派出骑兵时，指挥官就会派出枪兵，当玩家退回城中防守时，指挥官就会派出破城槌来攻城。 于是我们初步的设计如下，我们使用If-else这样的条件判断，根据玩家的不同行为来做出不同的操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值