小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶

 

 

Spring中有个非常重要的知识点,AOP,即面相切面编程,spring中提供的一些非常牛逼的功能都是通过aop实现的,比如下面这些大家比较熟悉的功能

  1. spring事务管理:@Transactional
  2. spring异步处理:@EnableAsync
  3. spring缓存技术的使用:@EnableCaching
  4. spring中各种拦截器:@EnableAspectJAutoProxy

大家想玩转spring,成为一名spring高手,aop是必须要掌握的,aop这块东西比较多,我们将通过三四篇文章来详解介绍这块的内容,由浅入深,让大家全面掌握这块知识。

说的简单点,spring中的aop就是依靠代理实现的各种功能,通过代理来对bean进行增强。

spring中的aop功能主要是通过2种代理来实现的

  1. jdk动态代理
  2. cglib代理

继续向下之前,必须先看一下这篇文章:Spring系列第15篇:代理详解(Java动态代理&cglib代理)?

spring aop中用到了更多的一些特性,上面这边文章中没有介绍到,所以通过本文来做一个补充,这2篇文章看过之后,再去看spring aop的源码,理解起来会容易一些,这2篇算是最基础的知识,所以一定要消化理解,不然aop那块的原理你很难了解,会晕车,

jdk动态代理

特征

  1. 只能为接口创建代理对象
  2. 创建出来的代理都是java.lang.reflect.Proxy的子类

案例

案例源码位置:

 
com.javacode2018.aop.demo1.JdkAopTest1

有2个接口

 
interface IService1 {     void m1(); }  interface IService2 {     void m2(); }

下面的类实现了上面2个接口

 
public static class Service implements IService1, IService2 {     @Override     public void m1() {         System.out.println("我是m1");     }     @Override     public void m2() {         System.out.println("我是m2");     } }

下面通过jdk动态代理创建一个代理对象,实现上面定义的2个接口,将代理对象所有的请求转发给Service去处理,需要在代理中统计2个接口中所有方法的耗时。

比较简单,自定义一个InvocationHandler

 
public static class CostTimeInvocationHandler implements InvocationHandler {     private Object target;     public CostTimeInvocationHandler(Object target) {         this.target = target;     }     @Override     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         long startime = System.nanoTime();         Object result = method.invoke(this.target, args); //将请求转发给target去处理         System.out.println(method + ",耗时(纳秒):" + (System.nanoTime() - startime));         return result;     } }

测试方法

 
{     Service target = new Service();     CostTimeInvocationHandler costTimeInvocationHandler = new CostTimeInvocationHandler(target);     //创建代理对象     Object proxyObject = Proxy.newProxyInstance(             target.getClass().getClassLoader(),             new Class[]{IService1.class, IService2.class}, //创建的代理对象实现了2个接口             costTimeInvocationHandler);     //判断代理对象是否是Service类型的,肯定是false咯     System.out.println(String.format("proxyObject instanceof Service = %s", proxyObject instanceof Service));     //判断代理对象是否是IService1类型的,肯定是true     System.out.println(String.format("proxyObject instanceof IService1 = %s", proxyObject instanceof IService1));     //判断代理对象是否是IService2类型的,肯定是true     System.out.println(String.format("proxyObject instanceof IService2 = %s", proxyObject instanceof IService2));     //将代理转换为IService1类型     IService1 service1 = (IService1) proxyObject;     //调用IService2的m1方法     service1.m1();     //将代理转换为IService2类型     IService2 service2 = (IService2) proxyObject;     //调用IService2的m2方法     service2.m2();     //输出代理的类型     System.out.println("代理对象的类型:" + proxyObject.getClass()); }

运行输出

 
proxyObject instanceof Service = false proxyObject instanceof IService1 = true proxyObject instanceof IService2 = true 我是m1 public abstract void com.javacode2018.aop.demo1.JdkAopTest1$IService1.m1(),耗时(纳秒):225600 我是m2 public abstract void com.javacode2018.aop.demo1.JdkAopTest1$IService2.m2(),耗时(纳秒):36000 代理对象的类型:class com.javacode2018.aop.demo1.$Proxy0

m1方法和m2方法被CostTimeInvocationHandler#invoke给增强了,调用目标方法的过程中统计了耗时。

最后一行输出可以看出代理对象的类型,类名中包含了$Proxy的字样,所以以后注意,看到这种字样的,基本上都是通过jdk动态代理创建的代理对象。

下面来说cglib代理的一些特殊案例。

cglib代理

cglib的特点

  1. cglib弥补了jdk动态代理的不足,jdk动态代理只能为接口创建代理,而cglib非常强大,不管是接口还是类,都可以使用cglib来创建代理
  2. cglib创建代理的过程,相当于创建了一个新的类,可以通过cglib来配置这个新的类需要实现的接口,以及需要继承的父类
  3. cglib可以为类创建代理,但是这个类不能是final类型的,cglib为类创建代理的过程,实际上为通过继承来实现的,相当于给需要被代理的类创建了一个子类,然后会重写父类中的方法,来进行增强,继承的特性大家应该都知道,final修饰的类是不能被继承的,final修饰的方法不能被重写,static修饰的方法也不能被重写,private修饰的方法也不能被子类重写,而其他类型的方法都可以被子类重写,被重写的这些方法可以通过cglib进行拦截增强

cglib整个过程如下

  1. Cglib根据父类,Callback, Filter 及一些相关信息生成key
  2. 然后根据key 生成对应的子类的二进制表现形式
  3. 使用ClassLoader装载对应的二进制,生成Class对象,并缓存
  4. 最后实例化Class对象,并缓存

案例1:为多个接口创建代理

代码比较简单,定义了2个接口,然后通过cglib来创建一个代理类,代理类会实现这2个接口,通过setCallback来对2个接口的方法进行增强。

 
public class CglibTest1 {     interface IService1 {         void m1();     }     interface IService2 {         void m2();     }     public static void main(String[] args) {         Enhancer enhancer = new Enhancer();         //设置代理对象需要实现的接口         enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});         //通过Callback来对被代理方法进行增强         enhancer.setCallback(new MethodInterceptor() {             @Override             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                 System.out.println("方法:" + method.getName());                 return null;             }         });         Object proxy = enhancer.create();         if (proxy instanceof IService1) {             ((IService1) proxy).m1();         }         if (proxy instanceof IService2) {             ((IService2) proxy).m2();         }         //看一下代理对象的类型         System.out.println(proxy.getClass());         //看一下代理类实现的接口         System.out.println("创建代理类实现的接口如下:");         for (Class cs : proxy.getClass().getInterfaces()) {             System.out.println(cs);         }     } }

运行输出

 
方法:m1 方法:m2 class com.javacode2018.aop.demo2.CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82 创建代理类实现的接口如下: interface com.javacode2018.aop.demo2.CglibTest1$IService1 interface com.javacode2018.aop.demo2.CglibTest1$IService2 interface org.springframework.cglib.proxy.Factory

上面创建的代理类相当于下面代码

 
public class CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82 implements IService1, IService2 {     @Override     public void m1() {         System.out.println("方法:m1");     }     @Override     public void m2() {         System.out.println("方法:m2");     } }

案例2:为类和接口同时创建代理

下面定义了2个接口:IService1和IService2,2个接口有个实现类:Service,然后通过cglib创建了个代理类,实现了这2个接口,并且将Service类作为代理类的父类。

 
public class CglibTest2 {     interface IService1 {         void m1();     }     interface IService2 {         void m2();     }     public static class Service implements IService1, IService2 {         @Override         public void m1() {             System.out.println("m1");         }         @Override         public void m2() {             System.out.println("m2");         }     }     public static void main(String[] args) {         Enhancer enhancer = new Enhancer();         //设置代理类的父类         enhancer.setSuperclass(Service.class);         //设置代理对象需要实现的接口         enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});         //通过Callback来对被代理方法进行增强         enhancer.setCallback(new MethodInterceptor() {             @Override             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                 long startime = System.nanoTime();                 Object result = methodProxy.invokeSuper(o, objects); //调用父类中的方法                 System.out.println(method + ",耗时(纳秒):" + (System.nanoTime() - startime));                 return result;             }         });         //创建代理对象         Object proxy = enhancer.create();         //判断代理对象是否是Service类型的         System.out.println("proxy instanceof Service" + (proxy instanceof Service));         if (proxy instanceof Service) {             Service service = (Service) proxy;             service.m1();             service.m2();         }         //看一下代理对象的类型         System.out.println(proxy.getClass());         //输出代理对象的父类         System.out.println("代理类的父类:" + proxy.getClass().getSuperclass());         //看一下代理类实现的接口         System.out.println("创建代理类实现的接口如下:");         for (Class cs : proxy.getClass().getInterfaces()) {             System.out.println(cs);         }     } }

运行输出

 
proxy instanceof Servicetrue m1 public void com.javacode2018.aop.demo2.CglibTest2$Service.m1(),耗时(纳秒):14219700 m2 public void com.javacode2018.aop.demo2.CglibTest2$Service.m2(),耗时(纳秒):62800 class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536 代理类的父类:class com.javacode2018.aop.demo2.CglibTest2$Service 创建代理类实现的接口如下: interface com.javacode2018.aop.demo2.CglibTest2$IService1 interface com.javacode2018.aop.demo2.CglibTest2$IService2 interface org.springframework.cglib.proxy.Factory

输出中可以代理对象的类型是:

 
class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536

带有$$EnhancerByCGLIB$$字样的,在调试spring的过程中,发现有这样字样的,基本上都是cglib创建的代理对象。

上面创建的代理类相当于下面代码

 
public class CglibTest2$Service$$EnhancerByCGLIB$$80494536 extends Service implements IService1, IService2 {     @Override     public void m1() {         long starttime = System.nanoTime();         super.m1();         System.out.println("方法m1,耗时(纳秒):" + (System.nanoTime() - starttime));     }     @Override     public void m2() {         long starttime = System.nanoTime();         super.m1();         System.out.println("方法m1,耗时(纳秒):" + (System.nanoTime() - starttime));     } }

案例3:LazyLoader的使用

LazyLoader是cglib用于实现懒加载的callback。当被增强bean的方法初次被调用时,会触发回调,之后每次再进行方法调用都是对LazyLoader第一次返回的bean调用,hibernate延迟加载有用到过这个。

看案例吧,通过案例理解容易一些。

 
public class LazyLoaderTest1 {     public static class UserModel {         private String name;         public UserModel() {         }         public UserModel(String name) {             this.name = name;         }         public void say() {             System.out.println("你好:" + name);         }     }     public static void main(String[] args) {         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(UserModel.class);         //创建一个LazyLoader对象         LazyLoader lazyLoader = new LazyLoader() {             @Override             public Object loadObject() throws Exception {                 System.out.println("调用LazyLoader.loadObject()方法");                 return new UserModel("路人甲java");             }         };         enhancer.setCallback(lazyLoader);         Object proxy = enhancer.create();         UserModel userModel = (UserModel) proxy;         System.out.println("第1次调用say方法");         userModel.say();         System.out.println("第1次调用say方法");         userModel.say();     } }

运行输出

 
第1次调用say方法 调用LazyLoader.loadObject()方法 你好:路人甲java 第1次调用say方法 你好:路人甲java

当第1次调用say方法的时候,会被cglib拦截,进入lazyLoader的loadObject内部,将这个方法的返回值作为say方法的调用者,loadObject中返回了一个路人甲Java的UserModel,cglib内部会将loadObject方法的返回值和say方法关联起来,然后缓存起来,而第2次调用say方法的时候,通过方法名去缓存中找,会直接拿到第1次返回的UserModel,所以第2次不会进入到loadObject方法中了。

将下代码拆分开来

 
System.out.println("第1次调用say方法"); userModel.say(); System.out.println("第1次调用say方法"); userModel.say();

相当于下面的代码

 
System.out.println("第1次调用say方法"); System.out.println("调用LazyLoader.loadObject()方法"); userModel = new UserModel("路人甲java"); userModel.say(); System.out.println("第1次调用say方法"); userModel.say();

下面通过LazyLoader实现延迟加载的效果。

案例4:LazyLoader实现延迟加载

博客的内容一般比较多,需要用到内容的时候,我们再去加载,下面来模拟博客内容延迟加载的效果。

 
public class LazyLoaderTest2 {     //博客信息     public static class BlogModel {         private String title;         //博客内容信息比较多,需要的时候再去获取         private BlogContentModel blogContentModel;         public BlogModel() {             this.title = "spring aop详解!";             this.blogContentModel = this.getBlogContentModel();         }         private BlogContentModel getBlogContentModel() {             Enhancer enhancer = new Enhancer();             enhancer.setSuperclass(BlogContentModel.class);             enhancer.setCallback(new LazyLoader() {                 @Override                 public Object loadObject() throws Exception {                     //此处模拟从数据库中获取博客内容                     System.out.println("开始从数据库中获取博客内容.....");                     BlogContentModel result = new BlogContentModel();                     result.setContent("欢迎大家和我一起学些spring,我们一起成为spring高手!");                     return result;                 }             });             return (BlogContentModel) enhancer.create();         }     }     //表示博客内容信息     public static class BlogContentModel {         //博客内容         private String content;         public String getContent() {             return content;         }         public void setContent(String content) {             this.content = content;         }     }     public static void main(String[] args) {         //创建博客对象         BlogModel blogModel = new BlogModel();         System.out.println(blogModel.title);         System.out.println("博客内容");         System.out.println(blogModel.blogContentModel.getContent()); //@1     } }

@1:调用blogContentModel.getContent()方法的时候,才会通过LazyLoader#loadObject方法从db中获取到博客内容信息

运行输出

 
spring aop详解! 博客内容 开始从数据库中获取博客内容..... 欢迎大家和我一起学些spring,我们一起成为spring高手!

案例5:Dispatcher

Dispatcher和LazyLoader作用很相似,区别是用Dispatcher的话每次对增强bean进行方法调用都会触发回调。

看案例代码

 
public class DispatcherTest1 {     public static class UserModel {         private String name;         public UserModel() {         }         public UserModel(String name) {             this.name = name;         }         public void say() {             System.out.println("你好:" + name);         }     }     public static void main(String[] args) {         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(LazyLoaderTest1.UserModel.class);         //创建一个Dispatcher对象         Dispatcher dispatcher = new Dispatcher() {             @Override             public Object loadObject() throws Exception {                 System.out.println("调用Dispatcher.loadObject()方法");                 return new LazyLoaderTest1.UserModel("路人甲java," + UUID.randomUUID().toString());             }         };         enhancer.setCallback(dispatcher);         Object proxy = enhancer.create();         LazyLoaderTest1.UserModel userModel = (LazyLoaderTest1.UserModel) proxy;         System.out.println("第1次调用say方法");         userModel.say();         System.out.println("第1次调用say方法");         userModel.say();     } }

运行输出

 
第1次调用say方法 调用Dispatcher.loadObject()方法 你好:路人甲java,514f911e-06ac-4e3b-aee4-595f82c16a5f 第1次调用say方法 调用Dispatcher.loadObject()方法 你好:路人甲java,bc062990-bc16-4226-97e3-b1b321a03468

案例6:通过Dispathcer对类扩展一些接口

下面有个UserService类,我们需要对这个类创建一个代理。

代码中还定义了一个接口:IMethodInfo,用来统计被代理类的一些方法信息,有个实现类:DefaultMethodInfo。

通过cglib创建一个代理类,父类为UserService,并且实现IMethodInfo接口,将接口IMethodInfo所有方法的转发给DefaultMethodInfo处理,代理类中的其他方法,转发给其父类UserService处理。

这个代码相当于对UserService这个类进行了增强,使其具有了IMethodInfo接口中的功能。

 
public class DispatcherTest2 {     public static class UserService {         public void add() {             System.out.println("新增用户");         }         public void update() {             System.out.println("更新用户信息");         }     }     //用来获取方法信息的接口     public interface IMethodInfo {         //获取方法数量         int methodCount();         //获取被代理的对象中方法名称列表         List methodNames();     }     //IMethodInfo的默认实现     public static class DefaultMethodInfo implements IMethodInfo {         private Class targetClass;         public DefaultMethodInfo(Class targetClass) {             this.targetClass = targetClass;         }         @Override         public int methodCount() {             return targetClass.getDeclaredMethods().length;         }         @Override         public List methodNames() {             return Arrays.stream(targetClass.getDeclaredMethods()).                     map(Method::getName).                     collect(Collectors.toList());         }     }     public static void main(String[] args) {         Class targetClass = UserService.class;         Enhancer enhancer = new Enhancer();         //设置代理的父类         enhancer.setSuperclass(targetClass);         //设置代理需要实现的接口列表         enhancer.setInterfaces(new Class[]{IMethodInfo.class});         //创建一个方法统计器         IMethodInfo methodInfo = new DefaultMethodInfo(targetClass);         //创建会调用器列表,此处定义了2个,第1个用于处理UserService中所有的方法,第2个用来处理IMethodInfo接口中的方法         Callback[] callbacks = {                 new MethodInterceptor() {                     @Override                     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                         return methodProxy.invokeSuper(o, objects);                     }                 },                 new Dispatcher() {                     @Override                     public Object loadObject() throws Exception {                         /**                          * 用来处理代理对象中IMethodInfo接口中的所有方法                          * 所以此处返回的为IMethodInfo类型的对象,                          * 将由这个对象来处理代理对象中IMethodInfo接口中的所有方法                          */                         return methodInfo;                     }                 }         };         enhancer.setCallbacks(callbacks);         enhancer.setCallbackFilter(new CallbackFilter() {             @Override             public int accept(Method method) {                 //当方法在IMethodInfo中定义的时候,返回callbacks中的第二个元素                 return method.getDeclaringClass() == IMethodInfo.class ? 1 : 0;             }         });         Object proxy = enhancer.create();         //代理的父类是UserService         UserService userService = (UserService) proxy;         userService.add();         //代理实现了IMethodInfo接口         IMethodInfo mf = (IMethodInfo) proxy;         System.out.println(mf.methodCount());         System.out.println(mf.methodNames());     } }

运行输出

 
新增用户 2 [add, update]

案例7:cglib中的NamingPolicy接口

接口NamingPolicy表示生成代理类的名字的策略,通过Enhancer.setNamingPolicy方法设置命名策略。

默认的实现类:DefaultNamingPolicy, 具体cglib动态生成类的命名控制。

DefaultNamingPolicy中有个getTag方法。

DefaultNamingPolicy生成的代理类的类名命名规则:

 
被代理class name + "$$" + 使用cglib处理的class name + "ByCGLIB" + "$$" + key的hashcode

如:

 
com.javacode2018.aop.demo2.DispatcherTest2$UserService$$EnhancerByCGLIB$$e7ec0be5@17d10166

自定义NamingPolicy,通常会继承DefaultNamingPolicy来实现,spring中默认就提供了一个,如下

 
public class SpringNamingPolicy extends DefaultNamingPolicy {     public static final SpringNamingPolicy INSTANCE = new SpringNamingPolicy();     @Override     protected String getTag() {         return "BySpringCGLIB";     } }

案例代码

 
public class NamingPolicyTest {     public static void main(String[] args) {         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(NamingPolicyTest.class);         enhancer.setCallback(NoOp.INSTANCE);         //通过Enhancer.setNamingPolicy来设置代理类的命名策略         enhancer.setNamingPolicy(new DefaultNamingPolicy() {             @Override             protected String getTag() {                 return "-test-";             }         });         Object proxy = enhancer.create();         System.out.println(proxy.getClass());     } }

输出

 
class com.javacode2018.aop.demo2.NamingPolicyTest$$Enhancer-test-$$5946713

Objenesis:实例化对象的一种方式

先来看一段代码,有一个有参构造函数:

 
public static class User {     private String name;     public User(String name) {         this.name = name;     }     @Override     public String toString() {         return "User{" +                 "name='" + name + '\'' +                 '}';     } }

大家来思考一个问题:如果不使用这个有参构造函数的情况下,如何创建这个对象?

通过反射?大家可以试试,如果不使用有参构造函数,是无法创建对象的。

cglib中提供了一个接口:Objenesis,通过这个接口可以解决上面这种问题,它专门用来创建对象,即使你没有空的构造函数,都木有问题,它不使用构造方法创建Java对象,所以即使你有空的构造方法,也是不会执行的。

用法比较简单:

 
@Test public void test1() {     Objenesis objenesis = new ObjenesisStd();     User user = objenesis.newInstance(User.class);     System.out.println(user); }

输出

 
User{name='null'}

大家可以在User类中加一个默认构造函数,来验证一下上面的代码会不会调用默认构造函数?

 
public User() {     System.out.println("默认构造函数"); }

再次运行会发现,并不会调用默认构造函数。

如果需要多次创建User对象,可以写成下面方式重复利用

 
@Test public void test2() {     Objenesis objenesis = new ObjenesisStd();     ObjectInstantiator userObjectInstantiator = objenesis.getInstantiatorOf(User.class);     User user1 = userObjectInstantiator.newInstance();     System.out.println(user1);     User user2 = userObjectInstantiator.newInstance();     System.out.println(user2);     System.out.println(user1 == user2); }

运行输出

 
User{name='null'} User{name='null'} false

代码位置

 
com.javacode2018.aop.demo2.CreateObjectTest

总结

  1. 代理这2篇文章是spring aop的基础,基础牢靠了,才能走的更远,大家一定要将这2篇文章中的内容吃透,全面掌握jdk动态代理和cglib代理的使用
  2. 这些知识点spring aop中全部都用到了,大家消化一下,下一篇讲解spring aop具体是如何玩的

Spring作为现在最流行的java 开发技术,其内部源码设计非常优秀。如果你不会Spring,那么很可能面试官会让你回家等通知。

Spring是什么?

有一个工地,几百号人在用铁锹铲子挖坑。

如果开一辆挖掘机来,用一天时间干的活就相当于一个工人一个月的工作量。而且这个挖掘机是免费开源的,不用花钱买,仅仅需要学习掌握如何操作。

你会如何选择?

这几百号人的工地就是企业应用项目实施团队,而挖掘机就是Spring。

Spring框架为开发Java应用程序提供了全面的基础架构支持。Spring包含了一些很好的功能,如依赖注入和开箱即用的模块:

Spring JDBC

Spring MVC

Spring Security

Spring AOP

Spring ORM

Spring Test

这些模块能极大缩短应用程序的开发时间,提高我们的工作效率。

Spring底层到底要看什么?以下是大神整理的学习笔记,给大家分享一下,希望可以对你掌握Spring有所帮助。(xmind格式可在文末获取)

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第1张图片

 

Spring学习笔记(完整内容在xmind文件中)

但是现在很多程序员对于Spring的理解只停留在很浅的层面。很多人只关注自己用的那部分代码的逻辑,而并不真正去理解框架。

如果你不懂Spring,那么大厂面试官也不会懂你为什么敢来面试?

看腾讯技术大牛带你玩转Spring全家桶,赠三本Spring实战篇电子文档

背景介绍

毋庸置疑,Spring 早已成为 Java 后端开发事实上的行业标准,无数的公司选择 Spring 作为基础的开发框架,大部分 Java 后端程序员在日常工作中也会接触到Spring ,因此,如何用好 Spring ,也就成为 Java程序员的必修课之一。

同时,Spring Boot 和 Spring Cloud的出现,可以帮助工程师更好地基于 Spring 及各种基础设施来快速搭建系统,可以说,它们的诞生又一次解放了大家的生产力。

因此,Spring Boot 和 Spring Cloud已成为 Spring 生态中不可或缺的一环。想成为一名合格的Java 后端工程师,Spring Framework、Spring Boot、Spring Cloud 这三者必须都牢牢掌握。

今天楼主就给大家分享Spring,Spring Boot,Spring Cloud的电子书学习资料!

转发文章并关注楼主,然后私信我回复【架构书籍】领取Spring全家桶实战文档

内容目录

【Spring实战】

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第2张图片

 

 

 

 

 

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第3张图片

 

 

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第4张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第5张图片

 

 

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第6张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第7张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第8张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第9张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第10张图片

 

【深入实践Spring Boot2.x】

 

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第11张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第12张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第13张图片

 

 

 

【Spring Cloud微服务实战】

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第14张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第15张图片

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第16张图片

 

 

 

小心,99%的面试者,都倒在了这里。一文带你了解spring全家桶_第17张图片

 

 

 

转发文章并关注楼主,然后私信我【架构书籍】即可免费领取Spring全家桶实战文档

资料真实有效,绝不弄虚作假!

你可能感兴趣的:(java,编程)