Spring系列第39篇：强大的Spel表达式(1)

JAVA无声

于 2024-03-31 12:44:11 发布

阅读量747

点赞数 28

分类专栏：程序员文章标签： spring java 算法

本文链接：https://blog.csdn.net/a369966697/article/details/137197223

版权

程序员专栏收录该内容

781 篇文章 0 订阅

订阅专栏

1）创建解析器：SpEL使用ExpressionParser接口表示解析器，提供SpelExpressionParser默认实现；

2）解析表达式：使用ExpressionParser的parseExpression来解析相应的表达式为Expression对象。

3）构造上下文：准备比如变量定义等等表达式需要的上下文数据。

4）求值：通过Expression接口的getValue方法根据上下文获得表达式值。

是不是很简单，接下来让我们看下其具体实现及原理吧。

SpEL原理及接口

SpEL提供简单的接口从而简化用户使用，在介绍原理前让我们学习下几个概念：

一、表达式： 表达式是表达式语言的核心，所以表达式语言都是围绕表达式进行的，从我们角度来看是“干什么”；

二、解析器： 用于将字符串表达式解析为表达式对象，从我们角度来看是“谁来干”；

三、上下文： 表达式对象执行的环境，该环境可能定义变量、定义自定义函数、提供类型转换等等，从我们角度看是“在哪干”；

四、根对象及活动上下文对象： 根对象是默认的活动上下文对象，活动上下文对象表示了当前表达式操作的对象，从我们角度看是“对谁干”。

理解了这些概念后，让我们看下SpEL如何工作的呢，如图所示：

工作原理

1.首先定义表达式：“1+2”；

2.定义解析器ExpressionParser实现，SpEL提供默认实现SpelExpressionParser；

2.1.SpelExpressionParser解析器内部使用Tokenizer类进行词法分析，即把字符串流分析为记号流，记号在SpEL使用Token类来表示；

2.2.有了记号流后，解析器便可根据记号流生成内部抽象语法树；在SpEL中语法树节点由SpelNode接口实现代表：如OpPlus表示加操作节点、IntLiteral表示int型字面量节点；使用SpelNodel实现组成了抽象语法树；

2.3.对外提供Expression接口来简化表示抽象语法树，从而隐藏内部实现细节，并提供getValue简单方法用于获取表达式值；SpEL提供默认实现为SpelExpression；

3.定义表达式上下文对象（可选），SpEL使用EvaluationContext接口表示上下文对象，用于设置根对象、自定义变量、自定义函数、类型转换器等，SpEL提供默认实现StandardEvaluationContext；

4.使用表达式对象根据上下文对象（可选）求值（调用表达式对象的getValue方法）获得结果。

接下来让我们看下SpEL的主要接口吧：

ExpressionParser接口

表示解析器，默认实现是org.springframework.expression.spel.standard包中的SpelExpressionParser类，使用parseExpression方法将字符串表达式转换为Expression对象，对于ParserContext接口用于定义字符串表达式是不是模板，及模板开始与结束字符：

public interface ExpressionParser {

Expression parseExpression(String expressionString) throws ParseException;

Expression parseExpression(String expressionString, ParserContext context) throws ParseException;

}

来看下示例：

@Test

public void testParserContext() {

ExpressionParser parser = new SpelExpressionParser();

ParserContext parserContext = new ParserContext() {

@Override

public boolean isTemplate() {

return true;

}

@Override

public String getExpressionPrefix() {

return “#{”;

}

@Override

public String getExpressionSuffix() {

return “}”;

}

};

String template = “#{'Hello '}#{‘World!’}”;

Expression expression = parser.parseExpression(template, parserContext);

System.out.println(expression.getValue());

}

在此我们演示的是使用ParserContext的情况，此处定义了ParserContext实现：定义表达式是模块，表达式前缀为“#{”，后缀为“}”；使用parseExpression解析时传入的模板必须以“#{”开头，以“}”结尾，如"#{'Hello '}#{‘World!’}"。

默认传入的字符串表达式不是模板形式，如之前演示的Hello World。

EvaluationContext接口

表示上下文环境，默认实现是org.springframework.expression.spel.support包中的StandardEvaluationContext类，使用setRootObject方法来设置根对象，使用setVariable方法来注册自定义变量，使用registerFunction来注册自定义函数等等。

Expression接口

表示表达式对象，默认实现是org.springframework.expression.spel.standard包中的SpelExpression，提供getValue方法用于获取表达式值，提供setValue方法用于设置对象值。

了解了SpEL原理及接口，接下来的事情就是SpEL语法了。

SpEL语法

基本表达式

字面量表达式

SpEL支持的字面量包括：字符串、数字类型（int、long、float、double）、布尔类型、null类型。

| 类型 | 示例 |

| — | — |

| 字符串 | String str1 = parser.parseExpression(“‘Hello World!’”).getValue(String.class); |

| 数字类型 | int int1 = parser.parseExpression(“1”).getValue(Integer.class);

long long1 = parser.parseExpression(“-1L”).getValue(long.class);

float float1 = parser.parseExpression(“1.1”).getValue(Float.class);

double double1 = parser.parseExpression(“1.1E+2”).getValue(double.class);

int hex1 = parser.parseExpression(“0xa”).getValue(Integer.class);

long hex2 = parser.parseExpression(“0xaL”).getValue(long.class); |

| 布尔类型 | boolean true1 = parser.parseExpression(“true”).getValue(boolean.class);

boolean false1 = parser.parseExpression(“false”).getValue(boolean.class); |

| null类型 | Object null1 = parser.parseExpression(“null”).getValue(Object.class); |

@Test

public void test2() {

ExpressionParser parser = new SpelExpressionParser();

String str1 = parser.parseExpression(“‘Hello World!’”).getValue(String.class);

int int1 = parser.parseExpression(“1”).getValue(Integer.class);

long long1 = parser.parseExpression(“-1L”).getValue(long.class);

float float1 = parser.parseExpression(“1.1”).getValue(Float.class);

double double1 = parser.parseExpression(“1.1E+2”).getValue(double.class);

int hex1 = parser.parseExpression(“0xa”).getValue(Integer.class);

long hex2 = parser.parseExpression(“0xaL”).getValue(long.class);

boolean true1 = parser.parseExpression(“true”).getValue(boolean.class);

boolean false1 = parser.parseExpression(“false”).getValue(boolean.class);

Object null1 = parser.parseExpression(“null”).getValue(Object.class);

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

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

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

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

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

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

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

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

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

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

}

输出

str1=Hello World!

int1=1

long1=-1

float1=1.1

double1=110.0

hex1=10

hex2=10

true1=true

false1=false

null1=null

算数运算表达式

SpEL支持加(+)、减(-)、乘(*)、除(/)、求余（%）、幂（^）运算。

| 类型 | 示例 |

| — | — |

| 加减乘除 | int result1 = parser.parseExpression(“1+2-3*4/2”).getValue(Integer.class);//-3 |

| 求余 | int result2 = parser.parseExpression(“4%3”).getValue(Integer.class);//1 |

| 幂运算 | int result3 = parser.parseExpression(“2^3”).getValue(Integer.class);//8 |

SpEL还提供求余（MOD）和除（DIV）而外两个运算符，与“%”和“/”等价，不区分大小写。

关系表达式

等于（==）、不等于(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)，区间（between）运算。

如parser.parseExpression("1>2").getValue(boolean.class);将返回false；

而parser.parseExpression("1 between {1, 2}").getValue(boolean.class);将返回true。

between运算符右边操作数必须是列表类型，且只能包含2个元素。第一个元素为开始，第二个元素为结束，区间运算是包含边界值的，即 xxx>=list.get(0) && xxx<=list.get(1)。

SpEL同样提供了等价的“EQ” 、“NE”、 “GT”、“GE”、 “LT” 、“LE”来表示等于、不等于、大于、大于等于、小于、小于等于，不区分大小写。

@Test

public void test3() {

ExpressionParser parser = new SpelExpressionParser();

boolean v1 = parser.parseExpression(“1>2”).getValue(boolean.class);

boolean between1 = parser.parseExpression(“1 between {1,2}”).getValue(boolean.class);

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

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

}

输出

v1=false

between1=true

逻辑表达式

且（and或者&&）、或(or或者||)、非(!或NOT)。

@Test

public void test4() {

ExpressionParser parser = new SpelExpressionParser();

boolean result1 = parser.parseExpression(“2>1 and (!true or !false)”).getValue(boolean.class);

boolean result2 = parser.parseExpression(“2>1 && (!true || !false)”).getValue(boolean.class);

boolean result3 = parser.parseExpression(“2>1 and (NOT true or NOT false)”).getValue(boolean.class);

boolean result4 = parser.parseExpression(“2>1 && (NOT true || NOT false)”).getValue(boolean.class);

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

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

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

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

}

输出

result1=true

result2=true

result3=true

result4=false

字符串连接及截取表达式

使用“+”进行字符串连接，使用“‘String’[0] [index]”来截取一个字符，目前只支持截取一个，如“'Hello ’ + ‘World!’”得到“Hello World!”；而“‘Hello World!’[0]”将返回“H”。

三目运算

三目运算符 **“表达式1?表达式2:表达式3”**用于构造三目运算表达式，如“2>1?true:false”将返回true；

Elivis运算符

Elivis运算符**“表达式1?:表达式2”**从Groovy语言引入用于简化三目运算符的，当表达式1为非null时则返回表达式1，当表达式1为null时则返回表达式2，简化了三目运算符方式“表达式1? 表达式1:表达式2”，如“null?:false”将返回false，而“true?:false”将返回true；

正则表达式

使用“str matches regex，如“‘123’ matches ‘\d{3}’”将返回true；

括号优先级表达式

使用“(表达式)”构造，括号里的具有高优先级。

类相关表达式

类类型表达式

使用“T(Type)”来表示java.lang.Class实例，“Type”必须是类全限定名，“java.lang”包除外，即该包下的类可以不指定包名；使用类类型表达式还可以进行访问类静态方法及类静态字段。

具体使用方法如下：

@Test

public void testClassTypeExpression() {

ExpressionParser parser = new SpelExpressionParser();

//java.lang包类访问

Class result1 = parser.parseExpression(“T(String)”).getValue(Class.class);

System.out.println(result1);

//其他包类访问

String expression2 = “T(com.javacode2018.spel.SpelTest)”;

Class value = parser.parseExpression(expression2).getValue(Class.class);

System.out.println(value == SpelTest.class);

//类静态字段访问

int result3 = parser.parseExpression(“T(Integer).MAX_VALUE”).getValue(int.class);

System.out.println(result3 == Integer.MAX_VALUE);

//类静态方法调用

int result4 = parser.parseExpression(“T(Integer).parseInt(‘1’)”).getValue(int.class);

System.out.println(result4);

}

输出

class java.lang.String

true

对于java.lang包里的可以直接使用“T(String)”访问；其他包必须是类全限定名；可以进行静态字段访问如“T(Integer).MAX_VALUE”；也可以进行静态方法访问如“T(Integer).parseInt(‘1’)”。

类实例化

类实例化同样使用java关键字“new”，类名必须是全限定名，但java.lang包内的类型除外，如String、Integer。

@Test

public void testConstructorExpression() {

ExpressionParser parser = new SpelExpressionParser();

String result1 = parser.parseExpression(“new String(‘路人甲java’)”).getValue(String.class);

System.out.println(result1);

Date result2 = parser.parseExpression(“new java.util.Date()”).getValue(Date.class);

System.out.println(result2);

}

实例化完全跟Java内方式一样，运行输出

路人甲java

Tue Aug 03 20:22:43 CST 2020

instanceof表达式

SpEL支持instanceof运算符，跟Java内使用同义；如“‘haha’ instanceof T(String)”将返回true。

@Test

public void testInstanceOfExpression() {

ExpressionParser parser = new SpelExpressionParser();

Boolean value = parser.parseExpression(“‘路人甲’ instanceof T(String)”).getValue(Boolean.class);

System.out.println(value);

}

输出

true

变量定义及引用

变量定义通过EvaluationContext接口的setVariable(variableName, value)方法定义；在表达式中使用"#variableName"引用；除了引用自定义变量，SpE还允许引用根对象及当前上下文对象，使用"#root"引用根对象，使用"#this"引用当前上下文对象；

@Test

public void testVariableExpression() {

ExpressionParser parser = new SpelExpressionParser();

EvaluationContext context = new StandardEvaluationContext();

context.setVariable(“name”, “路人甲java”);

context.setVariable(“lesson”, “Spring系列”);

//获取name变量，lesson变量

String name = parser.parseExpression(“#name”).getValue(context, String.class);

System.out.println(name);

String lesson = parser.parseExpression(“#lesson”).getValue(context, String.class);

System.out.println(lesson);

//StandardEvaluationContext构造器传入root对象，可以通过#root来访问root对象

context = new StandardEvaluationContext(“我是root对象”);

String rootObj = parser.parseExpression(“#root”).getValue(context, String.class);

System.out.println(rootObj);

//#this用来访问当前上线文中的对象

String thisObj = parser.parseExpression(“#this”).getValue(context, String.class);

System.out.println(thisObj);

}

输出

路人甲java

Spring系列

我是root对象

使用“#variable”来引用在EvaluationContext定义的变量；除了可以引用自定义变量，还可以使用“#root”引用根对象，“#this”引用当前上下文对象，此处“#this”即根对象。

自定义函数

目前只支持类静态方法注册为自定义函数；SpEL使用StandardEvaluationContext的registerFunction方法进行注册自定义函数，其实完全可以使用setVariable代替，两者其实本质是一样的；

@Test

public void testFunctionExpression() throws SecurityException, NoSuchMethodException {

//定义2个函数,registerFunction和setVariable都可以，不过从语义上面来看用registerFunction更恰当

StandardEvaluationContext context = new StandardEvaluationContext();

Method parseInt = Integer.class.getDeclaredMethod(“parseInt”, String.class);

context.registerFunction(“parseInt1”, parseInt);

context.setVariable(“parseInt2”, parseInt);

ExpressionParser parser = new SpelExpressionParser();

System.out.println(parser.parseExpression(“#parseInt1(‘3’)”).getValue(context, int.class));

System.out.println(parser.parseExpression(“#parseInt2(‘3’)”).getValue(context, int.class));

String expression1 = “#parseInt1(‘3’) == #parseInt2(‘3’)”;

boolean result1 = parser.parseExpression(expression1).getValue(context, boolean.class);

System.out.println(result1);

}

此处可以看出“registerFunction”和“setVariable”都可以注册自定义函数，但是两个方法的含义不一样，推荐使用“registerFunction”方法注册自定义函数。

运行输出

true

表达式赋值

使用Expression#setValue方法可以给表达式赋值

@Test

public void testAssignExpression1() {

Object user = new Object() {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return “$classname{” +

“name='” + name + ‘’’ +

‘}’;

}

};

{

//user为root对象

ExpressionParser parser = new SpelExpressionParser();

EvaluationContext context = new StandardEvaluationContext(user);

parser.parseExpression(“#root.name”).setValue(context, “路人甲java”);

System.out.println(parser.parseExpression(“#root”).getValue(context, user.getClass()));

}

{

//user为变量

ExpressionParser parser = new SpelExpressionParser();

EvaluationContext context = new StandardEvaluationContext();

context.setVariable(“user”, user);

parser.parseExpression(“#user.name”).setValue(context, “路人甲java”);

System.out.println(parser.parseExpression(“#user”).getValue(context, user.getClass()));

}

运行输出

$classname{name=‘路人甲java’}

对象属性存取及安全导航表达式

对象属性获取非常简单，即使用如“a.property.property”这种点缀式获取，SpEL对于属性名首字母是不区分大小写的；SpEL还引入了Groovy语言中的安全导航运算符“(对象|属性)?.属性”，用来避免“?.”前边的表达式为null时抛出空指针异常，而是返回null；修改对象属性值则可以通过赋值表达式或Expression接口的setValue方法修改。

public static class Car {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return “Car{” +

“name='” + name + ‘’’ +

‘}’;

}

public static class User {

private Car car;

public Car getCar() {

return car;

}

public void setCar(Car car) {

this.car = car;

}

@Override

public String toString() {

return “User{” +

“car=” + car +

‘}’;

}

@Test

public void test5() {

User user = new User();

EvaluationContext context = new StandardEvaluationContext();

context.setVariable(“user”, user);

ExpressionParser parser = new SpelExpressionParser();

//使用.符号，访问user.car.name会报错，原因：user.car为空

try {

System.out.println(parser.parseExpression(“#user.car.name”).getValue(context, String.class));

} catch (EvaluationException | ParseException e) {

System.out.println(“出错了：” + e.getMessage());

}

//使用安全访问符号?.，可以规避null错误

System.out.println(parser.parseExpression(“#user?.car?.name”).getValue(context, String.class));

Car car = new Car();

car.setName(“保时捷”);

user.setCar(car);

System.out.println(parser.parseExpression(“#user?.car?.toString()”).getValue(context, String.class));

}

运行输出

出错了：EL1007E: Property or field ‘name’ cannot be found on null

null

Car{name=‘保时捷’}

对象方法调用

对象方法调用更简单，跟Java语法一样；如“‘haha’.substring(2,4)”将返回“ha”；而对于根对象可以直接调用方法；

Bean引用

SpEL支持使用“@”符号来引用Bean，在引用Bean时需要使用BeanResolver接口实现来查找Bean，Spring提供BeanFactoryResolver实现。

@Test

public void test6() {

DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

User user = new User();

Car car = new Car();

car.setName(“保时捷”);

user.setCar(car);

factory.registerSingleton(“user”, user);

StandardEvaluationContext context = new StandardEvaluationContext();

context.setBeanResolver(new BeanFactoryResolver(factory));

ExpressionParser parser = new SpelExpressionParser();

User userBean = parser.parseExpression(“@user”).getValue(context, User.class);

System.out.println(userBean);

System.out.println(userBean == factory.getBean(“user”));

}

运行输出

User{car=Car{name=‘保时捷’}}

true

集合相关表达式

内联List

从Spring3.0.4开始支持内联List，使用{表达式，……}定义内联List，如“{1,2,3}”将返回一个整型的ArrayList，而“{}”将返回空的List，对于字面量表达式列表，SpEL会使用java.util.Collections.unmodifiableList方法将列表设置为不可修改。

@Test

public void test7() {

ExpressionParser parser = new SpelExpressionParser();

//将返回不可修改的空List

List result2 = parser.parseExpression(“{}”).getValue(List.class);

//对于字面量列表也将返回不可修改的List

List result1 = parser.parseExpression(“{1,2,3}”).getValue(List.class);

Assert.assertEquals(new Integer(1), result1.get(0));

try {

result1.set(0, 2);

} catch (Exception e) {

e.printStackTrace();

}

//对于列表中只要有一个不是字面量表达式，将只返回原始List，

//不会进行不可修改处理

String expression3 = “{{1+2,2+4},{3,4+4}}”;

List<List> result3 = parser.parseExpression(expression3).getValue(List.class);

result3.get(0).set(0, 1);

System.out.println(result3);

//声明二维数组并初始化

int[] result4 = parser.parseExpression(“new int[2]{1,2}”).getValue(int[].class);

System.out.println(result4[1]);

//定义一维数组并初始化

int[] result5 = parser.parseExpression(“new int[1]”).getValue(int[].class);

System.out.println(result5[0]);

}

输出

java.lang.UnsupportedOperationException

at java.util.Collections$UnmodifiableList.set(Collections.java:1311)

at com.javacode2018.spel.SpelTest.test7(SpelTest.java:315)

[[1, 6], [3, 8]]

内联数组

和Java 数组定义类似，只是在定义时进行多维数组初始化。

int[][][] result4 = parser.parseExpression(“new int[1][2][3]{{1}{2}{3}}”).getValue(int[][][].class);

集合，字典元素访问

SpEL目前支持所有集合类型和字典类型的元素访问，使用“集合[索引]”访问集合元素，使用“map[key]”访问字典元素；

//SpEL内联List访问

int result1 = parser.parseExpression(“{1,2,3}[0]”).getValue(int.class);

//SpEL目前支持所有集合类型的访问

Collection collection = new HashSet();

collection.add(1);

collection.add(2);

EvaluationContext context2 = new StandardEvaluationContext();

context2.setVariable(“collection”, collection);

int result2 = parser.parseExpression(“#collection[1]”).getValue(context2, int.class);

//SpEL对Map字典元素访问的支持

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

map.put(“a”, 1);

EvaluationContext context3 = new StandardEvaluationContext();

context3.setVariable(“map”, map);

int result3 = parser.parseExpression(“#map[‘a’]”).getValue(context3, int.class);

列表，字典，数组元素修改

可以使用赋值表达式或Expression接口的setValue方法修改；

@Test

public void test8() {

ExpressionParser parser = new SpelExpressionParser();

//修改list元素值

List list = new ArrayList();

list.add(1);

list.add(2);

EvaluationContext context1 = new StandardEvaluationContext();

context1.setVariable(“collection”, list);

parser.parseExpression(“#collection[1]”).setValue(context1, 4);

int result1 = parser.parseExpression(“#collection[1]”).getValue(context1, int.class);

System.out.println(result1);

//修改map元素值

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

map.put(“a”, 1);

EvaluationContext context2 = new StandardEvaluationContext();

context2.setVariable(“map”, map);

parser.parseExpression(“#map[‘a’]”).setValue(context2, 4);

Integer result2 = parser.parseExpression(“#map[‘a’]”).getValue(context2, int.class);

System.out.println(result2);

}

输出

集合投影

在SQL中投影指从表中选择出列，而在SpEL指根据集合中的元素中通过选择来构造另一个集合，该集合和原集合具有相同数量的元素；SpEL使用“（list|map）.![投影表达式]”来进行投影运算：

@Test

public void test9() {

ExpressionParser parser = new SpelExpressionParser();

//1.测试集合或数组

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。

为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的

并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）

我的美团offer凉凉了？开发工程师（Java岗）三面结束等通知...

66个Java面试知识点

架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）

我的美团offer凉凉了？开发工程师（Java岗）三面结束等通知...

算法刷题（PDF）

我的美团offer凉凉了？开发工程师（Java岗）三面结束等通知...

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
;

}

输出

集合投影

@Test

public void test9() {

ExpressionParser parser = new SpelExpressionParser();

//1.测试集合或数组

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-hXV4cu5T-1711860211913)]

[外链图片转存中…(img-CpphxTQk-1711860211913)]

[外链图片转存中…(img-WLnSTM32-1711860211914)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。

并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）

[外链图片转存中…(img-ocdqG4vE-1711860211914)]

66个Java面试知识点

[外链图片转存中…(img-pdaE5dRX-1711860211915)]

算法刷题（PDF）

[外链图片转存中…(img-8ALud57Q-1711860211915)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

JAVA无声

关注

28
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
Spring系列第39篇：强大的Spel表达式(1)

谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）66个Java面试知识点架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）算法刷题（PDF）
复制链接

扫一扫