【dubbo】服务运行的三种方式

    dubbo服务的运行方式有三种，分别为：

      1. 使用Servlet容器运行（Tomcat、Jetty等）

      2. 自建Main方法类来运行（Spring容器）

      3. 使用Dubbo框架提供的Main方法类来运行（Spring容器）

    下面通过详细介绍与配置，比较一下三种方式。

      1. tomcat等web容器

      此方式和我们平时在IDE（Eclipse、IDEA等）环境中部署项目一样，将dubbo服务项目直接添加到容器中启动即可，不需要做任何配置。

      但此方式其实是不可取的，它增加了复杂性（端口、管理等方面），也浪费资源（内存）。

      2. 自建Main方法类运行

      此方式是类似自己写了一个测试的方法，该方法通过初始化spring的配置文件，从而启动dubbo服务。Main方法代码如下：

public class DubboProvider {

    private static final Log log = LogFactory.getLog(DubboProvider.class);

    public static void main(String[] args) {
        try {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
            context.start();
        } catch (Exception e) {
            log.error("== DubboProvider context start error:",e);
        }
        synchronized (DubboProvider.class) {
            while (true) {
                try {
                    DubboProvider.class.wait();
                } catch (InterruptedException e) {
                    log.error("== synchronized error:",e);
                }
            }
        }
    }

}

      同样，此方式也存在一定的缺点：Dubbo本身提供的高级特性没用上；自己编写启动类可能会有缺陷，所以不建议使用，但可用于本地调试。

      3. 使用Dubbo框架提供的Main方法类运行

      此方法只需要修改一下项目的pom文件，配置代码如下：

  
    <build>  
        <finalName>edu-service-userfinalName>  

        <resources>  
            <resource>  
                <targetPath>${project.build.directory}/classestargetPath>  
                <directory>src/main/resourcesdirectory>  
                <filtering>truefiltering>  
                <includes>  
                    <include>**/*.xmlinclude>  
                    <include>**/*.propertiesinclude>  
                includes>  
            resource>  
              
            <resource>  
                <targetPath>${project.build.directory}/classes/META-INF/springtargetPath>  
                <directory>src/main/resources/springdirectory>  
                <filtering>truefiltering>  
                <includes>  
                    <include>spring-context.xmlinclude>  
                includes>  
            resource>  
        resources>  

        <pluginManagement>  
            <plugins>  
                  
                <plugin>  
                    <groupId>org.eclipse.m2egroupId>  
                    <artifactId>lifecycle-mappingartifactId>  
                    <version>1.0.0version>  
                    <configuration>  
                        <lifecycleMappingMetadata>  
                            <pluginExecutions>  
                                <pluginExecution>  
                                    <pluginExecutionFilter>  
                                        <groupId>org.apache.maven.pluginsgroupId>  
                                        <artifactId>maven-dependency-pluginartifactId>  

                                        <goals>  
                                            <goal>copy-dependenciesgoal>  
                                        goals>  
                                    pluginExecutionFilter>  
                                    <action>  
                                        <ignore />  
                                    action>  
                                pluginExecution>  
                            pluginExecutions>  
                        lifecycleMappingMetadata>  
                    configuration>  
                plugin>  
            plugins>  
        pluginManagement>  
        <plugins>  
              
            <plugin>  
                <groupId>org.apache.maven.pluginsgroupId>  
                <artifactId>maven-jar-pluginartifactId>  
                <configuration>  
                    <classesDirectory>target/classes/classesDirectory>  
                    <archive>  
                        <manifest>  
                            <mainClass>com.alibaba.dubbo.container.MainmainClass>  
                              
                            <useUniqueVersions>falseuseUniqueVersions>  
                            <addClasspath>trueaddClasspath>  
                            <classpathPrefix>lib/classpathPrefix>  
                        manifest>  
                        <manifestEntries>  
                            <Class-Path>.Class-Path>  
                        manifestEntries>  
                    archive>  
                configuration>  
            plugin>  
            <plugin>  
                <groupId>org.apache.maven.pluginsgroupId>  
                <artifactId>maven-dependency-pluginartifactId>  
                <executions>  
                    <execution>  
                        <id>copy-dependenciesid>  
                        <phase>packagephase>  
                        <goals>  
                            <goal>copy-dependenciesgoal>  
                        goals>  
                        <configuration>  
                            <type>jartype>  
                            <includeTypes>jarincludeTypes>  
                            <useUniqueVersions>falseuseUniqueVersions>  
                            <outputDirectory>  
                                ${project.build.directory}/lib  
                            outputDirectory>  
                        configuration>  
                    execution>  
                executions>  
            plugin>  
        plugins>  

build>  

      配置好以后，只需要在IDE中执行一下Maven install命令，便会打出一个jar包，在启动服务的时候，直接使用java -jar命令执行jar包即可。

      此方式是建议使用的方式，其优势在于是

      1. 由框架本身提供（com.alibaba.dubbo.container.Main）;

      2. 可实现优雅关机（ShutdownHook）

      本博客介绍的内容属于dubbo中服务容器的要点，关于服务容器的介绍，官方文档简单总结了如下几点：

      1. 服务容器是一个standalone的启动程序，因为后台服务不需要Tomcat或JBoss等web容器的功能，如果硬要用web容器去加载服务提供方，增加复杂性，也浪费资源。

      2. 服务容器只是一个简单的Main方法，并加载一个简单的spring容器，用于暴露服务。

      3. 服务容器的加载内容可以扩展，内置了spring、jetty、log4j等加载，可通过Container扩展点进行扩展。

      从以上介绍，我们也很容易得出，上面介绍的三种方式，该如何进行选择。