一、结果缓存
结果缓存，用于加速热门数据的访问速度，Dubbo提供声明式缓存，以减少用户加缓存的工作量。
lru 基于最近最少使用原则删除多余缓存，保持最热的数据被缓存，实现如下：
<dubbo:reference id="userService" group="*" interface="com.patty.dubbo.api.service.UserService" timeout="10000" retries="3" mock="true" check="false"> <dubbo:method name="findAllUsers" merger="myMerger" cache="lru"> </dubbo:method> </dubbo:reference>
cache="lru"表示采用lru缓存策略，运行后，可在与数据库交互的代码块上打个断点，会发现，首次请求时会穿透数据库，再次请求，则直接走dubbo缓存拿数据了。当然，实际应用中，最后还是继承redis到dubbo，实现缓存策略。
集成Redis(服务提供方):
1) pom.xml中加入redis依赖
<!-- Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
2）配置jedis
/** * Jedis数据源配置 * * @return JedisPoolConfig */ @Bean public JedisPoolConfig jedisPoolConfig() { JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); jedisPoolConfig.setMaxIdle(maxIdle); jedisPoolConfig.setMinIdle(minIdle); jedisPoolConfig.setMaxWaitMillis(maxWait); return jedisPoolConfig; } /** * Jedis数据连接工场 * * @return JedisConnectionFactory */ @Bean public JedisConnectionFactory redisConnectionFactory(JedisPoolConfig poolConfig) { JedisConnectionFactory factory = new JedisConnectionFactory(); factory.setHostName(host); factory.setPort(port); factory.setTimeout(timeout); if (StringUtils.isNotEmpty(password)) { factory.setPassword(password); } factory.setDatabase(database); factory.setPoolConfig(poolConfig); return factory; }
3）实现redis操作逻辑
@Component public class RedisBaseService { private Logger LOGGER = LoggerFactory.getLogger(RedisBaseService.class); @Autowired private RedisTemplate<String, String> redisTemplate; /** * 获取Set集合数据 * param key * return Set<String> */ public Set<String> getSets(String key) { return redisTemplate.opsForSet().members(key); } /** * 移除Set集合中的value * param k * param v */ public Long removeSetValue(String key, String value) { if (key == null && value == null) { return 0L; } return redisTemplate.opsForSet().remove(key, value); } /** * 保存到Set集合中 * param k * param v */ public Long setSet(String k, String v) { if (k == null && v == null) { return 0L; } return redisTemplate.opsForSet().add(k, v); } /** * 存储Map格式 * param key * param hashKey * param hashValue */ public void setMap(String key, String hashKey, Object hashValue) { redisTemplate.opsForHash().put(key, hashKey, hashValue); } /** * 根据key获取map对象 * param key */ public Map<Object, Object> getMap(String key) { return redisTemplate.opsForHash().entries(key); } /** * 存储带有过期时间的key-value * param key * param value * param timeOut 过期时间 * param unit 时间单位 */ public void setTime(String key, String value, Long timeOut, TimeUnit unit) { if (value == null) { LOGGER.info("redis存储的value的值为空"); throw new IllegalArgumentException("redis存储的value的值为空"); } if (timeOut > 0) { redisTemplate.opsForValue().set(key, value, timeOut, unit); } else { redisTemplate.opsForValue().set(key, value); } } /** * 存储key-value * param key * return Object */ public void set(String key, String value) { if (value == null) { LOGGER.info("redis存储的value的值为空"); throw new IllegalArgumentException("redis存储的value的值为空"); } redisTemplate.opsForValue().set(key, value); } /** * 根据key获取value * param key * return Object */ public String get(String key) { return redisTemplate.opsForValue().get(key); } /** * 判断key是否存在 * param key * return Boolean */ public Boolean exists(String key) { return redisTemplate.hasKey(key); } /** * 删除key对应的value * param key */ public void removeValue(String key) { if (exists(key)) redisTemplate.delete(key); } /** * 模式匹配批量删除key * param keyPattern */ public void removePattern(String keyPattern) { Set<String> keys = redisTemplate.keys(keyPattern); if (keys.size() > 0) redisTemplate.delete(keys); } }
4) 在业务逻辑中，加入缓存设置
/** * 根据id查询指定用户 * * @param id * @return */ public UserVo findUserById(String id) { if (redisBaseService.exists(id)) { Map<Object, Object> userMap = redisBaseService.getMap(id); return new UserVo( id, (String) userMap.get("name"), Integer.valueOf(userMap.get("age") + ""), (String) userMap.get("phoneNo")); } else { User user = userDao.findUserById(id); redisBaseService.setMap(id, "name", user.getName()); redisBaseService.setMap(id, "age", user.getAge() + ""); redisBaseService.setMap(id, "phoneNo", user.getPhoneNo()); return this.UserToUserVo(user); } }
5）具体代码参见：https://github.com/pattywgm/dubbo-demo.git
二、上下文信息
上下文中存放的是当前调用过程中所需的环境信息。RpcContext是一个ThreadLocal的临时状态记录器，当接收到RPC请求，或发起RPC请求时，RpcContext的状态都会变化。比如：A调B，B再调C，则B机器上，在B调C之前，RpcContext记录的是A调B的信息，在B调C之后，RpcContext记录的是B调C的信息。
服务提供方：
public class XxxServiceImpl implements XxxService { public void xxx() { // 服务方法实现 boolean isProviderSide = RpcContext.getContext().isProviderSide(); // 本端是否为提供端，这里会返回true String clientIP = RpcContext.getContext().getRemoteHost(); // 获取调用方IP地址 String application = RpcContext.getContext().getUrl().getParameter("application"); // 获取当前服务配置信息，所有配置信息都将转换为URL的参数 // ... yyyService.yyy(); // 注意：每发起RPC调用，上下文状态会变化 boolean isProviderSide = RpcContext.getContext().isProviderSide(); // 此时本端变成消费端，这里会返回false // ... } }
服务消费方：
xxxService.xxx(); // 远程调用 boolean isConsumerSide = RpcContext.getContext().isConsumerSide(); // 本端是否为消费端，这里会返回true String serverIP = RpcContext.getContext().getRemoteHost(); // 获取最后一次调用的提供方IP地址 String application = RpcContext.getContext().getUrl().getParameter("application"); // 获取当前服务配置信息，所有配置信息都将转换为URL的参数 // ... yyyService.yyy(); // 注意：每发起RPC调用，上下文状态会变化 // ...
三、异步调用
基于NIO的非阻塞实现并行调用，客户端不需要启动多线程即可完成并行调用多个远程服务，相对多线程开销较小。
现在我们在api包中，声明两个接口：ShoppingService和EatingService，并在服务方分别实现这两个接口，如下：
public interface EatingService { public String eating(); } @Service("eatingService") public class EatingServiceImpl implements EatingService { public EatingServiceImpl() { } @Override public String eating() { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } return "Eating for 5 seconds"; } }
public interface ShoppingService { public String shopping(); } @Service("shoppingService") public class ShoppingServiceImpl implements ShoppingService { public ShoppingServiceImpl(){ } @Override public String shopping() { try { Thread.sleep(6000); } catch (InterruptedException e) { e.printStackTrace(); } return "Shopping for 6 seconds"; } }
其中eatingService要运行大约5S， shoppingService运行大约6S实际。
在dubbo-provider.xml中配置这两个服务，进行注册。
<dubbo:service ref="shoppingService" interface="com.patty.dubbo.api.service.ShoppingService"/> <dubbo:service ref="eatingService" interface="com.patty.dubbo.api.service.EatingService"/>
在消费方，订阅这两个服务：
1）不采用异步调用的方式
<dubbo:reference id="shoppingService" interface="com.patty.dubbo.api.service.ShoppingService" timeout="200000" async="false"></dubbo:reference> <dubbo:reference id="eatingService" interface="com.patty.dubbo.api.service.EatingService" timeout="200000" async="false"></dubbo:reference>
@RequestMapping(value = "/doSomething", method = RequestMethod.GET) @ResponseBody public String doSomething() { return "Doing: " + shoppingService.shopping(); + " " + eatingService.eating();; }
启动程序，由于未采用异步方式，整个rpc请求的返回时间大约11s左右，如图：
2）采用异步调用方式
<!-- NIO异步 --> <dubbo:reference id="shoppingService" interface="com.patty.dubbo.api.service.ShoppingService" timeout="200000" async="true"></dubbo:reference> <dubbo:reference id="eatingService" interface="com.patty.dubbo.api.service.EatingService" timeout="200000" async="true"></dubbo:reference>
@RequestMapping(value = "/doSomething", method = RequestMethod.GET) @ResponseBody public String doSomething() { shoppingService.shopping(); Future<String> shoppingFuture = RpcContext.getContext().getFuture(); // 拿到调用的Future引用，当结果返回后，会被通知和设置到此Future。 eatingService.eating(); Future<String> eatingFuture = RpcContext.getContext().getFuture(); try { String doSth1 = shoppingFuture.get(); String doSth2 = eatingFuture.get(); return "Doing: " + doSth1 + " " + doSth2; } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } return "Doing: "; }
将async属性值设为"true", 表示采用异步调用，同时再客户端doSomething()代码块中，利用Future来承载异步返回的结果，由于是异步调用，整个调用返回的时间取决于运行时间较长的那个，本例中大概6s左右。如图：
