Spring依赖注入多种类型数据的示例代码

目录
  • Student实体类
  • StudentsClass实体类
  • beans.xml
  • 测试

Student实体类

package entity;
import java.util.*;
/**
 * @author LeDao
 * @company
 * @create 2022-02-13 21:26
 */
public class Student {
    private int id;
    private String name;
    private StudentClass studentClass;
    private String[] books;
    private List<String> hobbies;
    private Map<String, String> cards;
    private Set<String> games;
    private String wife;
    private Properties info;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    public String getName() {
        return name;
    public void setName(String name) {
        this.name = name;
    public StudentClass getStudentClass() {
        return studentClass;
    public void setStudentClass(StudentClass studentClass) {
        this.studentClass = studentClass;
    public String[] getBooks() {
        return books;
    public void setBooks(String[] books) {
        this.books = books;
    public List<String> getHobbies() {
        return hobbies;
    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    public Map<String, String> getCards() {
        return cards;
    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    public Set<String> getGames() {
        return games;
    public void setGames(Set<String> games) {
        this.games = games;
    public String getWife() {
        return wife;
    public void setWife(String wife) {
        this.wife = wife;
    public Properties getInfo() {
        return info;
    public void setInfo(Properties info) {
        this.info = info;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", studentClass=" + studentClass +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", cards=" + cards +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
}

StudentsClass实体类

package entity;
/**
 * @author LeDao
 * @company
 * @create 2022-02-14 14:11
 */
public class StudentClass {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Class{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

beans.xml

下面展示的数据类型有:一般类型、对象、数组、List、Map、Set、空值、Properties

<?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="studentClass1" class="entity.StudentClass">
        <property name="id" value="1"/>
        <property name="name" value="软件工程3班"/>
    </bean>
    <bean id="user1" class="entity.Student">
        <!--一般类型-->
        <property name="id" value="1"/>
        <property name="name" value="tom"/>
        <!--对象-->
        <property name="studentClass" ref="studentClass1"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>Java编程思想</value>
                <value>MySQL必知必会</value>
                <value>平凡的世界</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbies">
            <list>
                <value>唱</value>
                <value>跳</value>
                <value>rap</value>
                <value>打篮球</value>
            </list>
        </property>
        <!--Map-->
        <property name="cards">
            <map>
                <entry key="身份证" value="123"/>
                <entry key="校园卡" value="321"/>
            </map>
        </property>
        <!--Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>DNF</value>
                <value>COC</value>
            </set>
        </property>
        <!--空值-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="userName">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>
</beans>

测试

import config.MyConfig;
import entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author LeDao
 * @company
 * @create 2022-02-12 15:56
 */
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("user1");
        System.out.println(student);
    }
}

到此这篇关于Spring依赖注入多种类型数据的文章就介绍到这了,更多相关Spring依赖注入内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • spring中IOC控制反转依赖注入和new对象的区别说明

    目录 IOC控制反转依赖注入和new对象的区别 new对象 依赖注入 spring的IOC容器比New对象究竟好在哪 IOC控制反转依赖注入和new对象的区别 spring默认是单例模式的,依赖注入其中操作的都是一个对象 new对象 单例中如果要做到注入的效果就是在类的头部进行实例化对象,这个时候该对象不管使用与否都贯穿该类的始终.该类对象不被回收,这个实例化对象也不会被回收,因为存在引用状态.如果要使用多例对象则最好使用new创建对象而不是依赖注入,即使依赖注入有多例模式也不推荐. 依赖注入:

  • Spring使用Setter完成依赖注入方式

    目录 对依赖注入的理解 使用Setter完成不同类型属性的注入 整体配置文件 Spring解决setter方式的循环依赖的原理 对依赖注入的理解 依赖:实体间的所有依赖由容器创建 注入:容器负责完成实体间依赖互相注入的任务 使用Setter完成不同类型属性的注入 实体类Student package indi.stitch.pojo; import java.util.*; public class Student { private String name; private Address a

  • 深入浅出讲解Spring框架中依赖注入与控制反转及应用

    目录 一. 概念: 1. 使用前: 2. 使用后: 二. 理解控制反转(Ioc): 三. IoC的应用方法 一. 概念: 依赖注入(Dependency Injection,DI)与控制反转(IoC)的含义相同,只不过是从两个角度描述的同一个概念.对于一个Spring初学者来说,这两种称呼都很难理解,我们通过简单的语言来描述这两个概念. 使用对比: 1. 使用前: 当某个Java对象(调用者)需要调用另一个Java对象(被调用者,就是被依赖对象)时,在传统模式下,调用者通常会采用"new被调用者

  • Spring 控制反转和依赖注入的具体使用

    目录 控制反转的类型 1.依赖查找 1.1依赖拉取 1.2上下文依赖查找 2.依赖注入 2.1构造函数注入 2.2setter函数注入 Spring中的控制反转 1.Bean和BeanFactory 2.设置Spring配置 2.1XML配置 2.2注解配置 2.3Java配置 3.setter注入 4.构造函数注入 控制反转的类型 控制反转(IOC)旨在提供一种更简单的机制,来设置组件的依赖项,并在整个生命周期管理这些依赖项.通常,控制反转可以分成两种子类型:依赖注入(DI)和依赖查找(DL)

  • 详谈spring boot中几种常见的依赖注入问题

    目录 @Autowired依赖注入问题–逻辑使用先于@Autowired注解处理 测试用例 BeanFactory.getBean问题–getBean调用先于BeanDefinition信息注册 在Configuration中使用@Autowired注解 spring 实例化Bean过程 @Bean内部使用配置类@Autowired注解引入依赖 InitializingBean#afterPropertiesSet内部使用依赖 总结 最近有空总结一下之前在使用spring boot时遇到过的几种

  • Spring依赖注入多种类型数据的示例代码

    目录 Student实体类 StudentsClass实体类 beans.xml 测试 Student实体类 package entity; import java.util.*; /** * @author LeDao * @company * @create 2022-02-13 21:26 */ public class Student { private int id; private String name; private StudentClass studentClass; pri

  • Spring 依赖注入实现示例

    [注]本文译自:https://springframework.guru/...   在本文中,我将向你展示如何在 Spring Framework 的依赖项注入中使用 Project Lombok 以获得最佳实践.   Spring 框架本身具有多种执行依赖项注入的方式.选项的灵活性是 Spring 框架的优势.但是,并非所有的依赖项注入选项都被视为最佳实践.有些实际上不太好. 依赖注入示例   我提供了一些设置示例,供我们查看必须使用的各种依赖项注入选项.   让我们以 Spring Ser

  • Spring依赖注入(DI)两种方式的示例详解

    目录 一.依赖注入方式 二.setter注入 引用类型 简单类型 三.构造器注入 引用类型 简单类型 参数适配(了解) 四.依赖注入方式选择 一.依赖注入方式 思考:向一个类中传递数据的方式有几种? 普通方法(set方法) 构造方法 思考:依赖注入描述了在容器中建立bean与bean之间依赖关系的过程,如果bean运行需要的是数字或字符串呢? 引用类型 简单类型(基本数据类型与String) 依赖注入方式: setter注入 简单类型 引用类型 构造器注入 简单类型 引用类型 二.setter注

  • Spring依赖注入和控制反转详情

    目录 控制反转 什么是依赖? 紧耦合对象 松散耦合对象 依赖注入 为什么我们需要 IoC 容器? 以下是上面的重要问题 控制容器反转(IoC 容器) Spring 依赖注入 总结 前言: 在我们开始做任何事情之前,让我们先了解一下什么是控制反转.学习依赖注入和控制反转的概念,然后借助代码示例了解 Spring 框架如何支持它们. 控制反转 在我们开始做任何事情之前,让我们先了解一下什么是控制反转. 控制反转是面向对象编程中使用的术语,通过该术语,对象或对象集的控制权被赋予框架或由框架提供的容器.

  • Spring依赖注入的三种方式实例详解

    Spring依赖注入(DI)的三种方式,分别为: 1. 接口注入 2. Setter方法注入 3. 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di; public interface Logic { pub

  • Spring依赖注入的三种方式小结

    Spring的主要特性包括IOC和DI,其中DI是IOC的基础.在以前的Spring使用过程中大部分都是使用XML配置文件显式配置spring组件,导致大量的XML配置文件以及冗余的XML配置代码.阅读<Spring in Action>后总结Spring的DI功能的三种主要装配方式以及混合装配方式 根据注解自动装配 Spring中有非常丰富的注解,通过这些注解可以方便地配置Spring容器,使得Spring容器可以自动识别相关Bean并做自动注入装配. 使用注解 @Component注解:标

  • 详解Spring依赖注入:@Autowired,@Resource和@Inject区别与实现原理

    一.spring依赖注入使用方式 @Autowired是spring框架提供的实现依赖注入的注解,主要支持在set方法,field,构造函数中完成bean注入,注入方式为通过类型查找bean,即byType的,如果存在多个同一类型的bean,则使用@Qualifier来指定注入哪个beanName的bean. 与JDK的@Resource的区别:@Resource是基于bean的名字,即beanName,来从spring的IOC容器查找bean注入的,而@Autowried是基于类型byType

  • spring依赖注入原理与用法实例分析

    本文实例讲述了spring依赖注入原理与用法.分享给大家供大家参考,具体如下: 一 点睛 控制反转和依赖注入在Spring环境下是等同的概念,控制反转是通过依赖注入实现的.所谓依赖注入指的是容器负责创建对象和维护对象间的依赖关系,而不是通过对象本身负责自己的创建和解决自己的依赖. 依赖注入的主要目的是为了解耦,体现一种组合的概念.如果你希望你的类具备某项功能的时候,是继承自一个具有次功能的父类好呢?还是组合另外一个具有此功能的类好呢?答案是不言而喻的,继承一个父类,子类和父类耦合了,组合另外一个

  • spring依赖注入知识点分享

    spring与IoC IoC:控制反转,将由代码操纵的对象控制权,交给第三方容器,反转给第三方容器.这种对象依赖的关系管理方式,称作 IoC.IoC是一个思想,概念.比较 著名的两种方式: DL(Dependency Lookup)依赖查找,典型的是JNDI.java名称与服务接口. DI(Dependency Injection)依赖注入.是目前最优秀的接耦合方式.典型应用spring. spring的DI 依赖注入,即:为属性赋值. xml实现 1)设值注入 底层调用属性的setter方法进

  • spring依赖注入深入理解

    IOC&&DI IOC(Inversion of Control)一般分为两种类型:依赖注入DI(Dependency Injection)和依赖查找(Dependency Lookup) org.springframework.beans.factory.BeanFactory是IOC容器的具体实现,是Spring IOC容器的核心接口 Spring IOC负责创建对象,管理对象,装配对象,配置对象,并且管理这些对象的整个生命周期. 优点:把应用的代码量降到最低.最小代价和最小侵入式是松

随机推荐