java游戏服务器 策略+简单工厂

上一篇中我们讲到简单工厂模式有它的弊端，它不好在哪里呢？

我们看到，每次创建场景，我们都需要暴露两个类。。。

这是比较不好的，

可以通过策略模式+简单工厂模式来稍微改造下

一.先来一个策略模式UML图（大话设计模式）

• Strategy:所有策略的基类
• StrategyA、StrategyB、StrategyC:三个策略子类
• Context:上下文，包含一个父类Strategy引用，指向具体的子类策略对象(聚合关系)

二.接下来我们以游戏服务端开发里的生活技能来讲解。这个需求非常适合策略模式。

这里简化下需求：

游戏里生活技能为采集（采矿、采药...）和合成（烹饪、铸造...）两大类。

我们稍微改造下UML图：

1.有一个Context上下文类：

LifeSkillContext2

2.有一个strategy抽象类：

/**
 * 生活技能策略基类
 * 基类，所以是抽象类，方便子类去不同的实现
 * @author lizhibiao
 * @date 2019/1/10 21:18
 */
public abstract class AbstractLifeSkillLogic

3.有一个StrategyA子类（这里我们把它也设计为抽象类)

/**
 * 采集抽象类
 * 这里是抽象类，是因为采集包括采矿、采药。。。
 * 方便子类覆写
 * @author lizhibiao
 * @date 2019/1/10 21:30
 */
public abstract class AbstractAbilityCollectLogic extends AbstractLifeSkillLogic

4.有一个StrategyB子类（这里我们把它也设计为抽象类）

/**
 *
 * 合成类
 * 这里把合成类，也定义为抽象类是因为合成类包括（烹饪、铸造...）
 * 方便子类覆写
 * @author lizhibiao
 * @date 2019/1/10 21:23
 */
public abstract class AbstractAbilityComposeLogic extends AbstractLifeSkillLogic

5.StrategyA类下面挂两个子类分别是采矿和采药

/**
 * 采矿
 * 继承采集抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:26
 */
public class AbilityMining extends AbstractAbilityCollectLogic

/**
 * 采药
 * 继承采集抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:30
 */
public class AbilityHerbs extends AbstractAbilityCollectLogic

6.同理StrategyB类下面也挂两个子类分别是烹饪和铸造

/**
 *
 * 烹饪
 * 继承合成抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:37
 */
public class AbilityCooking extends AbstractAbilityComposeLogic

/**
 * 铸造类
 * 继承合成抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:43
 */
public class AbilityCasting extends AbstractAbilityComposeLogic

三：依次开始上代码

/**
 *
 * 生活技能上下文2
 * @author lizhibiao
 * @date 2019/1/11 15:23
 */
public class LifeSkillContext2
{
    private AbstractLifeSkillLogic abstractLifeSkillLogic = null;

    public LifeSkillContext2(LifeSkillTypeEnum typeEnum)
    {
        switch (typeEnum)
        {
            case MINING:
                abstractLifeSkillLogic = new AbilityMining();
                break;
            case HERBS:
                abstractLifeSkillLogic = new AbilityHerbs();
                break;
            case COOKING:
                abstractLifeSkillLogic = new AbilityCooking();
                break;
            case CASTING:
                abstractLifeSkillLogic = new AbilityCasting();
                break;
            default:
                break;
        }
    }

    public AbstractLifeSkillLogic getAbstractLifeSkillLogic()
    {
        return abstractLifeSkillLogic;
    }
}

/**
 * 生活技能策略基类
 * 基类，所以是抽象类，方便子类去不同的实现
 * @author lizhibiao
 * @date 2019/1/10 21:18
 */
public abstract class AbstractLifeSkillLogic
{

    /**
     * 使用生活技能操作
     * 抽象方法
     */
    public abstract void lifeSkillOperate();



}

/**
 * 采集抽象类
 * 这里是抽象类，是因为采集包括采矿、采药。。。
 * 方便子类覆写
 * @author lizhibiao
 * @date 2019/1/10 21:30
 */
public abstract class AbstractAbilityCollectLogic extends AbstractLifeSkillLogic
{

    @Override
    public void lifeSkillOperate()
    {
        System.out.println("执行采集共有操作------操起镰刀，动手");
    }

}

/**
 *
 * 合成类
 * 这里把合成类，也定义为抽象类是因为合成类包括（烹饪、铸造...）
 * 方便子类覆写
 * @author lizhibiao
 * @date 2019/1/10 21:23
 */
public abstract class AbstractAbilityComposeLogic extends AbstractLifeSkillLogic
{

    @Override
    public void lifeSkillOperate()
    {
        System.out.println("执行合成公有操作----------烹饪和铸造先点火。。。");
    }

}

/**
 * 采矿
 * 继承采集抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:26
 */
public class AbilityMining extends AbstractAbilityCollectLogic
{
    @Override
    public void lifeSkillOperate()
    {
        super.lifeSkillOperate();

        System.out.println("我是采矿--------采矿。。采矿。。。");
    }
}

/**
 * 采药
 * 继承采集抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:30
 */
public class AbilityHerbs extends AbstractAbilityCollectLogic
{
    @Override
    public void lifeSkillOperate()
    {
        super.lifeSkillOperate();

        System.out.println("我是采药-------采药。。采药。。");
    }
}

/**
 *
 * 烹饪
 * 继承合成抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:37
 */
public class AbilityCooking extends AbstractAbilityComposeLogic
{

    @Override
    public void lifeSkillOperate()
    {
        super.lifeSkillOperate();

        System.out.println("我是烹饪----烹饪。。烹饪。。");

    }

}

/**
 * 铸造类
 * 继承合成抽象类
 * @author lizhibiao
 * @date 2019/1/11 14:43
 */
public class AbilityCasting extends AbstractAbilityComposeLogic
{
    @Override
    public void lifeSkillOperate()
    {
        super.lifeSkillOperate();

        System.out.println("我是铸造----铸造。。铸造。。");
    }
}

四：接下来，我们开始测试

1.添加一个枚举类，如下：

/**
 * 生活技能枚举类
 * @author lizhibiao
 * @date 2019/1/11 14:52
 */
public enum LifeSkillTypeEnum
{
    /**
     * 采矿
     */
    MINING,

    /**
     * 采药
     */
    HERBS,

    /**
     * 烹饪
     */
    COOKING,

    /**
     * 铸造
     */
    CASTING

}

2.开始测试

//采矿  注意这里只暴露一个LifeSkillContext2类
LifeSkillContext2 context = new LifeSkillContext2(LifeSkillTypeEnum.MINING);
AbstractLifeSkillLogic mining = context.getAbstractLifeSkillLogic();
if (null != mining)
{
    mining.lifeSkillOperate();
}

System.out.println();

//烹饪  注意这里只暴露一个LifeSkillContext2类
LifeSkillContext2 context2 = new LifeSkillContext2(LifeSkillTypeEnum.COOKING);
AbstractLifeSkillLogic cooking = context2.getAbstractLifeSkillLogic();
if (null != cooking)
{
    cooking.lifeSkillOperate();
}

看到没，

确实是只暴露了一个类

输出结果：

但是这也是有弊端的，你发现我们每次都需要new一个上下文类，这样效率太低了。

3.我们来改造下

新建一个上下文类：

**
 *
 * 生活技能上下文
 * @author lizhibiao
 * @date 2019/1/10 21:08
 */
public class LifeSkillContext
{
    private static AbstractLifeSkillLogic abstractLifeSkillLogic = null;


    public static int setLifeSkillLogic(LifeSkillTypeEnum typeEnum)
    {
        //先置null
        abstractLifeSkillLogic = null;

        switch (typeEnum)
        {
            case MINING:
                abstractLifeSkillLogic = new AbilityMining();
                return 0;
            case HERBS:
                abstractLifeSkillLogic = new AbilityHerbs();
                return 0;
            case COOKING:
                abstractLifeSkillLogic = new AbilityCooking();
                return 0;
            case CASTING:
                abstractLifeSkillLogic = new AbilityCasting();
                return 0;
            default:
                return -1;
        }
    }

    public static AbstractLifeSkillLogic getLifeSkillLogic()
    {
        return abstractLifeSkillLogic;
    }
}

测试类如下：

/**
 * 测试类
 * @author lizhibiao
 * @date 2019/1/11 15:05
 */
public class Main
{
    private static final int SUCESSED = 0;

    public static void main(String[] args)
    {
        //采矿
        int result = LifeSkillContext.setLifeSkillLogic(LifeSkillTypeEnum.MINING);
        if (result == SUCESSED)
        {
            LifeSkillContext.getLifeSkillLogic().lifeSkillOperate();
        }

        System.out.println();

        //烹饪
        result = LifeSkillContext.setLifeSkillLogic(LifeSkillTypeEnum.COOKING);
        if (result == SUCESSED)
        {
            LifeSkillContext.getLifeSkillLogic().lifeSkillOperate();
        }

    }
}

测试结果如下：

看到没，这里我们只需要暴露一个LifeSkillContext类，并且我们不需要每次都去new一个上下文！！