Spring框架控制翻转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(); } 

本文地址：https://blog.csdn.net/weixin_43022687/article/details/107670948