今天完成的事情

1. 了解了一下 Apache Tuscany

这个东西的好处是可以整合 service，把 service 整合成 component，然后又可以把 component 整合在一起暴露为 service，最后还能把任意 service 对外暴露为一个远程接口就问你怕不怕。

而且 Apache Tuscany 只约束接口，至于实现怎么去做，甚至用什么语言去做都都无所谓。在 Apache Tuscany 1.x 里面有一个计算器的例子，项目是 java 的，但是加减乘除分别用 js、ruby、python 和 groovy 四种语言实现。

2. 跑通了 Apache Tuscany 计算器的例子

加减乘除 service 照样写，不用写 @Service 注解。

引入依赖：

在这个例子中使用到的所有依赖就是下面这些

<dependencies>
    <!--https://mvnrepository.com/artifact/org.apache.tuscany.sca/tuscany-base-runtime-->
    <dependency>
        <groupId>org.apache.tuscany.sca</groupId>
        <artifactId>tuscany-base-runtime</artifactId>
        <version>2.0.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.tuscany.sca.aggregation/tuscany-binding-rmi-runtime-aggregation -->
    <dependency>
        <groupId>org.apache.tuscany.sca.aggregation</groupId>
        <artifactId>tuscany-binding-rmi-runtime-aggregation</artifactId>
        <version>2.0.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.tuscany.sca.aggregation/tuscany-binding-ws-runtime-axis2-aggregation -->
    <dependency>
        <groupId>org.apache.tuscany.sca.aggregation</groupId>
        <artifactId>tuscany-binding-ws-runtime-axis2-aggregation</artifactId>
        <version>2.0.1</version>
    </dependency>
</dependencies>

最后写好计算器的 service 实现：

这里我把整个文件都贴出来了，需要注意的是文件头的引入，可以看到使用的并不是 spring 的 @Service 注解。

package org.example.service.impl;

import org.example.service.*;
import org.oasisopen.sca.annotation.Reference;
import org.oasisopen.sca.annotation.Service;

/**
 * @ClassName CalculatorImpl
 * @Description TODO
 * @Author owlwinter
 * @Date 2020/7/27 18:59
 * @Version 1.0
 **/
@Service(Calculator.class)
public class CalculatorImpl implements Calculator {

    private Add add;
    private Divide divide;
    private Multiply multiply;
    private Subtract subtract;

    @Reference
    public void setAdd(Add add){
        this.add = add;
    }

    @Reference
    public void setDivide(Divide divide){
        this.divide = divide;
    }

    @Reference
    public void setMultiply(Multiply multiply){
        this.multiply = multiply;
    }

    @Reference
    public void setSubtract(Subtract subtract){
        this.subtract = subtract;
    }

    @Override
    public double add(double x, double y) {
        return this.add.add(x, y);
    }

    @Override
    public double divide(double x, double y) {
        return this.divide.divide(x, y);
    }

    @Override
    public double multiply(double x, double y) {
        return this.multiply.multiply(x, y);
    }

    @Override
    public double subtract(double x, double y) {
        return this.subtract.subtract(x, y);
    }


}

然后就是要写好其配置文件：Calculator.composite

<composite
        xmlns="http://docs.oasis-open.org/ns/opencsa/sca/200912"
        targetNamespace="http://com.jnshu"
        name="Calculator">
    <!--xmlns="http://www.osoa.org/xmlns/sca/1.0"-->
    <component name="CalculatorServiceComponent">
        <implementation.java class="org.example.service.impl.CalculatorImpl" />
        <reference name="add" target="AddComponent"/>
        <reference name="subtract" target="SubtractComponent"/>
        <reference name="multiply" target="MultiplyComponent"/>
        <reference name="divide" target="DivideComponent"/>
    </component>
    <component name="AddComponent">
        <implementation.java class="org.example.service.impl.AddImpl"/>
    </component>
    <component name="SubtractComponent">
        <implementation.java class="org.example.service.impl.SubtractImpl"/>
    </component>
    <component name="MultiplyComponent">
        <implementation.java class="org.example.service.impl.MultiplyImpl"/>
    </component>
    <component name="DivideComponent">
        <implementation.java class="org.example.service.impl.DivideImpl"/>
    </component>
</composite>

然后写一个测试文件：

public class CalculatorServerClient {
    public static void main(String[] args) {
        Node node = NodeFactory.newInstance().createNode("Calculator.composite");
        node.start();

        System.out.println("start");
        Calculator calculator = node.getService(Calculator.class, "CalculatorServiceComponent");
        System.out.println(calculator.add(1.2, 1.2));
        System.out.println(calculator.subtract(2.1, 0.1));
        System.out.println(calculator.divide(10, 3));
        System.out.println(calculator.multiply(2, 0.5));
        node.stop();
    }
}

配置没出问题的话应该就可以跑出结果了

这只是一个非常简单的例子，甚至没有暴露出远程接口。

遇到的问题

1. Apache Tuscany 不支持高版本的 spring，当然也不支持 spring boot

这就很尴尬，我用 spring boot 写的，这下还得把项目降低到 spring 3.0.5.顺带着一大批依赖全部都要降级，并且还得防止依赖出问题。

我已经预见到明天做这个要有多蛋疼了。

明天的计划

1. 忍受 spring 依赖冲突的困扰