Spring依赖注入bean

最新推荐文章于 2024-08-13 15:26:53 发布
最新推荐文章于 2024-08-13 15:26:53 发布
阅读量799 收藏 3
点赞数
分类专栏： Spring系列 文章标签： spring bean 依赖注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ymaini/article/details/80721853
版权

Spring依赖注入bean

介绍

Spring是一个开源框架，目的是简化Java开发，具备两大核心特性： 依赖注入(dependency injection, DI)和切面编程(aspect-oriented programming，AOP)。

依赖注入

依赖注入使得对象之间的耦合性降低， 基于Java中的反射机制实现。

Spring对于bean的装配提供了3种主要的装配机制：

  • XML配置
  • Java代码配置
  • 自动发现和自动装配

3种机制可单独使用一种，也可配合使用。本文先介绍自动发现和自动装配实现bean注入。介绍之前先引入spring依赖，以gradle为例

// build.gradle文件
dependencies {
    compile('org.springframework:spring-context')
    compile('org.springframework:spring-core')
    compile('org.springframework:spring-test')
}

机制1-自动装配

构造bean

为实现bean的装配，我们先实现一个bean，与普通类不同之处在于，用到@Component注解。如下示例是字符串的全半角转换。

package com.notepad.spring;

import org.springframework.stereotype.Component;

/**
 * Description:  字符串处理函数
 * <p>
 * Create:       2018/6/17 18:55
 *
 * @author Yang Meng(eyangmeng@163.com)
 */

@Component
public class StringProcess {

    /**
     * 字符串的全角转半角
     *
     * @param content 字符串
     * @return 半角字符串
     */
    public String stringQ2B(String content) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < content.length(); i++) {
            int asciiCode = (int) content.charAt(i);
            if (asciiCode >= 65281 && asciiCode <= 65374) {
                asciiCode -= 65248;
            } else if (asciiCode == 12288) {
                asciiCode = 32;
            }
            stringBuilder.append((char) asciiCode);
        }
        return stringBuilder.toString();
    }

    /**
     * 字符串半角转全角
     *
     * @param content 字符串
     * @return 全角字符串
     */
    public String stringB2Q(String content) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < content.length(); i++) {
            int asciiCode = (int) content.charAt(i);
            if (asciiCode >= 33 && asciiCode <= 126) {
                asciiCode += 65248;
            } else if (asciiCode == 32) {
                asciiCode = 12288;
            }
            stringBuilder.append((char) asciiCode);
        }
        return stringBuilder.toString();
    }
}

Java 配置类

构造Java配置类， 利用自动发现进行bean的扫描， 用到注解 @Configuration和@ComponentScan。

package com.notepad.spring;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * Description:  Spring Config配置(Java8)
 * <p>
 * Create:       2018/6/17 18:39
 *
 * @author Yang Meng(eyangmeng@163.com)
 */

@Configuration
@ComponentScan(basePackages = "com.notepad")
public class SpringConfig {
}

bean装配验证

构造单测验证bean是否可以正常装配和使用。利用@RunWith和@ContextConfiguration来自动创建Spring上下文以及加载Java配置类，通过@Autowired注解实现bean的装配。

package com.notepad.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.junit.Assert.*;

/**
 * Description: Bean测试
 * <p>
 * Create:       2018/6/17 19:26
 *
 * @author Yang Meng(eyangmeng@163.com)
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = StringProcess.class)
public class StringProcessTest {

    @Autowired
    private StringProcess stringProcess;

    @Test
    public void stringQ2B() {
        String content = "２０１８年世界杯开幕了。";
        System.out.println(stringProcess.stringQ2B(content));
    }

    @Test
    public void stringB2Q() {
        String content = "2018年世界杯。";
        System.out.println(stringProcess.stringB2Q(content));
    }
}

Main方法使用

利用SpringJUnit4ClassRunner可以完成单测， 但是如何Main方法中要使用该bean还需要用到AnnotationConfigApplicationContext来加载Spring上下文，示例如下：

package com.notepad.spring;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


/**
 * Description:  Main方法中实用bean(Java8)
 * <p>
 * Create:       2018/6/17 23:14
 *
 * @author Yang Meng(eyangmeng@163.com)
 */
public class SpringMain {

    public static void main(String [] args) {
        StringProcess process = getStringProcess();
        if (process == null) {
            LOG.error("Can not create bean: StringProcess");
            return;
        }

        String content = "北京时间２３点整。";
        System.out.println(process.stringQ2B(content));
    }

    /**
     * 通过上下文加载获取bean
     *
     * @return StringProcess
     */
    private static StringProcess getStringProcess() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        return context.getBean(StringProcess.class);
    }

    private final static Logger LOG = LoggerFactory.getLogger(SpringMain.class);
}

机制2-Java代码配置

不同于自动装配和自动发现， 利用Java代码实现bean的注入， 构造方式于普通类的构造无差别。

构造bean

对于自己构造的类， 我们可以为对象添加@Component注解， 但是对于三方包我们无法修改。仍以字符串串的全半角转换类为例。

Java configure 类

利用Java代码实现bean的装配， 构造Java configure来整理需要用到的bean，用到注解 @Configuration和@Bean。

@Bean注解显示的构造bean。

package com.notepad.spring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Description:  Spring Config配置(Java8)
 * <p>
 * Create:       2018/6/17 18:39
 *
 * @author Yang Meng(eyangmeng@163.com)
 */

@Configuration
public class SpringConfig {

    @Bean
    public StringProcess getStringProcess() {
        return new StringProcess();
    }
}

bean装配验证和Main方法使用

测试和使用方式同自动装配相同。

机制3-XML配置

利用XML配置文件实现bean的注入，也是最常用的一种方式。

构造bean

仍以字符串串的全半角转换类为例。无@Component注解。

XML配置

利用 实现定义， id为bean的名称且唯一， class指定具体的类

<?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="stringProcess" class="com.notepad.spring.StringProcess"/>
</beans>

Main方法使用

不同于Java配置的方法，利用XML配置需用到ClassPathXmlApplicationContext从XML中加载上下文。

package com.notepad.spring;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Description:  Main方法中实用bean(Java8)
 * <p>
 * Create:       2018/6/17 23:14
 *
 * @author Yang Meng(eyangmeng@163.com)
 */
public class SpringMain {

    public static void main(String [] args) {
        StringProcess process = getStringProcess();
        if (process == null) {
            LOG.error("Can not create bean: StringProcess");
            return;
        }

        String content = "北京时间２３点整。";
        System.out.println(process.stringQ2B(content));
    }

    /**
     * 通过XML配置文件中加载上下文
     * @return StringProcess
     */
    private static StringProcess getStringProcess() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("answerbean-config.xml");
        return context.getBean(StringProcess.class);
    }

    private final static Logger LOG = LoggerFactory.getLogger(SpringMain.class);
}

总结

  1. @Component注解在普通类上声明bean
  2. @Configuration注解声明Java配置类， @ComponentScan实现自动扫描， @Bean注解声明具体bean实现细节
  3. @RunWith和@ContextConfiguration注解使用单测
  4. AnnotationConfigApplicationContext实现Main方法中加载利用Java配置类加载上下文
  5. ClassPathXmlApplicationContext实现XML加载上下文

后续问题

  1. Java配置类与XML配置相互配合
  2. Bean重名问题
  3. 类之外属性的注入
  4. 利用properties文件实现具体值注入等等

Github代码

https://github.com/yangbigmeng/notepad

参考

  1. Spring 实战(第四版) 第二章， 第三章

注： 本文介绍的均是Spring加载Bean的最基本的方法， bean的加载还设置多种类型， 如类的属性，方法，具体的值等，掌握bean注入的最好方法是根据参考文献了解。

回眸郎
关注
专栏目录
Spring依赖注入Bean的8种方式
m0_71777195的博客
05-30 699
并不是不注入，而是注入一个代理对象，可以理解为一个占位符，一个空壳子，先占着位置，等用到这个壳子的时候，这个壳子会去查找到真正的对象，调用真正对象的方法。同时虽然本文举例的是@Autowird注解和字段注入的方式，但上面提到的注入的Bean类型跟使用注解和注入方式没什么关系，@Resource注解，构造器注入，setter注入都是一样的。@Lazy的一个使用场景就是用来解决Spring无法处理的循环依赖场景，比如使用了@Async注解的循环依赖的场景，不了解的小伙伴可以看一下。
Spring bean 依赖注入
Attitude_one的博客
11-16 325
依赖注入 set方法 private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } bean配置文件 <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/> <bean id="userService" class="com.itheima.service..
spring依赖注入bean
07-19
这是在网上下载的例子，平时我们用的ioc都是在web中，本例实现在java application中实现依赖注入
Spring Bean 依赖注入
多凡的博客
07-22 570
依赖注入就是利用配置在Bean创建的时候，使用set方法给成员变量赋值，一般是给不经常变化的数据使用依赖注入 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/...
Spring注入bean的几种方式
最新发布
刘皇叔说Java的博客
08-13 962
可以在配置类中使用 @ComponentScan 注解来自动扫描指定包下的所有 @Component，@Service，@Repository，和 @Controller 注解的Bean。在上面的配置中，Spring会自动将名为 engine 的 Engine Bean 注入到 Car Bean 中的 engine 属性，因为它们的类型匹配。在Spring中，通过XML配置文件来注入Bean的方式主要包括以下几种：构造器注入、Setter注入、接口注入和集合注入。构造器注入是通过构造函数来注入依赖的。
Spring(二)-Spring Bean的依赖注入
蓝色的青春_巍
01-18 392
一、Spring Bean依赖注入 主要有两种常用的注入方式: Constructor-based dependency injection ：基于构造函数的依赖注入 Setter-based dependency injection ：基于设值函数的依赖注入 实列如下: ☐ set注入:(可以是字符,也可以是对象,还可以是list列表
Spring中bean的依赖注入解析
青春念邵的博客
06-29 423
开发中某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。这个过程是怎么实现的，下面就bean.xml文件中的做简要分析。         这个配置代表了一个bean，项目启动后它在spri
Spring Bean的依赖注入方式
weixin_43642556的博客
08-03 366
1. Bean的依赖注入概念 依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。 2. Bean的依赖注入方式 （1）s
面试官常问的spring依赖注入和bean的装配问题.pdf
04-26
在Spring的面试中，面试官常会问到关于依赖注入和Bean装配的问题。理解这些概念对于开发高质量的Spring应用程序至关重要。 首先，我们来讨论一下Spring中常见的依赖注入方式。 1. setter注入（Setter-based ...
Spring之Bean依赖注入
附子Jun的博客
10-31 96
学习目标： Spring之Bean依赖注入 学习内容： 实现依赖注入有两种方法： set方法 代码： package com.itheima.service.impl; import com.itheima.dao.UserDao; import com.itheima.service.UserService; public class UserServiceImpl implements UserService { private UserDao userDao; /* s
03spring-Bean的依赖注入
LCreator的博客
08-04 139
3.5 Bean的依赖注入入门 ①创建 UserService，UserService 内部在调用 UserDao的save() 方法 public class UserServiceImpl implements UserService { @Override public void save() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext
Bean的依赖注入
m0_71617641的博客
10-16 117
Bean的依赖注入方式
spring学习笔记2-Spring Bean依赖注入
weixin_43942512的博客
11-14 193
Spring Bean依赖注入 Spring框架的核心功能之一就是通过依赖注入的方式来管理Bean之间的依赖关系。 依赖注入 每个基于应用程序的 java 都有几个对象，这些对象一起工作来呈现出终端用户所看到的工作的应用程序。当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能独立于其他 Java 类来增加这些类重用的可能性，并且在做单元测试时，测试独立于其他类的独立性。依赖注入（或有时称...
依赖注入与Bean的装配
hasagei_ly的博客
09-29 1036
依赖注入有三种：setter注入；构造器注入；接口注入(基本不用)。其中setter注入应用最广泛。 即为Bean中的属性设置值（强行解释）   Bean的装配也有三种：XML中显示配置；在Java的接口和类中实现配置；隐式Bean的发现机制和自动装配原则 即声明这个Bean，并把它放在容器里（强行解释） （强行解释）在xml中代码如下： &lt;bean id="user" cla...
Spring - Spring配置文件-Bean依赖注入详解
qq_39123467的博客
04-05 1908
Spring配置文件-Bean依赖注入详解
Spring-Bean的依赖注入分析-01
Kevinnsm的博客
11-12 271
###我们先通过一个例子弄明白为什么要使用依赖注入### 1.创建业务层UserService接口及UserServiceImpl实现类（接口代码省略） public class UserServiceImpl implements UserService { @Override public void sava() { ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.
spring的依赖注入---Bean章
qq_41309583的博客
05-22 212
依赖注入 IOC的作用：降低程序的耦合性 依赖关系管理：交给spring管理 在当前对象中需要用到其他对象时 由spring提供 只需在配置文件中配置说明 依赖关系的维护： 能注入的数据有三类： 1）基本类型和String类 2）其他bean类型（在配置文件中或者注解配置过的bean） 3）复杂类型/集合类型 注入的方式有三种： 1）使用构造函数提供 2）使用set方法提供 3）使用注解提供 ...
深入理解Spring依赖注入
"本文主要介绍Spring框架中的依赖注入(Dependency Injection, DI)概念，以及如何通过XML配置实现DI的两种方式：设值注入和构造注入。" 在Spring框架中，依赖注入是核心特性之一，它有助于降低组件之间的耦合度，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值