实验1：框架设计者

实验1.框架设计者

SortorTest->BubbleSort。客户依赖具体的服务BubbleSort，地球人都知道这不好。
SortorTest->IntSort<=BubbleSort。应用程序SortorTest遵循针对接口编程/抽象依赖原则，依赖抽象类型IntSort，而BubbleSort自然地依赖父类型。
【SortorTest->IntSort】。这一步是关键。如果需要，将控制模块SortorTest设计成框架，可以将控制模块SortorTest和它必须依赖的抽象类型IntSort打包。控制模块SortorTest从应用程序(上层模块)变为框架(下层模块)。最好能够提供JavaDoc，并且将方法名sort 改成soooooort——体现控制反转(Inversion of Control)。
Main->【SortorTest->IntSort】<=BubbleSort。（其他程序员）使用框架。
带main的BubbleSort，BubbleSort->【SortorTest ->IntSort】<=BubbleSort。与第一步“依赖倒置”。

----------------------------------------------------------------------

本文介绍何谓框架，并提供了一个最简单的框架——对两个double操作后返回一个double值。

1、何谓框架

框架/framework是在底层/下层模块中定义的一个骨架式方案，处理各种应用中面临的共同的底层细节；而应用开发者可以按照自己的需求使用框架，给出自己的功能实现——只需要填入自己的东西/flesh。如果是applet或GUI框架，就有太多底层细节需要处理，因而最简单的框架util.DoubleOP仅仅说明这是一个骨架式方案——对两个double操作后返回一个double值。在这个骨架式方案，本框架处理了....大量的技术细节，不过代码被省略了。

本框架可以使你对两个double进行各种操作，如相加，比较、求幂等等，你具体如何应用，需要你按照自己的需求提供代码。

package util;
/**
 *框架/framework的目的，是定义一个骨架式方案，处理各种应用中面临的共同的底层细节；
 * @author yqj2065
 * @version 2016.7
 */
@FunctionalInterface 
public interface  DoubleOP {
    //对两个double操作后返回一个double值.可以使你对两个double进行各种操作，如相加，比较、求幂等等
    double op(double m,double n) ;
}

嗯，最简单的框架就是一个函数接口，它对两个double操作后返回一个double值。类似于JUnit，我们还设计了一个包含main(String[] args)启动本框架的类Main。使用本框架时，请在配置文件my.properties中指定将要创建的对象，键为2065。

package util;
import tool.God;
public class Main{
    /**
     * 命令行启动本框架。
     * @param args 至少两个double
     */
   public static void main(String[] args){
        DoubleOP f = (DoubleOP)God.create("2065");
        double d =f.op(Double.parseDouble(args[0]),Double.parseDouble(args[1]));
        System.out.println(d);
    }
    /**
     * 和JUnit一样，提供App调用的方式。
     */
    public static double runFramework(DoubleOP f,double x,double y){
        return f.op(x,y);
    } 
}

注意，框架一般使用的技术就是反射和回调。

tool.God利用反射和配置文件创建某个对象，
Main调用 f.op(double,double)，具体的方法体由上层代码提供。

ok，框架已经设计完成。

2.如何使用框架

现在是我们应用程序员干活的时候了。快哭了应用程序员最开始当然写HelloWorld，来熟悉框架..

.HelloWorld不能够和高傲的框架在一个包中，principle.callback.lowe，你可以想象它被打包为一个jar。

框架的使用者，通常进行填空式编程。

这就是库与框架的区别——上层模块的程序员直接调用的，属于库函数；要求上层模块的程序员提供的回调函数的，属于框架。

package abc;
public class HelloWorld implements util.DoubleOP{
    public double op(double m,double n){
        return m+n;
    }
}

第二步，按照框架的要求，自己写好配置文件。于是我们在my.properties中加上下面的键值对：

2065=principle.callback.HelloWorld

第三步，在命令行中运行和测试框架，例如：

E:\designPattern>java principle.callback.lower.Main 1.2 3.4
4.6

通常，我们应用程序员不会在控制台直接启动或调用框架，而是在应用程序中启动或调用框架，这就是框架的Main提供

runFramework(MyFramework ,double,double)的意义。框架的设计者真的很贴心。我们的应用程序如下：

package abc;
import tool.God;
import <span style="font-family: Arial, Helvetica, sans-serif;">util.DoubleOP</span>;
import util.Main;
public class App{
    public static void main(String[] args){
        DoubleOPf = (DoubleOP)God.create("2065");
        double d = Main.runFramework(f,1.2,3.4);
        System.out.println(d);
    }
}

既然HelloWorld也在本包中，应用程序App可以直接使用它而不用反射。我们也可以在App使用匿名类、λ表达式直接描述自己的需求——不定义太多的HelloWorld这样的类。

package abc;
import tool.God;
import util.DoubleOP;
import util.Main;
public class App{
    public static void main(String[] args){
        DoubleOP f = (DoubleOP)God.create("2065");
        double d = Main.runFramework(f,1.2,3.4);
        System.out.println(d);
    }
    public static void test(){
        double d = Main.runFramework(new HelloWorld(),1,3);
        System.out.println(d);
        
        DoubleOP f = (double m,double n)->{return m * n ;};
        d = Main.runFramework(f,1,3);
        System.out.println(d);
        
        f = (m,n)->{return m +2*n ;};
        d = Main.runFramework(f,1,3);
        System.out.println(d);

        d = Main.runFramework((m,n)->{return m-n ;},1,3);
        System.out.println(d);
    }
}

运行test()输出：

4.0
3.0
7.0
-2.0

3.何谓控制反转

拜托，在我的术语表中没有控制反转（Inversion of Control，英文缩写为IoC）这个垃圾术语，我不知道它是什么东西。