Spring-IOC入门理解
新建一个Maven工程
![](/assets/blank.gif)
在pom文件中导入需要的依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.lps</groupId><artifactId>Spring-002-first</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><!-- 依赖--><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.23</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency></dependencies><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target></properties>
</project>
我这里用jdk17
![](/assets/blank.gif)
可以ctrl+shift+ait+s调出structure进行jdk的配置 看个人使用情况配置
![](/assets/blank.gif)
public class User {//默认情况下spring通过反射机制 调用类的无参构造方法来实例化对象//实现原理如下//Class hhh = Class.forName("com.lps.bean.User");//hhh.newInstance();public User() {System.out.println("User的无参构造方法执行");}//当我们定义了有参构造器 无参构造器就无法实例了 所以记得定义下无参//No default constructor found;// nested exception is java.lang.NoSuchMethodException: com.lps.bean.User.<init>()public User(User u) {System.out.println("User的无参构造方法执行");}}
public class Vip {public Vip() {System.out.println("vip的无参构造器运行");}
}
public class UserDaoImplForMysql {public UserDaoImplForMysql() {}public void insert(){System.out.println("刘品水正在使用mysql保存信息");}
}
接下来是spring的xml配置
spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- id是bean的身份证号 不能重复 是唯一的标识--><bean id="userBean" class="com.lps.bean.User"></bean><!-- <bean id="userBean" class="com.lps.bean.Vip"></bean>--><!-- spring--><bean id="UserDaoImplForMysql" class="com.lps.dao.UserDaoImplForMysql"></bean></beans>
bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- id是bean的身份证号 不能重复 是唯一的标识--><bean id="userBean" class="com.lps.bean.User"></bean>
<!-- <bean id="userBean" class="com.lps.bean.Vip"></bean>-->
<!-- spring--><bean id="UserDaoImplForMysql" class="com.lps.dao.UserDaoImplForMysql"></bean></beans>
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="vip0" class="com.lps.bean.Vip"></bean><bean id="userBean" class="com.lps.bean.User"></bean><bean id="UserDaoImplForMysql0" class="com.lps.dao.UserDaoImplForMysql"></bean><!-- 配置java.util.Data Bean--><bean id="nowTime" class="java.util.Date"></bean></beans>
最后写一个测试类来感受IoC的好处即可
package com.lps.test;import com.lps.bean.User;
import com.lps.dao.UserDaoImplForMysql;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import java.text.SimpleDateFormat;
import java.util.Date;/*** ClassName: FirstSpringTest* Description:* Date: 2022/11/18 22:07* <author> <time> <version> <desc>* 刘品水 2022/11/18 22:07 @Version 1.0 描述*/
public class FirstSpringTest {@Testpublic void testBeginInitBean(){//执行以下代码就会执行实例化对象了 并不是getBean()方法调用的时候new ClassPathXmlApplicationContext("spring.xml");}@Testpublic void testBeanFactory(){//ApplicationContext接口的超级父类是BeanFactory(Bean工厂)//BeanFactory是IoC容器的顶级接口//Spring的IoC容器底层使用了;工厂模式//Spring底层的IoC是通过:XML解析、工厂模式、反射机制BeanFactory context = new ClassPathXmlApplicationContext("spring.xml");User bean = context.getBean("userBean", User.class);System.out.println(bean);}@Testpublic void testXmlPath(){FileSystemXmlApplicationContext context//= new FileSystemXmlApplicationContext("G:/JavaProject/Spring/beans.xml");= new FileSystemXmlApplicationContext("G:\\JavaProject\\Spring\\beans.xml");//用途不同//1、“\”:“\”只能用来表示目录。//2、“/”:“/”技能作为除法符号或者间隔符号使用,也能用来表示目录。Date nowTime = context.getBean("nowTime", Date.class);SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:ss:SSS");String nowtime = format.format(nowTime);System.out.println(nowtime);}@Testpublic void testFirstSpringCode(){//ApplicationContext应用上下文 spring容器 是一个接口 有很多实现类 其中有一个叫ClassPathXmlApplicationContext//ClassPathXmlApplicationContext:专门从类路径加载spring配置文件的spirng上下文对象/*ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml","bean.xml");*/ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml","bean.xml","xml/beans.xml");//这段代码只要执行 相当于启动了spring容器 解析spring.xml文件 实例化所有的spring文件Object userBean = applicationContext.getBean("userBean");System.out.println(userBean);Object userDaoImplForMysql = applicationContext.getBean("UserDaoImplForMysql");System.out.println(userDaoImplForMysql);System.out.println("===========================================");/* ClassPathXmlApplicationContext classPathXmlApplicationContext= new ClassPathXmlApplicationContext("bean.xml");*///根据public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {// this(configLocations, true, (ApplicationContext)null);// }//所以后面可以直接跟着写,"bean.xml" 可以指定多个路径Object vip = applicationContext.getBean("vip");Object userDaoImplForMysql1 = applicationContext.getBean("UserDaoImplForMysql");System.out.println(userDaoImplForMysql1);System.out.println(vip);System.out.println("==========");Object vip0 = applicationContext.getBean("vip0");System.out.println(vip0);System.out.println("----------------------------");
// Object nowTime = applicationContext.getBean("nowTime");
// Date nowTime = (Date)applicationContext.getBean("nowTime");//不想强制转换可以这样做Date nowTime = applicationContext.getBean("nowTime", Date.class);System.out.println(nowTime);SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:ss:SSS");String format = simpleDateFormat.format(nowTime);System.out.println("北京时间现在是:"+format);System.out.println("=====================");//强转之后可以调用UserDaoImplForMysql的方法UserDaoImplForMysql userDaoImplForMysql2 = applicationContext.getBean("UserDaoImplForMysql", UserDaoImplForMysql.class);userDaoImplForMysql2.insert();}
}
BeanFactory是IoC容器的顶级接口
![](/assets/blank.gif)
***OCP***
Open-Closed Principle软件设计中的“开-闭原则”
这个原则最早是由Bertrand Meyer提出,英文的原文是:Software entities should be open for extension,
but closed for modification.
意思是说,一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,
换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为.
满足OCP的设计给系统带来两个无可比拟的优越性.
1.通过扩展已有的软件系统,可以提供新的行为,以满足对软件的新需求,使变化中的软件系统有一定的适应性和灵活性.
2.已有的软件模块,特别是最重要的抽象层模块不能再修改,这就使变化中的软件系统有一定的稳定性和延续性.
例如:
编程模式中的工厂模式的“工厂方法”支持OCP原则
对扩展开放 对修改关闭
***DIP***
依赖倒置原则(dependency inversion principle)
面向接口编程 面向抽象编程 不要面向具体编程
降低耦合度 提高扩展力
表现层 业务层 持久层不再从上往下依赖
***IOC***
核心概念
1. IoC(Inversion of Control)控制反转
使用对象时,由主动new产生对象转换成,从外部提供对象
在这个过程中,对象的创建控制权由程序转移到外部,此思想称为控制反转。用来减低计算机代码之间的耦合度。
***Spring框架***
*Spring框架实现了控制反转IoC这种思想。
Spring可以帮你new对象
Spring框架可以帮你维护对象和对象之间的关系。
*Spring是一个实现了IoC思想的容器。
*控制反转的实现方式很多种,其中比较重要的依赖注入(Dependency Injection,简称DI),
*还有一种方式叫“依赖查找”(Dependency Lookup)。通过控制反转,对象在被创建的时候,
*由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说,依赖被注入到对象中。
**依赖注入DI 常见的两种方式
!!!set注入、构造方法注入!!!
依赖:A对象与B对象之间的关系
注入:是一种手段 通过这种手段可以让A对象与B对象产生关系。
依赖注入:对象A和对象B之间的关系,靠注入的手段来维护,为注入包括:set注入和构造器注入
***本节术语
OCP:开闭原则
IOC:控制反转
DIP:依赖倒置
DI:依赖注入
个人总结使用对象时通常是使用new但是如此耦合性太搞了 使用spring就是将对象的创建控制权全部交给Spring来处理 我们只需要设置spring的东西即可
Spring-IOC入门理解相关推荐
- 谈谈对Spring IOC的理解
2019独角兽企业重金招聘Python工程师标准>>> 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人 ...
- 谈谈我对Spring IOC的理解
学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家 ...
- 浅谈Spring IOC的理解
浅谈Spring IOC的理解 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊 ...
- Spring IOC的理解总结
1.1.IoC是什么 Ioc-Inversion of Control,即"控制反转",不是什么技术,而是一种设计思想.在Java开发中,Ioc意味着将你设计好的对象交给容器控制, ...
- 对Spring IOC的理解
1.2.IoC能做什么 IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合.更优良的程序.传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间 ...
- 谈谈Spring Ioc的理解
原文:http://blog.csdn.net/qq_22654611/article/details/52606960 学了几天Ioc了,但是对它的理解还是模模糊糊,看了这篇博客感觉对Ioc有了更深 ...
- Spring IOC的理解
一.IOC的理解 控制反转:一种设计理论思想.把对象的管理交给Spring进行,不再是原来的使用者自行管理. DI依赖注入:把对应属性值注入到具体对象中,如@Autowired完成属性值注入. 容器: ...
- Spring IOC入门(上)
Spring IOC(上) 一.什么是IOC 概念 IOC即 Inversion of Control,译为控制反转. IoC is also known as dependency injectio ...
- Spring IoC的理解----找女朋友的方法
Spring IoC,控制反转的意思. 1.传统的对象之间的引用是这样的:对象A需要用到对象B的时候,就主动去创建一个对象B.就如我们传统的找女朋友方法一样,当我们需要找女朋友的时候,会主动的去找符合 ...
- 对Spring IOC的理解(转)
Ioc-Inversion of Control,即"控制反转",不是什么技术,而是一种设计思想.在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象 ...
最新文章
- Linux下代码运行不了?看这里设置环境变量
- 滴滴大整改:9月8日至15日暂停深夜叫车服务
- python主要用于后端开发还是前端,Django是用于前端还是后端?
- CSP认证201604-4	游戏[C++题解]:bfs、拆点、迷宫问题加强版、三维数组
- Java爬取校内论坛新帖
- [译] RNN 循环神经网络系列 2:文本分类
- 收藏 | 有没有什么可以节省大量时间的 Deep Learning 效率神器?
- 019.nexus搭建docker镜像仓库/maven仓库
- 跨语言之间的socket通信(C--Java的握手)(基础篇转)
- 松露菌行业调研报告 - 市场现状分析与发展前景预测
- Python菜鸟入门:day06元组与字典
- 【备忘】mysql常用操作汇总
- 坐高铁只能用身份证了?
- Ubuntu下改变键盘映射
- cos(a-b)=cosa*cosb+sina*sinb的推导过程
- sphinxapi.php 详解,【转】Sphinx PHP api全文检索的例子
- 计算机组成原理00h,计算机组成原理 (2).doc
- 2021年全球专业油田化学品收入大约34600百万美元,预计2028年达到41640百万美元
- RF在智能座舱测试中的应用
- canvas实现粒子跟随鼠标动画