横岗网站制作,joomla与wordpress,网站 部署 域名,怎么给网站设置关键字IoC IoC#xff1a;Inversion of Control(控制反转) Spring是一个包含了众多工具的IoC容器(即bean#xff1a;spring管理的对象),也就是说Spring 是一个“控制反转”的容器。 之前是对象本身管理自己的生命周期等等#xff0c;现在交给spring来管理对象的生命周期 IoC介绍
…IoC IoCInversion of Control(控制反转) Spring是一个包含了众多工具的IoC容器(即beanspring管理的对象),也就是说Spring 是一个“控制反转”的容器。 之前是对象本身管理自己的生命周期等等现在交给spring来管理对象的生命周期 IoC介绍
1.2.1 传统程序开发
传统程序开发一个对象类的创建通常由调用者使用者来负责创建的比如我们创建一个Car对象通常由Framework来创建Framework创建Car对象时如果Car对象需要依赖其他对象比如Bottom或者Tire那么这些依赖对象也需要Framework来创建并注入给Car对象。
传统程序开发流程示意图
传统程序开发代码示例
public class NewCarExample {public static void main(String[] args) {// 传统方式直接创建Car对象Car car new Car();car.run();}
}// Car.java
public class Car {private Framework framework;public Car() {// Car类内部负责创建其依赖的Framework对象framework new Framework();System.out.println(Car init...);}public void run() {System.out.println(Car run...);framework.run();}
}// Framework.java
public class Framework {private Bottom bottom;public Framework() {// Framework类内部负责创建其依赖的Bottom对象bottom new Bottom();System.out.println(Framework init...);}public void run() {System.out.println(Framework run...);bottom.run();}
}// Bottom.java
public class Bottom {private Tire tire;public Bottom() {// Bottom类内部负责创建其依赖的Tire对象this.tire new Tire();System.out.println(Bottom init...);}public void run() {System.out.println(Bottom run...);tire.run();}
}// Tire.java
public class Tire {private int size;public Tire() {this.size 17;System.out.println(轮胎尺寸: size);}public void run() {System.out.println(Tire run...);}
}1.2.2 问题分析
在上面的代码中我们发现Car对象对Framework类、Bottom类、Tire类有很强的依赖关系。如果这些依赖关系中的任何一个发生变化比如Car类中需要增加一个依赖对象或者某个依赖对象的创建方式发生变化比如Tire需要进行自定义的Size那么构造方法就需要修改导致依赖他的所有方法的构造函数都需要修改那么Car类也需要进行修改。这使得代码的耦合度很高不利于代码的维护和扩展。
具体来说我们看以下几点
Framework类对Car类的依赖 Framework类在main方法中直接创建了Car对象。如果Car类的构造函数发生变化Framework类也需要修改。这同样导致了高耦合。依赖的传递性 如果Car类又依赖了其他类那么这些其他类也需要Framework来创建并注入给Car对象。这样一来Framework类就成了整个应用程序的“大管家”它需要知道所有对象的创建细节这使得Framework类变得臃肿且难以维护。单元测试困难 由于Car类直接创建了Framework对象当对Car类进行单元测试时很难替换掉Framework的真实实现例如使用模拟对象。这使得单元测试变得复杂。代码复用性差 由于Car类与其需要依赖的类紧密耦合Car类很难在其他不包含这些被依赖的类的场景下复用。
1.2.3 解决方案
在上面的解决方案中我们看到针对传统程序设计模式的缺点我们可以引入IoCInversion of Control 思想即控制反转。IoC的核心思想是对象的创建和依赖关系的维护不再由调用者负责而是由一个外部的容器来负责。当调用者需要某个对象时不再自己去创建而是向容器请求容器会负责创建并提供给调用者。
这就像是以前你饿了需要自己去厨房做饭自己创建对象现在你饿了只需要告诉餐厅你要什么菜向容器请求对象餐厅会帮你做好并送过来容器创建并提供对象。这样你就不需要关心做饭的细节只需要关心吃什么。
IoC控制反转流程示意图
通过IoC我们实现了控制反转将对象的创建和依赖注入的控制权从应用程序代码中移出交给了IoC容器。这样应用程序代码与它所依赖的对象之间的耦合度就大大降低了。
IoC容器就像一个中央工厂负责管理所有对象的生命周期和依赖关系。当应用程序需要某个对象时只需向IoC容器声明其需求IoC容器就会负责创建该对象及其所有依赖并将其注入到应用程序中。
IoC容器示意图
IoC容器的好处有
降低耦合度 对象之间不再直接依赖而是通过IoC容器进行解耦。当一个类的依赖发生变化时不需要修改该类本身的代码只需要修改IoC容器的配置。这使得代码更加灵活易于维护和扩展。提高代码复用性 对象不再负责创建自己的依赖因此可以更容易地在不同的场景下复用。例如Car类不再其依赖类的创建细节它可以与任何实现了其依赖类的接口的对象一起使用。提高可测试性 在单元测试中可以轻松地替换掉真实的对象使用模拟对象进行测试。这使得单元测试更加简单和高效。简化配置 IoC容器可以集中管理所有对象的创建和依赖关系从而简化了应用程序的配置。开发人员不再需要手动管理大量的对象创建代码。
1.2.4 IoC程序开发
基于以上思想我们尝试用代码来表示IoC到底是怎么一回事特别注意受控方式因为是IoC的关键所在。
首先我们先修改一下
// NewCarExample.java
public class NewCarExample {public static void main(String[] args) {// IoC方式由外部模拟IoC容器创建并注入依赖Tire tire new Tire();Bottom bottom new Bottom(tire); // Bottom依赖TireFramework framework new Framework(bottom); // Framework依赖BottomCar car new Car(framework); // Car依赖Frameworkcar.run();}
}// Car.java
public class Car {private Framework framework;// 通过构造函数注入依赖public Car(Framework framework) {this.framework framework;System.out.println(Car create...);}public void run() {System.out.println(Car run...);framework.run();}
}// Bottom.java
public class Bottom {private Tire tire;// 通过构造函数注入依赖public Bottom(Tire tire) {this.tire tire;System.out.println(Bottom create...);}public void run() {System.out.println(Bottom run...);tire.run();}
}// Tire.java
public class Tire {public Tire() {System.out.println(Tire create...);}public void run() {System.out.println(Tire run...);}
}// Framework.java
public class Framework {private Bottom bottom;// 通过构造函数注入依赖public Framework(Bottom bottom) {this.bottom bottom;System.out.println(Framework create...);}public void run() {System.out.println(Framework run...);bottom.run();}
}代码如上图所示我们看到各个类之间不再直接依赖而是通过构造器注入的方式将依赖对象从外部传入。这使得各个类之间的耦合度大大降低了并且可以非常容易地进行替换模拟或真实对象。当然离真正的IoC容器还有很长的路要走但思想已经非常接近了。
现在我们再来理一下Car依赖FrameworkFramework依赖BottomBottom依赖Tire那么整个依赖关系是
依赖关系与IoC容器示意图
#mermaid-svg-U4528BzB2Zop9tCi {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-U4528BzB2Zop9tCi .error-icon{fill:#552222;}#mermaid-svg-U4528BzB2Zop9tCi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-U4528BzB2Zop9tCi .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-U4528BzB2Zop9tCi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-U4528BzB2Zop9tCi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-U4528BzB2Zop9tCi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-U4528BzB2Zop9tCi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-U4528BzB2Zop9tCi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-U4528BzB2Zop9tCi .marker.cross{stroke:#333333;}#mermaid-svg-U4528BzB2Zop9tCi svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-U4528BzB2Zop9tCi .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-U4528BzB2Zop9tCi .cluster-label text{fill:#333;}#mermaid-svg-U4528BzB2Zop9tCi .cluster-label span{color:#333;}#mermaid-svg-U4528BzB2Zop9tCi .label text,#mermaid-svg-U4528BzB2Zop9tCi span{fill:#333;color:#333;}#mermaid-svg-U4528BzB2Zop9tCi .node rect,#mermaid-svg-U4528BzB2Zop9tCi .node circle,#mermaid-svg-U4528BzB2Zop9tCi .node ellipse,#mermaid-svg-U4528BzB2Zop9tCi .node polygon,#mermaid-svg-U4528BzB2Zop9tCi .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-U4528BzB2Zop9tCi .node .label{text-align:center;}#mermaid-svg-U4528BzB2Zop9tCi .node.clickable{cursor:pointer;}#mermaid-svg-U4528BzB2Zop9tCi .arrowheadPath{fill:#333333;}#mermaid-svg-U4528BzB2Zop9tCi .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-U4528BzB2Zop9tCi .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-U4528BzB2Zop9tCi .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-U4528BzB2Zop9tCi .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-U4528BzB2Zop9tCi .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-U4528BzB2Zop9tCi .cluster text{fill:#333;}#mermaid-svg-U4528BzB2Zop9tCi .cluster span{color:#333;}#mermaid-svg-U4528BzB2Zop9tCi div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-U4528BzB2Zop9tCi :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}TireBottomFrameworkCarIoC容器IoC容器是一个独立的模块它负责创建和管理所有的对象。当一个对象需要另一个对象时它不再自己去创建而是向IoC容器请求。IoC容器会负责创建所需的对象并将它们注入到请求对象中创建实例的时候不需要了解其中的细节, 降低了使用双方的的依赖程度,这样对象之间就解耦了。
Framework、Bottom、Tire和Car现在都变成了“被动”的对象它们不再主动去创建自己的依赖对象而是等待IoC容器将依赖对象注入进来。这种“被动”的特性就是IoC的核心思想。
IoC容器就像一个中央工厂负责管理所有对象的生命周期和依赖关系。当应用程序需要某个对象时只需向IoC容器声明其需求IoC容器就会负责创建该对象及其所有依赖并将其注入到应用程序中。
DI DI: Dependency Injection(依赖注入) 容器在运行期间,动态的为应用程序提供运行时所依赖的资源称之为依赖注入。 从这一点来看依赖注入DI和控制逆转IoC是从不同的角度所描述的同一件事依赖注入是 从应用程序的角度来描述指通过引入IoC容器利用依赖关系注入的方式实现对象之间的解耦
简单使用
Component 的作用
Component 就像给你的类贴上一个“标签”告诉Spring “嘿Spring我是一个组件请你管理我并且在需要的时候可以把我的实例提供给别人。”
当Spring扫描到带有Component注解的类时它就会
创建并管理这个类的实例对象。将这个实例放入它的“容器”中随时准备被其他地方使用。
Autowired 的作用
Autowired 就像一个“请求”告诉Spring “嘿Spring我这里需要一个你管理的某个类型的对象比如一个BookDao请你把它“送”给我”
Spring收到这个请求后就会从它管理的众多组件中找到一个匹配的然后自动把它赋值给你的变量。
结合 Component 和 Autowired 的DI流程 定义组件Component: Component // 告诉Spring我是BookDao请你管理我
public class BookDao {// ... 提供数据的方法
}Component // 告诉Spring我是BookService请你管理我
public class BookService {// ... 处理业务逻辑的方法
}现在BookDao 和 BookService 的实例都由Spring创建和管理了。 注入依赖Autowired: Component
public class BookService {Autowired // 告诉Spring我需要一个BookDao请你给我private BookDao bookDao; // Spring会自动把BookDao的实例赋值给它// ...
}RestController // RestController也包含了Component的功能所以Spring也会管理它
public class BookController {Autowired // 告诉Spring我需要一个BookService请你给我private BookService bookService; // Spring会自动把BookService的实例赋值给它// ...
}BookService 不再自己 new BookDao()而是声明它需要一个 BookDaoSpring会注入进来。BookController 不再自己 new BookService()而是声明它需要一个 BookServiceSpring会注入进来。
最终效果 各个类BookController、BookService、BookDao之间不再直接创建对方的实例而是通过Spring这个“中间人”来获取它们需要的依赖。这使得代码
更松散类与类之间不再紧密耦合。更灵活可以轻松替换依赖的实现。更容易测试测试时可以注入模拟的依赖。
深入介绍文章 IoC详细介绍 here DI详细介绍here
