标签：容器 Spring bean 简介 org com IOC
1） IOC/DI (IOC容器)
2） AOP面向切面编程
3） 声明式事务
官网地址：spring是一家公司-商业化运作。apache是一家基金会组织，接收社会的捐赠。
io表示开发者平台
1. Spring Framework
Spring 基础框架，可以视为 Spring 基础设施，基本上任何其他 Spring 项目都是以 Spring Framework 为基础的。
Spring5，基于jdk1.8 。
1.1 Spring Framework的优良特性
1 非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型（Java Bean）可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
2 控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。
3 面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。
4 容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。
5 组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML 和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。
6 声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。
7 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且 Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。
1.2 Spring Framework五大功能模块
2. IOC容器的概念
2.1 生活中的普通容器
普通容器只能用来存储，没有更多功能。
2.2 程序中的普通容器
变量，数组，集合
普通容器只能用来存储，没有更多功能。
2.3 生活中的复杂容器
政府管理我们的一生，生老病死都和政府有关。
4. IOC容器在Spring中的实现
Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：
①BeanFactory
这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
②ApplicationContex -- 我们自己使用
BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。
所以，以后在 Spring 环境下看到一个类或接口的名称中包含 ApplicationContext，那基本就可以断定，这个类或接口与 IOC 容器有关。
③ApplicationContext的主要实现类
5. 基于XML管理bean
5.1 实验01[重要]创建bean，并根据id获取
5.1.1 目标
由 Spring 的 IOC 容器创建类的对象，并根据bean的id属性值来获取bean对象。
5.1.2 思路
自定义一个类IEmpService => EmpServiceImpl,这个类在Spring的配置文件中进行配置，然后用ClassPathXMLApplicationContext这个类去读取配置文件，然后根据配置文件中配置的东西，将这个对象建立出来。
5.1.3 创建maven项目，导入依赖
完整的pom文件
|
<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.hy</groupId> <artifactId>mybatis001</artifactId> <version>0.0.1</version> <packaging>war</packaging>
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <maven.compiler.encoding>UTF-8</maven.compiler.encoding> </properties>
<dependencies> <!-- Spring core--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.20.RELEASE</version> </dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.20</version> </dependency>
<!-- Spring-Test --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.2.20.RELEASE</version> </dependency> <!--junit的核心jar包 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> </dependencies>
<build> <plugins> <!-- 指定jdk，防止update project --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.8</source> <target>1.8</target> <!-- 项目编码 --> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build> </project> |
导入一个依赖，传递过来剩下的jar文件
5.1.4 EmpService -> EmpServiceImpl
|
package com.hy.service.impl;
import com.hy.service.EmpService;
public class EmpServiceImpl implements EmpService { @Override public void reg() { System.out.println("用户注册"); } }
|
1） 先导入spring的相关环境，其实就是导入pom文件jar包的坐标gav。
2） 创建spring的配置文件applicationContext.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">
<!-- 实验01 [重要] 创建bean --> <!-- bean标签，通过配置bean标签告诉IOC容器需要创建是哪个类的对象 id属性：当前bean的唯一标识，设定了这个唯一标识后，在其他地方就可以用来引用这个bean对象 class属性:指定这个bean要配置的类的全类名 --> <bean id="empService" class="com.hy.service.impl.EmpServiceImpl" /> </beans> |
这个bean没有属性，所以可以写成单标签
5.1.5 创建测试类
|
public class TestService { // ApplicationContext就是我们的IOC容器 private ApplicationContext iocContainer = new ClassPathXmlApplicationContext("applicationContext.xml");
//实验01 [重要] 创建bean //从IOC容器中获取已配置的bean @Test public void testEmpService() { //通过bean的id属性的值得，获取这个bean对象 EmpService empService = (EmpService)iocContainer.getBean("empService"); empService.reg(); } } |
注意：Spring底层默认通过反射技术调用类的无参构造方法来创建类的对象。
5.1.6 无参构造方法的重要性，写一个有参的构造方法，测试
|
package com.hy.service.impl;
import com.hy.service.EmpService;
public class EmpServiceImpl implements EmpService {
public EmpServiceImpl(int age) { }
@Override public void reg() { System.out.println("用户注册"); } } |
报错: 如果没有无参构造方法，则会抛出下面的异常：
所以对一个JavaBean来说，无参构造器和属性的getXxx()、setXxx()方法是必须存在的，特别是在框架中。
5.1.7 用IOC容器创建对象和自己建区别
被放入到容器当中，相当于加入了会员俱乐部
在Spring环境下能够享受到的所有福利，都必须通过 IOC 容器附加到组件类上，所以随着我们在 Spring 中学习的功能越来越多，IOC 容器创建的组件类的对象就会比自己 new 的对象 其功能强大的越来越多。
5.2 实验02[重要]创建bean，并根据class类型来获取
5.2.1 指定类型的 bean 唯一(只有一个)
5.2.2 测试
|
package com.hy.test;
import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hy.service.EmpService; import com.hy.service.impl.EmpServiceImpl;
public class TestService2 { // ApplicationContext就是我们的IOC容器 private ApplicationContext iocContainer = new ClassPathXmlApplicationContext("applicationContext.xml");
//实验02 [重要] 创建bean，并且根据类型获取bean对象 //从IOC容器中根据类型获取已配置的bean对象 @Test public void testEmpService() { // EmpService empService = iocContainer.getBean(EmpService.class); //正确 EmpService empService = iocContainer.getBean(EmpServiceImpl.class); //正确 empService.reg(); //用户注册 } }
|
5.2.3 问题：如果配置了两个同样类型的bean对象，则报错，根据类型获取报错。
|
<?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">
<!-- 实验01 [重要] 创建bean --> <!-- bean标签，通过配置bean标签告诉IOC容器需要创建是哪个类的对象 id属性：当前bean的唯一标识，设定了这个唯一标识后，在其他地方就可以用来引用这个bean对象 class属性:指定这个bean要配置的类的全类名 --> <bean id="empService" class="com.hy.service.impl.EmpServiceImpl" />
<bean id="empService2" class="com.hy.service.impl.EmpServiceImpl" /> </beans>
|
|
package com.hy.test;
import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hy.service.EmpService; import com.hy.service.impl.EmpServiceImpl;
public class TestService2 { // ApplicationContext就是我们的IOC容器 private ApplicationContext iocContainer = new ClassPathXmlApplicationContext("applicationContext.xml");
//实验02 [重要] 创建bean，并且根据类型获取bean对象 //如果容器中配置了同样类型的两个bean对象， //从IOC容器中根据类型获取已配置的bean对象时，则报错。 @Test public void testEmpService() { // EmpService empService = iocContainer.getBean(EmpService.class); //失败 EmpService empService = iocContainer.getBean(EmpServiceImpl.class); //失败 } }
|
5.2.4 总结
如果一个类实现了某个接口，根据接口类型可以获取 bean 吗？
可以，前提是bean唯一，如下的配置就不行。
|
<bean id="empService" class="com.hy.service.impl.EmpServiceImpl" />
<bean id="empService2" class="com.hy.service.impl.EmpServiceImpl" /> |
如果一个接口有多个实现类，这些实现类都配置了 bean标签，根据接口类型可以获取 bean 吗？
不行，因为bean不唯一
根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。
5.3 实验03[重要] 给bean的属性赋值：通过setXxx方法注入
5.3.1 首先，给EmpServiceImpl添加一个属性,提供setXxx和getXxx方法
|
package com.hy.service.impl;
import com.hy.service.EmpService;
public class EmpServiceImpl implements EmpService { private String empStatus;
public String getEmpStatus() { return empStatus; }
public void setEmpStatus(String empStatus) { this.empStatus = empStatus; } @Override public void reg() { System.out.println("用户注册"); } } |
5.3.2 在配置时给通过property标签给属性赋值
|
<!-- 实验03 [重要] 创建bean，同时给bean的属性赋值：通过setXxx方法注入 --> <bean id="empService3" class="com.hy.service.impl.EmpServiceImpl"> <!-- property标签：通过类的setXxx()方法给该类的对象设置属性值 name属性：指定属性名(其实这个名字是setXxx和getXx方法定义的，和属性名无关) value属性：指定属性值 --> <property name="empStatus" value="积极"/> </bean> |
5.3.3 测试
|
package com.hy.test;
import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hy.service.impl.EmpServiceImpl;
public class TestService3 { private ApplicationContext iocContainer = new ClassPathXmlApplicationContext("applicationContext.xml");
//实验03 [重要] @Test public void testEmpService() { //通过bean的id属性的值得，获取这个bean对象 EmpServiceImpl empService3 = (EmpServiceImpl)iocContainer.getBean("empService3"); System.out.println(empService3.getEmpStatus()); //积极 } } |
5.4 实验04[重要] 引入外部已声明的bean
|
<!-- 实验四 [重要]给bean的属性赋值：引用外部已声明的bean --> <bean id="empMapper" class="com.hy.mapper.impl.EmpMapperImpl "> <property name="name" value="范冰冰"/> </bean>
<bean id="empService" class="com.hy.service.impl.EmpServiceImpl "> <!-- 使用外部已经配置好的empMapper这个bean来给当前组件的happyMachine属性赋值 --> <!-- 引用另外一个bean不能再使用value属性，而要使用ref属性指定bean的id --> <!-- 如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException: Cannot convert value of type 'java.lang.String' to required type 'com.' for property ' empMapper ': no matching editors or conversion strategy found 意思是不能把String类型转换成我们要的EmpMapper类型 说明我们使用value属性时，Spring只把这个属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值 --> <property name="empMapper" ref=" empMapper "/> </bean> |
5.5 内部bean[重要]
|
<!-- 内部bean PersonServiceImpl里有一个Dept属性 --> <bean id="personService" class="com.hy.service.impl.PersonServiceImpl"> <property name="dept" > <!-- 在property标签内部再配置一个bean，这就是内部bean 内部bean可以直接用来给property指定的属性赋值 - -> <!-- 内部bean，仅仅被外部bean使用，不能让其他的bean使用,所以内部bean不需要id --> <bean class="com.hy.bean.Dept"/> </property> </bean> |
5.6 引入外部属性文件[重要]
<!-- 实验六 [重要]给bean的属性赋值：引入外部属性文件 -->
<!-- 使用context名称空间下的property-placeholder标签引入外部属性文件(本质上就是记录外部属性文件的位置) -->
<!-- location属性：指定外部属性文件的路径。classpath:表示这个路径从类路径根目录开始 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 通过 ${key}的形式引用外部属性文件中的数据 -->
<property name="url" value="${jdbc.url}"/>
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
5.7 给bean的属性赋值：级联属性赋值（不重要，不怎么使用）
使用内部bean，给级联属性赋值。
<!-- 实验七 给bean的属性赋值：级联属性赋值 -->
<bean id="happyComponent7" class="com.hy.ioc.component.HappyComponent">
<!-- 使用内部bean的形式将happyMachine属性初始化 -->
<property name="happyMachine">
<!-- 相当于创建了HappyMachine的空对象赋值给happyMachine属性 -->
<bean class="com.hy.ioc.component.HappyMachine"/>
</property>
<!--
如果happyMachine属性没有被初始化，那么直接访问级联属性会抛出异常：
Caused by: org.springframework.beans.NullValueInNestedPathException: Invalid property 'happyMachine' of bean class [com.atguigu.ioc.component.HappyComponent]: Value of nested property 'happyMachine' is null
-->
<property name="happyMachine.machineName" value="aaa"/>
</bean>
5.8 通过构造方法，给bean属性赋值[不重要]
<!-- 实验八 给bean的属性赋值：构造器注入 -->
<bean id="happyTeam" class="com.hy.ioc.component.HappyTeam">
<!-- 调用类的构造器创建对象并同时传入参数值 -->
<!-- constructor-arg标签：给构造器对应位置传入参数 -->
<!-- index属性：指定当前参数在参数列表中的索引位置 -->
<!-- name属性：指定当前参数的参数名 -->
<!-- value属性：指定参数值 -->
<constructor-arg index="0" name="teamName" value="gaysTeam"/>
<constructor-arg index="1" name="memberCount" value="10" />
<constructor-arg index="2" name="memberSalary" value="555.55"/>
</bean>
5.9 给bean的集合属性赋值[不重要]
private List<String> nameList; //标签不需要完全一致，一样可以赋值成功
private Map<String,String> nameMap;
<!-- 实验十一 给bean的属性赋值：集合属性 -->
<bean id="classes" class="com.hy.ioc.component.Classes">
<property name="nameList">
<!-- list标签：准备一组集合类型的数据，给集合属性赋值 -->
<!--<list>
<value>member01</value>
<value>member02</value>
<value>member03</value>
</list>-->
<!-- 使用set标签也能实现相同效果，只是附带了去重功能 -->
<!--<set>
<value>member01</value>
<value>member02</value>
<value>member02</value>
</set>-->
<!-- array也同样兼容 -->
<array>
<value>member01</value>
<value>member02</value>
<value>member02</value>
</array>
</property>
<property name="nameMap">
<!-- 给Map类型的属性赋值 -->
<!--<map>
<entry key="财务部" value="张三"/>
<entry key="行政部" value="李四"/>
<entry key="销售部" value="王五"/>
</map>-->
<!-- 也可以使用props标签 -->
<props>
<prop key="财务部">张三2</prop>
<prop key="行政部">李四2</prop>
<prop key="销售部">王五2</prop>
</props>
</property>
</bean>
5.10 自动装配 与 手动装配[了解]
所谓自动装配就是一个组件需要其他组件时，由 IOC 容器负责找到那个需要的组件，并装配进去。
|
<!-- 实验十二 自动装配 --> <bean id="happyService3" class="com.hy.ioc.component.HappyService"/> <bean id="happyService2" class="com.hy.ioc.component.HappyService"/>
<!-- 使用bean标签的autowire属性设置自动装配效果 --> <!-- byType表示根据类型进行装配，此时如果类型匹配的bean不止一个，那么会抛NoUniqueBeanDefinitionException --> <!-- byName表示根据bean的id进行匹配。而bean的id是根据需要装配组件的属性的属性名来确定的 --> <bean id="happyController" class="com.hy.ioc.component.HappyController" autowire="byName"> <!-- 手动装配：在property标签中使用ref属性明确指定要装配的bean --> <!--<property name="happyService" ref="happyService"/>--> </bean> |
@Test
public void testExperiment12() {
HappyController happyController = iocContainer.getBean(HappyController.class);
HappyService happyService = happyController.getHappyService();
System.out.println("happyService = " + happyService);
}
5.11 bean的声明周期以及初始化
在无参构造方法打一个断点。
bean标签scope配置singleton时，bean的创建是在IOC容器初始化的时候，创建的，而不是在getBean的时候创建的。
bean标签scope配置prototype时，bean的创建实在调用getBean方法的时候创建的。
IOC容器关闭之前销毁bean对象。
这个接口总没有close方法在子接口中。
6，基于注解管理bean
和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。
本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。
1) 首先根据所需要的组件类型到IOC容器中查找
能够找到唯一的bean：直接执行装配
如果完全找不到匹配这个类型的bean：装配失败
和所需类型匹配的bean不止一个
没有@Qualifier注解：根据@Autowired标记位置成员变量的变量名作为bean的id进行匹配
能够找到：执行装配
找不到：装配失败
使用@Qualifier注解：根据@Qualifier注解中指定的名称作为bean的id进行匹配
能够找到：执行装配
找不到：装配失败
标签：容器,Spring,bean,简介,org,com,IOC 来源： https://www.cnblogs.com/lijili/p/16668322.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。