spring的控制反转和依赖注入讲解
1.Spring
1.1 简介
2002年首次推出Spring的雏形,interface21框架
2004正式发布1.0版本
解决企业应用开发的复杂性,其理念是使现有的技术更加容易使用!
SSH:Struct2+Spring+Hibernate
SSM:SpringMvc+Spring+Mybatis
官网:Spring Framework
下载地址: http://repo.spring.io/release/org/springframework/spring
文档:Overview (Spring Framework 5.2.22.RELEASE API)
github地址:spring-projects/spring-framework: Spring Framework (github.com)
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.1.RELEASE</version>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.1.RELEASE</version>
</dependency>
1.2 优点
Spring是开源的免费的容器!
是一个轻量级的非入侵式的框架!
控制反转(IOC),面向切面编程(AOP)
支持事务的处理,对框架整合的支持!
1.3 组成
1.4 扩展
Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot快速开发微服务
- 约定大于配置
Spring Cloud
- Spring Cloud是基于SpringBoot实现
学习SpringBoot的前提是学习Spring和SpringMVC
2、IOC理论推导
原来的写法:
1.UserDao接口
2.UserDaoImpl实现类
3.UserService业务接口
4.UserServiceImpl实现类
在之前的业务中,用户的需求会影响代码,根据用户需求修改原代码成本非常高!
我们使用一个Set接口实现,使用set注入后,程序不再具有主动性
Dao层的实现类:
public class UserDaoImpl implements UserDao{@Overridepublic void getUser() {System.out.println("获取用户数据");}
}public class UserSqlServerImpl implements UserDao{@Overridepublic void getUser() {System.out.println("sqlserver 获取用户数据");}
}
Service层,不需要写死dao层的代码:
private UserDao userDao;//利用set进行动态实现值的注入!public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void getUser() {userDao.getUser();}
测试:
public class MyTest {public static void main(String[] args) {//用户调用是业务层,dao层不需要接触UserServiceImpl userService = new UserServiceImpl();userService.setUserDao(new UserSqlServerImpl());userService.getUser();}
}
控制反转(主动权变了,程序不再具有主动性,变成被动接受对象)这种思想,从本质上解决了问题,程序员不用再去管理对象的创建了。系统的耦合性大大降低
IOC本质:
控制反转IOC(Inversion of Control)是一种设计思想,DI(依赖注入)是实现ioc的一种方法,所谓的控制反转就是:获得依赖对象的方式反转了
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式,在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入(DI)
3、HelloSpring
public class Hello {private String str;public String getStr() {return str;}public void setStr(String str) {this.str = str;}@Overridepublic String toString() {return "Hello{" +"str='" + str + '\'' +'}';}
}
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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--使用spring来创建对象,在spring都称为bean类型 变量名 = new Hello()id = 变量名class = new 的对象property相当于给对象中的属性设置一个值ref:引用spring容器中创建好的对象value:具体的值--><bean id="hello" class="com.liu.pojo.Hello"><property name="str" value="Spring"/></bean></beans>
测试:
import com.liu.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class MyTest {public static void main(String[] args) {//获取spring的上下文对象ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//对象都在spring中的管理了,直接取出来使用Hello hello = (Hello) context.getBean("hello");System.out.println(hello.toString());}
}
思考问题:
Hello对象是谁创建的?
hello对象是Spring创建的
Hello对象的属性是怎么设置的?
hello对象的属性由Spring容器设置的
创建bean的时候就创建了对象
这个过程就叫控制反转(原来需要我们new一个对象,现在由容器生成,我们只用从容器中拿即可)
控制:谁来控制对象的创建,传统应用程序的对象由程序本身控制创建的,使用spring后,对象由spring来创建
反转:程序本身不创建对象,变成被动的接收对象
依赖注入:利用set方法进行注入
IOC是一种变成思想,由主动的变成变成被动的接收,由spring创建,管理
4、IOC创建对象的方式
1.使用无参构造方法创建对象!默认实现
package com.liu.pojo;public class User {private String name;public User(){System.out.println("User的无参构造!");}public String getName(){return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user" class="com.liu.pojo.User"><property name="name" value="liuxiang"/></bean></beans>
public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");User user = (User) context.getBean("user");System.out.println(user);}
}
2.通过有参构造实现
- 下标赋值
<!--下标赋值--><bean id="user" class="com.liu.pojo.User"><constructor-arg index="0" value="liuxiang"/></bean>
- 类型赋值(不建议使用)
<bean id="user" class="com.liu.pojo.User"><constructor-arg type="java.lang.String" value="liuxiang"/>
</bean>
- 通过参数名
<bean id="user" class="com.liu.pojo.User"><constructor-arg name="name" value="刘想"/>
</bean>
5、Spring配置
5.1 别名
<alias name="user" alias="llx"/>
5.2 Bean的配置
id:bean的唯一标识符,相当于对象名
class:bean对象所对应的全限定名(包名+类型)
name:别名,更高级,可以取多个别名(空格,逗号,分号都可以分隔)
5.3 import
一般用于团队开发,可以将多个配置文件导入合并为一个
applicationContext.xml总的配置文件:
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
6、依赖注入
6.1 构造器注入
无参有参构造器注入:
<bean id="user" class="com.liu.pojo.User"><property name="name" value="liuxiang"/></bean>
<bean id="user" class="com.liu.pojo.User"><constructor-arg name="name" value="刘想"/>
</bean><bean id="user" class="com.liu.pojo.User"><constructor-arg type="java.lang.String" value="liuxiang"/>
</bean>
6.2 set注入(重点)
依赖注入:set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性由容器来注入
环境搭建:
- 复杂类型
public class Address {private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +'}';}
}
- 真实测试
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private Properties info;
- 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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="address" class="com.liu.pojo.Address"><property name="address" value="深圳"/></bean><bean id="student" class="com.liu.pojo.Student"><!--第一种,普通的value值--><property name="name" value="刘想"/><!--第二种,bean注入--><property name="address" ref="address"/><!--数组注入--><property name="books"><array><value>Java核心</value><value>Go语言</value><value>黑客技术</value><value>JVM</value></array></property><!--List--><property name="hobbys"><list><value>听歌</value><value>游戏</value><value>音乐</value></list></property><!--map--><property name="card"><map><entry key="身份证" value="421023111111112222"/><entry key="手机号" value="17777776666"/></map></property><!--set--><property name="games"><set><value>lol</value><value>吃鸡</value><value>王者</value></set></property><!--Properties--><property name="info"><props><prop key="driver">com.mysql.driver</prop><prop key="url">jdbc//mysql:3306</prop><prop key="username">root</prop><prop key="password">123456</prop></props></property></bean></beans>
- 测试类
public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");Student student = (Student) context.getBean("student");System.out.println(student);}
}
- 结果
Student{name='刘想',
address=Address{address='深圳'},
books=[Java核心, Go语言, 黑客技术, JVM],
hobbys=[听歌, 游戏, 音乐],
card={身份证=421023111111112222, 手机号=17777776666},
games=[lol, 吃鸡, 王者],
info={password=123456,url=jdbc//mysql:3306,driver=com.mysql.driver,username=root}}
6.3 扩展方式注入
- P命名注入(就是property)
导入头文件约束:
<beans
xmlns:p="http://www.springframework.org/schema/p"
</beans>
可以注入属性的值!
- c命名空间
就是构造器注入!
导入头文件约束:
<beans
xmlns:p="http://www.springframework.org/schema/c"
</beans>
7、Bean作用域
单例模式(Spring默认机制):全局共享唯一,创建的对象都是一样的
<bean id="user2" class="com.liu.pojo.User" c:age="18" c:name="刘想" scope="singleton"/>
原型模式:创建的对象不一样,每次从容器get的时候都会产生新对象!
<bean id="user2" class="com.liu.pojo.User" c:age="18" c:name="刘想" scope="prototype"/>
其余的request、session、application这些只能在web开发中使用!
spring的控制反转和依赖注入讲解相关推荐
- SSM框架—Spring基础—控制反转和依赖注入(概念)
控制反转: 控制反转(IoC)是面向对象编程的一个设计原则,用于降低代码耦合度 在传统面向对象编程中,获取对象的方式是用关键字"new"主动创建一个对象,也就是说,应用程序掌握着对 ...
- Spring的控制反转与依赖注入
学习过Spring的都知道Spring有三大核心的概念,分别是控制反转(IOC).依赖注入(DI)和面向切面编程(AOP).今天就来聊聊我对控制反转和依赖注入的了解,至于面向切面编程放到后面讲解. 一 ...
- Spring中控制反转和依赖注入
Spring之IOC控制反转和DI依赖注入 1.控制反转是什么? IOC控制反转,所谓反转是指使用方本身不负责依赖对象的创建和维护,而将对象的管理(创建.维护.销毁)都交给Spring容器管理,在使用 ...
- Spring的控制反转以及依赖注入,控制反转使程序具有高拓展性。
1. 控制反转(Inversion of Control, IOC) 将对象的创建.赋值.管理交给容器(Spring),通过xml文件即可修改对象的属性,不必修改源代码,具有高拓展性.各个模块间的对象 ...
- Spring 中控制反转 和 依赖注入 的区别和关系
控制反转 (IOC),面向对象的一种设计原则,目的是降低耦合度.依赖注入(DI)是实现控制反转的常见方式,控制反转的另外一种实现方式是 依赖查找.控制反转中的控制指的是自己控制(创建)自己的成员变量, ...
- 轻松了解Spring中的控制反转和依赖注入
点击上方 "程序员小乐"关注公众号, 星标或置顶一起成长 每天早上8点20分, 第一时间与你相约 每日英文 When you have something you really l ...
- Spring容器,控制反转,依赖注入
Spring boot学习之旅,为更好督促自己学习以记之,仅供参考. spring容器 程序启动的时候会创建spring容器,扫描给spring容器一个清单,比如:@Controller, @Bean ...
- Spring框架中的控制反转和依赖注入
控制反转: 控制反转是用来降低代码之间的耦合度的,基本思想就是借助"第三方"实现具有依赖对象的解耦. 为什么需要控制反转,因为项目中对象或多或少存在耦合.控制反转的关键在于Ioc容 ...
- Spring Ioc/DI 控制反转和依赖注入
Ioc(Inversion of Control)和DI(Dependency Injection)的全称分别是控制反转和依赖注入. 如何理解这两个概念呢? Ioc Ioc(控制反转)实际上就说把对象 ...
最新文章
- 数据结构与算法课程的代码链接
- 北方股份无人驾驶矿卡_踏歌智行携手北方股份10台无人驾驶新车批量投产 | 合创投资...
- 美国12大科技公司如何参与自动驾驶?
- set OpenCV_ROOT
- 输入一个数寻找丑数C语言,数据结构与算法试题80道.doc
- 计算机考研学长学什么,研究生学长浅谈考研心得
- 阿里巴巴的五大平台野心,让“连接”论成为过去式
- 【2021最新版】如何clean或者install Maven项目——IntelliJ IDEA系列教程
- c iostream.源码_通达信指标公式源码精准买卖主图指标公式免费分享
- 批量下载,多文件压缩打包zip下载
- revit2018注册表删除_Revit软件的彻底卸载方法 注册表卸载
- python语言要多久_怎么自学python,大概要多久?
- Canto助力金融衍生品市场持续、健康、快速发展
- 上海税前12000税后多少_税前12000元月工资,税后能拿多少
- 家庭组网 光猫+交换机利用VLAN划分实现客厅IPTV机顶盒与上网路由器单线复用(上)
- 1143-最长公共子序列的长度和最长公共子序列
- 配置 JAVA_HOME
- Dropout层到底在干些什么(Pytorch实现)
- 智能加工技术案例分析
- myeclipse下用axis2开发web service
热门文章
- 视口文件html,视口.html
- 长尾词推广系统推荐乐云seo_AI万词霸屏系统-长尾词全网推广+主词SEO排名【since 2014】...
- English Learning - Day9 作业打卡 2022.12.15 周四
- 个人对YY教育的一些雄心解读 教育真的好改变吗?
- 南京晓庄学院计算机组成原理实验报告,2013-2014年第一学期南京晓庄学院计算机组成原理期末考试回忆版...
- linux装系统基本分区,Linux基础——系统分区
- Java、JSP网上汽车售票系统
- activemq之MessageConsumer.receive方法
- 特征分解,奇异值分解(SVD) 和隐语义模型(LFM)
- 转贴:一个初中毕业生到准WEB程序员的经历!