看见上一位答主的可爱回答想笑。题主问这个问题应该是还没接触了解过spring框架，我有下面的学习建议:

　　spring框架包含了许多架构的顶级设计思路，去研究它是需要花费比较多经历的。而设计模式也是一大课题 ，有专门一本厚厚的设计模式的书籍给你学习。因此，这两种东西不能说先去学谁，应该是用到哪个学哪个。

　　有人说设计模式是为了弥补Java的不足，这是有一定道理的，常规的二十三种设计模式如果说你要全部理清还算要一点时间，要说能学精通还真的挺难。

　　归纳一下就是两种并行学习，设计模式是辅助spring框架的理解。

　　Spring在java生态圈的地位非常高

　　我先回答如何学习spring，设计模式先不谈。

　　会用spring不难，多在spring项目里开发功能即可。

　　众所周知，Spring的核心特性就是IOC和AOP，IOC（Inversion of Control），即“控制反转”；AOP（Aspect-OrientedProgramming），即“面向切面编程”.

　　我以个人体验讲讲吧，我刚开始学spring时，就是死记硬背这些概念，然后在SSM框架里开发功能需求，看看别人在spring怎么依赖、怎么定义Bean、怎么配置spring事务,依葫芦画瓢就把功能搞定了，但由于没有深入理解Spring的IOC和AOP，在出现spring问题时排查解决速度非常慢。

　　说白了，要涨更高的工资，spring的理解必须要深。常见spring接口必须知道作用。

　　如下：

　　学好这些spring高级特性，你就可以利用spring定制个性化功能，对于业务环境非常复杂的项目spring可以帮我们解决很多复杂问题。如：多数据源的多事务问题，可以利用spring的FactoryBean去生成代理对象；有些特殊业务场景需要手动获取spring里的Bean对象等等。

　　第二个问题是先学习设计模式还是spring？

　　spring里包含了很多设计模式的应用，设计模式这个问题可以单独拿出来细讲。

　　如果仅仅是想学会使用，则可以不学习设计模式，如果想深入层次的学习Spring底层源码，则设计模式是必不可少的！

　　下面从几个方面进行介绍

　　(1) Spring 源码中使用了哪些设计模式？

　　(2) 怎样学习设计模式？

　　(3) 推荐设计模式的书籍

　　spring 中使用了多种设计模式，下面简单介绍一下主要的设计模式

　　(1) 单例模式

　　保证独一无二，为了提高资源重复利用，通过技术手段保证在整个系统运行阶段，只有一个实例

　　场景： 配置文件、监控程序、IOC 容器、日历

　　实现手段： 懒汉式、饿汉式、注册登记式、反序列处理

　　Spring最常用的，注册登记式，效率性能最高的

　　Spring中bean的默认作用域就是singleton（单例）。

　　实现方式：

　　Spring 通过 ConcurrentHashMap 实现单例注册表的特殊方式实现单例模式。Spring 实现单例的核心代码如下

　　（2）代理设计模式

　　代理模式在 AOP 中的应用

　　AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

　　Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib ，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

　　当然你也可以使用 AspectJ ,Spring AOP 已经集成了AspectJ ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了。

　　使用 AOP 之后我们可以把一些通用功能抽象出来，在需要用到的地方直接使用即可，这样大大简化了代码量。我们需要增加新功能时也方便，这样也提高了系统扩展性。日志功能、事务管理等等场景都用到了 AOP 。

　　Spring AOP 和 AspectJ AOP 有什么区别?

　　Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。 Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。

　　Spring AOP 已经集成了 AspectJ ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了。AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单，

　　如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，它比Spring AOP 快很多。

　　(3)模板方法

　　应用场景： JdbcTemplate 工作流

　　代码场景： 模拟Spring JdbcTemplate的简单实现

　　Spring 中 jdbcTemplate、hibernateTemplate 等于 Template 结尾的对数据库操作的类，它们就使用到了模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是 Spring 并没有使用这种方式，而是使用Callback 模式与模板方法模式配合，既达到了代码复用的效果，同时增加了灵活性。

　　(4)观察者模式

　　观察者模式是一种对象行为型模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变的时候，这个对象所依赖的对象也会做出反应。Spring 事件驱动模型就是观察者模式很经典的一个应用。Spring 事件驱动模型非常有用，在很多场景都可以解耦我们的代码。比如我们每次添加商品的时候都需要重新更新商品索引，这个时候就可以利用观察者模式来解决这个问题。

　　Spring 事件驱动模型中的三种角色

　　事件角色

　　ApplicationEvent (org.springframework.context包下)充当事件的角色,这是一个抽象类，它继承了java.util.EventObject并实现了 java.io.Serializable接口。

　　Spring 中默认存在以下事件，他们都是对 ApplicationContextEvent 的实现(继承自ApplicationContextEvent)：

　　事件监听者角色

　　ApplicationListener 充当了事件监听者角色，它是一个接口，里面只定义了一个 onApplicationEvent（）方法来处理ApplicationEvent。ApplicationListener接口类源码如下，可以看出接口定义看出接口中的事件只要实现了 ApplicationEvent就可以了。所以，在 Spring中我们只要实现 ApplicationListener 接口实现 onApplicationEvent() 方法即可完成监听事件

　　

　　事件发布者角色

　　ApplicationEventPublisher 接口的publishEvent（）这个方法在AbstractApplicationContext类中被实现，阅读这个方法的实现，你会发现实际上事件真正是通过ApplicationEventMulticaster来广播出去的。具体内容过多，就不在这里分析了，后面可能会单独写一篇文章提到。

　　Spring 的事件流程总结

　　定义一个事件: 实现一个继承自 ApplicationEvent，并且写相应的构造函数；

　　定义一个事件监听者：实现 ApplicationListener 接口，重写 onApplicationEvent() 方法；

　　使用事件发布者发布消息: 可以通过 ApplicationEventPublisher 的 publishEvent() 方法发布消息。

　　Example:

　　(5) 适配器模式

　　适配器模式(Adapter Pattern) 将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。

　　spring AOP中的适配器模式

　　我们知道 Spring AOP 的实现是基于代理模式，但是 Spring AOP 的增强或通知(Advice)使用到了适配器模式，与之相关的接口是AdvisorAdapter 。Advice 常用的类型有：BeforeAdvice（目标方法调用前,前置通知）、AfterAdvice（目标方法调用后,后置通知）、AfterReturningAdvice(目标方法执行结束后，return之前)等等。每个类型Advice（通知）都有对应的:MethodBeforeAdviceInterceptor、AfterReturningAdviceAdapter、AfterReturningAdviceInterceptor。Spring预定义的通知要通过对应的适配器，适配成 MethodInterceptor接口(方法)类型的对象（如：MethodBeforeAdviceInterceptor 负责适配 MethodBeforeAdvice）。

　　代码场景：登录，为了兼容旧系统的登录功能，在老系统的基础之上进行兼容编程，Spring Adapter结尾的

　　(6) 装饰器模式

　　装饰者模式可以动态地给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。简单点儿说就是当我们需要修改原有的功能，但我们又不愿直接去修改原有的代码时，设计一个Decorator套在原有代码外面。其实在 JDK 中就有很多地方用到了装饰者模式，比如 InputStream家族，InputStream 类下有 FileInputStream (读取文件)、BufferedInputStream (增加缓存,使读取文件速度大大提升)等子类都在不修改InputStream 代码的情况下扩展了它的功能

　　应用场景： IO流 、数据源、也用代码改造一个旧系统，在Spring 中Decorator结尾的，Wrapper结尾的都是。

　　(7） 委派模式

　　代理模式的特殊情况，全权代理

　　应用场景： 项目经理、Dispatcher

　　代码场景： Spring 中ServletDispatcher /Delegate 命名结尾的都是委派模式

　　(1) 调整好心态，不要指望一蹴而就，不可浮躁。

　　学习和掌握设计模式需要一个过程，不同的阶段看这些设计模式有不同的领悟和感受。不要指望真正的设计模式的书籍既简单又有趣，一看就懂的。

　　(2) 学习设计模式的第一步 : 准确理解每个设计模式的功能、基本结构、标准实现，了解适合使用它的场景以及使用的效果。

　　(3) 学习设计模式的第二步: 实际的开发中，尝试着使用这些设计模式，并反复思考和总结是否使用得当，是否需要做一些变化。

　　(4) 学习设计模式的第三步 ： 再回头去看设计模式的理论，有了实际的模式应用经验再看设计模式，会有不同的感悟，一边看一边结合着应用经验来思考。比如设计模式的本质功能是什么？它是如何实现的？z这种实现方式还可以在什么地方应用? 如何才能把这个设计模式和具体的应用结合起来？这个设计模式的出发点是什么？等等。可以有很多考虑的点，从不同的角度对设计模式进行思考。

　　(5) 第四步 ： 多次反复学习设计模式的第二步和第三步。也就是在实际开发中使用，然后结合理论思考，然后再应用，再思考...如此循环，反复多次，直到达到对设计模式基本掌握的水平。

　　简而言之，要注意使用设计模式的理论和实践相结合，理论指导实践，实践反过来加深对理论的理解，如此反复循环，成螺旋式上升！

　　这本书非常经典，大家可以反复阅读，由于网上已没有纸质书，只有电子版，

　　有需要电子版的，可以私信。

　　谢邀！ 虽然Spring中用到了很多设计模式，但是如果你没学过设计模式，也是可以先学习Spring的，看过设计模式会对理解Spring的源码有帮助。 学一个框架，首先你要先学会如何使用，这样后续才可以更好的理解它的内部原理，理解原理才能在它的基础上做扩展，使用过程中报错也可以快速定位解决问题，先学会爬，才能学会走。 Spring框架的使用，可以参照官方的使用手册，读第一手资料不会被误导，如果你觉得英文看起来比较吃力，可以在豆瓣上找一本比较靠谱的书，跟着书学习，推荐一本Spring实战。Spring框架的基础用法会了，可以结合其它框架，比如mybatis等，整合使用，动手实践写一些小的项目。 在熟练使用的基础上，要去研究Spring内部的实现原理，如IOC、AOP、声明式事务等底层是如何实现的，有哪些扩展点、扩展接口可以使用，读源码去研究实现原理，配合书籍会效率高些，同样去找一本点评高的书。 再说设计模式，设计模式是解决设计问题的法宝，它是经验积累的成果，学习设计模式先了解它能解决什么问题、如何实现的，做到心里有数，但是切勿为了用某个设计模式而用，当真正需要解决某类问题的时候可以选择使用！ 希望对你有所帮助！

　　在学习spring框架之前，先夯实Java基础，基础夯实之后，后面的学习会更加的得心应手，比如说，Java基础，web前端，数据库，Javaweb编程等，这些掌握的差不多了，再去研究spring。

　　详细的可以到\"如鹏网\"上去了解一下，有网络的地方就可以学习，有问题随时提问，老师实时在线答疑。每个章节的后面都有相应的练习题和面试口才题，需要以录音的方式进行提交，实时把控学习质量。有新的课程更新了，也是可以继续申请了来学习的，比如说，Java提高课程，里面对spring和设计模式有更加深入详细的讲解。

　　直接引用原文来回答就是：

　　众所周知，设计模式是针对一些特定场景的、比较通用的解决方案。实际上这个定义已经指明了学习设计模式的两个重点：场景和方案。也就是说，学习设计模式的重点在于搞清楚这个模式的使用场景、以及它解决了什么问题。再深入一点的话，可以思考一下如果不使用设计模式还有什么样的方案、以及各种方案之间的优劣对比。如果要更全面、更系统地掌握面向对象思想，还可以把设计模式和SOLID、封装继承多态、高内聚低耦合以及抽象等理论概念串联起来。如果要写书，可以再分辨一下这种模式与相似的模式之间的区别。使用设计模式时也是一样：优先考虑使用场景以及要解决的问题，其次考虑各种解决方案之间的优劣对比，最后——其实压根也不用去考虑——到底要使用模式A还是模式B。总的来说，“使用-对比-概念，就是这个顺序”。之所以强调这一点，是因为无论是学习还是使用设计模式，我都见过很多人把时间精力花费在分辨模式A与模式B之间的概念上。最后呢？大多数人都对把自己绕晕，不但没搞清楚两者的区别，还忘了它们要怎么用、什么时候用。说到底，“黑猫白猫，会捉老鼠就是好猫”。我们学习和使用设计模式时，也不应该把重点放在“这是黄色的母马还是黑色的公马”上，而应该是这马适合长途负重、还是短距离冲刺。找准了使用场景，设计模式其实又容易学、又容易用。

　　。 如果你是想学习spring，建议你可以在网上找一些spring的基础课程，系统学习下。如

　　spring容器、依赖注入、控制反转、aop、bean的生命周期等等

　　。如果你是想学设计模式，也可以在网上找到对应的系统课程

　　。 spring与设计模式是两个概念，没有一定要先学谁。 spring源码中，使用了许多优秀的设计模式，如工厂、单例、代理、观察者等。但是没有学过设计模式，你也可以看的懂。设计模式，只是一种经验，一种问题的最优解决方案，而不是一种新的技术点。

　　个人建议先学习spring的基础知识，学会如何作用spring去做项目，如何将spring配置融合到项目中去。而当你去作用spring做项目后，你会发现你有很多疑问，这时就可以去系统的学习spring了，比如它的一些事务管理，切面编程等等，这时你想弄清楚spring那就需要去看设计模式了。

　　现在你在网上随便搜搜，都会搜到成百上千条的答案。总结最重要的一点，多用，多想，多总结。

　　众所周知，spring的生态圈在java开发中的地位那可是举足轻重的。现在web开发不是SSM就是SpringBoot全家桶，想要学好Spring，就要知道Spring在我们的开发工作中做了什么，通俗点来讲，就是我们在开发中应用Spring有什么好处。

　　Spring的特性，我们都知道Ioc和AOP吗。

　　IOC控制反转，说的直白点就是，之前该你做的事，现在不伦你做了。

　　举个不太恰当的例子：现在你开个饭店，做什么菜，做菜需要什么材料，都是你自己说了算，但是现在生意不太好做呀，你要管的事情太多了呀。

　　隔壁那个加盟店的生意不错呀，轻松还挣钱。所以你想着，我也加盟个饭店吧。但是你加盟之后呢，你就发现，原来你做啥菜，买啥菜，是你自己定的菜单，现在是人家加盟公司，来给你定做什么菜 ，来做菜的食材，都是人家直接配送了。你只能使用总部调配送来的东西呀。你不能决定你用啥菜了。

　　换到我们的Spring的Ioc来说呢，就是之前你这个对象要使用那个对象来干啥事，你可以自己new一个呀，现在不行了，你这个对象不能随便用了，得用我Spring指定分配给你的这个对象。你是失去了对象的创造和选择权利。

　　再来说Spring的学习，个人觉得不需要非得先学习设计模式，在学习Spring的过程中你会更多，更深入的了解到这些。

　　给你推荐本Spring的书Spring源码解析

　　学习Spring分三步：

　　Spring用一句话概述就是：一个精巧的Bean容器。它拥有两个非常重要的概念：IoC和AOP。

　　IoC

　　所谓的控制反转。通俗地讲，就是把原本需要程序员自己创建和维护的一大堆bean统统交由Spring管理。

　　各位将就看一下，此乃在下早期画作，色彩运用有点泛滥...

　　也就是说，Spring将我们从盘根错节的依赖关系中解放了。当前对象如果需要依赖另一个对象，只要打一个@Autowired注解，Spring就会自动帮你安装上。

　　AOP

　　所谓的面向切面编程。通俗地讲，它一般被用来解决一些系统交叉业务的织入，比如日志啦、事务啥的。打个比方，UserService的method1可能要打印日志，BrandService的method2可能也需要。就可以具体用代码展示就是：

　　这个切面，同时作用于3个方法，切面本身可以代表日志，也可以代表事务

　　交叉业务的编程问题即为面向切面编程。而Spring AOP的做法其实是将切面代码移动到原始方法的周围：

　　原先不用AOP时（图一），交叉业务的代码直接硬编码在方法内部的前后，而AOP则是把交叉业务写在方法调用前后。那么，为什么AOP不把代码也写在方法内部的前后呢？两点原因：

　　首先，这与AOP的底层实现方式有关：动态代理其实就是代理对象调用目标对象的同名方法，并在调用前后加增强代码。

　　其次，这两种最终运行效果是一样的，所以没什么好纠结的。

　　AOP注重切面的模块化，即将切面代码做成一个可管理的状态。比如日志打印，不再是直接硬编码在方法中的零散语句，而是做成一个切面类，通过通知方法去执行切面代码。

　　我相信大部分培训班出来的朋友也就言尽于此，讲完上面内容就准备收拾打卡下班了。

　　怎么说呢，IOC按上面的解释，虽然很浅，但也马马虎虎吧。然而AOP，很多人对它的认识是非常片面的...

　　这样吧，我问你一个问题，现在我自己写了一个UserController，以及UserServiceImpl implements UserService，并且在UserController中注入Service层对象：

　　@Autowired private UserService userService;

　　那么，这个userService一定是我们写的UserServiceImpl的实例吗？

　　如果你听不懂我要问什么，说明你对Spring的AOP理解还是太少了。

　　实际上，Spring依赖注入的对象并不一定是我们自己写的类的实例，也可能是userServiceImpl的代理对象。下面分别演示这两种情况：

　　注入的是UserServiceImpl类型

　　注入的是CGLib动态代理生成的userServiceImpl的代理对象

　　为什么两次注入的对象不同？

　　因为第二次我给UserServiceImpl加了@Transactional 注解。

　　此时Spring读取到这个注解，便知道我们要使用事务。而我们编写的UserService类中并没有包含任何事务相关的代码。如果给你，你会怎么做？动态代理嘛！

　　看到这里，我仿佛听到有一部分兄弟默默说了句：卧槽...

　　但是，上面对IOC和AOP的理解，也仅仅是应用级别，是一个面。仅仅了解到这个程度，对Spring的了解还是非常扁平的，不够立体。但我觉得我已经把Spring的大概面貌展现出来了，接下来你可以自己学了。在此之前，我建议最好复习一下Java的高阶知识点。

　　

　　

　　Servlet

　　只是学习Spring的话，其实可以不学Servlet，但web开发总是绕不开SpringMVC，SpringBoot也是如此。关于Servlet，主要是了解下生命周期方法、匹配路径、GET/POST请求及参数处理。

　　具体可以参考：

　　servlet的本质是什么，它是如何工作的？

　　注解

　　注解非常重要，好多初学者不够重视，这会导致后期在各种注解中迷失。而且现在大部分企业都在往Springboot、SpringCloud转型，新的框架都大量地使用注解，非常重要。

　　java注解是怎么实现的？

　　反射

　　框架的底层支撑，可以说是根本。很多初学者其实对反射云里雾里的，不能很好地理解，更不明白怎么用。其实注解搭配反射，可以玩出很多花样。

　　动态代理

　　Spring说穿了，就是IOC和AOP。动态代理在Spring中份量很重。

　　不过，千里之行始于足下，我觉得对于初学者来说，最重要的是知道Spring就是个很大的bean容器，还能自动装配bean。

　　Java动态代理的作用是什么

　　此时你再去学习Spring，就会事半功倍了。

　　如果对你有帮助，可以点个赞哟~

　　另外，答主呕心沥血写了半年的Java小册已经上线了，欢迎订购~

　　Spring学习视频：https://www.bilibili.com/video/av715776098

　　该回答转载自乐字节