Spring框架-IOC

1.框架概述

Spring 是轻量级的开源的 JavaEE 框架

Spring 可以解决企业应用开发的复杂性

Spring 有两个核心部分：IOC 和 Aop
IOC：控制反转，把创建对象过程交给 Spring 进行管理

Aop：面向切面，不修改源代码进行功能增强

特点：
方便解耦，简化开发

Aop 编程支持

方便程序测试

方便和其他框架进行整合

方便进行事务操作

降低 API 开发难度

2.入门案例

创建普通类以及普通方法：

public class User {public void add(){System.out.println("add...");}
}

创建 Spring 配置文件，在配置文件配置创建的对象：

<?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"><!--配置 User 对象创建--><bean id="user" class="com.psj.User"></bean>
</beans>

进行测试代码编写：

// 1.加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
// 2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();

3.IOC

3.1 什么是IOC

控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

目的是为了耦合度降低

入门案例就是 IOC 实现

3.2 底层原理

假设要在UserService类中调用UseDao的add方法，传统方式的耦合度太高，假设UserDao路劲改变了，调用的UserDao的其他类都要修改代码：

为了降低耦合度，可以使用工厂模式，这样其他要使用UserDao类的类通过调用工厂类间接实现，如果UserDao路径改变，此时不需要修改UserService类的代码，只要修改工厂类的代码即可：

在工厂模式中还是存在一定的耦合，所以采用IOC进一步降低耦合，三个重要的因素是xml解析、工厂模式以及反射。即使路径改变，也只需要修改xml文件即可：

IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
Spring 提供 IOC 容器实现两种方式：

BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用(加载配置文件时候不会创建对象，在获取对象才去创建对象)：
// 使用BeanFactory时该步加载配置文件，此时不会创建对象，等到执行getBean才会创建对象
BeanFactory context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用(加载配置文件时候就会把在配置文件对象进行创建)：
// 使用ApplicationContext时，假如配置文件中有很多的bean对象，在该步加载配置文件时都会创建，不管用不用
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
tips：

在开发中一般使用ApplicationContext，这样在启动服务器的时候就能创建好对象，而不是等到代码要创建对象时再创建

ApplicationContext有两个实现类：

FileSystemXmlApplicationContext：配置文件路径要求是在盘符下的路径

ClassPathXmlApplicationContext：配置文件路径要求是相对于src目录下的路径

3.3 操作 Bean 管理

3.3.1 什么是 Bean 管理

Bean 管理指的是两个操作：

Spring 创建对象：传统方式创建类的实例是通过new XXX，Spring也是调用构造器，只不过实现方式改变了

Spirng 注入属性：传统方式给类的属性赋值(注入属性)是通过set方法或者使用有参构造器，Spring也可以通过这两种方式，只不过实现方式变了

Bean 管理操作有两种方式：
基于 xml 配置文件方式实现

基于注解方式实现

3.3.2 基于 xml 方式

创建对象：<bean id="user" class="com.psj.User"></bean>
- 在 bean 标签有很多属性：
  - id 属性：唯一标识，就是一个别名
  - class 属性：类全路径（包类路径）
  - name属性：和id属性作用一样，使用几率很小
- 创建对象时候，默认执行无参数构造方法完成对象创建。假设类中只有有参构造器(默认创建的无参构造器就不存在了)，还是使用一样的方式创建对象会报错

注入属性：

通过set方法注入：

<bean id="user" class="com.psj.User"># 在类中一定要有相应属性的set方法。该name为类中的属性，不同于bean中的name<property name="username" value="psj"></property>
</bean>

通过有参构造器注入：

<bean id="user" class="com.psj.User"># 在类中一定要有相应的有参构造器(假设类中只有有参构造器，没写constructor-arg标签前会报错，写完后不会报错)<constructor-arg name="username" value="psj"></constructor-arg>
</bean>

p 名称空间注入：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"  # 添加 p 名称空间在配置文件中xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"># 不同于constructor-arg，类中只有有参构造器时会报错<bean id="user" class="com.psj.User" p:username="psj"></bean>
</beans>

注入其他类型属性(都采取set方法注入)：

注入null 值：要给username设置null值，直接使用<property name="username" value=null></property>是不行的

<bean id="user" class="com.psj.User"><property name="username"><null/></property>
</bean>

注入包含特殊符号的属性值：设置的值中包括了特殊符号，直接采取<property name="username" value="<<psj>>">是不行的

#1.把<和>进行转义 &lt; &gt;
<bean id="user" class="com.psj.User"><property name="username"><value>&lt;&lt;psj&gt;&gt;</value></property>
</bean>
<bean id="user" class="com.psj.User"><property name="username" value="&lt;&lt;psj&gt;&gt;"></property>
</bean>
#2.把带特殊符号内容写到 CDATA
<bean id="user" class="com.psj.User"><property name="username"><value><![CDATA[<<psj>>]]></value></property>
</bean>

注入外部 bean：要实现UserService类调用UserDao类的操作

# UserDaoImpl类
public class UserDaoImpl implements UserDao{@Overridepublic void update() {System.out.println("DAO UPDATE");}
}
# UserService类
public class UserService {// 要在xml中注入属性，需要set方法，而set方法需要在类中创建对象// 所以不是使用了Spring就可以完全不在类中创建对象private UserDao userDao1;public void setUserDao1(UserDao userDao1) {this.userDao1 = userDao1;}public void add(){System.out.println("service add...");userDao1.update();}
}

<!--创建service和dao对象-->
<bean id="userService" class="com.psj.service.UserService"><!--注入UserDao对象--><!--name是在UserService中创建的UserDao类型的属性名称ref是创建的UserDao类的bean标签id值--><property name="userDao1" ref="userDao"></property>
</bean>
<!--不要调用UserDao，这是接口，接口不能实例化-->
<bean id="userDao" class="com.psj.dao.UserDaoImpl"></bean>

// 1.加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
// 2.获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();  // 输出service add...和DAO UPDATE

注入内部 bean：以一对多关系中部门和员工为例

// 部门类
public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;}
}
// 员工类
public class Emp {private String ename;private String gender;//一个员工属于某一个部门，使用对象形式表示private Dept dept;public void setDept(Dept dept) {this.dept = dept;}public void setEname(String ename) {this.ename = ename;}public void setGender(String gender) {this.gender = gender;}
}

// bean.xml
<bean id="emp" class="com.psj.bean.Emp"><!--设置普通属性--><property name="ename" value="psj"></property><property name="gender" value="男"></property><!--设置对象属性--><property name="dept"><bean id="dept" class="com.psj.bean.Dept"><property name="dname" value="安保部"></property></bean></property>
</bean>
// 使用外部bean中ref效果是一样的
<bean id="emp" class="com.psj.bean.Emp"><!--设置普通属性--><property name="ename" value="psj"></property><property name="gender" value="男"></property><!--设置对象属性--><property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"><property name="dname" value="安保部"></property>
</bean>

级联赋值：

// 方法1：
<bean id="emp" class="com.psj.bean.Emp"><!--设置普通属性--><property name="ename" value="psj"></property><property name="gender" value="男"></property><!--设置对象属性--><property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"><property name="dname" value="安保部"></property>
</bean>
// 方法2：
<bean id="emp" class="com.psj.bean.Emp"><!--设置普通属性--><property name="ename" value="psj"></property><property name="gender" value="男"></property><!--设置对象属性--><property name="dept" ref="dept"></property>// 使用该方式的前提是Emp类中有getDept方法(Dept类中可以没有getDname方法)<property name="dept.dname" value="安保部"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"></bean>

注入集合属性：

// Stu类
public class Stu {//1 数组类型属性private String[] courses;//2 list 集合类型属性private List<String> list;//3 map 集合类型属性private Map<String, String> maps;//4 set 集合类型属性private Set<String> sets;private List<Course> courseList;public void setCourseList(List<Course> courseList) {this.courseList = courseList;}public void setSets(Set<String> sets) {this.sets = sets;}public void setCourses(String[] courses) {this.courses = courses;}public void setList(List<String> list) {this.list = list;}public void setMaps(Map<String, String> maps) {this.maps = maps;}
}

<bean id="stu" class="com.psj.bean.Stu"><!--数组类型属性注入--><property name="courses"><array><value>java</value><value>数据库</value></array></property><!--list 类型属性注入--><property name="list"><list><value>psj</value><value>psw</value></list></property><!--map 类型属性注入--><property name="maps"><map><entry key="JAVA" value="java"></entry><entry key="PHP" value="php"></entry></map></property><!--set 类型属性注入--><property name="sets"><set><value>MySQL</value><value>Redis</value></set></property>
</bean>

在集合中设置对象类型：

<bean id="course1" class="com.psj.bean.Course"><property name="cname" value="Spring5"></property>
</bean>
<bean id="course2" class="com.psj.bean.Course"><property name="cname" value="springMVC"></property>
</bean>
<property name="courseList"><list><ref bean="course1"></ref><ref bean="course2"></ref></list>
</property>

使用 util 标签完成注入的提取:

<util:list id="nameList"><value>psj</value><value>psw</value>
</util:list>
<bean id="name" class="com.psj.bean.Book"><property name="list" ref="nameList"></property>
</bean>

tips:

DI(依赖注入)就是注入属性，注入属性不只是Spring的概念

3.3.3 IOC 操作 Bean 管理-FactoryBean

Spring 有两种类型 bean：普通 bean和工厂 bean（FactoryBean）

普通 bean：在配置文件中定义 bean 属于什么类型就返回什么类型

// class中定义了Course类，在getBean("course1", Course.class)返回就是Course类
<bean id="course1" class="com.psj.bean.Course"><property name="cname" value="Spring5"></property>
</bean>

工厂 bean：返回类型可以和配置文件定义 bean的类型不一样(本质还是一个bean)

// 具体返回的类型由MyBean的getObject方法决定
<bean id="MyBean" class="com.psj.bean.MyBean"></bean>

public class MyBean implements FactoryBean<Course>{// 定义返回的类型,这里定义返回Course类@Overridepublic Course getObject() throws Exception {Course course = new Course();course.setCname("psj");return course;}@Overridepublic Class<?> getObjectType() {return null;}@Overridepublic boolean isSingleton() {return false;}
}
// 使用创建的工厂bean
...
Course course = context.getBean("MyBean", Course.class);  // 确定了要返回的类型后就写返回类型的class
System.out.println(course);

3.3.4 IOC 操作 Bean 管理-bean 作用域

bean作用域：即设置创建 bean 实例是单实例还是多实例(默认情况下为单实例对象）
// 单实例的情况
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book1);  // com.psj.bean.Book@33c911a1
System.out.println(book2);  //com.psj.bean.Book@33c911a1
在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象

设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象
# prototype:多实例，singleton:单实例
<bean id="book" class="com.psj.bean.Book" scope="prototype"></bean>

3.3.5 IOC 操作 Bean 管理-bean 生命周期

通过构造器创建 bean 实例（无参数构造）
为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
调用 bean 的初始化的方法（需要进行配置初始化的方法）
使用bean （即已经获取到对象）
当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"><property name="oname" value="手机"></property>
</bean>

// Orders类的定义
public class Orders {//无参数构造public Orders() {System.out.println("第一步 执行无参数构造创建 bean 实例");}private String oname;public void setOname(String oname) {this.oname = oname;System.out.println("第二步 调用 set 方法设置属性值");}//创建执行的初始化的方法public void initMethod() {System.out.println("第三步 执行初始化的方法");}//创建执行的销毁的方法public void destroyMethod() {System.out.println("第五步 执行销毁的方法");}
}
// ApplicationContext没有close方法，所以使用其子类ClassPathXmlApplicationContext
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建 bean 实例对象");
// 需要手动让 bean 实例销毁
context.close();
// 输出结果
//第一步 执行无参数构造创建 bean 实例
//第二步 调用 set 方法设置属性值
//第三步 执行初始化的方法
//第四步 获取创建 bean 实例对象
//com.psj.bean.Orders@482bce4f
//第五步 执行销毁的方法

tips:

如果加上 bean 的后置处理器，则生命周期变为7步：
1. 通过构造器创建 bean 实例（无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
3. 把 bean 实例传递 bean 后置处理器的其中一个方法 postProcessBeforeInitialization
4. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
5. 把 bean 实例传递 bean 后置处理器的其中一个方法 postProcessAfterInitialization
6. 使用bean （即已经获取到对象）
7. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

<!--配置后置处理器,对于同一个配置文件中的所有bean都会自动生效-->
<bean id="myBeanPost" class="com.psj.bean.MyBeanPost"></bean>

public class MyBeanPost implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("在初始化前执行的方法");return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("在初始化后执行的方法");return bean;}
}
//还是执行Orders orders = context.getBean("orders", Orders.class);
//输出结果
//第一步 执行无参数构造创建 bean 实例
//第二步 调用 set 方法设置属性值
//在初始化前执行的方法
//第三步 执行初始化的方法
//在初始化后执行的方法
//第四步 获取创建 bean 实例对象
//com.psj.bean.Orders@1649b0e6
//第五步 执行销毁的方法

3.3.6 IOC 操作 Bean 管理-xml 自动装配

手动装配：需要在bean的property中定义name和value，即指明为哪个属性指定什么值

<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"><property name="oname" value="手机"></property>
</bean>

自动装配：根据指定装配规则(属性名称或者属性类型)，Spring 自动将匹配的属性值进行注入

根据属性名称自动注入：

# 原始方式
<bean id="emp" class="com.psj.bean.Emp"><property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"></bean>
# 自动装配
<bean id="emp" class="com.psj.bean.Emp" autowire="byName"></bean># 要求：被装配的bean中id值一定要和类中属性名字一样
<bean id="dept" class="com.psj.bean.Dept"></bean>

根据属性类型自动注入：

<bean id="emp" class="com.psj.bean.Emp" autowire="byType"></bean>
# 如果该文件中还有一个id值不同但是class相同的bean对象，此时不清楚调用哪个bean。此时根据属性名称就不会报错
<bean id="dept" class="com.psj.bean.Dept"></bean>

3.3.7 IOC 操作 Bean 管理-外部属性文件

假设在bean中配置数据库信息：

直接进行配置：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="url" value="jdbc:mysql://localhost:3306/jdbc"></property><property name="username" value="root"></property><property name="password" value="xxxx"></property>
</bean>

引入外部的属性文件配置：

# 1.创建外部属性文件(假设名为jdbc.properties),写数据库信息
prop.driverClassName=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/jdbc
prop.username=root
prop.password=xxxx

# 2.在bean.xml引入 context 名称空间
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
# 3.使用标签引入外部属性文件
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${prop.driverClassName}"></property><property name="url" value="${prop.url}"></property><property name="username" value="${prop.username}"></property><property name="password" value="${prop.password}"></property>
</bean>

3.3.8 IOC 操作 Bean 管理-基于注解方式

什么是注解：
- 注解的概念：代码特殊标记
- 格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
- 如何使用注解：注解作用在类上面，方法上面，属性上面
- 使用注解的目的：简化 xml 配置
Spring 针对 Bean 管理中为**创建对象(即创建bean实例)**提供的注解：
- @Component
- @Service
- @Controller
- @Repository

基于注解方式实现对象创建：

引入依赖：需要Spring-aop-xxx.jar的jar包
开启组件扫描：

<!--开启组件扫描如果扫描多个包，多个包使用逗号隔开
-->
<context:component-scan base-package="com.psj"></context:component-scan>
<!--示例1：use-default-filters="false" 表示现在不使用默认filter(即扫描base-package下的所有注解)，自己配置 filter(即自己指定哪些类型的注解)context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.psj" use-defaultfilters="false">// 按注解类型过滤扫描的内容，此时只扫描Controller注解<context:include-filter type="annotation"                               expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2下面配置扫描包所有内容context:exclude-filter： 设置哪些内容不进行扫描(因为是扫描除了exclude外的所有，所以不设置use-defaultfilters)
-->
<context:component-scan base-package="com.psj"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

创建类，在类上面添加创建对象注解：

// 等价于<bean id="empService" class="com.psj.service.EmpService">
@Service(value = "empService")  // value可以省略，默认值是类名称(首字母小写)
public class EmpService {public void add(){}
}于注解方式实现属性注入

基于注解方式实现属性注入：

@Autowired：根据属性类型进行自动装配

// 在需要注入的类上添加注解(不是加在UserDao接口上，是加在实现类上)
@Repository
public class UserDaoImpl implements UserDao{@Overridepublic void update() {System.out.println("DAO UPDATE");}
}
// service层
@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {// 等价于<bean ...>//         <property name="userDao" ref="userDaoImpl"></property>//      </bean>// 如果在xml中注入属性，需要写属性的set方法，使用注解则不要@Autowiredprivate UserDao userDao;public void add(){userDao.update();}
}

@Qualifier：根据名称进行注入(需要和@Autowired一起使用)

@Repository(value = "userDaoImpl2")
public class UserDaoImpl2 implements UserDao{@Overridepublic void update() {System.out.println("DAO UPDATE2");}
}
// service层
@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {@Autowired  // 当一个接口有多个实现类时，这些实现类所属类型都是UserDao，所以根据类型进行注入则会失败@Qualifier(value = "userDaoImpl2")  private UserDao userDao;public void add(){userDao.update();}
}

@Resource：可以根据类型注入，也可以根据名称注入

@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {@Resource(name = "userDaoImpl2")  // 如果没有加name就是按照类型注入private UserDao userDao;public void add(){userDao.update();}
}

@Value：注入普通类型属性

@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {// 等价于<bean ...>//         <property name="name" value="psj"></property>//      </bean>@Value(value = "psj")private String name;
}

tips:

上述四个不同的注解可以混用，目的都创建bean实例
@Resource是javax.annotation下的类，JDK11无法直接使用

3.3.9 完全注解开发

上述完成了对创建对象和属性注入的注解操作，但是还是需要一个bean.xml文件，而完全注解开发则把配置文件也用注解代替
操作步骤：

创建配置类，替代 xml 配置文件：
@Configuration  // 将该类作为配置类，代替xml文件
// 等价于配置文件中的<context:component-scan base-package="com.psj"></context:component-scan>
@ComponentScan(basePackages = {"com.psj"})
public class SpringConfig {}
编写测试类：
// 不是加载配置文件，而是加载类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
EmpService empService = context.getBean("empService", EmpService.class);
empService.add();

Spring框架-IOC相关推荐

Spring框架 IOC
IOC(Inversion Of Control) 功能将主动通过new实例化的过程,交给Spring负责 Control:控制类的对象 Inversion:转交给Spring负责核心作用:解耦( ...
Spring 框架 IOC 与 DI 的总结
一:Spring并天下 1:Spring帝国: ①:Spring崛起什么是Spring:源于Rod Johnson在其著作<Expert one on one J2EE design and ...
Spring框架IOC的实现
工程目录: Client package demo;public class Client {static TVFactory factory;static TV tv;public static v ...
Spring框架(IoC、AOP面向接口切面)
新建一个Maven工程 Spring框架是由于软件开发的复杂性而创建的.Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅仅限于服务器端的开发. ...
Spring框架——IOC、DI
本篇博客主要介绍Java中的IOC和DI,以及在String框架中的应用.首先,我们将对IOC和DI进行概念介绍,然后讲解它们的关系及在String框架中的应用,最后通过一个实例来展示它们的具体用法. ...
Spring框架IoC/DI原理及实现
1.概念 IoC:指将对象的创建权,交给到Spring容器: DI :指Spring创建对象的过程中,将对象依赖的属性通过配置的方式自动的设值给当前的对象 . IoC/DI注解详解完成IoC/DI, ...
Spring框架IOC基础及XML的配置第二章
1 Spring概述 1.1 关于框架框架的概念框架:特指软件框架,它是我们在实际开发中解决项目需求的技术集合.运用框架可以大大简化代码的编写,缩短开发周期.同时,对后续负责项目维护的人员降低技术 ...
三大框架之spring框架+IoC控制反转、DI依赖注入
三大框架:业务层框架Spring+IoC+DI 往期文章:jsp与cookie.重定向与RESTFul架构支持下一章节: 持久层框架MyBatis 初识Spring框架 MyBatis 入门http ...
spring框架ioc（控制反转）第二讲
配置applicationContext.xml: spring的ioc容器的配置文件:applicationContext.xml(默认名称) 配置schema约束: http://www.spri ...

Spring框架-IOC

1.框架概述

2.入门案例

3.IOC

3.1 什么是IOC

3.2 底层原理

3.3 操作 Bean 管理

3.3.1 什么是 Bean 管理

3.3.2 基于 xml 方式

3.3.3 IOC 操作 Bean 管理-FactoryBean

3.3.4 IOC 操作 Bean 管理-bean 作用域

3.3.5 IOC 操作 Bean 管理-bean 生命周期

3.3.6 IOC 操作 Bean 管理-xml 自动装配

3.3.7 IOC 操作 Bean 管理-外部属性文件

3.3.8 IOC 操作 Bean 管理-基于注解方式

3.3.9 完全注解开发

Spring框架-IOC相关推荐

最新文章

热门文章