IoC详解

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量103 收藏
点赞数
分类专栏： Spring 文章标签： java spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzll_forever/article/details/121386949
版权

IoC详解

1 Bean创建

  • @Component，组件注解，用于将任意对象添加到spring容器中。
    • @Controller，将web层的对象，添加到spring容器。
    • @Service，将service层的对象，添加到spring容器。
    • @Repository，将dao层的对象，添加到spring容器。

2 依赖注入

  • 按照名称注入

    public class 类名{
    @Resource(name="名称")
    private 类型 变量;
}

  • 按照类型注入

    public class 类名{
    @Resource
    private 类型 变量;
}

  • 注册普通数据

    @Value 可以给成员变量注入、也可以给属性注入(getter/setter)

  • properties数据注入

    • 编写properties文件，key=value
    • 加载 @PropertySource(“classpath:properties文件”)
    • 注入数据 @Value("${key}")
    package com.czxy.demo07_di_properties.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;


@Configuration
@PropertySource("classpath:demo07.properties")
public class Demo07Configuration {

    @Value("${jdbc.driver}")
    private String driver;                  //给成员变量赋值

    @Value("${jdbc.url}")
    public void setUrl(String url) {        //给写属性赋值
        System.out.println("url:" + url);
        System.out.println("driver:" + driver);
    }
}

2.3 @Bean 注入第三方类

2.3.1 按照类型

  • 模拟类

    package com.czxy.demo08_bean_type.dao;


public class UserDao {
    public void selectAll() {
        System.out.println("user dao ");
    }
}

  • 配置类

    package com.czxy.demo08_bean_type.config;

import com.czxy.demo08_bean_type.dao.UserDao;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class Demo08Configuration {

    @Bean
    public UserDao createUserDao() {
        return new UserDao();
    }
}

  • 测试类

    package com.czxy.demo08_bean_type;

import com.czxy.demo07_di_properties.config.Demo07Configuration;
import com.czxy.demo08_bean_type.config.Demo08Configuration;
import com.czxy.demo08_bean_type.dao.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo08Configuration.class)
public class TestDemo08 {

    @Resource
    private UserDao userDao;

    @Test
    public void testDemo07() {
//        UserDao userDao = new UserDao();
        userDao.selectAll();
    }
}

2.3.2 按照名称

  • 模拟数据类

    • 接口
    • 实现类A
    • 实现类B

  • 配置类，创建2个实现类，并进行不同的命名

  • 测试类，依次注入不同命名的实现类

  • 实现

    • 配置类

      package com.czxy.demo09_bean_name.config;

import com.czxy.demo09_bean_name.dao.UserDao;
import com.czxy.demo09_bean_name.dao.impl.UserDaoImplA;
import com.czxy.demo09_bean_name.dao.impl.UserDaoImplB;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class Demo09Configuration {

    @Bean(name="userDaoA")
    public UserDao createUserDaoA() {
        return new UserDaoImplA();
    }

    @Bean(name="userDaoB")
    public UserDao createUserDaoB() {
        return new UserDaoImplB();
    }
}

    • 测试类

      package com.czxy.demo09_bean_name;

import com.czxy.demo09_bean_name.config.Demo09Configuration;
import com.czxy.demo09_bean_name.dao.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 */
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo09Configuration.class)
public class TestDemo09 {

    @Resource(name="userDaoA")
    private UserDao userDaoA;

    @Resource(name="userDaoB")
    private UserDao userDaoB;

    @Test
    public void testDemo07() {
        userDaoA.selectAll();
        userDaoB.selectAll();
    }
}

2.3.3 参数类型：引用数据

  • @Bean 修饰的方法，如果有参数，将自动注入。

  • 步骤：

    • 模拟类
      • UserDao
      • UserService
    • 配置类
      • 编写方法，createUserDao
      • 编写方法，createUserService( UserDao userDao )
    • 测试类

  • 实现

    • 配置类

      package com.czxy.demo10_bean_param.config;

import com.czxy.demo10_bean_param.dao.UserDao;
import com.czxy.demo10_bean_param.service.UserService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class Demo10Configuration {

    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

    @Bean
    public UserService userService(UserDao userDao) {
        userDao.selectAll();
        return new UserService();
    }
}

    • 测试类

      package com.czxy.demo10_bean_param;

import com.czxy.demo09_bean_name.config.Demo09Configuration;
import com.czxy.demo09_bean_name.dao.UserDao;
import com.czxy.demo10_bean_param.config.Demo10Configuration;
import com.czxy.demo10_bean_param.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo10Configuration.class)
public class TestDemo10 {

    @Resource(name="userService")
    private UserService userService;

    @Test
    public void testDemo07() {
        userService.selectAll();
    }
}

2.3.4 参数类型：简单数据

  • properties配置文件

    #key=value
jdbc.driver=com.mysql.jdbc.cj.Driver
jdbc.url=jdbc:mysql://localhost:3306/db2

user.username=jack
user.password=6666

  • 配置类

    package com.czxy.demo11_bean_value.config;

import com.czxy.demo10_bean_param.dao.UserDao;
import com.czxy.demo10_bean_param.service.UserService;
import com.czxy.demo11_bean_value.domain.User;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;


@Configuration
@PropertySource("classpath:demo07.properties")
public class Demo11Configuration {

    @Bean
    public User createUser(@Value("${user.username}") String username,
                           @Value("${user.password}") String password) {
        return new User(username,password);
    }
}

  • 测试类

    package com.czxy.demo11_bean_value;

import com.czxy.demo10_bean_param.service.UserService;
import com.czxy.demo11_bean_value.config.Demo11Configuration;
import com.czxy.demo11_bean_value.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo11Configuration.class)
public class TestDemo11 {

    @Resource
    private User user;

    @Test
    public void testDemo07() {
        System.out.println(user);
    }
}

2.4 Bean 作用域

  • 默认2个作用域：
    • 单例 singleton ：整个spring容器只有一个。
    • 多例 prototype：每获得一次创建一份。

2.4.1 单例

  • dao，确定作用域方式

    package com.czxy.demo12_scope.dao;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;


@Repository
@Scope("singleton")
public class UserDao {
}

  • 配置类

    package com.czxy.demo12_scope.config;

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


@Configuration
@ComponentScan(basePackages = {"com.czxy.demo12_scope.dao"})
public class Demo12Configuration {
}

  • 测试类，注入2次，打印结果一样的。

    package com.czxy.demo12_scope;

import com.czxy.demo04_component.config.Demo04Configuration;
import com.czxy.demo04_component.controller.StudentController;
import com.czxy.demo12_scope.config.Demo12Configuration;
import com.czxy.demo12_scope.dao.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith(SpringRunner.class)
@ContextConfiguration(classes = Demo12Configuration.class)
public class TestDemo12 {

    @Resource
    private UserDao userDao1;

    @Resource
    private UserDao userDao2;

    @Test
    public void testDemo4() {
        System.out.println(userDao1);
        System.out.println(userDao2);
    }
}

2.4.2 多例

  • 修改单例代码

    package com.czxy.demo12_scope.dao;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;


@Repository
//@Scope("singleton")
@Scope("prototype")
public class UserDao {
}

2.4.3 常量

package com.czxy.demo12_scope.dao;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;

 
@Repository
//@Scope("singleton")
//@Scope("prototype")
//@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)    //单例常量 singleton
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)     //多例常量 prototype
public class UserDao {
}
zzll_forever
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中IOC详解
qq_41359998的博客
02-06 1万+
一、IOC的原型 IOC ----控制反转 比如我们有一个功能是获取用户数据，我们使用Dao层实现这个功能，再在Service层调用这个功能。但是我们每增加一个接口，比如获取mysql中的数据，就要修改原来的代码，如果再增加一个新的接口，又需要去service实现类中修改对应的实现。 解决方法 用户实际调用的是业务层，dao层他们不需要接触 UserServiceImpl userService = new UserServiceImpl(); userSe
Spring之IOC详解
08-31
Spring之IOC详解 IOC（Inversion of Control，控制反转）是一种重要的面向对象编程法则，用于削减计算机程序的耦合问题。它是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection...
day-2021-10-05(Spring IOC详解)
TIM_Zhang1122的博客
10-05 102
2 IoC详解 2.1 Bean创建 @Component，组件注解，用于将任意对象添加到spring容器中。 @Controller，将web层的对象，添加到spring容器。 @Service，将service层的对象，添加到spring容器。 @Repository，将dao层的对象，添加到spring容器。 2.2 依赖注入 按照名称注入 public class 类名{ @Resource(name="名称") private 类型 变量; } 按照类型注入 p
Spring 框架——spring入门教程
热门推荐
随笔记
08-07 2万+
打个广告，帮朋友卖点东西，东西超便宜的哟【衣服鞋子等】，厂家直接出货，绝对低于市场价！！！一般都比市场价便宜3—7折【都是牌子货】，如果您感兴趣，可以扫描屏幕下方的二维码，感谢关注！！！ 微信 一、基本介绍 1、spring的特点 Spring是一个开源框架，Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EE full-st...
Java中的两种测试方法（JUnit,dbUnit）使用
xiaoma's Blog
10-24 4029
JUnit、dbunit的基本使用
IOC详解
weixin_47586838的博客
09-13 631
IOC的含义： Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。 DI—Depende...
Spring IOC详解
星海IT学习之路
07-14 1708
目录一、IOC的基本概念1.简述 IOC 概念2.Spring的IoC理解3.IOC的优点是什么？二、程序中的耦合1.程序的耦合和解耦2.解决耦合的思路3.工厂模式解耦程序的耦合三、解决程序的耦合1.BeanFactory和ApplicationContext有什么区别？2.ApplicationContext的常用实现类：3.Bean 标签解释Spring的几种bean的作用域4.Spring Bean的生命周期5.实例化bean的三种方式第一种方式：使用默认无参构造函数第二种方式：spring 管理静态
Spring IOC 详解
SunStaday的博客
01-09 266
Spring IOCIOC什么是IOCIOC容器介绍BeanFactory和ApplicationContext的区别Spring容器管理对象Spring依赖（pom.xml）Spring的配置文件Bean类的实例化方式（demo）创建实例类基于xml配置文件实现Bean基于无参构造函数实例化静态工厂方式实例化基于普通工厂方法实例化基于注解的方式装配Beanspring配置文件引入context约束实例类上添加注解 IOC 什么是IOC Ioc—Inversion of Control，即“控制反转”，不是
Spring系列--IOC详解
qq_42194397的博客
11-25 2275
IOC笔记总结
Spring ioc详解
wppi的博客
08-06 203
Spring概念 1 spring是开源的轻量级框架 2 spring核心主要两部分： （1）aop：面向切面编程，扩展功能不是修改源代码实现 （2）ioc：控制反转， - 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象 - 把对象的创建不是通过new方式实现，而是交给spring配置创建类对象 ...
IOC详解IOC详解IOC详解IOC详解
02-27
控制反转（IOC，Inversion of Control）是一种设计模式，它在软件工程中被广泛应用，特别是在Java开发中。IoC的核心思想是将对象的创建和管理权交给一个外部容器，而不是让对象自行创建和管理依赖。这有助于降低耦合...
SpringIOC 详解
09-17
SpringIOC Spring 框架是一个流行J2EE的开源产品，它提供了统一的应用架构方式、大量的中间层功能模块，大大简化了传统J2EE的开发模式。它的核心代码均来自于真实的项目，是由Spring 之父Rod Johnson 从商业项目开发...
ASP.NET MVC如何使用Unity实现Ioc详解
01-03
最近在学ASP.NET MVC项目中使用Ioc，选用了Unity作为依赖注入的容器组件，在网上找了相关的文章简单实现了依赖注入，但想用文件配置的方式进行容器注入的注册，发现相关的文章实现的方式不适用，因为网上的文章大多...
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
在本文中，我们将深入探讨Spring框架中的重要概念——控制反转（Inversion of Control，简称IOC），并重点关注如何通过注解和Java配置来实现IOC。Spring是Java开发中广泛使用的轻量级框架，它简化了应用程序的构建，...
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 324
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 544
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
微服务和kafka
m0_51586984的博客
06-26 1204
ZooKeeper 是一个开源的分布式协调服务，ZooKeeper框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。后来，Apache ZooKeeper成为Hadoop，HBase和其他分布式框架使用的有组织服务的标准。例如，Apache HBase使用ZooKeeper跟踪分布式数据的状态。ZooKeeper 的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来，构成一个高效可靠的原语集，并以一系列简单易用的接口提供给用户使用。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 276
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
spring ioc容器详解
07-09
Spring IOC容器构建流程如下： 1. 加载配置文件：Spring IOC容器首先需要加载配置文件，这些配置文件包含了Bean的定义和配置信息。 2. 创建Bean实例：Spring IOC容器根据配置文件中的Bean定义信息，创建Bean实例。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值