今天完成的事情：

将服务端放到服务器上运行

由于有两个服务端就需要两个打两个jar包

打可运行的main函数的jar需要用到一个shade插件

在pom文件里添加

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>1.4</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <filters>
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                            <exclude>META-INF/*.RSA</exclude>
                        </excludes>
                    </filter>
                </filters>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.jnshu.test.TestServer1</mainClass>
                    </transformer>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.schemas</resource>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

运行maven clean package命令就可以打包了

这里边的坑就是我打包一直报错，然后发现当时建的是webapp项目只能打war包，修改一个标签就可以了

<packaging>jar</packaging>

打好之后放到服务器上

rmi默认的ip是内网ip，我们本地是无法调用的，所以需要指定一个ip即可

System.setProperty("java.rmi.server.hostname","47.93.255.**");

然后客户端也调用这个url

<property name="serviceUrl" value="rmi://47.93.255.**:11011/StudentServiceImpl" />

还有一个，两个jar包在linux上运行会出现冲突，这时需要设置后台运行

java -jar file.jar &

这个&就是后台运行，只有关闭连接的时候才会中断

好了可以运行两个jar包了

看，启动jar包之后再回到命令行并不会关闭jar包

本地运行客户端

可以访问到服务器上的server了

之后可以用杀进程的方式的关闭其中的一个server来看看结果，很简单不写了。

jar war tar的区别

看一下任务9

Apache Tuscany 通过为基于服务组件架构（SCA）标准的SOA开发和管理提供全面的基础架构来简化开发SOA解决方案的任务。

SCA是一种使用组件来构建应用的框架，而SOA是一种组件模型，它将程序的功能（这里叫服务）通过服务之间定义的接口和契约联系起来。可以理解为一种松耦合的接口定义架构。

找了找例子，还是计算器那个，嗯。。。

定义一个计算器的接口，里面用上加减乘除的方法

public interface ICalculator{
    /**
     * 加法
     */
    double add(double n1, double n2);
    /**
     * 减法
     */
    double subtract(double n1, double n2);
    /**
     * 除法
     */
    double divide(double n1, double n2);
    /**
     * 乘法
     */
    double multiply(double n1, double n2);
}

接口实现类

public class Calculator implements ICalculator{

    /**
     * 引用其他组件IAdd，ISubtract，IMultiply,IDivide
     * @Reference 说明引用其他组件 会和.composite文件进行配置
     */
    private IAdd add;//加法组件
    private ISubtract subtract;//减法组件
    private IMultiply multiply;//乘法组件
    private IDivide divide;//除法组件
    public IAdd getAdd() {
        return add;
    }
    @Reference
    public void setAdd(IAdd add) {
        this.add = add;
    }

    public ISubtract getSubtract() {
        return subtract;
    }
    @Reference
    public void setSubtract(ISubtract subtract) {
        this.subtract = subtract;
    }

    public IMultiply getMultiply() {
        return multiply;
    }
    @Reference
    public void setMultiply(IMultiply multiply) {
        this.multiply = multiply;
    }

    public IDivide getDivide() {
        return divide;
    }
    @Reference
    public void setDivide(IDivide divide) {
        this.divide = divide;
    }

    @Override
    public double add(double n1, double n2) {
        return this.add.add(n1, n2);
    }

    @Override
    public double subtract(double n1, double n2) {
        return this.subtract.subtract(n1, n2);
    }

    @Override
    public double divide(double n1, double n2) {
        return this.divide.divide(n1, n2);
    }

    @Override
    public double multiply(double n1, double n2) {
        return this.multiply.multiply(n1, n2);
    }
}

在这个实现类里调用了加减乘除的组件，@Reference类似于Spring的注入

加减乘除的接口和实现类就不贴了，没什么特别的

看一下客户端

public class CalculatorServerClient {
    public static void main(String[] args) throws IOException {
        Node node = NodeFactory.newInstance().createNode("Calculator.composite");
        node.start();
        System.out.println("service启动");
        ICalculator c = node.getService(ICalculator.class,"Calculator");
        System.out.println(c.add(2, 2));
        System.out.println("3 + 2 = " + c.add(3, 2));
        System.out.println("3 - 2 = " + c.subtract(3, 2));
        System.out.println("3 * 2 = " + c.multiply(3, 2));
        System.out.println("3 / 2 = " + c.divide(3, 2));
        node.stop();
    }
}

这里其实是服务端和客户端放在一起了，加载了配置文件，node.start()启动service服务，node.getService()调用暴露的服务，node.stop关闭服务

配置文件Calculator.composite，这是个composite文件，类似于xml文件吧

<composite
        xmlns="http://docs.oasis-open.org/ns/opencsa/sca/200912"
        xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"
        targetNamespace="http://com.jnshu.service"
        name="Calculator">
        
    <service name="Calculator" promote="Calculator">
        <interface.java interface="com.jnshu.service.ICalculator"/>
        <binding.ws uri="http://127.0.0.1:8099/Calculator"/>
    </service>

    <component name="Calculator">
        <implementation.java class="com.jnshu.service.Calculator" />
        <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="com.jnshu.service.Add" />
    </component>
    <component name="SubtractComponent">
        <implementation.java class="com.jnshu.service.Subtract" />
    </component>
    <component name="MultiplyComponent">
        <implementation.java class="com.jnshu.service.Multiply" />
    </component>
    <component name="DivideComponent">
        <implementation.java class="com.jnshu.service.Divide" />
    </component>

</composite>

然后我这里为什么都是白的，2333

可以看到<component>注册了五个服务，name标记为Calculator什么的，采用Spring的首字母大写规则。reference调用别的组件的服务

此时并没有将Calculator类变成一个服务，暴露给远程调用，只是实现了本地的装配。需要通过<service>标签来实现，然后暴露出host，port和servicename就可以了，跟rmi一样。

再启动客户端

可以看到先启动了service，然后使用服务调用方法，再关闭service。

最后看一下jar包吧

<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>

明天计划的事情：

可能还有点细节问题，再看看吧。话说我没遇到传说中的迷之报红问题，因为，这TM都是白的啊！？