我想使用 java 8 新的默认方法重构模板方法。假设我在抽象类中有一个流程定义：
public abstract class FlowManager{
public void startFlow(){
phase1();
phase2();
}
public abstract void phase1();
public abstract void phase2();
}
而且我几乎没有扩展上述流程管理器的子类，并且每个子类都实现了自己的phase1方法phase2。我想知道将代码重构为这样的接口是否有意义：
public interface FlowManager{
public default startFlow(){
this.phase1();
this.phase2();
}
public void phase1();
public void phase2();
}
你怎么看？
使用带有默认方法的接口来实现模板方法模式对我来说似乎很可疑。
默认方法通常（但不总是）旨在被实现者覆盖。如果将接口的默认方法用作模板方法，则覆盖方法很容易出现编程错误，例如不调用super方法、在错误的时间调用它、更改阶段调用的顺序等。这些都是模板方法模式旨在避免的编程错误。
通常不打算重写模板方法。在 Java 类中，这可以通过创建方法来表示final。接口不能有最终方法；看到这个问题的理由。因此，最好使用带有 final 方法的抽象类作为模板来实现模板方法模式。
除了较早的答案之外，请注意还有更多的可能性。首先是将模板方法分离到自己的类中：
public interface Flow {
void phase1();
void phase2();
}
public final class FlowManager {
private final Flow flow;
public FlowManager(Flow flow) {
this.flow = flow;
}
public void startFlow() {
flow.phase1();
flow.phase2();
}
}
如果你已经在使用FlowManager.phaseX方法，你也可以让它实现Flow接口：
public final class FlowManager implements Flow {
private final Flow flow;
public FlowManager(Flow flow) {
this.flow = flow;
}
public void startFlow() {
flow.phase1();
flow.phase2();
}
@Override
public void phase1() {
flow.phase1();
}
@Override
public void phase2() {
flow.phase2();
}
}
通过这种方式，您明确表示用户必须实现Flow接口，但他们不能更改startFlow模板方法，因为它在最终类中声明。
Java 8 添加了一个新的函数模式来解决您的问题：
public final class FlowManager {
private final Runnable phase1;
private final Runnable phase2;
public FlowManager(Runnable phase1, Runnable phase2) {
this.phase1 = phase1;
this.phase2 = phase2;
}
public void startFlow() {
phase1.run();
phase2.run();
}
public void phase1() {
phase1.run();
}
public void phase2() {
phase2.run();
}
}
好吧，这段代码甚至在 Java 8 之前就可以工作，但现在您可以创建FlowManager更方便的使用 lambda 或方法引用。
您还可以组合这些方法：定义接口并提供一种从 lambda 构造它的方法：
public interface Flow {
void phase1();
void phase2();
static Flow of(Runnable phase1, Runnable phase2) {
return new Flow() {
@Override
public void phase1() {
phase1.run();
}
@Override
public void phase2() {
phase2.run();
}
};
}
}
Java 8 中的Collector接口以类似的方式实现。现在，根据用户的偏好，他们可以直接实现接口，也可以在Flow.of(...)那里使用并传递 lambda 或方法引用。
//设计模板类
public class Template {
protected interface MastSuppler{
List<Mast> apply(int projectId);
}
protected interface Transform<T>{
List<T> apply(List<Mast> masts);
}
protected interface PropertiesConsumer<T>{
void apply(List<T> properties);
}
public <T> void template(int projectId, MastSuppler suppler, Transform<T> transform, PropertiesConsumer<T> consumer){
System.out.println("projectId is " + projectId);
//1.List<Mast> masts = step1(int projectId);
List<Mast> masts = suppler.apply(projectId);
//2.List<T> properties = step2(List<Mast> masts)
List<T> properties = transform.apply(masts);
//3.use or consume these properties（print to console ,save to datebase）
consumer.apply(properties);
}
}
//与客户端一起使用
public class Mast {
public static void main(String[] args) {
//1.save to db
new Template().template(1,
projectId->getMastsfromMongo(projectId),
masts-> masts.stream().map(mast->mast.getName()).collect(Collectors.toList()),
names->System.out.println("save names to db "+ names));
//new Template(1, id->Arrays, );
//2.print to console
new Template().template(2,
projectId->getMastsSomewhere(projectId),
masts-> masts.stream().map(mast->mast.getLat()).collect(Collectors.toList()),
names->System.out.println("print lons to console "+ names));
}
private static List<Mast> getMastsfromMongo(int projectId){
Mast m1 = new Mast("1", 110, 23);
Mast m2 = new Mast("2", 111, 13);
return Arrays.asList(m1, m2);
}
private static List<Mast> getMastsSomewhere(int projectId){
Mast m1 = new Mast("3", 120, 53);
Mast m2 = new Mast("4", 121, 54);
return Arrays.asList(m1, m2);
}
private String name;
private double lon;
private double lat;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getLon() {
return lon;
}
public void setLon(double lon) {
this.lon = lon;
}
public double getLat() {
return lat;
}
public void setLat(double lat) {
this.lat = lat;
}
public Mast(String name, double lon, double lat) {
super();
this.name = name;
this.lon = lon;
this.lat = lat;
}
}
这两种方法都行得通。
使用哪一个在很大程度上取决于您FlowManager将拥有的其他功能以及您以后将如何使用它。
如果您还需要对某些状态进行建模，抽象类将允许您定义非静态字段。它还将允许拥有私有或受保护的方法。
另一方面，接口将使不相关的类更容易实现，因为您不会被限制为单继承。
Java 的教程在“与接口相比的抽象类”部分中很好地总结了它：
http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
我花了一些时间来理解 Java 8 中 Template 方法的实现，这就像魔术 :) 我们在 Java 8 中实现它的方式有些不同。
1-父类没有在其主体中定义方法（稍后将在子类中实现），它将它们定义为最终方法签名中的参数。
2-基于上述，子类不必在其主体中提供实现，它将在实例化期间提供实现。
import java.util.function.Consumer;
public abstract class FlowManager<T> {
public final void startFlow(T t,
Consumer<T> phase1,
Consumer<T> phase2){
phase1.accept(t);
phase2.accept(t);;
}
}
执行
public class FlowManager2<T>
extends FlowManagerJava8<String>{
}
主班
import java.util.function.Consumer;
public class Main {
public static void main(String args[]){
new FlowManager2<String>().startFlow("Helo World",
(String message)->System.out.println("Phase 1 : "+ message),
(String message)->System.out.println("Phase 2 : "+ message));
Consumer<String> phase1 =
(String message)-> System.out.println("Phase 1 : "+ message);
Consumer<String> phase2 =
(String message)-> System.out.println("Phase 2 : "+ message);
new FlowManager2<String>().startFlow("Helo World",
phase1,
phase2);
}
}