简单工厂模式与策略模式

工厂模式

工厂模式属于创建型模式，这个模式中不会暴露给你具体的创建过程，只会返给你
抽象的对相，就跟你去饭馆吃饭点了一个红烧鱼一样，你不需要知道这个红烧鱼是怎么做的，你要做的是吃就行。工厂模式侧重的是对象的创建；

实现规则很简单，首先有一个公共的抽象类或者接口，不同的行为分别继承自这个接口或者这个抽象类，具体定义一个工厂类，根据不同的特征来生产你想要的类。

比如说实现最简单的计算器功能：

• 抽象类

public interface Operation {

    int operat(int num1, int num2);

}

• 加法类

public class AddOperation implements Operation{


    @Override
    public int operat(int num1, int num2) {
        return num1 + num2;
    }

}

• 减法类

public class SubtractionOperation implements Operation{

    @Override
    public int operat(int num1, int num2) {
        return num1 - num2;
    }

}

• 工厂类

public class FactoryUtils {

    public static Operation createOperation(String op) {
        Operation operation = null;
        switch (op) {
        case "+":
            operation = new AddOperation(); 
            break;
        case "-":
            operation = new SubtractionOperation(); 
            break;
        default:
            break;
        }

        return operation;
    }
}

• main方法

public class FactoryMain {

    public static void main(String[] args) {
        int num1 = 100;
        int num2 = 200;
        //加法
        Operation op = FactoryUtils.createOperation("+");
        int result = op.operat(num1, num2);
        System.out.println(result);
        //减法
        op = FactoryUtils.createOperation("-");
        result = op.operat(num1, num2);
        System.out.println(result);

    }
}

策略模式

策略模式是定义了一系列的算法，把这些算法封装起来，使他们之间可以相互替换，这些算法独立于他的客户端并且可以相互变化，其实就是客户不用不用关心他们是怎么实现的，只需要给我一个结果即可。
这里需要注意的是 策略模式注重的是行为算法，而工厂模式注重的是对象的创建
其实这两个是可以联合使用的。

策略模式的实现需要三个角色：

• 抽象策略(strategy):定义一个抽象类或者接口，并给出具体策略的接口。
• 具体策略：抽象策略的实现类，具体实现了相关的算法和行为。

• 环境类：持有一个策略的引用。
  举个列子，还是比如上面的计算器：

• 抽象策略

public interface Strategy {

    int operate(int num1, int num2);
}

• 具体策略

package com.zyd.strategy.model;

public class AddStrategy implements Strategy{

    @Override
    public int operate(int num1, int num2) {
        return num1 + num2;

    }


}

package com.zyd.strategy.model;

public class SubtractionStrategy implements Strategy{

    @Override
    public int operate(int num1, int num2) {
        return num1 - num2;

    }


}

• 环境类

package com.zyd.strategy.model;

public class Context {

    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }


    public void executeOperate(int num1, int num2) {
        System.out.println(strategy.operate(num1, num2));
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public Strategy getStrategy() {
        return strategy;
    }
}

• 具体调用

package com.zyd;

import com.zyd.strategy.model.AddStrategy;
import com.zyd.strategy.model.Context;
import com.zyd.strategy.model.SubtractionStrategy;

public class StrategyMain {
    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        context.executeOperate(10, 100);

        Context context1 = new Context(new SubtractionStrategy());
        context1.executeOperate(10, 100);
    }
}

策略模式到此就实现完了，其实很简单。
前面我们也提到了工厂模式，实际上在通常的做法中，这两种是可以结合起来的，利用工厂模式来创建对象：

package com.zyd.strategy.model;

public class FactoryUtil {

    public static Strategy createStragegy(String op) {
        Strategy Strategy = null;
        switch (op) {
        case "+":
            Strategy = new AddStrategy(); 
            break;
        case "-":
            Strategy = new SubtractionStrategy(); 
            break;
        default:
            break;
        }

        return Strategy;
    }
}

而实际调用的代码就变成了这样：

package com.zyd;

import com.zyd.strategy.model.Context;
import com.zyd.strategy.model.FactoryUtil;

public class StrategyMain {
    public static void main(String[] args) {
        Context context = new Context(FactoryUtil.createStragegy("+"));
        context.executeOperate(10, 100);

        Context context1 = new Context(FactoryUtil.createStragegy("-"));
        context1.executeOperate(10, 100);
    }
}

策略模式和工厂模式到这就基本结束了，是不是很简单？
其实还可以更进阶一点，如果我们在增加一个乘法或者除法的，那我们就必须去修工厂类，再加一个case才行，这个是简单工厂模式的缺点，有什么办法来解决这个事情么？ 肯定有的，那就是注解。

那么首先 我们定义一个元注解：

package com.zyd.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationOperation {

    String operate() default "+";
}

ElementType.TYPE表示只作用于类
@Retention(RetentionPolicy.RUNTIME) 运行是注解
真正关键是实现简单工厂类：

package com.zyd.strategy.model;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.GenericArrayType;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import com.zyd.annotation.AnnotationOperation;

public class FactoryUtil {

    private String packageName = this.getClass().getPackage().getName();
    private  ClassLoader loader = this.getClass().getClassLoader();

    //获取包名下的所有类的名字
    private List<String> getPackageNames(String pkgName){

        List<String> list = new ArrayList<>();
        try {
            File file = new File(loader.getResource(pkgName.replace(".", "/")).toURI());
            String[] names = file.list();
            for (String str : names) {
                if(str.endsWith(".class")) {
                    list.add(str);
                }
            }
        } catch (URISyntaxException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return list;
    }
    //根据包名，加载出所有的类
    private  List<Class> getClasses(List<String> names){
        List<Class> list = new ArrayList<>();
        for (String name : names) {
            try {
                Class<?> clazz = loader.loadClass(packageName + "." + name.replace(".class", ""));

                list.add(clazz);
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return list;
    }

    public  Strategy createStragegy(String op) {
        try {
            List<Class> list = getClasses(getPackageNames(packageName));
            for (Class class1 : list) {
                if(FactoryUtil.class.equals(class1) 
                        || Strategy.class.equals(class1)
                        || Context.class.equals(class1)) {
                    continue;
                }
                Annotation[] ans = class1.getAnnotations();
                AnnotationOperation ope = null;
                for(Annotation an : ans) {
                    if(an instanceof AnnotationOperation) {
                        ope = (AnnotationOperation) an;
                        break;
                    }
                }

                if(ope != null) {
                    if(ope.operate().equals(op)) {
                        return (Strategy) class1.newInstance();
                    }
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return null;
    }
}

那么main方法就要改成这样了：

package com.zyd;

import com.zyd.strategy.model.Context;
import com.zyd.strategy.model.FactoryUtil;

public class StrategyMain {
    public static void main(String[] args) {
        FactoryUtil util = new FactoryUtil();
        Context context = new Context(util.createStragegy("+"));
        context.executeOperate(10, 100);

        Context context1 = new Context(util.createStragegy("-"));
        context1.executeOperate(10, 100);
    }
}

上面的注解很简单，稍微有点注解基础应该就能看懂

这样话如果你要是添加一个乘法类的话，只需要实现策略类，并且添加注解就OK了。
欢迎关注我的公众号： manong_xiaodong