SpringBoot+Dubbo实现分布式微服务开发实战系列（三）

最新推荐文章于 2024-04-12 02:57:46 发布

键盘客

最新推荐文章于 2024-04-12 02:57:46 发布

阅读量2.9k

点赞数

分类专栏： IT 文章标签： SpringBoot开发 SpringBoot+Dubbo电商项目开发 Dubbo实现电商项目开发 SpringBoot微服务落地开发电商分布式微服务项目

本文链接：https://blog.csdn.net/u011134780/article/details/92735224

版权

IT 专栏收录该内容

33 篇文章 5 订阅

订阅专栏

上一篇文章总结了基于SpringBoot实现分布式微服务下的统一配置、分环境部署配置。以及服务端模块的分离（每一个提供者就是一个独立的微服务）、微服务落地、Dubbo整合及提供者、消费者的配置实现。本次文章将接入数据库及缓存实现。项目结构如下：

从上图可以看出，我们要在提供者和消费者之间搭建缓存服务，本次以Redis为例讲解。系统在接入缓存服务后，对访问量大的查询接口，我们可以在接口第一次从服务端（提供者）获取数据后缓存起来，后面的请求进来先从缓存中获取，如果缓存中存在直接返回，否则调用提供者（查询数据库）获取数据，并添加到缓存中。这在高并发的情况下，会大大提升服务的效应效率，减轻提供者和数据库的压力。

基于之前的项目，我们一点一点的深入探讨，今天先从版本管理开始讲起。

版本统一管理

一，子模块版本控制

先看看父级项目的pom文件配置，设置各个子模块依赖的版本号。

再来看看各个模块的版本设置。

common模块pom配置

提供者以系统服务模块（lyn-sys）为例，其他模块设置相同。

lyn-sys下接口模块pom

lyn-sys下接口实现模块pom

再看看消费者lyn-web的依赖。

为什么要统一管理？我想有多年开发经验的Coder一定很明白它的重要性，这里不多讲。

二，第三方Jar依赖控制

关于第三方Jar管理，只需要将这些依赖放到<dependencyManagement>里面去，这里仅仅是应用外部的Jar，SpringBoot基本依赖并不放在这里。

SpringBoot基础依赖

其他第三方依赖

其他模块如果需要用到这些第三方Jar，就在自己的模块对应去添加，这样可以较少其他模块对不必要的jar依赖，减小最终jar/war包的的大小。如Dubbo依赖，各个提供者的接口层（***-api）就不需要依赖这个服务，它仅提供给服务实现及消费者依赖。所以我们只需在各个服务模块的Service现实（***-service）及消费者模块（lyn-web）pom里依赖。

数据库连接实现

先在pom里引入数据库的相关依赖（属于第三方被管理的jar）

然后在各个提供者实现（***-service）模块的pom里依赖

这里Mybatis逆向生成和数据库连接池的依赖在lyn-common模块的pom里。提供者实现模块的properties配置

然后使用逆向工程执行生成实体、mapper及xml映射文件。这里以lyn-goods服务层的结构为例。

在对应提供者的***-api里写Service接口及在***-service里写对应的Service接口的实现代码，上面是goods-service的代码实现为例。其他模块类似，到此为止，数据库及基础代码已生成，接着编写对应的Controller服务，此处代码不讲。

Redis接入即实现

目前java操作redis的客户端有jedis跟Lettuce。在springboot1.x系列中，其中使用的是jedis，但是到了springboot2.x使用的是Lettuce。因为我们的版本是springboot2.1，所以今天使用的是Lettuce。,父级pom里依赖如下：

这里我使用的版本分别如下：

Redis的版本号：2.1.2.RELEASE

commons-pools的版本：2.5.0

jackson-databind版本号：2.9.6

接下来配置Redis，目录结构如下：

代码：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.lang.reflect.Method;

/**
 * <p>Redis缓存配置</p>
 *
 * @author lft
 * @version 1.0
 * @date 2019/6/13 0013
 * @since jdk1.8
 */
@Configuration
@EnableCaching //启用缓存
public class CacheConfig extends CachingConfigurerSupport {

    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    /**
     * 缓存配置管理器
     */
    @Bean
    public CacheManager cacheManager(LettuceConnectionFactory factory) {
        //以锁写入的方式创建RedisCacheWriter对象
        RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
        //创建默认缓存配置对象
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        RedisCacheManager cacheManager = new RedisCacheManager(writer, config);
        return cacheManager;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

封装Redis缓存类：

public interface CacheService {
    Object getCache(String key);
    void setCache(String key, Object value);
    void setCache(String key, Object value, long time);
    <T> void setList(String key, List<T> os);
    <T> void setList(String key, List<T> os, long time);
    <T> List<T> getList(String key);
    boolean isExistKey(String key);
    void removeKey(String key);
    Set<String> getMatchPrefixKey(String prefix);
    Long getExpire(String key);
}

实现代码：

@Service("cacheService")
public class CacheServiceImpl implements CacheService {
    private static Logger logger = LoggerFactory.getLogger(CacheServiceImpl.class);
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Object getCache(String key) {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        return valueOperations.get(key);
    }
    @Override
    public void setCache(String key, Object value) {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        valueOperations.set(key, value);
    }
    @Override
    public void setCacheToRedis(String key, Object value, long time) {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        if(time > 0){
            valueOperations.set(key, value, time, TimeUnit.SECONDS);
        }else{
            valueOperations.set(key, value);
        }
    }
    @Override
    public <T> void setList(String key, List<T> os) {
        ListOperations<String,Object> listOperations = redisTemplate.opsForList();
        for (Object o : os) {
            listOperations.rightPush(key, o);
        }
    }
    @Override
    public <T> void setList(String key, List<T> os, long time) {
        if(time > 0){
            ListOperations<String,Object> listOperations = redisTemplate.opsForList();
            for (Object o : os) {
                listOperations.rightPush(key, o);
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        }
    }
    @Override
    public <T> List<T> getList(String key) {
        ListOperations<String, Object> listOperations = redisTemplate.opsForList();
        List<T> o = null;
        if (listOperations.size(key) > 0) {
            o = (List<T>) listOperations.range(key, 0, -1);
        }
        return o;
    }
    @Override
    public boolean isExistKey(String key) {
        if(!StringUtils.isEmpty(key)) {
            return redisTemplate.hasKey(key);
        }
        return false;
    }
    @Override
    public void removeKey(String key) {
        redisTemplate.delete(key);
    }
    @Override
    public Set<String> getMatchPrefixKey(String prefix) {
        if(!StringUtils.isEmpty(prefix)) {
            Set<String> keys = stringRedisTemplate.keys(prefix + "*");
            if(keys==null || keys.size() == 0){
                return null;
            }
            return keys;
        }
        return null;
    }
    @Override
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }
}

现在，在我们的消费者properties里配置redis。

接着我们在Controller里写一个测试接口

消费者（lyn-web）启动类添加包扫描，如下：

在数据库添加一条数据

然后启动四个提供者和一个消费者服务测试。

再通过Redis客户端看看缓存的数据。

本次讲了SpringBoot分布式微服务开发下的子模块及第三方jar的版本统一管理、数据库接入、Redis的配置及简单的缓存实现。到目前为止，一个简单的项目分布式电商项目已经基本成型，但如果要以正式项目开发使用，那还有很多需要处理和优化。比如Reids缓存，如何防止缓存被击穿和缓存雪崩的发生？下期我们继续深入去讨论实现。

精彩文章推荐：

Spring Boot实现分布式微服务开发实战系列（一）

Spring Boot实现分布式微服务开发实战系列（二）

扫码关注微信公众号可查看完整系列文章，并可获取相关学习资料；

键盘客

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot+Dubbo实现分布式微服务开发实战系列（三）

上一篇文章总结了基于SpringBoot实现分布式微服务下的统一配置、分环境部署配置。以及服务端模块的分离（每一个提供者就是一个独立的微服务）、微服务落地、Dubbo整合及提供者、消费者的配置实现。本次文章将接入数据库及缓存实现。项目结构如下：从上图可以看出，我们要在提供者和消费者之间搭建缓存服务，本次以Redis为例讲解。系统在接入缓存服务后，对访问量大的查询接口，我们可以在接口第...
复制链接

扫一扫