框架体系——Spring

news2025/7/13 20:27:43

Spring IOC

IOC控制反转

  • IOC 控制反转，全称Inverse of Control，是一种设计理念
  • 由代理人来创建和管理对象，消费者通过代理人来获取对象
  • Ioc的目的是降低对象之间的耦合
  • 通过加入Ioc容器将对象统一管理，将对象关联变为弱耦合。
    在这里插入图片描述

DI依赖注入

  • IoC是设计理念，是现代程序设计遵循的标准，是宏观目标
  • DI(Dependency Injection)是具体技术实现，是微观实现。
  • DI在java中就是利用反射技术实现对象注入（Injection）

Spring

  • Spring可以从狭义和广义两个角度看待
  • 狭义的Spring是指Spring框架（Spring Framework）
  • 广义的Spring是指Spring生态体系

狭义的Spring框架

  • Spring框架是企业开发复杂性的一站式解决方案
  • Spring框架的核心是IoC容器与AoP面向切面编程
  • Spring IoC负责创建与管理系统对象，并在此基础上拓展功能

广义的Spring框架

Spring 全家桶，包括Spring data，springboot，springcloud等等

传统开发方式

  • 对象直接引用导致对象硬性关联，程序难以维护拓展
  • 在这里插入图片描述

Spring IoC容器

  • IoC容器是Spring生态的地基，用于统一创建与管理对象依赖
    在这里插入图片描述
    Spring IoC容器职责
  • 对象的控制权交由第三方统一管理
  • 利用Java反射技术实现运行时对象创建与关联（DI依赖注入）
  • 基于配置提高应用程序的可维护性与拓展性

Spring IoC初体验

需求：
在这里插入图片描述
下面是普通的代码实现，将child和apple进行强关联，这就出现了一个问题，灵活性不高，如果我想修改，就必须改动源代码

    public static void main(String[] args) {
        Apple apple1 = new Apple("红富士", "红色", "欧洲");
        Apple apple2 = new Apple("绿富士", "绿色", "绿大利");
        Apple apple3 = new Apple("蓝富士", "蓝色", "兰博基尼");
        Child lily = new Child("lily", apple1);
        Child andy = new Child("andy", apple2);
        Child luna = new Child("luna", apple3);
        lily.eat();
        andy.eat();
        luna.eat();
    }

针对这个问题，Spring应运而生，下面我们使用Spring来实现上述逻辑

Spring
首先，引入Spring的依赖

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

下面是几大重要的包
在这里插入图片描述

接着在resources下新建applicationContext.xml，增加配置如下：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--在IoC容器启动时，自动由Spring实例化Apple对象，取名sweetApple放入容器中-->
<bean id="sweetApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
    <property name="title" value="红富士"></property>
    <property name="origin" value="欧洲"></property>
    <property name="color" value="红色"></property>
</bean>

    <bean id="sourApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
        <property name="title" value="青苹果"></property>
        <property name="origin" value="中亚"></property>
        <property name="color" value="绿色"></property>
    </bean>

    <bean id="softApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
        <property name="title" value="金帅"></property>
        <property name="origin" value="中国"></property>
        <property name="color" value="黄色"></property>
    </bean>
</beans>

然后新建SpringApplication类，看看获取对象

package com.imooc.imooc.spring.ioc.eneity;

import com.imooc.imooc.spring.ioc.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/22 19:34
 * @Version 1.0
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
       Apple sweetApple =  context.getBean("sweetApple",Apple.class);
        System.out.println(sweetApple.getTitle());
    }
}

配置Bean的三种方式

Spring框架有三种配置Bean的方式，分别是 XML配置Bean） ，基于注解配置Bean，基于Java代码配置Bean
下面我们详细学习如何通过XML配置Bean；

实例化bean的三种方法

而使用XML配置bean，也有三种实例化Bean方法 基于构造方法对象实例化、基于静态工厂实例化、基于工厂实例方法实例化
在这里插入图片描述

下面是通过工厂类实例化对象，优势在于隐藏了对象创建的细节。
首先是配置：

 <bean id="apple4" class="com.imooc.spring.ioc.factory.AppleStaticFactory" factory-method="CreateSweetApple"/>

    <!-- 使用工厂实例创建对象-->
    <bean id="factoryInstance" class="com.imooc.spring.ioc.factory.ApplyFactoryInstance"></bean>
    <bean id="apple5" factory-bean="factoryInstance" factory-method="createSweetApple"/>

然后是两个工厂及其方法：

public class ApplyFactoryInstance {
    public Apple createSweetApple(){
        Apple apple =new Apple();
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        apple.setTitle("红富士");
        return apple;
    }
}


public class AppleStaticFactory {
    public static Apple CreateSweetApple(){
        Apple apple =new Apple();
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        apple.setTitle("红富士");
        return apple;
    }
}

初始化完成后，我们如何从Ioc容器中获取bean呢？有两种方式，分别如下：
在这里插入图片描述

另外，其实在xml中 bean有ID和Name两个属性，这两个属性有什么区别呢？
首先，我们来看看他们的相同点：

  • bean id 和name都是设置对象在IoC容器中的唯一标识
  • 两者在同一个配置文件中都不允许重复
  • 两者允许在多个配置文件中出现重复，新对象覆盖旧对象

两者不同点：

  • id要求更为严格，一次只能定义一个对象标识（推荐）
  • name更为宽松，一次允许定义多个对象标识
  • tips：id和name命名要求有意义，且驼峰命名
    除此之外，其实Spring还支持无ID/name属性，此时使用类名全路径作为唯一标识。

对象依赖注入

  • 依赖注入是指运行时将容器内对象利用反射赋给其他对象的操作
  • 基于Setter注入对象
  • 基于构造方法注入对象

IOC在项目中的重要用途

示例代码如下：
在这里插入图片描述

ApplicationContext-service.xml：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="bookService" class="com.imooc.spring.ioc.bookshop.service.BookService">
        <property name="bookDao" ref="bookDao"></property>
    </bean>
</beans>

ApplicationContext-dao.xml：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="com.imooc.spring.ioc.bookshop.dao.BookDaoImpl"></bean>
</beans>

BookDao

package com.imooc.spring.ioc.bookshop.dao;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:42
 * @Version 1.0
 */
public interface BookDao {
    public void insert();
}

BookDaoImpl

package com.imooc.spring.ioc.bookshop.dao;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:42
 * @Version 1.0
 */
public class BookDaoImpl implements BookDao{

    public void insert() {
        System.out.println("向Mysql Book 表插入一条数据");
    }
}

bookShopApplication

package com.imooc.spring.ioc.bookshop;

import com.imooc.spring.ioc.bookshop.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:47
 * @Version 1.0
 */
public class bookShopApplication {
    public static void main(String[] args) {
        ApplicationContext context =  new ClassPathXmlApplicationContext("classpath:ApplicationContext-*.xml");
        BookService bookService = context.getBean("bookService",BookService.class);
        bookService.purchase();
    }
}

实现对象依赖注入有两种方式：setter方法注入/构造方法注入

区别在于xml‘中bean参数 一个使用 property 一个使用 constructor-arg

注入集合对象

1. 注入List：
在这里插入图片描述

2. 注入set
在这里插入图片描述

3. 注入map
在这里插入图片描述

  1. 注入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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--list可重复-->
   <!-- <bean id="company" class="com.imooc.spring.ioc.entity.Company">
        <property name="rooms">
            <list>
                <value>2001-总裁办</value>
                <value>2003-总经理办公室</value>
                <value>2010-研发部会议室</value>
                <value>2010-研发部会议室</value>
            </list>
        </property>
    </bean>-->
<!-- set 可重复 -->
    <bean id="c1" class="com.imooc.spring.ioc.entity.Computer">
        <constructor-arg name="brand" value="联想"></constructor-arg>
        <constructor-arg name="type" value="台式机"></constructor-arg>
        <constructor-arg name="sn" value="8389283012"></constructor-arg>
        <constructor-arg name="price" value="3085"></constructor-arg>
    </bean>

    <bean id="company" class="com.imooc.spring.ioc.entity.Company">
        <property name="rooms">
            <set>
                <value>2001-总裁办</value>
                <value>2003-总经理办公室</value>
                <value>2010-研发部会议室</value>
                <value>2010-研发部会议室</value>
            </set>
        </property>

        <property name="computers">
            <map>
                <entry key="dev-880172" value-ref="c1"></entry>

                <entry key="dev-88173">
                    <bean class="com.imooc.spring.ioc.entity.Computer">
                        <constructor-arg name="brand" value="华为"></constructor-arg>
                        <constructor-arg name="type" value="笔记本"></constructor-arg>
                        <constructor-arg name="sn" value="8389283013"></constructor-arg>
                        <constructor-arg name="price" value="5085"></constructor-arg>
                    </bean>
                </entry>
            </map>
        </property>

        <property name="info">
            <props>
                <prop key="phone">010-12345678</prop>
                <prop key="address">湖北省武汉市xx中心</prop>
                <prop key="website">http:www.baidu.com</prop>
            </props>
        </property>
    </bean>
</beans>

查看容器内对象

示例代码：

package com.imooc.spring.ioc;

import com.imooc.spring.ioc.entity.Company;
import com.imooc.spring.ioc.entity.Computer;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 23:09
 * @Version 1.0
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:ApplicationContext.xml");
        Company company = context.getBean("company", Company.class);
        System.out.println(company);
        System.out.println(company.getInfo().getProperty("website"));
		// 获取容器内对象名称
        String[] beanNames = context.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            System.out.println(beanName);
            System.out.println("类型："+context.getBean(beanName).getClass().getName());
            System.out.println("内容："+context.getBean(beanName).toString());
        }
    }
}

bean scope属性

  • bean scope 属性用于决定对象核实被创建
  • bean scope 配置将影响容器内对象的数量
  • 默认情况下bean会在IoC容器创建后自动序列化，全局唯一

bean scope属性清单

在这里插入图片描述

singleton 与 prototype对比

在这里插入图片描述

bean的生命周期

在这里插入图片描述
配置示例：
在这里插入图片描述

实现极简IoC容器（模拟Spring实现流程）

首先是IOC容器类：
接口：

package com.imooc.spring.ioc.context;

/**
 * ApplicationContext 接口
 *
 * @Author wangw
 * @Date 2022/11/26 22:15
 * @Version 1.0
 */
public interface ApplicationContext {
    public Object getBean(String beanId);
}

实现类：

package com.imooc.spring.ioc.context;

import com.imooc.spring.ioc.entity.Apple;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ApplicationContext 实现类，本质就是一个IOC容器
 *
 * @Author wangw
 * @Date 2022/11/26 22:16
 * @Version 1.0
 */
public class ClassPathXmlApplicationContext implements ApplicationContext {
    private Map iocContainer = new HashMap();

    public ClassPathXmlApplicationContext() {
        try {
            String filePath = this.getClass().getResource("/applicationContext.xml").getPath();
            filePath = new URLDecoder().decode(filePath, "UTF-8");
            SAXReader reader = new SAXReader();
            Document document = reader.read(filePath);
            List<Node> nodes = document.getRootElement().selectNodes("bean");
            for (Node node : nodes) {
                Element element = (Element) node;
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                Class class1 = Class.forName(className);
                Object obj = class1.newInstance();
                List<Node> list = element.selectNodes("property");
                for (Node node1 : list) {
                    Element property = (Element) node1;
                    String propName = property.attributeValue("name");
                    String propValue = property.attributeValue("value");
                    String setMethodName ="set"+propName.substring(0,1).toUpperCase()+propName.substring(1);
                    System.out.println("准备执行"+setMethodName+"方法注入数据");
                    Method method = class1.getMethod(setMethodName,String.class);
                    method.invoke(obj,propValue);

                }
                iocContainer.put(id, obj);
                System.out.println("ioc容器初始化完毕");
                System.out.println(iocContainer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Object getBean(String beanId) {
        return iocContainer.get(beanId);
    }
}

配置XML:

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean id ="sweetApple" class="com.imooc.spring.ioc.entity.Apple">
        <property name="title" value="红富士"></property>
        <property name="origin" value="欧洲"></property>
        <property name="color" value="红色"></property>
    </bean>
</beans>

实体类：

package com.imooc.spring.ioc.entity;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/26 22:11
 * @Version 1.0
 */
public class Apple {
    private String title;
    private String color;
    private String origin;

    public Apple() {
    }

    public Apple(String title, String color, String origin) {
        this.title = title;
        this.color = color;
        this.origin = origin;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getOrigin() {
        return origin;
    }

    public void setOrigin(String origin) {
        this.origin = origin;
    }
}

启动类：

package com.imooc.spring.ioc;

import com.imooc.spring.ioc.context.ApplicationContext;
import com.imooc.spring.ioc.context.ClassPathXmlApplicationContext;
import com.imooc.spring.ioc.entity.Apple;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/26 22:27
 * @Version 1.0
 */
public class Application {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext();
        Apple apple = (Apple) context.getBean("sweetApple");
        System.out.println(apple);

    }
}

至此实现效果如下，可以看出其实Spring IoC容器就是通过反射实现的
在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MyBatis中有哪些注解呢？

MyBatis中有哪些注解呢？

转自: MyBatis中有哪些注解呢&#xff1f; 为了简化 XML 的配置&#xff0c;MyBatis 提供了注解。我们可以通过 MyBatis 的 jar 包查看注解&#xff0c;如下图所示。 以上注解主要分为三大类&#xff0c;即 SQL 语句映射、结果集映射和关系映射 下面分别进行讲解 一、SQL 语句…
阅读更多...
Allegro中如何进行尺寸标注

Allegro中如何进行尺寸标注

摘要本文介绍了如何在Allegro中进行尺寸标注&#xff0c;包含各种标注样式的区别、如何设置参数、如何显示单位、如何导出带尺寸的PDF与DXF等信息。 一. 为什么要尺寸标注PCB尺寸标注的作用&#xff1a; 方便设计人员明确板子的大小&#xff0c;以及安装位置的各种细节&#xf…
阅读更多...
react学习笔记3--数据双向绑定，组件通信

react学习笔记3--数据双向绑定，组件通信

一、表单处理 1、受控组件-input元素 通过设置input元素的value值&#xff08;或复选框的checked值&#xff09;实现Getter&#xff0c;通过监听onChange事件实现Setter&#xff0c;从而实现数据双向绑定。 class element extends React.Component {state {txt:""…
阅读更多...
vulhub靶场搭建与使用

vulhub靶场搭建与使用

vulhub靶场搭建与使用1.前言2.配置yum源2.1备份原来的源文件2.2 配置阿里源2.3重置yum源2.4更新yum源3.安装docket3.1安装docket3.2启动docket3.3设置国内镜像源3.4重启docket4.安装docker-compose4.1安装dockers-compose4.2提升权限5.安装vulhub5.1安装git5.2下载vulhub5.3下载…
阅读更多...
自知识蒸馏（知识蒸馏二）

自知识蒸馏（知识蒸馏二）

自知识蒸馏&#xff08;知识蒸馏二&#xff09;自知识蒸馏&#xff08;知识蒸馏二&#xff09;Born-Again Neural Networks&#xff08;ICML2018&#xff09;方法为什么有效实验结果Training Deep Neural Networks in Generations: A More Tolerant Teacher Educates Better St…
阅读更多...
MyBatis工作原理

MyBatis工作原理

MyBatis工作流程&#xff1a; 具体介绍&#xff1a; (1) MyBatis 读取核心配置文件mybatis-config.xml mybatis-config.xml核心配置文件主要配置了MyBatis的运行环境等信息。 (2)加载映射文件Mapper.xml Mapexm文件即SQL映射文件&#xff0c;该文件配置了操作数据库的SOL语句&a…
阅读更多...
Python+Appium移动端自动化测试框架实现

Python+Appium移动端自动化测试框架实现

一、Appium 概述 1、Appium 简介 Appium是一个开源的自动化测试框架，可以用来测试基于iOS、Android和Firefox OS 平台的原生与混合的应用。 该框架使用Selenium WebDriver，在执行测试时用于和Selenium Server 通信的是JSON Wire Protocol。在Selenium 2中，Appium将取代 i…
阅读更多...
【CNN】经典网络LeNet——最早发布的卷积神经网络之一

【CNN】经典网络LeNet——最早发布的卷积神经网络之一

前言 LeNet是Yann LeCun于1988年提出的用于数字识别的网络结构&#xff0c;可以说LeNet是深度CNN网络的基石&#xff0c;AlexNet、VGG、GoogLeNet、ResNet等都是在VGG基础上加入各类激活函数或加深网络演变而来的&#xff0c;所以理解LeNet对于现在主流CNN深度学习架构的理解有…
阅读更多...
制作一个简单HTML电影网页设计（HTML+CSS）

制作一个简单HTML电影网页设计（HTML+CSS）

HTML实例网页代码, 本实例适合于初学HTML的同学。该实例里面有设置了css的样式设置&#xff0c;有div的样式格局&#xff0c;这个实例比较全面&#xff0c;有助于同学的学习,本文将介绍如何通过从头开始设计个人网站并将其转换为代码的过程来实践设计。 文章目录一、网页介绍一…
阅读更多...
基于蚁群算法的多配送中心的车辆调度问题的研究（Matlab代码实现）

基于蚁群算法的多配送中心的车辆调度问题的研究（Matlab代码实现）

&#x1f468;‍&#x1f393;个人主页&#xff1a;研学社的博客 &#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜…
阅读更多...
【图像处理】小波编码图像中伪影和纹理的检测附Matlab代码和报告

【图像处理】小波编码图像中伪影和纹理的检测附Matlab代码和报告

✅作者简介&#xff1a;热爱科研的Matlab仿真开发者&#xff0c;修心和技术同步精进&#xff0c;matlab项目合作可私信。 &#x1f34e;个人主页&#xff1a;Matlab科研工作室 &#x1f34a;个人信条&#xff1a;格物致知。 更多Matlab仿真内容点击&#x1f447; 智能优化算法 …
阅读更多...
如果各位同学还对时间复杂度有疑问？看这一篇就可以啦！

如果各位同学还对时间复杂度有疑问？看这一篇就可以啦！

&#x1f387;&#x1f387;&#x1f387;作者&#xff1a; 小鱼不会骑车 &#x1f386;&#x1f386;&#x1f386;专栏&#xff1a; 《java练级之旅》 &#x1f393;&#x1f393;&#x1f393;个人简介&#xff1a; 一名专科大一在读的小比特&#xff0c;努力学习编程是我…
阅读更多...
chrome浏览器一键切换搜索引擎，一键切换谷歌和百度搜索

chrome浏览器一键切换搜索引擎，一键切换谷歌和百度搜索

chrome浏览器一键切换搜索引擎&#xff0c;一键切换谷歌和百度搜索 背景 有么有办法在谷歌和百度之间&#xff08;或其他引擎或非引擎&#xff0c;如Youtube、B站、Bing等&#xff09;之间切换。我们当然是不想重新输入keyword&#xff0c;甚至点击浏览器插件的图标后再选择引…
阅读更多...
Scala010--Scala中的常用集合函数及操作Ⅰ

Scala010--Scala中的常用集合函数及操作Ⅰ

之前我们已经知道了Scala中的数据结果有哪些&#xff0c;并且能够使用for循环取到该数据中的元素&#xff0c;现在我们再进一步的去了解更加方便及常用的函数操作&#xff0c;使得我们能够对集合更好的利用。 目录 一&#xff0c;foreach函数 1&#xff0c;遍历一维数组 1&…
阅读更多...
Pytorch中CrossEntropyLoss()详解

Pytorch中CrossEntropyLoss()详解

一、损失函数 nn.CrossEntropyLoss() 交叉熵损失函数 nn.CrossEntropyLoss() &#xff0c;结合了 nn.LogSoftmax() 和 nn.NLLLoss() 两个函数。 它在做分类&#xff08;具体几类&#xff09;训练的时候是非常有用的。 二. 什么是交叉熵 交叉熵主要是用来判定实际的输出与期望…
阅读更多...
HTML CSS个人网页设计与实现——人物介绍丁真(学生个人网站作业设计)

HTML CSS个人网页设计与实现——人物介绍丁真(学生个人网站作业设计)

&#x1f389;精彩专栏推荐&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb; ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业…
阅读更多...
SpringBoot SpringBoot 原理篇 1 自动配置 1.8 bean 的加载方式【六】

SpringBoot SpringBoot 原理篇 1 自动配置 1.8 bean 的加载方式【六】

SpringBoot 【黑马程序员SpringBoot2全套视频教程&#xff0c;springboot零基础到项目实战&#xff08;spring boot2完整版&#xff09;】 SpringBoot 原理篇 文章目录SpringBootSpringBoot 原理篇1 自动配置1.8 bean 的加载方式【六】1.8.1 ImportSelector1 自动配置 1.8 b…
阅读更多...
改进牛顿法潮流计算IEEE33节点潮流计算matlab程序——

改进牛顿法潮流计算IEEE33节点潮流计算matlab程序——

IEEE33节点潮流计算matlab程序——改进牛顿法潮流计算 改进牛顿法的基本原理 参考文献&#xff1a;一种新的配电网潮流算法——改进牛顿法-拉夫逊法 牛顿法是改进牛顿法的基础&#xff0c;对牛顿法作科学的近似&#xff0c;即雅可比矩阵做一些更改&#xff0c;使得每次计算得…
阅读更多...
stm32项目平衡车详解(stm32F407)下

stm32项目平衡车详解(stm32F407)下

stm32项目平衡车详解(stm32F407)下 HC-SRO4 超声波测距避障功能开发 TSL1401 CCD摄像头实现小车巡线功能 文章目录stm32项目平衡车详解(stm32F407)下前言一、HC-SRO4 超声波测距避障功能开发HC-SRO4超声波测距模块&#xff1f;超声波测距避障功能开发避障模式开发二、TSL1401 …
阅读更多...
【微软】【ICLR 2022】TAPEX：通过学习神经 SQL 执行器进行表预训练

【微软】【ICLR 2022】TAPEX：通过学习神经 SQL 执行器进行表预训练

重磅推荐专栏&#xff1a; 《Transformers自然语言处理系列教程》 手把手带你深入实践Transformers&#xff0c;轻松构建属于自己的NLP智能应用&#xff01; 论文&#xff1a;https://arxiv.org/abs/2107.07653 代码&#xff1a;https://github.com/microsoft/Table-Pretrainin…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023