Spring——创建对象、配置及依赖注入

已于 2022-10-23 22:39:59 修改
阅读量640 收藏
点赞数
分类专栏： Spring 文章标签： spring java xml
于 2021-11-06 11:35:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47770336/article/details/121176594
版权

文章目录

4.IOC创建对象的方式

  1. 使用无参构造创建对象，默认！

  2. 假设我们要使用有参构造创建对象

    1. 下标赋值

      <bean id="user" class="net.cqwu.pojo.User">
            <constructor-arg index="0" value="feliks"/>
        </bean>
      1. 类型赋值：不建议使用
          <bean id="user" class="net.cqwu.pojo.User">
        <constructor-arg type="java.lang.String" value="feliks2"/>
    </bean>
      1. 参数名
          <bean id="user" class="net.cqwu.pojo.User">
        <constructor-arg name="name" value="feliks3"/>
    </bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

User

public class User {
    private String name;

    //没有无参构造，报错
    public User(String name){
        this.name = name;
    }
//省略getter,setter
    public void show(){
        System.out.println("name:"+name);
    }
}

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">

<!--    1.下标赋值-->
<!--        <bean id="user" class="net.cqwu.pojo.User">-->
<!--            <constructor-arg index="0" value="feliks"/>-->
<!--        </bean>-->

<!--    2.类型赋值法：不建议使用-->
<!--    <bean id="user" class="net.cqwu.pojo.User">-->
<!--        <constructor-arg type="java.lang.String" value="feliks2"/>-->
<!--    </bean>-->

<!--3.直接通过参数名来创建-->
    <bean id="user" class="net.cqwu.pojo.User">
        <constructor-arg name="name" value="feliks3"/>
    </bean>

    <bean id="userT" class="net.cqwu.pojo.UserT"></bean>
</beans>

测试MyTest

import net.cqwu.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {

       //Spring容器，类似于婚介网站
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        User user = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");
        user.show();
        System.out.println(user == user2);
    }
}

5.Spring配置

别名

<!--    如果添加了别名，也可以使用别名获取这个对象-->
    <alias name="user" alias="bieming"/>

Bean的配置

<!--
    id: bean 的唯一标识符，相当于对象名
    class: bean 对象所对应的全限定名：包名 + 类名
    name: 别名
-->
    <bean id="userT" class="net.cqwu.pojo.UserT" name="user2">
        <property name="name" value="feliks"></property>
    </bean>

UserT user = (UserT) context.getBean("user2");
        user.show();

import

团队开发时，将多个配置文件导入合并为一个

<import resource="beans1.xml"></import>

DI依赖注入

构造器注入

<beans>
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg ref="beanTwo"/>
        <constructor-arg ref="beanThree"/>
    </bean>

    <bean id="beanTwo" class="x.y.ThingTwo"/>

    <bean id="beanThree" class="x.y.ThingThree"/>
</beans>

Set方式注入!!!

  • 依赖注入：set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性，由容器来注入

【环境搭建】

  1. 复杂类型
public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}
  1. 真实测试对象
public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> game;
    private String wife;//空指针
    private Properties info;
}
//get  set  toString省略
  1. 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 id="address" class="net.cqwu.pojo.Address">
        <property name="address" value="Chongqing"></property>
    </bean>
    <bean id="student" class="net.cqwu.pojo.Student">
    <!--第一种：普通值注入 -->
    <property name="name" value="feliks"></property>

    <!--第二种：Bean注入：ref-->
        <property name="address" ref="address"></property>

    <!--数组注入-->
        <property name="books">
            <array>
                <value>西游记</value>
                <value>红楼梦</value>
                <value>三国</value>
                <value>水浒</value>
            </array>
        </property>

        <!--List注入-->
        <property name="hobbys">
            <list>
                <value>魔方</value>
                <value>唱歌</value>
                <value>听歌</value>
            </list>
        </property>

        <!--Map-->
        <property name="card">
            <map>
                <entry key="身份证" value="11111111"/>
                <entry key="银行卡" value="22222222"/>
            </map>
        </property>

        <!--Set-->
        <property name="game">
            <set>
                <value>lol</value>
                <value>bob</value>
                <value>coc</value>
            </set>
        </property>

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

        <!--Properties-->
        <property name="info">
            <props>
                <prop key="学号">4029</prop>
                <prop key="姓名">feliks</prop>
                <prop key="专业">软件</prop>
                <prop key="username">admin</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>
</beans>
  1. MyTest
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}
/*
* Student{
name='feliks'
, address=Address{address='Chongqing'}
, books=[西游记, 红楼梦, 三国, 水浒]
, hobbys=[魔方, 唱歌, 听歌]
, card={身份证=11111111, 银行卡=22222222}
, game=[lol, bob, coc]
, wife='null'
, info={学号=4029, password=123456, 专业=软件, 姓名=feliks, username=admin}
}
* */

拓展方式注入

详细解释见官方文档中的

XML Shortcut with the p-namespace
XML Shortcut with the c-namespace

对象

public class User {
    private String name;
    private int age;


    //加上无参 和 有参构造器，才能使用c命名注入
    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}//省略getter setter toString

测试类

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

beans.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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

        <!--p命名空间注入，可以直接注入属性的值：property-->
        <bean id="user" class="net.cqwu.pojo.User" p:name="feliks" p:age="22"/>

        <!--c命名空间注入，通过构造器注入：constructs-args-->
        <bean id="user2" class="net.cqwu.pojo.User" c:age="21" c:name="Feliks"/>
</beans>

注意：p 和 c命名空间注入不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

Bean的作用域

官方文档：

ScopeDescription
singleton(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
prototypeScopes a single bean definition to any number of object instances.
requestScopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
sessionScopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
applicationScopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
websocketScopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.
  1. 单例模式（Spring默认机制）
<bean id="user2" class="net.cqwu.pojo.User" c:age="21" c:name="Feliks" scope="singleton"/>

测试

        User user = context.getBean("user2",User.class);
        User user2 = context.getBean("user2",User.class);
        System.out.println(user==user2);//true
  1. 原型模式：每次从容器中get的时候，都会产生一个新对象
<bean id="user2" class="net.cqwu.pojo.User" c:age="21" c:name="Feliks" scope="prototype"/>

测试

        User user = context.getBean("user2",User.class);
        User user2 = context.getBean("user2",User.class);
        System.out.println(user==user2);//false

request session application只能在web开发中使用到

Feliks.
关注
专栏目录
Spring进阶（三）之依赖注入详解
weixin_56644618的博客
09-27 330
1. 本文主要讲解了xml中bean的依赖注入，都是采用硬编码的方式进行注入的，这种算是手动的方 式2. 注入普通类型通过value属性或者value元素设置注入的值；注入对象如果是容器的其他bean的时 候，需要使用ref属性或者ref元素或者内置bean元素的方式3. 还介绍了其他几种类型List、Set、Map、数组、Properties类型的注入，多看几遍加深理解4. 后面我们将介绍spring为我们提供的更牛逼的自动注入。
关于Spring的依赖注入
security_linsho的博客
04-12 833
一 对象的依赖注入 通过set方法 （通过Bean注入，就是后面的ref） 需要注入的类中要有一个属性，这个属性就是被注入的类，还要创建该属性的set方法，因为我们是通过set方法进行注入的，所以进行如下的书写 然后在Spring 的核心配置文件中开始进行编写注入 需要注意的是 property标签中的name属性里面填的是set方法的名字，但是要去掉set并且首字母小写，虽然看似就是属性的名字，其实不是，如果你把set方法后面的名字进行修改了，这个name里面的值也应该修改，然后后面的r
Spring-创建对象和依赖注入
NULL_YM
02-12 1054
简介 前面我们会用BeanFactory工厂模式进行解耦，降低程序的耦合性。本次使用spring的进行解耦，它提高了我们的效率，还有很多其他的功能。 Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现...
Spring中Map类型依赖注入的使用
最新发布
ls188665的博客
07-18 479
为了详细解释这段代码的装配过程，并编写一份详细的开发文档，我们需要从几个方面进行阐述：Spring框架的依赖注入机制、@Resource注解的作用、类型作为依赖的特别性，以及这段代码在实际开发中的应用和注意事项。
浅谈spring5创建对象3种方式以及依赖注入
Y
07-25 298
一 背景介绍 spring 框架里面包含了很多流行的技术，如IOC，DI,SpringlMVC，官方文档地址（https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core），一开始听这些名词时云里雾里的，什么控制反转，什么依赖注入等等。随着代码的阅读和理解，也逐渐慢慢清晰了起来，扒开了重重迷雾，果然，时间才是最好的礼物。 1.1 IOC 控制反转 控制反转（Inversion of
Spring——依赖注入DI
Galip的博客
12-27 756
依赖注入（DI） 依赖注入（Dependency Injection,DI）。 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 . 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 . 构造器注入 我们在之前的案例4已经详细讲过了 settet注入 (重点) 要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属...
Spring学习（三）Spring配置bean对象
周帅傅
06-24 336
Spring学习（三）Spring配置bean对象 一、spring对象的获取及属性赋值方式 1、通过bean的id获取IOC容器中的对象 public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml"); //根据bean标签的id来获取对象
Spring核心知识点系列5--Spring配置文件之bean的依赖注入
牧羊少年的博客
08-23 434
setter方式和有参构造的依赖注入实现
初识Spring（一：spring配置，创建对象，注意事项）
刘刘刘刘刘牛皮的博客
09-16 253
Spring概念： spring在开发中的角色就是用来管理对象的创建和其他框架的，简单的来说，spring就是将已有的技术变得更加简便优秀。 spring遵循的是车轮理论，就是现有的技术就不在进行开发了，只需要拿来进行整合，变得更加完善就好。但是随着spring越做越好，也开始替代了一些其他的技术。 学习spring的主要三个内容： a)IoC/DI: 控制反转/依赖注入：IoC就是创...
Spring系列：聊聊Spring工厂对象创建与Spring的注入
llzz_zzll的博客
06-20 849
前言 本章主要对Spring工厂创建对象，以及Spring框架中的注入做一个#简单的说明。 1. Spring工厂创建对象原理讨论 1. 通过Spring工厂创建对象，重要有如下几步： # 第一步：创建一个Account实体类 # 第二步：到applicationContext.xml中配置Account # 第三步：测试-->创建工厂，读取applicationContext.xml配 置文件，并通过工厂对象中的方法getBean()获取Accout这个id属 性所对应的这个对象。 2. 对S
Spring_ 依赖注入 详细讲解
康康要加油的博客
03-10 800
文章目录一、什么是依赖注入？1、类的关系1.1、 依赖关系（Dependency）1.2、聚合（Aggregation）2、关系强度二、 为什么使用依赖注入？1、开闭原则1.1、定义1.2、 开闭原则优点2、高内聚，低耦合三、 依赖注入的方式1、通过 Set 方法注入1.1、 配置文件1.2、 Bean 对象2、通过构造方法注入2.1、 配置文件2.2、 Bean 对象3、自动注入3.1、 局部自动注入3.2、 全局自动注入四、 依赖注入的数据类型1、注入 Bean 对象2、注入基本数据类型和字符串 一、
Spring 创建对象和依赖注入
weixin_52907605的博客
05-21 359
1.创建对象 Spring创建对象有两种配置方式：xml配置文件和注解 1.1配置文件 package com.xianoupeng.bean; //员工类 public class Emp { private String name; private int age; private Dept dept; public Emp() { System.out.println("Emp 无参构造被调用"); } pub...
spring依赖注入 集合＜list＞与＜map＞属性的注入
weixin_44141172的博客
11-27 2191
spring中和属性的依赖注入list集合属性的依赖注入map集合属性的依赖注入 在spring中可以通过一组内置的xml标签来配置集合属性 list集合属性的依赖注入 创建Car类，有brand(品牌)，crop(厂商)，price(价格)三个属性 创建PersonList类，有name和Car(Object)两个属性 创建spring-di.xml配置文件，在配置文件中已经创建好了car car2 car3三个car对象 配置一个PersonList <bean id="personLis
Spring中的依赖注入（二）
VioletHan7的博客
01-06 227
目录 - Spring中基于注解的IOC以及IOC的案例 - 案例：使用xml方式和注解方式实现单表的CRUD操作 持久层技术选择：dbutils - 改造基于注解的IOC案例，使用纯注解的方式实现 spring的一些新注解的使用 - Spring和Juint的整合 1. 基于注解的IOC配置 1.1 明确 学习基于注解的IOC配置，注解配置和xml配置实现的功能是一样的，都是降低...
spring配置详解-三种对象创建方式_
Leon_Jinhai_Sun的博客
07-02 194
新建一个包,b_create,关于Spring创建对象的方式,咱们首先先介绍默认方式,我复制一个配置文件过来, 在这个包下创建一个配置文件,把这些注释可以删掉了,现在咱们看到的情况,是常见的情况,这种情况它是怎么 创建对象的呢,这是创建方式一,这个问题我留给你们,一会创建对象,怎么创建的,我问的不是那么深奥,是不是走 空参,空参构造创建的,不经历构造函数是不可能创建对象的,所以这种方式只有...
二、Spring配置之三种对象创建方式
panchang199266的博客
08-21 341
public class User { private String name; private Integer age; public String getName() { return name; } public void setName(String name) { this.name = name; } ...
【笔记】Spring基础配置及对象的基本获取
11-11 225
一、首先安装Spring Tool Suite 二、导入需要用到基本jar包  commons-logging-1.1.3.jar spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEASE.jar spring-core-4.0.0.RELEASE.jar             spring-expression-4.0....
spring的配置及依赖注入(详细）
七一
08-11 1296
1、spring的配置 1.1、起别名 alias设置别名，为bean设置别名，可以设置多个别名 <!--设置别名：在获取Bean的时候可以使用别名获取--> <alias name="user" alias="user2"/> 1.2、bean的配置 <!--注册一个javabean到spring容器中,这里name属性也可以设置多个别名，--> <bean id="user" class="com.lili.entity.User" name="user3
Spring IOC与依赖注入实战：创建与配置调用类
"这篇内容主要介绍了Spring框架中的核心特性——控制反转（IoC）和依赖注入（DI），以及如何在实际应用中创建调用类。文章通过实例展示了Spring配置文件的使用，包括定义接口和实现类，配置bean的原型作用域，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值