Spring配置与依赖注入基础详解

目录
  • 1.Spring配置
    • 1.1.别名
    • 1.2.Bean的配置
    • 1.3.import
  • 2.依赖注入(DI)
    • 2.1.构造器注入
    • 2.2.Set 注入(重点)
    • 2.3.扩展的注入
    • 2.4.Bean的作用域

1.Spring配置

1.1.别名

别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名:在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>
12

1.2.Bean的配置

Bean的配置

  <!--bean就是java对象,由Spring创建和管理-->
<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
class是bean的全限定名=包名+类名
-->
<bean id="user" class="com.kuang.pojo.UserT" name="u1 u2,u3">
        <property name="name" value="西部开源"/>
    </bean>
    <!--    alias取别名-->
    <!--    <alias name="user" alias="ccccccccccccccccc"/>-->

1.3.import

import

团队的合作通过import来实现 .

    <import resource="beans2.xml"/>
    <import resource="beans.xml"/>
    <import resource="beans3.xml"/>

2.依赖注入(DI)

Dependency Injection

概念

  • 依赖注入(Dependency Injection,DI)。
  • 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
  • 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

2.1.构造器注入

构造器注入

我们在之前的案例已经讲过了

2.2.Set 注入(重点)

Set 注入 (重点)

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试pojo类 :

Address.java

public class Address {
    private String address;
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

Student.java

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbs;
    private Map<String,String> cad;
    private Set<String> games;
    private String wife;
    private Properties info;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public String[] getBooks() {
        return books;
    }
    public void setBooks(String[] books) {
        this.books = books;
    }
    public List<String> getHobbs() {
        return hobbs;
    }
    public void setHobbs(List<String> hobbs) {
        this.hobbs = hobbs;
    }
    public Map<String, String> getCad() {
        return cad;
    }
    public void setCad(Map<String, String> cad) {
        this.cad = cad;
    }
    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{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbs=" + hobbs +
                ", cad=" + cad +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

2.3.扩展的注入

1、常量注入

 <bean id="address" class="com.kaung.pojo.Address">
        <property name="address" value="西安"/>

测试:

public class MyTest {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}

2、Bean注入

注意点:这里的值是一个引用,ref

 <bean id="student" class="com.kaung.pojo.Student">
        <property name="name" value="秦疆"/>
        <property name="address" ref="address"/>
        <property name="books">
     </bean>

3、List注入

 <bean id="student" class="com.kaung.pojo.Student">
        <property name="name" value="秦疆"/>
        <property name="address" ref="address"/>
        <property name="hobbs">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
    </bean>

4、数组注入

 <property name="books">
            <array>
                <value>红楼梦</value>
                <value>三国演义</value>
                <value>西游记</value>
                <value>水浒传</value>
            </array>
        </property>

5、Map注入

 <property name="cad">
            <map>
                <entry key="身份证" value="111111111111111"/>
                <entry key="银行卡" value="2222222222222221"/>
            </map>
        </property>

6、set注入

<property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

7、Null注入

<property name="wife">
            <null></null>
        </property>

8、Properties注入

 <property name="info">
            <props>
                <prop key="学号">202001020114</prop>
                <prop key="姓名">小明</prop>
                <prop key="url">男</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

测试结果:

Student{name='...', address=Address{address='西安'}, books=[红楼梦, 三国演义, 西游记, 水浒传], hobbs=[听歌, 敲代码, 看电影], cad={身份证=111111111111111, 银行卡=2222222222222221}, games=[LOL, COC, BOB], wife='null', info={学号=*********, password=123456, url=男, 姓名=小明}}

9、p命名和c命名注入

p命名和c命名注入

User.java :【注意:这里没有有参构造器!】

public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public User() {
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1、P命名空间注入 : 需要在头文件中加入约束文件

导入约束 : xmlns:p="http://www.springframework.org/schema/p"
 <!--P(属性: properties)命名空间 , 直接注入属性-->
<bean id="user" class="com.kaung.pojo.User" p:name="狂神" p:age="18"/>

2、c 命名空间注入 : 需要在头文件中加入约束文件

导入约束 : xmlns:c="http://www.springframework.org/schema/c"
 <!--C(构造: Constructor)命名空间 , 使用构造器注入-->
<bean id="user2" class="com.kaung.pojo.User" c:age="19" c:name="狂神" scope="singleton"/>
</beans>

发现问题:爆红了,刚才我们没有写有参构造!

解决:把有参构造器加上,这里也能知道,c 就是所谓的构造器注入!

测试代码:

  @Test
    public void test2()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user);
        System.out.println(user.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user==user2);
    }

2.4.Bean的作用域

Bean的作用域

在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象 .

几种作用域中,request、session作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于web的Spring ApplicationContext环境。

Singleton(单例模式)

当一个bean的作用域为Singleton,那么Spring IoC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。Singleton是单例类型,就是在创建起容器时就同时自动创建了一个bean的对象,不管你是否使用,他都存在了,每次获取到的对象都是同一个对象。注意,Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton,可以这样配置:

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
1

测试:

  @Test
    public void test2()
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user);
        System.out.println(user.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user==user2);
    }
}

Prototype(原型模式)

当一个bean的作用域为Prototype,表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)时都会创建一个新的bean实例。Prototype是原型类型,它在我们创建容器的时候并没有实例化,而是当我们获取bean的时候才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。根据经验,对有状态的bean应该使用prototype作用域,而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype,可以这样配置:

  <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>    或者 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

当一个bean的作用域为Request,表示在一次HTTP请求中,一个bean定义对应一个实例;即每个HTTP请求都会有各自的bean实例,它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>
1

针对每次HTTP请求,Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例,且该loginAction bean实例仅在当前HTTP request内有效,因此可以根据需要放心的更改所建实例的内部状态,而其他请求中根据loginAction bean定义创建的实例,将不会看到这些特定于某个请求的状态变化。当处理请求结束,request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session,表示在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
1

针对某个HTTP Session,Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例,且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样,可以根据需要放心的更改所创建实例的内部状态,而别的HTTP Session中根据userPreferences创建的实例,将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候,在该HTTP Session作用域内的bean也会被废弃掉。

到此这篇关于Spring配置与依赖注入基础详解的文章就介绍到这了,更多相关Spring依赖注入内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

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

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

  • Spring入门基础之依赖注入

    目录 一.构造器注入 二.set注入 三.其他方式注入 (1)导入约束 (2)p命名注入 (3)c命名注入 一.构造器注入 在前几节已经做过了详细的说明讲解,我们先跳过 二.set注入 依赖注入 依赖: bean对象的创建以及管理都依赖于Spring IOC容器 注入: bean对象中的所有属性,都有容器进行注入 在前面我们已经见识过了 普通类型注入和 bean注入的方式,那么对于复杂类型List.数组类型.Map.Set属性等怎么进行注入呢? 我们先提供一个包含各种类型的实体类 Student

  • Spring依赖注入的几种方式分享梳理总结

    目录 环境 准备 设值注入 构造注入 总结 环境 Ubuntu 22.04 IntelliJ IDEA 2022.1.3 JDK 17.0.3 Spring 5.3.21 准备 创建Maven项目 test0706 . 修改 pom.xml 文件,添加依赖: ...... <!-- https://mvnrepository.com/artifact/junit/junit --> <dependency> <groupId>junit</groupId>

  • Spring的DI依赖注入详解

    目录 1.什么是DI依赖注入? 2.利用 set 方法给属性赋值 3.利用 构造函数 给属性赋值 总结: 1.什么是DI依赖注入? spring动态的向某个对象提供它所需要的其他对象.这一点是通过DI(Dependency Injection,依赖注入)来实现的.比如对象A需要操作数据库,以前我们总是要在A中自己编写代码来获得一个Connection对象,有了 spring我们就只需要告诉spring,A中需要一个Connection,至于这个Connection怎么构造,何时构造,A不需要知道

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

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

  • Spring入门配置和DL依赖注入实现图解

    1.Spring入门配置 1.1.起别名 给项目起别名 ! 1.2.import 导入其他xml 1.3.Bean的配置最重要的,又很多配置,我们先学一点 2.依赖注入(DL) 很重要 2.1.set注入 三种方式: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi

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

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

  • 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框架中依赖注入与控制反转及应用

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

  • Spring配置与依赖注入基础详解

    目录 1.Spring配置 1.1.别名 1.2.Bean的配置 1.3.import 2.依赖注入(DI) 2.1.构造器注入 2.2.Set 注入(重点) 2.3.扩展的注入 2.4.Bean的作用域 1.Spring配置 1.1.别名 别名 alias 设置别名 , 为bean设置别名 , 可以设置多个别名 <!--设置别名:在获取Bean的时候可以使用别名获取--> <alias name="userT" alias="userNew"/&

  • Spring quartz Job依赖注入使用详解

    Spring quartz Job依赖注入使用详解 一.问题描述: 使用Spring整合quartz实现动态任务时,想在job定时任务中使用某个service时,直接通过加注解@Component.@Autowired是不能注入的,获取的对象为Null.如下面的代码: @Component @PersistJobDataAfterExecution @DisallowConcurrentExecution public class TicketSalePriceLessThanLowestPri

  • Spring Bean常用依赖注入方式详解

    一般而言,Spring的依赖注入有三种:构造器注入.setter注入以及接口注入.本文主要讲构造器注入与setter注入. 1.构造器注入 为了让Spring完成构造器注入,我们需要去描述具体的类.构造方法并设置构造方法的对应参数. 代码如下: public class Role { private Long id; private String roleName; private String note; public Long getId() { return id; } public vo

  • Java spring的三种注入方式详解流程

    目录 设置Spring的作用域 自动注入 @Primary Qualifier @ComponentScan不同的配置对性能的影响 懒加载 三种注入方式 字段注入(IDEA 会提示不推荐) 字段注入的bean类外部不可见 循环依赖问题 构造器注入(官方推荐) set方法注入 设置Spring的作用域 或者使用枚举值设置 单例和多里使用场景 自动注入 @Primary 一个接口有多个实现被spring管理吗,在依赖注入式,spring会不知道注入哪个实现类就会抛出NoUniqueBeanDefin

  • Spring配置数据源流程与作用详解

    目录 一.数据源的作用 二.数据源手动创建 1.数据源的开发步骤 2.手动创建c3p0数据源 3.手动创建druid数据源 4.通过properties配置文件创建连接池 5.通过spring配置数据源 6.通过spring抽取jdbc配置文件 一.数据源的作用 数据源(连接池)是提高程序性能出现的 事先实例化数据源,初始化部分连接资源 使用连接资源时从数据源中获取 使用完毕后将连接资源归还给数据源 常见的数据源(连接池):DBCP.C3P0.BoneCP.Druid等 在JavaSE中的JDB

  • spring boot静态变量注入配置文件详解

    本文实例为大家分享了spring boot静态变量注入配置文件的具体代码,供大家参考,具体内容如下 spring 静态变量注入 spring 中不支持直接进行静态变量值的注入,我们看一下代码: @Component(value = "KafkaConfig") @ConfigurationProperties(prefix = "baseConfig") public class KafkaConfig { private static String logBrok

  • 200行Java代码如何实现依赖注入框架详解

    依赖注入介绍 先回顾下依赖注入的概念: 我们常提起的依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念.具体含义是:当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例.但在Spring里,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为

  • Spring bean 四种注入方式详解

    目录 一.Set方式注入 pojo层: 1.xml 文件 test测试 二.构造函数方式注入 pojo层 2.xml文件 test测试 三.注解注入 pojo层 3.xml文件 test测试 四.JavaConfig 方式注入 pojo层 JavaConfig 类 xml文件 扫描包 测试: 五.Service层注入详解 service serviceImpl xml配置文件 总结 一.Set方式注入 pojo层: /** * @Author: crush * @Date: 2021-06-17

  • Spring Bean三种注入方式详解

    在Spring容器中为一个bean配置依赖注入有三种方式: 使用属性的setter方法注入  这是最常用的方式: 使用构造器注入: 使用Filed注入(用于注解方式). Field注入是最常见的一种方式,可以采用 @Autowired 对Bean类的接口进行初始化,代码如下 @ContextConfiguration({"/META-INF/spring/amazing-base.xml"}) @RunWith(SpringJUnit4ClassRunner.class) public

  • JavaScript反射与依赖注入实例详解

    本文实例讲述了JavaScript反射与依赖注入.分享给大家供大家参考,具体如下: 对于javascript中的反射的理解,一直都是认为,利用数组对回调函数进行保存,之后在适当的时刻利用call或是apply 方法,对回调进行调用即可,一般如下操作: 首先定义两个方法: var service = function() { return { name: 'Service' }; } var router = function() { return { name: 'Router' }; } 我们

随机推荐