Spring（一）IOC

最新推荐文章于 2023-05-12 08:50:54 发布
最新推荐文章于 2023-05-12 08:50:54 发布
阅读量76 收藏
点赞数
分类专栏： Spring SpringMVC MyBatis 文章标签： spring java ioc bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48465257/article/details/113583691
版权

文章目录

IOC

IOC本质

  • IOC（控制反转），是一种设计思想，DI（依赖注入）是实现IOC的一种方法。没有IOC的程序中，使用面向对象编程，对象的创建以及对象间的依赖关系完全在程序中，对象的创建由程序自己控制。使用IOC的程序中，控制反转后将对象的创建转移给第三方，即获得依赖对象的方式反转了。
  • 控制：控制对象的创建，传统 程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
  • 反转：程序本身不创建对象，而是被动的接收对象。
  • 依赖注入：利用set方法来进行注入。
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象的中的所有属性，由容器来注入。

创建一个 Maven 项目

解决静态资源导出问题

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

引入依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

XML配置实现

编写实体类

package com.xuan.pojo;

public class User {

    private Integer userId;
    private String userName;

    public User(Integer userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                '}';
    }
}

package com.xuan.pojo;

public class Teacher {

    private Integer teacherId;
    private String teacherName;

    public Integer getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(Integer teacherId) {
        this.teacherId = teacherId;
    }

    public String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "teacherId=" + teacherId +
                ", teacherName='" + teacherName + '\'' +
                '}';
    }
}

package com.xuan.pojo;

import java.util.*;

public class Student {

    private Integer studentId;
    private String studentName;
    private Teacher teacher;
    private String[] strings;
    private List<String> list;
    private Map<String, Object> map;
    private Set<String> set;
    private String wife;
    private Properties properties;

    public Integer getStudentId() {
        return studentId;
    }

    public void setStudentId(Integer studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public String[] getStrings() {
        return strings;
    }

    public void setStrings(String[] strings) {
        this.strings = strings;
    }

    public List<String> getList() {
        return list;
    }

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

    public Map<String, Object> getMap() {
        return map;
    }

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

    public Set<String> getSet() {
        return set;
    }

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

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getProperties() {
        return properties;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "studentId=" + studentId +
                ", studentName='" + studentName + '\'' +
                ", teacher=" + teacher +
                ", strings=" + Arrays.toString(strings) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                ", wife='" + wife + '\'' +
                ", properties=" + properties +
                '}';
    }
}

编写配置文件

<?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="teacher" class="com.xuan.pojo.Teacher">
        <property name="teacherId" value="1"/>
        <property name="teacherName" value="唐僧"/>
    </bean>
    <bean id="student" class="com.xuan.pojo.Student">
        <property name="studentId" value="2"/>
        <property name="studentName" value="孙悟空"/>
        <property name="teacher" ref="teacher"/>
        <property name="strings">
            <array>
                <value>数组1</value>
                <value>数组2</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="map1" value="map1"/>
                <entry key="map2" value="map2"/>
            </map>
        </property>
        <property name="set">
            <set>
                <value>set1</value>
                <value>set2</value>
            </set>
        </property>
        <property name="wife">
            <null/>
        </property>
        <property name="properties">
            <props>
                <prop key="properties1">properties1</prop>
                <prop key="properties2">properties2</prop>
            </props>
        </property>
    </bean>
<!--    有参构造-->
    <bean id="user" class="com.xuan.pojo.User">
        <constructor-arg name="userId" value="1"/>
        <constructor-arg name="userName" value="观音菩萨"/>
    </bean>

</beans>

测试

package com.xuan;

import com.xuan.pojo.Student;
import com.xuan.pojo.Teacher;
import com.xuan.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test01(){
        //通过set注入
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Teacher teacher = context.getBean("teacher", Teacher.class);
        Student student = context.getBean("student", Student.class);
        System.out.println(teacher);
        System.out.println(student);
    }

    @Test
    public void test02(){
        //通过有参构造注入
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user);
    }

}

最终项目包结构

在这里插入图片描述

Bean的作用域

  • 单例模式（Spring默认机制）
  • 原型模式：每次从容器中get的时候，都会产生一个新对象。

注解实现

编写配置文件

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    指定要扫描那个包下的注解-->
    <context:component-scan base-package="com.xuan"/>

<!--    开启注解支持-->
    <context:annotation-config/>

</beans>

编写实体类

package com.xuan.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {

    @Value("1")
    private Integer userId;
    @Value("孙悟空")
    private String userName;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                '}';
    }
}

编写dao层

package com.xuan.dao;

import com.xuan.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {

    @Autowired
    private User user;

    public void hello(){
        System.out.println("==="+user.getUserId()+"==="+user.getUserName()+"===");
    }
}

编写service层

package com.xuan.service;

import com.xuan.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    public void hello(){
        userDao.hello();
    }

}

编写controller层

package com.xuan.controller;

import com.xuan.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public void hello(){
        userService.hello();
    }

}

测试

package com.xuan.controller;

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

public class TestUserController {

    @Test
    public void testHello(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserController userController = context.getBean("userController", UserController.class);
        userController.hello();
    }

}

最终项目包结构

在这里插入图片描述

独守丶轩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IOC介绍及其简单实现
朱志辉的专栏
05-15 4088
 预备知识： Java反射原理，XML及其解析 IOC：Inversion of Control，控制反转，它最主要反映的是与传统面向对象（OO）编程的不同。通常我们编程实现某种功能都需要几个对象相互作用，从编程的角度出发，也就是一个主对象要保存其他类型对象的引用，通过调用这些引用的方法来完成任务。如何获得其他类型的对象引用呢？一种方式是主对象内部主动获得所需引用；另一种方式是在主对象
【java基础】IOC介绍及其简单实现
weixin_33994444的博客
05-28 233
　　控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找。依赖注入应用比较广泛，我们这里只介绍依赖注入。 　　一、IOC简介 　　控制反转IOC，它最主要反映的是与传统面向对象（OO）...
Spring Boot核心知识--2
聚沙成塔
12-17 140
二、夯实基础：JavaConfig与常见Annotation 2.1、JavaConfig 我们知道 bean是Spring IOC中非常核心的概念，Spring容器负责bean的生命周期的管理。在最初，Spring使用XML配置文件的方式来描述bean的定义以及相互间的依赖关系，但随着Spring的发展，越来越多的人对这种方式表示不满，因为Spring项目的所有业务类均以bean的形式配置在...
什么叫IOC（编程术语）
自由引导码民！
04-19 1030
 IoC就是Inversion of Control，控制反转。在Java开发中，IoC意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转。 下面我们以几个例子来说明什么是IoC 假设我们要设计一个Girl和一个Boy类，其中Girl有kiss方法，即Girl想要Kiss一个Boy。那么，我们的问题是，Girl如何能够认识这个Boy？ 在我们中国，常见的MM与G
简单IOC实现
helloworlddm的博客
04-29 847
IOC基本原理 IOC：控制反转，是Spring框架的核心，能够实现动态注入实例的功能。在Spring中，这个过程由Spring框架帮助我们完成。我们只需要配置好相应的XML文件或者使用注解，Spring会自动进行注入。 IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致...
Spring中IoC优点与缺点解析
08-28
IoC(Inversion of Control)是 Spring 框架中的一种设计模式，它的主要思想是将对象的创建和管理交给容器，从而解耦合对象之间的依赖关系。今天，我们将详细解析 IoC 的优点和缺点。 优点 1. 简化对象的创建：IoC ...
spring_ioc
06-04
这是spring_ioc部分的内容。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
springIoc实现原理
04-20
Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由代码自身来完成，而在Spring Ioc中...
spring-IOC代码
06-16
**Spring IOC（控制反转）深度解析** 在Java开发领域，Spring框架因其强大的功能和灵活性而备受推崇，其中的核心概念就是IOC（Inversion of Control，控制反转）。本文将深入探讨Spring IOC，以及它如何通过容器来...
IOC编程实践
qq_38164867的博客
09-04 200
IOC编程，实现视图绑定，控件绑定和事件绑定 IOC(inversion of control)的中文解释是“控制反转”或者“依赖注入”，它的实现目的是：我们可以通过配置文件来控制程序的流程，达到程序代码的优化。通俗的讲就是将程序要做的一些事交给框架处理，达到很好的解耦性。 android中常用的视图绑定框架有多个，像Butterknife,XUtils等，今天就窥探下其原理。 分三步 一、视图绑...
Spring IOC 编程实现
田宝宝的博客
06-09 435
Spring IOC编程实现 ...
浅谈IOC编程思想
阿生
08-03 356
IOC 是的缩写表示控制反转在整个系统中IOC就相当于哆啦A梦的口袋，任何对象可以通过这个口袋中拿到。有了IOC容器之后再看c对象的依赖，它虽然还是依赖于a和b但是情况却不一样了fill:#333;color:#333;color:#333;fill:none;}IOC容器abc如图所示，此时的情况相当于cc的依赖交由IOC容器进行管理，在程序运行时IOC容器主动的将a和b进行注入到c中。这时候c由主动创建a和b两个依赖的行为被反转为被动接受IOC容器注入a和b依赖思考一下？......
Spring 框架基础(03)：核心思想 IOC 编程说明，案例演示
【积累】，是一个长期持续的过程。
09-26 211
这是一个工厂，用于生成任意bean。采取延迟加载，第一次getBean时才会初始化Bean。是BeanFactory的子接口，功能更强大。（国际化处理、事件传递、Bean自动装配、各种不同应用层的Context实现）。当配置文件被加载，就进行对象实例化。用于加载classpath（类路径、src）下的xml加载xml运行时位置用于加载指定盘符下的xml加载xml运行时位置/WEB-INF/…xml，通过ServletContext.getRealPath()获得具体盘符配置。ENDhttps。...
IOC实现完全接口编程
传a奇—学习博客
12-20 1962
接触Spring框架也比较久了，用的做多的自然是IOC（控制反转），IOC作为Spring中的核心技术之一到底有什么好处呢？？？作为菜鸟的我，在使用IOC时最大的一个感触就是，使用它可以实现完全的面向接口编程。为什么？？？？还是让例子来说话。 首先来看一下再不用IOC的时候，如何实现接口编程的的。    public interface Office{ public void show
谈谈IOC容器和AOP编程
最新发布
qx020814的博客
05-12 354
类在创建时，会走一步叫做类加载器，加载的过程中就会创建一个Class类，里面就包含了这个类的所有元素。Java发展的路途中，由刚开始的使用new创建对象，到使用抽象类，接口进行解耦，又到了提问时刻，什么是耦合度？当一个对象要使用，但是，它并不能直接拿来用，有一个或者多个前提，必须给定别的 方法，或者对象。所以代理模式就是：通过代理（接口实现）这个类，拥有父类的方法，但是自己还加了一些自己的方法。，我们不再创建对象，只负责调用，以前是程序员new，现在反过来了。的情况下，加一些奇奇怪怪的业务。
IOC编程框架原理
weixin_48325343的博客
04-11 85
##ioc编程框架 一、ioc编程原理 IOC控制反转----DI依赖注入 一般我们编程时直接在对象内部new一个对象进行创建，ioc编程框架是用容器来代替new创建对象 将自己创建的对象交给容器控制 二、代码实现 `package ioc; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.lang.reflect.Field; imp
控制反转（IOC）或依赖注入（DI）和面向切面编程(AOP)
chenrui310的博客
08-01 3249
spring学习第一篇：控制反转（IOC）或依赖注入（DI）和面向切面编程(AOP) spring相关的书和博文看了很多，一直也没明白依赖注入和面向切面编程到底是什么，spring企业实战看到第三遍突然恍然大悟，也许是因为之前动手写过代码，所以终于潜移默化，慢慢理解了吧。 http://www.360doc.com/content/18/0125/09/27831725_724899826.s...
Spring IoC容器深度解析
在软件开发领域，Spring框架是Java应用开发中的一个核心组件，特别是它的IoC（Inversion of Control，控制反转）容器，它极大地简化了对象的创建、管理和依赖处理。Spring的IoC容器是整个框架的核心，负责管理对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值