Spring 框架依赖注入

最新推荐文章于 2023-03-02 21:39:23 发布
最新推荐文章于 2023-03-02 21:39:23 发布
阅读量464 收藏 1
点赞数
分类专栏： Spring 框架 文章标签： spring 框架 bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoyue_new/article/details/52239360
版权

IOC：某一接口具体实现类的控制权从控制类中移除，转交给第三方（如Spring）

三种依赖注入的方式

  1. 属性注入，通过setter方法注入bean的属性值或依赖的对象
  2. 构造注入
  3. 工厂方法注入（很少使用）

例子

这里我们使用了spring-4.3.2，maven配置文件

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${org.springframework-version}</version>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
<!-- Junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
</dependency>

一. 属性注入和构造方法注入

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

    <!-- 
        配置bean
        id：标识容器中bean对象
        class：bean的全类名，通过反射的方式在IOC容器中创建Bean，所以要求Bean类必须有无参构造器
     -->
    <bean id="helloWorld" class="com.spring.test.HelloWorld">
        <property name="name" value="crystal"></property>
    </bean>

    <!-- 通过构造方法配置bean,可以指定参数的位置和类型，以区分重载的构造函数 -->
    <bean id="car" class="com.spring.test.Car">
        <constructor-arg value="BENCHI" index="0"></constructor-arg>
        <constructor-arg value="200000.0" index="1" type="double"></constructor-arg>
    </bean>
    <bean id="car1" class="com.spring.test.Car">
        <!-- 如果字面值包含特殊字符，使用<![CDATA[]]>包裹起来
            属性值可以使用value子节点来配置
         -->
        <constructor-arg type="java.lang.String">
            <value><![CDATA[<shanghai>]]></value>
        </constructor-arg>
        <constructor-arg value="200" index="1" type="int"></constructor-arg>
    </bean>

    <bean id="person" class="com.spring.test.Person">
        <property name="name" value="Crystal"></property>
        <property name="age" value="20"></property>
        <!-- 可以使用ref建立引用之间的关系 -->
        <!-- 
        <property name="car" ref="car"></property>
         -->
        <!-- 
            <property name="car">
                <ref bean="car2"/>
            </property>
         -->
         <!-- 
         <property name="car">
            <bean class="com.spring.test.Car">
                <constructor-arg value="changanFute"></constructor-arg>
                <constructor-arg value="3000000"></constructor-arg>
                <constructor-arg value="240"></constructor-arg>
            </bean>
         </property> 
         -->
         <!-- 测试赋值null -->
         <!-- <property name="car"><null/></property> -->
         <property name="car" ref="car1"></property>
         <!-- 为级联属性赋值，注意：属性需要先初始化后才能为级联属性赋值，和structs2不同 -->
         <property name="car.price" value="400000"></property>
    </bean>

    <!-- 测试配置集合属性 -->
    <bean id="person3" class="com.spring.test.collections.Person">
        <property name="name" value="barry"></property>
        <property name="age" value="21"></property>
        <property name="cars">
            <list>
                <ref bean="car"/>
                <ref bean="car1"/>
                <bean class="com.spring.test.Car">
                    <constructor-arg value="changanFute"></constructor-arg>
                    <constructor-arg value="3000000"></constructor-arg>
                    <constructor-arg value="240"></constructor-arg>
                </bean>
            </list>
        </property>
    </bean>

    <!-- 配置Map的属性值 -->
    <bean id="newPerson" class="com.spring.test.collections.NewPerson">
        <property name="name" value="lina"></property>
        <property name="age" value="22"></property>
        <property name="cars">
            <!-- 使用map节点及map的entry子节点配置Map类型的成员变量 -->
            <map>
                <entry key="AA" value-ref="car"></entry>
                <entry key="BB" value-ref="car1"></entry>
            </map>
        </property>
    </bean>


    <!-- 配置Properties属性值 -->
    <bean id="dataSource" class="com.spring.test.collections.DataSource">
        <property name="properties">
            <!-- 使用props和prop子节点来为Properties属性赋值 -->
            <props>
                <prop key="user">root</prop>
                <prop key="password">1234</prop>
                <prop key="jdbcUrl">jdbc:mysql://test</prop>
                <prop key="jdbcDriver">com.mysql.jdbc.Driver</prop>
            </props>
        </property>
    </bean>

    <!-- 配置单例的集合bean，以供多个bean进行引用，需要导入util命名空间 -->
    <util:list id="cars">
        <ref bean="car"/>
        <ref bean="car1"/>
    </util:list>

    <bean id="person4" class="com.spring.test.collections.Person">
        <property name="name" value="Jackie"></property>
        <property name="age" value="30"></property>
        <property name="cars" ref="cars"></property>
    </bean>

    <!-- 通过p命名空间为bean的属性赋值，需要先导入p命名空间，相对于传统配置方式更为简洁 -->
    <bean id="person5" class="com.spring.test.collections.Person" p:name="Queue" p:age="32" p:cars-ref="cars"></bean>
</beans>

1. 下面是简单的属性注入、构造注入的测试类

Car.java

package com.spring.test;

public class Car {
    private String name;
    private int maxSpeed;
    private double price;

    public Car() {
    }

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Car(String name, int maxSpeed) {
        this.name = name;
        this.maxSpeed = maxSpeed;
    }

    public Car(String name, double price, int maxSpeed) {
        this.name = name;
        this.price = price;
        this.maxSpeed = maxSpeed;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [name:" + name + ", price:" + price + ", maxSpeed:" + maxSpeed + "]";
    }
}

HelloWorld.java

package com.spring.test;

public class HelloWorld {

    private String name;

    public HelloWorld() {
        System.out.println("HelloWorld constructor...");
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("setName:" + name);
        this.name = name;
    }

    @Override
    public String toString() {
        return "hello," + name;
    }
}

Person.java

package com.spring.test;

public class Person {

    private String name;
    private int age;
    private Car car;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person: [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
}

Main.java

package com.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();
        hello.setName("barry");
        System.out.println("print:"+ hello + "\n");

        // 装入 Spring 配置文件
        /**
         * 装入 Spring 配置文件
         * ApplicationContext是IOC容器，它有两个主要实现类（ClassPathXmlApplicationContext和FileSystemXmlApplicationContext）
         * ApplicationContext在初始化上下文时就实例化所有单例的Bean
         */
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //HelloWorld hello1 = (HelloWorld) context.getBean("helloWorld");   // 通过id获取bean对象
        HelloWorld hello1 = context.getBean(HelloWorld.class);  // 通过类型获取bean对象（要求在IOC容器里该类型的对象只能有一个）
        System.out.println(hello1);
    }

    @Test
    public void testContructor() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Car car = (Car) context.getBean("car"); // 通过类型获取bean对象（要求在IOC容器里该类型的对象只能有一个）
        Car car1 = (Car) context.getBean("car1");
        System.out.println(car);
        System.out.println(car1);

        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }
}

2. 下面是集合的测试类
NewPerson.java

package com.spring.test.collections;

import java.util.Map;

import com.spring.test.Car;

public class NewPerson {

    private String name;
    private int age;
    private Map<String, Car> cars;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Map<String, Car> getCars() {
        return cars;
    }
    public void setCars(Map<String, Car> cars) {
        this.cars = cars;
    }

    @Override
    public String toString() {
        return "Person: [name=" + name + ", age=" + age + ", cars=" + cars + "]";
    }
}

Person.java

package com.spring.test.collections;

import java.util.List;

import com.spring.test.Car;

public class Person {

    private String name;
    private int age;
    private List<Car> cars;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public List<Car> getCars() {
        return cars;
    }
    public void setCars(List<Car> cars) {
        this.cars = cars;
    }

    @Override
    public String toString() {
        return "Person: [name=" + name + ", age=" + age + ", cars=" + cars + "]";
    }
}

DataSource.java

package com.spring.test.collections;

import java.util.Properties;

public class DataSource {

    private Properties properties;

    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "DataSource: [properties:" + properties + "]";
    }
}

Main.java

package com.spring.test.collections;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    @Test
    public void testCollections() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person3");
        System.out.println(person);

        NewPerson newPerson = (NewPerson) context.getBean("newPerson");
        System.out.println(newPerson);

        DataSource dataSource = (DataSource) context.getBean("dataSource");
        System.out.println(dataSource);

        Person person4 = (Person) context.getBean("person4");
        System.out.println(person4);

        Person person5 = (Person) context.getBean("person5");
        System.out.println(person5);
    }
}

二. 下面静态工厂方法和实例工厂方法注入的实例

beans-factory.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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 
        通过静态工厂方法来配置bean，注意不是配置静态工厂方法实例，而是配置bean实例 
        class：指向静态方法的全类名
        factory-method：指向静态工厂方法名
        constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数
    -->
    <bean id="car" class="com.spring.test.factory.StaticBeanFactory" factory-method="getCar">
        <constructor-arg value="audi"></constructor-arg>
    </bean>

    <!-- 
        通过实例工厂方法来配置bean 
        factory-method：指向工厂方法名
        factory-bean：指向拥有该工厂方法的bean
        constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数
    -->
    <bean id="factory" class="com.spring.test.factory.InstanceCarFactory"></bean>
    <bean id="car1" class="com.spring.test.factory.Car" factory-bean="factory" factory-method="getCar">
        <constructor-arg value="ford"></constructor-arg>
    </bean>
</beans>

Car.java

package com.spring.test.factory;

public class Car {
    private String brand;
    private double price;

    public Car(String brand, double price) {
        super();
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [brand=" + brand + ", price=" + price + "]";
    }
}

StaticBeanFactory.java

package com.spring.test.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 静态工厂方法：直接调用某一个类的静态方法就可以获取 Bean 实例
 * @author cye
 *
 */
public class StaticBeanFactory {

    private static Map<String, Car> cars = new HashMap<String, Car>();
    static {
        cars.put("audi", new Car("audi", 200000));
        cars.put("ford", new Car("ford", 300000));
    }

    public static Car getCar(String brand) {
        return cars.get(brand);
    }
}

InstanceCarFactory.java

package com.spring.test.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 实例工厂方法：将对象的创建过程封装到另一个对象实例的方法里，当客户端需要请求对象时，只需要简单调用实例方法而不需要关心对象具体的创建细节，
 * @author cye
 *
 */
public class InstanceCarFactory {

    private Map<String, Car> cars;

    public InstanceCarFactory() {
        cars = new HashMap<String, Car>();
        cars.put("audi", new Car("audi", 200000));
        cars.put("ford", new Car("ford", 300000));
    }

    public Car getCar(String brand) {
        return cars.get(brand);
    }
}

Main.java

package com.spring.test.factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
        Car car = (Car) ctx.getBean("car");
        System.out.println(car);

        car = (Car) ctx.getBean("car1");
        System.out.println(car);
    }
}
caoyue_new
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring依赖注入
m0_62356365的博客
04-21 3226
一、什么是依赖注入 DI (Dependency Injection)：依赖注入是指在 Spring IOC 容器创建对象的过程中，将所依赖的对象通过配置进行注入。我们可以通过依赖注入的方式来降低对象间的耦合度。 在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高，维护成本越高，因此对象的设计应使对象之间的耦合越小越好。 1 类的关系 继承、实现、依赖、关联、聚合、组合。 2 关系强度 继承 = 实现 > 组合 > 聚合 > 关联 > 依赖 二、为什
Spring框架依赖注入
m0_58984702的博客
12-09 302
1.什么是spring框架? Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。 2.sprin
Spring依赖注入的三种方式
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
12-01 6763
还是与属性注入的解释是一样的,原因就是JDK是我们最底层的框架,Spring作为上层,要基于JDK/Java的,所以要满足Java的规范,java规定,被final修饰的属性1.在定义的时候进行赋值2.在构造方法内部进行赋值。原因还是一样的,因为满足Java的规范,被final修饰的属性 一个是定义的时候就进行赋值,一个是在构造方法内部进行赋值.满足第二条,所以可以注入final修饰的属性.将Bean对象更加简单地从Spring中取出来,有三种方式,分别为 属性注入, setter注入,构造方法注入。
Spring 依赖注入详解
swadian2008的博客
10-25 4702
/ 依赖关系，指的就是对象之间的相互协作关系依赖注入（DI）是一个过程，在这个过程中，对象仅通过构造函数参数、工厂方法的参数或在对象被实例化后通过属性设置来定义它们的依赖项（即与该对象一起工作的其他对象）。然后，容器在创建 bean 时注入这些依赖项。这个过程基本上是与对象直接通过构造类或等机制来控制其依赖项的实例化或位置是相反的，因此得名控制反转。// 对象不直接创建自己，而是通过 Spring 容器创建，那么 Spring 容器是如何创建对象的？
Spring 的依赖注入
南淮北安的博客
05-14 6191
文章目录一、依赖注入的概念二、构造函数注入三、set 方法注入（更常用的方式）四、注入集合属性 一、依赖注入的概念 依赖注入： Dependency Injection，它是 spring 框架核心 IOC 的具体实现，具体点就是依赖关系的维护称之为依赖注入 我们的程序在编写时， 通过控制反转， 把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 IOC 解耦只是降低他们的依赖关系，但不会消除。 例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系， 在使用 spri
详解Spring框架的依赖注入
smilejiasmile的博客
03-02 709
本篇主要介绍Spring的依赖注入。依赖注入是Spring协调不同Bean实例之间的合作而提供的一种工作机制，在确保Bean实例之间合作的同时，并能保持每个Bean的相对独立性。通过本篇的学习，可以达成如下目标。 ● 理解基于构造函数的依赖注入 ● 理解基于设置函数的依赖注入 ● 基于自动装配的依赖注入 ● 基于注解的依赖注入 在Spring框架下，当Bean实例 A运行过程中需要引用另...
Spring框架资源注入
我是猿小白的博客
04-25 839
一、DI是什么  DI是Dependency Injection，即依赖注入，DI实际上和IOC是一回事，只是观察的角度不同而已。  bean对象的创建依赖于容器，bean对象的创建依赖于资源(常量、对象、数组......)什么是注入？  注入：创建对象时所需要的资源由容器进行配置和注入，注入的过程也称为装配。二、注入的资源可以有哪些？    注入的资源可以是常量、对象、数组、集合等，下面就用ja...
Spring框架依赖注入方法示例
08-28
Spring框架依赖注入方法示例 Spring框架依赖注入是指在Spring框架中，容器负责实例化、配置和管理对象之间的依赖关系的过程。依赖注入是Spring框架的核心机制之一，通过依赖注入，Spring框架可以将对象之间的耦合度...
深入解析Java的Spring框架中bean的依赖注入
09-03
在Java的Spring框架中，依赖注入（Dependency Injection，简称DI）是一种设计模式，用于降低代码间的耦合度，提高软件的可测试性和可维护性。Spring框架提供了实现DI的主要机制，使得对象之间的依赖关系可以通过外部...
spring依赖注入知识点分享
08-25
Spring 依赖注入知识点分享 在本篇文章中，我们将详细介绍 Spring 依赖注入的知识点...Spring 依赖注入是 Spring 框架的核心机制之一，它提供了多种方式来管理对象之间的依赖关系，提高了应用程序的灵活性和可维护性。
java Spring DI依赖注入.rar
01-30
在Spring框架中，依赖注入有两种主要实现方式：构造器注入和setter注入。 1. 构造器注入：通过在类的构造器中传递依赖对象来初始化实例。这种方式强制所有依赖在对象创建时就已知，有利于确保对象的完整性和一致性...
Spring框架基础之依赖注入和标注
10-17
依赖注入和标注的基本概念，分类，使用方式，用来解决 组件值得 装配问题，组件扫描等
Spring简介-Spring的优势
Leon_Jinhai_Sun的博客
09-03 223
Spring的优势 1）方便解耦，简化开发 通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度耦合。 用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。 2）AOP 编程的支持 通过 Spring的 AOP 功能，方便进行面向切面编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松实现。 3）声明式事务的支持 可以将我们从单调烦...
spring框架之依赖注入
weixin_44558721的博客
03-02 234
spring复习
最全的Spring依赖注入方式，你都会了吗
zwx900102的博客
03-20 3625
@Autowrite 和 @Resource 以及 @Qualifier 注解的区别
什么是依赖注入，相对于(Spring)框架
人生在世
05-14 568
简单来说，依赖情况如下：可以理解为有A和B类，在A类的improtentMethod（）方法中调用（使用）了B类的方法，可以称做A类依赖与B类。public class A { public void improtentMethod() { B b = new B(); //声明一个B的实例引用 b.usefuMethod(); } }如果需要使用B类
什么是Spring依赖注入
Charles Ren's Tech Blog
11-14 5676
参考文档 https://segmentfault.com/a/1190000018972356 什么是Spring的依赖注入？有什么好处 依赖注入：是指程序运行过程中，如果需要创建一个对象，无须再代码中new创建，而是依赖外部的注入。 spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对pojo之间依赖关系的管理 new对象：类的头部进行实例化对象和依赖注入一个效果，这个时候该对...
第二次请求时没有带上session的问题
蛾子
08-10 3362
最近在整理框架，登陆成功后用户信息没有保存，后面获取用户信息怎么也获取不到，最后发现是每次请求的sessionId都不同。
spring框架依赖注入的原理
最新发布
05-15
Spring框架的依赖注入（Dependency Injection，简称DI）原理是通过反射机制，将bean的依赖关系注入到bean中。具体来说，当Spring容器启动时，它会读取配置文件中的bean定义信息，并通过反射机制创建对应的bean实例。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值