先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
@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();
}
}
我们直接基于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为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是一个专门用于实现对远端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 是一个特殊的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默认采用的是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;
// }
}
===========================================================================
业务描述
在分布式系统中，数据量将越来越大时，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现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();
}
}
业务描述
在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助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
4)改变购物车某个商品的购买数量
hincrby cart:101 2002 2
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Map;
/**
- 作业:基于redis存储商品购物车信息
*/
public class CartDemo01 {
public static void addCart(Long userId,Long productId,int num){
//1.建立redis链接
Jedis jedis=new Jedis(“192.168.126.130”,6379);
jedis.auth(“123456”);
//2.向购物车添加商品
//hincrBy这个函数在key不存在时会自动创建key
jedis.hincrBy(“cart:” + userId, String.valueOf(productId),num);
//3.释放redis链接
jedis.close();
}
//查看我的购物车
public static Map<String, String> listCart(Long userId){
//1.建立redis链接
Jedis jedis=new Jedis(“192.168.126.130”,6379);
jedis.auth(“123456”);
//2.查看购物车商品
Map<String, String> map = jedis.hgetAll(“cart:” + userId);
//3.释放redis链接
jedis.close();
return map;
}
public static void main(String[] args) {
//1.向购物车添加商品
addCart(101L,201L,1);
addCart(101L,202L,1);
addCart(101L,203L,2);
//2.查看购物车商品
Map<String, String> map = listCart(101L);
System.out.println(map);
}
}
总结
总的来说，面试是有套路的，一面基础，二面架构，三面个人。
最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
业务描述
简易购物车业务设计如图所示:
基础指令操作,例如:
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
4)改变购物车某个商品的购买数量
hincrby cart:101 2002 2
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Map;
/**
- 作业:基于redis存储商品购物车信息
*/
public class CartDemo01 {
public static void addCart(Long userId,Long productId,int num){
//1.建立redis链接
Jedis jedis=new Jedis(“192.168.126.130”,6379);
jedis.auth(“123456”);
//2.向购物车添加商品
//hincrBy这个函数在key不存在时会自动创建key
jedis.hincrBy(“cart:” + userId, String.valueOf(productId),num);
//3.释放redis链接
jedis.close();
}
//查看我的购物车
public static Map<String, String> listCart(Long userId){
//1.建立redis链接
Jedis jedis=new Jedis(“192.168.126.130”,6379);
jedis.auth(“123456”);
//2.查看购物车商品
Map<String, String> map = jedis.hgetAll(“cart:” + userId);
//3.释放redis链接
jedis.close();
return map;
}
public static void main(String[] args) {
//1.向购物车添加商品
addCart(101L,201L,1);
addCart(101L,202L,1);
addCart(101L,203L,2);
//2.查看购物车商品
Map<String, String> map = listCart(101L);
System.out.println(map);
}
}
总结
总的来说，面试是有套路的，一面基础，二面架构，三面个人。
最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友
[外链图片转存中…(img-1Pzpc3AZ-1713588024206)]
[外链图片转存中…(img-xI21VBIr-1713588024207)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-HEZ1lreK-1713588024207)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
1030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
