Spring5·IOC部分

spring5

• 1.基本概念
• • 1.1概述
  • 1.2特点
  • 1.3入门案例
• 2.IOC容器
• • 2.1IOC底层原理
  • 2.2IOC接口
  • 2.3IOC *** 作Bean管理(基于xml)
  • 2.4IOC *** 作Bean管理(基于注解)

1.基本概念 1.1概述

1.Spring是轻量级的开源的JavaEE框架
2.Spring可以解决企业应用开发的复杂性
3.Spring有两个核心部分：IOC和Aop
IOC:控制反转，把创建对象过程交给Spring进行管理
Aop:面向切面，在不修改源代码的情况下，进行功能增强

1.2特点

1.方便解耦，简化开发
2.Aop编程支持
3.方便程序测试
4.方便和其他框架进行整合
5.方便进行事务 *** 作
6.降低API开发难度

1.3入门案例

1.下载Spring (官网本版后带GA表示稳定版)

2.下载地址
（https://repo.spring.io/ui/native/release/org/springframework/spring/）

3.在IDEA中，创建普通Java工程

4.导入相关jar包

5.创建一个类，在这个类中创建一个普通的方法

6.创建Spring配置文件，在配置文件中配置要创建的对象
6.1Spring配置文件使用xml格式

7.进行测试代码编写

2.IOC容器 2.1IOC底层原理

1.什么是IOC

• 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
• 使用IOC的目的：为了降低耦合度
• 之前做的入门案例就是IOC实现

2.IOC底层实现

• xml解析
• 工厂模式
• 反射

3.画图讲解IOC底层原理

工厂模式可以降低耦合度，但是不可以降低到最低限度

Spring的IOC中使用工厂模式结合xml解析，反射则可以使耦合度降低到最低限度

2.2IOC接口

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

2. Spring提供IOC容器实现两种方式：(两种接口)

   1. BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员使用。加载配置文件时不会创建对象，在获取对象(使用对象)才会去创建对象
   2. ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员使用。加载配置文件时候就会把在配置文件对象进行创建

3. ApplicationContext接口的实现类的理解
   

2.3IOC *** 作Bean管理(基于xml)

什么是Bean管理

• Bean管理指的是两个 *** 作
  • Spring创建对象
  • Spring注入属性

Bean管理 *** 作有两种方式

• 1.基于xml配置文件方式实现
• 2.基于注解方式实现

IOC *** 作Bean管理(基于xml)

1.基于xml方式创建对象

2. 在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象的创建
3. 介绍bean标签里的常用属性：id:唯一的标识符，class: 值为类的全限定名称
4. 创建对象时，默认也是执行无参构造方法完成对象创建

2.基于xml方式注入属性
       DI:依赖注入，就是注入属性

第一种注入方式：使用set方法进行注入

1.创建类，定义属性和对应的set方法

2.在Spring配置文件中配置对象创建，配置属性注入

    <bean id="Book" class="com.it.domain.Book">
        
        <property name="name" value="周星驰">property>
        <property name="age" value="55">property>
    bean>

第二种注入方式：使用有参数构造函数进行注入

1.创建类，定义属性，创建有参构造函数
2.在Spring配置文件中进行配置

<bean id="Teacher" class="com.it.domain.Teacher">
        
        <constructor-arg name="id" value="1001">constructor-arg>
        <constructor-arg name="name" value="坂井泉水">constructor-arg>
        <constructor-arg index="2" value="18">constructor-arg>
    bean>

3.p名称空间注入
        使用p名称空间注入，可以简化基于xml配置方式

第一步：添加p名称空间在配置文件中
第二步：进行属性注入，在bean标签里面进行 *** 作

底层用到的还是set方法，所有可以用此方法简化set注入属性的配置文件,但是不能简化有参构造函数注入属性的配置文件

4.注入空值和特殊符号

1.注入空值(null)

2.特殊字符

• 可以使用转义符号（< 表示: < > 表示: >）
• 也可以使用
  

5.注入外部bean和级联赋值

1. 创建两个类student和animal

2. 在student中创建Animal类型属性，生成set方法，可以调用animal里面的方法，属性
   

3. 在Spring配置文件中进行设置
   

6.注入内部bean

1. 一对多关系：部门和员工(部门是一，员工是多)
2. 创建两个类
   
3. 在Spring配置文件中进行配置
   

7.注入集合类型属性

1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
4.注入Set集合类型属性



细节问题
1.在集合里面设置对象类型值

bean管理(Spring有两种类型bean，一种是bean，另一种是工厂bean(FactoryBean))

1.普通bean: 在配置文件中定义bean类型就是返回类型
2.工厂bean:在配置文件中定义bean类型可以和返回类型不一样

• 第一步：创建类，实现接口FactoryBean，让这个类作为工厂bean
  

• 第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型
  
  

bean的作用域：指在Spring里面，设置创建bena实例是单实例还是多实例

1.在Spring里面，默认情况下，bean是单实例对象
2.如何设置单实例或多实例

• Spring配置文件中bean标签的scope属性用于设置单实例或多实例
• scope的值
  • 默认是 singleton 表示是单实例对象
  • prototype 表示是多实例对象

3.singleton和prototype的区别

• scope=singleton时,加载spring配置文件时候就会创建单实例对象
• scope=prototyep时,在调用getBean方法时候创建多实例对象

bean的生命周期:从对象创建到对象销毁的过程

1.通过构造器创建bean实例(无参构造器)
2.为bean的属性设置值和对其他bean引用(调用set方法)
3.调用bean的初始化的方法(需要进行配置初始化的方法，bean标签中的init-method属性)，
4.bean可以使用了(对象获取到了)
5.当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法，bean标签中的destroy-method属性)

如果bean加了后置处理器，则bean的声明周期有7步

1.通过构造器创建bean实例(无参构造器)
2.为bean的属性设置值和对其他bean引用(调用set方法)
3.把bean实例传递给bean后置处理器的方法
4.调用bean的初始化的方法(需要进行配置初始化的方法，bean标签中的init-method属性)
5.把bean实例传递给bean后置处理器另一个的方法
6.bean可以使用了(对象获取到了)
7.当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法，bean标签中的destroy-method属性)

演示添加后置处理器的效果
1.创建类，实现接口BeanPostProcessor,创建后置处理器

public class MyBean implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

2.配置后置处理器

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="bean" class="com.it.Bean.bean" init-method="a" destroy-method="b">
        <property name="name" value="玩偶">property>
    bean>

    <bean id="myBean" class="com.it.Bean.MyBean">bean>

beans>

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

    <bean id="emp" class="com.it.duo.Emp" autowire="byType">bean>
    <bean id="dept" class="com.it.duo.Dept">bean>

基于xml的外部属性文件

举例数据库连接池
1.创建外部属性文件，properties格式文件，

2.把外部properties属性文件引入到spring配置文件中
①引入contest名称空间
②在Spring配置文件中使用标签引入外部属性文件

<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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

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


beans>

2.4IOC *** 作Bean管理(基于注解)

1.什么是注解

1.注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值······)
2.使用注解，注解可以用在类上面，方法上面，属性上面
3.使用注解目的：简化xml配置

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

1.@Component
2.@Service
3.@Controller
4.@Repository
上面四个注解功能是一样的，都可以用来创建bean实例

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

1.引入依赖

2.开启组件扫描
①先在配置文件中引入context空间名称
②

 
    <context:component-scan base-package="com.it.dao,com.it.A">context:component-scan>

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

//在注解里面value属性值可以省略不写
//默认值是首字母小写的类名称(userService)
@Component(value= "lhk") //相当于
public class UserService {

    public void add(){
        System.out.println("D················");
    }
}

4.组件扫描细节配置

示例一

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

示例二

    <context:component-scan base-package="com.it">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    context:component-scan>

5.实现属性注入

1.@Autowired: 根据属性类型进行自动装配
①创建两个类，添加创建对象的注解，创建对象
②在类A中注入类B对象: 在类A中添加B类型的属性，在属性上面使用注解

@Component(value= "lhk") //相当于
public class UserService {
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("UserService················");
        userDao.add();
    }
}

2.@Qualifier：根据属性名称进行注入
这个@Qualifier注解的使用，和上面@Autowired一起使用

//在注解里面value属性值可以省略不写
//默认值是首字母小写的类名称(userService)
@Component(value= "lhk") //相当于
public class UserService {
    @Autowired
    @Qualifier(value = "ud")//根据名称来注入
    private UserDaoImpl userDao;
    public void add(){
        System.out.println("UserService················");
        userDao.add();
    }
}
******************************************************
@Component(value = "ud")
public class UserDaoImpl implements UaerDao {

    @Override
    public void add() {
        System.out.println("UserDaoImpl··········");
    }
}

3.@Resource: 根据属性类型注入，也可以根据属性名称注入

//在注解里面value属性值可以省略不写
//默认值是首字母小写的类名称(userService)
@Component(value = "lhk") //相当于
public class UserService {
//    @Autowired
//    @Qualifier(value = "ud")//根据名称来注入
//    private UserDaoImpl userDao;

    //@Resource//根据类型注入
    @Resource(name = "ud")//根据名称注入
    private UserDaoImpl userDao;

    public void add() {
        System.out.println("UserService················");
        userDao.add();
    }
}

4.@Value：注入普通类型属性

    @Value(value="玩偶")
    private String name;
    @Value(value = "18")
    private Integer age;

6.完全注解开发（其它不变）

1.创建配置类，替代xml配置文件

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.it.wan"})//相当于
public class Xml {

}

2.编写测试类

 @Test
    public void test03() {
        ApplicationContext context = new AnnotationConfigApplicationContext(Xml.class);
        UserService lhk = context.getBean("lhk", UserService.class);
        lhk.add();
    }