diff --git a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiConsumer.java b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiConsumer.java
index 1f489cf..6d18ae8 100644
--- a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiConsumer.java
+++ b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiConsumer.java
@@ -21,7 +21,7 @@
 import org.apache.dubbo.config.ApplicationConfig;
 import org.apache.dubbo.config.ReferenceConfig;
 import org.apache.dubbo.config.RegistryConfig;
-
+import org.apache.dubbo.config.bootstrap.DubboBootstrap;
 import org.apache.dubbo.hello.HelloReply;
 import org.apache.dubbo.hello.HelloRequest;
 
@@ -29,7 +29,7 @@
 import java.util.concurrent.TimeUnit;
 
 public class ApiConsumer {
-    public static void main(String[] args) throws InterruptedException, IOException {
+    public static void main(String[] args) throws IOException {
         ReferenceConfig<IGreeter> ref = new ReferenceConfig<>();
         ref.setInterface(IGreeter.class);
         ref.setCheck(false);
@@ -38,8 +38,13 @@
         ref.setProtocol(CommonConstants.TRIPLE);
         ref.setLazy(true);
         ref.setTimeout(100000);
-        ref.setApplication(new ApplicationConfig("demo-consumer"));
-        ref.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
+
+        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
+        bootstrap.application(new ApplicationConfig("demo-consumer"))
+                .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
+                .reference(ref)
+                .start();
+
         final IGreeter iGreeter = ref.get();
 
         System.out.println("dubbo ref started");
diff --git a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiProvider.java b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiProvider.java
index e052dcb..df90b39 100644
--- a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiProvider.java
+++ b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiProvider.java
@@ -22,18 +22,21 @@
 import org.apache.dubbo.config.ProtocolConfig;
 import org.apache.dubbo.config.RegistryConfig;
 import org.apache.dubbo.config.ServiceConfig;
-import java.util.concurrent.CountDownLatch;
+import org.apache.dubbo.config.bootstrap.DubboBootstrap;
 
 public class ApiProvider {
-    public static void main(String[] args) throws InterruptedException {
+    public static void main(String[] args) {
         ServiceConfig<IGreeter> service = new ServiceConfig<>();
         service.setInterface(IGreeter.class);
         service.setRef(new IGreeter1Impl());
-        service.setProtocol(new ProtocolConfig(CommonConstants.TRIPLE, 50051));
-        service.setApplication(new ApplicationConfig("demo-provider"));
-        service.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
-        service.export();
-        System.out.println("dubbo service started");
-        new CountDownLatch(1).await();
+
+        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
+        bootstrap.application(new ApplicationConfig("demo-provider"))
+                .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
+                .protocol(new ProtocolConfig(CommonConstants.TRIPLE, 50051))
+                .service(service)
+                .start()
+                .await();
+
     }
 }
diff --git a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperConsumer.java b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperConsumer.java
index abdb343..ce40f92 100644
--- a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperConsumer.java
+++ b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperConsumer.java
@@ -20,6 +20,7 @@
 import org.apache.dubbo.config.ApplicationConfig;
 import org.apache.dubbo.config.ReferenceConfig;
 import org.apache.dubbo.config.RegistryConfig;
+import org.apache.dubbo.config.bootstrap.DubboBootstrap;
 
 public class ApiWrapperConsumer {
     public static void main(String[] args) {
@@ -28,8 +29,13 @@
         ref.setCheck(false);
         ref.setProtocol("tri");
         ref.setLazy(true);
-        ref.setApplication(new ApplicationConfig("demo-consumer"));
-        ref.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
+
+        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
+        bootstrap.application(new ApplicationConfig("demo-consumer"))
+                .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
+                .reference(ref)
+                .start();
+
         final IGreeter2 iGreeter = ref.get();
         System.out.println("dubbo ref started");
         long st = System.currentTimeMillis();
diff --git a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperProvider.java b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperProvider.java
index e8176f6..ce979fb 100644
--- a/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperProvider.java
+++ b/dubbo-samples-triple/src/main/java/com/apache/dubbo/sample/basic/ApiWrapperProvider.java
@@ -22,19 +22,21 @@
 import org.apache.dubbo.config.ProtocolConfig;
 import org.apache.dubbo.config.RegistryConfig;
 import org.apache.dubbo.config.ServiceConfig;
-
-import java.io.IOException;
+import org.apache.dubbo.config.bootstrap.DubboBootstrap;
 
 public class ApiWrapperProvider {
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) {
         ServiceConfig<IGreeter2> service = new ServiceConfig<>();
         service.setInterface(IGreeter2.class);
         service.setRef(new IGreeter2Impl());
-        service.setProtocol(new ProtocolConfig(CommonConstants.TRIPLE, 50051));
-        service.setApplication(new ApplicationConfig("demo-provider"));
-        service.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
-        service.export();
-        System.out.println("dubbo service started");
-        System.in.read();
+
+        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
+        bootstrap.application(new ApplicationConfig("demo-provider"))
+                .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
+                .protocol(new ProtocolConfig(CommonConstants.TRIPLE, 50051))
+                .service(service)
+                .start()
+                .await();
+
     }
 }
