Spring Boot入门66-91 Springboot集成dubbo和Redis

最新推荐文章于 2022-10-18 14:33:19 发布

高开低走。

最新推荐文章于 2022-10-18 14:33:19 发布

阅读量436

点赞数 1

分类专栏：锦到说Springboot 文章标签： java

本文链接：https://blog.csdn.net/qq_43568982/article/details/124225492

版权

锦到说Springboot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

开始时间：2022-04-17
课程链接：动力节点springboot

Redis回顾

NoSQL-> Not Only SQL

Redis ：一个NoSQL数据库，常用作缓存使用（cache）
Redis的数据类型： string , hash ,set ,zset , list
Redis是一个中间件：是一个独立的服务器。
Java中著名的客户端： Jedis ， lettuce ， Redisson
Spring,SpringBoot中有一个RedisTemplate（StringRedisTemplate），处理和redis交互

Windows上装一下redis
先打开服务端，挂着不要关，再打开客户端
在这里插入图片描述
Redis集成到springboot中，要添加起步依赖

<!--redis起步依赖： 直接在项目中使用RedisTemplate(StringRedisTemplate)-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

data-redis使用的 lettuce 客户端库

在程序中使用RedisTemplate类的方法操作redis数据，实际就是调用的lettuce 客户端的中的方法

通过Springboot连接Redis

package com.bjpowernode.controller;

import ...;

import javax.annotation.Resource;

@RestController
public class RedisController {

    /**
     * 注入RedisTemplate
     * <p>
     * RedisTemplate 泛型
     * RedisTemplate<String,String>
     * RedisTemplate<Object,Object>
     * RedisTemplate
     * <p>
     * 注意： RedisTemplate对象的名称 redisTemplate
     */
    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 添加数据到redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name, String value) {

        // 操作Redis中string类型的数据， 先获取ValueOperations对象
        ValueOperations valueOperations = redisTemplate.opsForValue();

        //添加数据到redis
        valueOperations.set("myname", "JDH");
        return "向redis添加string类型的数据";
    }

    // 从redis获取数据
    @GetMapping("/redis/getk")
    public String getData(String k) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是" + k + ",他的值是：" + v;
    }

在这里插入图片描述

可以看到redis 里面

这里有\xac，是因为序列化的缘故
RESTFul风格

    @PostMapping("/redis/{k}/{v}")
    public String addStringKV(@PathVariable String k,
                              @PathVariable String v) {

        // 使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k, v);
        return "使用StringRedisTemplate对象";
    }

    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable String k) {
        String v = stringRedisTemplate.opsForValue().get(k);
        return "k的value:" + v;
    }
}

也可以正确获得
在这里插入图片描述

6.2 对比 StringRedisTemplate 和 RedisTemplate

StringRedisTemplate ：把k，v 都是作为String处理，使用的是String的序列化，可读性好
RedisTemplate ：把k，v 经过了序列化存到redis。 k，v 是序列化的内容，不能直接识别.
默认使用的jdk序列化，可以修改为其他的序列化
序列化：把对象转化为可传输的字节序列过程称为序列化。
反序列化：把字节序列还原为对象的过程称为反序列化。

为什么需要序列化

序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）。

什么情况下需要序列化

通过上面我想你已经知道了凡是需要进行“跨平台存储”和”网络传输”的数据，都需要进行序列化。

本质上存储和网络传输都需要经过把一个对象状态保存成一种跨平台识别的字节格式，然后其他的平台才可以通过字节信息解析还原对象信息。

序列化的方式

序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：JDK（不支持跨语言、性能差）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protofbuff、
Student( name=zs, age=20) ---- { “name”:“zs”, “age”:20 }
从左到右 Java对象序列化为JSON
从右到做 JSON反序列化为Java对象

自己设置RedisTemplate的序列化机制

    /**
     * 设置 RedisTemplate 序列化
     * 可以设置 key 的序列化， 可以设置value的序列化
     * 可以同时设置 key 和 value的序列化
     */
    @PostMapping("/redis/addstr")
    public String addString(String k, String v) {
        // 使用RedisTemplate
        // 设置 key 使用String的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        // 设置 value 的序列化
        redisTemplate.setValueSerializer(new StringRedisSerializer());

        redisTemplate.opsForValue().set(k, v);
        return "定义RedisTemplate对象的key，value的序列化";
    }

设置以后就ok了
使用JSON的序列化，注意，这里的实体类Student，要实现序列化接口才行
并且，需要在setting
找到下面的，勾选上
在这里插入图片描述
然后光标放Student上面就可以加一个版本号了

public class Student implements Serializable {

    /**
     * 使用json 序列化， 把java对象转为json存储
     */

    @PostMapping("/redis/addjson")
    public String addJson() {
        Student student = new Student();
        student.setId(1001);
        student.setName("zhangsan");
        student.setAge(20);

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));

        redisTemplate.opsForValue().set("mystudent", student);

        return "json序列化";
    }

在这里插入图片描述

    @PostMapping("/redis/getjson")
    public String getJson() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));

        Object obj = redisTemplate.opsForValue().get("mystudent");

        return "json反序列化=" + obj;
    }

反序列化
在这里插入图片描述

Springboot集成Dubbo

提供者

<dependencies>

   <!--加入公共项目的gav-->
   <dependency>
      <groupId>com.bjpowernode</groupId>
      <artifactId>022-interface-api</artifactId>
      <version>1.0.0</version>
   </dependency>

   <!--dubbo依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
      <version>2.7.8</version>
   </dependency>


   <!--zookeeper依赖-->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>2.7.8</version>
      <type>pom</type>
      <exclusions>
         <!-- 排除log4j依赖 -->
         <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
         </exclusion>
      </exclusions>
   </dependency>
</dependencies>

实现接口

@DubboService(interfaceClass = StudentService.class,version = "1.0",timeout = 5000)
public class StudentServiceImpl implements StudentService {
    @Override
    public Student queryStudent(Integer id) {
        Student student  = new Student();
        if( 1001 == id){
            student.setId(1001);
            student.setName("------1001-张三");
            student.setAge(20);
        } else if(1002  == id){
            student.setId(1002);
            student.setName("#######1002-李四");
            student.setAge(22);
        }

        return student;
    }

配置dubbo信息

spring.application.name=studentservice-provider

#@DubboService
dubbo.scan.base-packages=com.bjpowernode.service

#\u914D\u7F6Edubbo\u534F\u8BAE
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881


dubbo.registry.address=zookeeper://localhost:2181

主应用

/**
 * @EnableDubbo 启用Dubbo
 * 这是个复合注解，包含下面俩注解
 * @EnableDubboConfig
 * @DubboComponentScan
 */
@SpringBootApplication
@EnableDubbo
public class ProviderApplication {

	public static void main(String[] args) {
		SpringApplication.run(ProviderApplication.class, args);
	}
}

consumer

依赖是一样的
写一个controller

package com.bjpowernode.controller;

import com.bjpowernode.model.Student;
import com.bjpowernode.service.StudentService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DubboController {

    /**
     * 引用远程服务， 把创建好的代理对象，注入给studentService
     */
    //@DubboReference(interfaceClass = StudentService.class,version = "1.0")

    /**
     * 没有使用interfaceClass，默认的就是 引用类型的 数据类型
      */
    @DubboReference(version = "1.0")
    private StudentService studentService;

    @GetMapping("/query")
    public String queryStudent(Integer id){
        Student student   = studentService.queryStudent(id);
        return "调用远程接口，获取对象："+student;
    }
}

Consumer的应用类

@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {

	public static void main(String[] args) {
		SpringApplication.run(ConsumerApplication.class, args);
	}
}

application.properties

spring.application.name=consumer-application
dubbo.registry.address=zookeeper://localhost:2181
dubbo.scan.base-packages=com.bjpowernode.controller
server.port=8081