培训培训网站建设,属于公司的网站怎么做,徐州做网站的设计师,win7记事本做网站文章目录 一. Spring框架概述1. 什么是Spring框架2. 为什么要学习框架#xff1f;3. Spring框架学习的难点 二. Spring核心设计思想1. 容器是什么#xff1f;2. IoC是什么#xff1f;3. Spring是IoC容器4. DI#xff08;依赖注入#xff09;5. DL#xff08;依赖查找3. Spring框架学习的难点 二. Spring核心设计思想1. 容器是什么2. IoC是什么3. Spring是IoC容器4. DI依赖注入5. DL依赖查找 一. Spring框架概述
1. 什么是Spring框架
我们通常所说的 Spring 指的是 Spring FrameworkSpring 框架它是⼀个开源框架有着活跃而庞大的社区这就是它之所以能长久不衰的原因Spring 支持广泛的应用场景它可以让 Java 企业级的应用程序开发起来更简单。
用⼀句话概括 SpringSpring 框架是包含了众多工具方法的 IoC 容器。
2. 为什么要学习框架
因为学习框架相当于从“小作坊”到“工厂”的升级小作坊什么都要自己做工厂是组件式装配特点就是高效。
框架更加易⽤、简单且高效。
Servlet有以下痛点
添加外部 jar 不⽅便容易出错比如添加了⼀个不匹配的外部 jar 版本。运行和调试的时候需要配置 Tomcat 不⽅便。发布不方便Servlet 项目必须依靠外置的 Tomcat外置的 Web 容器运行。路由配置不方便⼀个访问地址对应⼀个 Servlet 类。…
而 Spring Boot 相比于 Servlet 具备以下优点
快速添加外部 jar 包。调试项目更方便无需配置 Tomcat点击“运行”按钮就可以直接运行项目因为 Spring Boot 内置了 Tomcat 容器可直接运行但是 Servlet 需外挂 Tomcat。发布项目更加方便无需配置 Tomcat使用 java -jar 方式就可以发布。对象自动装配。添加路由更加方便无需每个访问地址都添加⼀个类。…
3. Spring框架学习的难点
配置比较多。需要⼤量的外部 jar 包在下载时容易出错。会涉及简单的软件⼯程的设计思想分层思想前后端的分层思想后端工程的分层思想。知识点相对来说比之前的知识更加的分散要仔细听才能搞懂各个知识点的逻辑关系。要记的东西很多所以要大量地重复练习才能记住比如各种注解。
Spring框架基本学习应用路线Spring全家桶Spring/Spring Boot/Spring MVC) - MyBatis - Redis 等。
二. Spring核心设计思想
Spring 核心就是这么一句话Spring 框架是包含了众多工具方法的 IoC 容器。
那么这句话怎么理解呢什么是容器什么又是 IoC
1. 容器是什么
容器是用来容纳某种物品的基本装置。 ——来⾃百度百科
Java 中也有一些容器比如 ListMapSet 等这些集合是属于数据储存的容器它把我们常用的操作都封装到集合中了我们只需要知道集合为我们提供的方法就可以使用各种集合了还有 Tomcat 是属于 Web 容器同理 Spring 是就一个 IoC 容器它包含了许多的工具和方法。
2. IoC是什么
IoC 即 Inversion of Control直译过来就是控制反转的意思这是一种思想控制权反转在 Java 的常规代码中对象的生命周期是由当前代码程序员自己控制的而控制权反转就是对象的生命周期不再由当前代码片段来控制而是由 SpringIoC 容器来控制 。
这种思想还比较抽象我们来通过一个例子来了解它。
我们都知道汽车它包含轮胎底座车身等现在我们要造一辆汽车时需要有车身而车身需要有底座和轮胎最传统的思想就是造车时需要车身于是就new一个车身而车身需要底座于是就再new一个底座同理底座需要轮胎那就造底座前new一个轮胎。
我们可以得到以下代码
package old;/*** 传统开发方式, 耦合性问题*/
// 汽车类
public class Car {// 车身private Framework framework;public Car() {framework new Framework();}public void init() {System.out.println(do car);// 汽车的组建依赖于车身framework.init();}
}package old;// 车身类
public class Framework {private Bottom bottom;public Framework() {bottom new Bottom();}public void init() {System.out.println(do framework);// 车身的组建依赖于底盘bottom.init();}
}package old;// 底盘类
public class Bottom {private Tire tire;public Bottom() {tire new Tire();}public void init() {System.out.println(do bottom);// 底盘的组建依赖于轮胎tire.init();}
}package old;// 轮胎类
public class Tire {private int size 17; // 轮胎的尺寸public void init() {System.out.println(size - size);}
}package old;public class Test {public static void main(String[] args) {Car car new Car();car.init();}
}但是但上面的代码中轮胎的大小是固定写死的 然而随着对的车的需求量越来越大个性化需求也会越来越多这 时候我们就需要加⼯多种尺寸的轮胎那这个时候就要对上面的程序进行修改了根据我们上面写的代码我们需要往轮胎Tire类的构造方法加上一个参数由于底盘Bottom类控制着Tire类那么底盘类的构造方法也需要加上一个参数以此类推我们的车身Framework类与汽车Car类都需要为构造方法加上参数于是我们得到了如下的代码
package old;/*** 传统开发方式, 耦合性问题*/
// 汽车类
public class Car {// 车身private Framework framework;public Car(int size) {framework new Framework(size);}public void init() {System.out.println(do car);// 汽车的组建依赖于车身framework.init();}
}package old;// 车身类
public class Framework {private Bottom bottom;public Framework(int size) {bottom new Bottom(size);}public void init() {System.out.println(do framework);// 车身的组建依赖于底盘bottom.init();}
}package old;// 底盘类
public class Bottom {private Tire tire;public Bottom(int size) {tire new Tire(size);}public void init() {System.out.println(do bottom);// 底盘的组建依赖于轮胎tire.init();}
}package old;// 轮胎类
public class Tire {private int size 17; // 轮胎的尺寸public Tire(int size) {this.size size;}public void init() {System.out.println(size - size);}
}package old;public class Test {public static void main(String[] args) {Car car new Car(20);car.init();}
}此时如果需要个性化定制轮胎的大小就可以只改动构造Car对象传入的参数就可以了但是如果再加上加上一个需求还要定制轮胎的颜色那我们又要加参数此时就意味着像上面一样修改最底层的代码 整个调⽤链上的所有代码都需要修改。
这样的代码耦合性就太高了为了解决这个问题我们可以使用loC的思想来实现代码将控制权交出去也就是说IoC模式下我们不再自己构造创建对象当我们需要轮胎Tire类时你就给我传一个Tire对象我们不去new一个Tire对象了这样的话就算在Tire类加参数也只需要改动Tire类的构造方法与相关执行方法与属性顶多再改一下Tire对象的创建同理其他类也一样将对象作为参数传入到上级类的构造方法中去就行了但此时其他类是不需要修改的这个过程也叫做传入或注入。 由于我们创建Car时需要Framework所以先要实例一个Framework对象同理实例一个Framework对象需要Bottom对象那么需先实例一个Bottom对象一样在实例Bottom对象之前需要实例一个Tire对象于是需要先后创建Tire对象Bottom对象Framework对象后才能创建一个Car对象我们可以得到如下的代码
package ioc;public class Car {// 汽车的组建依赖于车身的组建private Framework franmework;public Car(Framework franmework) {this.franmework franmework;}public void init() {System.out.println(do car...);franmework.init();}
}package ioc;public class Framework {// 车身的组建依赖于底盘private Bottom bottom;public Framework(Bottom bottom) {this.bottom bottom;}public void init() {System.out.println(do franmework);bottom.init();}
}package ioc;public class Bottom {// 底盘的组建依赖于轮胎private Tire tire;public Bottom(Tire tire) {this.tire tire;}public void init() {System.out.println(do bottom...);tire.init();}
}package ioc;public class Tire {private int size 17;private String color 黑色;public Tire(int size, String color) {this.size size;this.color color;}public void init() {System.out.println(size - size);System.out.println(color- color);}
}package ioc;public class IOCDemo {// 这里的内容包含就相当于是 IoC 容器做的事情// 对象的生命周期控制权就翻转给 IoC 容器了, 不再由程序员控制private Tire tire;private Bottom bottom;private Framework framework;public Car car;public IOCDemo() {tire new Tire(17, 红色);bottom new Bottom(tire);framework new Framework(bottom);car new Car(framework);}
}package ioc;/*** 模拟 IoC 容器*/
public class Test {public static void main(String[] args) {// 直接使用, 创建就交给IoC了IOCDemo ioc new IOCDemo();Car car ioc.car;car.init();}
}此时如果要变需求需要加参数或减少参数IoC 的代码只需改动图中的两处代码即可 整个调用链是不用做任何改变的 达到了解耦的目的。 在传统的代码中对象创建顺序是Car - Framework - Bottom - Tire 改进之后解耦的代码的对象创建顺序是Tire - Bottom - Framework - Car
到这里我们就可以发现传统的代码类创建顺序是反着的Car 控制 FrameWorkFrameWork 控制着 BottomBottom 控制着 Tire而改进之后的控制权发生了反转是下层将对象注入到当前对象当中下级的控制权不再由上级控制了下级在发生改变时会将改变完成后的对象注入上级这样上级就是不受影响的这就是 IoC 的实现思想。
所以 IoC 有以下的优点对象Bean的生命周期交给 IoC 框架维护作为程序员无需关注说白了就是程序员不需要关注对象创建、销毁时机以及对象的依赖关系这些工作加个 IoC 框架也就是 Spring做就行实现了代码的解耦对象的使用更加方便高效。
3. Spring是IoC容器
Spring 框架就是包含了多个工具方法的 IoC 容器既然是容器那它就有存和取的功能这也是 Spring 最核心的两个功能
将 Bean对象存储到 Spring 容器中。将 Bean对象从 Spring 容器中取出来。
将对象存放到容器有什么好处呢? 将对象存储到 IoC 容器相当于我们将所有可能用到的工具制作好都放到仓库当我们需要使用时直接取即可用完归还仓库而 new 对象的方式相当于我们每次需要用工具的时候现场制作制作完了扔掉下次需要的时候重新做。
Spring 是⼀个 IoC 容器说的是对象的创建和销毁的权利都交给 Spring 来管理了它本身⼜具备了存储对象和获取对象的能力。
4. DI依赖注入
DI即Dependency Injection依赖注入。
所谓依赖注⼊就是由 IoC 容器在运行期间动态地将某种依赖关系注入到对象之中在pom.xml有一个依赖项就是用来导入外部的资源而这里的依赖注入导入的不是外部的资源而是对象当某个 Java 实例需要另一个 Java 实例时创建被调用者的工作不是由调用者实现而是由 Spring 容器来完成然后注入调用者因此称为依赖注入。
IoC 与 DI 的区别是什么
依赖注入DI和控制反转IoC是从不同的角度的描述的同⼀件事情就是指通过引入 IoC 容器利用依赖关系注入的方式实现对象之间的解耦。
IoC 是“目标”也是⼀种思想而目标和思想只是⼀种指导原则最终还是要有可行的落地方案而 DI 就属于具体的实现也就是说IoC 是一种思想而 DI 是 IoC 的一种实现。
5. DL依赖查找
DL即Dependency Lookup依赖查找也是 IoC的一种实现。
依赖查找和依赖注入的区别在于依赖注入是将依赖关系委托给容器由容器来管理对象之间的依赖关系容器外部是不关心这种依赖关系的需要时由容器判断提供什么而依赖查找是由对象自己来查找它所依赖的对象容器只负责管理对象的生命周期也就是说此时需要容器外部自己确定要容器提供哪种依赖关系两者之间是主动和被动的区别。
