dubbox2.8.4例子教程一

最新推荐文章于 2020-08-17 10:01:47 发布
最新推荐文章于 2020-08-17 10:01:47 发布
阅读量115 收藏
点赞数
文章标签： java json 大数据

简介

Dubbo是一个来自阿里巴巴的开源分布式服务框架，当当根据自身的需求，为Dubbo实现了一些新的功能，包括REST风格远程调用、Kryo/FST序列化等等。并将其命名为Dubbox（即Dubbo eXtensions），教程一就写生产者，教程二就写消费者

一、生产者工程结构

 

 

二、Simple.java（测试普通dubbo功能）

package bhz.entity;

import java.io.Serializable;
import java.util.Map;

public class Simple  implements Serializable
{  
     private static final long serialVersionUID = -4914434736682797743L;  
     private String name;  
     private int age;  
     private Map<String,Integer> map;  
     public Simple(){  
  
     }  
     public Simple(String name,int age,Map<String,Integer> map){  
         this.name = name;  
         this.age = age;  
         this.map = map;  
     }  
  
     public String getName() {  
       return name;  
     }  
  
     public void setName(String name) {  
        this.name = name;  
     }  
  
     public int getAge() {  
        return age;  
     }  
  
     public void setAge(int age) {  
        this.age = age;  
     }  
  
     public Map<String, Integer> getMap() {  
        return map;  
     }  
  
     public void setMap(Map<String, Integer> map) {  
        this.map = map;  
     }  
  
  
}

2、User.java（测试dubbox特有的rest服务）

package bhz.entity;

import java.io.Serializable;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;

import org.codehaus.jackson.annotate.JsonProperty;

@XmlRootElement
public class User implements Serializable
{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    @NotNull
    private String id;

    @NotNull
    @Size(min = 6, max = 50)
    private String name;
    
    public User() {
    }
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

3、dubbo-provider.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"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
    
    <!-- 引入properties配置文件 -->
    <util:properties id="zcparams" location="classpath:params.properties"></util:properties>
    
    <!-- 指定dubbox生产者名称 -->
    <dubbo:application name="provider" owner="programmer" organization="dubbox"/>

    <!-- zookeeper注册中心 -->
    <dubbo:registry address="zookeeper://192.168.0.4:2181?backup=192.168.0.5:2181,192.168.0.6:2181"/>

    <dubbo:annotation package="bhz.service" />
    <!-- kryo实现序列化-->
    <dubbo:protocol name="dubbo"  serialization="kryo" optimizer="bhz.utils.SerializationOptimizerImpl" /> 

    <!--指定 rest服务 -->
    <dubbo:protocol name="rest" server="tomcat" port="8888" contextpath="provider" accepts="500" />

</beans>

4、SimpleService.java

package bhz.service;

import bhz.entity.Simple;
/**
 * 测试普通dubbo服务
 * @author Administrator
 *
 */
public interface SimpleService {
    
    public String sayHello(String name);
 
    public Simple getSimple();
}

5、UserService.java

package bhz.service;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.alibaba.dubbo.rpc.protocol.rest.support.ContentType;

import bhz.entity.User;
/**
 * 功能:本类测试dubbox的rest服务
 * @author Administrator
 *
 */
@Path("/userService")
@Consumes({MediaType.APPLICATION_JSON, MediaType.TEXT_XML})    // @Consumes 注释代表的是一个资源可以接受的 MIME 类型
@Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_XML_UTF_8})    //@Produces 注释代表的是一个资源可以返回的 MIME 类型
public interface UserService {
    @GET
    @Path("/testget")
    public void testget();
    
    @GET
    @Path("/getUser")
    public User getUser();
    
    @GET
    @Path("/get/{id : \\d+}")
    public User getUser(@PathParam(value = "id") Integer id);
    
    @GET
    @Path("/get/{id : \\d+}/{name : [a-zA-Z][0-9]}")
    public User getUser(@PathParam(value = "id") Integer id, @PathParam(value = "name") String name);
    
    @POST
    @Path("/testpost")
    public void testpost();
    
    @POST
    @Path("/postUser")
    public User postUser(User user);
    
    @POST
    @Path("/post/{id}")
    public User postUser(@PathParam(value = "id") String id);

}

6、SimpleServiceImpl.java

package bhz.service.impl;

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Service;

import bhz.entity.Simple;
import bhz.service.SimpleService;
//spring注解
//@Service("simpleService") 
/*
 * dubbo注解
 * interfaceClass 指定服务接口
 * protocol 指定协议
 * retries 重试策略
 */
@com.alibaba.dubbo.config.annotation.Service(interfaceClass=bhz.service.SimpleService.class, protocol={"dubbo"}, retries=0)
public class SimpleServiceImpl implements SimpleService{

    @Override
    public String sayHello(String name) {
        return "hello" + name;
    }

    @Override
    public Simple getSimple() {
        Map<String,Integer> map = new HashMap<String, Integer>(2);  
        map.put("zhang0", 1);  
        map.put("zhang1", 2);  
        return new Simple("zhang3", 21, map);
    }

}

7、UserServiceImpl.java

package bhz.service.impl;

import bhz.entity.User;
import bhz.service.UserService;


//这个是dubbo的注解（同时提供dubbo本地，和rest方式）
@com.alibaba.dubbo.config.annotation.Service(interfaceClass=bhz.service.UserService.class, protocol = {"rest", "dubbo"}, retries=0)
public class UserServiceImpl implements UserService{

    public void testget() {
        //http://localhost:8888/provider/userService/getUser
        System.out.println("测试...get");
    }
    

    public User getUser() {
        System.out.println("==========");
        User user = new User();
        user.setId("1001");
        user.setName("张三");
        return user;
    }


    public User getUser(Integer id) {
        System.out.println("测试传入int类型的id: " + id);
        User user = new User();
        user.setId("1001");
        user.setName("张三");
        return user;
    }
    
    

    public User getUser(Integer id, String name) {

        System.out.println("测试俩个参数：");
        System.out.println("id: " + id);
        System.out.println("name: " + name);
        User user = new User();
        user.setId("1001");
        user.setName("张三");
        return user;
    }
    

    public void testpost() {
        System.out.println("测试...post");
    }
    

    public User postUser(User user) {
        System.out.println(user.getName());
        System.out.println("测试...postUser");
        User user1 = new User();
        user1.setId("1001");
        user1.setName("张三");
        return user1;
    }


    public User postUser(String id) {
        System.out.println(id);
        System.out.println("测试...post");
        User user = new User();
        user.setId("1001");
        user.setName("张三");
        return user;
    }
    
    

}

8、FastJsonConvert.java(fastJson转换工具类)

package bhz.utils;

import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
 * 功能:fastJson转换工具类
 * @author jacky
 *
 */
public class FastJsonConvert {


    private static final SerializerFeature[] featuresWithNullValue = { SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullBooleanAsFalse,
            SerializerFeature.WriteNullListAsEmpty, SerializerFeature.WriteNullNumberAsZero, SerializerFeature.WriteNullStringAsEmpty };

    /**
     * JsonString 转换 Object
     * 
     * @param <T>
     * @param data
     * @param clzss
     * @return
     */
    public static <T> T convertJSONToObject(String data, Class<T> clzss) {
        try {
            T t = JSON.parseObject(data, clzss);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;

        }
    }
    /**
     * JsonString 转换 List<Object>
     * 
     * @param <T>
     * @param data
     * @param clzss
     * @return
     */
    public static <T> List<T> convertJSONToArray(String data, Class<T> clzss) {
        try {
            List<T> t = JSON.parseArray(data, clzss);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
            
        }
    }

    /**
     * 功能:把java对象序列化成json字符串
     * @param obj  java实体
     * @return   json字符串
     */
    public static String convertObjectToJSON(Object obj) {
        try {
            String text = JSON.toJSONString(obj);
            System.out.println(text);
            return text;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * Object to JsonString
     *
     * @param <T>
     * @param data
     * @param valueType
     * @return
     */
    public static String convertObjectToJSONWithNullValue(Object obj) {
        try {
            String text = JSON.toJSONString(obj, featuresWithNullValue);
            return text;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        System.err.println(System.getProperties());
    }
}

9、HttpProxy.java(发送http请求，测试rest服务的工具类)

package bhz.utils;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class HttpProxy {
    private static class SingletonHolder {
        static final HttpProxy instance = new HttpProxy();
    }

    public static HttpProxy getInstance() {
        return SingletonHolder.instance;
    }

    private static CloseableHttpClient httpClient;
    
    private static final String CONTENT_TYPE_JSON = "application/json";

    static {
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(HttpProxyConfig.MAX_TOTAL_CONNECTIONS);
        cm.setDefaultMaxPerRoute(HttpProxyConfig.MAX_ROUTE_CONNECTIONS);
        
        
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(HttpProxyConfig.CONNECT_TIMEOUT)
                .setConnectTimeout(HttpProxyConfig.CONNECT_TIMEOUT)
                .build();
        //缓存
        /*        
         CacheConfig cacheConfig = CacheConfig.custom()
                .setMaxCacheEntries(1000)
                .setMaxObjectSize(8192)
                .build();
        */
        httpClient = HttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(cm)
                .build();
    }

    public static HttpClient getHttpClient() {
        return httpClient;
    }
    
    /**
     * <B>方法名称：</B>普通请求<BR>
     * <B>概要说明：</B>普通请求<BR>
     * @param requestUrl 请求路径
     * @param requestContent 请求内容
     * @return 返回响应结果
     * @throws IOException
     */
    public static String post(String requestUrl, String requestContent) throws IOException {
        StringEntity requestEntity = new StringEntity(requestContent, Consts.UTF_8);
        return execute(requestUrl,requestEntity);
    }
    
    /**
     * 功能:发送json请求
     * @param requestUrl   请求路径url
     * @param jsonContent  json字符串
     * @return 返回json字符串
     * @throws IOException
     */
    public static String postJson(String requestUrl, String jsonContent) throws IOException {
        StringEntity requestEntity = new StringEntity(jsonContent, Consts.UTF_8);
        requestEntity.setContentEncoding("UTF-8");    
        requestEntity.setContentType(CONTENT_TYPE_JSON);  
        return execute(requestUrl,requestEntity);
    }

    /**
     * <B>方法名称：</B>模拟表单上传<BR>
     * <B>概要说明：</B>模拟表单上传<BR>
     * @param requestUrl 请求路径
     * @param params 属性参数
     * @return 返回响应结果
     * @throws IOException
     */
    public static String post(String requestUrl, Map<String, String> params) throws IOException {
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        if (params != null) {
            for (Map.Entry<String, String> entry : params.entrySet()) {
                nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
        }
        EntityBuilder builder = EntityBuilder.create();
        builder.setParameters(nvps);
        HttpEntity httpEntity = builder.build();
        return execute(requestUrl,httpEntity);
    }
    
    /**
     * <B>方法名称：</B>上传文件<BR>
     * <B>概要说明：</B>上传文件<BR>
     * @param requestUrl 请求路径
     * @param localFile  文件位置
     * @param username       用户名
     * @param password       密码
     * @return 响应信息
     * @throws IOException
     */
    public static String upload(String requestUrl, String localFile, String username, String password) throws IOException {
        HttpPost httpPost = new HttpPost(requestUrl);
        // 把文件转换成流对象FileBody
        FileBody fileBody = new FileBody(new File(localFile));
        StringBody usernameInp = new StringBody(username, ContentType.create("text/plain", Consts.UTF_8));
        StringBody passwordInp = new StringBody(password, ContentType.create("text/plain", Consts.UTF_8));
        HttpEntity httpEntity = MultipartEntityBuilder.create()
                // 相当于<input type="file" name="file"/>
                .addPart("file", fileBody)
                // 相当于<input type="text" name="userName" value=userName>
                .addPart("username", usernameInp)
                .addPart("password", passwordInp)
                .build();
        return execute(requestUrl,httpEntity);
    }
    
    /**
     * 功能:执行请求方法
     * @param requestUrl 请求路径Url
     * @param httpEntity  封装好的http实体
     * @return json字符串
     * @throws IOException
     */
    private static String execute(String requestUrl, HttpEntity httpEntity) throws IOException {
        String result = null;
        HttpPost httpPost = new HttpPost(requestUrl);
        httpPost.setEntity(httpEntity);    
        try {
            CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
            try {
                HttpEntity entity = httpResponse.getEntity();
                if (httpResponse.getStatusLine().getReasonPhrase().equals("OK") && httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                    result = EntityUtils.toString(entity, "UTF-8");
                }
                //进行销毁
                EntityUtils.consume(entity);
            } finally {
                if (null != httpResponse) {
                    httpResponse.close();
                }
            }
        } finally {
            if (null != httpPost) {
                httpPost.releaseConnection();
            }
        }
        return result;
    }
    /**
     * 功能:发送http的get请求
     * @param requestUrl   请求url
     * @return 字符串
     */
    public static String get(String requestUrl){
        HttpGet httpGet = new HttpGet(requestUrl);
        // 执行get请求.  
        CloseableHttpResponse response =null;
        HttpEntity entity =null;
        String result =null;
        try {
            response = httpClient.execute(httpGet);
            entity = response.getEntity();
             // 打印响应状态    
            System.out.println(response.getStatusLine());  
            if (entity != null) {  
                // 打印响应内容长度    
                System.out.println("Response content length: " + entity.getContentLength());  
                // 打印响应内容    
                result = EntityUtils.toString(entity);
                System.out.println("Response content: " + result);  
            }  
            System.out.println("------------------------------------");   
        } catch (Exception e) {
            e.printStackTrace();
        }finally {  
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }  
        }  
        return result;    
    }
    

    
}

10、HttpProxyConfig.java

package bhz.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * <br>
 * 类 名: HttpCallerConfig <br>
 * 描 述: http属性配置参数 <br>
 */
@Component
public class HttpProxyConfig {
    /**
     * 最大连接数
     */
    public static int MAX_TOTAL_CONNECTIONS = 800;
    /**
     * 每个路由最大连接数
     */
    public static int MAX_ROUTE_CONNECTIONS = 400;
    /**
     * 连接超时时间
     */
    public static int CONNECT_TIMEOUT = 10000;
    /**
     * 读取超时时间
     */
    public static int READ_TIMEOUT = 10000;

    /**
     * 设置 mAX_TOTAL_CONNECTIONS
     * 
     * @param mAX_TOTAL_CONNECTIONS
     */
    @Value("#{zcparams[max_total_connections]}")
    private void setMAX_TOTAL_CONNECTIONS(int mAX_TOTAL_CONNECTIONS) {
        MAX_TOTAL_CONNECTIONS = mAX_TOTAL_CONNECTIONS;
    }

    /**
     * 设置 mAX_ROUTE_CONNECTIONS
     * 
     * @param mAX_ROUTE_CONNECTIONS
     */
    @Value("#{zcparams[max_total_connections]}")
    private void setMAX_ROUTE_CONNECTIONS(int mAX_ROUTE_CONNECTIONS) {
        MAX_ROUTE_CONNECTIONS = mAX_ROUTE_CONNECTIONS;
    }

    /**
     * 设置 cONNECT_TIMEOUT
     * 
     * @param cONNECT_TIMEOUT
     */
    @Value("#{zcparams[connect_timeout]}")
    private void setCONNECT_TIMEOUT(int cONNECT_TIMEOUT) {
        CONNECT_TIMEOUT = cONNECT_TIMEOUT;
    }

    /**
     * 设置 rEAD_TIMEOUT
     * 
     * @param rEAD_TIMEOUT
     */
    @Value("#{zcparams[read_timeout]}")
    private void setREAD_TIMEOUT(int rEAD_TIMEOUT) {
        READ_TIMEOUT = rEAD_TIMEOUT;
    }

}

11、SerializationOptimizerImpl.java(自定义序列化实现类)

package bhz.utils;

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import bhz.entity.Simple;
import bhz.entity.User;

import com.alibaba.dubbo.common.serialize.support.SerializationOptimizer;

public class SerializationOptimizerImpl implements SerializationOptimizer {

    public Collection<Class> getSerializableClasses() {
        List<Class> classes = new LinkedList<Class>();
        //这里可以把所有需要进行序列化的类进行添加
        classes.add(User.class);
        classes.add(Simple.class);
        return classes;
    }
}

12、log4j.properties

log4j.rootLogger=INFO, console, file

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.file.File=D:/002_developer/workspace_001/zcmoni.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.logger.org.springframework=WARN

13、params.properties

#HttpCaller
max_total_connections = 1600
max_route_connections = 1200
connect_timeout = 30000
read_timeout = 30000

14、Provider.java(启动dubbo服务类)

package bhz.test;


import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Provider {

    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                new String[] { "dubbo-provider.xml" });
        context.start();
        System.in.read(); // 为保证服务一直开着，利用输入流的阻塞来模拟
    }
}

15、HttpTest1.java(测试dubbox的rest服务类)

package bhz.test;

import bhz.entity.User;
import bhz.utils.FastJsonConvert;
import bhz.utils.HttpProxy;

public class HttpTest1 {

    public static void main(String[] args) throws Exception{
        User user = new User();
        user.setId("1001");
        user.setName("李四");
        String responseStr1 = HttpProxy.postJson("http://localhost:8888/provider/userService/postUser",
                FastJsonConvert.convertObjectToJSON(user));
        System.out.println("post请求返回的结果"+responseStr1);
        System.out.println("========================");
        String string = HttpProxy.get("http://localhost:8888/provider/userService/getUser");
        System.out.println("get请求返回的结果"+string);
        
    }
}

16、测试结果

========================
HTTP/1.1 200 OK
Response content length: -1
Response content: {"id":"1001","name":"张三"}
------------------------------------
get请求返回的结果{"id":"1001","name":"张三"}

参考资料地址

http://dangdangdotcom.github.io/dubbox/

http://www.open-open.com/lib/view/open1417426480618.html

weixin_34250434
关注
Dubbox-2.8.4源码Maven编译及部署
shanghongbin的专栏
02-19 518
1.下载Dubbox-2.8.4源码 地址：https://github.com/dangdangdotcom/dubbox/releases/tag/dubbox-2.8.4 2.将源码压缩包解压到磁盘 3.用Maven编译 开启cmd，进入dubbox根目录，例如：D:\dubbox-dubbox-2.8.4，执行如下命令： mvn install -Dmaven.test...
dubbox-2.8.4
09-20
dubbox-dubbox-2.8.4的压缩包，里面包含了bubbo的所有源码,dubbox2.8.4版本，增强dubbox功能，由当当网开源出来,maven构建！
dubbox 2.8.4 服务端消费端配置示例
weixin_34117522的博客
06-08 196
2019独角兽企业重金招聘Python工程师标准>>> ...
dubbox2.8.4
04-27
dubbox2.8.4版本，增强dubbox功能，由当当网开源出来,maven构建！
dubbox 2.8.4 完整jar包
12-14
是dubbox的jar2.8.4版本的jar完整jar包 因为用pom文件下载不下来只好自己从网上下载下来 共享给大家.
dubbox 2.8.4 版本 maven 依赖
01-08
附件为：dubbox2.8.4 maven依赖文件。 使用方法：按照依赖关系，自行创建maven依赖文件夹后，将附件解压至指定文件夹即可使用。 可解决Missing artifact com.alibaba:dubbo:jar:2.8.4 dubbo问题。
dubbox例子
01-17
dubbox例子，一个消费者工程和两个生产者工程
dubbox2.8.4.rar
12-06
2.8.4 版本是 Dubbox 的一个稳定版本，可能包含了一些新特性、优化或者修复了已知的问题。由于在阿里云库中找不到这个特定版本的 rar 包，这可能是由于某些原因，如版本更新或者资源迁移，导致的。不过，你已经找到...
dubbo 基于dubbox 2.8.4 编译
08-18
dubbo 基于dubbox 2.8.4 编译
dubbox 2.8.4
03-22
jdk1.7.0_13,win7 x86 环境下编译的 dubbox 2.8.4
dubbox 2.8.4 版本 maven 依赖
01-23
附件为：dubbox2.8.4 maven依赖文件。 使用方法：按照依赖关系，自行创建maven依赖文件夹后，将附件解压至指定文件夹即可使用。 文件夹目录：com/alibaba/dubbo/2.8.4/ com.alibaba dubbo 2.8.4
dubbox2.8.4（需要自己解压一下）
03-08
已经编译好的dubbox2.8.4 只需要直接放在本地仓库（repository\com）即可使用
SpringBoot2.x集成dubbo2.8.4消费者
绊脚石
07-06 1795
dubbo版本2.8.4，springboot版本2.x 引入依赖 dubbo-spring-boot-starter，dubbo的启动依赖 dubbo依赖。可根据dubbo服务提供者的版本进行更改，需要在dubbo-spring-boot-starter中将dubbo依赖排除 zkclient。zookeeper相关依赖，如不想使用自带依赖版本，则可排除zookeeper依赖，引入所需版本的zookeeper依赖 服务提供者jar包 <dependency> <groupId&g
dubbox 2.8.4的配置和使用
风.foxwho(神秘狐)
02-24 1976
JAVA jdk安装 http://blog.csdn.net/fenglailea/article/details/26006647 zookeeper安装 http://blog.csdn.net/fenglailea/article/details/52458737 只看第一个
Dubbo @Reference retries=0 不生效
代码搬运工
05-16 6718
一、背景 在使用dubbo服务中避免不了重试机制，平时新增、更新操作通常都会设置dubbo服务只调用一次，不然服务就需要做幂等，因为dubbo重试次数默认是2次，所以服务只调用一次需要设置retries =0，今天就来简单讲解下@Reference retries=0 这 一个小坑。 二、代码讲解 本文讲解的是Springboot集成Alibaba Dubbo版本 <dependency> <groupId>com.alibaba.boot</groupId&g
@Reference(retries=0)依然会重试2次问题分析
zidongxiangxi的博客
08-17 1668
问题 使用@Reference 注解的时候，发现设置retries=0，还是会出现调用3次的情况，而不是我们期望的不重试。 代码分析 dubbo默认的集群方式是failover，看FailoverClusterInvoker的代码，重试次数在这部分代码：  从这部分代码可以看出来，次数是从url的retries参数拿到的，如果拿不到就会使用Constants.DEFAULT_RETRIES=2 所以，如果@Reference没有配置retries，次数就会是2+1=3，即失败后还会重试2次。  但为什
关于dubbox-2.8.4血与泪的总结
xiejunxing的专栏
10-31 9585
1、准备工作  下载dubbox的源代码  下载地址：https://github.com/dangdangdotcom/dubbox 2、编译源码（此处默认大家会用maven了）  运行maven命令：mvn clean install -Dmaven.test.skip=true ，此处注意，有坑，在win10上面默认是使用 windows PowerShell来启动的，在这个工具
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值