springIOC的使用流程及spring中使用类型转换器的方式

2023-06-13 09:06:58 作者：^迷藏^

Spring IOC是Spring框架的核心原理之一，它是一种软件设计模式，用于管理应用程序中的对象依赖关系，这篇文章主要介绍了springIOC的使用流程以及spring中如何使用类型转换器,需要的朋友可以参考下

一、Spring – 控制反转IOC

Spring IOC（Inversion of Control，控制反转）是Spring框架的核心原理之一。它是一种软件设计模式，用于管理应用程序中的对象依赖关系。

1. IOC的基本原理

在传统开发模式下：

对象的创建和依赖关系的管理通常由开发人员手动完成。

这种方式导致了高度耦合的代码，使得应用程序难以维护和扩展。

而Spring IOC通过控制对象的创建和依赖关系的注入，实现了对象之间的解耦。

所有的对象都交给IOC容器来管理，我们直接调用即可

基本原理：

Spring IOC的基本原理是将对象的控制权从应用程序代码中转移到框架中。

它通过配置文件或注解描述对象之间的依赖关系，然后由Spring框架负责创建和管理这些对象。

具体而言，Spring IOC的原理如下：

配置：首先，开发人员需要在配置文件（如XML文件）或使用注解的方式中描述对象及其依赖关系。这些配置文件包含了对象的定义、依赖关系以及其他相关的配置信息。
加载：Spring框架会读取配置文件，并根据配置信息创建对象的定义。这个过程通常称为"加载"或"解析"。
创建：一旦对象定义被加载，Spring框架将根据这些定义创建对象的实例。对象的创建过程由Spring容器负责管理，可以通过反射、工厂模式等方式进行对象的实例化。
注入：对象创建完成后，Spring框架会查找对象所依赖的其他对象，并将这些对象注入到目标对象中。这种依赖关系的注入可以通过构造函数、属性或方法进行。
管理：一旦对象被创建和注入依赖关系，Spring框架将负责管理这些对象的生命周期。它会跟踪对象的创建、使用和销毁，并在需要时进行适当的处理。

通过Spring IOC，开发人员可以将应用程序的业务逻辑与对象的创建和依赖管理解耦。这样可以提高代码的可维护性、可测试性和可扩展性，同时也降低了代码之间的耦合度，使得应用程序更加灵活和可配置。

需要注意的是，Spring框架提供了多种实现IOC的方式，包括XML配置、基于注解的配置和基于Java的配置等。开发人员可以根据实际需求选择适合的方式来实现IOC。

2.IOC的步骤 – 以XML格式为例

导入相关的依赖包

spring-core.jar：提供了Spring框架的核心功能，包括Bean定义、依赖注入等。
spring-beans.jar：包含了Spring框架的Bean工厂和Bean定义的相关类。
spring-context.jar：提供了Spring框架的应用上下文，包括IOC容器的实现。
spring-expression.jar：包含了Spring框架的表达式语言模块，用于支持在配置文件中使用表达式进行配置。

创建JavaBean：

package com.springIOC.pojo;
import java.util.Date;
/**
 * Author : YWJ
 * Date : 2023/6/9
 * Name : 框架
 */
public class Student {
    private String name ;
    private Integer age ;
    private String gender ;
    private Date birth ;
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", birth=" + birth +
                '}';
    }
}

在配置文件中编写对应该JavaBean的配置信息

<?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 = "testStudent" class = "com.springIOC.pojo.Student">
        <property name="name" value="测试"></property>
        <property name="age" value="18"></property>
        <property name="gender" value="男"></property>
        <property name="birth" value="2023-01-09"></property>
    </bean>
</beans>

测试

package com.springIOC;
import com.springIOC.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Author : YWJ
 * Date : 2023/6/9
 * Name : 框架
 */
public class test {
    @Test
    public void test01(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
        Student student = ac.getBean("testStudent", Student.class);
        System.out.println(student);
    }
}

IOC的实现步骤可总结为下：

配置Spring容器：首先，需要创建一个Spring容器来管理对象的创建和依赖关系。可以通过XML配置文件、基于注解的配置或者Java配置等方式进行配置。
定义Bean：在配置文件或者注解中定义需要由Spring容器管理的Bean对象。可以指定Bean的类名、作用域、依赖关系等信息。
加载配置：Spring框架会读取配置文件或者扫描注解，将配置信息加载到Spring容器中。这个过程可以通过XML解析、注解处理器等实现。
创建Bean实例：Spring容器根据配置信息，通过反射或者工厂模式等方式创建Bean对象的实例。
处理依赖注入：一旦Bean实例创建完成，Spring容器会解析Bean对象的依赖关系，将依赖的对象注入到目标Bean中。依赖注入可以通过构造函数注入、属性注入或者方法注入等方式实现。
管理Bean的生命周期：Spring容器会管理Bean对象的生命周期，包括初始化和销毁。可以通过初始化方法和销毁方法进行定义和配置。
获取Bean实例：在应用程序中，可以通过Spring容器来获取已经创建和管理的Bean实例。可以根据Bean的名称或者类型进行获取。

二、Spring类型转换器

在Spring框架中，类型转换器（Type Converter）用于将一个数据类型转换为另一个数据类型，以满足应用程序的需求。Spring提供

了多种类型转换器，包括内置的默认类型转换器和自定义的类型转换器。

1. 常见的类型转换器

String类型转换器：用于将String类型转换为其他基本数据类型（如int、boolean、double等）或自定义的对象类型。Spring默认提供了基本数据类型和常见的Java类的String转换器。

// 将String转换为int类型
String intString = "123";
int intValue = Integer.parseInt(intString);
// 将String转换为boolean类型
String booleanString = "true";
boolean booleanValue = Boolean.parseBoolean(booleanString);

数字类型转换器：用于在不同数字类型之间进行转换，如int、long、float、double等。

// 将String转换为double类型
String doubleString = "3.14";
double doubleValue = Double.parseDouble(doubleString);
// 将int转换为String类型
int intValue = 42;
String intString = Integer.toString(intValue);

日期类型转换器：用于处理日期和时间类型的转换，包括Java.util.Date、Java.time.LocalDate等。

// 使用@DateTimeFormat注解将String转换为LocalDate类型
public void setDateOfBirth(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate dateOfBirth) {
    this.dateOfBirth = dateOfBirth;
}
// 将LocalDate转换为String类型
LocalDate currentDate = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String dateString = currentDate.format(formatter);

集合类型转换器：用于将字符串或数组转换为集合类型，如List、Set、Map等。

// 将逗号分隔的字符串转换为List<Integer>类型
String numbers = "1,2,3,4,5";
List<Integer> numberList = Arrays.stream(numbers.split(","))
                                .map(Integer::parseInt)
                                .collect(Collectors.toList());
// 将数组转换为Set<String>类型
String[] fruitsArray = {"apple", "banana", "orange"};
Set<String> fruitSet = new HashSet<>(Arrays.asList(fruitsArray));

自定义类型转换器：开发人员可以实现自定义的类型转换器，以处理应用程序特定的数据类型转换需求。

自定义类型转换器需要实现org.springframework.core.convert.converter.Converter接口

或继承org.springframework.core.convert.converter.GenericConverter接口，

并注册到Spring容器中。

//自定义转化器
public class MyCustomConverter implements Converter<String, MyCustomType> {
    @Override
    public MyCustomType convert(String source) {
        // 自定义转换逻辑
        // 将String转换为MyCustomType对象
        // ...
    }
}

<!-- 注册到配置文件 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.example.MyCustomConverter" />
        </list>
    </property>
</bean>

//或者使用注解方式注册
@Configuration
public class MyConfiguration {
    @Bean
    public FormattingConversionServiceFactoryBean conversionService() {
        FormattingConversionServiceFactoryBean conversionService = new FormattingConversionServiceFactoryBean();
        conversionService.setConverters(Collections.singleton(new MyCustomConverter()));
        return conversionService;
    }
}

到此这篇关于springIOC的使用流程以及spring中如何使用类型转换器的文章就介绍到这了,更多相关spring类型转换器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！