• Spring IOC的应用


    IOC的实现,主要靠 xml/注解 + 工厂模式 + 反射 实现的。通过xml或注解配置需要管理的bean,通过工厂模式+反射获取bean的实例。

    一、IOC基础

    1、maven导入spring的 jar包 和 单测包

            基础依赖context里面包含context、aop、beans、core、expression这些jar包
    1. <dependency>
    2.     <groupId>org.springframeworkgroupId>
    3.     <artifactId>spring-contextartifactId>
    4.     <version>5.3.19version>
    5. dependency>
    6. <dependency>
    7.     <groupId>junitgroupId>
    8.     <artifactId>junitartifactId>
    9.     <version>4.13.2version>
    10.     <scope>testscope>
    11. dependency>

    2、bean的配置

    bean的配置主要通过三种模式:纯xml模式、xml+注解模式、纯注解模式

    2.1 纯xml模式

    2.1.1 xml文件头
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     https://www.springframework.org/schema/beans/spring-beans.xsd">
    2.1.2 实例化Bean的三种方式
    方式一:使用无参构造函数
    在默认情况下,它会通过反射调⽤⽆参构造函数来创建对象。如果类中没有⽆参构造函数,将创建失败。
    1. <bean id="userService" class="com.lagou.service.impl.TransferServiceImpl">
    2. bean>
    方式二:使⽤静态⽅法创建
    在实际开发中,我们使用的对象有时候并不是通过构造函数直接创建的,在创建过程中可能做很多额外操作,这时提供创建对象的方法恰好是个静态static方法,比如获取数据库连接DriverManager.getConnection()。在历史代码没有用spring框架,但是使用了工厂模式解耦,在接入spring后,可以通过这类对象就可以如下配置:
    1. <bean id="userService" class="com.lagou.factory.BeanFactory" 
    2.     factory-method="getTransferService">bean>
    方式三:使用实例化方法创建
    同使用静态方法创建类似,区别是用于获取对象的方法不再是static修饰的,而是普通方法
    1. <bean id="beanFactory"
    2.     class="com.lagou.factory.instancemethod.BeanFactory">bean>
    3. <bean id="transferService" factory-bean="beanFactory" 
    4.     factory-method="getTransferService">bean>
    2.1.3 Bean的生命周期
    spring支持6种作用范围,不同的作用范围生命周期不同。spring默认bean对象都是单例的。
    实际开发中,用到做多的作⽤范围就是singleton(单例模式)和prototype(原型模式,也叫多例模式)。配置⽅式参考下⾯的代码:
    1. <bean id="transferService"
    2.     class="com.lagou.service.impl.TransferServiceImpl" scope="singleton">
    3. bean>
    不同作⽤范围的⽣命周期:
    • 单例模式:singleton
                对象出⽣:当创建容器时,对象就被创建了。
                对象活着:只要容器在,对象⼀直活着。
                对象死亡:当销毁容器时,对象就被销毁了。
                ⼀句话总结:单例模式的bean对象⽣命周期与容器相同。
    • 多例模式:prototype
                对象出⽣:当使⽤对象时,创建新的对象实例。
                对象活着:只要对象在使⽤中,就⼀直活着。
                对象死亡:当对象⻓时间不⽤时,被java的垃圾回收器回收了。
                ⼀句话总结:多例模式的bean对象,spring框架只负责创建,不负责销毁。
    2.1.4 Bean标签属性
    • id属性: ⽤于给bean提供⼀个唯⼀标识。在⼀个标签内部,标识必须唯⼀。
    • class属性:⽤于指定创建Bean对象的全限定类名。
    • name属性:⽤于给bean提供⼀个或多个名称。多个名称⽤空格分隔。
    • factory-bean属性:⽤于指定创建当前bean对象的⼯⼚bean的唯⼀标识。当指定了此属性之后,class属性失效。
    • factory-method属性:⽤于指定创建当前bean对象的⼯⼚⽅法,如配合factory-bean属性使⽤,则class属性失效。如配合class属性使⽤,则⽅法必须是static的。
    • scope属性:⽤于指定bean对象的作⽤范围。通常情况下就是singleton。当要⽤到多例模式时,可以配置为prototype。
    • init-method属性:⽤于指定bean对象的初始化⽅法,此⽅法会在bean对象装配后调⽤。必须是⼀个⽆参⽅法。
    • destory-method属性:⽤于指定bean对象的销毁⽅法,此⽅法会在bean对象销毁前执⾏。它只能为scope是singleton时起作⽤。
    2.1.5 DI依赖注入的xml配置
    依赖注⼊分类
        按照注⼊的⽅式分类
             构造函数注⼊:顾名思义,就是利⽤带参构造函数实现对类成员的数据赋值。
             set⽅法注⼊:它是通过类成员的set⽅法实现数据的注⼊。(使⽤最多的)
        按照注⼊的数据类型分类
             基本类型和String:注⼊的数据类型是基本类型或者是字符串类型的数据。
             其他Bean类型:注⼊的数据类型是对象类型,称为其他Bean的原因是,这个对象是要求出现在IoC容器中的。那么针对当前Bean来说,就是其他Bean了。
             复杂类型(集合类型):注⼊的数据类型是Aarry,List,Set,Map,Properties中的⼀种类型
    2.1.5.1 构造函数注入
    使⽤要求是,类中提供的构造函数参数个数必须和配置的参数个数⼀致,且数据类型匹配。
    同时需要注意的是,当没有⽆参构造时,则必须提供构造函数参数的注⼊,否则Spring框架会报错。
    1. <bean id="userDao" class="com.test.UserDao">
    2.     <constructor-arg name="name" value="zhangsan"/>
    3.     <constructor-arg name="age" value="18"/>
    4.     <constructor-arg name="friend" ref="user"/>
    5. bean>
    在使⽤构造函数注⼊时,涉及的标签是 constructor-arg ,该标签有如下属性:
    name :⽤于给构造函数中指定名称的参数赋值。
    index :⽤于给构造函数中指定索引位置的参数赋值。
    value :⽤于指定基本类型或者 String 类型的数据。
    ref :⽤于指定其他 Bean 类型的数据。写的是其他 bean 的唯⼀标识。
    2.1.5.2 set方法注入
    利⽤字段的set⽅法实现赋值的注⼊⽅式,需要有无参构造方法。此种⽅式在实际开发中是使⽤最多的注⼊⽅式。
    1. <bean id="userDao" class="com.test.UserDao">
    2.     <property name="name" value="zhangsan"/>
    3.     <property name="age" value="18"/>
    4.     <property name="friend" ref="user"/>
    5. bean>
    在使⽤ set ⽅法注⼊时,需要使⽤ property 标签,该标签属性如下:
    name :指定注⼊时调⽤的 set ⽅法名称。(注:不包含 set 这三个字⺟ ,druid 连接池指定属性名称)
    value :指定注⼊的数据。它⽀持基本类型和 String 类型。
    ref :指定注⼊的数据。它⽀持其他 bean 类型。写的是其他 bean 的唯⼀标识。
    2.1.5.3 复杂数据类型注入
    复杂类型数据指的是集合类型数据。集合分为两类,⼀类是List结构(数组结构),⼀类是Map接⼝(键值对)
    以set方法注入为例:类型分别是String[]、Map、List、Properties
    1. <bean id="userDao" class="com.test.UserDao">
    2.     <property name="myArray">
    3.         <array>
    4.             <value>array1value>
    5.             <value>array2value>
    6.             <value>array3value>
    7.         array>
    8.     property>
    9.     <property name="myMap">
    10.         <map>
    11.             <entry key="key1" value="value1"/>
    12.             <entry key="key2" value="value2"/>
    13.         map>
    14.     property>
    15.     <property name="mySet">
    16.         <set>
    17.             <value>set1value>
    18.             <value>set2value>
    19.         set>
    20.     property>
    21.     <property name="myProperties">
    22.         <props>
    23.             <prop key="prop1">value1prop>
    24.             <prop key="prop2">value2prop>
    25.         props>
    26.     property>
    27. bean>
    List 结构的集合数据注⼊时, array , list , set 这三个标签通⽤,另外注值的 value 标签内部 可以直接写值,也可以使⽤ bean 标签配置⼀个对象,或者⽤ ref 标签引⽤⼀个已经配合的 bean 的唯⼀标识。
    Map 结构的集合数据注⼊时, map 标签使⽤ entry ⼦标签实现数据注⼊, entry 标签可以使 key value 属性指定存⼊ map 中的数据。使⽤ value-ref 属性指定已经配置好的 bean 的引⽤。
    同时 entry 标签中也可以使⽤ ref 标签,但是不能使⽤ bean 标签。⽽ property 标签中不能使 ref 或者 bean 标签引⽤对象

    2.2 xml与注解相结合模式(最常用)

    用xml的bean:第三⽅jar中的bean,⽐如德鲁伊数据库连接池
    用注解的bean:⾃⼰开发的bean定义
    xml+注解结合模式,xml⽂件依然存在,所以,spring IOC容器的启动仍然从加载xml开始
    2.2.1 xml中标签与注解的对应关系
    xml形式
    对应的注解形式
    标签
    @Component("accountDao"),注解加在类上
    bean的id属性内容直接配置在注解后面如果不配置,默认定义个这个bean的id为类的类名首字母小写;
    另外,针对分层代码开发提供了@Componenet的三种别名@Controller、@Service、@Repository分别用于控制层类、服务层类、dao层类的bean定义,这四个注解的用法完全一样,只是为了更清晰的区分而已
    标签的scope属性
    @Scope("prototype"),默认单例,注解加在类上
    标签的init-method属性
    @PostConstruct,注解加在方法上,该方法就是初始化后调用的方法
    标签的destory-method属性
    @PreDestory,注解加在方法上,该方法就是销毁前调用的方法
    2.2.2 DI依赖注入的注解实现方式
    方法一:@Autowired(推荐使⽤)
    @Autowired为Spring提供的注解,需要导⼊包org.springframework.beans.factory.annotation.Autowired。
    @Autowired采取的策略为按照类型注⼊。
    1. @Autowired
    2. private AccountDao accountDao;
    这样会去spring容器中找到类型为AccountDao的类,然后将其注⼊进来。这样会产⽣⼀个问题,当⼀个类型有多个bean值的时候,会造成⽆法选择具体注⼊哪⼀个的情况,这个时候我们需要配合着@Qualifier使⽤。
    @Qualifier告诉Spring具体去装配哪个对象
    1. @Autowired
    2. @Qualifier(name="jdbcAccountDaoImpl")
    3. private AccountDao accountDao;
    方法二:@Resource
    @Resource 注解由 J2EE 提供,需要导⼊包 javax.annotation.Resource。
    @Resource 默认按照 ByName ⾃动注⼊。
    1. @Resource
    2. private AccountDao accountDao;
    3. @Resource(name="studentDao")
    4. private StudentDao studentDao;
    5. @Resource(type="TeacherDao")
    6. private TeacherDao teacherDao;
    7. @Resource(name="manDao",type="ManDao")
    8. private ManDao manDao;
    如果同时指定了 name 和 type,则从Spring上下⽂中找到唯⼀匹配的bean进⾏装配,找不到则抛出异常。
    如果指定了 name,则从上下⽂中查找名称(id)匹配的bean进⾏装配,找不到则抛出异常。
    如果指定了 type,则从上下⽂中找到类似匹配的唯⼀bean进⾏装配,找不到或是找到多个,都会抛出异常。
    如果既没有指定name,⼜没有指定type,则⾃动按照byName⽅式进⾏装配;
    注意:
    @Resource 在 Jdk 11中已经移除,如果要使⽤,需要单独引⼊jar包
    1. <dependency>
    2.     <groupId>javax.annotationgroupId>
    3.     <artifactId>javax.annotation-apiartifactId>
    4.     <version>1.3.2version>
    5. dependency>

    2.3 纯注解模式

    改造xml+注解模式,将xml中遗留的内容全部以注解的形式迁移出去,最终删除xml,从Java配置类启动
    对应注解
    @Configuration 注解,表名当前类是⼀个配置类
    @ComponentScan 注解,替代 context:component-scan
    @PropertySource,引⼊外部属性配置⽂件
    @Import 引⼊其他配置类
    @Value 对变量赋值,可以直接赋值,也可以使⽤ ${} 读取资源配置⽂件中的信息
    @Bean 将⽅法返回对象加⼊ SpringIOC 容器

    3、启动IOC的方式

    3.1 Java环境下启动IOC容器

    • ClassPathXmlApplicationContext:从类的根路径下加载配置⽂件(推荐使⽤)
    • FileSystemXmlApplicationContext:从磁盘路径上加载配置⽂件
    • AnnotationConfigApplicationContext:纯注解模式下启动Spring容器
    1. ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    2. UserDao userDao = (UserDao)context.getBean("userDao");

    3.2 Web环境下启动IOC容器

    3.2.1 从xml启动容器
    1. web-app PUBLIC
    2.     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    3.     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    4. <web-app>
    5.     <display-name>Archetype Created Web Applicationdisplay-name>
    6.     
    7.     <context-param>
    8.         <param-name>contextConfigLocationparam-name>
    9.         <param-value>classpath:applicationContext.xmlparam-value>
    10.     context-param>
    11.     
    12.     <listener>
    13.         <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    14.     listener>
    15. web-app>
    3.2.2 从配置类启动容器
    1. web-app PUBLIC
    2.     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    3.     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    4. <web-app>
    5.     <display-name>Archetype Created Web Applicationdisplay-name>
    6.     
    7.     <context-param>
    8.         <param-name>contextClassparam-name>
    9.         <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContextparam-value>
    10.     context-param>
    11.     
    12.     <context-param>
    13.         <param-name>contextConfigLocationparam-name>
    14.         <param-value>com.lagou.edu.SpringConfigparam-value>
    15.     context-param>
    16.     
    17.     <listener>
    18.         <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    19.     listener>
    20. web-app>

    二、IOC高级特性

    1、lazy-Init延迟加载

    ApplicationContext 容器的默认⾏为是在启动服务器时将所有 singleton bean 提前进⾏实例化。提前实例化意味着作为初始化过程的⼀部分,ApplicationContext 实例会创建并配置所有的singleton bean。
    默认:lazy-init="false",⽴即加载,表示在spring启动时,⽴刻进⾏实例化
    设置 lazy-init 为 true 的 bean 将不会在 ApplicationContext 启动时提前被实例化,⽽是第⼀次向容器通过 getBean 索取 bean 时实例化的。
    <bean id="testBean" calss="com.test.LazyBean" lazy-init="true" />
    如果⼀个设置了⽴即加载的 bean1,引⽤了⼀个延迟加载的 bean2 ,那么 bean1 在容器启动时被实例化,⽽ bean2 由于被 bean1 引⽤,所以也被实例化,这种情况也符合延时加载的 bean 在第⼀次调⽤时才被实例化的规则。
    也可以在容器层次中通过在 元素上使⽤ "default-lazy-init" 属性来控制延时初始化。如下⾯配置:
    1. <beans default-lazy-init="true">
    2.     
    3. beans>
    如果⼀个 bean 的 scope 属性为 scope="pototype" 时,即使设置了 lazy-init="false",容器启动时也不会实例化bean,⽽是调⽤ getBean ⽅法实例化的。

    2、自定义Bean的创建过程:FactoryBean

    FactoryBean可以生成某一个类型的Bean实例,spring框架一些组件中会使用,还有其他框架和spring框架整合时会使用
    实现类
    1. public class UserFactoryBean implements FactoryBean {
    2.     private String userInfo;//名字,年龄
    3.     public void setUserInfo(String userInfo) {
    4.         this.userInfo = userInfo;
    5.     }
    6.     //自定义bean的创建过程
    7.     @Override
    8.     public User getObject() throws Exception {
    9.         User user = new User();
    10.         String[] strings = userInfo.split(",");
    11.         user.setName(strings[0]);
    12.         user.setAge(Integer.parseInt(strings[1]));
    13.         return user;
    14.     }
    15.     //返回bean类型
    16.     @Override
    17.     public Class getObjectType() {
    18.         return User.class;
    19.     }
    20.     //返回作用域是否单例,默认单例
    21.     @Override
    22.     public boolean isSingleton() {
    23.         return FactoryBean.super.isSingleton();
    24.     }
    25. }
    xml配置
    1. <bean id="userFactoryBean" class="com.test.UserFactoryBean">
    2.     <property name="userInfo" value="张三,19"/>
    3. bean>
    测试
    1. ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    2. User userDao = (User)context.getBean("userFactoryBean");
    3. System.out.println(userDao);

  • 相关阅读:
    软件测试面试怎样介绍自己的测试项目?会问到什么程度?
    Kubernetes(k8s) 资源限制:resources,LimitRange,ResourceQuota
    hive-on-spark
    .NET Framework 2023 年 8 月安全和质量汇总更新
    layui2.9.7-入门初学
    Python二分查找
    pytest-bdd快速示例和问题解决
    Kafka使用Java管理主题和分区
    微机原理与技术接口 实验五 基本IO操作温度控制实验
    推荐一个好用的电商开源项目yudao源码
  • 原文地址:https://blog.csdn.net/xike1024/article/details/142271964