4-1-1 Spring基础-Spring IoC容器与Bean管理

IoC控制反转

IoC控制反转,全称Inverse of Control,是一种设计理念

由代理人来创建与管理对象,消费者通过代理人来获取对象

IoC的目的是降低程序与程序之间直接耦合

为什么要IoC控制反转

对象直接引用导致对象硬性关联,程序难以维护

例如:顾客直接采购苹果

加入IoC对象统一管理,让对象关联变为弱耦合

例如:果商冷冻仓库批发苹果,然后快递给顾客

DI依赖注入

IoC是设计理念,是现代程序设计遵循的标准,是宏观目标

DI(Dependency Injection)是具体技术实现,是微观实现

DI在Java中利用反射技术实现对象注入(Injection)

Spring的含义

狭义的Spring是指Spring框架(Spring Fremework)

广义的Spring是指Spring生态体系

狭义的Spring框架

Spring框架是企业开发复杂性的一站式解决方案

Spring框架的核心是IoC容器与AOP面向切面编程

Spring IoC负责创建与管理系统对象,并在此基础上扩展功能

Spring IoC容器职责

对象的控制权交由第三方统一管理(IoC)控制反转

利用Java反射技术实现运行时对象创建与关联(DI依赖注入)

基于配置提高应用程序的可维护性与扩展性

Spring IoC的简单Demo

工程目录

 

pom.xml文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mingm.spring</groupId>
    <artifactId>ioc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <repositories>
        <repository>
            <id>aliyun</id>
            <name>aliyun</name>
            <url>https://maven.aliyun.com/repository/public</url>
        </repository>
    </repositories>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
    </dependencies>

</project>

applicationContext.xml文件如下:

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 在IoC容器启动时,自动由Spring实例化Apple对象,取名sweetApple放入到容器中 -->
    <bean id="sweetApple" class="com.mingm.spring.ioc.entity.Apple">
        <property name="title" value="红富士"></property>
        <property name="origin" value="欧洲"></property>
        <property name="color" value="红色"></property>
    </bean>

    <bean id="sourApple" class="com.mingm.spring.ioc.entity.Apple">
        <property name="title" value="青苹果"></property>
        <property name="origin" value="中亚"></property>
        <property name="color" value="绿色"></property>
    </bean>

    <bean id="softApple" class="com.mingm.spring.ioc.entity.Apple">
        <property name="title" value="金帅"></property>
        <property name="origin" value="中国"></property>
        <property name="color" value="黄色"></property>
    </bean>

    <bean id="rdApple" class="com.mingm.spring.ioc.entity.Apple">
        <property name="title" value="蛇果"></property>
        <property name="origin" value="美国"></property>
        <property name="color" value="红色"></property>
    </bean>

    <bean id="lily" class="com.mingm.spring.ioc.entity.Child">
        <property name="name" value="莉莉"/>
        <property name="apple" ref="softApple"/>
    </bean>

    <bean id="andy" class="com.mingm.spring.ioc.entity.Child">
        <property name="name" value="安迪"/>
        <property name="apple" ref="rdApple"/>
    </bean>

    <bean id="luna" class="com.mingm.spring.ioc.entity.Child">
        <property name="name" value="露娜"/>
        <property name="apple" ref="sweetApple"/>
    </bean>
</beans>

SpringApplication.java用于启动Spring IoC容器

import com.mingm.spring.ioc.entity.Apple;
import com.mingm.spring.ioc.entity.Child;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringApplication {
    public static void main(String[] args) {
        //创建Spring IoC容器,并根据配置文件在容器中实例化对象
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Apple sweetApple = context.getBean("sweetApple" , Apple.class);
        System.out.println(sweetApple.getTitle());
        //从IoC容器中提取beanId=lily的对象
        Child lily = context.getBean("lily", Child.class);
        lily.eat();
        Child andy = context.getBean("andy", Child.class);
        andy.eat();
        Child luna = context.getBean("luna", Child.class);
        luna.eat();

    }
}

初始化IoC容器

三种配置方式

基于XML配置Bean

基于注解配置Bean

基于Java代码配置Bean

Xml方式创建IoC容器

核心代码如下:

//创建Spring IoC容器,并根据配置文件在容器中实例化对象
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

实例化Bean的三种方式

基于构造方法对象实例化

基于静态工厂实例化

基于工厂实例方法实例化

示例工程

工程目录

 

 

实体类

package com.mingm.spring.ioc.entity;

public class Apple {
    private String title;
    private String color;
    private String origin;
    private Float price;

    public Apple() {
        System.out.println("Apple对象已创建," + this);
    }

    public Apple(String title, String color, String origin) {
        System.out.println("通过带参构造方法创建对象, " + this);
        this.title = title;
        this.color = color;
        this.origin = origin;
    }

    public Apple(String title,  String origin ,String color, Float price) {
        System.out.println("通过带参构造方法创建对象, " + this);
        this.title = title;
        this.color = color;
        this.origin = origin;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getOrigin() {
        return origin;
    }

    public void setOrigin(String origin) {
        this.origin = origin;
    }
}

package com.mingm.spring.ioc.entity;

public class Child {
    private String name;
    private Apple apple;

    public Child(){

    }

    public Child(String name, Apple apple) {
        this.name = name;
        this.apple = apple;
    }

    public String getName() {
        return name;
    }

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

    public Apple getApple() {
        return apple;
    }

    public void setApple(Apple apple) {
        this.apple = apple;
    }

    public void eat(){
        System.out.println(name + "吃到了" + apple.getOrigin() + "种植的" + apple.getTitle());
    }
}

工厂方法对象

package com.mingm.spring.ioc.factory;

import com.mingm.spring.ioc.entity.Apple;

/**
 * 静态工厂通过静态方法创建对象,隐藏创建对象的细节
 */
public class AppleStaticFactory {
    public static Apple createSweetApple(){
        //logger.info("")
        Apple apple = new Apple();
        apple.setTitle("红富士");
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        return apple;
    }
}

package com.mingm.spring.ioc.factory;

import com.mingm.spring.ioc.entity.Apple;

/**
 * 工厂实例方法创建对象是指IoC容器对工厂类进行实例化并调用对应的实例方法创建对象的过程
 */
public class AppleFactoryInstance {
    public Apple createSweetApple(){
        Apple apple = new Apple();
        apple.setTitle("红富士");
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        return apple;
    }
}

applicationContext.xml文件配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--bean标签默认通过默认构造方法创建对象-->
    <bean id="apple1" class="com.mingm.spring.ioc.entity.Apple">

    </bean>
    <!--使用带参构造方法实例化对象-->
    <bean name="apple2" class="com.mingm.spring.ioc.entity.Apple">
        <constructor-arg name="title" value="红富士"/>
        <constructor-arg name="color" value="红色"/>
        <constructor-arg name="origin" value="欧洲"/>
        <constructor-arg name="price" value="19.8"/>
    </bean>

    <bean id="apple3" class="com.mingm.spring.ioc.entity.Apple">
        <constructor-arg index="0" value="红富士"/>
        <constructor-arg index="1" value="欧洲"/>
        <constructor-arg index="2" value="红色"/>
        <constructor-arg index="3" value="19.8"/>
    </bean>

    <!--利用静态工厂获取对象-->
    <bean id="apple4" class="com.mingm.spring.ioc.factory.AppleStaticFactory"
          factory-method="createSweetApple"/>

    <!--利用工厂实例方法获取对象-->
    <bean id="factoryInstance" class="com.mingm.spring.ioc.factory.AppleFactoryInstance"/>
    <bean id="apple5" factory-bean="factoryInstance" factory-method="createSweetApple"/>
</beans>

从IoC容器获取Bean

//第一种方法 推荐,符合现在java编码规范
Apple apple1 = context.getBean("apple1", Apple.class);
//第二种方法
Apple apple2 = (Apple)context.getBean("apple2");

id与name属性相同点和区别

相同点:

1.bean id与name都是设置对象在IoC容器的唯一标识

2.两者在同一配置文件中都不允许重复

3.两者允许在多个配置文件中出现重复,新对象覆盖旧对象

//初始化多个配置文件,如果两个配置文件有共同的id或name,那么获取bean会从后一个配置文件中获取,新对象覆盖旧对象
String[] configLocations = new String[]{"classpath:applicationContext.xml","classpath:applicationContext-1.xml"};
//初始化IoC容器并实例化对象
ApplicationContext context = new ClassPathXmlApplicationContext(configLocations);

区别:

1.id更为严格,一次只能定义一个对象标识

2.name更为宽松,一次允许定义多个对象标识

    <bean name="apple2,apple7" class="com.mingm.spring.ioc.entity.Apple">
        <constructor-arg name="title" value="红富士2号"/>
        <constructor-arg name="color" value="红色"/>
        <constructor-arg name="origin" value="欧洲"/>
        <constructor-arg name="price" value="29.8"/>
    </bean>

3.id与name命名要有意义,按驼峰命名书写

路径表达式

加载单个配置文件

//创建Spring IoC容器,并根据配置文件在容器中实例化对象
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

classpath指的就是类路径

 

表达式实例	说明
classpath:config.xml	扫描classpath根路径下(不包含jar)的config.xml
classpath:com/mingm/config.xml	扫描classpath根路径下(不包含jar)com.mingm包中的config.xml
classpath*:com/mingm/config.xml	扫描classpath根路径下(包含jar)com.mingm包中的config.xml
classpath:config-*.xml	扫描classpath根路径下(不包含jar)所有以config-开头的xml文件
classpath:com/**/config.xml	扫描classpath根路径下(不包含jar)com包(包含任何子包)的config.xml
file:c/config.xml	扫描c盘根路径下的config.xml

对象依赖注入

依赖注入是指运行时将容器内对象利用反射赋值给其他对象的操作

基于setter方法注入对象

基于构造方法注入对象(前文已经说明)

基于setter方法注入对象

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="sweetApple" class="com.mingm.spring.ioc.entity.Apple">
        <!-- IoC容器自动利用反射机制运行时调用setXXX方法为属性赋值 -->
        <property name="title" value="红富士"/>
        <property name="color" value="红色"/>
        <property name="origin" value="欧洲"/>
        <property name="price" value="19.8"/>
    </bean>

    <bean id="lily" class="com.mingm.spring.ioc.entity.Child">
        <property name="name" value="莉莉"/>
        <!-- 利用ref注入依赖对象 -->
        <property name="apple" ref="sweetApple"/>
    </bean>

    <bean id="sourApple" class="com.mingm.spring.ioc.entity.Apple">
        <property name="title" value="青苹果"/>
        <property name="color" value="绿色"/>
        <property name="origin" value="中亚"/>
        <property name="price" value="9.8"/>
    </bean>

    <bean id="andy" class="com.mingm.spring.ioc.entity.Child">
        <constructor-arg name="name" value="安迪"/>
        <constructor-arg name="apple" ref="sourApple"/>
    </bean>

</beans>

注入集合对象

注入List

<bean id="company" class="com.mingm.spring.ioc.entity.Company">
    <property name="rooms">
        <list>
            <!-- 注入引用对象用ref -->
            <value>2001-总裁办</value>
            <value>2003-总经理办公室</value>
            <value>2010-研发部会议室</value>
            <value>2010-研发部会议室</value>
        </list>
    </property>
</bean>        

注入Set

<bean id="company" class="com.mingm.spring.ioc.entity.Company">
    <property name="rooms">
        <set>
                        <!-- 注入引用对象用ref -->
            <value>2001-总裁办</value>
            <value>2003-总经理办公室</value>
            <value>2010-研发部会议室</value>
            <value>2010-研发部会议室</value>
        </set>
    </property>
</bean> 

注入Map

<bean id="company" class="com.mingm.spring.ioc.entity.Company">
    <property name="computers">
        <map>
            <entry key="dev-88172" value-ref="c1"/>
            <entry key="dev-88173">
                <bean class="com.mingm.spring.ioc.entity.Computer">
                    <constructor-arg name="brand" value="联想"/>
                    <constructor-arg name="type" value="笔记本"/>
                    <constructor-arg name="sn" value="1280258012"/>
                    <constructor-arg name="price" value="5060"/>
                </bean>
            </entry>
        </map>
    </property>
</bean>

注入Properties

<bean id="company" class="com.mingm.spring.ioc.entity.Company">
    <property name="info">
        <props>
            <prop key="phone">010-12345678</prop>
            <prop key="address">北京市朝阳区XX路XX大厦</prop>
            <prop key="website">http://www.xxx.com</prop>
        </props>
    </property>
</bean>

        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Company company = context.getBean("company", Company.class);
        System.out.println(company);
        String website = company.getInfo().getProperty("website");
        System.out.println(website);

查看容器内对象

import com.mingm.spring.ioc.entity.Company;
import com.mingm.spring.ioc.entity.Computer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取容器内所有beanId数组
        String[] beanNames = context.getBeanDefinitionNames();
        for (String beanName:beanNames){
            System.out.println(beanName);
            System.out.println("类型:" + context.getBean(beanName).getClass().getName());
            System.out.println("内容:" + context.getBean(beanName));
        }

        Computer computer = context.getBean("com.mingm.spring.ioc.entity.Computer", Computer.class);
        System.out.println(computer.getBrand());
        Computer computer1 = context.getBean("com.mingm.spring.ioc.entity.Computer#1", Computer.class);
        System.out.println(computer1.getBrand());
    }
}

bean对象的作用域

bean scope属性

bean scope属性用于决定对象何时被创建与作用范围

bean scope配置将影响容器内对象的数量

默认情况下bean会在IoC容器创建后自动实例化,全局唯一

scope用法

<bean id="userDao" class="com.mingm.spring.ioc.dao.UserDao"  scope="prototype"/>

bean scope属性清单

scope属性	说明
singleton	单例(默认值),每一个容器有且只有唯一的实例,实例被全局共享
prototype	多例,每次使用都是创建一个实例
request	web环境下,每一次独立请求存在唯一实例
session	web环境下,每一个session存在唯一实例
application	web环境下,ServletContext存在唯一实例
websocket	web环境下,WebSocket连接中存在唯一实例

singleton与prototype

singleton:

1.在容器中是单例多线程执行,存在线程安全风险,所以该实例不能存在有状态的对象

2.被singleton修饰的bean会在IoC容器启动时实例化

protoytype:

1.在容器中多实例,占用更多资源,不存在线程安全问题

2.被prototype修饰的bean会在getBean()或者对象注入时实例化

bean生命周期

 

注意:对象执行构造方法时,该对象没有注入属性值,只有IoC容器为对象注入属性,对象调用init-method初始化方法对象才完成初始化

代码举例

对象实例

package com.mingm.spring.ioc.entity;

public class Order {
    private Float price;
    private Integer quantity;
    private Float total;

    public Order(){
        System.out.println("创建Order对象," + this);
    }

    public void init(){
        System.out.println("执行init()方法");
        total = price * quantity;
    }
    public void pay(){
        System.out.println("订单金额为:" + total);
    }
    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        System.out.println("设置price:" + price);
        this.price = price;
    }

    public Integer getQuantity() {
        return quantity;
    }

    public void setQuantity(Integer quantity) {
        System.out.println("设置quantity:" + quantity);
        this.quantity = quantity;
    }

    public Float getTotal() {
        return total;
    }

    public void setTotal(Float total) {
        this.total = total;
    }

    public void destroy(){
        System.out.println("释放与订单对象相关的资源");
    }
}

在applicationContext.xml文件中配置

    <bean id="order1" class="com.mingm.spring.ioc.entity.Order" init-method="init" destroy-method="destroy">
        <property name="price" value="19.8"/>
        <property name="quantity" value="1000"/>
    </bean>

主方法

package com.mingm.spring.ioc;

import com.mingm.spring.ioc.entity.Order;
import com.mingm.spring.ioc.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        System.out.println("======IoC容器已初始化=======");

        Order order1 = context.getBean("order1", Order.class);
        order1.pay();
        //销毁IoC容器
        ((ClassPathXmlApplicationContext) context).registerShutdownHook();
    }
}

运行结果

 其他细节

prototype时对象创建与init-method延迟至执行业务代码阶段

prototype时对象不再受IoC对象管理,不再触发destory-method

延迟加载lazy-init属性可让对象创建与初始化延迟到执行代码阶段

基于注解配置IoC容器

基于注解的优势

摆脱繁琐的XML形式的bean与依赖注入

基于声明式的原则,更适合轻量级的现代企业应用

让代码可读性变得更好,研发人员拥有更好的开发体验

开启组件扫描

    <!-- XML配置开启组件扫描,才能使用注解 -->
    <context:component-scan base-package="com.mingm">
        <!-- 排除不需要扫描的包 -->
        <context:exclude-filter type="regex" expression="com.mingm.exl.*"/>
    </context:component-scan>

三类注解

组件类型注解 - 声明当前类的功能与职责

自动装配注解 - 根据属性特征自动注入对象

元数据注解 - 更细化的辅助IoC容器管理对象的注解

四种组件类型注解

注解	说明
@Component	组件注解,通用注解,被该注解描述的类将被IoC容器管理并实例化
@Controller	语义注解,说明当前类是MVC应用中的控制器类
@Service	语义注解,说明当前类是Service业务服务类
@Repository	语义注解,说明当前类用于业务持久层,通常描述对应Dao类

两类自动装配注解

 

分类	注解	说明
按类型装配	@Autowored	按容器内对象类型动态注入属性,由Spring机构提供
	@Inject	基于JSR-330(Dependency Injection for java)标准,其他同@AutoWired,但不支持required属性
按名称装配	@Named	与@Inject配合使用,JSR-330规范,按属性名自动装配属性
	@Resource	基于JSR-250规范,优先按名称,再按类型匹配

元数据注解

注解	说明
@Primary	按类型装配时出现多个相同类型对象,拥有此注解对象优先被注入
@PostConstruct	描述方法,相当于XNL中init-method配置的注解版本
@PreDestory	描述方法,相当于XML中destory-method配置的注解版本
@Scope	设置对象的scope属性
@Value	为属性注入静态数据

演示@Value

config.properties文件

metaData=mingm.com
connection.driver=xxxxx
connection.url=xxx
connection.username=xxx
connection.password=xxx

applicationContext.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!--通知Spring IoC容器初始化时加载属性文件-->
    <context:property-placeholder location="classpath:config.properties"/>
    <!-- 在IoC容器初始化时自动扫描四种组件类型注解并完成实例化
        @Repository
        @Service
        @Controller
        @Component
     -->
    <context:component-scan base-package="com.mingm"/>
</beans>

UserService.java

package com.mingm.spring.ioc.service;

import com.mingm.spring.ioc.dao.IUserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service
@Scope("prototype")//设置单例/多例,XML中 bean scope完全相同
public class UserService {
    @Value("${metaData}")//读取config.properties的metaData属性值
    private String metaData ;
    @Value("${connection.password}")
    private String password;

    public UserService(){
        System.out.println("正在创建UserService:" + this);
    }

    @PostConstruct //XML中bean init-method完全相同
    public void init(){
        System.out.println("初始化UserService对象,metaData=" + metaData);
    }

    //Spring IoC容器会自动通过反射技术将属性private修饰符自动改为public,直接进行赋值
    //不再执行set方法
    @Autowired
    private IUserDao udao ;

    public IUserDao getUdao() {
        return udao;
    }


    /*@Autowired
    //如果装配注解放在set方法上,则自动按类型/名称对set方法参数进行注入
    public void setUdao(UserDao udao) {
        System.out.println("setUdao:" + udao);
        this.udao = udao;
    }*/
}

使用Java Config方式实现Spring IoC

Java Config核心注解

注解	说明
@Configuration	描述类,说明当前类是Java Config配置类,完全替代XML文件
@Bean	描述方法,方法返回对象将被IoC容器管理,beanI默认方法名
@ImportResource	描述类,加载静态文件,可以使用@Value注解获取
@ComponentScan	描述类,同XML的<context:compoment-scan>标签

例如:

import com.mingm.spring.ioc.controller.UserController;
import com.mingm.spring.ioc.dao.EmployeeDao;
import com.mingm.spring.ioc.dao.UserDao;
import com.mingm.spring.ioc.service.UserService;
import org.springframework.context.annotation.*;

@Configuration //当前类是一个配置类,用于替代applicationContext.xml
@ComponentScan(basePackages = "com.mingm")
public class Config {
    @Bean //Java Config利用方法创建对象,将方法返回对象放入容器,beanId=方法名
    public UserDao userDao(){
        UserDao userDao = new UserDao();
        System.out.println("已创建" + userDao);
        return userDao;
    }

    @Bean //Java Config利用方法创建对象,将方法返回对象放入容器,beanId=方法名
    @Primary
    public UserDao userDao1(){
        UserDao userDao = new UserDao();
        System.out.println("已创建" + userDao);
        return userDao;
    }

    @Bean
    //先按name尝试注入,name不存在则按类型注入
    public UserService userService(UserDao udao , EmployeeDao employeeDao){
        UserService userService = new UserService();
        System.out.println("已创建" + userService);
        userService.setUserDao(udao);
        System.out.println("调用setUserDao:" + udao);
        userService.setEmployeeDao(employeeDao);
        return userService;
    }

    @Bean //<bean id="xxx" clas="xxx">
    @Scope("prototype")
    public UserController userController(UserService userService){
        UserController userController = new UserController();
        System.out.println("已创建" + userController);
        userController.setUserService(userService);
        System.out.println("调用setUserService:" + userService);
        return userController;
    }
}

启动类

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringApplication {
    public static void main(String[] args) {
        //基于Java Config配置IoC容器的初始化
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        System.out.println("=========================");
        String[] ids = context.getBeanDefinitionNames();
        for(String id : ids){
            System.out.println(id + ":" + context.getBean(id));
        }
    }
}