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);
}
}
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
我的面试宝典：一线互联网大厂Java核心面试题库
以下是我个人的一些做法，希望可以给各位提供一些帮助：
整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！
283页的Java进阶核心pdf文档
Java部分：Java基础，集合，并发，多线程，JVM，设计模式
数据结构算法：Java算法，数据结构
开源框架部分：Spring，MyBatis，MVC，netty，tomcat
分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等
微服务部分：SpringBoot，SpringCloud，Dubbo，Docker
还有源码相关的阅读学习
//没有投过票则执行投票
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);
}
}
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-9CvRivX0-1711039418255)]
[外链图片转存中…(img-fy8P8YGk-1711039418255)]
[外链图片转存中…(img-ijEw2rdC-1711039418256)]
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-LJm0UALr-1711039418256)]
我的面试宝典：一线互联网大厂Java核心面试题库
以下是我个人的一些做法，希望可以给各位提供一些帮助：
整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！
[外链图片转存中…(img-1pJCLOoz-1711039418257)]
283页的Java进阶核心pdf文档
Java部分：Java基础，集合，并发，多线程，JVM，设计模式
数据结构算法：Java算法，数据结构
开源框架部分：Spring，MyBatis，MVC，netty，tomcat
分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等
微服务部分：SpringBoot，SpringCloud，Dubbo，Docker
[外链图片转存中…(img-aN9E2iXH-1711039418257)]
还有源码相关的阅读学习
[外链图片转存中…(img-nzxIgc3g-1711039418258)]
扫一扫
529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
