03-Java中操作redis实践

最后

小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

开源分享：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】

程序员代码面试指南 IT名企算法与数据结构题目最优解

这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点， 本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。 “刷”完本书后，你就是“题王”!

《TCP-IP协议组(第4版)》

本书是介绍TCP/IP协议族的经典图书的最新版本。本书自第1版出版以来，就广受读者欢迎。

本书最新版进行」护元，以体境计算机网络技不的最新发展，全书古有七大部分共30草和7个附录:第一部分介绍一些基本概念和基础底层技术:第二部分介绍网络层协议:第三部分介绍运输层协议;第四部分介绍应用层协议:第五部分介绍下一代协议，即IPv6协议:第六部分介绍网络安全问题:第七部分给出了7个附录。

Java开发手册（嵩山版）

这个不用多说了，阿里的开发手册，每次更新我都会看，这是8月初最新更新的**（嵩山版）**

MySQL 8从入门到精通

本书主要内容包括MySQL的安装与配置、数据库的创建、数据表的创建、数据类型和运算符、MySQL 函数、查询数据、数据表的操作(插入、更新与删除数据)、索引、存储过程和函数、视图、触发器、用户管理、数据备份与还原、MySQL 日志、性能优化、MySQL Repl ication、MySQL Workbench、 MySQL Utilities、 MySQL Proxy、PHP操作MySQL数据库和PDO数据库抽象类库等。最后通过3个综合案例的数据库设计，进步讲述 MySQL在实际工作中的应用。

Spring5高级编程（第5版）

本书涵盖Spring 5的所有内容，如果想要充分利用这一领先的企业级 Java应用程序开发框架的强大功能，本书是最全面的Spring参考和实用指南。

本书第5版涵盖核心的Spring及其与其他领先的Java技术(比如Hibemate JPA 2.Tls、Thymeleaf和WebSocket)的集成。本书的重点是介绍如何使用Java配置类、lambda 表达式、Spring Boot以及反应式编程。同时，将与企业级应用程序开发人员分享一些见解和实际经验，包括远程处理、事务、Web 和表示层，等等。

JAVA核心知识点+1000道 互联网Java工程师面试题

企业IT架构转型之道 阿里巴巴中台战略思想与架构实战

本书讲述了阿里巴巴的技术发展史，同时也是-部互联网技 术架构的实践与发展史。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

• Service逻辑对象设计及实现

• Controller逻辑对象设计及实现

• 总结（Summary）

Redis 客户端

===================================================================

概述

---

Redis 是一种C/S 架构的分布式缓存数据库，它有自带的命令行客户端，也有对应的Java或其它语言客户端，可以在这些客户端中通过一些API对redis进行读写操作。

准备工作

---

第一步：创建工程。

创建maven父工程，例如03-redis,并在此工程下创建两个子工程，一个为sca-jedis,一个为sca-tempate,例如：

第二步：添加父工程依赖

修改父工程pom.xml文件，添加编译配置

org.apache.maven.plugins

maven-compiler-plugin

3.8.1

8

8

Jedis的基本应用

====================================================================

简介

---

Jedis是Java中操作redis的一个客户端，类似通过jdbc访问mysql数据库。

准备工作

---

在sca-jedis 工程添加如下依赖

redis.clients

jedis

3.5.2

junit

junit

4.12

test

com.google.code.gson

gson

2.8.6

Jeids基本应用实践

---

在Jedis工程中的src/test/java目录创建单元测类,例如:

package com.jt;

import org.junit.Test;

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class JedisTests {

/**

• 测试是否可以连通redis。

*/

@Test

public void testGetConnection(){

Jedis jedis=new Jedis(“192.168.126.129”,6379);

String result = jedis.ping();

System.out.println(result);

}

/**

• 测试字符串操作

*/

@Test

public void testStringOper01(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.129”,6379);

//2.执行redis数据操作(增删改查)

//2.1新增数据

jedis.set(“id”, “100”);

jedis.set(“name”, “tony”);

//2.2修改数据

jedis.incr(“id”);

jedis.incrBy(“id”, 100);//201

jedis.set(“name”, “Mike”);//Mike

//2.3查询数据

String id = jedis.get(“id”);

String name = jedis.get(“name”);

System.out.println(“id=”+id+“;name=”+name);

//2.4删除数据

jedis.del(“name”);

//3.释放资源

jedis.close();

}

/**

• 测试字符串操作

*/

@Test

public void testStringOper02(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.129”,6379);

//2.数据操作(将一个map对象转换为json字符串，然后写入到redis)

//2.1构建map对象

Map<String,String> map=new HashMap<>();

map.put(“id”, “100”);

map.put(“name”, “Mike”);

//2.2将map转换为字符串

Gson gson=new Gson();

String jsonStr = gson.toJson(map);

//2.3将字符串写入到redis

String key= UUID.randomUUID().toString();

jedis.set(key, jsonStr);

//3.释放资源

jedis.close();

}

/**

• 课堂练习：

• 基于hash类型将testStringOper02中对象写入到redis，

• 并且尝试进行查询，修改，删除等操作。

*/

@Test

public void testHash01(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.129”,6379);

//2.执行hash数据操作

//2.1新增数据

String key= UUID.randomUUID().toString();

jedis.hset(key, “id”, “500”);

jedis.hset(key, “name”, “Jack”);

//2.2修改数据数据

jedis.hset(key, “name”, “Jim”);

//2.3查询数据

Map<String, String> map = jedis.hgetAll(key);

System.out.println(map);

//2.4删除数据

//jedis.del(key);

jedis.expire(key, 10);

//3.释放资源

jedis.close();

}

/**

• 测试:redis中list结构的应用

• 基于FIFO(First In First Out)算法,借助redis实现一个队列

*/

@Test

public void testListOper01(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.130”,6379);

//2.存储数据

jedis.lpush(“lst1”,“A”,“B”,“C”,“C”);

//3.更新数据

Long pos=jedis.lpos(“lst1”,“A”);//获取A元素的位置

jedis.lset(“lst1”,pos,“D”);//将A元素位置的内容修改为D

//4.获取数据

int len=jedis.llen(“lst1”).intValue();//获取lst1列表中元素个数

List rpop = jedis.rpop(“lst1”,len);//获取lst1列表中所有元素

System.out.println(rpop);

//5.释放资源

jedis.close();

}

//list类型练习：实现一个阻塞式队列

@Test

public void testListOper02(){

//1.连接redis

Jedis jedis=new Jedis(“192.168.126.128”,6379);

//2.向队列存数据

//jedis.lpush(“list1”,“A”,“B”,“C”);

//3.按先进先出的顺序从队列取数据

List list= jedis.brpop(40,“list1”);

System.out.println(list);

jedis.brpop(40,“list1”);

jedis.brpop(40,“list1”);

jedis.brpop(40,“list1”);

//4.释放资源

jedis.close();

}

//set类型练习

@Test

public void testSetOper01() {

//1.连接redis

Jedis jedis = new Jedis(“192.168.126.128”, 6379);

//2.朋友圈点赞

jedis.sadd(“count”, “1”, “1”, “2”);

//3.取出点赞数

Set set = jedis.smembers(“count”);

System.out.println(set);

//4.释放资源

jedis.close();

}

}

连接池JedisPool连接池应用

---

我们直接基于Jedis访问redis时，每次获取连接，释放连接会带来很大的性能开销，可以借助Jedis连接池，重用创建好的连接，来提高其性能，简易应用方式如下：

package com.jt;

import org.junit.Test;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolTests {

@Test

public void testJedisPool(){

//定义连接池的配置

JedisPoolConfig config=new JedisPoolConfig();

config.setMaxTotal(1000);//最大连接数

config.setMaxIdle(60);//最大空闲数

//创建连接池

JedisPool jedisPool=

new JedisPool(config,“192.168.126.130”,6379);

//从池中获取一个连接

Jedis resource = jedisPool.getResource();

resource.auth(“123456”);

//通过jedis连接存取数据

resource.set(“class”,“cgb2004”);

String clazz=resource.get(“class”);

System.out.println(clazz);

//将链接返回池中

resource.close();

//关闭连接池

jedisPool.close();

}

}

我们可以基于池对象，设计一个数据源，将来在业务中通过一个数据源对象，从池中获取连接，不用每次获取连接都要创建池对象，例如：

package com.jt.redis;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

public class JedisDataSource {

private static final String IP=“192.168.126.128”;

private static final int PORT=6379;//redis.conf 默认端口

/**

• volatile 关键通常用于修饰属性:

• 1)保证线程其可见性(一个线程改了,其它CPU线程立刻可见)

• 2)禁止指令重排序

• 3)不能保证其原子性(不保证线程安全)

*/

private static volatile JedisPool jedisPool;

//方案1:饿汉式池对象的创建

/*static{

JedisPoolConfig config=new JedisPoolConfig();

config.setMaxTotal(16);

config.setMaxIdle(8);

jedisPool=new JedisPool(config,IP,PORT);

}

public static Jedis getConnection(){

return jedisPool.getResource();

}*/

//方案2:懒汉式池对象的创建

public static Jedis getConnection(){

if(jedisPool==null) {

synchronized (JedisDataSource.class) {

if (jedisPool == null) {

JedisPoolConfig config = new JedisPoolConfig();

config.setMaxTotal(16);

config.setMaxIdle(8);

jedisPool = new JedisPool(config, IP, PORT);

//创建对象分析

//1.开辟内存空间

//2.执行属性的默认初始化

//3.执行构造方法

//4.将创建的对象的内存地址赋值给jedisPool变量

//假如使用了volatile修饰jedisPool变量,可以保证如上几个步骤是顺序执行的

}

}

}

return jedisPool.getResource();

}

public static void close(){

jedisPool.close();

}

}

RedisTemplate基本应用

===========================================================================

简介

---

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

准备工作

---

第一步：添加在sca-template工程添加依赖

org.springframework.boot

spring-boot-dependencies

2.3.2.RELEASE

import

pom

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-starter-data-redis

org.springframework.boot

spring-boot-starter-test

test

第二步：创建工程配置文件application.yml,其内容如下：

spring:

redis:

host: 192.168.126.129 #写自己的ip

port: 6379

第三步：创建工程启动类，例如：

package com.jt;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class RedisApplication {

public static void main(String[] args) {

SpringApplication.run(RedisApplication.class,args);

}

}

RedisTemplate对象应用实践

---

RedisTemplate是一个专门用于实现对远端redis数据进行操作的对象，默认会采用JDK序列化方式存取数据，应用案例如下：

package com.jt.redis;

@SpringBootTest

public class RedisTemplateTests {

/**

• 此对象为操作redis的一个模板对象,基于此对象进行数据存储时，

• 数据会进行序列化，序列化方式默认为JDK自带的序列化机制。

*/

@Autowired

private RedisTemplate redisTemplate;

/*测试是否能够连通redis/

@Test

void testGetConnection(){

RedisConnection connection =

redisTemplate.getConnectionFactory()

.getConnection();

String result = connection.ping();

System.out.println(result);

}

@Test

void testStringOper01(){

//1.获取字符串操作对象(ValueOperations)

ValueOperations vo = redisTemplate.opsForValue();

//2.操作redis数据

vo.set(“x”, 100);

Object x = vo.get(“x”);

System.out.println(x);

//vo.increment(“x”);//不可以

Long y = vo.increment(“y”);

y=vo.increment(“y”);

//Object y = vo.get(“y”);//不可以

System.out.println(y);

//存储key/value，设置key的有效期

vo.set(“z”, “100”, Duration.ofSeconds(10));

}

@Test

void testStringOper02(){

//1.获取字符串操作对象(ValueOperations)

ValueOperations vo = redisTemplate.opsForValue();

//2.按默认序列化方式存储数据

String token= UUID.randomUUID().toString();

vo.set(token,“admin”);

//3.指定序列方式进行数据存储

redisTemplate.setKeySerializer(RedisSerializer.string());

redisTemplate.setValueSerializer(RedisSerializer.string());

vo.set(token,“Mike”);

//4.更新数据(假如有对应的key则直接进行覆盖)

vo.set(token, “Jack”);

Object value = vo.get(token);

System.out.println(value);

//5.删除数据(存数据时给定有效期-生产环境必须设置)

vo.set(“permissions”, “sys:res:update”,Duration.ofSeconds(5));

}

@Test

void testHashOper01(){

//1.获取Hash操作对象(ValueOperations)

HashOperations ho = redisTemplate.opsForHash();

//2.以hash类型存储数据

ho.put(“blog”,“id”,100);

ho.put(“blog”, “title”, “redis…”);

//3.获取数据

Object id = ho.get(“blog”, “id”);

Object title = ho.get(“blog”, “title”);

System.out.println(“id=”+id+“;title=”+title);

Map blog = ho.entries(“blog”);//取key对应的所有值。

System.out.println(blog);

}

/**

• 设计一个Blog类，然后通过redisTemplate将此类的对象写入到redis数据库

• 两种方案：

• 1)方案1：基于ValueOperations对象实现数据存取

• 2)方案2：基于HashOperations对象实现数据存储

*/

@Test

void testHashOper02() throws JsonProcessingException {

//1.获取数据操作对象(ValueOperations,HashOperations)

ValueOperations vo = redisTemplate.opsForValue();

HashOperations ho = redisTemplate.opsForHash();

//2.基于ValueOperations存取Blog对象

Blog blog=new Blog();

blog.setId(100L);

blog.setTitle(“redis …”);

vo.set(“blog-jack”, blog);//序列化

Object o = vo.get(“blog-jack”);//反序列化

System.out.println(o);

//3.基于HashOperations存取Blog对象

ObjectMapper objectMapper=new ObjectMapper();//jackson

String jsonStr=objectMapper.writeValueAsString(blog);

Map map = objectMapper.readValue(jsonStr, Map.class);

ho.putAll(“blog-mike”, map);

ho.put(“blog-mike”,“id”,“200”);

map=ho.entries(“blog-mike”);

System.out.println(map);

}

@Test

void testListOper(){

//向list集合放数据

ListOperations listOperations = redisTemplate.opsForList();

listOperations.leftPush(“lstKey1”, “100”); //lpush

listOperations.leftPushAll(“lstKey1”, “200”,“300”);

listOperations.leftPush(“lstKey1”, “100”, “105”);

listOperations.rightPush(“lstKey1”, “700”);

Object value= listOperations.range(“lstKey1”, 0, -1);

System.out.println(value);

//从list集合取数据

Object v1=listOperations.leftPop(“lstKey1”);//lpop

System.out.println(“left.pop.0=”+v1);

value= listOperations.range(“lstKey1”, 0, -1);

System.out.println(value);

}

@Test

void testSetOper(){

SetOperations setOperations=redisTemplate.opsForSet();

setOperations.add(“setKey1”, “A”,“B”,“C”,“C”);

Object members=setOperations.members(“setKey1”);

System.out.println(“setKeys=”+members);

//…

}

@Test

void testFlushdb(){

redisTemplate.execute(new RedisCallback() {

@Override

public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {

//redisConnection.flushDb();

redisConnection.flushAll();

return “flush ok”;

}

});

}

@Test

void testGetConnection(){

RedisConnection connection =

stringRedisTemplate.getConnectionFactory()

.getConnection();

String ping = connection.ping();

System.out.println(ping);

}

}

创建Blog对象,然后基于RedisTemplate进行序列化实践,Blog代码如下

package com.jt.redis.pojo;

import java.io.Serializable;

public class Blog implements Serializable {//{“id”:10,“title”:“redis”}

private static final long serialVersionUID = -6721670401642138021L;

private Integer id;

private String title;

public Blog(){

System.out.println(“Blog()”);

}

public Blog(Integer id,String title){

this.id=id;

this.title=title;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

@Override

public String toString() {

return “Blog{” +

“id=” + id +

“, title='” + title + ‘’’ +

‘}’;

}

}

在RedisTemplateTests类中添加如下单元测试方法,进行测试,例如:

@Test

void testJsonOper() throws JsonProcessingException {

ValueOperations valueOperations = redisTemplate.opsForValue();

Blog blog=new Blog(10,“study redis”);

valueOperations.set(“blog”,blog);//序列化

blog=(Blog)valueOperations.get(“blog”);//反序列化

System.out.println(“blog=”+blog);

}

StringRedisTemplate 对象应用实践

---

StringRedisTemplate 是一个特殊的RedisTemplate对象，默认基于字符串序列化方式存取数据，其应用方式如下：

package com.jt.redis;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.core.HashOperations;

import org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.TimeUnit;

@SpringBootTest

public class StringRedisTemplateTests {

/**

• 此对象为操作redis的一个客户端对象,这个对象

• 对key/value采用了字符串的序列化(StringRedisSerializer)

• 方式进行,redis数据的读写操作.

*/

@Autowired

private StringRedisTemplate stringRedisTemplate;

@Test

void testHashOper01(){

//1.获取hash操作的对象

HashOperations<String, Object, Object> vo =stringRedisTemplate.opsForHash();

//2.读写redis数据

//2.1存储一个对象

vo.put(“user”, “id”, “100”);

vo.put(“user”, “username”, “tony”);

vo.put(“user”, “status”, “1”);

//2.2获取一个对象

//2.2.1获取对象某个属性值

Object status =vo.get(“user”,“status”);

System.out.println(status);

//2.2.2获取对象某个key对应的所有值

List user = vo.values(“user”);

System.out.println(user);

}

@Test

void testStringOper02() throws JsonProcessingException {

//1.获取字符串操作对象(ValueOperations)

ValueOperations<String, String> vo =

stringRedisTemplate.opsForValue();

//2.读写redis中的数据

Map<String,String> map=new HashMap<>();

map.put(“id”,“100”);

map.put(“title”,“StringRedisTemplate”);

//将map对象转换为json字符串写到redis数据库

String jsonStr=//jackson (spring-boot-starter-web依赖中自带)

new ObjectMapper().writeValueAsString(map);

vo.set(“blog”, jsonStr);

jsonStr=vo.get(“blog”);

System.out.println(jsonStr);

//将json字符串转换为map对象

map=

new ObjectMapper().readValue(jsonStr, Map.class);

System.out.println(map);

}

@Test

void testStringOper01(){

//1.获取字符串操作对象(ValueOperations)

ValueOperations<String, String> vo =

stringRedisTemplate.opsForValue();

//2.读写redis中的数据

vo.set(“x”, “100”);

vo.increment(“x”);

vo.set(“y”, “200”, 1, TimeUnit.SECONDS);

String x = vo.get(“x”);

String y = vo.get(“y”);

System.out.println(“x=”+x+“,y=”+y);

}

}

基于业务定制RedisTemplate对象(拓展)

---

我们知道系统中的RedisTemplate默认采用的是JDK的序列化机制，假如我们不希望使用默认的JDK方式序列化，可以对RedisTemplate对象进行定制，指定自己的序列化方式，例如：

package com.jt;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.JsonInclude;

import com.fasterxml.jackson.annotation.JsonTypeInfo;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializer;

import java.net.UnknownHostException;

@Configuration

public class RedisConfig {//RedisAutoConfiguration

//自定义json序列化

public RedisSerializer jsonSerializer(){

//1.定义Redis序列化,反序列化规范对象(此对象底层通过ObjectMapper完成对象序列化和反序列化)

Jackson2JsonRedisSerializer serializer=

new Jackson2JsonRedisSerializer(Object.class);

//2.创建ObjectMapper(有jackson api库提供)对象,基于此对象进行序列化和反序列化

//2.1创建ObjectMapper对象

ObjectMapper objectMapper=new ObjectMapper();

//2.2设置按哪些方法规则进行序列化

objectMapper.setVisibility(PropertyAccessor.GETTER,//get方法

JsonAutoDetect.Visibility.ANY);//Any 表示任意方法访问修饰符

//对象属性值为null时,不进行序列化存储

objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

//2.2激活序列化类型存储,对象序列化时还会将对象的类型存储到redis数据库

//假如没有这个配置,redis存储数据时不存储类型,反序列化时会默认将其数据存储到map

objectMapper.activateDefaultTyping(

objectMapper.getPolymorphicTypeValidator(),//多态校验分析

ObjectMapper.DefaultTyping.NON_FINAL,//激活序列化类型存储,类不能使用final修饰

JsonTypeInfo.As.PROPERTY);//PROPERTY 表示类型会以json对象属性形式存储

serializer.setObjectMapper(objectMapper);

return serializer;

}

//高级定制

@Bean

public RedisTemplate<Object, Object> redisTemplate(

RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {

RedisTemplate<Object, Object> template = new RedisTemplate();

template.setConnectionFactory(redisConnectionFactory);

//设置key的序列化方式

template.setKeySerializer(RedisSerializer.string());

template.setHashKeySerializer(RedisSerializer.string());

//设置值的序列化方式

template.setValueSerializer(jsonSerializer());

template.setHashValueSerializer(jsonSerializer());

//更新一下RedisTemplate对象的默认配置

template.afterPropertiesSet();

return template;

}

//简单定制

// @Bean

// public RedisTemplate<Object, Object> redisTemplate(

// RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {

// RedisTemplate<Object, Object> template = new RedisTemplate();

// template.setConnectionFactory(redisConnectionFactory);

// //设置key的序列化方式

// template.setKeySerializer(RedisSerializer.string());

// template.setHashKeySerializer(RedisSerializer.string());

// //设置值的序列化方式

// template.setValueSerializer(RedisSerializer.json());

// template.setHashValueSerializer(RedisSerializer.json());

// return template;

// }

}

基于Redis的项目业务分析及实践

===========================================================================

分布式id

---

业务描述

在分布式系统中，数据量将越来越大时，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做 分布式ID，这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习.

关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

/**

• 需求:生成一个分布递增的id

• 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库

• 表中自带的自增策略-auto_increment)

*/

public class IdGeneratorDemo01 {

public static Long getId(){

Jedis jedis=new Jedis(“192.168.126.130”,6379);

//jedis.auth(“123456”);//假如redis设置了密码,连接redis时需要指定密码

Long id = jedis.incr(“id”);

jedis.close();

return id;

}

//自己创建线程执行任务

static void execute01(){

for(int i=0;i<10;i++) {

new Thread(){

@Override

public void run() {

String tName=Thread.currentThread().getName();

System.out.println(tName+“->”+

IdGeneratorDemo01.getId());

}

}.start();

}

}

//基于线程池执行任务

static void execute02(){

//构建一个最多只有3个线程的线程池

ExecutorService es=

Executors.newFixedThreadPool(3);

for(int i=1;i<=10;i++){

//从池中取线程执行任务

es.execute(new Runnable() {//这个任务会存储到阻塞式任务队列中

@Override

public void run() {

System.out.println(Thread.currentThread().getName()

+“->”+getId());

}

});

}

}

public static void main(String[] args) {

//execute01();

execute02();

}

}

单点登陆(SSO)

---

业务描述

在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息,例如:

关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.UUID;

/**

• 基于redis的单点登录设计及实现

• 1)用户登录成功以后将登录状态等信息存储到redis

• 2)用户携带token去访问资源,资源服务器要基于token从redis查询用户信息

*/

public class SSODemo01 {

/**

• 执行登录认证,将来这样的业务要写到认证服务器

• @param username

• @param password

*/

static String doLogin(String username,String password){

//1.检验数据的合法性(判定用户名,密码是否为空,密码的长度,是否有数字字母特殊符号构成)

if(username==null||“”.equals(username))

throw new IllegalArgumentException(“用户不能为空”);

//2.基于用户名查询用户信息,并判定密码是否正确

if(!“jack”.equals(username))

throw new RuntimeException(“此用户不存在”);

if(!“123456”.equals(password))

throw new RuntimeException(“密码不正确”);

//3.用户存在且密码正确,将用户信息写入到redis

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

String token= UUID.randomUUID().toString();

jedis.hset(token, “username”, username);

jedis.hset(token, “permission”, “sys:resource:create”);

jedis.expire(token, 10);//设置key的有效时间

jedis.close();

//4.将token返回给客户端(将来使用response对象响应到客户端).

return token;

}

static String token;

/**

• 演示资源访问过程

• 1)允许匿名访问(无需登录)

• 2)登录后访问(认证通过了)

• 3)登录后必须有权限才可以访问

*/

static Object doGetResource(String token){

//1.校验token是否为空

if(token==null)

throw new IllegalArgumentException(“请先登录”);

//2.基于token查询redis数据,假如有对应数据说明用户登录了

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

String username=jedis.hget(token, “username”);

if(username==null)

throw new RuntimeException(“登录超时,请重新登录”);

String permission=jedis.hget(token, “permission”);

jedis.close();

//3.检查用户是否有访问资源的权限,假如有则允许访问

if(!“sys:resource:create”.equals(permission))

throw new RuntimeException(“你没有权限访问这个资源”);

//4.返回要访问的资源.

return “your resource”;

}

public static void main(String[] args) {

//1.登录操作(用户身份认证)

token=doLogin(“jack”, “123456”);

System.out.println(token);

//2.携带token访问资源服务器

Object result=doGetResource(token);

System.out.println(result);

}

}

简易秒杀队列

---

业务描述

在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:

关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

//秒杀队列演示

//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),

//因为写redis内存数据库要比写你的mysql数据库快很多倍

//算法:先进先出(FIFO)-体现公平性

public class SecondKillDemo01 {

//商品抢购首先是入队

static void enque(String msg){//入队

Jedis jedis=new Jedis(“192.168.126.130”,6379);

jedis.auth(“123456”);//没有认证不需要写这个语句

jedis.lpush(“queue”,msg);

jedis.close();

}

//底层异步出队(基于这个消息,生成订单,扣减库存,…)

static String deque(){//出队

Jedis jedis=new Jedis(“192.168.126.130”,6379);

jedis.auth(“123456”);//没有认证不需要写这个语句

String result=jedis.rpop(“queue”);

jedis.close();

return result;

}

public static void main(String[] args){

//1.多次抢购(模拟在界面上多次点击操作)

new Thread(){

@Override

public void run() {

for(int i=1;i<=10;i++){//模拟页面上按钮点击

enque(String.valueOf(i));

try{Thread.sleep(100);}catch(Exception e){}

}

}

}.start();

//2.从队列取内容(模拟后台从队列取数据)

new Thread(){

@Override

public void run() {

for(;😉{

String msg=deque();

if(msg==null)continue;

System.out.print(msg);

}

}

}.start();

}

}

简易投票系统

---

业务描述

在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,例如:

关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.Set;

/**

• 基于某个活动的简易投票系统设计

• 1)投票数据存储到redis (key为活动id,多个用户id的集合)

• 2)同一个用户不能执行多次投票

• 3)具体业务操作(投票,获取总票数,获取哪些人参与了投票)

*/

public class VoteDemo01 {

/**

• 获取哪些人执行了这个活动的投票

• @param activityId

• @return

*/

static Set doGetMembers(String activityId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.获取当前活动的总票数

Set smembers = jedis.smembers(activityId);

//3.释放资源

jedis.close();

return smembers;

}

/**

• 获取指定活动的投票总数

• @param activityId

• @return

*/

static Long doCount(String activityId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.获取当前活动的总票数

Long count=jedis.scard(activityId);

//3.释放资源

jedis.close();

return count;

}

/**

• 执行投票操作

• @param activityId

• @param userId

*/

static void doVote(String activityId,String userId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.执行投票

//2.1检查是否投过票

Boolean flag = jedis.sismember(activityId, userId);

//2.2执行投票或取消投票

if(flag){

//假如已经投过票,再投票就取消投票

jedis.srem(activityId, userId);

}else{

//没有投过票则执行投票

jedis.sadd(activityId, userId);

}

//3.释放资源

jedis.close();

}

public static void main(String[] args) {

String activityId=“101”;

String userId1=“1”;

String userId2=“2”;

String userId3=“3”;

//执行投票动作

doVote(activityId, userId1);

doVote(activityId, userId2);

doVote(activityId, userId3);

//获取投票的总票数

Long aLong = doCount(activityId);

System.out.println(aLong);

//获取参与投票的成员

Set members= doGetMembers(activityId);

System.out.println(members);

}

}

简易购物车系统

---

业务描述

简易购物车业务设计如图所示:

基础指令操作,例如:

1)向购物车添加商品

hset cart:101 2001 1

hset cart:101 2002 1

hset cart:101 2003 2

2)查看购物车商品

hgetall cart:101

3)删除购物车商品

hdel cart:101 2003

最后

笔者已经把面试题和答案整理成了面试专题文档

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

tatic Set doGetMembers(String activityId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.获取当前活动的总票数

Set smembers = jedis.smembers(activityId);

//3.释放资源

jedis.close();

return smembers;

}

/**

• 获取指定活动的投票总数

• @param activityId

• @return

*/

static Long doCount(String activityId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.获取当前活动的总票数

Long count=jedis.scard(activityId);

//3.释放资源

jedis.close();

return count;

}

/**

• 执行投票操作

• @param activityId

• @param userId

*/

static void doVote(String activityId,String userId){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”, 6379);

//2.执行投票

//2.1检查是否投过票

Boolean flag = jedis.sismember(activityId, userId);

//2.2执行投票或取消投票

if(flag){

//假如已经投过票,再投票就取消投票

jedis.srem(activityId, userId);

}else{

//没有投过票则执行投票

jedis.sadd(activityId, userId);

}

//3.释放资源

jedis.close();

}

public static void main(String[] args) {

String activityId=“101”;

String userId1=“1”;

String userId2=“2”;

String userId3=“3”;

//执行投票动作

doVote(activityId, userId1);

doVote(activityId, userId2);

doVote(activityId, userId3);

//获取投票的总票数

Long aLong = doCount(activityId);

System.out.println(aLong);

//获取参与投票的成员

Set members= doGetMembers(activityId);

System.out.println(members);

}

}

简易购物车系统

---

业务描述

简易购物车业务设计如图所示:

基础指令操作,例如:

1)向购物车添加商品

hset cart:101 2001 1

hset cart:101 2002 1

hset cart:101 2003 2

2)查看购物车商品

hgetall cart:101

3)删除购物车商品

hdel cart:101 2003

最后

笔者已经把面试题和答案整理成了面试专题文档

[外链图片转存中…(img-RjQ3o1vV-1715758486185)]

[外链图片转存中…(img-F9n6lf7u-1715758486186)]

[外链图片转存中…(img-y2xuV6ct-1715758486186)]

[外链图片转存中…(img-PWoxjoZy-1715758486186)]

[外链图片转存中…(img-y4eV9AJ9-1715758486187)]

[外链图片转存中…(img-I4VpS1pp-1715758486187)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取