Spring学习笔记--IOC容器

最新推荐文章于 2024-09-21 00:43:01 发布

Lancber

最新推荐文章于 2024-09-21 00:43:01 发布

阅读量434

点赞数 2

分类专栏： Spring学习笔记文章标签： spring java

本文链接：https://blog.csdn.net/weixin_43022687/article/details/107670948

版权

Spring学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

- - IOC容器学习笔记

IOC容器学习笔记

什么是IOC：

控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。
使用IOC是为了降低耦合度。

1. IOC底层原理

xml解析、工厂模式、反射

工厂模式：通过建立中间工厂类降低类之间的耦合度
反射：通过得到类的字节码文件操作类

IOC过程：

配置xml文件，配置创建的对象

<bean id="dao" class="com.company.UserDao"></bean>

有service类和dao类，创建工厂类

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

2. IOC接口(BeanFactory)

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

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

BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用；
加载配置文件时不会创建对象，在获取（使用）对象时才会创建对象。
ApplicationContext：BeanFactory的子接口，提供更多更强大的功能，一般由开发人员使用。
加载配置文件时就会把配置文件中的对象去创建。

ApplicationContext接口主要的实现类：

FileSystemXmlApplicationContext
ClassPathXmlApplicationContext

什么是Bean管理：

Bean管理指的是两个操作：Spring创建对象，Spring注入属性。
Bean管理操作有两种方式：基于xml配置文件方式实现，基于注解方式实现。

3. IOC操作Bean管理(基于xml)

3.1 基于xml方式创建对象

(1)在Spring配置文件中，使用bean标签，标签黎曼条件对应属性即可实现对象创建

<bean id="dao" class="com.company.UserDao"></bean>

(2)bean标签中的常用属性

id属性：唯一标识，(不可使用符号)
class属性：对象的类的全路径
name属性：与id属性相似，但可使用符号

(3)创建对象时，默认执行无参数构造方法

3.2 基于xml方式注入属性

DI:依赖注入,即注入属性

使用set方法进行注入

(1)创建类，对应属性和set方法

public class Book{
    private String bname;
    private String bauthor;
    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
    
    public void testDemo(){
        System.out.print("name:"+bname+",author:"+bauthor);
    }   
}

(2)在Spring配置文件中首先配置对象创建，而后配置属性注入

<!--set方法注入属性-->
    <bean id="book" class="com.company.Book">
        <!--使用property完成属性注入
            name:类里面的属性名称
            value：向属性注入的值
        -->
        <property name="bname" value="达芬奇密码"></property>
        <property name="bauthor" value="Dan Brown"></property>
    </bean>

(3)测试代码

package com.company.testdemo;

import com.company.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

使用有参数构造注入

(1)创建类，定义属性，创建属性对应的有参构造方法

package com.company;

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

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
    
    public void ordersTest(){
        System.out.print("oname:"+oname+",address:"+address);
    }
}

(2)在Spring文件中进行配置

<!--有参构造方法注入属性-->
    <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="LiMing"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

constructor-arg还具有属性index,即通过索引来指定变量，即：<constructor-arg index="0" value="LiMing"></constructor-arg>为第一个变量注入属性。

(3)测试代码

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

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

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

<?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"       
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
       
</beans>

(2)进行属性注入，在bean标签里进行操作

<!--使用p空间名称-->
    <bean id="book" class="com.company.Book" p:bname="文学回忆录" p:bauthor="木心"></bean>

3.3 基于xml方式注入其他类型属性

字面量：设置属性的固定值即为字面量。

设值时可为空值

<bean id="book" class="com.company.Book">
       <!--使用property完成属性注入
            name:类里面的属性名称
            value：向属性注入的值
        -->
        <property name="bname" value="达芬奇密码"></property>
        <property name="bauthor" value="Dan Brown"></property>
        
        <!--向属性中设置空值-->
        <property name="address">
            <null/>
        </property>
        
    </bean>

属性值包含特殊符号

<bean id="book" class="com.company.Book">
       <!--使用property完成属性注入
            name:类里面的属性名称
            value：向属性注入的值
        -->
        <property name="bname" value="达芬奇密码"></property>
        <property name="bauthor" value="Dan Brown"></property>
        
        <!--属性值包含特殊符号
            1.把<>进行转义：&lt;&gt;
            2.把带特殊符号内容写到CDATA <![CDATA[属性值]]> 
        -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>

    </bean>

3.4 基于xml方式注入属性-外部bean

(1)创建两个类：service,dao
(2)在service调用dao里面的方法

UserService类：

package com.company.service;
import com.company.dao.UserDao;
import com.company.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.update();
        //原始方式：创建UserDao对象
        //UserDao userdao=new UserDaoImpl();
        //userdao.update();
    }
}

UserDao接口及实现类：

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

(3)在Spring配置文件里进行配置

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

(4)测试

public class TestBean {
    @Test
    public void testAdd(){
        //加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");

        //加载配置创建的对象
        UserService userService=context.getBean("UserService",UserService.class);
        userService.add();
    }
}

3.5 基于xml方式注入属性-内部bean

(1)一对多关系：部门与员工。在实体类之间表示一对多关系。

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

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


//员工类
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:"+ename+",gender:"+gender+",dept:"+dept);
    }
}

(2)在Spring配置文件中进行配置

<!--内部bean-->
    <bean id="emp" class="com.company.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Ann"></property>
        <property name="gender" value="female"></property>

        <!--设置对象类型属性-->
        <property name="dept" >
            <bean id="dept" class="com.company.bean.Dept">
                <property name="dname" value="hr"></property>
            </bean>
        </property>
        
    </bean>

(3)测试

@Test
    public void testBean3(){
        //加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");

        //加载配置创建的对象
        Emp emp=context.getBean("emp",Emp.class);
        emp.add();
    }

3.6 基于xml方式注入属性-级联赋值

(1)第一种写法：

<!--级联赋值-->
    <bean id="emp" class="com.company.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Ann"></property>
        <property name="gender" value="female"></property>

        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        
    </bean>

    <bean id="dept" class="com.company.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

(2)第二种写法
Emp类里需添加get方法：

//员工类
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 Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void add(){
        System.out.println("ename:"+ename+",gender:"+gender+",dept:"+dept);
    }
}

Spring配置文件:

<!--级联赋值-->
    <bean id="emp" class="com.company.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Ann"></property>
        <property name="gender" value="female"></property>

        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="开发部"></property>
        
    </bean>

    <bean id="dept" class="com.company.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

3.7 基于xml方式注入属性-集合属性

注入数组类型属性，注入List集合类型属性，注入Map集合类型属性
(1)创建类，并生成set方法：

public class Stu {
    //数组类型属性
    private String[] courses;
    //list集合类型
    private List<String> list;
    //map集合类型属性
    private Map<String,String> maps;
    //set集合类型属性
    private Set<String> 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;
    }

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

(2)在Spring配置文件里进行配置

<!--集合属性注入-->
    <bean id="stu" class="com.company.CollectionType.Stu">

        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>python</value>
            </array>
        </property>


        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>Johnsan</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>

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

<!--集合属性注入-->
    <bean id="stu" class="com.company.CollectionType.Stu">
    
        <!--注入值为对象的list集合类型-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>

    <!--创建多个course对象-->
    <bean id="course1" class="com.company.CollectionType.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.company.CollectionType.Course">
        <property name="cname" value="Spring boot框架"></property>
    </bean>

把集合注入部分提取出来作为公共部分
(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: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">

</beans>

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

<!--提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>Spring实战</value>
        <value>Springboot实战</value>
        <value>Java实战</value>
    </util:list>

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

3.8 FactoryBean

Spring中有两种类型bean,一种是普通bean,一种是工厂bean(FactoryBean)
普通bean:在bean标签的class属性定义的类型是什么，则其返回的类型即为该类型；
FactoryBean:在配置文件定义bean类型可以和返回类型不一样

(1)创建类，让这个类作为工厂bean，实现接口FactoryBean

(2)实现接口里面的方法，在实现的方法定义返回的bean类型

public class MyBean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course=new Course();
        course.setCname("Java");
        return course;
    }

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

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

配置文件：

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

    <bean id="myBean" class="com.company.factorybean.MyBean"></bean>

</beans>

测试代码：

@Test
    public void testBean3(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
        Course course =context.getBean("myBean", Course.class);
        System.out.println(course);
    }

3.9 Bean的作用域

在Spring里，可设置创建bean的实例是单实例或多实例；默认情况下，bean是单实例对象。

@Test
    public void testList(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        Book book1=context.getBean("book", Book.class);
        Book book2=context.getBean("book", Book.class);
        //book.test();
        System.out.println(book1);
        System.out.println(book2);
    }

测试结果为：

com.company.CollectionType.Book@727803de  
com.company.CollectionType.Book@727803de

两个对象地址相同即说明，默认情况下，bean为单实例对象。

设置单实例或多实例
(1)在Spring配置文件bean标签有属性(scope)可用于设置单实例或多实例

(2)scope属性值：
第一个值，默认值：singleton,表示单实例对象。当此属性为该值时，在加载Spring配置文件时就会创建单实例对象。

第二个值，prototype,表示多实例对象。当此属性为该值时，并不是在加载Spring配置文件时创建对象，而是在调用getBean()方法时创建多实例对象。

<!--提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>Spring实战</value>
        <value>Springboot实战</value>
        <value>Java实战</value>
    </util:list>

    <!--提取list集合类型属性注入使用,属性值为多实例-->
    <bean id="book" class="com.company.CollectionType.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

测试代码：

@Test
    public void testList(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        Book book1=context.getBean("book", Book.class);
        Book book2=context.getBean("book", Book.class);
        //book.test();
        System.out.println(book1);
        System.out.println(book2);
    }

测试结果：

com.company.CollectionType.Book@727803de  
com.company.CollectionType.Book@704921a5

两个对象地址不同，即说明为多实例对象。

3.10 Bean的生命周期

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

无bean后置处理器，生命周期分为五步

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

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

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

(4)bean可以使用（对象已经获取）

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

public class Orders {
    private String oname;

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

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

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

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

配置文件，需要配置文件中指定初始方法及销毁方法

<bean id="orders" class="com.company.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="oname" value="mobile"></property>
    </bean>

测试代码：

@Test
    public void testBean4(){
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders =context.getBean("orders", Orders.class);
        System.out.println("第四步，获取创建bean实例对象");
        System.out.println(orders);

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

测试结果：

第一步，执行无参数构造创造bean实例
第二步，调用set方法设置属性值
第三步，执行初始化的方法
第四步，获取创建bean实例对象
com.company.bean.Orders@74ad1f1f
第五步，执行销毁的方法

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

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

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

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

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

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

(6)bean可以使用（对象已经获取）

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

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

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.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;
    }
}

配置后置处理器，若有多个实例，则会为每个实力都实现后置处理器

    <bean id="orders" class="com.company.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="oname" value="mobile"></property>
    </bean>

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

测试代码：

    @Test
    public void testBean4(){
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders =context.getBean("orders", Orders.class);
        System.out.println("第四步，获取创建bean实例对象");
        System.out.println(orders);

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

    }

测试结果：

第一步，执行无参数构造创造bean实例
第二步，调用set方法设置属性值
在初始化之前执行的方法
第三步，执行初始化的方法
在初始化之后执行的方法
第四步，获取创建bean实例对象
com.company.bean.Orders@69b0fd6f
第五步，执行销毁的方法

3.11 xml自动装配

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

bean标签属性autowrite,用来配置自动装配

autowrite属性里常用两个值：
byName根据属性名注入，注入值的bean的id值要与类属性名称一致
byType根据属性类型注入,对于同类型不能定义多个，无法识别

类文件：

public class Emp {
    private Dept dept;//该属性名需与配置文件中的id值一致

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }

    public void test(){
        System.out.println(dept);
    }
}

配置文件：

    <!--
        自动装配
        bean标签属性autowrite,配置自动装配
        autowrite属性里常用两个值：
        byName根据属性名注入，注入值的bean的id值要与类属性名称一致
        byType根据属性类型注入,
      -->
    <bean id="emp" class="com.company.autowrite.Emp" autowire="byName">
        <!--<property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.company.autowrite.Dept"></bean>

3.12 外部属性文件

直接配置数据库信息（配置德鲁伊连接池）
引入德鲁伊连接池依赖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="Lancer"></property>
        <property name="password" value="026563"></property>
    </bean>

引入外部属性文件配置数据库连接池
(1)新建一个外部属性文件：jdbc.properties

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=Lancer
prop.password=026563

(2)把外部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 http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

(3)在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 http://www.springframework.org/schema/context/spring-context.xsd">

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

    <!--配置连接池-->
    <bean id="dataSourse" 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>
</beans>

4. IOC操作Bean管理(基于注释)

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

4.1 创建对象

以下四个注解功能一致，都可以用来创建bean实例；

@Component
@Service
@Controller
@Repository

(1)需额外引入spring-aop-5.2.6.RELEASE.jar依赖

(2)开启组件扫描，首先须在配置文件添加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 http://www.springframework.org/schema/context/spring-context.xsd">
    <!--
        开启组件扫描
        如果扫描多个包，可以将多个包使用逗号隔开
        也可直接扫描包的上层目录
    -->
    <!--<context:component-scan base-package="com.company.dao,com.company.service"></context:component-scan>-->
    <context:component-scan base-package="com.company"></context:component-scan>


</beans>

(3)创建类，在类上面添加创建对象注解

package com.company.service;

import org.springframework.stereotype.Component;

//注解里面value值的属性值可以省略不写，默认值为类名称，首字母小写。
//即：UserService-userService
//该处其他注解同样可以直接执行（@Service,@Controller,@Repository）
@Component(value = "userService")//与<bean id="userService" class="com.company.service.UserService"></bean>
public class UserService {

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

(4)测试代码

    @Test
    public void testService(){
        //加载配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }

4.2 开启组件扫描

(1)context:include-filter,设置扫描哪些内容

<?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 http://www.springframework.org/schema/context/spring-c
    <!--
        示例1
        use-default-filters="false"表示现在不使用默认filter，自己配置filter
        context:include-filter,设置扫描哪些内容
        expression="org.springframework.stereotype.Controller" 说明只扫描带@Controller注解的类
     -->
    <context:component-scan base-package="com.company" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

</beans>

(2)context:exclude-filter ,设置哪些内容不扫描

<?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 http://www.springframework.org/schema/context/spring-context.xsd">
    <!--
        示例2
        首先扫描包中所有内容
        context:exclude-filter ,设置哪些内容不扫描
    -->
    <context:component-scan base-package="com.company">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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

@AutoWired：根据属性类型进行自动装配
(1)把service和dao对象创建，在service和dao类上添加创建对象的注解
UserDao类：

public interface UserDao {
    public void add();
}
---
package com.company.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {

    }
}

(2)在service注入dao对象，在service类添加dao类型属性，在属性上使用注解

package com.company.service;

import com.company.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class UserService {

    //定义dao类型属性，不需要添加set方法。添加输入属性注解
    @Autowired //根据类型进行注入
    private UserDao userDao;

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

@Qualifier：根据属性名称进行注入
该注解使用需要与@AutoWired一起使用。

@Repository
public class UserService {
    //定义dao类型属性，不需要添加set方法。添加输入属性注解
    @Autowired
    @Qualifier(value = "userDaoImpl")//与UserDaoImpl类的注解value值一致
    private UserDao userDao;

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

@Resourse：可以根据类型注入，也可以根据名称注入

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

@Value：注入普通类型属性

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

4.4 纯注解开发

(1)创建配置类，替代xml配置文件

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.company"})//等价配置文件中的<context:component-scan base-package="com.company"></context:component-scan>
public class SpringConfig {

}

(2)编写测试类

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