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檔案，配置程式碼如下：

<!--MAVEN打包duboo可執行jar begin -->  
    <build>  
        <finalName>edu-service-user</finalName>  

        <resources>  
            <resource>  
                <targetPath>${project.build.directory}/classes</targetPath>  
                <directory>src/main/resources</directory>  
                <filtering>true</filtering>  
                <includes>  
                    <include>**/*.xml</include>  
                    <include>**/*.properties</include>  
                </includes>  
            </resource>  
            <!-- 結合com.alibaba.dubbo.container.Main -->  
            <resource>  
                <targetPath>${project.build.directory}/classes/META-INF/spring</targetPath>  
                <directory>src/main/resources/spring</directory>  
                <filtering>true</filtering>  
                <includes>  
                    <include>spring-context.xml</include>  
                </includes>  
            </resource>  
        </resources>  

        <pluginManagement>  
            <plugins>  
                <!-- 解決Maven外掛在Eclipse內執行了一系列的生命週期引起衝突 -->  
                <plugin>  
                    <groupId>org.eclipse.m2e</groupId>  
                    <artifactId>lifecycle-mapping</artifactId>  
                    <version>1.0.0</version>  
                    <configuration>  
                        <lifecycleMappingMetadata>  
                            <pluginExecutions>  
                                <pluginExecution>  
                                    <pluginExecutionFilter>  
                                        <groupId>org.apache.maven.plugins</groupId>  
                                        <artifactId>maven-dependency-plugin</artifactId>  

                                        <goals>  
                                            <goal>copy-dependencies</goal>  
                                        </goals>  
                                    </pluginExecutionFilter>  
                                    <action>  
                                        <ignore />  
                                    </action>  
                                </pluginExecution>  
                            </pluginExecutions>  
                        </lifecycleMappingMetadata>  
                    </configuration>  
                </plugin>  
            </plugins>  
        </pluginManagement>  
        <plugins>  
            <!-- 打包jar檔案時，配置manifest檔案，加入lib包的jar依賴 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <configuration>  
                    <classesDirectory>target/classes/</classesDirectory>  
                    <archive>  
                        <manifest>  
                            <mainClass>com.alibaba.dubbo.container.Main</mainClass>  
                            <!-- 打包時 MANIFEST.MF檔案不記錄的時間戳版本 -->  
                            <useUniqueVersions>false</useUniqueVersions>  
                            <addClasspath>true</addClasspath>  
                            <classpathPrefix>lib/</classpathPrefix>  
                        </manifest>  
                        <manifestEntries>  
                            <Class-Path>.</Class-Path>  
                        </manifestEntries>  
                    </archive>  
                </configuration>  
            </plugin>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-dependency-plugin</artifactId>  
                <executions>  
                    <execution>  
                        <id>copy-dependencies</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>copy-dependencies</goal>  
                        </goals>  
                        <configuration>  
                            <type>jar</type>  
                            <includeTypes>jar</includeTypes>  
                            <useUniqueVersions>false</useUniqueVersions>  
                            <outputDirectory>  
                                ${project.build.directory}/lib  
                            </outputDirectory>  
                        </configuration>  
                    </execution>  
                </executions>  
            </plugin>  
        </plugins>  

</build>  
<!--MAVEN打包duboo可執行jar end -->

      配置好以後，只需要在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擴充套件點進行擴充套件。

      從以上介紹，我們也很容易得出，上面介紹的三種方式，該如何進行選擇。