5.1（Spring）Spring和IOC学习

Spring概述

1. Spring 是轻量级的开源的 JavaEE 框架

2. Spring 可以解决企业应用开发的复杂性

3. Spring 有两个核心部分：IOC 和 Aop

   IOC：控制反转，把创建对象过程交给 Spring 进行管理

   Aop：面向切面，不修改源代码进行功能增强

特点

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

环境搭建

想要使用Spring，我们只需要引入Spring的jar文件即可操作。当然这里可以使用Maven来构建我们的项目

Maven构建项目

因为可以通过Maven来进行引入我们的jar文件等操作

刚刚创建出来的项目模块

在pom中引入Spring依赖

 <!-- Spring核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

通过这张图看到在Maven中只要引入一个context依赖即可

示例不用IOC

以往我们创建对象都是通过new的方式进行创建对象，每次需要对象之前都是通过new的方式。

Spring中提供了IOC，我们创建对象不在需要new的方式创建对象而是通过Spring的IOC

package pojo;

//创建一个javaBean
public class Student {
    private String name;

    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package SpringTest;
import pojo.Student;
public class SpringIOCTest {
    public static void main(String[] args) {

//        在没有使用Spring的IOC，我们创建对象都是通过new的方式
        Student student = new Student("wsl",21);
        System.out.println("学生姓名"+student.getName());
    }
}

SpringIOC

IOC示例

在Sping中存在一个配置文件，这个配置文件可以提前指定Spring可以对哪些类使用IOC等操作

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 使用spring创建对象，在spring中这些都称为bean -->
    <bean class="pojo.Student" id="student">
        <property name="name" value="wsl"/>
        <property name="age" value="21"/>
    </bean>
    
</beans>

package SpringTest;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Student;
public class SpringIOCTest {
    public static void main(String[] args) {

//        在没有使用Spring的IOC，我们创建对象都是通过new的方式
        Student student = new Student("wsl",21);
        System.out.println("学生姓名"+student.getName());

//        加载Spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("SpringTest.xml");
//        通过配置文件来得到javabean
        Student student1 = context.getBean("student", Student.class);
//        打印Spring创建出来对象的name
        System.out.println("SpringIOC学生姓名"+student1.getName());


    }
}

通过上面代码，SpringIOC确实没有直接通过new的方式创建对象，使用了配置文件获取javabean

IOC容器分析

在IOC中底层通过（XML解析）（工厂模式）（反射）来完成

业务层调用数据访问层

我们在java中为了分层开发，业务层需要调用数据访问层的代码，就需要在业务层引入数据访问层，可以如何调用呢

package service;
//数据访问层演示
public class DaoImple {
    public String getString(){
        return "";
    }
}

方式一

可以看到在业务层的方法内部创建数据访问层对象，这样的代码耦合在一起。

如果数据访问层创建错误，也会影响到业务层

package service;
//演示业务层调用数据访问层
public class ServiceImple {
    public String getDaoString(){
//        方法内部通过创建数据访问层对象来完成数据访问层操作
        DaoImple daoImple = new DaoImple();
         return daoImple.getString();
    }
}

方式二

这样依赖确实做到了解耦，但是每次使用业务层都需要进行指定数据访问层。有些麻烦

package service;
//演示业务层调用数据访问层
public class ServiceImple {

//    内部使用私有属性，在调用业务层的时候给与数据访问层赋值
    private DaoImple daoImple;

    public void setDaoImple(DaoImple daoImple) {
        this.daoImple = daoImple;
    }

//    业务层方法中需要数据访问层的调用
    public String getDaoString(){
         return daoImple.getString();
    }

}

在IOC中提供了很多的注解，控制反转，依赖注入。简化了方式二的操作

为什么要用IOC呢

IoC 不是一种技术，只是一种思想

一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

我的解释

**通过配置文件，或者之后的注解，约定好一个类。之后就可以通过IOC进行创建。**达到了解耦。

在java面向对象中，经常在一个类中需要引入另一个类的对象来做操作，这个类的对象一般都是创建好的（固定的）。

如果我们通过IOC来进行操作，可以通过配置很容易的改变引用这个类实例的变化。

之后会存在多种注解，

1. 控制反转：IOC来创建对象，创建对象的控制权交给了IOC
2. 依赖注入：对象之间的引用，这种依赖。在容器运行期间决定。 相当于对象的内部属性赋值，内部的对象引用由依赖注入来操作

什么是IOC

**Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。**在Java开发中，**Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。**如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；*谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）*。

●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IOC执行原理

IOC底层通过（XML解析）（工厂模式）（反射）

首先IOC中需要使用到Spring的配置文件

这个配置文件中定义了类的属性，和对象的引用。

通过加载配置文件来获取对象，内部是对象工厂，运行中指定了数据。在XML中进行对应获取类的路径

在通过反射进行对象的创建，从而使用对象工厂返回出去

IOC底层就是对象工厂，两种实现方式

IOC一般两种使用方式（xml配置方式）（注解方式）

IOC的XML方式

下面都是属于XML中对应代码的方式，我这里直接引入尚硅谷的笔记了。因为都是重复的东西。

基于 xml 方式创建对象

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

• id 属性：唯一标识
• class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

基于 xml 方式注入属性

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

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

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

/**
 * 演示使用 set 方法进行注入属性
 */
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;
    }
}

<!--2 set 方法注入属性-->
< bean id= "book" class= "com.atguigu.spring5.Book">
<!--使用 property 完成属性注入
        name：类里面属性名称
        value：向属性注入的值
        -->
< property name= "bname" value="易筋经"></ property>
< property name= "bauthor" value="达摩老祖"></ property>
</ bean>

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

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

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

<!--3 有参数构造注入属性-->
<bean id= "orders" class= "com.atguigu.spring5.Orders">
<constructor- arg name= "oname" value="电脑" ></ constructor- arg>
<constructor- arg name= "address" value= "China"></ constructor- arg>
</bean>

p名称空间注入

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

< bean id= "book" class= "com.atguigu.spring5.Book"  p:bname="九阳神功" p:bauthor="无名氏"/>

XML注入其他属性

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


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

外部bean:直接在beans标签内部直接定义的bean对象，外部bean可以被多个bean对象引用

内部bean:在某个bean标签的内部定义的bean对象，内部bean只能被某个对象的某个属性引用。

xml注入外部bean

（1）创建两个类 service 类和 dao 类
（2）在 service 调用 dao 里面的方法
（3）在 spring 配置文件中进行配置

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.update();
    }
}

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

< bean id= "userDaoImpl" class= "com.atguigu.spring5.dao.UserDaoImpl"></ bean>

注入属性- 内部 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;
    }
}

<!--内部 bean-->
    <bean id="emp"class="com.atguigu.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename"value="lucy"></property>
        <property name="gender"value=" "女" "></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept"class="com.atguigu.spring5.bean.Dept">
        <property name="dname"value=" "安保部" "></property>
        </bean>
    </property>
    </bean>

级联属性-级联赋值

第一种

（1 1 ）第一种写法
<!--级联赋值-->
< bean id= "emp" class= "com.atguigu.spring5.bean.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.spring5.bean.Dept">
< property name= "dname" value=" " 财务部" "></ property>
</ bean>

第二种编写xml方式

<!--级联赋值-->
< bean id= "emp" class= "com.atguigu.spring5.bean.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.spring5.bean.Dept">
< property name= "dname" value=" " 财务部" "></ property>
</bean>

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

1 、注入数组类型属性
2 、注入 List 集合类型属性
3 、注入 Map 集合类型属性
（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

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;
    }
    publ ic 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;
    }
}

 <!--1集合类型属性注入-->
<bean id="stu"class="com.atguigu.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
    <array>
        <value>java 课程</value>
        <value>数据库课程</value>
    </array>
</property>
<!--list 类型属性注入-->
<property name="list">
    <list>
        <value>张三</value>
        <value>小三</value>
    </list>
</property>
<!--map 类型属性注入-->
<property name="maps">
    <map>
        <entry key="JAVA"value="java"></entry>
        <entry key="PHP"value="php"></entry>
    </map>
</property>
<!--set 类型属性注入-->
<property name="sets">
    <set>
        <value>MySQL</value>
        <value>Redis</value>
    </set>
</property>
</bean>

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

        <!--创建多个 course 对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="Spring5 框架"></ property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="MyBatis 框架">
</ property>
</bean>
        <!--注入 list 集合类型，值是对象-->
<property name="courseList">
<list>
    <ref bean="course1"></ref>
    <ref bean="course2"></ref>
</list>
</property>

把集合注入部分提取出来
（1）在 spring 配置文件中引入名称空间 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"
       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 集合注入提取

 <!--（2）使用 util 标签完成 list 集合注入提取-->
    <!--1 提取 list 集合类型属性注入-->
    <util :list id="bookList">
        <value>易筋经</ value>
        <value>九阴真经</ value>
        <value>九阳神功</ value>
    </util>
    <!--2 提取 list 集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book">
        < property name="list" ref="bookList"></ property>
    </ bean>

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

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

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
（2）scope 属性值
第一个值 默认值，singleton，表示是单实例对象
第二个值 prototype，表示是多实例对象

request：一次请求中的bean

session：一次会话中的bean

（3）singleton 和 prototype 区别
第一 singleton 单实例，prototype 多实例

第二 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象

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

Bean的生命周期

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

bean 生命周期

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

public class Orders {
    //无参数构造
    public Orders() {
        System.out.println(" "第一步 执行无参数构造创建 n bean 实例" ");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println(" "第二步 调用 t set 方法设置属性值" ");
    }

    //创建执行的初始化的方法
    public void initMethod() {
        System.out.println(" "第三步 执行初始化的方法" ");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println(" "第五步 执行销毁的方法" ");
    }
}

 <bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>

   @Test
    public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println(" "第四步 获取创建 n bean 实例对象" ");
        System.out.println(orders);
//手动让 bean 实例销毁
        context.close();
    }

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

添加后置处理器后，放入Spring容器中即可。所有的SpringBean在使用的时候都会进行调用

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

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

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

IOC中XML自动装配

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

对象之间的引用，不在通过ref进行指定。而是使用自动装配的形式。

进一步的简化了代码

根据属性名称自动注入

   <!--实现自动装配
bean 标签属性 autowire，配置自动装配
autowire 属性常用两个值：
byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
byType 根据属性类型注入
-->
    < bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
        <!--<property name="dept" ref="dept"></property>-->
    </ bean>
    < bean id="dept" class="com.atguigu.spring5.autowire.Dept"></ bean>

根据属性类型自动注入

  <!--实现自动装配
   bean 标签属性 autowire，配置自动装配
   autowire 属性常用两个值：
   byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
   byType 根据属性类型注入
   -->
    < bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
        <!--<property name="dept" ref="dept"></property>-->
    </ bean>
    < bean id="dept" class="com.atguigu.spring5.autowire.Dept"></ bean>

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

创建外部属性文件，properties 格式文件，写键值对的形式

把外部 properties 属性文件引入到 spring 配置文件中，引入 context 名称空间

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

    <!--引入propertiesTest配置文件-->
    <context:property-placeholder location="propertiesTest.properties"/>

    <!-- 使用spring创建对象，在spring中这些都称为bean -->
    <bean class="pojo.Student" id="student">
        <property name="name" value="${name}"/>
        <property name="age" value="${age}"/>
    </bean>
</beans>

验证成功

IOC注解开发

因为我们再实际中，不可能针对每个类都去编写XML配置

所以出现了注解，方便我们的类加入Spring容器中

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

（1）@Component 表示其他类
（2）@Service 表示业务逻辑类
（3）@Controller 表示控制器类
（4）@Repository 表示数据访问层类

• 上面四个注解功能是一样的，都可以用来创建 bean 实例
• 不同的注解表示不同类的形式
• 上面注解放在指定的类上，在spring配置文件中进行扫描。 表示该类加入了Spring容器中。
• 使用注解就不需要再编写大量的XML配置了

使用注解示例

修改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: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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定扫描包-->
    <!--只有扫描到的类  注解才会生效-->
    <context:component-scan base-package="cn"/>

</beans>

类中添加注解

//创建一个javaBean
//使用注解，为这个类指定一个获取的名称
@Component("student")
public class Student {

    @Value("wsl")
    private String name;

    @Value("21")
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

查看测试类

public class SpringIOCTest {
    public static void main(String[] args) {
//        加载Spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("SpringTest.xml");
//        通过配置文件来得到javabean
        Student student1 = context.getBean("student", Student.class);
//        打印Spring创建出来对象的name
        System.out.println("SpringIOC学生姓名"+student1.getName());
    }
}

通过上面的情况，确实发现减少了xml的编写

开启扫描的细节使用

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

（1）@Autowired：根据属性类型进行自动装配
第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service
public class UserService {
    //定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
    @Autowired
    private UserDao userDao; ;
    public void add() {
        System. out .println( "service add.......");
        userDao.add();
    }
}

@Qualifier：根据名称进行注入
        这个@Qualifier 注解的使用，和上面@Autowired 一起使用
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

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

@Value：注入普通类型属性
@Value(value = "abc")
private String name;

IOC完全注解开发

这些内容在之后Spring注解文章中我会认真进行编写

使用配置类，来代替所有的XML，在SpringBoot总就不存在Spring的配置文件，使用了完全注解开发