menu 若在
springIOC_01
35 浏览 | 2021-03-12 | 阅读时间: 约 13 分钟 | 分类: JAVA | 标签: Spring,Ioc
请注意,本文编写于 31 天前,最后修改于 31 天前,其中某些信息可能已经过时。

1. Spring概述

1.1 spring概述

1.1.1 spring是什么

​ Spring是分层的Java SE/EE应用 full-stack轻量级开源框架,以IoC(Inverse Of Control:反转控制)和AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE企业应用开源框架。

1.1.2 spring优势

方便解耦,简化开发

​ 通过Spring提供的IoC容器,可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。

AOP编程的支持

​ 通过Spring的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

声明式事务的支持

​ 可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活的进行事务的管理,提高开发效率和质量。

方便程序的测试

​ 可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。

方便集成各种优秀框架

​ Spring可以降低各种框架的使用难度,提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持。

降低JavaEE API的使用难度

Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使这些API的使用难度大为降低

Java源码是经典学习范例

​ Spring的源代码设计精妙、结构清晰、匠心独用,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

1.1.3 spring的体系结构

2. IOC的概念和作用

2.1 程序间的耦合

2.1.1 什么是程序的耦合

​ 耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立性)。耦合性存在于各个领域,而非软件设计中独有的,但是我们只讨论软件工程中的耦合。

​ 软件工程中,耦合指的就是就是对象之间的依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

​ 它有如下分类:

​ (1) 内容耦合。当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另一个模块时,这样的耦合被称为内容耦合。内容耦合是最高程度的耦合,应该避免使用之。

​ (2) 公共耦合。两个或两个以上的模块共同引用一个全局数据项,这种耦合被称为公共耦合。在具有大量公共耦合的结构中,确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

​ (3) 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传递该全局变量的信息,则称之为外部耦合。

​ (4) 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动作,这种耦合被称为控制耦合。

​ (5) 标记耦合 。若一个模块A通过接口向两个模块B和C传递一个公共参数,那么称模块B和C之间存在一个标记耦合。

​ (6) 数据耦合。模块之间通过参数来传递数据,那么被称为数据耦合。数据耦合是最低的一种耦合形式,系统中一般都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另一些模块的输入数据。

​ (7) 非直接耦合 。两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实现的。

​ 总结:

​ 耦合是影响软件复杂程度和设计质量的一个重要因素,在设计上我们应采用以下原则:如果模块间必须存在耦合,就尽量使用数据耦合,少用控制耦合,限制公共耦合的范围,尽量避免使用内容耦合。

​ 内聚与耦合

​ 内聚标志一个模块内各个元素彼此结合的紧密程度,它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系,一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量,耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合,高内聚。就是同一个模块内的各个元素之间要高度紧密,但是各个模块之间的相互依存度却要不那么紧密。

​ 内聚和耦合是密切相关的,同其他模块存在高耦合的模块意味着低内聚,而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时,应力争做到高内聚,低耦合。

我们在开发中,有些依赖关系是必须的,有些依赖关系可以通过优化代码来解除的。

请看下面的示例代码:

    /**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl implements IAccountService {
        private IAccountDao accountDao = new AccountDaoImpl();
    }

上面的代码表示:

​ 业务层调用持久层,并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类,编译将不能通过。这种编译期依赖关系,应该在我们开发中杜绝。我们需要优化代码解决。

再比如:

​ 早期我们的JDBC操作,注册驱动时,我们为什么不使用DriverManager的register方法,而是采用Class.forName的方式?

public static void main(String[] args) throws Exception { 
    //1.注册驱动 
    //DriverManager.registerDriver(new com.mysql.jdbc.Driver());         Class.forName("com.mysql.jdbc.Driver"); 
    //2.获取连接 
    //3.获取预处理sql语句对象 
    //4.获取结果集 
    //5.遍历结果集 }

原因就是:

​ 我们的类依赖了数据库的具体驱动类(MySQL),如果这时候更换了数据库品牌(比如Oracle),需要修改源码来重新数据库驱动。这显然不是我们想要的。

2.1.2 解决程序耦合的思路

​ 当是我们讲解jdbc时,是通过反射来注册驱动的,代码如下:

​ Class.forName("com.mysql.jdbc.Driver"); //此处只是一个字符串

​ 此时的好处是,我们的类中不再依赖具体的驱动类,此时就算删除mysql的驱动jar包,依然可以编译(运行就不要想了,没有驱动不可能运行成功的)

​ 同时,也产生了一个新的问题,mysql驱动的全限定类名字符串是在java类中写死的,一旦要改还是要修改源码。

​ 解决这个问题也很简单,使用配置文件配置。

2.1.3 工厂模式解耦

​ 在实际开发中我们可以把三层的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来并存起来。在接下来的使用的时候,直接拿过来用就好了。

​ 那么,这个读取配置文件,创建和获取三层对象的类就是工厂。

2.1.4 控制反转-Inversion Of Control

1、存哪去?

​ 分析:由于我们是很多对象,肯定要找个集合来存。这时候有Map和List供选择。 到底选Map还是List就看我们有没有查找需求。有查找需求,选Map。

所以我们的答案就是

​ 在应用加载时,创建一个Map,用于存放三层对象。

​ 我们把这个map称之为容器。

2、还是没解释什么是工厂?

​ 工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。

​ 原来:

​ 我们在获取对象时,都是采用new的方式。是主动的。

现在:

​ 我们获取对象时,同时跟工厂要,有工厂为我们查找或者创建对象。是被动的。

这种被动接收的方式获取对象的思想就是控制反转,它是spring框架的核心之一。

明确ioc的作用:

削减计算机程序的耦合(解除我们代码中的依赖关系)

3.使用spring的IOC解决程序耦合

3.1 案例的前期准备[会用]

​ 使用的案例是,账户的业务层和持久层的依赖关系解决。在开始spring的配置之前,要先准备一下环境。由于我们是使用spring解决依赖关系,并不是真正的要做增删改查操作,所以此时我们没必要写实体类。并且我们在此处使用的是java工程,不是java web工程。

3.1.1 准备spring的开发包

官网:http://spring.io/

下载地址:http://repo.springsource.org/libs-release-local/org/springframework/spring

解压:(Spring目录结构:)

  • docs :API和开发规范.
  • libs :jar包和源码.
  • schema :约束.

使用的版本是spring5.0.2。

特别说明: spring5版本是用jdk8编写的,所以要求我们的jdk版本是8及以上。

同时tomcat的版本要求8.5及以上。

3.1.2 创建业务层接口和实现类

/** * 账户的业务层接口 */
public interface IAccountService {
    /** * 保存账户(此处只是模拟,并不是真的要保存) */ 
    void saveAccount();
}


/** * 账户的业务层实现类*/ 
public class AccountServiceImpl implements IAccountService { 
    private IAccountDao accountDao = new AccountDaoImpl();//此处的依赖关系有待解决 
    @Override 
    public void saveAccount() { 
        accountDao.saveAccount();                         
    } 
}

3.1.3 创建持久层接口和实现类

/** * 账户的持久层接口  */ 
public interface IAccountDao { 
    /** * 保存账户 */ 
    void saveAccount(); 
} 


/** * 账户的持久层实现类  */ 
public class AccountDaoImpl implements IAccountDao { 
    @Override 
    public void saveAccount() { 
        System.out.println("保存了账户"); 
    } 
}

3.2 基于XML的配置(入门案例)[掌握]

3.2.1 第一步:拷贝必备的jar包到工程的lib目录中

3.2.2 第二步:在类的根路径下创建一个任意名称的xml文件(不能是中文)

给配置文件导入约束:

/spring-framework-5.0.2.RELEASE/docs/spring-framework-reference/html5/core.html

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

3.2.3 第三步:让spring管理资源,在配置文件中配置service和dao

<?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的管理细节
        1.创建bean的三种方式
        2.bean对象的作用范围
        3.bean对象的生命周期
    -->

    <!--创建Bean的三种方式 -->
    <!-- 第一种方式:使用默认构造函数创建。
            在spring的配置文件中使用bean标签,配以id和class属性之后,且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数,则对象无法创建。

    <bean id="accountService" class="AccountServiceImpl"></bean>
    -->

    <!-- 第二种方式: 使用普通工厂中的方法创建对象(使用某个类中的方法创建对象,并存入spring容器)
    <bean id="instanceFactory" class="com..factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    -->

    <!-- 第三种方式:使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象,并存入spring容器)
    <bean id="accountService" class="com..factory.StaticFactory" factory-method="getAccountService"></bean>
    -->

    <!-- bean的作用范围调整
        bean标签的scope属性:
            作用:用于指定bean的作用范围
            取值: 常用的就是单例的和多例的
                singleton:单例的(默认值)
                prototype:多例的
                request:作用于web应用的请求范围
                session:作用于web应用的会话范围
                global-session:作用于集群环境的会话范围(全局会话范围),当不是集群环境时,它就是session
    -->

    <!-- bean对象的生命周期
            单例对象
                出生:当容器创建时对象出生
                活着:只要容器还在,对象一直活着
                死亡:容器销毁,对象消亡
                总结:单例对象的生命周期和容器相同
            多例对象
                出生:当我们使用对象时spring框架为我们创建
                活着:对象只要是在使用过程中就一直活着。
                死亡:当对象长时间不用,且没有别的对象引用时,由Java的垃圾回收器回收
     -->

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="cn.msy.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="cn.msy.dao.impl.AccountDaoImpl"></bean>
</beans>

3.2.4 测试配置是否成功

/** * 模拟一个表现层  */
public class Client {
    /** * 使用main方法获取容器测试执行*/
    public static void main(String[] args) { 
        //1.使用ApplicationContext接口,就是在获取spring容器 
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); 
        //2.根据bean的id获取对象 
        IAccountService aService = (IAccountService) ac.getBean("accountService"); 
        System.out.println(aService); 
        IAccountDao aDao = (IAccountDao) ac.getBean("accountDao"); 
        System.out.println(aDao); 
    } 
}

3.3 Spring基于XML的IOC细节[掌握]

3.3.1 spring中工厂的类结构图

3.3.1.1 BeanFactory 和ApplicationContext 的区别

BeanFactory 才是Spring 容器中的顶层接口。

ApplicationContext 是它的子接口。

BeanFactory 和ApplicationContext 的区别:

​ 创建对象的时间点不一样。

​ ApplicationContext:只要一读取配置文件,默认情况下就会创建对象。

​ BeanFactory:什么使用什么时候创建对象。

3.3.1.2 ApplicationContext 接口的实现类

ClassPathXmlApplicationContext:

​ 它是从类的根路径下加载配置文件 推荐使用这种

FileSystemXmlApplicationContext:

​ 它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext:

​ 当我们使用注解配置容器对象时,需要使用此类来创建spring 容器。它用来读取注解。

3.3.2 IOC中bean标签和管理对象细节

3.3.2.1 bean标签

作用:

​ 用于配置对象让spring来创建的。

​ 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性:

​ id:给对象在容器中提供一个唯一标识。用于获取对象。

​ class:指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

​ scope:指定对象的作用范围。

  • singleton :默认值,单例的. *
  • prototype :多例的. *
  • request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中. *
  • session :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中. *
  • global session :WEB项目中,应用在Portlet环境.如果没有Portlet环境那么globalSession相当于session.

init-method:指定类中的初始化方法名称。

destroy-method:指定类中销毁方法名称。

3.3.2.2 bean的作用范围和生命周期

<!-- bean对象的生命周期
        单例对象 scope="singleton"
        一个应用只有一个对象的实例。它的作用范围就是整个引用。
            出生:当容器创建时对象出生
            活着:只要容器还在,对象一直活着
            死亡:容器销毁,对象消亡
            总结:单例对象的生命周期和容器相同
        多例对象 scope="prototype"
        每次访问对象时,都会重新创建对象实例。
            出生:当我们使用对象时spring框架为我们创建
            活着:对象只要是在使用过程中就一直活着。
            死亡:当对象长时间不用,且没有别的对象引用时,由Java的垃圾回收器回收
 -->

3.3.2.3 实例化Bean的三种方式

<!--创建Bean的三种方式 -->
    <!-- 第一种方式:使用默认构造函数创建。
            在spring的配置文件中使用bean标签,配以id和class属性之后,且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数,则对象无法创建。
<bean id="accountService" class="AccountServiceImpl"></bean>
-->

<!-- 第二种方式: 使用普通工厂中的方法创建对象(使用某个类中的方法创建对象,并存入spring容器)
<bean id="instanceFactory" class="com..factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
-->

<!-- 第三种方式:使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象,并存入spring容器)
<bean id="accountService" class="com..factory.StaticFactory" factory-method="getAccountService"></bean>
-->

3.3.3 spring的依赖注入

3.3.3.1 依赖注入的概念

​ 依赖注入:Dependency Injection。它是spring框架核心ioc的具体实现。

​ 我们的程序在编写时,通过控制反转,把对象的创建交给了spring,但是代码中不可能出现没有依赖的情况。ioc解耦只是降低他们的依赖关系,但不会消除。例如:我们的业务层仍会调用持久层的方法。

​ 那这种业务层和持久层的依赖关系,在使用spring之后,就让spring来维护了。

​ 简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取。

3.3.3.2 构造函数注入

package cn.msy.service.impl;
import cn.msy.service.IAccountService;
import java.util.Date;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    //如果是经常变化的数据,并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}
<?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中的依赖注入
        依赖注入:
            Dependency Injection
        IOC的作用:
            降低程序间的耦合(依赖关系)
        依赖关系的管理:
            以后都交给spring来维护
        在当前类需要用到其他类的对象,由spring为我们提供,我们只需要在配置文件中说明
        依赖关系的维护:
            就称之为依赖注入。
         依赖注入:
            能注入的数据:有三类
                基本类型和String
                其他bean类型(在配置文件中或者注解配置过的bean)
                复杂类型/集合类型
             注入的方式:有三种
                第一种:使用构造函数提供
                第二种:使用set方法提供
                第三种:使用注解提供
     -->


    <!--构造函数注入:
        使用的标签:constructor-arg
        标签出现的位置:bean标签的内部
        标签中的属性
            type:用于指定要注入的数据的数据类型,该数据类型也是构造函数中某个或某些参数的类型
            index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
            name:用于指定给构造函数中指定名称的参数赋值                                        常用的
            =============以上三个用于指定给构造函数中哪个参数赋值===============================
            value:用于提供基本类型和String类型的数据
            ref:用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

        优势:
            在获取bean对象时,注入数据是必须的操作,否则对象无法创建成功。
        弊端:
            改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供。
    -->
    <bean id="accountService" class="cn.msy.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

3.3.3.3 set方法注入

package cn.msy.service.impl;

import cn.msy.service.IAccountService;

import java.util.Date;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl2 implements IAccountService {

    //如果是经常变化的数据,并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

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

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

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }


}

    <!-- set方法注入                更常用的方式
        涉及的标签:property
        出现的位置:bean标签的内部
        标签的属性
            name:用于指定注入时所调用的set方法名称
            value:用于提供基本类型和String类型的数据
            ref:用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
        优势:
            创建对象时没有明确的限制,可以直接使用默认构造函数
        弊端:
            如果有某个成员必须有值,则获取对象是有可能set方法没有执行。
    -->
    <bean id="accountService2" class="cn.msy.service.impl.AccountServiceImpl2">
        <property name="name" value="TEST" ></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>

3.3.3.4 使用p名称空间注入数据(本质还是调用set方法)

此种方式是通过在xml中导入p名称空间,使用p:propertyName来注入数据,它的本质仍然是调用类中的set方法实现注入功能。

package cn.msy.service.impl;
import cn.msy.service.IAccountService;
import java.util.Date;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl2 implements IAccountService {

    //如果是经常变化的数据,并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

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

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

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }


}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="accountService" class="com..service.impl.AccountServiceImpl4" 
          p:name="test" p:age="21" p:birthday-ref="now"/> </beans>

3.3.3.5 注入集合属性

package cn.msy.service.impl;

import cn.msy.service.IAccountService;

import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.Map;

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void  saveAccount(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}
    <!-- 复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签:
            list array set
        用于个Map结构集合注入的标签:
            map  props
        结构相同,标签可以互换
    -->
    <bean id="accountService3" class="cn.msy.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

发表评论

email
web

全部评论 (暂无评论)

info 还没有任何评论,你来说两句呐!