Spring学习笔记：IOC

IOC底层原理

什么是IOC

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

IOC底层原理

原始模式

class UserService
{
    execute()
    {...}
}

class UserDao
{
    add()
    {...}
}

现在我想在UserService中调用UserDao的add（）方法

class UserService
{
    execute()
    {
        UserDao dao = new UserDao();
        dao.add();
    }
}

class UserDao
{
    add()
    {...}
}

但是这样耦合度太高了。Dao变了，Service也得变

因此出现了工厂模式：就是为了解耦合

class UserDao
{
    add()
    {...}
}

class UserFactory
{
    public static UserDao getDao()
    {
        return new UserDao();
    }
}

class UserService
{
    execute()
    {
        UserDao dao = UserFactory.getDao();
        dao.add();
    }
}

但是这样还是会有耦合度，没有降低到最低限度，需要进一步解耦

目的就是为了：耦合度降低到最低限度

IOC过程(进一步降低耦合度)：

第一步： xml配置文件，配置创建的对象

< bean id ="起的名字 class= “路径" >

第二步：有service类和 dao类，创建工厂类

class UserFactory
{
    public static UserDao getDao()
    {
        // 使用xml解析
        String classValue = class属性值;
        // 通过反射创建对象
        Class clazz = Class.forName(classValue);
        return (UserDao)clazz.newInstance();
    }
}

IOC接口（BeanFactory）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
Spring 提供IOC容器完成两种方式（两个接口）：
1. BeanFactory: IOC容器最基本的实现，是Spring内部的使用接口，不提供开发人员使用
  - 加载配置文件的时候不会去创建对象，在获取（使用）对象的时候才去创建对象
2. ApplicationContext：是BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
  1. 在加载配置文件的时候就会把配置文件对象进行创建
ApplicationContext接口有实现类
2. ClassPathXmlApplicationContext 是在项目内部的，FileSystemXmlApplication是在磁盘中的，需写出绝对路径

IOC操作Bean管理（基于XML）

1、什么是Bean管理（概念）

Bean管理指的是两个操作
- Spring创建对象
- Spring注入属性
  - 在创建对象的过程中给这个属性设置一个值（可以通过set方法，但是这次交给Spring Bean管理）

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

基于Xml配置文件方式实现
基于注解方式实现

IOC操作Bean管理（基于XML）

1. 基于XML方式创建对象

在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
在bean标签有很多属性，介绍常用的属性
1. id属性：给这个对象取一个标识名字
2. class属性：创建对象类的全路径（包类路径）
3. name属性：和Id属性是一样的，但是不怎么用了
创建对象的时候，默认是使用无参构造方法来完成对象创建

2. 基于xml方式注入属性

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

3. 第一种注入属性的方式：使用set方法进行注入 (无参构造)

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

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

package demo01;

public class Book
{
    private String bname;
    /*set方式注入属性*/
    public void setBname(String bname)
    {
        this.bname=bname;
    }
    /*有参构造方式注入属性*/
    public Book(String bname)
    {
        this.bname=bname;
    }
  
    public static void main(String[] args)
    {
        /*有参构造方式注入属性*/
        Book book= new Book("书本");

    }
}

package demo01;

public class Book
{
    /*创建属性*/
    private String bname;
    private String bauthor;
    /*创建属性对应的set方法*/
    public void setBname(String bname)
    {
        this.bname=bname;
    }
    public void setBauthor(String bauthor)
    {
        this.bauthor=bauthor;
    }
    public static void main(String[] args)
    {
        Book book = new Book();
        book.setBname("abc");
        book.setBauthor("aaa");
    }
}

package demo01.TestDemo;

import demo01.Book;
import demo01.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5
{
    @Test
    public void testBook()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Book book =context.getBean("book", Book.class);
        System.out.println(book);
        book.testDemo();
    }
  
}

package demo01;

public class Book
{
    /*创建属性*/
    private String bname;
    private String bauthor;
    /*创建属性对应的set方法*/
    public void setBname(String bname)
    {
        this.bname=bname;
    }
    public void setBauthor(String bauthor)
    {
        this.bauthor=bauthor;
    }
    public void testDemo()
    {
        System.out.println(bname+"::"+bauthor);
    }
  
}

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

第一步：创建类，定义属性，创建属性对应有参构造方法

package demo01;

/*使用有参数构造注入*/
public class Orders
{
    private String oname;
    private String address;
    /*有参数的构造*/
    public Orders (String oname,String address)
    {
        this.oname= oname;
        this.address=address;
    }
  
}

第二步：在Spring配置文件中配置

<?xml version="1.0" encoding="UTF-8"?>

第三步：测试

package demo01.TestDemo;

import demo01.Book;
import demo01.Orders;
import demo01.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5
{
   
    @Test
    public  void testOrders()
    {
        ApplicationContext context =new ClassPathXmlApplicationContext("bean1.xml");
        Orders orders =context.getBean("orders",Orders.class);
        System.out.println(orders);
        orders.ordersTest();
    }
}

p名称空间注入

使用P名称空间注入，可以简化基于xml配置方式
- 第一步：添加p名称空间在配置文件中
- 第二步：进行属性注入，在bean标签里面进行操作
  - ```
  <?xml version="1.0" encoding="UTF-8"?>
  
      
```

IOC操作Bean管理（XML注入其他类型属性）

字面量

什么是字面量
- 设置属性的固定值，比如在构造参数的时候，直接指定属性的值是什么

null值

xml文件中设置
```
        
        
        
        
            
        
    
```

属性值包含特殊符号

注入属性-外部bean

步骤

创建两个类service类和dao类

package demo01.service;

import demo01.dao.UserDao;
import demo01.dao.UserDaoImpl;

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对象
        UserDao userDao = new UserDaoImpl();
        userDao.update();*/
        userDao.update();
    }
}

package demo01.dao;

public class UserDaoImpl implements UserDao
{
    @Override
    public void update()
    {
        System.out.println("dao update...");
    }
}

package demo01.dao;

public interface UserDao
{
    public void update();
}

在service调用dao里面的方法

在Spring配置文件中配置

<?xml version="1.0" encoding="UTF-8"?>

也就是说，在外部建个对象，然后把他引入。

测试

package demo01.TestDemo;

import demo01.User;
import demo01.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean
{
    @Test
    public void testAdd()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

注入属性-内部bean

一对多关系：
- 部门与员工：一个部分有多个员工，一个员工属于一个部分。
在实体类之间表示一对多关系，员工表示所属部分，使用对象类型属性进行表示

两个类

部门类

package demo01.bean;

//部门类
public class Dept
{
    private String dname;

    public void setDname(String dname)
    {
        this.dname = dname;
    }

    @Override
    public String toString()
    {
        return "Dept{" + "dname='" + dname + '\'' + '}';
    }
}

员工类

package demo01.bean;
//员工类
public class Emp
{
    private  String ename;
    private  String gender;
    private  Dept dept;
    public void setEname(String ename)
    {
        this.ename = ename;
    }

    public void setGender(String gender)
    {
        this.gender = gender;
    }

    public void setDept(Dept dept)
    {
        this.dept = dept;
    }
    public  void add()
    {
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}

在Spring配置文件中进行配置。

<?xml version="1.0" encoding="UTF-8"?>

因为emp内部有Dept这个对象属性，因此直接在内部在定义一个对象。然后给他赋值。

测试

package demo01.TestDemo;

import demo01.User;
import demo01.bean.Emp;
import demo01.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean
{
    @Test
    public void testBean1()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
    @Test
    public  void testBean2()
    {
        ApplicationContext context =new ClassPathXmlApplicationContext("bean3.xml");
        Emp emp=context.getBean("emp",Emp.class);
        emp.add();
    }
}

注入属性：级联赋值

第一种写法

<?xml version="1.0" encoding="UTF-8"?>

第二种写法

<?xml version="1.0" encoding="UTF-8"?>

但是需要在emp中给Dept的get方法生成出来用来接受属性

package demo01.bean;
//员工类
public class Emp
{
    private  String ename;
    private  String gender;
    private  Dept dept;

    /*生成dept的get方法，这样才能收到bean4.xml中的赋值属性*/

    public Dept getDept()
    {
        return dept;
    }

    ...
}

IOC操作Bean管理（xml注入集合属性）

注入数组类型属性
注入List集合类型属性
注入Map集合类型属性

具体步骤

创建类，定义数组、list、map、set类型属性，生成对应的set方法

 package demo01.collectionType;

 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 public class Stu
 {
     /*数组类型属性*/
     private  String[] courses;
     /*list集合类型属性*/
     private List list;
     /*map集合类型属性*/
     private Map maps;
     /*set集合类型属性*/
     private  Set set;
     public void setCourses(String[] courses)
     {
         this.courses = courses;
     }

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

     public void setMaps(Map maps)
     {
         this.maps = maps;
     }
     public void setSet(Set set)
     {
         this.set = set;
     }
 }

在Spring配置文件中进行配置

 <?xml version="1.0" encoding="UTF-8"?>
 
    
     
         
         
             
                 java
                 数据库课程
             
         
         
         
             
                 张三
                 李四
             
         
         
         
             
                 
                 
             
         
         
         
             
                 1
                 2

测试类中进行测试

 package TestDemo;

 import demo01.collectionType.Stu;
 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class testSpring5Demo1
 {
     @Test
     public void testCollection()
     {
         ApplicationContext context =new ClassPathXmlApplicationContext("bean1.xml");
         Stu stu=context.getBean("stu", Stu.class);
         System.out.println(stu);
         stu.test();
     }
 }

特殊情况：

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

新建一个对象Couses类

package demo01.collectionType;

public class Courses
{
    private String cname;

    public void setCname(String cname)
    {
        this.cname = cname;
    }

    @Override
    public String toString()
    {
        return "Courses{" + "cname='" + cname + '\'' + '}';
    }
}

在原Stu类中，添加新的对象类型值，并对其进行Set方法

package demo01.collectionType;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu
{
    ...
    /*对象类型*/
    private  List coursesList;

    public void setCoursesList(List coursesList)
    {
        this.coursesList = coursesList;
    }
    ...
    public void test()
    {
        ...
        System.out.println(coursesList);
    }
}

给bean1.xml文件中进行注释

<?xml version="1.0" encoding="UTF-8"?>


    
        ...
        ...

把集合注入部分提取出来

重新建立一个类Book

package demo01.collectionType;
import java.util.List;
public class Book
{
    private  List list;
    public void setList(List list)
    {
        this.list = list;
    }
}

在Spring 配置文件中引入名称空间util
- 给bean2.xml改为util

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

<?xml version="1.0" encoding="UTF-8"?>


    
    
    
        易筋经
        九阴真经
        九阳神功

IOC操作Bean管理（FactoryBean）

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
- 普通bean：在配置文件中定义 bean 类型就是返回类型
  - 例如：
- 工厂bean: 在配置文件定义 bean 类型可以和返回类型不一样

工厂bean举例：

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

package factoryBean;

import demo01.collectionType.Courses;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean
{
}

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

package factoryBean;

import demo01.collectionType.Courses;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean
{
    /*返回bean的实例*/
    /*定义返回bean的类型*/

    /*@Override
    public Object getObject() throws Exception
    {
        return null;
    }
    */
    /*这样设置就是Mybean 返回的对象是Course对象，而不是myBean*/
    @Override
    public Courses getObject() throws Exception
    {
        Courses courses =new Courses();
        courses.setCname("abc");
        return courses;
    }
    /*返回类型*/
    @Override
    public Class<?> getObjectType()
    {
        return null;
    }

    /*判断他是否是个单例*/
    @Override
    public boolean isSingleton()
    {
        return FactoryBean.super.isSingleton();
    }
}

<?xml version="1.0" encoding="UTF-8"?>

测试

package TestDemo;

import demo01.collectionType.Courses;
import demo01.collectionType.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testSpring5Demo1
{
    @Test
    public void Test1()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Courses courses =context.getBean("myBean",Courses.class);
        System.out.println(courses);
    }

}

通过上述也可以很明显的看出，在bean3.xml中定义的返回值类型和最终在类中定义的返回值类型是不一样的。

IOC操作Bean管理（bean作用域）

在 Spring 里面，设置创建 bean 实例是单实例还是多实例
在 Spring 里面，默认情况下，bean 是单实例对象
如何设置单实例还是多实例
- 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
- scope 属性值
  - 第一个值默认值，singleton，表示是单实例对象
  - 第二个值 prototype，表示是多实例对象
- singleton 和 prototype 区别
  - singleton 单实例，prototype 多实例
  - 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象。
    设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象

IOC 操作 Bean 管理（bean 生命周期）

什么是生命周期
- 从对象创建到对象销毁的过程
bean生命周期步骤
1. 通过构造器创建 bean 实例（执行无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用类中的set 方法）
3. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
4. bean 此时就可以使用了（对象获取到了）
5. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
生命周期展示
生命周期其实还有两层： bean的后置处理器
1. 通过构造器创建 bean 实例（执行无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用类中的set 方法）
3. 【新添加的一层】把 bean 实例传递 bean 后置处理器的方法 PostProcessBeforeInitialization
4. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
5. 【新添加的一层】把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
6. bean 此时就可以使用了（对象获取到了）
7. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
演示添加后置处理器效果

IOC操作Bean管理（xml自动装配）

什么是自动装配
- 根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入
- 这种手动注入值叫 手动装配
- 不需要写上面这一行的，就叫自动装配
演示自动装配过程
- 根据属性名称自动注入
  - ```
  <?xml version="1.0" encoding="UTF-8"?>
  
  
      
      
      
  
      
      
```
- 根据属性类型自动注入
  - 只需要将autowire="byType"

IOC操作Bean管理（外部属性文件）

像这样的属性有很多，但是当很多属性的时候，就需要一个一个的添加。而且当属性发生变化的时候，这个xml文件也需要发生改变。
这样是非常不方便，因此，我们可以引入外部的属性文件，例如数据库

直接配置数据库信息方式

配置连接池（德鲁伊连接池）
```
    
        
        
        
        
        
        
        
    
```

引入外部属性文件配置数据库连接池方式
- 创建外部属性文件，properties 格式文件，写数据库信息
  - key:value 格式，且其名称（key）是可以随便写的。
  - ```
  prop.driverClass=com.mysql.jdbc.Driver
  prop.url=jdbc:mysql://localhost:3306/userDb
  prop.userName=root
  prop.password=root
```
- 把外部 properties 属性文件引入到 spring 配置文件中
  - 引入 context 名称空间
    - ```
    <?xml version="1.0" encoding="UTF-8"?>
```
- 在 spring 配置文件使用标签引入外部属性文件

IOC操作Bean管理（基于注解方式）

什么是注解
- 注解是代码特殊标记，
  - 格式：@注解名称(属性名称=属性值, 属性名称=属性值..)
- 使用注解，注解作用在类上面、方法上面、属性上面
- 使用注解目的：简化 xml 配置
Spring 针对 Bean 管理中创建对象提供注解
- @Component
  *
- @Service
  - 一般用在业务逻辑层和Service层
- @Controller
  - 一般用在web层上
- @Repository
  - 一般用在持有层上
- 上面四个注解功能是一样的，都可以用来创建 bean 实例

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

第一步：引入依赖
第二步：开启组件扫描（也就是说告诉Spring容器，我现在要在哪个包哪个类里加上注解，让他扫描这些类）
- ```
<?xml version="1.0" encoding="UTF-8"?>

    
    
```

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

package service;

import org.springframework.stereotype.Component;

/*上面这行代码等价于   

* 同时在注解里面value属性值可以省略不写。
* 默认值是类名称，首字母小写
* UserService--> userService
* */
@Component(value = "userService")

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

测试

package TestDemo;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;

public class testSpring5Demo1
{
    @Test
    public void test1()
    {
        ApplicationContext context =new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }

}

开启组件扫描的一些细节配置
- 如果在xml配置文件中写入
```
    
```
  则代表着扫描所有的demo01下的所有内容
- 如果是
```
        
```
  则代表着如下
  - use-default-filters="false" 表示现在不适用默认filter，自己配置fileter
  - context ：include-filter : 设置扫描哪些内容
  - 例如上述代码，只扫描带有标记，Controller标记的类
- 如果是context:exclude-filter：设置哪些内容不进行扫描
基于注解方式实现属性注入
1. @Autowired：根据属性类型进行自动装配
  - 第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
    - 建个interface接口，取名为UseDao
      - package dao; public interface UserDao { public void add(); }
    - 写出接口的实现类 UserDaoImpl
      - package dao; import org.springframework.stereotype.Repository; @Repository public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("dao add..."); } }
  - 第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解
    - ```
    package service;
    
    import dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService
    {
        /*定义dao类型属性
        *   注意，不需要添加set方法*/
        @Autowired//根据类型进行注入
        private UserDao userDao;
        public void add()
        {
            System.out.println("add...");
            userDao.add();
        }
    }
```
- 测试一下
  - 因为Autowired是根据类型进行注入，因此，是UserDao类型，根据UserDao类型找到其实现类UserDaoImpl，对其进行实现注入操作
2. @Qualifier：根据属性名称进行注入
  - 这个@Qualifier 注解的使用，和上面@Autowired 一起使用
  - 一个接口是有多个实现类的，但是如果根据类型注入，UserDao类型有好几个实现类，那么到底找哪个实现类进行注入是不清晰的。因此需要这个，直接指定名称
  - @Qualifier(value = "") value默认不写是首字母小写。
  - ```
  @Autowired  //根据类型进行注入
  @Qualifier(value = "useDaoImpl")
```
3. @Resource：既可以根据类型注入，也可以根据名称注入
  - ```
  @Resource(name = "userDaoImpl1") //根据名称进行注入
  private UserDao userDao;
```
4. @Value：注入普通类型属性
  - ```
  @Value(value = "abc")
  private String name;
```

完全注解开发

创建配置类，用其替代 xml 配置文件

package config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration/*有这个标记才会将其当成配置文件，从而取代xml配置文件*/
@ComponentScan(basePackages = {"dao"})
/*等价于 xml配置文件中的*/
public class SpringConfig
{
}

编写测试类

@Test
    public  void test2()
    {
        /*加载配置类*/
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("useService",UserService.class);
        System.out.println(userService);
        userService.add();

    }

SSM

Spring学习笔记：IOC

IOC底层原理

什么是IOC

IOC底层原理

IOC过程(进一步降低耦合度)：

IOC接口 （BeanFactory）

IOC操作Bean管理（基于XML）

1、 什么是Bean管理（概念）

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

IOC操作Bean管理（基于XML）

1. 基于XML方式创建对象

2. 基于xml方式注入属性

3. 第一种注入属性的方式：使用set方法进行注入 (无参构造)

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

p名称空间注入

IOC操作Bean管理（XML注入其他类型属性）

字面量

注入属性-外部bean

注入属性-内部bean

注入属性： 级联赋值

IOC操作Bean管理（xml注入集合属性）

IOC操作Bean管理（FactoryBean）

IOC操作Bean管理（bean作用域）

在 Spring 里面，设置创建 bean 实例是单实例还是多实例

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

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

singleton 和 prototype 区别

IOC 操作 Bean 管理（bean 生命周期）

什么是生命周期

bean生命周期步骤

生命周期展示

生命周期其实还有两层： bean的后置处理器

演示添加后置处理器效果

IOC操作Bean管理（xml自动装配）

什么是自动装配

演示自动装配过程

根据属性名称自动注入

根据属性类型自动注入

IOC操作Bean管理（外部属性文件）

直接配置数据库信息方式

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

IOC操作Bean管理（基于注解方式）

什么是注解

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

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

开启组件扫描的 一些细节配置

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

完全注解开发

相关

IOC接口（BeanFactory）

1、什么是Bean管理（概念）

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

注入属性：级联赋值

开启组件扫描的一些细节配置