2. 程式人生 > >用dubbo框架寫的簡單的介面作為客戶端

用dubbo框架寫的簡單的介面作為客戶端

阿新 • • 發佈：2019-01-23

在客戶端需要依賴服務端的jar包和類，在客戶端也新建和服務端一樣的介面和實現類


consumer.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        ">

    <!-- 消費方應用名，用於計算依賴關係，不是匹配條件，不要與提供方一樣 -->
    <dubbo:application name="hehe_consumer" />

    <!-- 使用zookeeper註冊中心暴露服務地址 -->
    <!--<dubbo:registry address="multicast://127.0.0.1:1234" />-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />
    <!--<dubbo:dubooTestDemo address="127.0.0.1:20880"></dubbo:registry>-->

    <!-- 生成遠端服務代理，可以像使用本地bean一樣使用demoService -->
    <dubbo:reference id="dubooTestDemo" group="jd" version="1.0" timeout="2000" interface="com.jd.service.DubboTestService"/>
    <dubbo:reference id="registerService" interface="com.jd.service.RegisterService"/>
</beans>

新建類DubboConsumer 內容有如下，這種方式是整合spring去掉用服務端介面 
import com.alibaba.fastjson.JSON;
import com.jd.domain.ResponseMessage;
import com.jd.domain.User;
import com.jd.service.DubboTestService;
import com.jd.service.RegisterService;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import javax.xml.ws.spi.Invoker;
import java.io.IOException;

/**
 * Created by Administrator on 2017/9/2 0002.
 */
public class DubboConsumer {
    public static void main(String[] args) throws IOException {
        //classpath去執行時的環境去找這個檔案
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo/consumer.xml");
        //如果consumer.xml不放在resources下，可以使用檔案路徑FileSystemXmlApplication這個介面，填寫絕對路徑
        //ApplicationContext context1 = new FileSystemXmlApplicationContext("D:\\dubboController\\xml\\consumer.xml");
        DubboTestService dubboTestService = (DubboTestService)context.getBean("dubooTestDemo");
        String name = dubboTestService.getName();
        System.out.println(name);
        dubboTestService.say();
        //返回的是一個物件，物件輸出必須得轉化成字串形式，用fastjson
        ResponseMessage responseMessage = dubboTestService.getUserById(55);
        System.out.print("responseMessage"+ JSON.toJSONString(responseMessage));

        RegisterService registerService = (RegisterService)context.getBean("registerService");
        User user = new User();
        user.setUsername("niu");
        //{"username":"niuniu"}

        registerService.registerUser(user);

    }
}

第二種方法用泛化的方式去掉用 
import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.MethodConfig;
import com.alibaba.dubbo.config.ReferenceConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.fastjson.JSON;
import com.jd.service.DubboTestService;
import com.jd.service.RegisterService;
import javafx.application.Application;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2017/9/3 0003.
 */
public class GenericConsumer {
    //api呼叫方式
    @Test
    public void genericTest() {
        //對應配置檔案中的<dubbo:application name="hehe_consumer" />
        ApplicationConfig application = new ApplicationConfig();
        application.setName("xixi");

        // 對應配置檔案中的暴露中心連結地址
        RegistryConfig registry = new RegistryConfig();
        registry.setAddress("multicast://224.5.6.7:1234");
//        registry.setUsername("aaa");
//        registry.setPassword("bbb");
        // 注意：ReferenceConfig為重物件，內部封裝了與註冊中心的連線，以及與服務提供方的連線

        // 引用遠端服務
        // 服務實現,對應配置中的 <dubbo:reference id="dubooTestDemo" group="jd" version="1.0" timeout="2000" interface="com.jd.service.DubboTestService"/>
        ReferenceConfig<DubboTestService> reference = new ReferenceConfig<DubboTestService>();// 此例項很重，封裝了與註冊中心的連線以及與提供者的連線，請自行快取，否則可能造成記憶體和連線洩漏
        reference.setApplication(application);
        reference.setRegistry(registry);// 多個註冊中心可以用setRegistries()
        reference.setInterface(DubboTestService.class);
        reference.setVersion("1.0");
        reference.setGroup("jd");
        reference.setTimeout(2000);
//        reference.setUrl("dubbo://127.0.0.1:20880/com.longteng.service.DubboTestService?application=xixi_provider&callbacks=10000&connect.timeout=10000&method=getUsers");
// 和本地bean一樣使用xxxService
        //方法的設定
        List<MethodConfig> methods = new ArrayList<MethodConfig>();
        MethodConfig method = new MethodConfig();
        method.setName("getName");
        method.setTimeout(10000);
        //方法重試
        method.setRetries(0);
        methods.add(method);
        reference.setMethods(methods);// 設定方法級配置

        //相當於api的方式呼叫
        //長連線，一個介面只需要做一次就好了 get相當於spring裡的getbean 那一段一樣，和spring那個相對應理解
        DubboTestService xxxService = reference.get();// 注意：此代理物件內部封裝了所有通訊細節，對
        Object o = "jiaou";
        System.out.println(JSON.toJSONString(xxxService.getUserById(1)));
        System.out.println(JSON.toJSONString(xxxService.sayHello("jiaou")));
        System.out.println();
    }


}

第三種方式用telnet去呼叫

com.test.DemoService
檢視服務中的介面
dubbo>ls com.test.DemoService
queryDemoPageList
insertDemolist
uploadDemoList
deleteDemolist
ls
(list services and methods)
ls
顯示服務列表。
ls -l
顯示服務詳細資訊列表。
ls XxxService
顯示服務的方法列表。
ls -l XxxService
顯示服務的方法詳細資訊列表。
3.呼叫服務介面
呼叫介面時，以JSON格式傳入引數（這點很方便 :-D），然後列印返回值和所用時間。
dubbo>invoke com.test.DemoService.queryDemoPageList({"id":"100"}, 1, 2)
{"totalCount":1,"data":[{date":"2011-03-23 14:10:32","name":"張三","keyword":null}]}

elapsed: 10 ms.
invoke
invoke XxxService.xxxMethod({"prop": "value"})
呼叫服務的方法。
invoke xxxMethod({"prop": "value"})

寫程式碼作為TelnetSocket

/**
 * Created by Administrator on 2017/9/3 0003.
 */
import org.apache.log4j.Logger;
import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;


public class TelnetSocket {

    private final static Logger LOGGER = Logger.getLogger(TelnetSocket.class);
    /**
     * socket函式
     */
    private Socket socket;

    /**
     * 換行符
     */
    private final static String LINE_SEPARATOR = System.getProperty("line.separator");
    /**
     * 預設讀字元編碼
     */
    private String readEncoding = "UTF-8";

    /**
     * 預設寫字元編碼
     */
    private String writeEncoding = "UTF-8";

    /**
     * DubboTelnetClient 構造
     *
     * @param ip
     *            ip地址
     * @param port
     *            埠
     * @throws java.net.UnknownHostException
     * @throws java.io.IOException
     */
    public TelnetSocket(String ip, int port) throws UnknownHostException,
            IOException {
        this.socket = new Socket(ip, port);
    }

    /**
     * DubboTelnetClient 構造
     *
     * @param ip
     *            ip地址
     * @param port
     *            埠
     * @param connTimeout
     *            連線超時時間超時時間
     * @throws java.net.UnknownHostException
     * @throws java.io.IOException
     */
    public TelnetSocket(String ip, int port, int connTimeout)
            throws UnknownHostException, IOException {
        this(ip, port, connTimeout, 5000);
    }

    public boolean isConnected(){
        return socket.isConnected();
    }

    /**
     * DubboTelnetClient 構造
     *
     * @param ip
     *            ip地址
     * @param port
     *            埠
     * @param connTimeout
     *            連線超時時間
     * @param soTimeout
     *            讀取超時時間
     * @throws java.net.UnknownHostException
     * @throws java.io.IOException
     */
    public TelnetSocket(String ip, int port, int connTimeout, int soTimeout)
            throws UnknownHostException, IOException {
        try {
            this.socket = new Socket();
            socket.setSoTimeout(soTimeout);
            socket.connect(new InetSocketAddress(ip, port), connTimeout);
        } catch (Exception e) {
            LOGGER.error("連線"+ip+":"+port+"異常"+e.getMessage(), e);
        }
    }

    /**
     * 傳送訊息
     *
     * @param msg
     *            訊息
     * @param times
     *            讀取次數（即遇到dubbo>結尾代表一次）
     * @return 返回訊息
     * @throws java.io.IOException
     */
    public String send(String msg, int times) throws IOException {

        String result = "";
        InputStream in = null;
        OutputStream out = null;
        ByteArrayOutputStream baout = null;
        try {
            // 初始化通道
            //傳送訊息
            in = socket.getInputStream();
            out = socket.getOutputStream();
            // 傳送請求
            out.write(msg.getBytes(writeEncoding));
            out.write(LINE_SEPARATOR.getBytes(writeEncoding));
            out.flush();    //重新整理快取

            //接收訊息
            baout = new ByteArrayOutputStream();
            // 解析得到的響應
            StringBuffer sb = new StringBuffer();
            byte[] bs = new byte[1024];
            int len = 0;
            int i = 0;
            while (i < 1024 && (len = in.read(bs)) != -1) {
                //if (i > 1024) { // 防止無限迴圈 最多取 1M的資料
                //	break;
                //}
                String data = new String(bs, 0, len, readEncoding);
                baout.write(bs, 0, len);
                sb.append(data);

                String last = sb.substring(sb.length()-6);
                if (last.endsWith("jsf>") || "dubbo>".equals(last) || "lnet> ".equals(last)) {
                    if (--times < 1) {
                        break; // 讀到這個就斷開連線返回
                    }
                }
                i++;
            }
            result = new String(baout.toByteArray(), readEncoding);
            return result;
        } catch (Exception e) {
            LOGGER.error("執行socket命令"+msg+"結束, 結果為"+e.getMessage(), e);
        }finally {
            if(baout!=null){
                baout.close();
            }
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return result;
    }
    /**
     * 傳送訊息
     *
     * @param msg
     *            訊息
     * @return 返回訊息
     * @throws java.io.IOException
     */
    public String send(String msg) throws IOException {
        int time = 1;
        if (msg.startsWith("count")) {
            time = 2; // count命令會返回2次dubbo
        } else if (msg.startsWith("trace")) {
            String[] cmds = msg.split("\\s+"); // trace幾次返回幾次
            time = cmds.length > 2 ? Integer.valueOf(cmds[cmds.length - 1]
                    .trim()) : 1;
        }
        return send(msg, time);
    }

    /**
     * 傳送訊息
     *
     * @param msg
     *            訊息
     * @return 返回訊息
     * @throws java.io.IOException
     * @deprecated use {@link #send(String)}
     */
    public String sendOld(String msg) throws IOException {
        String result = "";
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            // 初始化通道
            in = new BufferedReader(new InputStreamReader(
                    socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);

            // 傳送請求
            out.println(msg);
            out.flush();

            // 解析得到的響應
            StringBuffer sb = new StringBuffer();
            char[] cbuf = new char[10240];
            in.read(cbuf);
			/*try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}*/
            sb.append(cbuf, 0, cbuf.length);
            result = sb.toString();
            return result;
        } finally {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        }
    }

    /**
     * 關閉連線
     */
    public void close() {
        try {
            if (socket != null && !socket.isClosed())
                socket.close();
        } catch (IOException e) {
            // ignore
            // e.printStackTrace();
        }
    }

    /**
     * @return the readEncoding
     */
    public String getReadEncoding() {
        return readEncoding;
    }

    /**
     * @param readEncoding the readEncoding to set
     */
    public void setReadEncoding(String readEncoding) {
        this.readEncoding = readEncoding;
    }

    /**
     * @return the writeEncoding
     */
    public String getWriteEncoding() {
        return writeEncoding;
    }

    /**
     * @param writeEncoding the writeEncoding to set
     */
    public void setWriteEncoding(String writeEncoding) {
        this.writeEncoding = writeEncoding;
    }

    public static void main(String[] args) {
        String[] cmds = new String[] { "invoke com.jd.ecc.delivery.service.AddressBaseService.getAddressesByCode(\"3301\")" };
//		String[] cmds = new String[] { "ls -l", "count com.jd.testsaf.HelloService", "trace com.jd.testsaf.HelloService"};
        TelnetSocket client = null;
        long time0 = System.currentTimeMillis();
        try {
            for (int i = 0; i < cmds.length; i++) {
                client = new TelnetSocket("192.168.192.153", 32000,5000,30000);
//				client = new DubboTelnetClient("10.12.120.121", 20880,5000);
                client.setReadEncoding("gbk");
                String res = client.send(cmds[i]);
                System.out.println("命令:" + cmds[i] + "   返回");
                System.out.println(res);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (client != null) {
                client.close();
            }
        }
        long time1 = System.currentTimeMillis();
        System.out.println("耗時：" + (time1 - time0) + "ms");
    }
}

TelnetConsumer
import java.io.IOException;

/**
 * Created by Administrator on 2017/9/3 0003.
 */
public class TelnetConsumer {
    public static void main(String[] args) throws IOException {
        String ip = "127.0.0.1";
        int port = 20880;
        TelnetSocket telnetSocket = new TelnetSocket(ip,port);
        String interfaceName = "com.jd.service.DubboTestService";
        String methodName = "getUserById";
        String param = "0";
        //invoke com.jd.service.DubboTestService.getUserById(0) 命令的組裝
        String cmd = "invoke "+interfaceName+"."+methodName+"(\""+param+"\")";
        System.out.print(cmd);
        String result = telnetSocket.send(cmd);

        System.out.print("返回的結果："+result);

    }
}


相關推薦

用dubbo框架寫的簡單的介面作為客戶端

在客戶端需要依賴服務端的jar包和類，在客戶端也新建和服務端一樣的介面和實現類 consumer.xml配置如下 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin

WebService手寫簡單案例：客戶端與服務端的資料互動

本篇部落格是模擬服務端釋出服務，客戶端模擬接收服務端的返回資料的一個簡單案例（客戶端輸入姓名，服務端根據客戶端輸入的姓名模糊查詢身份證的案例） 服務端釋出服務 1.專案準備工作：新建一個web專案，匯入mysql的jar包放入工程，寫好jdbc連線，寫好實體類，寫dao，不同的

python中的flask框架寫簡單的登入介面

flask框架和css的應用 實現的環境： windows環境 eclipse下的pydev pip3 install flask jinja2 步驟一：首先建立一個web.py # -*- coding:utf-8 -*- ''' Created

用CI框架寫了簡單的pdo單例類

class db{ private static $instance; //私有的靜態變數 private $pdo = ''; //私有的建構函式 //$db_type 資料庫型別 $host 主機ip $dbname

基於thrift的java和python分別作為客戶端和服務端的調用實現

Coding except arr pes com ssa utf-8 encoding 中文亂碼 前面已經實現了純java的thrift的實現。 現在實現實現一下python作為客戶端和服務端的thrift的調用 1.python作為客戶端，java作為服務端 java服

如何使用SSH框架寫一個介面方法並可用URL地址訪問介面顯示返回的字串

如何使用SSH框架寫一個介面方法並可用URL地址訪問介面顯示返回的字串 git原始碼地址：https://gitee.com/zeyang_wang/ssh_myStudy 如何使用SSH框架寫一個介面方法並可用URL地址訪問介面顯示返回的字串？ 如： 在瀏覽器訪問本地啟動的專案： ht

用ssm框架寫sms專案

歷經一個禮拜的時間在ssm框架的學習和練習中，我逐漸認識和理解了ssm框架 在開發過程中的優勢所在。 前兩天在理解專案的需求和要求後，按照教案例項的步驟和結合功能需求， 做出來了學生管理專案的雛形。能實現基本功能，但在框架的結構功能還有點 懵懂。接下來一天的專

用Bootstrap框架寫響應式輪播圖

說實話個人覺得這個Bootstrap的js外掛來實現輪播圖效果挺好的。 提醒一下你得要到Bootstrap官網提前下載一下這個： 還有就是在你的開頭記得加上這行程式碼： 結尾記得加上這兩行： <!-- 輪播圖 --> <div id="

用BeautifulSoup + selenium 寫簡單的爬蟲程式設計

我們以抓取選股寶網頁裡面的利好以及利空對應的股票名稱為例子1、建立專案        開啟PyCharm2、新建py檔案3、程式設計    3.1 建立檔案函式# 建立檔案函式 （檔案路徑，檔名） def establish_file(file_path, file_name

用table分組寫設定介面

#import "ViewController.h" @interface ViewController ()<UITableViewDelegate,UITableViewDataSource> @property (nonatomic,strong)UIT

httpclient妙用一 httpclient作為客戶端呼叫webservice

httpclient作為客戶端呼叫webservice 1.個人觀點       webservice框架有很多，比如axis、axis2、cxf、xFire等等，做服務端和做客戶端都可行，個人感覺使用這些框架的好處是減少了對於介面資訊的解析，最主要的是減少了對於傳遞

用SSM框架實現簡單的專案-《圖書管理系統》

$(function () { /*三條件動態查詢*/ $("#queryBooks").click(function () { $("#pageNum").val(1); $("

用FLask框架寫第一個小程式

#encoding:utf-8 #從flask這個包中匯入Flask這個類 from flask import Flask #初始化一個Flask物件叫app #需要傳遞一個引數__name__ #1.方便flask框架尋找資源 #2.方便flask外掛比如Flask-S

用ThinkPHP框架寫程式還原或搬家

第一步：修改連線資料庫檔案 路徑：Application\Common\Conf   config.php 二：修改樣式檔案路徑 路徑：Application\Home\Conf   con

新人寫的每日新聞客戶端

creat baidu lis ongl http music hao123 eat 新聞 %E5%A4%8D%E5%86%99ONCREaTE%E6%96%B9%E6%B3%95%E6%97%B6%E5%87%BA%E9%94%99 http://music.hao123

ajax用beforeSend自定義請求過程中客戶端事件，提高用戶體驗

函數 fun 直接 alert 完成後 and success ram reat 本文為博主原創，未經允許不得轉載： 在應用ajax的過程中，當我們再前臺提交請求的時候，如果服務端響應事件比較長，就會導致需要等很長時間在前臺才能接受到服務端返回的 響應結果，往

[轉]Netty入門(最簡單的Netty客戶端/服務器程序)

serve exc new final 綁定 title graceful 關閉連接 listener 　Java中的NIO是一種解決阻塞式IO問題的基本技術，但是NIO的編寫對java程序員是有比較高的要求的。那麽Netty就是一種簡化操作的一個成熟的網絡IO編程框架。這

Python學習筆記1：簡單實現ssh客戶端和服務端

bsp dev bre 客戶端 break 基於 bin listen 客戶 實現基於python 3.6。 server端： 1 __author__ = "PyDev2018" 2 3 import socket,os 4 server = socket.s

SmartAccess禁止通過NetScaler用戶訪問虛擬桌面重定向客戶端打印機

edit size 分析 ces access 桌面圖標 打印機 服務 pro SmartAccess禁止通過NetScaler用戶重定向客戶端打印機 介紹 SmartAccess和SmartControl允許您根據用戶連接的方式更改ICA連接行為（例如，禁用客戶端設備映射

Ajax異步請求返回文件流（eg：導出文件時，直接將導出數據用文件流的形式返回客戶端供客戶下載）

usermode table logs param onload img height tle http 在異步請求中要返回文件流，不能使用JQuery，因為$.ajax,$.post 不支持返回二進制文件流的類型，可以看到下圖，dataType只支持xml，json，sc