Spirng-IOC零碎知识点

Spirng IOC

依赖注入

  • 根据名称注入
<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsd"><bean id="foo" class="com.liyong.learn.inject.Foo"><property name="name" value="liyong"></property><property name="age" value="22"></property></bean><bean id="foo1" class="com.liyong.learn.inject.Foo"><property name="name" value="liyong1`"></property><property name="age" value="221"></property></bean><bean id="bar" class="com.liyong.learn.inject.Bar"><property name="name" value="liyong"></property><property name="age" value="22"></property><property name="addr" value="cq"></property></bean><bean id="list" class="com.liyong.learn.inject.ListFoo"><property name="list"><!-- 注入List --><util:list><ref bean="foo"></ref><ref bean="foo1"></ref></util:list></property></bean>
</beans>

注入的时候也可以直接注入：

<bean id="list" class="com.liyong.learn.inject.ListFoo" autowire="byType"></bean>

<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd"><!-- 导入资源 --><import resource="beans.xml"></import>
</beans>

public static void main(String[] args) {BeanFactory beanFactory = new ClassPathXmlApplicationContext("inject.xml");Bar bean = beanFactory.getBean(Bar.class);System.out.println(bean);ListFoo listFoo = beanFactory.getBean(ListFoo.class);listFoo.getList().stream().forEach(System.out::println);
}

重点关注util 注入和byType注入

  • 根据Bean类型注入
    • 单个Bean对象
    • 集合Bean对象
  • 注入非Bean对象
  • 注入容器内建Bean对象
  • 注入类型
    • 实时注入
    • 延迟注入
public class ListFoo {private Collection<Foo> list;private BeanFactory beanFactory;private ObjectFactory<ApplicationContext> objectFactory;
}

public static void main(String[] args) {BeanFactory beanFactory = new ClassPathXmlApplicationContext("inject.xml");Bar bean = beanFactory.getBean(Bar.class);System.out.println(bean);ListFoo listFoo = beanFactory.getBean(ListFoo.class);listFoo.getList().stream().forEach(System.out::println);System.out.println(listFoo.getBeanFactory());// false 这里注入的bean 并不是beanFactorySystem.out.println(beanFactory == listFoo.getBeanFactory());// 输出为 DefaultListableBeanFactorySystem.out.println(listFoo.getBeanFactory().getClass());// 会错误 没有这个bean 说明我们依赖注入和依赖查找并不是同源的beanFactory.getBean(BeanFactory.class);System.out.println(beanFactory == listFoo.getObjectFactory().getObject());
}

SpirngIOC 依赖来源

  • 自定义Bean（配置的bean xml 或者注解）
  • 容器内建对象（例如Environment Bean 容器默认初始化）
  • 容器内建依赖（比如上面例子中的BeanFactory就是内建依赖）

Spring配置元信息

  • bean定义配置
    • 基于XML
    • 基于Properties文件
    • 基于Java注解
    • 基于JavaAPI
  • IOC容器配置
    • 基于XML文件
    • 基于Java注解
    • 基于JavaAPI
  • 外部化配置
    基于Java注解

BeanFactory还是ApplicationContext？

// 为什么这个表达式不会成立呢？因为他们是两个不同的对象 他们只是复用同一个接口
System.out.println(beanFactory == listFoo.getBeanFactory());

ApplicationContext是BeanFactory的一个超集,提供了更多企业级的功能。通过源码也可以看到我们下面的ApplicationContext是通过组合进来了一个BeanFactory。
在这里插入图片描述

BeanFactory 与 ApplicationContext的对比
官网推荐我们使用ApplicationContext,因为BeanFactory 有的能力BeanFactory都有

ApplicationContext 除了IOC容器角色还提供那些特性？
  • 面向切面AOP
  • 配置元信息
  • 资源管理
  • 事件
  • 国际化
  • 注解
  • Environment抽象
使用BeanFactory 与 ApplicationContext

1 XML的方式使用
直接使用，但是这样的话就不会提供事件机制比如BeanPostProcessor

DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions("inject.xml");
Bar bean = factory.getBean(Bar.class);
// 如果需要支持BeanPostProcessor 通过下面的方式进行设置
factory.addBeanPostProcessor(new MyBeanPostProcessor());

2 注解的方式使用

@Configuration
public class Main {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(Main.class);context.refresh();Bar bean = context.getBean(Bar.class);System.out.println(bean);}@Beanpublic Bar initBar() {return new Bar();}
}

SpringIOC容器生命周期

1 启动

public void refresh() throws BeansException, IllegalStateException {
// 加锁 因为不确定是单线程还是在多线程的环境中会创建 ApplicationContext
synchronized (this.startupShutdownMonitor) {// Prepare this context for refreshing.prepareRefresh();// Tell the subclass to refresh the internal bean factory.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// Prepare the bean factory for use in this context.// 内建对象prepareBeanFactory(beanFactory);try {// Allows post-processing of the bean factory in context subclasses.postProcessBeanFactory(beanFactory);// Invoke factory processors registered as beans in the context.invokeBeanFactoryPostProcessors(beanFactory);// Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);// Initialize message source for this context.initMessageSource();// Initialize event multicaster for this context.initApplicationEventMulticaster();// Initialize other special beans in specific context subclasses.onRefresh();// Check for listener beans and register them.registerListeners();// Instantiate all remaining (non-lazy-init) singletons.finishBeanFactoryInitialization(beanFactory);// Last step: publish corresponding event.finishRefresh();}catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}// Destroy already created singletons to avoid dangling resources.destroyBeans();// Reset 'active' flag.cancelRefresh(ex);// Propagate exception to caller.throw ex;}finally {// Reset common introspection caches in Spring's core, since we// might not ever need metadata for singleton beans anymore...resetCommonCaches();}
}
}

2 停止

protected void doClose() {// Check whether an actual close attempt is necessary...if (this.active.get() && this.closed.compareAndSet(false, true)) {if (logger.isDebugEnabled()) {logger.debug("Closing " + this);}LiveBeansView.unregisterApplicationContext(this);try {// Publish shutdown event.publishEvent(new ContextClosedEvent(this));}catch (Throwable ex) {logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);}// Stop all Lifecycle beans, to avoid delays during individual destruction.if (this.lifecycleProcessor != null) {try {this.lifecycleProcessor.onClose();}catch (Throwable ex) {logger.warn("Exception thrown from LifecycleProcessor on context close", ex);}}// Destroy all cached singletons in the context's BeanFactory.destroyBeans();// Close the state of this context itself.closeBeanFactory();// Let subclasses do some final clean-up if they wish...onClose();// Reset local application listeners to pre-refresh state.if (this.earlyApplicationListeners != null) {this.applicationListeners.clear();this.applicationListeners.addAll(this.earlyApplicationListeners);}// Switch to inactive.this.active.set(false);}}

BeanFactory 是容器 区别于 FactoryBean
FactoryBean 是 Spring 框架提供的一种特殊的工厂 Bean 接口，用于创建复杂的 Bean 对象。与普通的 Bean 不同，FactoryBean 实现类不直接返回实例化的 Bean 对象，而是通过工厂方法来创建 Bean 实例。这样可以为 Bean 的创建和初始化过程提供更多的灵活性和控制。
下面是一些 FactoryBean 的主要用途和特点：

  • 定制化实例化逻辑：通过实现 FactoryBean 接口，你可以自定义创建 Bean 实例的逻辑，包括可能需要的条件判断、初始化过程和配置管理等。
  • 延迟初始化：FactoryBean 可以实现延迟加载，即在需要时才实际创建对象，而不是在应用启动时就建。
  • 装饰器模式：通过 FactoryBean，你可以实现装饰器模式，对原始 Bean 进行一些额外的处理或包装。
  • 对象的复用：FactoryBean 可以控制对象的创建与返回，从而实现对象的重用，避免重复创建实例。
  • 提供灵活性：FactoryBean 的存在使得 Spring 容器中的 Bean 创建更加灵活，可以根据需求定制不同的创建逻辑。

BeanDefinition 元信息

在这里插入图片描述
1 定义bean

// 1 通过 BeanDefinitionBuilder 构建
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(Foo.class);
builder.addPropertyValue("name", "liyong");
builder.addPropertyValue("age", 11);
// 这里还可以对 beanDefinition 进行修改
BeanDefinition beanDefinition = builder.getBeanDefinition();
//2  通过 AbstractBeanDefinition 以及派生类
GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
// 设置Bean类型
genericBeanDefinition.setBeanClass(Foo.class);
MutablePropertyValues values = new MutablePropertyValues();
values.addPropertyValue("name", "liyong");
values.addPropertyValue("age", 11);
genericBeanDefinition.setPropertyValues(values);

2 命名Bean

  • 命名规范可以按照参数的命名规范（xml一般自定义名称比较多）
  • DefaultBeanNameGenerator 是Spirng提供的一个API用于生成BeanName
  • AnnotationBeanNameGenerator 基于注解扫描的BeanNameGenerator实现

3 别名Bean

<!--  将 foo -> 映射别名 aliasFoo  -->
<alias name="foo" alias="aliasFoo"></alias>

BeanFactory beanFactory = new ClassPathXmlApplicationContext("beans.xml");
Foo aliasFoo = (Foo) beanFactory.getBean("aliasFoo");
Foo foo = (Foo) beanFactory.getBean("foo");
System.out.println(foo == aliasFoo);

注册BeanDefinition

1 xml配置
2 注解配置元信息
@Bean
@Component
@Import
通过注解我们的Bean，Spring容器不会重复注册同样的bean

@Import({Demo.Config.class})
public class Demo {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(Demo.class);context.refresh();// 通过 命名生产器生成的 如果没有生成兜底策略为类名称Map<String, Config> beansOfType = context.getBeansOfType(Config.class);System.out.println(beansOfType);Map<String, Bar> barMap = context.getBeansOfType(Bar.class);System.out.println(barMap);context.close();}@Componentstatic class Config {@Beanpublic Bar userBean() {Bar bar = new Bar();bar.setAddr("fdsa");bar.setName("li");bar.setAge(10);return bar;}}
}

在这里插入图片描述
3 Java Api 配置元信息

  • BeanDefinitionRegistry#registerBeanDefinition （用于命名方式）
  • BeanDefinitionReaderUtils#registerWithGeneratedName （用于非命令方式）
  • AnnotatedBeanDefinitionReader（配置类的方式）
  public static void registerFooBeanDefinition(BeanDefinitionRegistry registry, String beanName) {BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(Bar.class);builder.addPropertyValue("name", "liyong");builder.addPropertyValue("age", 20);if (StringUtils.hasText(beanName)) {registry.registerBeanDefinition(beanName, builder.getBeanDefinition());} else {BeanDefinitionReaderUtils.registerWithGeneratedName(builder.getBeanDefinition(), registry);}}

实例化Spring Bean

  • Bean 实例化
    • 常规方式
      • 通过构造器（配置元信息：XML，Java注解和Java API）
      • 通过静态工厂方法（配置元信息：XML 和 Java API）
      • 通过Bean工厂方法（配置元信息：XML 和 Java API）
      • 通过FactoryBean （配置元信息：XML，Java注解和Java API）
    • 特殊方式
      • 通过ServiceLoaderFactoryBean(配置元信息：XML，Java注解和Java API)
      • 通过AutowireCapableBeanFactory#createBean(Class,boolean)
      • 通过BeanDefinitionRegistry#registerBeanDefinition(String,BeanDefiniton)
        通过静态方法
 <bean id="developer" class="com.liyong.learn.createbean.HighDeveloper" factory-method="createDeveloper"></bean>

在类里面定义静态的构造Bean的方法如下，省略get,set

public class HighDeveloper {private String name;private Integer salary;public HighDeveloper() {}public HighDeveloper(String name, Integer salary) {this.name = name;this.salary = salary;}@Overridepublic String toString() {return "HighDeveloper{" +"name='" + name + '\'' +", salary=" + salary +'}';}public static HighDeveloper createDeveloper() {HighDeveloper developer = new HighDeveloper();developer.setName("ly");developer.setSalary(15 * 15);return developer;}
}

通过Bean工厂方法

<bean id="developer" class="com.liyong.learn.createbean.HighDeveloper" factory-method="createDeveloper"></bean>
<bean id="developerFactory" class="com.liyong.learn.createbean.DefaultDeveloperCreateFactory"></bean>
<bean id="developerByFc" class="com.liyong.learn.createbean.HighDeveloper" factory-bean="developerFactory" factory-method="createDeveloper"></bean>

BeanFactory beanFactory = new ClassPathXmlApplicationContext("bean-create.xml");
HighDeveloper developer = beanFactory.getBean("developer", HighDeveloper.class);
HighDeveloper developerFc = beanFactory.getBean("developerByFc", HighDeveloper.class);
System.out.println(developer);
System.out.println(developerFc);
System.out.println(developer == developerFc);

通过FactoryBean
这里和上面有所区别，这里我们只需要定义工厂就行了，不需要先定义工厂，然后还要定义具体的bean来指定实现工厂。

<bean id="developer-by-factory-bean"  class="com.liyong.learn.createbean.DeveloperFactoryBean"></bean>

HighDeveloper developerFcBean = beanFactory.getBean("developer-by-factory-bean", HighDeveloper.class);

通过ServiceLoaderFactoryBean的方式

public static void main(String[] args) {BeanFactory beanFactory = new ClassPathXmlApplicationContext("bean-create.xml");// 基于xml配置的beanServiceLoader<DeveloperCreateFactory> bean = beanFactory.getBean(ServiceLoader.class);Iterator<DeveloperCreateFactory> it = bean.iterator();while (it.hasNext()) {DeveloperCreateFactory next = it.next();System.out.println(next.createDeveloper());}// ServiceLoader 加载的beanServiceLoader<DeveloperCreateFactory> load = ServiceLoader.load(DeveloperCreateFactory.class, Thread.currentThread().getContextClassLoader());Iterator<DeveloperCreateFactory> iterator = load.iterator();while (iterator.hasNext()) {DeveloperCreateFactory next = iterator.next();System.out.println(next.createDeveloper());}
}

基于xml

<bean id="developerFactoryServiceLoader" class="org.springframework.beans.factory.serviceloader.ServiceLoaderFactoryBean"><property name="serviceType" value="com.liyong.learn.createbean.DeveloperCreateFactory"></property>
</bean>

基于ServiceLoader也就是SPI机制，需要再这个目录下放置文件：
在这里插入图片描述
AutowireCapableBeanFactory

ApplicationContext context = new ClassPathXmlApplicationContext("bean-create.xml");
AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory();
HighDeveloper developer = autowireCapableBeanFactory.createBean(HighDeveloper.class);
System.out.println(developer);

Bean初始化

  • @PostConstruct
  • 实现InitializingBean 接口的afterPropertiesSet()方法
  • 自定义初始化方法
    • xml 指定 inti-method
    • 注解 @Bean(initMethod = ‘init’)
    • Java API AbstractBeanDefinition#setInitMethodName(String)

在bean中指定init方法，在创建bean的时候回去调用这个初始化方法

@PostConstruct
public void init() {System.out.println("init ing");
}

@Bean 指定initMethod

@Bean(initMethod = "initMethod")
public HighDeveloper highDeveloper() {return new HighDeveloper();
}
// 在类中添加方法
public void initMethod() {System.out.println("@Bean inti ing");}

通过InitializingBean 的实现

public class HighDeveloper implements InitializingBean {@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("InitializingBean init ing");}

三者的顺序：PostConstruct -> InitializingBean -> @Bean
在这里插入图片描述
通过AbstractBeanDefinition的方式

AnnotationConfigApplicationContext beanFactory = new AnnotationConfigApplicationContext();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(HighDeveloper.class);
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
beanDefinition.setInitMethodName("initMethod");
BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, beanFactory);
beanFactory.refresh();
HighDeveloper developer = beanFactory.getBean(HighDeveloper.class);
System.out.println(developer);

延迟初始化SpringBean

  • xml配置 （Lazy-init=“true”）

  • Java 注解 @Lazy(true)
    不使用延迟初始化

public static void main(String[] args) {AnnotationConfigApplicationContext beanFactory = new AnnotationConfigApplicationContext();beanFactory.register(Client.class);beanFactory.refresh();System.out.println("context finish");HighDeveloper developer = beanFactory.getBean(HighDeveloper.class);System.out.println(developer);}@Bean(initMethod = "initMethod")@Lazy(value = false)public HighDeveloper highDeveloper() {return new HighDeveloper();}

在这里插入图片描述

使用延迟初始化

@Lazy(value = true)
public HighDeveloper highDeveloper() {return new HighDeveloper();
}

在这里插入图片描述
总结：对比上面我们可以发现，如果不使用延迟加载在上下文刷新的时候Bean的初始化已经完成了。延迟加载的话，在真正使用的时候才会进行初始化。

Bean的销毁阶段

1 通过标注 注解 @PreDestory
2 实现DisposableBean 接口的destory()方法
3 自定义销毁方法

  • XML配置 bean destory=‘destory’
  • Java注解 @Bean(destory=‘destory’)
  • Java API：AbstractBeanDefiniton#setDestoryMethodName()
public class Client implements DisposableBean {public Client(){}private String name;private Integer age;public Client(String name, Integer age) {this.age = age;this.name = name;}@PreDestroypublic void preDestroy () {System.out.println("PreDestroy ......");}@Overridepublic String toString() {return "Client{" +"name='" + name + '\'' +", age=" + age +'}';}public void beanDestroy() {System.out.println("beanDestroy ....");}@Overridepublic void destroy() throws Exception {System.out.println("disposableDestroy ...");}
}

@Configuration
public class BeanDemo  {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(BeanDemo.class);context.refresh();Object demo = context.getBean("demo");System.out.println(demo);context.close();}@Bean(destroyMethod = "beanDestroy")public Client demo() {return new Client();}
}

在这里插入图片描述

Bean 垃圾回收

1 关闭上下文
2 调用GC
3 覆盖Object finalize() 方法

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.register(BeanDemo.class);context.refresh();Object demo = context.getBean("demo");System.out.println(demo);context.close();Thread.sleep(5000L);System.gc();Thread.sleep(5000L);

@Override
public void finalize() throws Throwable {System.out.println("finalize");
}

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

引入RabbitMQ

引入RabbitMQ

前置条件 docker 安装 mq docker run \-e RABBITMQ_DEFAULT_USERdudu \-e RABBITMQ_DEFAULT_PASS123456 \-v mq-plugins:/plugins \--name mq \--hostname mq \-p 15672:15672 \-p 5672:5672 \--network hmall \-d \rabbitmq:3.8-management可能会出现&#xff1a;docker: Er…
阅读更多...
【深度学习】【Lora训练0】StabelDiffusion，Lora训练，kohya_ss训练

【深度学习】【Lora训练0】StabelDiffusion，Lora训练，kohya_ss训练

文章目录 环境数据自动标注kohya_ss BLIP2kohya_ss WD14 后续 资源&#xff1a; &#xff08;1&#xff09;训练ui kohya_ss&#xff1a; https://github.com/bmaltais/kohya_ss &#xff08;2&#xff09;kohya_ss 的docker 其他docker https://github.com/ashleykleynhans…
阅读更多...
GraphGPT——图结构数据的新语言模型

GraphGPT——图结构数据的新语言模型

在人工智能的浪潮中&#xff0c;图神经网络&#xff08;GNNs&#xff09;已经成为理解和分析图结构数据的强大工具。然而&#xff0c;GNNs在面对未标记数据时&#xff0c;其泛化能力往往受限。为了突破这一局限&#xff0c;研究者们提出了GraphGPT&#xff0c;这是一种为大语言…
阅读更多...
AcWing 161：电话列表 ← 字典树（Trie 树）之前缀匹配

AcWing 161：电话列表 ← 字典树（Trie 树）之前缀匹配

【题目来源】https://www.acwing.com/problem/content/163/【题目描述】 给出一个电话列表&#xff0c;如果列表中存在其中一个号码是另一个号码的前缀这一情况&#xff0c;那么就称这个电话列表是不兼容的。 假设电话列表如下&#xff1a;Emergency 911 Alice 97625999 Bob …
阅读更多...
2022 亚马逊云科技中国峰会，对话开发者论坛

2022 亚马逊云科技中国峰会，对话开发者论坛

目录 前言 最近整理资料发现还有一些前 2 年的内容没发出来&#xff0c;故补发记录&#xff0c;每年都有新的感悟。 开发者论坛 1. 你认为什么是开发者社区&#xff0c;如何定义一个成功的开发者社区&#xff1f; 我认为可以把开发者社区看成一个 “产品” 来对待&#xff…
阅读更多...
ESP8266-01s刷入固件报SP8266 Chip efuse check error esp_check_mac_and_efuse

ESP8266-01s刷入固件报SP8266 Chip efuse check error esp_check_mac_and_efuse

一、遇到的问题 使用ESP8266 固件烧录工具flash_download_tools_v3.6.8 烧录固件报错&#xff1a; 二、解决方法 使用espressif推出发基于python的底层烧写工具&#xff1a;esptool 安装方法&#xff1a;详见https://docs.espressif.com/projects/esptool/en/latest/esp32/ …
阅读更多...
电脑中的两个固态硬盘比一个好，想知道为什么吗

电脑中的两个固态硬盘比一个好，想知道为什么吗

你当前的电脑很有可能有一个NVME SSD作为主驱动器&#xff0c;但可能至少还有一个插槽可以放另一个SSD&#xff0c;而且这样做可能是个好主意。 两个SSD可以提高性能 如果你有两个固态硬盘&#xff0c;你可以从中获得比有一个更好的性能。一种方法是使用RAID 0将两个驱动器组…
阅读更多...
《ESP8266通信指南》14-连接WIFI（基于Lua）

《ESP8266通信指南》14-连接WIFI（基于Lua）

往期 《ESP8266通信指南》13-Lua 简单入门&#xff08;打印数据&#xff09;-CSDN博客 《ESP8266通信指南》12-Lua 固件烧录-CSDN博客 《ESP8266通信指南》11-Lua开发环境配置-CSDN博客 《ESP8266通信指南》10-MQTT通信&#xff08;Arduino开发&#xff09;-CSDN博客 《ES…
阅读更多...
eNSP-浮动静态路由配置

eNSP-浮动静态路由配置

ip route-static 192.168.1.0 24 192.168.3.2 preference 60 #设置路由 目标网络地址 和 下一跳地址 preference值越大 优先级越低 一、搭建拓扑结构 二、主机配置 pc1 pc2 三、配置路由器 1.AR1路由器配置 <Huawei>sys #进入系统视图 [Huawei]int g0/0/0 #进入接…
阅读更多...
喜报|知从科技荣获“2023年度浦东新区创新创业奖”

喜报|知从科技荣获“2023年度浦东新区创新创业奖”

4月11日&#xff0c;由上海市浦东新区人民政府举办的“2024年浦东新区经济突出贡献企业表彰活动”在上海国际会议中心隆重举行。知从科技凭借过去一年在行业内卓越的技术创新实力及对浦东新区发展作出的杰出贡献&#xff0c;入选创新创业20强企业&#xff0c;荣获“2023年度浦东…
阅读更多...
C++类和对象（4）

C++类和对象（4）

目录 1.初始化列表 2.单参数里面的隐式类型转换 3.多参数的隐式类型转换 4.匿名对象 1.初始化列表 &#xff08;1&#xff09;首先看一下初始化列表具体是什么&#xff1f; 这个就是初始化列表的具体形式&#xff0c;对&#xff0c;你没有看错&#xff0c;这个初始化列表里…
阅读更多...
Hotcoin Research | 模块化将是大势所趋：拆解模块化区块链的现状和未来

Hotcoin Research | 模块化将是大势所趋：拆解模块化区块链的现状和未来

关于模块化区块链叙事的讨论源于Celestia和其代币TIA的亮眼表现。实际上&#xff0c;模块化是未来区块链设计的主要发展方向和大势所趋。模块化区块链就像乐高积木一样&#xff0c;将区块链系统拆分为可重用的模块&#xff0c;通过定制组合可实现不同功能的区块链网络。这种灵活…
阅读更多...
锂电池恒流恒压CCCV充电模型MATLAB仿真

锂电池恒流恒压CCCV充电模型MATLAB仿真

微❤关注“电气仔推送”获得资料&#xff08;专享优惠&#xff09; CCCV简介 CCCV充电过程是恒流充电&#xff08;CC&#xff09;和恒压充电&#xff08;CV&#xff09;的结合。在CC阶段对电池施加恒定电流&#xff0c;以获得更快的充电速度&#xff0c;此时电池电压持续升高…
阅读更多...
C++基础——输入输出（文件）

C++基础——输入输出（文件）

一、标准输入输出流 C 的输入输出是程序与用户或外部设备&#xff08;如文件、网络等&#xff09;之间交换信息的过程。 C 提供了丰富的标准库来支持这种交互&#xff0c;主要通过流的概念来实现。 流&#xff1a;抽象概念&#xff0c;表示一连串的数据&#xff08;字节或字…
阅读更多...
C++语言·string类

C++语言·string类

1. 为什么有string类 C语言中&#xff0c;字符串是以\0结尾的一些字符的集合&#xff0c;为了操作方便&#xff0c;C标准库中提供了一些str系列的库函数(strcpy,strcat)&#xff0c;但是这些库函数与字符串是分离开的&#xff0c;不太符合OOP(Object Oriented Programming面向对…
阅读更多...
Java 语法 (杂七杂八的知识)

Java 语法 (杂七杂八的知识)

面向对象三大特性 封装, 多态, 继承 基本数据类型 一字节 (Byte) 占八位 (bit) JDK, JRE, JVM JDK (Java Development Kit) : Java 开发工具包, 包括了 JRE, 编译器 javac, 和调试工具 Jconsole, jstack 等 JRE (Java Runtime Environment) : Java 运行时环境, 包括了 JVM , …
阅读更多...
【牛客】Tokitsukaze and Average of Substring

【牛客】Tokitsukaze and Average of Substring

原题链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 前缀和。 开一个int类型的前缀和数组pre[30][N]&#xff08;pre[i][j]表示某字符转成的数字 i 在一段区间的前缀个数。因为字母表有‘a’~z…
阅读更多...
【使用ChatGPT的API之前】OpenAI API提供的可用模型

【使用ChatGPT的API之前】OpenAI API提供的可用模型

文章目录 一. ChatGPT基本概念二. OpenAI API提供的可用模型1. InstructGPT2. ChatGPT3. GPT-4 三. 在OpenAI Playground中使用GPT模型-ing 在使用GPT-4和ChatGPT的API集成到Python应用程序之前&#xff0c;我们先了解ChatGPT的基本概念&#xff0c;与OpenAI API提供的可用模型…
阅读更多...
云原生Kubernetes: K8S 1.29版本 部署Harbor

云原生Kubernetes: K8S 1.29版本 部署Harbor

目录 一、实验 1.环境 2.Linux 部署docker compose 3.证书秘钥配置 4.K8S 1.29版本 部署Harbor 5.K8S 1.29版本 使用Harbor 二、问题 1.docker 登录harbor失败 一、实验 1.环境 &#xff08;1&#xff09;主机 表1 主机 主机架构版本IP备注masterK8S master节点1.2…
阅读更多...
java报错:使用mybatis plus查询一个只返回一条数据的sql，却报错返回了1000多条

java报错:使用mybatis plus查询一个只返回一条数据的sql，却报错返回了1000多条

今天遇到一个问题 系统线上问题&#xff0c;经常出现这样的问题&#xff0c;刚重启系统时不报错了&#xff0c;可是运行一段时间又会出现。sql已经写了limit 1&#xff0c;mybatis的debug日志也返回total为1&#xff0c;可是却报错返回了1805条数据 乍一看&#xff0c;感觉太不…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023