proxy.m1(“路人”);
proxy.m1(100);
}
运行输出
请求参数：[路人]
我是m1方法,参数：路人
我是m1方法,参数：100
输出中可以看出，m1第一次调用被增强了，第二次没有被增强。
args会在调用的过程中对参数实际的类型进行匹配，比较耗时，慎用。
6、@within
用法
@within(注解类型)：匹配指定的注解内定义的方法。
匹配规则
调用目标方法的时候，通过java中Method.getDeclaringClass()获取当前的方法是哪个类中定义的，然后会看这个类上是否有指定的注解。
被调用的目标方法Method对象.getDeclaringClass().getAnnotation(within中指定的注解类型) != null
来看3个案例。
案例1
目标对象上有@within中指定的注解，这种情况时，目标对象的所有方法都会被拦截。
来个注解
package com.javacode2018.aop.demo9.test9;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Ann9 {
}
来个目标类，用@Ann9标注
package com.javacode2018.aop.demo9.test9;
@Ann9
public class S9 {
public void m1() {
System.out.println(“我是m1方法”);
}
}
来个Aspect类
package com.javacode2018.aop.demo9.test9;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest9 {
/**
* 定义目标方法的类上有Ann9注解
*/
@Pointcut(“@within(Ann9)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试代码
@Test
public void test9() {
S9 target = new S9();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest9.class);
S9 proxy = proxyFactory.getProxy();
proxy.m1();
}
m1方法在类S9中定义的，S9上面有Ann9注解，所以匹配成功
运行输出
execution(void com.javacode2018.aop.demo9.test9.S9.m1())
我是m1方法
案例2
定义注解时未使用@Inherited，说明子类无法继承父类上的注解，这个案例中我们将定义一个这样的注解，将注解放在目标类的父类上，来看一下效果。
定义注解Ann10
package com.javacode2018.aop.demo9.test10;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Ann10 {
}
来2个父子类
注意：
S10Parent为父类，并且使用了Anno10注解，内部定义了2个方法大家注意一下
而S10位代理的目标类，继承了S10Parent，内部重写了父类的m2方法，并且又新增了一个m3方法
package com.javacode2018.aop.demo9.test10;
@Ann10
class S10Parent {
public void m1() {
System.out.println(“我是S10Parent.m1()方法”);
}
public void m2() {
System.out.println(“我是S10Parent.m2()方法”);
}
}
public class S10 extends S10Parent {
@Override
public void m2() {
System.out.println(“我是S10.m2()方法”);
}
public void m3() {
System.out.println(“我是S10.m3()方法”);
}
}
来个Aspect类
package com.javacode2018.aop.demo9.test10;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest10 {
//匹配目标方法声明的类上有@Anno10注解
@Pointcut(“@within(com.javacode2018.aop.demo9.test10.Ann10)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试用例
S10为目标类，依次执行代理对象的m1、m2、m3方法，最终会调用目标类target中对应的方法。
@Test
public void test10() {
S10 target = new S10();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest10.class);
S10 proxy = proxyFactory.getProxy();
proxy.m1();
proxy.m2();
proxy.m3();
}
运行输出
execution(void com.javacode2018.aop.demo9.test10.S10Parent.m1())
我是S10Parent.m1()方法
我是S10.m2()方法
我是S10.m3()方法
分析结果
从输出中可以看出，只有m1方法被拦截了，其他2个方法没有被拦截。
确实是这样的，m1方法的是由S10Parent定义的，这个类上面有Ann10注解。
而m2方法虽然也在S10Parent中定义了，但是这个方法被子类S10重写了，所以调用目标对象中的m2方法的时候，此时发现m2方法是由S10定义的，而S10.class.getAnnotation(Ann10.class)为空，所以这个方法不会被拦截。
同样m3方法也是S10中定义的，也不会被拦截。
案例3
对案例2进行改造，在注解的定义上面加上@Inherited，此时子类可以继承父类的注解，此时3个方法都会被拦截了。
下面上代码，下面代码为案例2代码的一个拷贝，不同地方只是注解的定义上多了@Inherited
定义注解Ann11
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Ann11 {
}
2个父子类
package com.javacode2018.aop.demo9.test11;
@Ann11
class S11Parent {
public void m1() {
System.out.println(“我是S11Parent.m1()方法”);
}
public void m2() {
System.out.println(“我是S11Parent.m2()方法”);
}
}
public class S11 extends S11Parent {
@Override
public void m2() {
System.out.println(“我是S11.m2()方法”);
}
public void m3() {
System.out.println(“我是S11.m3()方法”);
}
}
Aspect类
package com.javacode2018.aop.demo9.test11;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest11 {
@Pointcut(“@within(com.javacode2018.aop.demo9.test11.Ann11)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试用例
@Test
public void test11() {
S11 target = new S11();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest11.class);
S11 proxy = proxyFactory.getProxy();
proxy.m1();
proxy.m2();
proxy.m3();
}
运行输出
execution(void com.javacode2018.aop.demo9.test11.S11Parent.m1())
我是S11Parent.m1()方法
execution(void com.javacode2018.aop.demo9.test11.S11.m2())
我是S11.m2()方法
execution(void com.javacode2018.aop.demo9.test11.S11.m3())
我是S11.m3()方法
这次3个方法都被拦截了。
7、@target
用法
@target(注解类型)：判断目标对象target类型上是否有指定的注解；@target中注解类型也必须是全限定类型名。
匹配规则
target.class.getAnnotation(指定的注解类型) != null
2种情况可以匹配
-
注解直接标注在目标类上
-
注解标注在父类上，但是注解必须是可以继承的，即定义注解的时候，需要使用
@Inherited标注
案例1
注解直接标注在目标类上，这种情况目标类会被匹配到。
自定义一个注解`Ann6`
package com.javacode2018.aop.demo9.test6;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Ann6 {
}
目标类`S6`上直接使用`@Ann1`
package com.javacode2018.aop.demo9.test6;
@Ann6
public class S6 {
public void m1() {
System.out.println(“我是m1”);
}
}
来个`Aspect`类
package com.javacode2018.aop.demo9.test6;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest6 {
//@1：目标类上有@Ann1注解
@Pointcut(“@target(Ann1)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试代码
@Test
public void test6() {
S6 target = new S6();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest6.class);
S6 proxy = proxyFactory.getProxy();
proxy.m1();
System.out.println(“目标类上是否有 @Ann6 注解：” + (target.getClass().getAnnotation(Ann6.class) != null));
}
运行输出
execution(void com.javacode2018.aop.demo9.test6.S6.m1())
我是m1
目标类上是否有 @Ann6 注解：true
案例2
注解标注在父类上，注解上没有@Inherited，这种情况下，目标类无法匹配到，下面看代码
注解Ann7
package com.javacode2018.aop.demo9.test7;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Ann7 {
}
来2个父子类，父类上有`@Ann7`，之类`S7`为目标类
package com.javacode2018.aop.demo9.test7;
import java.lang.annotation.Target;
@Ann7
class S7Parent {
}
public class S7 extends S7Parent {
public void m1() {
System.out.println(“我是m1”);
}
public static void main(String[] args) {
System.out.println(S7.class.getAnnotation(Target.class));
}
}
来个Aspect类
package com.javacode2018.aop.demo9.test7;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest7 {
/**
* 匹配目标类上有Ann7注解
*/
@Pointcut(“@target(com.javacode2018.aop.demo9.test7.Ann7)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试代码
@Test
public void test7() {
S7 target = new S7();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest7.class);
S7 proxy = proxyFactory.getProxy();
proxy.m1();
System.out.println(“目标类上是否有 @Ann7 注解：” + (target.getClass().getAnnotation(Ann7.class) != null));
}
运行输出
我是m1
目标类上是否有 @Ann7 注解：false
分析结果
@Ann7标注在了父类上，但是@Ann7定义的时候没有使用@Inherited，说明之类无法继承父类上面的注解，所以上面的目标类没有被拦截，下面我们将@Ann7的定义改一下，加上@Inherited
package com.javacode2018.aop.demo9.test7;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Ann7 {
}
再次运行输出
execution(void com.javacode2018.aop.demo9.test7.S7.m1())
我是m1
目标类上是否有 @Ann7 注解：true
此时目标对象被拦截了。
8、@args
用法
@args(注解类型)：方法参数所属的类上有指定的注解；注意不是参数上有指定的注解，而是参数类型的类上有指定的注解。
案例1
@Pointcut(“@args(Ann8)”)：匹配方法只有一个参数，并且参数所属的类上有Ann8注解
可以匹配下面的代码，m1方法的第一个参数类型是Car类型，Car类型上有注解Ann8
@Ann8
class Car {
}
public void m1(Car car) {
System.out.println(“我是m1”);
}
案例2
@Pointcut(“@args(*,Ann8)”)：匹配方法只有2个参数，且第2个参数所属的类型上有Ann8注解
可以匹配下面代码
@Ann8
class Car {
}
public void m1(String name,Car car) {
System.out.println(“我是m1”);
}
案例3
@Pointcut(“@args(…,com.javacode2018.aop.demo9.test8.Ann8)”)：匹配参数数量大于等于1，且最后一个参数所属的类型上有Ann8注解
@Pointcut(“@args(*,com.javacode2018.aop.demo9.test8.Ann8,…)”)：匹配参数数量大于等于2，且第2个参数所属的类型上有Ann8注解
@Pointcut(“@args(…,com.javacode2018.aop.demo9.test8.Ann8,*)”)：匹配参数数量大于等于2，且倒数第2个参数所属的类型上有Ann8注解
这个案例代码，大家自己写一下，体验一下。
9、@annotation
用法
@annotation(注解类型)：匹配被调用的方法上有指定的注解。
案例
定义一个注解，可以用在方法上
package com.javacode2018.aop.demo9.test12;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Ann12 {
}
定义2个类
S12Parent为父类，内部定义了2个方法，2个方法上都有@Ann12注解
S12是代理的目标类，也是S12Parent的子类，内部重写了m2方法，重写之后m2方法上并没有@Ann12注解，S12内部还定义2个方法m3和m4，而m3上面有注解@Ann12
package com.javacode2018.aop.demo9.test12;
class S12Parent {
@Ann12
public void m1() {
System.out.println(“我是S12Parent.m1()方法”);
}
@Ann12
public void m2() {
System.out.println(“我是S12Parent.m2()方法”);
}
}
public class S12 extends S12Parent {
@Override
public void m2() {
System.out.println(“我是S12.m2()方法”);
}
@Ann12
public void m3() {
System.out.println(“我是S12.m3()方法”);
}
public void m4() {
System.out.println(“我是S12.m4()方法”);
}
}
来个Aspect类
当被调用的目标方法上有@Ann12注解的时，会被beforeAdvice处理。
package com.javacode2018.aop.demo9.test12;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AspectTest12 {
@Pointcut(“@annotation(com.javacode2018.aop.demo9.test12.Ann12)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
测试用例
S12作为目标对象，创建代理，然后分别调用4个方法
@Test
public void test12() {
S12 target = new S12();
AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAspect(AspectTest12.class);
S12 proxy = proxyFactory.getProxy();
proxy.m1();
proxy.m2();
proxy.m3();
proxy.m4();
}
运行输出
execution(void com.javacode2018.aop.demo9.test12.S12Parent.m1())
我是S12Parent.m1()方法
我是S12.m2()方法
execution(void com.javacode2018.aop.demo9.test12.S12.m3())
我是S12.m3()方法
我是S12.m4()方法
分析结果
m1方法位于S12Parent中，上面有@Ann12注解，被连接了，m3方法上有@Ann12注解，被拦截了，而m4上没有@Ann12注解，没有被拦截，这3个方法的执行结果都很容易理解。
重点在于m2方法的执行结果，没有被拦截，m2方法虽然在S12Parent中定义的时候也有@Ann12注解标注，但是这个方法被S1给重写了，在S1中定义的时候并没有@Ann12注解，代码中实际上调用的是S1中的m2方法，发现这个方法上并没有@Ann12注解，所以没有被拦截。
10、bean
用法
bean(bean名称)：这个用在spring环境中，匹配容器中指定名称的bean。
案例
来个类BeanService
package com.javacode2018.aop.demo9.test13;
public class BeanService {
private String beanName;
public BeanService(String beanName) {
this.beanName = beanName;
}
public void m1() {
System.out.println(this.beanName);
}
}
来个Aspect类
package com.javacode2018.aop.demo9.test13;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
public class Aspect13 {
//拦截spring容器中名称为beanService2的bean
@Pointcut(“bean(beanService2)”)
public void pc() {
}
@Before(“pc()”)
public void beforeAdvice(JoinPoint joinPoint) {
System.out.println(joinPoint);
}
}
来个spring配置类
package com.javacode2018.aop.demo9.test13;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@EnableAspectJAutoProxy // 这个可以启用通过AspectJ方式自动为符合条件的bean创建代理
public class MainConfig13 {
//将Aspect13注册到spring容器
@Bean
public Aspect13 aspect13() {
return new Aspect13();
}
@Bean
public BeanService beanService1() {
return new BeanService(“beanService1”);
}
@Bean
public BeanService beanService2() {
return new BeanService(“beanService2”);
}
}
这个配置类中有个
@EnableAspectJAutoProxy，这个注解大家可能比较陌生，这个属于aop中自动代理的范围，后面会有文章详细介绍这块，这里大家暂时先不用关注。
测试用例
下面启动spring容器，加载配置类MainConfig13，然后分别获取beanService1和beanService2，调用他们的m1方法，看看效果
@Test
public void test13() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig13.class);
//从容器中获取beanService1
BeanService beanService1 = context.getBean(“beanService1”, BeanService.class);
beanService1.m1();
//从容器中获取beanService2
BeanService beanService2 = context.getBean(“beanService2”, BeanService.class);
beanService2.m1();
}
运行输出
beanService1
execution(void com.javacode2018.aop.demo9.test13.BeanService.m1())
beanService2
beanService2的m1方法被拦截了。
11、reference pointcut
表示引用其他命名切入点。
有时，我们可以将切入专门放在一个类中集中定义。
其他地方可以通过引用的方式引入其他类中定义的切入点。
语法如下：
@Pointcut(“完整包名类名.方法名称()”)
若引用同一个类中定义切入点，包名和类名可以省略，直接通过方法就可以引用。
比如下面，我们可以将所有切入点定义在一个类中
package com.javacode2018.aop.demo9.test14;
import org.aspectj.lang.annotation.Pointcut;
public class AspectPcDefine {
@Pointcut(“bean(bean1)”)
public void pc1() {
}
@Pointcut(“bean(bean2)”)
public void pc2() {
}
}
下面顶一个一个Aspect类，来引用上面的切入点
package com.javacode2018.aop.demo9.test14;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Aspect14 {
@Pointcut(“com.javacode2018.aop.demo9.test14.AspectPcDefine.pc1()”)
public void pointcut1() {
}
@Pointcut(“com.javacode2018.aop.demo9.test14.AspectPcDefine.pc1() || com.javacode2018.aop.demo9.test14.AspectPcDefine.pc2()”)
public void pointcut2() {
}
}
12、组合型的pointcut
Pointcut定义时，还可以使用&&、||、!运算符。
-
&&：多个匹配都需要满足
-
||：多个匹配中只需满足一个
-
!：匹配不满足的情况下
@Pointcut(“bean(bean1) || bean(bean2)”) //匹配bean1或者bean2
@Pointcut(“@target(Ann1) && @Annotation(Ann2)”) //匹配目标类上有Ann1注解并且目标方法上有Ann2注解
@Pointcut(“@target(Ann1) && !@target(Ann2)”) // 匹配目标类上有Ann1注解但是没有Ann2注解
总结
–
本文详解了@Pointcut的12种用法，案例大家一定要敲一遍，敲的过程中，会遇到问题，然后解决问题，才能够加深理解。
有问题的也欢迎大家留言交流，谢谢！
案例源码
https://gitee.com/javacode2018/spring-series
路人甲java所有案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。
Spring系列
-
Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）
-
Spring系列第29篇：BeanFactory扩展（BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor）
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
最后
很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。
我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。
不管是查缺补漏还是深度学习都能有非常不错的成效，需要的话记得帮忙点个赞支持一下
整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
11篇：bean中的autowire-candidate又是干什么的？]( )
-
Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）
-
Spring系列第29篇：BeanFactory扩展（BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor）
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-88ZSsrQ7-1712113814885)]
[外链图片转存中…(img-H1smJ2na-1712113814886)]
[外链图片转存中…(img-4Rj2Pxsk-1712113814886)]
[外链图片转存中…(img-sUnZ3Vdq-1712113814886)]
[外链图片转存中…(img-IbavVdSM-1712113814887)]
[外链图片转存中…(img-fHCfuWlE-1712113814887)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-hMXr7JSI-1712113814887)]
最后
很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。
我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。
不管是查缺补漏还是深度学习都能有非常不错的成效，需要的话记得帮忙点个赞支持一下
整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
5593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
