Spring见解 1.2

2.3.Spring的IOC解决程序耦合

2.3.1.创建工程

在这里插入图片描述

2.3.1.1.pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.by</groupId>
    <artifactId>Spring_IOC_Xml</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <properties>
        <!-- 项目源码及编译输出的编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!-- 项目编译JDK版本 -->
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    
    <dependencies>
        <!-- Spring常用依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
    </dependencies>
</project>

注意：Jar包彼此存在依赖，只需引入最外层Jar即可由Maven自动将相关依赖Jar引入到项目中。

Spring常用功能的Jar包依赖关系
在这里插入图片描述

​ 核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。

  • spring-beans和spring-core模块是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
  • spring-context模块构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
  • spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。
2.3.1.2.dao
/**
 * 持久层实现类
 */
public class UserDaoImpl implements UserDao {

    @Override
    public void addUser(){
        System.out.println("insert into tb_user......");
    }
}
2.3.1.3.service
/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {
    //此处有依赖关系
    private UserDao userDao = new UserDaoImpl();

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

2.3.2.IOC

2.3.2.1.applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    
    <!--
		2、把对象交给spring来创建
       		id：给对象在容器中提供一个唯一标识。用于获取对象	
		   	class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数
	-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <bean id="userService" class="com.by.service.UserServiceImpl"></bean>
</beans>

注意：命名无限制，约定俗成命名有：spring-context.xml、applicationContext.xml、beans.xml

2.3.2.2.测试
/**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        //1.使用ApplicationContext接口，就是在获取spring容器
        ApplicationContext ac = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        //2.根据bean的id获取对象
        UserDao userDao = (UserDao) ac.getBean("userDao");
        System.out.println(userDao);

        UserService userService = (UserService) ac.getBean("userService");
        System.out.println(userService);
        userService.addUser();
    }
}
  • 问题：service层仍然耦合

2.3.3.DI

概述：DI（Dependency Injection）依赖注入，在Spring创建对象的同时，为其属性赋值，称之为依赖注入。

2.3.3.1.构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。具体代码如下：

/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String name;
    private Integer age;

    public UserServiceImpl(UserDao userDao, String name, Integer age) {
        this.userDao = userDao;
        this.name = name;
        this.age = age;
    }

    public void addUser(){
        System.out.println(name+","+age);
        userDao.addUser();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    <!--2、把对象交给spring来创建-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <bean id="userService" class="com.by.service.UserServiceImpl">
        <!--
               要求：类中需要提供一个对应参数列表的构造函数。
               标签：constructor-arg
                       ==给谁赋值:==
				           index:指定参数在构造函数参数列表的索引位置
				           name:指定参数在构造函数中的名称
				       ==赋什么值:==
				           value:它能赋的值是基本数据类型和String类型
				           ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
        -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
    </bean>
</beans>
2.3.3.2.set方法注入

顾名思义，就是在类中提供需要注入成员的set方法。具体代码如下：

/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String name;
    private Integer age;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void addUser(){
        System.out.println(name+","+age);
        userDao.addUser();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    <!--2、把对象交给spring来创建-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <bean id="userService" class="com.by.service.UserServiceImpl">
        <!--
               要求：property
               标签：constructor-arg
                       ==给谁赋值:==
				           name:找的是类中set方法后面的部分
				       ==赋什么值:==
				           value:它能赋的值是基本数据类型和String类型
				           ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
        -->
        <property name="userDao" ref="userDao"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="18"></property>
    </bean>
</beans>
2.3.3.3.自动注入

不用在配置中 指定为哪个属性赋值，由spring自动根据某个 “原则” ，在工厂中查找一个bean并为属性注入值。具体代码如下：

/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    <!--2、把对象交给spring来创建-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
        <!--autowire="byType"：按照类型自动注入值-->
    <bean id="userService" class="com.by.service.UserServiceImpl" autowire="byType">
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    <!--2、把对象交给spring来创建-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <!--autowire="byType"：按照类型自动注入值-->
    <bean id="userService" class="com.by.service.UserServiceImpl" autowire="byName">
    </bean>
</beans>
2.3.3.4.注入集合类型的属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map。具体代码如下：

/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void addUser(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        userDao.addUser();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!--1、注意：要导入schema约束-->
<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">
    <!--2、把对象交给spring来创建-->
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <bean id="userService" class="com.by.service.UserServiceImpl">
        <!--
                要求：property
                标签：constructor-arg
                        ==给谁赋值:==
				            name:找的是类中set方法后面的部分
				        ==赋什么值:==
				            value:它能赋的值是基本数据类型和String类型
				            ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
        -->
        <property name="userDao" ref="userDao"></property>
        <!-- 给mySet集合注入数据 -->
        <property name="mySet">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>
        <!-- 注入array数组数据 -->
        <property name="myArray">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <!-- 注入list集合数据 -->
        <property name="myList">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>
        <!-- 注入Map数据 -->
        <property name="myMap">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB" value="bbb"></entry>
            </map>
        </property>
    </bean>
</beans>

2.4.Spring中的工厂类

2.4.1.ApplicationContext

  • ApplicationContext的实现类，如下图：

    • ClassPathXmlApplicationContext：加载类路径下 Spring 的配置文件
    • FileSystemXmlApplicationContext：加载本地磁盘下 Spring 的配置文件

2.4.2.BeanFactory

  • spring中工厂的类结构图

  • 区别：

    • ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

      /**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("UserServiceImpl对象创建了...");
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

      /**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("Spring IOC容器创建好了");
    }
}

  • BeanFactory：是在 getBean 的时候才会创建对象。

    /**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("UserServiceImpl对象创建了...");
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

    /**
* 模拟表现层
*/
public class Client {
  public static void main(String[] args) {
      new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
      System.out.println("Spring IOC容器创建好了");
  }
}

2.5.bean的作用范围

2.5.1.概述

  • 在Spring中，bean作用域用于确定bean实例应该从哪种类型的Spring容器中返回给调用者。

2.5.2.五种作用域

  • 目前Spring Bean的作用域或者说范围主要有五种：

    作用域说明
    singleton默认值，Bean以单例方式存在spring IoC容器
    prototype每次从容器中调用Bean时都返回一个新的实例，相当于执行newInstance()
    requestWEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 request 域中
    sessionWEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 session 域中
    applicationWEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 ServletContext 域中

  • 可以通过 <bean> 标签的scope 属性控制bean的作用范围，其配置方式如下所示：

    <bean id="..." class="..." scope="singleton"/>

  • 需要根据场景决定对象的单例、多例模式

    单例：Service、DAO、SqlSessionFactory（或者是所有的工厂）

    多例：Connection、SqlSession

2.6.bean的生命周期

2.6.1.单例bean

  • 案例

    <bean id="userService" class="com.by.service.UserServiceImpl"
      			scope="singleton" init-method="init" destroy-method="destroy">

    /**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("调用构造方法创建bean...");
    }

    public void setUserDao(UserDao userDao) {
        System.out.println("调用set方法注入值...");
        this.userDao = userDao;
    }

    public void init(){
        System.out.println("调用init方法初始化bean...");
    }

    public void destroy(){
        System.out.println("调用destroy方法销毁bean...");
    }

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

    /**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac = 
        	new ClassPathXmlApplicationContext("applicationContext.xml");
        //关闭容器
        ac.close();
    }
}

  • 生命周期：

    [容器启动]—>构造方法(实例化)—>set方法(注入)—>init方法(初始化)—>[容器关闭]—>destroy方法(销毁)

2.6.2.多例bean

  • 案例

    <bean id="userService" class="com.by.service.UserServiceImpl"
      			scope="prototype" init-method="init" destroy-method="destroy">

    /**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("调用构造方法创建bean...");
    }

    public void setUserDao(UserDao userDao) {
        System.out.println("调用set方法注入值...");
        this.userDao = userDao;
    }

    public void init(){
        System.out.println("调用init方法初始化bean...");
    }

    public void destroy(){
        System.out.println("调用destroy方法销毁bean...");
    }

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

    /**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac = 
            	new ClassPathXmlApplicationContext("applicationContext.xml");
        //使用对象
        ac.getBean("userService");
    }
}

  • 生命周期：

    [使用对象]---->构造方法(实例化)—>set方法(注入)—>init方法(初始化)—>[JVM垃圾回收]—>destroy方法(销毁)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/292657.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

vue3 插槽 slot 使用

vue3 插槽 slot 使用

vue3 插槽 slot 使用 在 Vue3 中&#xff0c;插槽&#xff08;slot&#xff09;是一种重要的组件复用和内容分发机制。通过使用插槽&#xff0c;可以让组件更加灵活和具有可复用性&#xff0c;在不同的地方渲染不同的内容&#xff0c;同时保证相同的样式。 插槽资料 官网介绍&…
阅读更多...
分布式（10）

分布式（10）

目录 46.什么是Session Replication? 47.什么是Session数据集中存储&#xff1f; 48.什么是Cookie Based Session? 49.什么是JWT&#xff1f;使用JWT的流程&#xff1f;对比传统的会话有啥区别&#xff1f; 50.如何设计一个秒杀系统&#xff1f; 51.接口设计要考虑哪…
阅读更多...
地址变量与函数进阶

地址变量与函数进阶

指针与函数的高级用法 1.数组2.函数的重载3.函数的指针类型参数4.可变参数函数链表5.函数指针6.指针函数7.内联函数8.总结 在上节中我们简单谈论了指针变量&#xff0c;这节我们就来讨论指针变量的实际应用。 1.数组 相信有一定C语言基础的小伙伴一定很熟悉这个类型。数组可以…
阅读更多...
Node.js(四)-express

Node.js(四)-express

1. 初识express 1.1 express简介 1.1.1 什么是express 官方&#xff1a;Express是基于Node.js平台&#xff0c;快速、开放、极简的web开发框架。 通俗&#xff1a;Express的作用和Node.js内置的http模块类似&#xff0c;是专门用来创建web服务器的。 express的本质&#xff1…
阅读更多...
KNN 分类（选择最佳的 K 值，并可视化模型精度与 n_neighbors 的关系）

KNN 分类（选择最佳的 K 值，并可视化模型精度与 n_neighbors 的关系）

import matplotlib.pyplot as plt from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier# 导入乳腺癌数据集 cancer load_breast_cancer()# 划分训练集和测试集 X_tra…
阅读更多...
函数作用域和块级作用域

函数作用域和块级作用域

(1)Es5之前的作用域 在Es5之前只有全局作用域和函数作用域。 (1)全局作用域 范围:在winodw全局里面都生效 例子: for(var i0;i<5;i){}console.log(window.ii); 返回的结果是:True (2)函数作用域 范围:在这个函数里面生效 例子: function fn(b) {console.log(b);}con…
阅读更多...
如何配置Zabbix告警邮件通知并基于GPT提供解决方案？

如何配置Zabbix告警邮件通知并基于GPT提供解决方案？

一、概述 时间来到2023年末&#xff0c;距离Open AI发布GPT-3.5&#xff0c;首次向公众推出ChatGPT已经整整过去了一年。如今&#xff0c;以ChatGPT为代表的人工智能模型已然被应用众多领域&#xff0c;当然也包括IT运维。在IT运维中&#xff0c;通过对接运维监控平台&#xff…
阅读更多...
类和对象之拜访对象村

类和对象之拜访对象村

类和对象 1.面向对象的初步认知 ————&#xff08;进入对象村&#xff09;1.1为什么称为对象村1.2面向对象和面向过程 2.类的定义和使用————&#xff08;这个陌生人是谁&#xff1f;&#xff09;2.1简单认识类2.2类的定义格式2.3定义一个狗类 3.类的实例化之new一个“对…
阅读更多...
Plugin ‘org.springframework.boot:spring-boot-maven-plugin:‘ not found

Plugin ‘org.springframework.boot:spring-boot-maven-plugin:‘ not found

IDEA创建spring boot项目的时候&#xff0c;pom.xml 文件中spring-boot-maven-plugin报红。 解决方法&#xff1a; 给spring-boot-maven-plugin指定版本 原因&#xff1a; idea自动找的插件版本是其他版本的&#xff0c;和自己设置的不同&#xff0c;导致idea在本地maven仓库…
阅读更多...
深入解析JMeter响应断言功能

深入解析JMeter响应断言功能

JMeter 是一个功能强大的性能测试工具&#xff0c;它可以模拟大量用户并发访问网站或应用程序&#xff0c;以测试其性能和稳定性。在进行性能测试时&#xff0c;我们需要对响应结果进行断言&#xff0c;以确保应用程序或网站的功能和性能符合预期。 在 JMeter 中&#xff0c;响…
阅读更多...
Spring之强大的DefaultListableBeanFactory

Spring之强大的DefaultListableBeanFactory

系列文章目录 如何查看类继承结构参考这里 文章目录 系列文章目录一、DefaultListableBeanFactory的类继承实现结构二、实现接口 一、DefaultListableBeanFactory的类继承实现结构 二、实现接口 AliasRegistry&#xff1a;支持别名功能&#xff0c;一个名字可以对应多个别名B…
阅读更多...
SpringBoot整合sentinel

SpringBoot整合sentinel

1、引入依赖 <dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-sentinel</artifactId> </dependency> 2、 配置文件添加 spring:cloud:sentinel:transport:dashboard: ip:8858 项目重启&#x…
阅读更多...
[PyTorch][chapter 9][李宏毅深度学习][CNN]

[PyTorch][chapter 9][李宏毅深度学习][CNN]

前言&#xff1a; 卷积神经网络&#xff08;Convolutional Neural Networks&#xff09;是一种深度学习模型或类似于人工神经网络的多层感知器&#xff0c;常用来分析视觉图像。卷积神经网络的创始人是着名的计算机科学家Yann LeCun&#xff0c;目前在Facebook工作&#xff0c;…
阅读更多...
Time-series forecasting with deep learning: a survey

Time-series forecasting with deep learning: a survey

人们开发了许多深度学习架构来适应不同领域的时间序列数据集的多样性。在本文中&#xff0c;我们调查了一步前进和多水平时间序列预测中使用的常见编码器和解码器设计&#xff0c;描述了如何将时间信息纳入每个模型的预测中。接下来&#xff0c;我们重点介绍混合深度学习模型的…
阅读更多...
数据结构【排序篇】

数据结构【排序篇】

数据结构【排序篇】 文章目录 数据结构【排序篇】前言为什么突然想学算法了&#xff1f;为什么选择码蹄集作为刷题软件&#xff1f; 目录一、插入排序二、交换排序三、 选择排序四、归并排序和基数排序 结语 前言 为什么突然想学算法了&#xff1f; > 用较为“官方”的语言讲…
阅读更多...
SpringIOC之support模块DefaultMessageSourceResolvable

SpringIOC之support模块DefaultMessageSourceResolvable

博主介绍&#xff1a;✌全网粉丝5W&#xff0c;全栈开发工程师&#xff0c;从事多年软件开发&#xff0c;在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战&#xff0c;博主也曾写过优秀论文&#xff0c;查重率极低&#xff0c;在这方面有丰富的经验…
阅读更多...
【ITK库学习】使用itk库进行图像配准：变换Transform（三）

【ITK库学习】使用itk库进行图像配准：变换Transform（三）

目录 1、itkAffineTransform 仿射变换2、itkBSplineDeformableTransform B样条可变形变换 1、itkAffineTransform 仿射变换 该类实现向量空间的仿射变换&#xff08;例如空间坐标&#xff09; 此类允许定义和操作n维仿射空间&#xff08;及其关联的向量空间&#xff09;对其自…
阅读更多...
QT C++调用python传递RGB图像和三维数组，并接受python返回值(图像)

QT C++调用python传递RGB图像和三维数组，并接受python返回值(图像)

目的&#xff1a; 用QT调用python代码&#xff0c;将QT读取的图像(Qimage)作为参数传入python中&#xff0c;将QT的三维数组作为参数传递给python&#xff0c;python接收QT传入的图像进行计算&#xff0c;将结果返回给QT并显示。 一 .pro 头文件的配置&#xff0c;和lib库的…
阅读更多...
在 Mac 上轻松安装和配置 JMeter

在 Mac 上轻松安装和配置 JMeter

Apache JMeter 是一个开源的负载测试工具&#xff0c;可以用于测试静态和动态资源&#xff0c;确定服务器的性能和稳定性。在本文中&#xff0c;我们将讨论如何下载和安装 JMeter。 安装 Java&#xff08;已安装 Java 的此步骤可跳过&#xff09; 要安装 Java&#xff0c;请按…
阅读更多...
数字孪生与边缘计算的结合

数字孪生与边缘计算的结合

数字孪生与边缘计算的结合可以在物理实体附近进行实时数据处理和决策&#xff0c;从而提高响应速度、降低延迟&#xff0c;并有效地利用边缘资源。以下是数字孪生在边缘计算中的一些应用&#xff0c;希望对大家有所帮助。北京木奇移动技术有限公司&#xff0c;专业的软件外包开…
阅读更多...
最新文章

Copyright @ 2022~2023