AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

spring ioc原理（看完后大家可以自己写一个spring）

2018-04-13 1039
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_34173549/article/details/79929123  ...
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_34173549/article/details/79929123

    

在学习spring的时候，最常听到的词应该就是IOC和AOP了，下面，我从我的角度再次理解一下Spring里的IOC和AOP.


IOC简介

    IoC(InversionofControl)：IoC就是应用本身不依赖对象的创建和维护而是交给外部容器(这里为spring),这要就把应用和对象之间解耦,控制权交给了外部容器。即Don'tcallme,I'llcallyou！所以IoC也称DI(依赖注入)对象的创建和维护依赖于外部容器.

IOC详解

    关于IOC的博客有很多，我们可以从这篇博客中了解一下：

    深入浅出Spring（二）IoC详解

简单理解IOC

    我们从文章中发现，其实ioc所做的一件事情就是把A和B的强耦合关系，变成A依赖于B的接口的关系，但具体A要实现B接口中哪一种B类型，由C来决定，以达到解耦，通俗来讲，我们在家到饭点的时候就会说“我要吃饭”，我这里代表的是A，饭代表的是B的接口，但是具体是要吃什么饭，那就由你的妈妈在决定，你妈妈给你在碗里放了米饭（B），你就要吃米饭，当然，今天你妈妈开心，也可以给你碗里放一个鸡腿，这个决定权在你的妈妈，也就是我们常说的把控制权交给第三方。一次来达到我（A）和米饭（B）的解耦。

DI与IOC 的关系

    我们可能会经常听到另一个词：DI,这里，简单的做一下讲解：

    因为IOC确实不够开门见山，因此业界曾进行了广泛的讨论，最终软件界的泰斗级人物MartinFowIer提出了DI（依注入：Dependency Injection)的概念用以代替loc,即让调用类对某一接口实现类的依赖关系由第三方（容器或协作类）注入，以移除调用类对某一接口实现类的依赖。“依賴注入”这个名词显然比“控制反转”直接明了、易于理解。

    所以，我认为IOC和DI描述的是一件事情，只是从不同的角度来描述：

    IOC控制反转：说的是创建对象实例的控制权从代码控制剥离到IOC容器控制，实际上就是我们现在说的第三方，侧重于原理。

    DI依赖注入：说的是创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。

说到DI，可能就会有出现这样一个问题，既然DI侧重实现，那么他是怎么实现的呢？也就是怎么注入的呢？下面我们

几种注入方式：

    简单说一下几种注入方式：

    第一种：构造函数注入（这里我们直接沿用上面的例子）：

  

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1.        publicclass Team {   
  2.          privateLeader leader；  
  3.          publicTeam(Leader leader){  
  4.                    this.leader=leader;  
  5. }  
  6.              public void firstMetting(){   
  7.                  leader.introduce();   
  8.              }   
  9.          }     
  10. 在Boss出的代码为：  
  11. public class Boss {    
  12.    public void direct(){   
  13.        Leader leader = new Li();   
  14.        Team team = new Team(leader);   
  15.        team.firstMetting();   
  16. }   

 第二种：属性注入：

    有时,我们会发现,虽然小李在这个team里要发言，，但并非每次都要发言，在这种情况下通过构造函数注入并不妥当，这时可以考虑使用属性注入。属性注入可以有选择地通过setter方法完成调用类所需依赖的注入，更加灵活方便；

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public class Team {   
  2.          privateLeader leader；  
  3.          publicvoid SetLeader (Leader leader){  
  4.                    this.leader=leader;  
  5. }  
  6.              public void firstMetting(){   
  7.                  leader.introduce();   
  8.              }   
  9.          }     
  10. 在Boss出的代码为：  
  11. public class Boss {   
  12.    public void direct(){   
  13.        Leader leader = new Li();   
  14.        Team team = new Team();   
  15.                    Team.setLeader(leader);  
  16.        team.firstMetting();   
  17. }   


    和通过构造函数注入不同，在实例化Team时，并未指定任何发言人，而是在实例化Team后，在需要小李出场时，才调用其setLeader方法注入扮演者。按照类似的方式，这样，我们就可以在不同的场合，注入相应的发言人了。

 

第三种：接口注入：

[html]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. 定义接口:  
  2. Public interface teamInject{  
  3.          voidinjectLeader(Leader leader);  
  4. }  
  5. public class Team implements teamInject {   
  6.          privateLeader leader；  
  7.          publicvoid injectLeader (Leader leader){  
  8.                    this.leader=leader;  
  9. }  
  10.              public void firstMetting(){   
  11.                  leader.introduce();   
  12.              }   
  13.          }     
  14. 在Boss出的代码为：  
  15. public class Boss {   
  16.    public void direct(){   
  17.        Leader leader = new Li();   
  18.        Team team = new Team();   
  19.                    Team.setLeader(leader);  
  20.        team.firstMetting();   
  21. }   


    由于通过接口注入需要额外声明一个接口，增加了类的数目，而且它的效果和属性注

    入并无本质区别，因此我们不提倡采用这种方式。

Spring中实现IOC

   当然，在这个例子中，我们是通过手动维护第三方类的，那么，Spring容器是怎么实现的呢？

    spring容器实现的方法网上也有很多，在这里，我就直接站在巨人的肩膀上了：

   手动模拟IOC

 

    其实，在Spring容器中，容器只是把第三方这个类对外封装成一个xml节点，在容器中进行查询注入，注意，这里用到两个非常重要的技术，一个是查找XML，另一个是根据方法名利用反射机制调用类。我感觉如果以后想写出好的程序，这两个技术是必不可少的。

 

IOC就讲到这里，下面讲一下我对AOP的理解：Spring中的AOP

控制反转/依赖注入

 

最近，买了本spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。 先就IOC和DI谈一点我的看法。

IOC（DI）：其实这个Spring架构核心的概念没有这么复杂，更不像有些书上描述的那样晦涩。Java程序员都知道：java程序中的每个业务逻辑至少需要两个或以上的对象来协作完成，通常，每个对象在使用他的合作对象时，自己均要使用像new object（） 这样的语法来完成合作对象的申请工作。你会发现：对象间的耦合度高了。而IOC的思想是：Spring容器来实现这些相互依赖对象的创建、协调工作。对象只需要关系业务逻辑本身就可以了。从这方面来说，对象如何得到他的协作对象的责任被反转了（IOC、DI）。

这是我对Spring的IOC的体会。DI其实就是IOC的另外一种说法。DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：获得依赖对象的方式反转了。

如果对这一核心概念还不理解：这里引用一个叫Bromon的blog上找到的浅显易懂的答案：



IoC与DI

　　首先想说说IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

　　那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。如果你还不明白的话，我决定放弃。

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。关于反射的相关资料请查阅java doc。
　理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在spring的框架中堆积木而已。

如果还不明白，放弃java吧！

 

下面来让大家了解一下Spring到底是怎么运行的。

Java代码 
  1. public static void main(String[] args) {   
  2.         ApplicationContext context = new FileSystemXmlApplicationContext(   
  3.                 "applicationContext.xml");   
  4.         Animal animal = (Animal) context.getBean("animal");   
  5.         animal.say();   
  6.     }  
[java]  view plain  copy
  1. public static void main(String[] args) {  
  2.         ApplicationContext context = new FileSystemXmlApplicationContext(  
  3.                 "applicationContext.xml");  
  4.         Animal animal = (Animal) context.getBean("animal");  
  5.         animal.say();  
  6.     }  


这段代码你一定很熟悉吧，不过还是让我们分析一下它吧，首先是applicationContext.xml

Java代码 
  1. <bean id="animal" class="phz.springframework.test.Cat">   
  2.         <property name="name" value="kitty" />   
  3.     </bean>  
[java]  view plain  copy
  1. <bean id="animal" class="phz.springframework.test.Cat">  
  2.         <property name="name" value="kitty" />  
  3.     </bean>  


他有一个类phz.springframework.test.Cat

Java代码 
  1. public class Cat implements Animal {   
  2.     private String name;   
  3.     public void say() {   
  4.         System.out.println("I am " + name + "!");   
  5.     }   
  6.     public void setName(String name) {   
  7.         this.name = name;   
  8.     }   
  9. }  
[java]  view plain  copy
  1. public class Cat implements Animal {  
  2.     private String name;  
  3.     public void say() {  
  4.         System.out.println("I am " + name + "!");  
  5.     }  
  6.     public void setName(String name) {  
  7.         this.name = name;  
  8.     }  
  9. }  


实现了phz.springframework.test.Animal接口

Java代码 
  1. public interface Animal {   
  2.     public void say();   
  3. }  
[java]  view plain  copy
  1. public interface Animal {  
  2.     public void say();  
  3. }  


很明显上面的代码输出I am kitty! 

那么到底Spring是如何做到的呢？ 
接下来就让我们自己写个Spring 来看看Spring 到底是怎么运行的吧！ 

首先，我们定义一个Bean类，这个类用来存放一个Bean拥有的属性

Java代码 
  1. /* Bean Id */  
  2.     private String id;   
  3.     /* Bean Class */  
  4.     private String type;   
  5.     /* Bean Property */  
  6.     private Map<String, Object> properties = new HashMap<String, Object>();  
[java]  view plain  copy
  1. /* Bean Id */  
  2.     private String id;  
  3.     /* Bean Class */  
  4.     private String type;  
  5.     /* Bean Property */  
  6.     private Map<String, Object> properties = new HashMap<String, Object>();  


一个Bean包括id,type,和Properties。 

接下来Spring 就开始加载我们的配置文件了，将我们配置的信息保存在一个HashMap中，HashMap的key就是Bean 的 Id ，HasMap 的value是这个Bean，只有这样我们才能通过context.getBean("animal")这个方法获得Animal这个类。我们都知道Spirng可以注入基本类型，而且可以注入像List，Map这样的类型，接下来就让我们以Map为例看看Spring是怎么保存的吧 

Map配置可以像下面的

Java代码 
  1. <bean id="test" class="Test">   
  2.         <property name="testMap">   
  3.             <map>   
  4.                 <entry key="a">   
  5.                     <value>1</value>   
  6.                 </entry>   
  7.                 <entry key="b">   
  8.                     <value>2</value>   
  9.                 </entry>   
  10.             </map>   
  11.         </property>   
  12.     </bean>  
[java]  view plain  copy
  1. <bean id="test" class="Test">  
  2.         <property name="testMap">  
  3.             <map>  
  4.                 <entry key="a">  
  5.                     <value>1</value>  
  6.                 </entry>  
  7.                 <entry key="b">  
  8.                     <value>2</value>  
  9.                 </entry>  
  10.             </map>  
  11.         </property>  
  12.     </bean>  


Spring是怎样保存上面的配置呢？，代码如下：

Java代码 
  1. if (beanProperty.element("map") != null) {   
  2.                     Map<String, Object> propertiesMap = new HashMap<String, Object>();   
  3.                     Element propertiesListMap = (Element) beanProperty   
  4.                             .elements().get(0);   
  5.                     Iterator<?> propertiesIterator = propertiesListMap   
  6.                             .elements().iterator();   
  7.                     while (propertiesIterator.hasNext()) {   
  8.                         Element vet = (Element) propertiesIterator.next();   
  9.                         if (vet.getName().equals("entry")) {   
  10.                             String key = vet.attributeValue("key");   
  11.                             Iterator<?> valuesIterator = vet.elements()   
  12.                                     .iterator();   
  13.                             while (valuesIterator.hasNext()) {   
  14.                                 Element value = (Element) valuesIterator.next();   
  15.                                 if (value.getName().equals("value")) {   
  16.                                     propertiesMap.put(key, value.getText());   
  17.                                 }   
  18.                                 if (value.getName().equals("ref")) {   
  19.                                     propertiesMap.put(key, new String[] { value   
  20.                                             .attributeValue("bean") });   
  21.                                 }   
  22.                             }   
  23.                         }   
  24.                     }   
  25.                     bean.getProperties().put(name, propertiesMap);   
  26.                 }  
[java]  view plain  copy
  1. if (beanProperty.element("map") != null) {  
  2.                     Map<String, Object> propertiesMap = new HashMap<String, Object>();  
  3.                     Element propertiesListMap = (Element) beanProperty  
  4.                             .elements().get(0);  
  5.                     Iterator<?> propertiesIterator = propertiesListMap  
  6.                             .elements().iterator();  
  7.                     while (propertiesIterator.hasNext()) {  
  8.                         Element vet = (Element) propertiesIterator.next();  
  9.                         if (vet.getName().equals("entry")) {  
  10.                             String key = vet.attributeValue("key");  
  11.                             Iterator<?> valuesIterator = vet.elements()  
  12.                                     .iterator();  
  13.                             while (valuesIterator.hasNext()) {  
  14.                                 Element value = (Element) valuesIterator.next();  
  15.                                 if (value.getName().equals("value")) {  
  16.                                     propertiesMap.put(key, value.getText());  
  17.                                 }  
  18.                                 if (value.getName().equals("ref")) {  
  19.                                     propertiesMap.put(key, new String[] { value  
  20.                                             .attributeValue("bean") });  
  21.                                 }  
  22.                             }  
  23.                         }  
  24.                     }  
  25.                     bean.getProperties().put(name, propertiesMap);  
  26.                 }  



接下来就进入最核心部分了，让我们看看Spring 到底是怎么依赖注入的吧，其实依赖注入的思想也很简单，它是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。让我们看看具体它是怎么做的吧。 
首先实例化一个类，像这样

Java代码 
  1. public static Object newInstance(String className) {   
  2.         Class<?> cls = null;   
  3.         Object obj = null;   
  4.         try {   
  5.             cls = Class.forName(className);   
  6.             obj = cls.newInstance();   
  7.         } catch (ClassNotFoundException e) {   
  8.             throw new RuntimeException(e);   
  9.         } catch (InstantiationException e) {   
  10.             throw new RuntimeException(e);   
  11.         } catch (IllegalAccessException e) {   
  12.             throw new RuntimeException(e);   
  13.         }   
  14.         return obj;   
  15.     }  
[java]  view plain  copy
  1. public static Object newInstance(String className) {  
  2.         Class<?> cls = null;  
  3.         Object obj = null;  
  4.         try {  
  5.             cls = Class.forName(className);  
  6.             obj = cls.newInstance();  
  7.         } catch (ClassNotFoundException e) {  
  8.             throw new RuntimeException(e);  
  9.         } catch (InstantiationException e) {  
  10.             throw new RuntimeException(e);  
  11.         } catch (IllegalAccessException e) {  
  12.             throw new RuntimeException(e);  
  13.         }  
  14.         return obj;  
  15.     }  


接着它将这个类的依赖注入进去，像这样

Java代码 
  1. public static void setProperty(Object obj, String name, String value) {   
  2.         Class<? extends Object> clazz = obj.getClass();   
  3.         try {   
  4.             String methodName = returnSetMthodName(name);   
  5.             Method[] ms = clazz.getMethods();   
  6.             for (Method m : ms) {   
  7.                 if (m.getName().equals(methodName)) {   
  8.                     if (m.getParameterTypes().length == 1) {   
  9.                         Class<?> clazzParameterType = m.getParameterTypes()[0];   
  10.                         setFieldValue(clazzParameterType.getName(), value, m,   
  11.                                 obj);   
  12.                         break;   
  13.                     }   
  14.                 }   
  15.             }   
  16.         } catch (SecurityException e) {   
  17.             throw new RuntimeException(e);   
  18.         } catch (IllegalArgumentException e) {   
  19.             throw new RuntimeException(e);   
  20.         } catch (IllegalAccessException e) {   
  21.             throw new RuntimeException(e);   
  22.         } catch (InvocationTargetException e) {   
  23.             throw new RuntimeException(e);   
  24.         }   
  25. }  
[java]  view plain  copy
  1. public static void setProperty(Object obj, String name, String value) {  
  2.         Class<? extends Object> clazz = obj.getClass();  
  3.         try {  
  4.             String methodName = returnSetMthodName(name);  
  5.             Method[] ms = clazz.getMethods();  
  6.             for (Method m : ms) {  
  7.                 if (m.getName().equals(methodName)) {  
  8.                     if (m.getParameterTypes().length == 1) {  
  9.                         Class<?> clazzParameterType = m.getParameterTypes()[0];  
  10.                         setFieldValue(clazzParameterType.getName(), value, m,  
  11.                                 obj);  
  12.                         break;  
  13.                     }  
  14.                 }  
  15.             }  
  16.         } catch (SecurityException e) {  
  17.             throw new RuntimeException(e);  
  18.         } catch (IllegalArgumentException e) {  
  19.             throw new RuntimeException(e);  
  20.         } catch (IllegalAccessException e) {  
  21.             throw new RuntimeException(e);  
  22.         } catch (InvocationTargetException e) {  
  23.             throw new RuntimeException(e);  
  24.         }  
  25. }  


最后它将这个类的实例返回给我们，我们就可以用了。我们还是以Map为例看看它是怎么做的，我写的代码里面是创建一个HashMap并把该HashMap注入到需要注入的类中，像这样，

Java代码 
  1. if (value instanceof Map) {   
  2.                 Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()   
  3.                         .iterator();   
  4.                 Map<String, Object> map = new HashMap<String, Object>();   
  5.                 while (entryIterator.hasNext()) {   
  6.                     Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();   
  7.                     if (entryMap.getValue() instanceof String[]) {   
  8.                         map.put((String) entryMap.getKey(),   
  9.                                 getBean(((String[]) entryMap.getValue())[0]));   
  10.                     }   
  11.                 }   
  12.                 BeanProcesser.setProperty(obj, property, map);   
  13.             }  
[java]  view plain  copy
  1. if (value instanceof Map) {  
  2.                 Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()  
  3.                         .iterator();  
  4.                 Map<String, Object> map = new HashMap<String, Object>();  
  5.                 while (entryIterator.hasNext()) {  
  6.                     Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();  
  7.                     if (entryMap.getValue() instanceof String[]) {  
  8.                         map.put((String) entryMap.getKey(),  
  9.                                 getBean(((String[]) entryMap.getValue())[0]));  
  10.                     }  
  11.                 }  
  12.                 BeanProcesser.setProperty(obj, property, map);  
  13.             }  


好了，这样我们就可以用Spring 给我们创建的类了，是不是也不是很难啊？当然Spring能做到的远不止这些，这个示例程序仅仅提供了Spring最核心的依赖注入功能中的一部分。 

文章标签：
Java
Spring
容器
关键词：
Spring原理
Spring IOC
ioc Spring
Spring IOC原理
追风筝的猪
目录
相关文章
喜欢猪猪
|
12天前
|
XML Java 开发者
Spring Boot开箱即用可插拔实现过程演练与原理剖析
【11月更文挑战第20天】Spring Boot是一个基于Spring框架的项目，其设计目的是简化Spring应用的初始搭建以及开发过程。Spring Boot通过提供约定优于配置的理念，减少了大量的XML配置和手动设置，使得开发者能够更专注于业务逻辑的实现。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理，并通过Java代码手写模拟Spring Boot的启动过程，为开发者提供一个全面的理解。
喜欢猪猪
23 0
mikechen的互联网架构
|
27天前
|
XML 缓存 Java
搞透 IOC、Spring IOC ，看这篇就够了！
本文详细解析了Spring框架的核心内容——IOC（控制反转）及其依赖注入（DI）的实现原理，帮助读者理解如何通过IOC实现组件解耦，提高程序的灵活性和可维护性。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
43 2
蓝易云
|
18天前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
31 0
dlwlrma-晴子
|
2月前
|
Java Spring 容器
Spring底层原理大致脉络
Spring底层原理大致脉络
dlwlrma-晴子
47 4
喜欢猪猪
|
2月前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
【10月更文挑战第1天】Spring框架以其强大的控制反转（IOC）和面向切面编程（AOP）功能，成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理，并通过源码解析来揭示其实现机制。同时，我们还将探讨Spring事务管理的核心原理，并给出相应的源码示例。
喜欢猪猪
134 9
dream_ready
|
2月前
|
存储 开发框架 Java
什么是Spring？什么是IOC？什么是DI？IOC和DI的关系？ —— 零基础可无压力学习，带源码
文章详细介绍了Spring、IOC、DI的概念和关系，解释了控制反转(IOC)和依赖注入(DI)的原理，并提供了IOC的代码示例，阐述了Spring框架作为IOC容器的应用。
dream_ready
32 0
什么是Spring？什么是IOC？什么是DI？IOC和DI的关系？ —— 零基础可无压力学习，带源码
喜欢猪猪
|
3月前
|
缓存 Java Spring
手写Spring Ioc 循环依赖底层源码剖析
在Spring框架中，IoC（控制反转）是一个核心特性，它通过依赖注入（DI）实现了对象间的解耦。然而，在实际开发中，循环依赖是一个常见的问题。
喜欢猪猪
42 4
喜欢猪猪
|
2月前
|
XML Java 数据格式
Spring IOC容器的深度解析及实战应用
【10月更文挑战第14天】在软件工程中，随着系统规模的扩大，对象间的依赖关系变得越来越复杂，这导致了系统的高耦合度，增加了开发和维护的难度。为解决这一问题，Michael Mattson在1996年提出了IOC（Inversion of Control，控制反转）理论，旨在降低对象间的耦合度，提高系统的灵活性和可维护性。Spring框架正是基于这一理论，通过IOC容器实现了对象间的依赖注入和生命周期管理。
喜欢猪猪
73 0
木子0204
|
2月前
|
XML Java 数据格式
Spring的IOC和AOP
Spring的IOC和AOP
木子0204
48 0
猿java
|
2月前
|
XML 前端开发 Java
拼多多1面：聊聊Spring MVC的工作原理！
本文详细剖析了Spring MVC的工作原理，涵盖其架构、工作流程及核心组件。Spring MVC采用MVC设计模式，通过DispatcherServlet、HandlerMapping、Controller和ViewResolver等组件高效处理Web请求。文章还探讨了DispatcherServlet的初始化和请求处理流程，以及HandlerMapping和Controller的角色。通过理解这些核心概念，开发者能更好地构建可维护、可扩展的Web应用。适合面试准备和技术深挖
猿java
43 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Ehcache 整合Spring 使用页面、对象缓存
  • 4
    Spring Security（07）——缓存UserDetails
  • 5
    面向切面的Spring
  • 6
    在Spring中使用JDK定时器实现调度任务
  • 7
    阿里开发者学院：Java Spring Boot 2.5.x开发实战课程
  • 8
    Spring框架下的单元测试方法
  • 9
    【Spring框架】我终于读懂了ApplicationContext（案例详解）
  • 10
    Spring(二)之入门示例
  • 1
    实时计算 Flink版产品使用问题之Spring Boot集成Flink可以通过什么方式实现通过接口启动和关闭Flink程序
    179
  • 2
    实时计算 Flink版产品使用问题之使用Spring Boot启动Flink处理任务时，使用Spring Boot的@Scheduled注解进行定时任务调度，出现内存占用过高，该怎么办
    118
  • 3
    2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
    297
  • 4
    《滚雪球学Spring Boot》教程导航帖（更新于2024.07.16）
    69
  • 5
    如何优化Spring Boot应用性能？
    62
  • 6
    Spring Boot 2.x新特性有哪些？
    75
  • 7
    如何实现Springboot+camunda+mysql的集成
    385
  • 8
    Spring Boot框架在java领域的优势
    79
  • 9
    Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法
    301
  • 10
    spring 事务控制 设置手动回滚 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()；
    137

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    无影云桌面