DI依赖注入和第三方bean管理以及核心容器

最新推荐文章于 2023-07-11 10:14:00 发布
最新推荐文章于 2023-07-11 10:14:00 发布
阅读量239 收藏 1
点赞数 1
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59564754/article/details/126922550
版权

文章目录

1.依赖注入方式

  • setter 注入方式

    • 简单类型
    • 引用类型

  • 构造器注入

    • 简单类型
    • 引用类型
1.1 setter 注入简单类型

在实现类中添加简单数据类型，并提供 setter 方法

public class BookDaoImpl implements BookDao {

    //注入简单类型
    private int num;

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public void save() {
        System.out.println("book dao save......"+num);
    }
}

配置文件中添加 bean

    <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
        <property name="num" value="10"/>
    </bean>

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookDao bookDao = (BookDao) context.getBean("bookDao");

        bookDao.save();
        //book dao save......10
    }
1.2 setter 注入引用数据类型

在实现类中添加引用数据类型，并提供 setter 方法

public class BookServiceImpl implements BookService {
    //注入引用类型
    private BookDao bookDao;

    @Override
    public void save() {
        System.out.println("book service save......");
        
        bookDao.save();
    }
    //提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

配置文件中添加 bean

    <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
        <property name="connectionNum" value="10"/>
    </bean>

    <bean id="bookService" class="com.my.service.impl.BookServiceImpl">
        //引用类型
        <property name="bookDao" ref="bookDao"/>
    </bean>

测试运行结果

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookService bookService = (BookService) context.getBean("bookService");

        bookService.save();
        //输出结果为： book service save......
        //book dao save......10
    }
1.3 构造器注入简单数据类型

在实现类中，添加构造方法

public class BookDaoImpl implements BookDao {

    private int num;

    public BookDaoImpl(int num) {
        this.num = num;
    }

    @Override
    public void save() {
        System.out.println("book dao save......"+num);
    }
}

配置文件中配置 bean

    <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
        <constructor-arg name="num" value="10"/>
    </bean>

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookDao bookDao = (BookDao) context.getBean("bookDao");

        bookDao.save();
        //输出结果为：book dao save......10
    }
}
1.4构造器注入引用类型

在实现类中，添加构造方法

public class BookServiceImpl implements BookService {

    //注入引用类型
    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void save() {
        System.out.println("book service save......");

        bookDao.save();
    }
}

配置文件中配置 bean

    <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNum" value="10"/>
    </bean>

    <bean id="bookService" class="com.my.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookService bookService = (BookService) context.getBean("bookService");

        bookService.save();
        //输出结果为：book service save......
        //book dao save......10
    }
1.5集合注入

创建一个实现类，添加集合：数组、List、Set、Map、Properties 。 并提供 setter 方法

public class BookDaoImpl implements BookDao {
    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

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

    @Override
    public void save() {

        System.out.println("array数组："+ Arrays.toString(array));
        System.out.println("list数组："+list);
        System.out.println("set数组："+set);
        System.out.println("map数组："+map);
        System.out.println("properties数组："+properties);

    }
}

配置文件，注入集合类型数据

   <bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">

        <property name="array">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>a</value>
                <value>b</value>
                <value>c</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>a</value>
                <value>b</value>
                <value>c</value>
                <value>c</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry key="1" value="a"/>
                <entry key="2" value="b"/>
                <entry key="3" value="c"/>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="4">d</prop>
                <prop key="5">e</prop>
                <prop key="6">f</prop>
            </props>
        </property>

    </bean>

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationConfig.xml");

        BookDao bookDao = (BookDao) context.getBean("bookDao");

        bookDao.save();
        //输出结果为：array数组：[1, 2, 3]
        //list数组：[a, b, c]
        //set数组：[a, b, c]
        //map数组：{1=a, 2=b, 3=c}
        //properties数组：{4=d, 5=e, 6=f}
    }

2. 第三方数据源对象管理（管理第三方 bean）

  1. 导入 spring-context 依赖和 第三方 Druid 依赖
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.22.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.11</version>
        </dependency>
  1. 开启命名空间，在 beans 标签里添加 context ，如下：
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd

       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd

       ">
  1. 创建资源包 properties 文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root
  1. 配置文件中加载 properties 文件，使用 ${} 读取文件里的属性值
<!--    1.开启命名空间-->
<!--    2.加载properties文件-->
   <context:property-placeholder location="jdbc.properties"/>

<!--    3.使用${}读取文件里的属性值-->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="${jdbc.driver}"/>
       <property name="url" value="${jdbc.url}"/>
       <property name="username" value="${jdbc.username}"/>
       <property name="password" value="${jdbc.password}"/>
   </bean>

测试运行结果

    public static void main(String[] args) {

        ApplicationContext context =new ClassPathXmlApplicationContext("applicationConfig.xml");

        DataSource dataSource = (DataSource) context.getBean("dataSource");

        System.out.println(dataSource);
        //输出结果为：{
        //	CreateTime:"2022-09-18 19:45:03",
        //	ActiveCount:0,
        //	PoolingCount:0,
        //	CreateCount:0,
        //	DestroyCount:0,
        //	CloseCount:0,
        //	ConnectCount:0,
        //	Connections:[
        //	]
        //}
    }

3.核心容器

3.1创建容器的方式

  • 类路径加载配置文件

    ApplicationContext context =new ClassPathXmlApplicationContext("applicationConfig.xml");

  • 文件路径加载配置文件

    ApplicationContext context1=new FileSystemXmlApplicationContext("D:\\SpringProjects\\spring_07_dataSource\\src\\main\\resources\\applicationConfig.xml");

  • 加载多个配置文件，用逗号隔开

    ApplicationContext context =new ClassPathXmlApplicationContext("applicationConfig.xml","applicationConfig2.xml");
3.2获取 bean 的方式

  • 使用 bean 名称获取

    BookDao bookDao = (BookDao) context.getBean("bookDao");

  • 使用 bean 名称获取并指定类型

    BookDao bookDao = context.getBean("bookDao", BookDao.class);

  • 使用 bean 类型获取

    BookDao bookDao = context.getBean(BookDao.class);
3.3容器类层次结构

在这里插入图片描述

2023-8-13胖胖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
11.注解开发依赖注入及管理第三方Bean
DiKeLuoNa
12-19 492
注解开发依赖注入及管理第三方bean
第三方bean管理&第三方bean依赖注入
PeterLee3333的博客
05-05 248
1、在类配置中定义一个方法获得要管理的对象（以后基本是单独定义一个配置类，然后把jdbc数据放在另一个类中，但是需要在配置类中导类） public Datasource dataSource(){ DruidDataSource ds = new DruidDataSource(); ds.setDriverclassName( "com.mysql.jdbc.Driver"); ds.setUrl( "jdbc : mysql: / / localhost : 3306/spring_db")
注解开发定义bean和纯注解开发-依赖注入-管理第三方bean以及xml配置与注解对比
m0_59564754的博客
09-20 341
注解开发定义bean和纯注解开发-依赖注入-管理第三方bean以及xml配置与注解对比
Spring5 中更优雅的第三方 Bean 注入
最新发布
江南一点雨的专栏
07-11 363
接下来松哥就来和大家简单聊一聊这个话题。
Spring中依赖注入方式及第三方bean管理
m0_62912377的博客
04-24 778
依赖注入描述了在容器中建立bean与bean之间的依赖关系的过程，Spring便提供了两种注入方式setter注入和构造器注入，以下将展示setter注入和构造器注入分别对引用类型和简单类型的四种注入方式
spring依赖注入知识点分享
08-25
DI 依赖注入是一种 IoC 方式，它将对象之间的依赖关系管理交给第三方容器，典型的是 Spring。DI 依赖注入是一种优秀的解耦合方式，广泛应用于 Java 开发中。 Spring 的 DI 依赖注入 在 Spring 中，DI 依赖注入是一...
控制反转（IoC）与依赖注入（DI）1
08-03
而在IoC模式下，这种依赖关系被反转，对象A不再负责创建或管理对象B，而是由一个第三方——即IoC容器——负责创建和维护对象B，并将其注入到对象A中，使得对象A能够使用对象B。这样，对象A和对象B之间实现了解耦，...
ASP.NET MVC实现依赖注入的完整过程
10-16
虽然有许多成熟的第三方库如AutoFac可以使用，但在这里我们将构建一个简单的轻量级版本。我们定义了一个`Component`特性，用于标记需要被注入的类。在`Global.asax`的`Application_Start`方法中，我们需要遍历项目中...
Spring 30道面试题和答案.docx
06-15
2. 作为第三方Web框架的中间层。 3. 用于远程服务。 Spring IOC容器是Spring框架的核心，负责创建、装配、配置和管理对象的生命周期。依赖注入（DI）是Spring的重要概念，它通过容器将组件和服务关联起来，而不是在...
Spring注解开发管理第三方bean及依赖注入
m0_61961937的博客
06-15 1373
Spring注解开发管理第三方bean及依赖注入的格式
SpringBoot引入第三方jar的Bean的三种方式
后端元宇宙
11-25 1万+
在SpringBoot的大环境下，基本上很少使用之前的xml配置Bean，主要是因为这种方式不好维护而且也不够方便。 因此本篇博文也不再介绍Spring中通过xml来声明bean的使用方式。 注解装配Bean 1、使用@Component等派生注解 只要在类上加类上加 @Component 注解即可,该注解只要被扫描到就会注入到spring的bean容器中。 @Component public class AnoDemoBean { } 当然不只是@Component注解可以声明Bean，还有如:@Re.
Spring 第三方bean管理（第三方bean注入资源）（以druid为例子）
阿博的博客
10-15 1049
第三方bean管理（第三方bean注入资源）（以druid为例子）
如何实现第三方注入bean？
xingcsdnboke的博客
08-26 144
【代码】如何实现第三方注入bean？
第三方Bean依赖的注入（注解开发）
m0_47023871的博客
05-07 534
简单类型依赖的注入 //1.定义一个方法获得要管理的对象 @Value("com.mysql.jdbc.Driver") private String driver; @Value("jdbc:mysql://localhost:3306/dbtest1") private String url; @Value("root") private String userName; @Value("123456") private String pa
Spring注入第三方Bean(druid)
qq_38642731的博客
03-24 584
概要 利用Spring配置第三方bean的方法主要是通过利用bean标签内利用set方法对第三方依赖的对象注入 注： 这里还用到了context引用properties的属性值，用来解耦合
springboot的第三方bean注入方式&springboot监控
weixin_61294560的博客
10-24 591
springboot第三方注入，一起springboot监控
Spring学习（十八）Bean 的三种依赖注入方式介绍
热门推荐
wangxin1248的博客
06-05 2万+
依赖注入：让调用类对某一接口实现类的依赖关系由第三方注入，以移除调用类对某一接口实现类的依赖。 接下来将详细的向大家介绍Spring容器支持的三种依赖注入的方式以及具体配置方法： •    属性注入方法 •    构造函数注入方法 •    工厂方法注入方法 一．属性注入 属性注入即通过setXXX()方法注入Bean的属性值或者依赖对象，由于属性注入方式具有可选择性和灵活高的
06-Springboot第三方组件注入：yml文件和@Bean的第三方组件注入
前路无畏的博客
11-15 1万+
上一篇：05-Springboot构造器绑定：yum文件和Properties类的构造器绑定https://blog.csdn.net/fsjwin/article/details/109700066 yml中配置的数据也可以在@Bean标注的类上，示例如下： 1. application.yml ymlother: str: 普通字符串 specialStr: "换\n行字符串" num: 520 dnum: 520:22 birth: 2020/11/11 11:11:11 li
springboot注入第三方jar包的类
qq_22855003的博客
05-05 1万+
比如我们要注入CrawlerTask1，CrawlerTask2这个两个类 因为这两个类没有被@Service，@Repository等类注解，如果我们想用@Autowired注入会报错 @Autowired private CrawerTask1 crawerTask1; 我们可以新建一个Config类，在里面获得我们想要注入的第三方jar包的类，通过@Configuration注解这...
ioc控制反转和DI依赖注入实验
05-10
控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）是面向对象编程中的两个重要概念。它们可以帮助我们更好地实现代码的松耦合，提高代码的可维护性和可扩展性。 IoC是一种编程思想，它将程序的控制权从程序员手中转移到了IoC容器中，由IoC容器来管理和调用对象之间的依赖关系。IoC容器就像是一个工厂，它负责创建和管理对象，程序员只需要告诉IoC容器需要哪些对象，IoC容器就会根据配置文件或者注解等方式来创建对象，并将它们组合起来。 DI是IoC的一种具体实现方式，它通过构造函数、属性或者方法等方式将依赖关系注入到对象中。当一个对象需要另一个对象时，它不会直接创建这个对象，而是通过IoC容器来获取这个对象。通过DI，我们可以实现对象之间的松耦合，提高代码的可维护性和可测试性。 下面是一个简单的例子，演示如何使用IoC容器和DI实现对象之间的依赖注入： ```java // 定义接口 public interface MessageService { void send(String message); } // 实现接口 public class EmailService implements MessageService { public void send(String message) { System.out.println("Email sent: " + message); } } // 定义需要依赖注入的类 public class MyClass { private MessageService messageService; // 通过构造函数注入依赖 public MyClass(MessageService messageService) { this.messageService = messageService; } public void doSomething() { // 使用依赖的方法 messageService.send("Hello World!"); } } // 使用IoC容器创建对象并注入依赖 public class Main { public static void main(String[] args) { // 创建IoC容器 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); // 从IoC容器中获取对象 MyClass myClass = (MyClass) context.getBean("myClass"); // 调用方法 myClass.doSomething(); } } ``` 在上面的例子中，我们定义了一个MessageService接口和一个EmailService实现类。然后我们定义了一个MyClass类，它需要依赖MessageService对象来完成一些操作。通过构造函数注入依赖，我们可以将MessageService对象注入到MyClass中。最后，在使用IoC容器创建对象时，我们可以通过配置文件或者注解等方式来指定依赖的实现类，IoC容器会自动创建对象并注入依赖。 总之，IoC和DI是非常重要的编程思想，它们可以帮助我们更好地管理对象之间的依赖关系，提高代码的可维护性和可扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2023-8-13胖胖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值