Springboot + Dubbo + Redis + Mysql 整合

一、项目分包

分包

分包

• common: 通用工具类
• springboot-system:
  1. springboot-ap: 映射实体类以及服务接口
  2. springboot-service:mapper接口以及服务实现
• springboot-web:前端控制层

分包可按个人喜欢进行分包

二、添加依赖

image.png

            
            
                org.apache.dubbo
                dubbo-spring-boot-starter
                ${dubbo.version}
            

            
                org.apache.dubbo
                dubbo
                ${dubbo.version}
            
            
            
                org.apache.curator
                curator-recipes
                2.7.0
            
            
            
                com.101tec
                zkclient
                ${zkclient.version}
            
          
         
              org.springframework.boot
              spring-boot-starter-data-redis
          

三、修改配置文件application.yml

sys:
  service:
    #定义版本号
    version: 1.0.0
# Dubbo 服务提供者配置
dubbo:
  application:
    #服务名称
    name: dubbo-service
  registry:
    #服务注册地址
    address: zookeeper://127.0.0.1:2181
  # Dubbo 协议与端口
  protocol:
    #dubbo 协议
    name: dubbo
    #随机端口号:表示让dubbo自行找一个可用的port
    port: -1
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/sys?relaxAutoCommit=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&characterSetResults=UTF-8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&failOverReadOnly=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis连接地址
    host: 127.0.0.1
    # Redis 端口号
    port: 6379
    # Redis服务器连接密码（默认为空）
    password:
    pool:
      #连接池最大连接数（使用负值表示没有限制）
      max-active: 8
      # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池中的最小空闲连接
      min-idle: 0
      # 连接超时时间（毫秒）
    timeout: 300
mybatis:
  mapper-locations: classpath:mappers/*.xml
  configuration:
    map-underscore-to-camel-case: true
  type-aliases-package: com.podinns.domain
server:
  #完全关闭HTTP端点，但仍创建一个WebApplicationContext
  port: -1

Service层配置
@Service 用在服务提供者中，在类或者接口中声明。
服务提供者实现相关的服务接口，当消费端调用相关的类时，最终会调用提供者的实现方法。
@Reference 用在消费端，表明使用的是服务端的什么服务
Redis配置：

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 缓存数据时Key的生成器，可以依据业务和技术场景自行定制
     *
     * @return
     */
    @Bean
    @Override
    @Deprecated
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            //类名+方法名
            sb.append(target.getClass().getName());
            sb.append(".").append(method.getName());
            for (Object obj : params) {
                sb.append(obj);
            }
            return sb.toString();
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory))
                // 默认缓存过期时间：天
                .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(30)))
                .transactionAware()
                .build();
    }

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

Service实现类配置：

/**
       当出现系统版本升级时,新版本有可能不够稳定,这时候可以通过设置version来进行平滑的过渡,下面是dubbo官网的版本迁移步骤：

　　　　在低压力时间段，先升级一半提供者为新版本，再将所有消费者升级为新版本，然后将剩下的一半提供者升级为新版本

　　　　而新旧版本我们可以通过version来定义,假设老版本的version=1.0.0新版本的version=2.0.0；

　　　　老版本服务提供者：@Service(version='1.0.0')

　　　　新版本服务提供者：@Service(version='2.0.0')

　　　　老版本服务消费者：@Reference(version='1.0.0')

　　　　新版本服务消费者：@Reference(version='2.0.0')

　　　　这样新旧版本就完美错开,只会调用version对应的服务,如果调用的时候不需要区分版本号,则进行如下配置：@Reference(version='*'),这样dubbo会默认在新老版本中随机调用
*/
@Service(version = "${sys.service.version}")
public class MasterBaseServiceImpl implements MasterBaseService {
    @Autowired
    private MasterBaseMapper masterBaseMapper;
    //注入RedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public Map insert() {
        MasterBase masterBase = masterBaseMapper.selectByPrimaryKey(509);
        masterBase.setId(null);
        masterBase.setGuestTypeCode("HOU");
        masterBase.setDays(null);
        masterBase.setTimes("3");
        masterBaseMapper.insert(masterBase);
        String key = "order_hou_" + masterBase.getId();
        Map map = new HashMap<>();
        map.put("orderId",masterBase.getId());
        map.put("expireTime", DateUtils.getStrDateTime(masterBase.getDepDatetime()));
        map.put("roomNum",masterBase.getRoomNo());
        map.put("rsvMan",masterBase.getRsvMan());
        //Redis   Map类型存储
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.putAll(key,map);
        //Redis获取Map
        Map mapValue = getMapValue("order_hou_" + masterBase.getId());
        // *号 必须要加，否则无法模糊查询
        String prefix = "order_hou_" + "*";
        // 获取所有的key
        Set keys = redisTemplate.keys(prefix);
        for (String str : keys) {
            System.out.println(str);
        }
        return mapValue;
    }

    public Map getMapValue(String key) {
        HashOperations hps = redisTemplate.opsForHash();
        return hps.entries(key);
    }
}

此时服务就已经注册到注册中心了，然后配置消费端

application.yml配置文件配置

dubbo:
  registry:
    address: zookeeper://127.0.0.1:2181
  consumer:
    version: 1.0.0
#    actives:
server:
  port: 8089
spring:
  application:
    name: springboot-web
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis连接地址
    host: 127.0.0.1
    # Redis 端口号
    port: 6379
    # Redis服务器连接密码（默认为空）
    password:
    pool:
      #连接池最大连接数（使用负值表示没有限制）
      max-active: 8
      # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池中的最小空闲连接
      min-idle: 0
      # 连接超时时间（毫秒）
    timeout: 300
#距离多少分钟时间进行提醒（minutes）
alarm:
  minutes: 5

服务启动：

@SpringBootApplication
@EnableDubbo //开启dubbo服务扫描
@EnableTransactionManagement
public class SysApplication {
    public static void main(String[] args) {
        SpringApplication.run(SysApplication.class,args);
    }
}

配置消费端

@Controller
@RequestMapping("/sys")
public class SysController {
  
    //配置调用的服务
    @Reference(version = "${dubbo.consumer.version}")
    private SysService sysService;
    @Reference(version = "${dubbo.consumer.version}")
    private MasterBaseService masterBaseService;
    @Resource
    private RedisUtil redisUtil;


    @PostMapping("/getSys")
    @ResponseBody
    public List  getSys(){
        return sysService.getAll();
    }

    @PostMapping("/set")
    @ResponseBody
    public boolean setRedisCache(){
        Map map = new HashMap();
        map.put("001","张三");
        map.put("002","李四");
        return redisUtil.set("stuMap", map, -1);
    }

    @PostMapping("/get")
    @ResponseBody
    public Object getRedisCache(){
        Object stuMap = redisUtil.getHashSet("stuMap");
        return stuMap;
    }

    @PostMapping("/getMasterBase")
    @ResponseBody
    public Map getMasterBase(){
        Map insert = masterBaseService.insert();
        return insert;
    }
}

服务启动：

@EnableDubbo//启动Dubbo服务扫描
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
//@ImportResource(locations={"dubbo/dubbo-consumer.xml"})
public class AppApplication {
    public static void main(String[] args) {
        SpringApplication.run(AppApplication.class,args);
    }
}

Dubbo负载均衡配置：

image.png

修改Dubbo负载均衡策略:

1、zk集群 配置

1.1：非主从配置方法

dubbo:
  registry:
    protocol: zookeeper
    address: 12.1.1.69:2181,12.1.1.85:2181,12.1.1.84:2181
    check: false
1.2：主从配置方法

dubbo:
  registry:
    address: zookeeper://127.0.0.1:2181?backup=127.0.0.1:2180,127.0.0.1:2182
　　 check: false

2、负载配置

  dubbo:
    reference:
      loadbalance: roundrobin

random

随机，按权重设置随机概率。
在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

roundRobin

轮询，按公约后的权重设置轮询比率。
存在慢的提供者类即请求问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

leastActive

最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

consistentHash

一致性Hash，相同参数的请求总是发到同一提供者。
当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其他提供者，不会引起剧烈变动。
缺省只对第一个参数Hash，如果要修改，请配置
缺省用160份虚拟节点，如果要修改，请配置