Java基础之Spring5的核心之一IOC容器

一、什么是IOC

1）控制反转，把创建对象和对象的调用过程交给Spring 管理。

2）使用IOC的目的，为了降低耦合度。

二、IOC的底层原理

XML解析、工厂模式、反射

三、IOC思想

基于IOC容器完成，IOC容器底层就是对象工厂。

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

（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员使用

特点：加载配置文件的时候不会创建对象，在获取（使用）对象才去创建。

（2）ApplicationContext：BeanFactory接口的子接口。提供开发人员使用

特点：在加载配置文件的时候就创建对象

五、IOC操作之Bean管理

1、什么是Bean管理：

Bean管理指的是两个操作：
Spring创建对象
Spring注入值：手动注入、自动装配

<!--创建对象、自动装配
   bean标签里面的autowire属性：
       属性值：byName:根据属性名字注入值，id的值必须与类里面的属性名称一样
             byType:根据属性的类型注入值。
-->
<bean id="employee" class="tianfei.Spring5.autowire.Employee" autowire="byType">
   <!--手动装配-->
   <!--<property name="dept" ref="dept"></property>-->
</bean>

2、IOC操作之Bean管理两种方式

1）基于XML配置文件方式：

首先创建一个User类：

public class User {

private Integer id;
       private String name;

public User() {
       }

public User(Integer id, String name) {
           this.id = id;
           this.name = name;
       }

public void setId(Integer id) {
           this.id = id;
       }

public void setName(String name) {
           this.name = name;
       }

public void setAddress(String address) {
           this.address = address;
       }
   }

在XML配置文件中配置User对象：

<!--1、配置User对象
      id：为创建后的对象名，可自取
      class：为类的全路径
 -->
<bean id="user" class="tianfei.Spring5.User">
   <!--2、通过set方法注入属性
           通过property注入属性
                name ：类里面的属性
                value ：类里面属性对应的值
   -->
   <property name="id" value="1"></property>
   <property name="name" value="田飞"></property>

<!--通过有参构造注入属性-->
   <constructor-arg name="id" value="2"></constructor-arg>
   <constructor-arg name="name" value="张三"></constructor-arg>

<!--通过p名称空间注入属性
        使用前，需在xml标签属性中加入：xmlns:p="http://www.springframework.org/schema/p"
   -->
   <bean id="user" class="tianfei.Spring5.User" p:id="1" p:name="李四"></bean>
</bean>

测试类：

public class testDemo {
   @Test
   public void test() {
       //1、加载Spring5 的xml配置文件
       ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

//2、获取配置创建的对象
       User user = context.getBean("usera", User.class);

System.out.println(user);
   }
}

补充：在XML配置文件中引入外部文件（以jdbc.properties）

<!--引入外部文件  jdbc.properties
       需在名称空间中加入：xmlns:context="http://www.springframework.org/schema/context"
   -->
   <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

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

jdbc.properties配置文件内容如下：

prop.driverClassName=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userdb
prop.username=root
prop.password=tianfei

2）基于注解方式（以UserDao接口以及其实现类和UserService类为例）

public interface UserDao {
         public void add();
   }
       @Controller(value = "userDaoImpl")
   public class UserDaoImpl implements UserDao {

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

public UserDaoImpl() {
       }
   }

//value属性可以省略，如果省略则默认创建的对象名为  类名首字母小写  对象
@Service(value = "userService")
public class UserService {
   //基于注解注入基本类型数据
   @Value(value = "abc")
   private String str;

//基于注解注入对象类型值
//    @Autowired  //根据类型注入
//    @Qualifier(value = "userDaoImpl")  //根据名称注入 需要和 Autowired 一起使用
//    private UserDao userDao;

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

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

public void test() {
       System.out.println("userDao = " + userDao);
       System.out.println(str);
   }
}

测试类：

public class test {
   @Test
   public void test1(){
       //测试使用注解创建对象
       //需要在mxl配置文件中配置：<context:component-scan base-package="tianfei.Spring5"></context:component-scan> ，来开启注解扫描组件
       //不需要添加set方法
       ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

UserService userService = context.getBean("userService", UserService.class);

System.out.println(userService);
       userService.add();
       userService.test();
   }
   @Test
   public void test2(){
       //测试使用注解创建对象
       //不需要添加set方法
       //使用完全注解
       ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

UserService userService = context.getBean("userService", UserService.class);

System.out.println(userService);
       userService.add();
       userService.test();
   }
}

使用完全注解时需要创建一个类作为配置类：

@Configuration      //作为配置类，代替xml配置文件，进行完全注解开发
@ComponentScan(value = {"tianfei.Spring5"})
public class SpringConfig {
}

3、IOC操作Bean管理（工厂Bean）

Spring有两种Bean:

1）普通Bean：在配置文件中定义bean类型就是返回值类型

2）工厂Bean：在配置文件中定义bean类型和返回值类型可以不一样

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

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

public class MyBean implements FactoryBean<User> {

//用来改变返回对象（返回的对象可以和创建的对象不一样）
   @Override
   public User getObject() throws Exception {
       return new User(1,"张三");
   }

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

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

创建 MyBean.xml文件添入：

<!--创建类的对象-->
<bean id="myBean" class="tianfei.Spring5.factorybean.MyBean"></bean>

测试类：

  public class test {

@Test
   public void testMyBean() {
       //测试 FactoryBean 工厂
       ApplicationContext context = new ClassPathXmlApplicationContext("MyBean.xml");

Book book = context.getBean("myBean",Book.class);
       System.out.println(book);
   }
}

4、Bean的生命周期（加上后置处理器后共七步）：

（1）通过无参构造器创建bean实例（无参构造）
（2）为 bean的属性注入值或引用其他bean（set方法）
（3）把 bean 实例传递给 bean 后置处理器方法 postProcessBeforeInitialization
（4）调用 bean的初始化方法（需要自行配置初始化方法）
（5）把 bean 实例传递给 bean 后置处理器方法 postProcessAfterInitialization
（6）获取 bean实例对象
（7）当容器关闭时，调用 bean的销毁方法（需要自行配置销毁方法）

来源：https://blog.csdn.net/tf835991342/article/details/116203629