Spring 的控制反转/依赖注入
第一章 Spring 的控制反转/依赖注入
回顾
增删改查。
课前测：
本章内容
spring:春天 IOC：将创建对象的权力交给 spring 核心容器去控制。工厂模式
BeanFactory: 懒汉
ApplicationContext: 饿汉
< bean id="" name="" class="" scope="" >
getBean的三种方式： id 类型 id+类型
创建对象的三种方式：1.默认使用无参构造创建 2.使用工厂静态方 3.实例方法
生命周期：
单例对象：关闭容器时，销毁对象
多利对象：GC垃圾回收机制 (守护线程)
第一节：Spring 春天
控制：对象的创建。
控制反转：将创建对象的权力交给 spring 核心容器去控制。
1.简介
框架：半成品软件，由美国技术大拿开发.
spring 生态圈,spring全家桶（spring MVC boot cloud data security)
SSM : spring springMVC Mybatis
srpringboot cloud
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IOC（Inverse Of Control:控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
MVC model view controller=====>三层架构 service
模型(实体和dao) 视图(jsp) 控制器(servlet)—>
三层架构：
展现层web：controller（页面的跳转）,jsp（页面）
持久层：dao （数据操作）
业务层：service (业务逻辑)
2.Spring的发展历程
1997 年 IBM 提出了 EJB 的思想
1998 年，SUN 制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson（spring 之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了 J2EE 使用 EJB 开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了 J2EE 开发不使用 EJB 的解决方式（Spring 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）
3. Spring的优点
servlet调用dao
BookDao bookdao = new BookDaoImpl();
- 方便解耦，简化开发
通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造
成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可
以更专注于上层的应用。
- AOP 编程的支持
通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以
通过 AOP 轻松应付。
- 声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，
提高开发效率和质量。
- 方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可
做的事情。
方便集成各种优秀框架
Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
微软（邪教) J++ SunPK(正教人多，分散，谁都听谁的,Spring第三方框架，IBM HP EMC 通用 宇通等)
Spring崛起把微软干趴下了
- 降低 JavaEE API 的使用难度
Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的
使用难度大为降低。
- Spring 源码是经典学习范例
Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以
及对 Java 技术的高深造诣。它的源代码无疑是 Java 技术的最佳实践的范例。
4.Spring的体系结构
javaBean
模块
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。
ORM 持久层框架
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bRxjDwbz-1645885880916)(assets/HemWeNoCPcQvsarJ.png!thumbnail)]
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是
BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。Spring 上下文：Spring 上下文是一个配置文件xml，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。
第二节：Spring的IOC控制反转
1.为什么要用 Spring
目的：降低耦合：对象与对象之间的耦合。
举个栗子：
如何解决这个问题呢？使用工厂模式解决。
代码改过后并没有完成我们的目的。此时如果将Food变成了Food1还是要一个一个修改。
如何解决？使用接口的多态。
2.程序的耦合 (课下自己看)
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。
它有如下分类：
（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
**总结：**耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
3. 解决方案（IOC控制反转）
什么是IOC ?
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。使用对象的时候不再是我们直接new，而是将创建对象的权利交给框架中的核心容器，需要使用对象的时候直接从容器中获取。
IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前 大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题 ，所以他将自己框架的名字命名为 Spring 告诉全世界 冬天过去了 春天来了）。
第三节：spring项目的搭建
1.1 下载jar包
官网：http://spring.io/
下载地址：https://repo.springsource.org/libs-release-local/org/springframework/spring
现在Spring–>生态圈（全家桶）
解压:
(Spring 目录结构:)
* docs :API 和开发规范。
* libs :jar 包和源码。
*schema :约束。
创建项目并导入jar包
1.2 配置bean.xml文件
1.3 编写测试代码并运行
测试类中可以通过两种方式获取Bean对象的创建。
参考以下，两个接口的区别：
输出结果，可以观察到对象的创建,方法的调用
2.spring对Bean对象的管理细节
spring的核心组件：BeanFactory 接口 和 ApplicationContext接口
两者功能类似。
2.1 ApplicationContext 和BeanFactory 两个接口的区别
spring工厂中类的结构图。
BeanFactory接口
Spring容器顶层接口：获取Bean对象;管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
BeanFactory接口包含以下基本方法——ApplicationContext肯定都有，因为他是子接口，加强版
boolean containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true。Object getBean(String str)返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常。Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型Class getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式 String[] getAliases(String name) 返回给定bean名称的所有别名ApplicationContext接口
是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件 事件传递载入多个配置文件等 实现类常见有三个
ClassPathXmlApplicationContext：-classpath路径加载xml文件的
FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的
AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。
package com.aaa.qy127.controller;import com.aaa.qy127.service.SpringService;
import com.aaa.qy127.service.impl.SpringServiceImpl;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;/*** @ClassName SpringTest* @Description ToDo* @Auther teacher Bai* @Date 2020/12/19 10:31*/
public class SpringTest {public static void main(String[] args) {//这是使用自己new 对象的方式创建对象//SpringService service = new SpringServiceImpl();/*使用读取bean.xml的方式 创建对象首先需要读取bean.xml文件怎么读？1.使用BeanFactory（spring核心容器的顶层接口）2.使用BeanFactory的子接口 ApplicationContext(自接口功能更加强大) 常用！*//*** 1.使用BeanFactory（spring核心容器的顶层接口）* ① 读取bean.xml配置文件* ClassPathResource resource = new ClassPathResource("bean.xml");* ② 读取第①步中bean.xml文件中的信息* XmlBeanFactory factory = new XmlBeanFactory(resource);* ③ 通过获取到的factory取出bean对象* Object service1 = factory.getBean("service1");*/ClassPathResource resource = new ClassPathResource("bean.xml");XmlBeanFactory factory = new XmlBeanFactory(resource);Object service1 = factory.getBean("service1");SpringService service = (SpringServiceImpl) service1;service.print1();/*** 2.使用BeanFactory的子接口 ApplicationContext(自接口功能更加强大) 常用！* ① 读取bean.xml配置文件* 使用ClassPathXmlApplicationContext实现类 （类路径下的bean.xml）* ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");* 使用FileSystemXmlApplicationContext实现类 读取文件 （文件系统路径下的bean.xml）* ApplicationContext context = new FileSystemXmlApplicationContext("E:\\课堂笔记\\QY127\\spring\\Spring01-IOC和DI\\spring-02\\src\\bean.xml");* ② 通过获取到的context取出bean对象* SpringService service1 = (SpringServiceImpl)context.getBean("service1");**///ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");ApplicationContext context = new FileSystemXmlApplicationContext("E:\\课堂笔记\\QY127\\spring\\Spring01-IOC和DI\\spring-02\\src\\bean.xml");SpringService service1 = (SpringServiceImpl)context.getBean("service1");service1.print1();}
}
面试题：BeanFactory 和 ApplicationContext 的区别：
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
单例模式下创建对象的时间点不一样：
ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象。
BeanFactory：(懒加载/懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。
2.1.1 Spring中的测试函数使用
@Testpublic void test01(){ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");People bean = context.getBean(People.class);System.out.println(bean);}我们使用 Junit测试 每次都需要创建 ApplicationContext 对象 非常麻烦，所以使用Spring的测试 性能更好 而且方便。A 导入测试包<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>compile</scope></dependency><dependency><groupId>org.Springframework</groupId><artifactId>Spring-test</artifactId><version>5.3.7</version></dependency>
B 在测试类中 添加注解
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:Spring.xml")
public class JavaTest {@Autowiredprivate ApplicationContext context;@Autowiredprivate People p1;@Testpublic void test(){People bean = context.getBean(People.class);System.out.println(bean);}@Testpublic void test01(){System.out.println(p1);}
}
2.2 getBean()的三种方式
A 通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)
Object p1 = context.getBean("唯一标识id");//此处获取的是一个Object类型，可以转换成我们需要的类型。
B 通过类型去获取
People bean = context.getBean(类名.class);
确保bean的类型是唯一的 不然会报错：org.springframework.beans.factory.NoUniqueBeanDefinitionException
C 通过 id + 类型去获取
People bean = context.getBean("p1",People.class);
2.3 创建Bean对象的方式
bean的属性配置
id ： 当前bean的唯一标识符
class：配置类的全限定名/全路径
name：配置当前bean的名字，并且可以配置多个。
第一种方式：使用默认构造创建（常用）直接去调用 bean对象中的无参空构造方法来创建对象
在spring的bean.xml文件中配置过bean标签，并且设置id和class属性后，会自动的调用默认构造创建对象，如果没有默认的空构造，则对象无法创建。
<bean id="唯一标识id" class="类的全限定名"></bean>第二种方式：使用普通工厂中的方法创建对象(使用某个类中的方法创建对象，并存入spring容器)
ServiceFactory factory = new ServiceFactory(); <bean id="普通工厂类的唯一标识" class="工厂类的全限定名"></bean> factory.getService(); <bean id="需要通过工厂创建的对象" factory-bean="上边bean的id" factory-method="工厂中的方法名"></bean>第三种方式：使用普通工厂的静态方法创建对象
<!--使用静态工厂的方式创建bean对象--> <bean id="accountService" class="工厂类的全类名" factory-method="生产对象的静态方法"></bean>
2.4 bean对象的作用范围
bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）
scope：常用 singleton,prototype
singleton：单例的（默认值）当加载配置文件时，就会创建对象。
prototype：多例的（当getBean时才会创建对象）
request：作用于请求范围
session：作用于会话范围
global-session: 全局，作用于分布式集群环境。如果不是集群环境，就是session
<bean id="唯一标识" class="全类名" scope="singleton/prototype"></bean>
默认为singleton单例的：整个程序运行期间对象只会被创建一次。
prototype 多例的，在程序运行期将，用了几次就创建几次对象。
多例对象java的GC垃圾回收机制，在检测到对象长时间不用时，会自动回收/销毁。
2.5 bean对象的生命周期
有的类 对象被创建的时候需要调用初始化函数，对象被回收的时候需要调用销毁函数。现在对象时由spring核心容器去管理的。所以这些函数的调用应该由spring负责。我们只需要通过配置告诉spring初始化函数是谁，销毁函数是谁。bean的生命周期函数。可以同过配置两个方法测试。
init-method：对象的初始化方法
destroy-method：销毁对象的方法（main方法测试时，不会调用销毁方法，是因为还没来得及，速度太快，可以手动销毁，调用close()；方法，但是此时ApplicationContext对象应该是子类类型，不能再是ApplicationContext类型了)；
单例对象：
出生：当容器创建时，对象出生
活着：只要容器还在，对象一直存在
死亡：容器销毁，对象也销毁
初始化方法会被调用，但是销毁方法如果是使用ApplicationContext接口类型，销毁方法无法被调用，需要使用子接口类型，才可以看到销毁方法被调用。context.close();
多例对象
出生：当使用对象时，才会创建
活着：只要使用，一直活着
死亡：java垃圾回收机制，当对象长时间不用时，GC垃圾回收机制，自动回收。
作业：
1. 复习 servlet所有知识点
2. 掌握今天讲解的知识点
3. 预习 依赖注入和springMVC
4. 增删改查不行的，接着搞！
第四节：依赖注入DI
相当于你请对象去吃饭、买衣服、送礼物啊
IOC:控制反转 创建对象！
依赖注入：目的就是给对象中的属性赋值。
对象中的属性都可以是哪些数据类型：基本类型，String , Date, List<?>----->基本，引用
1.简介
依赖注入(Dependency Injection)
IOC控制反转的最终目的就是降低程序的耦合，也就是削减依赖关系。
依赖关系的管理以后都交给spring维护，依赖关系的管理就称之为依赖注入。也就是说在当前类需要用到其它类的对象时，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护就可以了。
依赖注入的方式：
依赖注入的数据：三种类型
1. 基本数据类型和String
2. 其它bean实体对象类型(在配置文件中或者注解配置过的bean)
3. 复杂类型/集合类型(集合类型只能通过配置文件注入)
什么时候使用IOC和DI创建对象？
如果是单例对象，可以使用IOC和DI。整个程序运行期间只会创建一个对象，我们不用考虑对象中数据的改变。
但是，如果我们要创建的对象中的属性值，一直在改变，此时就不推荐使用DI和IOC了。
2.第一种：使用构造函数提供注入
argument
如果使用构造函数注入，需要在bean.xml文件的bean标签中添加constructor-arg标签
标签中的属性：
type : 用于指定要注入的数据的类型，该数据类型也是构造函数中某个或某些参数的类型。
index: 用指定给构造函数中指定索引位置的参数赋值，索引从0开始。
name: 用于给构造函数的参数赋值，指定参数的名称直接赋值 （常用）
value : 用于提供基本类型和String类型的数据
ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean
注意：在获取bean对象时，必须要注入数据，否则对象无法创建成功。
缺点：改变了bean对象的实例化方式，就算我们在创建对象时，用不到这些数据，也必须提供。
<!--构造注入--><bean id="p1" class="com.bai.demo2.entity.Person"><constructor-arg name="age" value="18"></constructor-arg><constructor-arg name="name" value="张三"></constructor-arg><constructor-arg name="date" ref="d1"></constructor-arg></bean><!--日期对象的bean--><bean id="d1" class="java.util.Date"></bean>
3.第二种：使用set方法注入(常用)
如果使用set函数注入，需要在bean.xml文件的bean标签中添加 property 标签
需要属性：
name: 用于给无参空构造函数的参数赋值，指定设值的set方法（将set方法的set去掉把大写字母变小写 setAge()====>age）
value : 用于提供基本类型和String类型的数据
ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean
**优点：**解决了构造注入时的问题，可以选择性的注入值，不是必须注入全部了。
<!--注入java提供的Date类--><bean id="date" class="java.util.Date"></bean><!--set方法注入--><bean id="person" class="com.aaa.ioc.Person"><property name="name" value="李四"></property><property name="age" value="29"></property><property name="birthday" ref="date"></property></bean>
3.复杂数据类型的注入
数组、集合（LIst、Set、Map、Properties）
<!-- 配置bean，放在spring的IOC容器--><bean id="depart" class="com.aaa.entity.Depart"><property name="id" value="1"/><property name="name" value="腾讯战略投研部"/><!-- 集合的注入;array n个子标签value --><property name="emps"><array><value>马化腾</value><value>刘治平</value><value>江二涛</value><value>苏磊</value></array></property><property name="nicknames"><list><value>小马哥</value><value>投资帝</value><value>江郎</value><value>苏仙</value></list></property><property name="hobbies"><set><value>王者</value><value>游戏</value><value>产品</value><value>产品</value></set></property><!-- 如何遍历？先写map Entry --><property name="maps"><map><entry><key><value>football</value></key><value>足球</value></entry><entry key="bassketball" value="篮球"></entry><entry key="pingpangball" value="乒乓球"/></map></property><!-- props:复数;一般用在配置文件,是Map的简化版本;--><property name="properties"><props><prop key="dirver">com.mysql.cj.jdbc.Driver</prop><prop key="url">http:///school:3306</prop><prop key="username">root</prop><prop key="password">root</prop></props></property></bean>
针对Properties类的操作
//如果和来获取相应的集合数据,depart获取完毕后；简化版的HashMapProperties properties = depart.getProperties();String driver = properties.getProperty("driver");String url = properties.getProperty("url");String username = properties.getProperty("username");String password = properties.getProperty("password");System.out.println(driver+"\t"+url+"\t"+username+"\t"+password);
5.SpEL，EL表达式，在web页面，对变量输出；
<!--spel:格式；#{bean的id名.属性名}--><bean id="emp" class="com.aaa.entity.Emp"><property name="eid" value="2"/><property name="ename" value="乔玉奇"/><property name="dname" value="#{depart.name}"/></bean>
6.注入外部文件
${key}这样的表达式在XML中，代表引入的properties文件中key对应的一个变量值，完全是靠第三方jar自己解析的，xml格式读取的符号。
为了解决很多无效的配置文件，可以使用注解。
4.第三种：使用注解提供 （注意开启注解的包扫描）
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--开启注解包扫描--><context:component-scan base-package="要扫描的包全名"></context:component-scan>
</beans>
注解分类：
1.用于创建对象的：
作用和在xml配置文件中编写一个< bean>标签实现的功能一样
@Component:（只要不属于三层架构 就使用）作用：用于把当前类对象存入spring容器中。具有value属性，用于指定bean的id，如果不写value，默认跟当前类名对应(首字母改小写)@Component("student1")作用就相当于：<bean id="student1" class="全类名"></bean>
衍生三个注解：
@Controller(表现层) @Service(业务层) @Repository(持久层)这三个注解的作用和@Component注解一样，是spring框架为我们提供的明确的三层架构使用的注解，让我们的三层架构更加清晰。
2.用于注入数据的
作用和xml文件中bean标签中的property标签的作用一样
@Autowired 重点
作用：自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。如果IOC容器中没有任何bean的类型和要注入的变量类型匹配，则报错如果IOC容器中有多个类型匹配时，会根据要注入的变量名作为id去匹配，如果匹配到了，就可以执行，否则，报错。
注意：使用注解时，set方法就不是必要的了。
以上@Autowired注解存在一定的局限性，(如果核心容器中有多个相同对象，只使用@Autowired是无法注入成功的)如何解决问题？
@Qualifier作用：在按照类型注入的基础上再按照名称注入。它再给类成员注入时不能单独使用。但是再给方法注入时可以。属性：value 用于指定注入的bean的id
@Resource作用：直接按照bean的id注入。它可以独立使用。属性：name 用于指定bean的id
以上三个注解都只能注入其它bean类型的数据，而基本类型和String类型无法使用上述注解。那么如何注入基本数据类型和String类型呢？（集合类型只能通过xml注入）
@Value作用：用于注入基本数据类型和String数据类型。
3.用于改变作用范围的：
作用和bean标签中的scope属性的功能一样
@Scope:作用：用于指定bean的作用范围属性：value 指定范围的取值。常用 singleton prototype
4.和生命周期相关的：
作用和bean标签中的init-method和destory-method方法的作用一样
@PostConstruct:用于指定初始化方法
@PreDestroy :用于指定销毁方法
5.测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring_ano_bean.xml")
总结：
BeanFactory接口和ApplicationContext接口的区别：
getBean() 方法
依赖注入：
构造注入
set注入
注解注入
作业：
改造三层架构
模拟三层架构
service,impl
dao,impl
controller(测试类)
理清楚依赖关系。
rce
作用：直接按照bean的id注入。它可以独立使用。
属性：name 用于指定bean的id
以上三个注解都只能注入其它bean类型的数据，而基本类型和String类型无法使用上述注解。那么如何注入基本数据类型和String类型呢？（集合类型只能通过xml注入）
@Value
作用：用于注入基本数据类型和String数据类型。
[外链图片转存中...(img-SEsBVE0f-1645885880932)]**3.用于改变作用范围的**： 作用和bean标签中的scope属性的功能一样```properties
@Scope:作用：用于指定bean的作用范围属性：value 指定范围的取值。常用 singleton prototype
4.和生命周期相关的：
作用和bean标签中的init-method和destory-method方法的作用一样
@PostConstruct:用于指定初始化方法
@PreDestroy :用于指定销毁方法
5.测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring_ano_bean.xml")
总结：
BeanFactory接口和ApplicationContext接口的区别：
getBean() 方法
依赖注入：
构造注入
set注入
注解注入
作业：
改造三层架构
模拟三层架构
service,impl
dao,impl
controller(测试类)
理清楚依赖关系。
分别使用bean.xml方式配置，和注解方式配置。完成三层架构的调用。
Spring 的控制反转/依赖注入相关推荐
- 那些年搞不懂的高深术语——依赖倒置•控制反转•依赖注入•面向接口编程...
那些年,空气中仿佛还能闻到汉唐盛世的余韵,因此你决不允许自己的脸上有油光,时刻保持活力.然而,你一定曾为这些"高深术语"感到过困扰--依赖倒置•控制反转•依赖注入•面向接口编程.也 ...
- Spring框架学习笔记(1) ---[spring框架概念 , 初步上手使用Spring , 控制反转 依赖注入初步理解 ]
spring官网 -->spring官网 spring5.3.12–>spring-framework 在线文档 --> Spring 5.3.12 文章目录 1.Spring概论 ...
- 控制反转---依赖注入理解
在学习Spring的时候,意外找到这个控制反转(IoC)和面向切面(AOP)的容器框架之前,我们先来看一下什么是控制反转(IoC). 控制反转(Ioc)和依赖注入(DI)刚听到感到很难理解,平时也程序 ...
- 设计模式——控制反转依赖注入
一.控制反转: 从简单的代码示例入手: /// <summary>/// 邮件服务类/// </summary>public class EmailService{public ...
- 【C#|.NET】从控制反转(依赖注入)想到事件注入 (非AOP)
前文 事件注入的想法是由依赖注入所联想到 依赖注入不算什么吸引人的话题 本篇就不详说了 不过有闲暇时间的机会不妨按照自己的兴趣去摸索.研究一些东西,也是一种乐子. 在抓虫系列里简单的描述一下依赖注入在 ...
- 那些年搞不懂的高深术语——依赖倒置•控制反转•依赖注入•面向接口编程【转】...
那些年,空气中仿佛还能闻到汉唐盛世的余韵,因此你决不允许自己的脸上有油光,时刻保持活力.然而,你一定曾为这些"高深术语"感到过困扰.也许时至今日,你仍对它们一知半解.不过就在今天, ...
- 高深术语——依赖倒置•控制反转•依赖注入•面向接口编程
今天,我将带领你以一种全新的高清视角进入奇妙的编程世界,领略涵泳在这些"高深术语"中的活泼泼的地气,以及翩跹于青萍之末的云水禅心. 高聚合·低耦合 简短:管理好自己(内聚),但是有 ...
- 【转】那些年搞不懂的高深术语——依赖倒置•控制反转•依赖注入•面向接口编程
作者:在好 链接:https://www.zhihu.com/question/31021366/answer/102239756 来源:知乎 著作权归作者所有.商业转载请联系作者获得授权,非商业转载 ...
- 控制反转/依赖注入概念
控制反转概念 控制反转是影响广泛的设计模式,其主要目的就是为了管理对象之间的关系,为对象之间解除耦合,把对象生命周期的管理和关系的管理这些和对象个体无关的公共任务交给公共容器处理. 控制反转有如下好处 ...
最新文章
- 机器人动力学简化模型（Euler-Lagrange equation）
- 【Kaggle-MNIST之路】CNN再添加一个层卷积（八）
- Linux 串口编程分析
- sql针对某字段去重查询_sql的简单查询
- vue domo网站_DOMO与Tableau-逐轮
- linux能装ps,在linux上使用ps（转载）
- DHTML【9】--Javascript
- Android动画之属性动画
- RFID定位技术在医院资产管理中的运用-RFID资产管理解决方案-RFID手持机-新导智能
- 基尔霍夫定律(Kirchhoff laws)
- 七月行情有盼头——技术派=基础，资金流派和基本面派是工具，思维流是集大成者_96
- 学生管理系统:含注册登录操作
- 51单片机（入门保姆级教程）——LED闪烁及流水灯
- rpg人物制作软件_《RPG Maker MZ》——轻松上手的角色扮演游戏制作工具
- 居家隔离没事干？进来秒变算法工程师
- 支付计算机维护费分录,税控技术维护费会计分录是什么
- 笔记本电脑插入耳机不能自动切换播放设备，小键盘不能自动打开，蓝屏问题记录
- FICO-笔记_20211019_002
- C++实现五子棋小游戏（源代码）
- crmebPro多门店企业微信配置文档