springioc基本使用.md

最新推荐文章于 2024-07-18 09:20:47 发布
最新推荐文章于 2024-07-18 09:20:47 发布
阅读量163 收藏
点赞数
分类专栏： Java 文章标签： spring java xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Master724/article/details/122971209
版权

1.IOC概念

Inversion of Control,控制反转
即将对象的控制权交由spring,由spring代替人工去操作对象,省去了操作对象的代码
操作包括创建,初始化,销毁等
主要用到以下名词
bean:spring中一个bean代表一个对象,对象的其它属性设置都基于bean
context:上下文管理窗口,用于从Spring获取对象

2.配置方式

配置方式有三种

  1. XML方式
  2. JAVA代码方式
  3. 混合方式,即JAVA代码中读取XML配置方式

主要依赖spring-context包

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.2.9.RELEASE</version>
</dependency>

3.xml方式

3.1 创建Spring.xml配置文件

下载完依赖后,IDEL会出现对象的选项,右击目录会有SpringConfig选项,输入任意文件名,即可创建Sring配置文件

3.2 读取文件方式

主类中使用 ClassPathXmlApplicationContext() 方法调用

package SpringIocDemo;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
    public static void main(String[] args) {
        //xml 配置方式
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        User user = context.getBean("getUser", User.class);
        System.out.println(user);
    }

3.3 注入

IOC对象及其属性注入首先需要有这个对象,项目内创建一个User对象,且这个对象的所有属性需要有getter和setter方法,否则注入不会生效

package SpringIocDemo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;

public class User {
    private String name;
    private int age;
    private String sex;
    private Cat cat;
    private Cat[] cats;
    private List<String> favoryter;
    private Map<String,Object> mymap;
    private Properties myper;

    public Properties getMyper() {
        return myper;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", cat=" + cat +
                ", cats=" + Arrays.toString(cats) +
                ", favoryter=" + favoryter +
                ", mymap=" + mymap +
                ", myper=" + myper +
                '}';
    }

    public void setMyper(Properties myper) {
        this.myper = myper;
    }

    public Map<String, Object> getMymap() {
        return mymap;
    }

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

    public List<String> getFavoryter() {
        return favoryter;
    }

    public void setFavoryter(List<String> favoryter) {
        this.favoryter = favoryter;
    }

    public Cat[] getCats() {
        return cats;
    }

    public void setCats(Cat[] cats) {
        this.cats = cats;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public User(){
        System.out.println("init");
    }

    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

以下均在xml文件内操作

3.3.1 Bean的获取

<bean id="用于查找的唯一id" class="类的路径"/>
如
<bean id="userid" class="SpringIocDemo.User">
id最好使用与类名相同,便于记忆
这样在主类中使用如下代码即可读取到spring创建的User对象

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
User user = context.getBean("getUser", User.class);
System.out.println(user);

3.3.2 构造方法注入

使用 constructor-arg 参数
需要有对应的有参构造方法
name的值为对应的属性名,value为需要注入的值

    <bean id="user1" class="SpringIocDemo.User">
        <constructor-arg name="name" value="test"/>
        <constructor-arg name="age" value="12"/>
        <constructor-arg name="sex" value="famale"/>
    </bean>

3.3.3 property参数注入属性

    <bean id="user2" class="SpringIocDemo.User">
        <property name="sex" value="male"/>
        <property name="name" value="user2"/>
    </bean>

3.3.4 P名称空间注入属性

P名称空间需要手动引入
xmlns:p="http://www.springframework.org/schema/p
P后面直接是 属性名:属性值
<bean id="user3" class="SpringIocDemo.User" p:name="user3"/>

3.3.5 工厂方法注入对象

第一行为静态工厂方法
第二,三行为实例工厂方法

<bean class="SpringIocDemo.MyFactory" id="factory" factory-method="getinstance"/>
<bean class="SpringIocDemo.MyFactory" id="factory2" />
<bean class="SpringIocDemo.MyFactory" factory-bean="factory2" factory-method="getinstance2" id="factory3"/>

静态工厂方法
需要新建工厂类,并且在工厂类中编写工厂方法,返回需要的实例
再使用 factory-method 参数传入工厂方法,再主类中获取这个bean即可
实例工厂方法则有一些不同,需要先定义工厂类的bean
再通过 factory-bean 获取到工厂类的实例,最通过 factory-method 传入工厂方法

3.3.6 对象属性注入

使用 ref 属性指向对应的baen

    <bean class="SpringIocDemo.User" id="user">
        <property name="cat" ref="cat"/>
    </bean>
    <bean class="SpringIocDemo.Cat" id="cat">
        <property name="name" value="this cat"/>
        <property name="age" value="20"/>
    </bean>

3.3.7 复杂属性注入

array 注入列表
list 注入数组
map 注入 map
props 注入 properties

    <bean class="SpringIocDemo.User" id="user5">
        <property name="cats">
            <array>
                <ref bean="cat"/>
                <bean class="SpringIocDemo.Cat" id="cat2">
                    <property name="name"  value="cat2name"/>
                    <property name="age"    value="12"/>
                </bean>
            </array>
        </property>
    </bean>

    <bean class="SpringIocDemo.User" id="user4">
        <property name="favoryter">
            <list>
                <value>u1</value>
                <value>u2</value>
                <value>u3</value>
                <value>u4</value>
            </list>
        </property>
    </bean>

    <bean class="SpringIocDemo.User" id="user6">
        <property name="mymap">
            <map>
                <entry key="m2" value="m2val"/>
                <entry key="m1" value-ref="cat"/>
            </map>
        </property>
    </bean>

    <bean class="SpringIocDemo.User" id="user7">
        <property name="myper">
            <props>
                <prop key="p1">p1val</prop>
                <prop key="p2">p2val</prop>
            </props>
        </property>
    </bean>

4. Java配置类方式

步骤

  1. 创建JavaConfig类名随意
  2. 使用 @Configuration 注解此类,使其成为配置类
  3. 创建获取实例的方法,并使用 @Bean 注解,使其成为Bean,供context调用
  4. 主类中使用 AnnotationConfigApplicationContext(JavaConfig.class) 获取配置类上下文
    各种属性的注入同Java编码,无需要特殊配置
package SpringIocDemo;

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

@Configuration
public class JavaConfig {
    @Bean
    public User getUser(){
        User u = new User();
        u.setAge(12);
        u.setName("javaconfig");
        u.setCat(getCat());
        u.setCats(new Cat[]{getCat(),getCat()});
        return u;
    }

    @Bean
    public Cat getCat(){
        Cat cat = new Cat();
        cat.setAge(1);
        cat.setName("catname");
        return cat;
    }
}

主类调用

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class);
        User user = context.getBean("getUser", User.class);
        System.out.println(user);

5.自动注入

自动注入主要依赖以下四个注解,都是基于Component编写,目前功能一致

  1. @Component,用于其它组件
  2. @Respository,用于Dao层
  3. @Service,用于Service层
  4. @Controllar,用于Controller层

步骤

  1. 创建配置类或者配置文件
  2. 在目标对象上使用 @Autowired @Resources @Injected注解
  3. 在配置类或者配置文件中配置自动扫瞄的路径

注意点:
Autowired是根据类型去查找,只能有一个对象,否则会报错
Resources根据名称去查找,默认情况定义的变量名就是查找的名称,也可以手动指定
当一个类存在多个实例时,就使用Resources
如果多实例使用auotwired,则需要增加一个Qualifier注解指定对象的变量名

主类

package SpringIocDemo.AutoInject;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AutoMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
//        FileSystemXmlApplicationContext cont = new FileSystemXmlApplicationContext("D:\\Code\\Java\\AllDemo\\Learn\\src\\main\\java\\SpringIocDemo\\AutoInject\\spring.xml");
        UserInter users = context.getBean(UserService.class);

        System.out.println(users.getALlUser());
    }
}

使用 @ComponentScan 配置扫瞄的包或者类

package SpringIocDemo.AutoInject;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages = "SpringIocDemo.AutoInject" )
public class Config {

}

目标类

package SpringIocDemo.AutoInject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import java.util.ArrayList;
import java.util.List;
@Controller
public class UserService implements UserInter{

    @Autowired
    Cat cat;
    @Autowired
    Cat cat2;

    @Override
    public List<String> getALlUser(){
        ArrayList<String> users = new ArrayList<>();
        for(int i=0;i<10;i++){
            users.add("javaboy:"+i);
        }
        cat.setAge(20);
        cat.setName("tes2");
        System.out.println(cat.toString());
        cat2.setAge(22);
        cat2.setName("test4");
        System.out.println(cat.toString());
        return users;
    }
}

xml配置扫瞄包或者类

 <context:component-scan base-package="SpringIocDemo.AutoInject"/>

6.@Condition条件注解

即根据条件来选择获取的对象或者执行的代码

步骤

  1. 创建条件类,实现 Condition 接口
  2. 定义目标实例类
  3. 配置bean,需要使用相同的ID,并使用 @Conditional 注解

条件类

package SpringIocDemo.ConditionDemo;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Locale;

public class LinuxCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return conditionContext.getEnvironment().getProperty("os.name").toLowerCase(Locale.ROOT).contains("linux");
    }
}


package SpringIocDemo.ConditionDemo;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class WinCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return conditionContext.getEnvironment().getProperty("os.name").toLowerCase().contains("windows");
    }
}

实例类接口

package SpringIocDemo.ConditionDemo;


public interface ShowCmd {
    public void showCmd();
}

实例类

package SpringIocDemo.ConditionDemo;

public class WinShowCmd implements ShowCmd {
    @Override
    public void showCmd() {
        System.out.println("dir");
    }
}


package SpringIocDemo.ConditionDemo;

public class LinuxShowCmd implements ShowCmd {
    @Override
    public void showCmd() {
        System.out.println("ls");
    }
}

配置类

package SpringIocDemo.ConditionDemo;

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

@Configuration
public class Config {
    @Bean("cmd")
    @Conditional(WinCondition.class)
    ShowCmd winCmd(){
        return new WinShowCmd();
    }
    @Bean("cmd")
    @Conditional(LinuxCondition.class)
    ShowCmd linuxcmd(){
        return new LinuxShowCmd();
    }
}

主类调用方式

package SpringIocDemo.ConditionDemo;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ConditionMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        ShowCmd cmd = context.getBean("cmd",ShowCmd.class);
        // 这里会根据对应的条件执行bean内对应的方法
        cmd.showCmd();
    }
}
mChenQ
关注
专栏目录
Spring.md
LEIQINGQI的博客
10-09 306
文章目录01 入门核心思想： IOC, AOP能解决的问题：1 pojo2 配置文件3 name 和 id工厂类型4 单例和多例两个bean：一个beanprototype5 延迟加载6 初始化和销毁方法person pojoxmltest：04 对象的创建方式4.1 无参构造函数4.2 有参构造函数4.3 实例工厂方法方法：applicationContexttest：4.4 静态工厂方法方法...
day-Spring IoC & DI.md
10-15
### Spring 概述 #### 1.1 Spring 是什么？ Spring 是一个用于构建 Java SE/EE 应用的分层的、全栈式的轻量级开源框架，它以 IOC...这不仅展示了 Spring 的基本使用方法，还体现了 Spring 在简化开发流程方面的优势。
Spring_IoC入门笔记.md
05-29
依赖注入：Dependency Injection IOC的作用：降低程序间的偶合（依赖关系） 依赖关系的管理：以后都交给spring来维护 在当前类需要用到其他类的对象时，由spring为我们提供，我们只需在配置文件中说明 依赖关系的维护：就称之为依赖注入 依赖注入： 注入方式：有三种 第一种：使用构造函数提供(创建对象时，必须提供数据，否则无法创建成功) 使用的标签：constructor-arg 标签出现的位置：bean标签的内部 标签中的属性： type:用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些数据的类型 index:用于指定要注入的数据 给构造函数中指定索引位置的参数赋值，索引位置从0开始 name:用于指定给构造函数中指定名称的参数赋值 常用 ============以上三个用于指定给构造函数中的那个参数赋值=========================== value:用于提供基本类型和String类型 ref:用于指定其他bean类型数据，它所指的是在spring的IOC容器中出现的bean
Spring框架三、Spring IOC基本使用
吃透Java
03-20 315
一、spring对象的获取及属性赋值方式 People.java package com.bobo.bean; public class People { private int id; private String name; private int age; private boolean gender; public int getId() { ...
Spring中的IOC详解
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-18 3273
单例Bean和多实例Bean的生命周期主要区别在于实例化和销毁的管理方式，单例Bean在容器启动时创建一个实例，并由容器负责管理其生命周期的完整过程。在Spring框架中，Bean是应用程序的核心组件，它们由Spring容器创建、组装和管理，以帮助开发者实现松耦合、可测试和可维护的代码。IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。Bean的自动装配是Spring框架提供的一种便捷的方式，用于自动解析和设置Bean之间的依赖关系，而无需显式配置每一个依赖关系的方式。
Spring IoC 使用
时光
06-29 321
Spring IoC 使用
Spring IoC 快速使用入门
jason559的博客
01-21 139
目录一、启动 IoC 容器的方式：1、Java 环境下启动 IoC 容器：2、Web 环境下启动 IoC 容器：1）从 xml 启动容器；2）从配置类启动容器二、纯 xml 模式1、bean 对象的创建2、对象属性的依赖注入配置三、xml 与注解相结合模式1、注意2、xml 中标签与注解的对应（IoC）3、DI 依赖注入的注解实现方式1）@Autowired （推荐使用）2）@Resource3）注意：四、纯注解模式 一、启动 IoC 容器的方式： 1、Java 环境下启动 IoC 容器： ClassPa
Spring之IoC使用
zcg_741454897的博客
10-12 348
IOC简介 概念、优点网上一大堆，我只说下自己的见解。所谓控制反转IoC就是在开发过程中，不需要手动的new对象，而是把对象都交给Spring的IOC容器，由Spring容器来创建和注入到需要的相应对象的位置。 不使用SpringIoC的情况下举个例子：在传统的MVC模型中，用户Controller类会调用用户Service类，用户Service类调用用户Dao类，如果实现一个注册功能，需要有以下流程： Controller需要调用Service中的方法，所以Controller类中必须创建Service对
day2-Spring IOC 和 DI 注解开发.md
10-15
### Spring IOC与DI注解开发知识点详解 #### 一、Spring框架...通过以上内容，我们可以了解到Spring框架中IOC和DI的基本概念，以及如何配置和使用数据源（连接池）。这为开发高效稳定的企业级应用提供了坚实的基础。
【狂神说】Spring全面详细笔记.md
12-20
1. **Spring Core**：提供框架的基本组成部分，包括IoC容器的基础实现。 2. **Spring Context**：建立在Core之上，提供了一个配置文件的加载机制及事件传播机制。 3. **Spring AOP**：提供了面向切面编程的实现，让...
Spring笔记.md
04-17
通过上述示例可以看出，使用Spring框架的IoC机制可以极大地简化对象的创建和管理过程，使得代码更加简洁、易于维护。同时，Spring框架的AOP特性还可以帮助我们更好地处理一些横切关注点，提高代码的可重用性和可维护...
谈谈Spring IOC得理解，原理与实现.md
08-20
谈谈Spring IOC得理解，原理与实现.md
Spring IOC 使用笔记
weixin_46427348的博客
04-15 323
Spring框架 Spring框架概述 1.Spring 是轻量级的开源JavaEE 框架 2.Spring 可以解决企业应用开发的复杂性 3.Spring 有两个核心部分 IOC 和Aop IOC： 控制反转 把创建对象过程交给Spring 进行管理 Aop : 面向切面，不修改源代码进行功能增强 4.Spring 特点 1.方便解耦 简化开发 2.Aop 编程的支持 3.方便程序的测试 4.方便和其他框架进行整合 5.方便进行事物操作 6.减低API开发难度 ...
spring ioc原理（看完后大家可以自己写一个spring）
热门推荐
it_man的专栏
08-02 38万+
控制反转/依赖注入 最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。 先就IOC和DI谈一点我的看法。IOC（DI）：其实这个Spring架构核心的
详解Spring IOC的使用
Joker_ZJN的博客
03-22 686
一文详解Spring IOC的使用
javaEE学习笔记9-21
qq_44102239的博客
09-21 133
9-21优化的工厂模式控制反转（IOC）Spring的IOCSpring管理bean对象创建Bean对象bean的作用范围bean的生命周期依赖注入使用构造函数注入set方法注入 优化的工厂模式 不加修改时，循环地调用工厂模式，将产生多个对象。这组对象将单独，独立地调用自己的方法。 工厂利用反射创建对象的语句： bean=Class.forName(beanPath).newInstance(); 由于使用了newInstance()，每次调用都必然调用默认构造函数，创建新对象。 使用单例对象，避免创建大
Spring IOC使用
qq_42001445的博客
09-27 141
**Maven** 安装Maven，搭建环境变量 Maven获取jar包通过坐标定位：公司/组织(groupId)+项目名（artifactId）+版本(version) Maven仓库分为： 本地：自己的 <localRepository>路径 </localRepository> 私有：有的公司自己搭建自己的仓库 中央：默认国外，可以改成阿里的比较快 **配置：** 3层保险，默认中央仓库首选为阿里云，如果失败去外国仓库1找，还失败去外国2仓库找； <mirror&
Spring中IOC的使用
Programer0的博客
04-07 192
IOC的使用 [1]责任链 使用MVC设计思想进行开发的时候，数据在各层之间进行传递，数据在业务上构成一个链条， 这个链条称之为责任链。 [2]基于责任链开发的缺点 基于责任链开发模式，我们发现代码层和层之间相互调用，造成了层和层的耦合性太高了。 而写代码的时候讲究的原则--低耦合、高内聚 [3] 解决的方案 Spring IOC : ...
spring基础之二-＞Spring IOC基本使用
qq_22717543的博客
09-22 167
spring IOC基本使用 通过前面的介绍我们已经知道了Spring中非常重要的一个特性就是IOC,下面我们将要来看一下如何使用IOC容器，帮助大家更好的体会spring的优势。 1、spring_helloworld (1)使用手动加载jar包的方式实现，分为三个步骤，现在几乎不用 导包：导入这五个包即可 commons-logging-1.2.jar spring-beans-5.2.3.RELEASE.jar spring-context-5.2.3.RELEASE.jar spring-cor
Spring IOC深度解析：控制反转与Bean管理
"02Spring IOC.md" 在Spring框架中，IOC（Inversion of Control，控制反转）是一个核心概念，它将对象的创建和管理权交由Spring容器来处理，从而降低了组件之间的耦合度。控制反转的主要目的是提高软件组件的可重用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值