文章目录

  • IOC容器
    • 一、IOC底层原理
    • 二、IOC接口
    • 三、Bean管理
      • IOC操作Bean管理(基于xml)
        • 1、基于XML配置文件创建对象
        • 2、基于XML方式注入属性
        • 3、第一种注入方式:set方式注入
        • 4、第二种注入方式:有参构造函数注入
        • 5、p名称空间注入(了解即可)
      • IOC操作Bean管理(xml注入其他类型属性)
        • 1、字面量
        • 2、注入属性—外部Bean
        • 3、注入属性—内部Bean
        • 4、注入属性—级联赋值
      • IOC操作Bean管理(xml注入集合属性)
        • 1、创建类
        • 2、在spring配置文件进行配置
        • 3、在集合里面设置对象类型值
        • 4、把集合注入部分提取出来
      • IOC操作Bean管理(FactoryBean)
        • 1、Spring有两种类型bean
        • 2、普通bean
        • 3、工厂bean
      • IOC操作Bean管理(bean 作用域)
        • 1、在Spring里面,设置创建bean实例是单实例还是多实例
        • 2、在Spring里面,默认情况下,`bean是单实例对象`
        • 3、如何设置单实例还是多实例
      • IOC操作Bean管理(bean生命周期)
        • 1、生命周期
        • 2、bean生命周期
          • (1)通过构造器`创建bean实例`(无参构造)
          • (2)为bean设置`属性值`和对其他bean`引用`(调用set方法)
          • (3)调用bean的`初始化`的方法(需要进行配置)
          • (4)bean`可以使用了`(对象获取到了)
          • (5)当容器关闭时候,调用bean`销毁`的方法(需要进行配置销毁的方法)
        • 3、bean的后置处理器
      • IOC操作Bean管理(xml自动装配)
        • 1、什么是自动装配
        • 2、演示自动装配过程
      • IOC操作Bean管理(外部属性文件)
        • 1、直接配置数据库信息
        • 2、引入外部属性文件配置数据库连接池
      • IOC操作Bean管理(基于注解方式)
        • 1、什么是注解
        • 2、Spring针对Bean管理中创建对象提供注解
        • 3、基于注解方式实现对象创建
        • 4、开启组件扫描细节配置
        • 5、基于注解方式实现属性注入
          • (1)第一步:把service和dao对象创建,在service和dao类添加创建对象注解
          • (2)第二步:在service注入dao对象,在service类添加dao类型属性,在属性上面使用
        • 6、完全注解开发

IOC容器

一、IOC底层原理

1、什么是IOC

(1)即:控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理

(2)使用IOC目的:为了降低耦合度

(3)上篇文章中的Spring快速上手就是IOC实现

2、IOC底层原理

(1)xml解析、工厂模式、反射

3、画图讲解IOC底层原理

二、IOC接口

1、IOC思想基于IOC容器完成,IOC容器底层就是对象工厂

2、Spring提供IOC容器实现的两种方式(两个接口)

​ (1)BeanFactory接口:IOC容器基本实现是Spring内部接口的使用接口,不提供给开发人员进行使用(加载配置文件时候不会创建对象,在获取对象时才会创建对象。)

(2)ApplicationContext接口:BeanFactory接口的子接口,提供更多更强大的功能,提供给开发人员使用(加载配置文件时候就会把在配置文件对象进行创建)推荐使用

3、ApplicationContext接口有实现类

三、Bean管理

1、什么是Bean管理

Bean管理就是两个操作:

1、Spring创建对象

2、Spring注入属性

IOC操作Bean管理(基于xml)

1、基于XML配置文件创建对象

<bean id="hello" class="com.jin.pojo.Hello"></bean>

(1)在Spring配置文件中,使用bean标签,标签里面添加对应属性,就可以实现对象创建

(2)在Bean标签有很多属性,介绍常用的属性

  • id属性:唯一标识
  • class属性:类全路径(包类路径)

(3)创建对象时候,默认也是执行无参数构造方法完成对象创建

2、基于XML方式注入属性

(1)DI:依赖注入,也就是注入属性

3、第一种注入方式:set方式注入

//(1)传统方式: 创建类,定义属性和对应的set方法public class Book {//创建属性private String bname; //创建属性对应的set方法public void setBname(String bname) {this.bname = bname;}}
<bean id="book" class="com.jin.pojo.Book"><property name="bname" value="Hello"></property></bean>

4、第二种注入方式:有参构造函数注入

//(1)传统方式:创建类,构建有参函数public class Orders {//属性private String oname;private String address;//有参数构造public Orders(String oname,String address) {this.oname = oname;this.address = address;}}
<bean id="orders" class="com.jin.pojo.Orders"><constructor-arg name="oname" value="Hello"></constructor-arg><constructor-arg name="address" value="China!"></constructor-arg></bean>

5、p名称空间注入(了解即可)

<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--><bean id="book" class="com.jin.pojo.Hello" p:name="酷小亚" p:address="酷啊"/></beans>

IOC操作Bean管理(xml注入其他类型属性)

1、字面量

(1)null值

 <bean id="book" class="com.jin.pojo.Hello"><property name="name" value="酷小亚"></property> <property name="address"> <null/> </property> </bean>

(2)属性值包含特殊符号

 <bean id="book" class="com.jin.pojo.Hello"> <!--属性值包含特殊符号1、把进行转义2、把带特殊符号内容写到CDATA--><property name="address" ><value><![CDATA[<>]]></value></property> </bean>

2、注入属性—外部Bean

(1)创建两个类:service类和dao类

(2)在service调用dao里面的方法

//dao类public interface UserDao { void update();}//dao接口实现类public class UserDaoImpl implements UserDao {@Overridepublic void update() {System.out.println("dao update...........");}}//service类public class UserService {//创建UserDao类型属性,生成set方法private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void add() {System.out.println("service add...............");userDao.update();//调用dao方法}}

(3)在spring配置文件中进行配置

<bean id="userService" class="com.jin.service.UserService"><property name="userDao" ref="userDaoImpl"></property></bean><bean id="userDaoImpl" class="com.jin.dao.UserDaoImpl"></bean>

(4)测试代码

 @Testpublic void testAdd(){//1、加载spring配置文件ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");//2、获取配置创建的对象UserService userService = context.getBean("userService", UserService.class);userService.add();}

.

3、注入属性—内部Bean

(1)一对多关系:部门和员工

部门和员工 一个部门有多个员工,一个员工属于一个部门(部门是一,员工是多)

(2)在实体类之间表示一对多关系

员工表示所属部门,使用对象类型属性进行表示

//部门类public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;} @Overridepublic String toString() {return "Dept{" +"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;}public void add(){ System.out.println(ename+"::"+gender+"::"+dept);}}

(3)在spring配置文件中进行配置

 <bean id="emp" class="com.jin.pojo.Emp"><property name="ename" value="酷小亚"></property><property name="gender" value=""></property><property name="dept"><bean id="dept" class="com.jin.pojo.Dept"><property name="dname" value="安保部"></property></bean></property></bean>

(4)测试代码

 @Testpublic void testAdd(){//1、加载spring配置文件ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");//2、获取配置创建的对象Emp emp = context.getBean("emp", Emp.class);emp.add();}

.

4、注入属性—级联赋值

(1)第一种写法

 <bean id="emp" class="com.jin.pojo.Emp"><property name="ename" value="Andy"></property><property name="gender" value=""></property><property name="dept" ref="dept"></property></bean><bean id="dept" class="com.jin.pojo.Dept"><property name="dname" value="公关部门"></property></bean>

(2)第二种写法

 //方式二:生成dept的get方法(get方法必须有!!)public Dept getDept() {return dept;}
 <bean id="emp" class="com.jin.pojo.Emp"><property name="ename" value="jams"></property><property name="gender" value=""></property><property name="dept" ref="dept"></property><property name="dept.dname" value="技术部门"></property></bean><bean id="dept" class="com.jin.pojo.Dept"></bean>

IOC操作Bean管理(xml注入集合属性)

1、创建类

定义数组、list、map、set类型属性,生成对应set方法

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;//...(生成set方法)... public void test(){System.out.println(Arrays.toString(courses));System.out.println(list);System.out.println(maps);System.out.println(sets);}}

2、在spring配置文件进行配置

(1)注入数组类型属性

 <bean id="stu" class="com.jin.pojo.Stu"><property name="courses"><array><value>java</value><value>go</value></array></property></bean>

(2)注入List集合类型属性

 <bean id="stu" class="com.jin.pojo.Stu"><property name="list"><list><value>酷小</value><value>小亚</value></list></property> </bean>

(3) 注入Map集合类型属性

 <bean id="stu" class="com.jin.pojo.Stu"><property name="sets"><set><value>MySQL</value><value>Redis</value></set></property></bean>

测试代码

@Testpublic void Test01(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");Stu stu = context.getBean("stu", Stu.class);stu.test();}

3、在集合里面设置对象类型值

//学生所学多门课程private List<Course> courseList;//创建集合public void setCourseList(List<Course> courseList) {this.courseList = courseList;}
public class Course {//课程类private String cname;public void setCname(String cname) {this.cname = cname;}}
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course"><property name="cname" value="Spring5框架"></property></bean><bean id="course2" class="com.atguigu.spring5.collectiontype.Course"><property name="cname" value="MyBatis框架"></property></bean>
 <property name="courseList"> <list> <ref bean="course1"></ref> <ref bean="course2"></ref> </list> </property>

4、把集合注入部分提取出来

(1)在spring配置文件中引入名称空间util

//实体类Bookpublic class Book {private List<String> bookList;public void setBookList(List<String> bookList) {this.bookList = bookList;}public void test(){System.out.println(bookList);}}
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"></beans>

(2)使用util标签完成list集合注入提取

<bean id="book" class="com.jin.pojo.Book"><property name="bookList" ref="bookList"></property></bean><util:list id="bookList"><value>七龙珠</value><value>西游记</value><value>海贼王</value></util:list>
@Testpublic void Test02(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");Book book = context.getBean("book", Book.class);book.test();}

.

IOC操作Bean管理(FactoryBean)

1、Spring有两种类型bean

即:一种 普通bean,另一种工厂bean(FactoryBean)

2、普通bean

在配置文件中定义bean类型就是返回类型

3、工厂bean

即:在配置文件中定义bean类型可以和返回类型不一样

(1)创建类,让这个类作为工厂bean,实现接口FactoryBean

package com.jin.pojo;import org.springframework.beans.factory.FactoryBean;public class MyBean implements FactoryBean<Course> {//定义返回bean@Overridepublic Course getObject() throws Exception {Course course = new Course();course.setCname("abc");return course;}@Overridepublic Class<" />> getObjectType() {return null;}@Overridepublic boolean isSingleton() {return FactoryBean.super.isSingleton();}}

(2)实现接口里面的方法,在实现的方法中定义返回的bean类型

<bean id="myBean" class="com.jin.pojo.MyBean"></bean>

(3)测试代码

@Testpublic void Test03(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");Course course = context.getBean("myBean", Course.class);System.out.println(course);}

.

IOC操作Bean管理(bean 作用域)

1、在Spring里面,设置创建bean实例是单实例还是多实例

2、在Spring里面,默认情况下,bean是单实例对象

3、如何设置单实例还是多实例

(1)在Spring配置文件bean标签里面有属性(scope)用于设置单实例还是多实例

(2)scope 属性值

  • singleton : (默认值)表示单实例对象
  • prototype : 多实例对象

.

(3)singleton 和 prototype区别

  • singleton 单实例,prototype多实例
  • 设置scope值是singleton时候,是加载spring配置文件时候就会创建单实例对象
  • 设置scope值是prototype时候,不是在加载spring配置文件时候创建对象,而是在调用getBean方法时候创建多实例对象

IOC操作Bean管理(bean生命周期)

1、生命周期

(1)从对象创建到对象销毁的过程

2、bean生命周期

(1)通过构造器创建bean实例(无参构造)
public class Orders {private String oname;//无参数构造public Orders() {System.out.println("第一步 执行无参数构造创建bean实例");}}
(2)为bean设置属性值和对其他bean引用(调用set方法)
public void setOname(String oname) {this.oname = oname;System.out.println("第二步 调用set方法设置属性值");}
<bean id="orders" class="com.jin.pojo.Orders"><property name="oname" value="手机"></property></bean>
(3)调用bean的初始化的方法(需要进行配置)
 //创建执行的初始化的方法public void initMethod(){System.out.println("第三步 执行初始化方法");}

(4)bean可以使用了(对象获取到了)
@Testpublic void Test04(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");Orders orders = context.getBean("orders", Orders.class);System.out.println("第四步 获取创建bean实例对象");System.out.println(orders);}
(5)当容器关闭时候,调用bean销毁的方法(需要进行配置销毁的方法)
//创建执行的销毁的方法public void destroyMethod(){System.out.println("第五步 执行销毁的方法");}

3、bean的后置处理器

bean 的后置处理器,bean 生命周期有七步 (正常生命周期为五步,而配置后置处理器完成后为七步)

​ (1)通过构造器创建 bean 实例(无参数构造)

​ (2)为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)

(3)把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

​ (4)调用 bean 的初始化的方法(需要进行配置初始化的方法)

​ (5)把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

​ (6)bean 可以使用了(对象获取到了)

​ (7)当容器关闭时候,调用 bean 的销毁的方法(需要进行配置销毁的方法)

4、演示添加后置处理器效果

(1)创建类,实现接口BeanPostProcessor,创建后置处理器

public class MyBeanPost implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("在初始化之前执行的方法");return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("在初始化之后执行的方法");return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);}}

.

IOC操作Bean管理(xml自动装配)

1、什么是自动装配

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

2、演示自动装配过程

创建两个类Dept、Emp

//部门类public class Dept {@Overridepublic String toString() {return "Dept{}";}}//员工类public class Emp { private Dept dept;//员工属于什么部门public void setDept(Dept dept) {this.dept = dept;}@Overridepublic String toString() {return "Emp{" +"dept=" + dept +'}';}}

(1)方式一:根据属性名称byName自动注入

<!----><!----><!----><!----><bean id="emp" class="com.jin.autowire.Emp" autowire="byName"> </bean><bean id="dept" class="com.jin.autowire.Dept"></bean></beans>

(2)方式二:根据属性类型byType自动注入

 <bean id="emp" class="com.jin.autowire.Emp" autowire="byType"></bean><bean id="dept" class="com.jin.autowire.Dept"></bean></beans>

IOC操作Bean管理(外部属性文件)

1、直接配置数据库信息

(1)引入德鲁伊(druid)连接池依赖jar包

德鲁伊连接池jar包下载地址: https://repo1.maven.org/maven2/com/alibaba/druid/

.

或者(导入依赖)

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.8</version></dependency>

(2)配置德鲁伊连接池

<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/springdb"></property><property name="username" value="root"></property><property name="password" value="123456"></property></bean>

2、引入外部属性文件配置数据库连接池

(1)创建外部属性文件,properties格式文件,写数据库信息

driverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/springdbuserName=rootpassWord=123456

(2)把外部properties 属性文件引入到spring配置文件中

首先引入context名称空间(类似p名称空间注入)

<context:property-placeholder location="classpath:jdbc.properties"/><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${driverClassName}"></property><property name="url" value="${url}"></property><property name="username" value="${userName}"></property><property name="password" value="${passWord}"></property></bean>

IOC操作Bean管理(基于注解方式)

1、什么是注解

(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值…)

(2)使用注解,注解作用在 类上面、方法上面、属性上面

(3)使用注解目的:简化xml配置

2、Spring针对Bean管理中创建对象提供注解

都可以用来创建bean实例,但是四个注解功能是一样的

(1)@Component

(2)@Service

(3)@Controller

(4)@Repository

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

(1)第一步:引入依赖

<dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.22</version></dependency>

(2)第二步:开启组件扫描

首先引入context名称空间(类似p名称空间注入)

 <context:component-scan base-package="com.jin"></context:component-scan>

(3)第三步:创建类,在类上面创建对象注解

//在注解里面value属性值可以省略不写//默认值是类名称,首字母小写User --> user@Component(value = "user") //类似 public class User {public void add(){System.out.println("User add ...");}

(4)第四步:测试代码

@Testpublic void MyTest02(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");User user = context.getBean("user", User.class);user.add();}

.

4、开启组件扫描细节配置

(1)自定义扫描配置,扫描哪些需要的注解

<context:component-scan base-package="com.jin" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/></context:component-scan>

(2)自定义扫描配置,哪些注解不进行扫描

 <context:component-scan base-package="com.jin" use-default-filters="false"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/></context:component-scan>

5、基于注解方式实现属性注入

  • @AutoWired :根据属性类型进行自动装配
  • @Qualifier :根据属性名称进行注入,(要和上面的@AutoWired一起使用)

以防一个接口拥有多个实现类,所有要使用@Qualifier这个限定词!

代码如: @Qualifier(value = “userDaoImpl2” )

  • @Resource :可以根据类型注入,也可以根据名称注入不推荐使用

可以说是@AutoWired 和 @Qualifier 的集合

代码如:@Resource(name = “userDaoImpl2”)

因为@Resource 是javax(java扩展包)中的注解,不是springframework中的注解。所以不推荐使用!

  • @Value :注入普通类型属性
@Value("abc")private String name;System.out.println(name);
(1)第一步:把service和dao对象创建,在service和dao类添加创建对象注解
(2)第二步:在service注入dao对象,在service类添加dao类型属性,在属性上面使用
//dao接口public interface UserDao {public void add();}//dao接口实现类@Repositorypublic class UserDaoImpl implements UserDao{@Overridepublic void add() {System.out.println("dao add ...");}}//service类@Servicepublic class UserService {//定义dao类型属性//不需要添加set方法//添加注入属性注解@Autowiredprivate UserDao userDao;public void add(){System.out.println("service add ...");userDao.add();}}

6、完全注解开发

(1)创建配置类,代替xml配置文件

@Configuration //作为配置类,替代xml配置文件@ComponentScan(basePackages = {"com.jin"})public class SpringConfig {}

(2)编写测试类

@Testpublic void MyTest04(){//创建AnnotationConfigApplicationContext(注解配置应用语境)对象AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);UserService userService = context.getBean("userService", UserService.class);userService.add();}