Spring篇-IOC容器

柔光的暖阳◎ 2021-06-10 20:40 443阅读 0赞

# IOC容器 #

## 概念 ##

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

## IOC底层原理 ##

> xml解析、工厂模式、反射

图解:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]

## IOC(BeanFactory接口) ##

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

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

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

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

(2) ApplicationContext：BeanFactory 接口的**子接口**，提供更多更强大的功能，一般由开发人 员进行使用

**特点**:加载配置文件时候就会把在配置文件对象进行创建

**ApplicationContext 接口有实现类**

*  ClassPathXmlApplicationContext
    
     说明:在src下的配置文件
 *  FileSystemXmlApplicationContext
    
     说明:在系统磁盘中的绝对路径

## IOC操作–Bean管理(基于xml方式) ##

### 基于xml方式创建对象 ###

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建  
（2）在 bean 标签有很多属性，介绍常用的属性

id 属性：唯一标识

class 属性：类全路径（包类路径）  
（3）创建对象时候，默认也是**执行无参数构造方法**完成对象创建

### 基于xml方式注入属性 ###

> DI：依赖注入，就是注入属性

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

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

/** * @author cVzhanshi * @create 2021-04-14 21:51 */
    public class Book { 
        private String name;
        private String author;
    
        public void setAuthor(String author) { 
            this.author = author;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    }

2、 在 spring 配置文件配置对象创建，配置属性注入

<bean id="book" class="com.atguigu.spring5.Book">
            
            <property name="name" value="Java入门到精通"></property>
            <property name="author" value="cVzhanshi"></property>
        </bean>

3、测试

@Test
        public void testBook(){ 
            //1、加载spring配置文件
    
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            //2、获取配置创建的对象
            Book book = context.getBean("book", Book.class);
    
            System.out.println(book);
            
        }
    }

运行效果:

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ML5FmFS7-1618545559611)(Spring5.assets/1618408868483.png)\]][img-ML5FmFS7-1618545559611_Spring5.assets_1618408868483.png]

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

1、 创建类，定义属性，创建属性对应有参数构造方法

/** 使用有参构造器注入 * @author cVzhanshi * @create 2021-04-14 22:02 */
    public class Orders { 
    
        private String name;
        private String address;
    
        public Orders(String name, String address) { 
            this.name = name;
            this.address = address;
        }
    
        @Override
        public String toString() { 
            return "Orders{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

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

<bean id="orders" class="com.atguigu.spring5.Orders">
            <constructor-arg name="name" value="asus"></constructor-arg>
            <constructor-arg name="address" value="cVzhanshi"></constructor-arg>
       </bean>

3、测试

@Test
        public void testOrder(){ 
            //1、加载spring配置文件
    
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            //2、获取配置创建的对象
            Orders oders = context.getBean("orders", Orders.class);
    
            System.out.println(oders);
    
        }

运行效果:

![在这里插入图片描述][20210416120230995.png]

#### p 名称空间注入 (简化set方法注入) ####

> 基于set方法进行注入，简化了一下使用set方法的配置文件内容

1、 添加 p 名称空间在配置文件中

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-flmsofrs-1618545559616)(Spring5.assets/1618409636898.png)\]][img-flmsofrs-1618545559616_Spring5.assets_1618409636898.png]

2、编写配置文件

<bean id="book" class="com.atguigu.spring5.Book" p:name="java入门到精通" p:author="cVzhanshi">
        </bean>

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

#### 字面量 ####

##### null值 #####

<property name="address">
    	 <null/>
    </property>

运行效果:

![在这里插入图片描述][20210416120307905.png]

##### 属性值包含特殊符号 #####

<property name="address">
     <value><![CDATA[<<南京>>]]></value>
    </property>

#### 注入属性-外部 bean ####

1、创建两个类 service 类和 dao 类，在 service 调用 dao 里面的方法

/**dao类
     * @author cVzhanshi
     * @create 2021-04-15 9:38
     */
    public class UserDaoImpl implements UserDao {
        @Override
        public void update() {
            System.out.println("update---------------------");
        }
    }
    
    
    
    
    /**Service类
     * @author cVzhanshi
     * @create 2021-04-15 9:39
     */
    public class UserService {
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void add(){
            System.out.println("add-------------------");
            userDao.update();
        }
    }

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

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

3、测试

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

运行效果

![在这里插入图片描述][20210416120356152.png]

#### 注入属性-内部 bean ####

（1）一对多关系：部门和员工 一个部门有多个员工，一个员工属于一个部门 部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

//部门类
    /**
     * @author cVzhanshi
     * @create 2021-04-15 10:03
     */
    public class Dep {
        private String dname;
        public void setDname(String dname) {
            this.dname = dname;
        }
        @Override
        public String toString() {
            return "Dep{" +
                    "dname='" + dname + '\'' +
                    '}';
        }
    }
    
    
    //员工类
    /**
     * @author cVzhanshi
     * @create 2021-04-15 10:03
     */
    public class Emp {
        private String ename;
        private String gender;
        //员工属于某一个部门，使用对象形式表示
        private Dep dept;
        public void setDept(Dep dept) {
            this.dept = dept;
        }
        public void setEname(String ename) {
            this.ename = ename;
        }
        public void setGender(String gender) {
            this.gender = gender; }
        @Override
        public String toString() {
            return "Emp{" +
                    "ename='" + ename + '\'' +
                    ", gender='" + gender + '\'' +
                    ", dept=" + dept +
                    '}';
        }
    }

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

（4）测试

@Test
        public void testneiBean(){ 
            ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
            Emp emp = context.getBean("emp", Emp.class);
            System.out.println(emp);
        }

运行效果:

![在这里插入图片描述][20210416120451593.png]

#### 注入属性-级联赋值 ####

##### 第一种写法 #####

<bean id="emp" class="com.atguigu.entity.Emp">
         
         <property name="ename" value="lucy"></property>
         <property name="gender" value="女"></property>
         
         <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.entity.Dep">
    	 <property name="dname" value="财务部"></property>
    </bean>

运行效果

![在这里插入图片描述][20210416120516179.png]

##### 第二种写法(对象要有get方法) #####

private Dep dept;
    
        public Dep getDept() { 
            return dept;
        }
    
        public void setDept(Dep dept) { 
            this.dept = dept;
        }

<bean id="emp" class="com.atguigu.entity.Emp">
         
         <property name="ename" value="lucy"></property>
         <property name="gender" value="女"></property>
         
         <property name="dept" ref="dept"></property>
         
         <property name="dept.dname" value="技术部"></property>
     </bean>
     <bean id="dept" class="com.atguigu.entity.Dep">
         <property name="dname" value="财务部"></property>
     </bean>

运行效果

![在这里插入图片描述][20210416120546521.png]

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

#### 注入list、map、数组等集合属性 ####

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

/**
     * @author cVzhanshi
     * @create 2021-04-15 10:49
     */
    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 setCourses(String[] courses) {
            this.courses = courses;
        }
        public void setList(List<String> list) {
            this.list = list;
        }
        public void setMaps(Map<String, String> maps) {
            this.maps = maps;
        }
    }

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

<bean id="stu" class="com.atguigu.collection.Stu">
       		 	
            <property name="courses">
                <array>
                    <value>Java编程</value>
                    <value>PHH</value>
                    <value>Andriod</value>
                </array>
            </property>
         	
            <property name="list">
                <list>
                    <value>cVzhanshi</value>
                    <value>ursula</value>
                </list>
            </property>
         	
            <property name="maps">
                <map>
                    <entry key="JAVA" value="java"></entry>
                    <entry key="PYTHON" value="python"></entry>
                    <entry key="C++" value="c++"></entry>
                </map>
            </property>
         	
            <property name="sets">
                <set>
                    <value>abc</value>
                    <value>def</value>
                </set>
            </property>
        </bean>

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

<bean id="course1" class="com.atguigu.collection.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>

#### 把集合注入部分提取出来 ####

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

![在这里插入图片描述][20210416120631700.png]

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

<util:list id="bookList">
         <value>易筋经</value>
         <value>九阴真经</value>
         <value>九阳神功</value>
    </util:list>
    
    <bean id="book" class="com.atguigu.collection.Book">
     	<property name="list" ref="bookList"></property>
    </bean>

### IOC 操作 Bean 管理（FactoryBean) ###

> Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

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

测试工厂bean

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

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

/** * @author cVzhanshi * @create 2021-04-15 11:22 */
    public class MyBean implements FactoryBean<Course> { 
    
        /** * 定义返回类型 * @return * @throws Exception */
        @Override
        public Course getObject() throws Exception { 
            Course course = new Course("cVzhanshi");
            return course;
        }
    
        @Override
        public Class<?> getObjectType() { 
            return null;
        }
    
        @Override
        public boolean isSingleton() { 
            return false;
        }
    
    }

test&xml

public void testFactoryBean(){ 
            ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
            Course myBean = context.getBean("myBean", Course.class);
            System.out.println(myBean);
        }

运行效果

![在这里插入图片描述][20210416120701952.png]

### IOC 操作 Bean 管理（ bean 作用域 ) ###

> 作用域: 在 Spring 里面，设置创建 bean 实例是单实例还是多实例
> 
>     单实例：只有一个对象
>       
>       实例：又多个对象

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

@Test
        public void testjilianBean(){ 
            ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
            Emp emp1 = context.getBean("emp", Emp.class);
            Emp emp2 = context.getBean("emp", Emp.class);
            System.out.println(emp1);
            System.out.println(emp2);
        }

![在这里插入图片描述][20210416120754188.png]

**Bean中设置单实例或多实例**

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

2、scope的属性值

*  第一个值 默认值，singleton，表示是单实例对象
 *  第二个值 prototype，表示是多实例对象

**设置多实例**

@Test
        public void testjilianBean(){
            ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
            Emp emp1 = context.getBean("emp", Emp.class);
            Emp emp2 = context.getBean("emp", Emp.class);
            System.out.println(emp1);
            System.out.println(emp2);
        }

![在这里插入图片描述][20210416120818975.png]

**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类:

/** * @author cVzhanshi * @create 2021-04-15 20:21 */
    public class Lifes { 
        private String name;
    
        public Lifes() { 
            System.out.println("第一步 执行无参构造器创建bean对象");
        }
    
        public String getName() { 
    
            return name;
        }
    
        public void setName(String name) { 
            System.out.println("第二步 调用 set 方法设置属性值");
            this.name = name;
        }
    
        //创建执行的初始化的方法
        public void initMethod() { 
            System.out.println("第三步 执行初始化的方法");
        }
        //创建执行的销毁的方法
        public void destroyMethod() { 
            System.out.println("第五步 执行销毁的方法");
        }
    
    }

xml

test

@Test
        public void testLife(){ 
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");
            Lifes life = context.getBean("life", Lifes.class);
            System.out.println("第四步，获取创建bean实例对象");
            System.out.println(life);
            
            //需要手动关闭
           //且ApplicationConteext对象中没有close方法，需要ClassPathXmlApplicationConteext对象才有
            context.close();
        }

运行效果

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EUOWYu20-1618545559630)(Spring5.assets/1618490336132.png)\]][img-EUOWYu20-1618545559630_Spring5.assets_1618490336132.png]

#### bean 的后置处理器，bean 生命周期有七步 ####

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

代码演示

*  创建类，实现接口 BeanPostProcessor，创建后置处理器

/**
     * @author cVzhanshi
     * @create 2021-04-15 20:24
     */
    public class MyBeanPost implements BeanPostProcessor {
    
    
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("在初始化之前执行的方法");
            return null;
        }
        
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("在初始化之后执行的方法");
            return null;
        }
    }

*  xml配置文件

<bean id="life" class="com.atguigu.life_cycle.Lifes" init-method="initMethod" destroy-method="destroyMethod">
            <property name="name" value="cVzhanshi"></property>
        </bean>
        
        <bean id="myBeanPost" class="com.atguigu.life_cycle.MyBeanPost">
        </bean>

*  测试

*  运行效果

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]

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

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

#### 根据属性名称自动注入 ####

user&course class

/** * @author cVzhanshi * @create 2021-04-16 9:19 */
    public class User { 
        private Course course;
    
        public User() { 
        }
    
        public void setCourse(Course course) { 
            this.course = course;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "course=" + course +
                    '}';
        }
    }
    
    
    /** * @author cVzhanshi * @create 2021-04-16 9:19 */
    public class Course { 
        private String name;
    
        public void setName(String name) { 
            this.name = name;
        }
    
        @Override
        public String toString() { 
            return "Course{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

spring配置文件

<bean id="user" class="com.atguigu.autowire.User" autowire="byName">
        </bean>
        <bean id="course" class="com.atguigu.autowire.Course">
            <property name="name" value="cVzhanshi"></property>
        </bean>

运行效果:

![在这里插入图片描述][20210416120915719.png]

图解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 3]

#### 根据属性类型自动注入 ####

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 4]

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

> 常用于数据库连接

1、当不使用外部属性文件配置德鲁伊连接池

<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="root"></property>
    </bean>

2、使用外面文件配置德鲁伊连接池

*  引入 context 名称空间

*  在 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.userName}"></property>
     <property name="password" value="${prop.password}"></property>
    </bean>

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

*  注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…) （
 *  使用注解，注解作用在类上面，方法上面，属性上面
 *  使用注解目的：简化 xml 配置

### 基于注解方式创建对象 ###

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

*  @Component
 *  @Service ----> 一般用于service层
 *  @Controller ----> 一般用于web层
 *  @Repository ----> 一般用于dao层

> 上面四个注解功能是一样的，都可以用来创建 bean 实例

#### 创建对象过程 ####

*  导入依赖

![在这里插入图片描述][20210416121012682.png]

*  开启组件扫描 (配置文件)

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

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

/**
     * @author cVzhanshi
     * @create 2021-04-16 10:51
     */
    
    //在注解里面 value 属性值可以省略不写，
    //默认值是类名称，首字母小写
    //UserDao -- userDao@Component(value = "userDao") ----> <bean id="userService" class=".."/
    @Controller(value = "userDao")
    public class UserDao {
        public void add(){
            System.out.println("add==========================");
        }
    }

*  测试

@Test
        public void testAnnotation(){ 
            ApplicationContext context = new ClassPathXmlApplicationContext("bean8.xml");
            UserDao userDao = context.getBean("userDao", UserDao.class);
            System.out.println(userDao);
            userDao.add();
        }

运行结果:

![在这里插入图片描述][20210416121030911.png]

#### 开启组件扫描细节配置 ####

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

### 基于注解方式注入属性 ###

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

> 根据属性类型进行自动装配

*  把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
 *  第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Repository(value = "userDaoImpl")
    public class UserDaoImpl implements UserDao{ 
    
        @Override
        public void add() { 
            System.out.println("UserDao Add---------------");
        }
    }

@Service(value = "userService")
    public class UserService { 
    
        @Autowired
        private UserDao userDao;
    
        public void add(){ 
            System.out.println("UserService add--------");
            userDao.add();
        }
    }

*  测试

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

运行效果:

![在这里插入图片描述][20210416121057535.png]

#### @Qualifier（根据名称进行注入） ####

> 这个@Qualifier 注解的使用，和上面@Autowired 一起使用
> 
> 当一个接口有多个实现类类时根据类型不好注入属性，所有就需要用Qualifier注解来通过名称注入属性

如:

![在这里插入图片描述][20210416121104779.png]

就会报错，所以需要@Qualifier注解

*  把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
 *  创建多个dao的实现类
 *  在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Repository(value = "userDaoImpl")
    public class UserDaoImpl implements UserDao{ 
    
        @Override
        public void add() { 
            System.out.println("userDaoImpl Add---------------");
        }
    }

@Repository(value = "userDaoImpl1")
    public class UserDaoIml1 implements UserDao {
        @Override
        public void add() {
            System.out.println("UserDaoIml1 -add=-=");
        }
    }

@Service(value = "userService")
    public class UserService {
    
        @Autowired
        @Qualifier(value = "userDaoImpl1")
        private UserDao userDao;
    
        public void add(){
            System.out.println("UserService add--------");
            userDao.add();
        }
    }

*  测试

当 @Qualifier(value = “userDaoImpl1”)时，运行效果  
![在这里插入图片描述][20210416121116920.png]

当 @Qualifier(value = “userDaoImpl”)时，运行效果

![在这里插入图片描述][20210416121123871.png]

**由此可见，根据name的不同，注入的时不同对象的属性**

#### @Resource：可以根据类型注入，可以根据名称注入 ####

> 能达到相同的效果，但是不推荐使用，因为他是来自类javax.annotation.Resource，而不是spring的

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

#### @Value：注入普通类型属性 ####

@Service(value = "userService")
    public class UserService {
        
        @Autowired
        @Qualifier(value = "userDaoImpl")
        private UserDao userDao;
        
        
        @Value(value = "cVzhanshi")
        private String name;
        
    
        public void add(){
            System.out.println("UserService add-------- name = "+ name);
            userDao.add();
        }
    }

运行效果:

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-obYlpJYb-1618545559649)(Spring5.assets/1618544882739.png)\]][img-obYlpJYb-1618545559649_Spring5.assets_1618544882739.png]

### 完全注解开发 ###

*  创建配置类，替代 xml 配置文件

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

*  编写测试类

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

运行结果:

![在这里插入图片描述][20210416121144458.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]: /images/20210516/0b9cab9ea276441c9094957dbb8189d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]: /images/20210516/65d54db661ae4a7983c79d22b5ca3dbb.png
[img-ML5FmFS7-1618545559611_Spring5.assets_1618408868483.png]: /images/20210516/380de896003546999d1265a7f9e0d4f4.png
[20210416120230995.png]: /images/20210516/4615791fe6b141dfb9dd5f1d5d97da3c.png
[img-flmsofrs-1618545559616_Spring5.assets_1618409636898.png]: /images/20210516/1bf45c2966a14bd78f9507623e16f0f9.png
[20210416120307905.png]: /images/20210516/81bb585499244b1288d1f570b20d3609.png
[20210416120356152.png]: /images/20210516/9a05fe809478429bbf3037fa327dc53c.png
[20210416120451593.png]: /images/20210516/c0d9f4c9f9484f4fbf8707762f27c5ab.png
[20210416120516179.png]: /images/20210516/01acac62c1e048128f96b4c34ca52e75.png
[20210416120546521.png]: /images/20210516/c0e757fba70d4230a16954b64edce83d.png
[20210416120631700.png]: /images/20210516/630bbac18d79444cab16e85b9c203b93.png
[20210416120701952.png]: /images/20210516/f93d2caa59054281a22ef5d7374238ef.png
[20210416120754188.png]: /images/20210516/6ea800ca5e054836afdacb045cc706ad.png
[20210416120818975.png]: /images/20210516/874371a146504703b99f749c7aa7adce.png
[img-EUOWYu20-1618545559630_Spring5.assets_1618490336132.png]: /images/20210516/aa09e07eb2734594b2afa9bb6adbb359.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]: /images/20210516/be2b0b953da5462a8554fb5ba1badccf.png
[20210416120915719.png]: /images/20210516/9e40180379ac41cc98cc2fface95e043.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 3]: /images/20210516/3a00dc83500c439998c8e73b5780a29e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 4]: /images/20210516/1d6d284253b94528a3e825fbf02239e5.png
[20210416121012682.png]: /images/20210516/c6986d7026834c7d80a4b4a541882fbb.png
[20210416121030911.png]: /images/20210516/897d635d90fa4c62ab98576d2db94901.png
[20210416121057535.png]: /images/20210516/c85d7f5178644e669aede83f84107405.png
[20210416121104779.png]: /images/20210516/e93d59c19e1e47488031fa9bfda962f0.png
[20210416121116920.png]: /images/20210516/f4eed4b8b4114473b2d92619ccbe881b.png
[20210416121123871.png]: /images/20210516/1b8c61fcdb07458f97e669f05b60924c.png
[img-obYlpJYb-1618545559649_Spring5.assets_1618544882739.png]: /images/20210516/e7881c2b85214224970b0648743d5c94.png
[20210416121144458.png]: /images/20210516/5080a0efde6143a494c34336c46c725e.png