Spring5——IOC

IOC

1 IOC?

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

使用ioc目的：解耦

2 底层原理

xml解析、工厂模式、反射

下图是工厂模式解耦

IOC解耦过程：

1、xml配置文件，配置创建的对象：

2、service类和dao类：创建工厂类，newInstance创建对象

3 IOC接口

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

2、Spring提供IOC容器实现的两种方式：（两个接口）

BeanFactory：IOC容器最基本的实现方式，是Spring内部使用的接口，开发中不去使用。加载配置文件的时候不会创建对象，在获取对象的时候才会创建

ApplicationContext：BeanFactory接口的子接口，提供了更多更强大的功能，开发使用。加载配置文件的时候就会创建对象

3、ApplicationContext接口有实现类：File…是绝对路径。Class…是相对路径

4 IOC操作Bean管理

4.1 基本定义

1、Bean管理？Bean管理指的是两个操作：

Spring创建对象

Spring注入属性

2、Bean管理操作的两种方式

基于xml配置文件方式实现

基于注解方式实现

4.2 基于xml方式

4.2.1 基于xml方式创建对象

①在spring配置文件中，使用bean标签，添加对应属性，就可实现对象的创建

②在bean标签里面有常用的属性：

id属性：唯一标识

class属性：类全路径

name属性：同id属性，早期使用现在都用id

③创建对象的时候，默认也是执行无参的构造方法（只有有参会报错，默认不写构造就是无参）

4.2.2 基于xml方式注入属性

①DI：依赖注入，就是注入属性，是IOC的具体实现

第一种注入的方式：使用Set方式

第二种注入的方式：使用有参数的构造

方法声明：

public class Orders {
private String onname;
private String address;

//有参数构造
public Orders(String onname, String address) {
  this.onname = onname;
  this.address = address;
}
}

配置文件配置

<bean id="orders" class="com.znv.spring.Orders">
<constructor-arg name="oname" value="iphone13"></constructor-arg>
<constructor-arg name="address" value="南京市江宁区胜太路"></constructor-arg>
<!--这种表示构造方法第一个参数设置为多少，是按照下标索引从0开始<constructor-arg index="0" value=""></constructor-arg>-->
</bean>

第三种p名称空间注入

p注入方法：添加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"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="book" class="com.znv.spring.Book" p:bname="三国演义" p:bauthor="罗贯中"></bean>

4.2.3 基于xml注入空值和特殊符号

1 字面量

null值

<!--null值-->
<property name="address">
<null/>
</property>

属性值包含特殊符号

  <!--属性包含特殊符号
      1 把<>进行转义
      2 把特殊符号内容写到CDATA
  -->
  <property name="address">
      <value><![CDATA[<<南京>>]]></value>
  </property>

4.2.4 基于xml注入外部bean

1 演示

创建两个类servic类和dao类——>在service调用dao里面的方法

public class UserService {

//创建UserDao类型属性，生成Set方法
private UserDao userDao;

public void setUserDao(UserDao userDao) {
  this.userDao = userDao;
}

public void add(){
  System.out.println("service add start ...");

//        原始方式创建UserDao对象
//        UserDao userDao = new UserDaoImpl();
//        userDao.update();

}
}

<bean id="userService" class="com.znv.spring.service.UserService">
  <!--注入userDao对象
      name属性：类里面属性名称
      ref属性：创建userDao对象bean标签id值
  -->
  <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.znv.spring.dao.UserDaoImpl"></bean>

4.2.5 基于xml注入内部bean和级联赋值

1、一对多关系：举例比如部门和员工，部门是一，员工是多

2、在实体类中表示一对多的关系

//部门类
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;
}
}

3、在Spring配置文件中进行配置

<!--内部bean-->
<bean id="emp" class="com.znv.spring.bean.Emp">
  <!--先设置两个普通的属性-->
  <property name="ename" value="youpei"></property>
  <property name="gender" value="男"></property>
  <!--设置对象类型属性-->
  <property name="dept">
      <bean id="dept" class="com.znv.spring.bean.Dept">
          <property name="dname" value="研发中心"></property>
      </bean>
  </property>
</bean>

4、级联赋值

（1）、第一种

<!--内部bean-->
<bean id="emp" class="com.znv.spring.bean.Emp">
  <!--先设置两个普通的属性-->
  <property name="ename" value="youpei"></property>
  <property name="gender" value="男"></property>
  <!--级联赋值-->
  <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.znv.spring.bean.Dept">
  <property name="dname" value="财务部"></property>
</bean>

（2）、第二种

<!--内部bean-->
<bean id="emp" class="com.znv.spring.bean.Emp">
  <!--先设置两个普通的属性-->
  <property name="ename" value="youpei"></property>
  <property name="gender" value="男"></property>
  <!--级联赋值，dept属性需要有get方法-->
  <property name="dept" ref="dept"></property>
  <property name="dept.dname" value="人事部"></property>
</bean>
<bean id="dept" class="com.znv.spring.bean.Dept">
  <property name="dname" value="财务部"></property>
</bean>

4.2.6 基于xml注入集合类型属性

1、注入数组类型属性

2、注入list集合类型属性

3、注入Map集合类型属性

（1）、创建类定义各集合类型属性

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;

public void setSets(Set<String> sets) {
  this.sets = sets;
}

public void setList(List<String> list) {
  this.list = list;
}

public void setMaps(Map<String, String> maps) {
  this.maps = maps;
}

public void setCourses(String[] courses) {
  this.courses = courses;
}

}

（2）、在spring配置文件配置

<!--集合类型属性注入-->
<bean id="stu" class="com.znv.spring.demo2.collectiontype.Stu">
  <!--数组类型属性注入-->
  <property name="courses">
      <array>
          <value>hadoop课程</value>
          <value>spark课程</value>
      </array>
  </property>
  <!--List类型属性注入-->
  <property name="list">
      <list>
          <value>都是MR模型</value>
          <value>都可作为hive执行引擎</value>
      </list>
  </property>
  <!--Map类型属性注入-->
  <property name="maps">
      <map>
          <entry key="HADOOP" value="两次shuffle中间过程落盘"></entry>
          <entry key="SPARK" value="两次shuffle中间过程不落盘"></entry>
      </map>
  </property>
  <!--Set类型属性注入-->
  <property name="sets">
      <set>
          <value>Hadoop执行完一个task就释放该task资源</value>
          <value>spark先把资源拿到手全部执行完再放手</value>
      </set>
  </property>
</bean>

4、在集合里面设置对象的值

  <!--List集合类型属性注入，但值是对象-->
  <property name="courseList">
      <list>
          <ref bean="course1"></ref>
          <ref bean="course2"></ref>
      </list>
  </property>
  
      <!--创建多个course对象-->
<bean id="course1" class="com.znv.spring.demo2.collectiontype.Course">
  <property name="cname" value="Kafka课程"></property>
</bean>
<bean id="course2" class="com.znv.spring.demo2.collectiontype.Course">
  <property name="cname" value="Flink课程"></property>
</bean>

5、把集合注入的部分提取

（1）、在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"
 xmlns:p="http://www.springframework.org/schema/p"
 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">

（2）、使用util标签完成list集合注入提取

<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
  <value>elasticsearch权威指南</value>
  <value>hadoop权威指南</value>
  <value>hbase权威指南</value>
</util:list>

<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.znv.spring.demo2.collectiontype.Book">
  <property name="list" ref="bookList"></property>
</bean>

4.3 工厂bean(FactoryBean)

1、Spring有两种类型的bean，一种是普通的bean，另外一个是工厂bean(工厂bean)

2、普通bean：在配置文件中定义bean类型就是返回的类型

3、工厂bean：在配置文件定义的bean类型

第一步 创建类：该类作为工厂bean，实现接口FactoryBean；第二步 实现接口里面的实现方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {
/**
   * 定义返回bean
   *
   * @return
   * @throws Exception
   */
  @Override
  public Course getObject() throws Exception {
      Course course = new Course();
      course.setCname("scala");
      return course;
  }

  @Override
  public Class<?> getObjectType() {
      return null;
  }

  @Override
  public boolean isSingleton() {
      return false;
  }
}

  @Test
  public void test3(){
      ApplicationContext context = new ClassPathXmlApplicationContext("com/znv/spring/demo2/bean3.xml");
      Course course = context.getBean("myBean", Course.class);
      System.out.println(course);
  }

  <bean id="myBean" class="com.znv.spring.demo2.factorybean.MyBean"></bean>

4.4 bean的作用域

1、在spring里面，可以设置创建bean实例是单实例还是多实例

2、在spring里面，默认情况下，bean是一个单实例对象

  ApplicationContext context = new ClassPathXmlApplicationContext("com/znv/spring/demo2/bean2.xml");
  Book book1 = context.getBean("book", Book.class);
  //book.test();
  Book book2 = context.getBean("book", Book.class);
  System.out.println(book1);
  System.out.println(book2);
  
  //result
  com.znv.spring.demo2.collectiontype.Book@70a9f84e
  com.znv.spring.demo2.collectiontype.Book@70a9f84e

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

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

（2）scope属性：第一个值，默认值 singleton，表示单实例对象；第二个值prototype，表示多实例对象

<bean id="book" class="com.znv.spring.demo2.collectiontype.Book" scope="prototype">
  <property name="list" ref="bookList"></property>
</bean>

	<!--result-->
com.znv.spring.demo2.collectiontype.Book@130f889
com.znv.spring.demo2.collectiontype.Book@1188e820

（3）singleton和prototype区别

singleton单实例 prototype多实例；

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

request、session用的比较少，表示请求和会话

4.5 bean的生命周期

1、生命周期：从对象创建到销毁的过程

2、bean生命周期

（1）通过构造器创建bean的实例(无参构造)

（2）为bean的属性设置值和对其他bean的引用（调用set方法）

（3）调用bean的初始化的方法（需要配置）

（4）bean可以使用（对象获取）

（5）当容器关闭，调用bean的销毁的方法（需要配置销毁的方法）

3、演示bean生命周期

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("第五步 执行销毁的方法");
}

}

<bean id="orders" class="com.znv.spring.demo2.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
  <property name="oname" value="iPhone13"></property>
</bean>

@Test
public void testBean3() {
  ApplicationContext context = new ClassPathXmlApplicationContext("com/znv/spring/demo2/bean4.xml");
  Orders orders = context.getBean("orders", Orders.class);
  System.out.println("第四步 获取创建bean实例对象");
  System.out.println(orders);

  //手动让bean实例销毁
  ((ClassPathXmlApplicationContext) context).close();
}

4、加上bean的后置处理器，bean的生命周期有七步

（1）通过构造器创建bean的实例(无参构造)

（2）为bean的属性设置值和对其他bean的引用（调用set方法）

（3）把bean实例传递给bean后置处理器的方法postProcessBeforeInitialization

（4）调用bean的初始化的方法（需要配置）

（5）把bean实例传递给bean后置处理器的方法postProcessAfterInitialization

（6）bean可以使用（对象获取）

（7）当容器关闭，调用bean的销毁的方法（需要配置销毁的方法）

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

创建类，实现接口BeanPostProcessor，在spring配置文件中配置，只要配置，该配置文件中每个实例化对象都要执行后置处理器效果方法

public class MyBeanPost implements BeanPostProcessor {

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

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

<!--配置后置处理器-->
<bean id="myBeanPost" class="com.znv.spring.demo2.bean.MyBeanPost"></bean>

4.6 xml自动装配

1、定义

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

2、演示自动装配过程

（1）根据属性的名称自动装配，属性的名称

<bean id="emp" class="com.znv.spring.demo2.autowire.Emp" autowire="byName">
  <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.znv.spring.demo2.autowire.Dept"></bean>

（2）根据属性的类型自动注入，类的类型

<bean id="emp" class="com.znv.spring.demo2.autowire.Emp" autowire="byType">
  <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.znv.spring.demo2.autowire.Dept"></bean>

4.7 引入外部属性文件

1、直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池的jar包

<!--配置连接池-->
<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/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>

2、引入外部属性文件配置

（1）创建外部属性文件，properties格式文件，写数据库连接信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.usrName=root
prop.password=123456

（2）把外部properties属性文件引入到Spring配置文件中

引入context名称空间，等同于util引入

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

在spring配置文件使用标签引入外部属性文件

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  <property name="driverClassName" value="${prop.driverClass}"></property>
  <property name="url" value="${prop.url}"></property>
  <property name="username" value="${prop.usrName}"></property>
  <property name="password" value="${prop.password}"></property>
</bean>

4.8 基于注解方式

1、什么是注解？

（1）注解就是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值…)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解的目的：为了简化xml配置

4.8.1 创建对象

1、常见注解

（1）@Component 空注解

（2）@Service 业务逻辑层

（3）@Controller 外部层

（4）@Repository 持久层

四个注解功能是一样的，都可以创建bean的实例

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

第一步引入依赖spring-aop

第二步开启组件扫描

<?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"
 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">

	<!--开启组件扫描
  1 如果扫描多个包，可以使用逗号隔开
  2 扫描包上层目录
-->
<context:component-scan base-package="com.znv.spring.demo3"></context:component-scan>

第三步 创建类，在类上面添加创建对象的注解

// 注解里面value属性值可以省略。
// 默认是类名称，首字母小写 如下就是 UserService -- userService
@Component(value = "userService") //<bean id ="userService" class=".."/>
public class UserService {

public void add(){
  System.out.println("service add start ...");
}
}

4.8.2 组件扫描配置

<!--示例1
  use-default-filters="false" 表示不使用默认filter，自己配置filter
  context:include-filter 哪些内容需要扫描
  type="annotation" 根据注解来扫描
  expression 具体的注解
-->
<context:component-scan base-package="com.znv.spring.demo3" use-default-filters="false">
  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--示例2
      context:exclude-filter 哪些内容不需要扫描
      type="annotation" 根据注解来扫描
      expression 具体的注解
  -->
<context:component-scan base-package="com.znv.spring.demo3" use-default-filters="false">
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

4.8.3 注入属性@Autowired和Qualifer

（1）@Autowired 根据属性类型进行自动装配

第一步 service 和 dao 对象进行创建，并添加创建对象注解

第二步 service 注入 dao 对象，在 service 类添加 dao 类属性，在属性上使用注解

@Service
public class UserService {

//定义dao类型的属性
//不需要添加set方法
//添加注入属性注解
@Autowired
private UserDao userDao;

public void add(){
  System.out.println("service add start ...");
  userDao.add();
}
}

（2）@Qualifer 根据属性名称进行注入

@Qualifer注解的使用需要结合@Autowired一起使用

@Service
public class UserService {

//定义dao类型的属性
//不需要添加set方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImp111") //接口有多个实现类，根据名称可以指定类，默认首字母小写
private UserDao userDao;

public void add(){
  System.out.println("service add start ...");
  userDao.add();
}
}

@Repository(value = "userDaoImp111")
public class UserDaoImpl implements UserDao {
@Override
public void add() {
  System.out.println("dao add start ...");
}
}

（3）@Resource 可以根据类型注入，也可以根据名称注入

import javax.annotation.Resource;

这是java扩展包中不是spring中，所以spring不太推荐

   //@Resource //不加value会根据类型注入
   @Resource(name = "userDaoImp111") //name根据类名称注入
   private UserDao userDao;

（4）@Value 注入普通类型属性

   @Value(value = "youpei")
   private String name;

   public void add() {
       System.out.println("service add start ..." + name);
       userDao.add();
   }

4.8.4 完全注解开发

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

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

}

（2）编写测试类

   @Test
   public void testService2(){
       ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
       UserService userService = context.getBean("userService", UserService.class);
       System.out.println(userService);
       userService.add();
   }

删除线格式