【手撕Spring源码】一些值得注意的Spring底层细节

news2024/10/6 18:24:38

文章目录

  • FactoryBean
  • @Indexed 原理
  • Spring代理的特点
  • @Value 装配底层
  • @Autowired 装配底层
  • 事件监听器
  • 模拟事件发布器

FactoryBean

FactoryBean是一个Factory对象,用于生成其他bean示例。当一个bean实现FactoryBean接口后,Spring容器调用其getObject方法返回该工厂所生成的bean,而不是该FactoryBean本身。但是工厂生成的产品对象只能说是一部分受到Spring容器的管理，我们来看看下面的例子：

我们把一个Bean1通过工厂Bean的方法纳入Spring管理，看看结果：

Bean1：

public class Bean1 implements BeanFactoryAware {
    private static final Logger log = LoggerFactory.getLogger(Bean1.class);

    private Bean2 bean2;

    @Autowired
    public void setBean2(Bean2 bean2) {
        log.debug("setBean2({})", bean2);
        this.bean2 = bean2;
    }

    public Bean2 getBean2() {
        return bean2;
    }

    @PostConstruct
    public void init() {
        log.debug("init");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.debug("setBeanFactory({})", beanFactory);
    }
}

Bean1的工厂类：

@Component("bean1")
public class Bean1FactoryBean implements FactoryBean<Bean1> {

    private static final Logger log = LoggerFactory.getLogger(Bean1FactoryBean.class);

    // 决定了根据【类型】获取或依赖注入能否成功
    @Override
    public Class<?> getObjectType() {
        return Bean1.class;
    }

    // 决定了 getObject() 方法被调用一次还是多次
    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public Bean1 getObject() throws Exception {
        Bean1 bean1 = new Bean1();
        log.debug("create bean: {}", bean1);
        return bean1;
    }
}

Bean后处理器：

@Component
public class Bean1PostProcessor implements BeanPostProcessor {

    private static final Logger log = LoggerFactory.getLogger(Bean1PostProcessor.class);

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("bean1") && bean instanceof Bean1) {
            log.debug("before [{}] init", beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("bean1") && bean instanceof Bean1) {
            log.debug("after [{}] init", beanName);
        }
        return bean;
    }
}

测试类：

@ComponentScan
public class A43 {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A43.class);

        Bean1 bean1 = (Bean1) context.getBean("bean1");
        Bean1 bean2 = (Bean1) context.getBean("bean1");
        Bean1 bean3 = (Bean1) context.getBean("bean1");
        
        //因为工厂isSingleton方法返回的true，所以是单例模式
        System.out.println(bean1);
        System.out.println(bean2);
        System.out.println(bean3);
		
		//如果想通过类型获取，那么工厂中的getObjectType方法就一定要返回正确的值
        System.out.println(context.getBean(Bean1.class));

		//两种获取工厂bean的方法
        System.out.println(context.getBean(Bean1FactoryBean.class));
        System.out.println(context.getBean("&bean1"));

        context.close();

}

结果：

在这里插入图片描述
在这里插入图片描述

总结💡：

  1. 它的作用是用制造创建过程较为复杂的产品, 如 SqlSessionFactory, 但 @Bean 已具备等价功能
  2. 使用上较为古怪, 一不留神就会用错
    1. 被 FactoryBean 创建的产品
      • 会认为创建、依赖注入、Aware 接口回调、前初始化这些都是 FactoryBean 的职责, 这些流程都不会走
      • 唯有后初始化的流程会走, 也就是产品可以被代理增强
      • 单例的产品不会存储于 BeanFactory 的 singletonObjects 成员中, 而是另一个 factoryBeanObjectCache 成员中
    2. 按名字去获取时, 拿到的是产品对象, 名字前面加 & 获取的是工厂对象。当然我们也可以通过工厂类型去拿工厂对象。

@Indexed 原理

在这里插入图片描述

💡

  1. 在编译时就根据 @Indexed 生成 META-INF/spring.components 文件
  2. 扫描时(二选一)
    • 如果发现 META-INF/spring.components 存在, 以它为准加载 bean definition
    • 否则, 会遍历包下所有 class 资源 (包括 jar 内的)
  3. 解决的问题：在编译期就找到 @Component 组件，节省运行期间扫描 @Component 的时间

Spring代理的特点

我们看一段代码：

@Component
public class Bean1 {

    private static final Logger log = LoggerFactory.getLogger(Bean1.class);

    protected Bean2 bean2;

    protected boolean initialized;

    @Autowired
    public void setBean2(Bean2 bean2) {
        log.debug("setBean2(Bean2 bean2)");
        this.bean2 = bean2;
    }

    @PostConstruct
    public void init() {
        log.debug("init");
        initialized = true;
    }

    public Bean2 getBean2() {
        log.debug("getBean2()");
        return bean2;
    }

    public boolean isInitialized() {
        log.debug("isInitialized()");
        return initialized;
    }
}

增强：

@Aspect
@Component
public class MyAspect {

    // 故意对所有方法增强
    @Before("execution(* com.itheima.a45.Bean1.*(..))")
    public void before() {
        System.out.println("before");
    }
}

测试类：
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

从这里我们可以看出来依赖注入和初始化影响的是原始对象

我们再来看看代理与目标的成员变量情况：

    public static void showProxyAndTarget(Bean1 proxy) throws Exception {
        System.out.println(">>>>> 代理中的成员变量");
        System.out.println("\tinitialized=" + proxy.initialized);
        System.out.println("\tbean2=" + proxy.bean2);

        if (proxy instanceof Advised advised) {
            System.out.println(">>>>> 目标中的成员变量");
            Bean1 target = (Bean1) advised.getTargetSource().getTarget();
            System.out.println("\tinitialized=" + target.initialized);
            System.out.println("\tbean2=" + target.bean2);
        }
    }

在这里插入图片描述

所以说代理与目标是两个对象，二者成员变量并不共用数据。我们平时是使用的方法去获取成员变量，方法虽然被增强，但其中还是会调用原方法，所以获取的就是目标对象中的成员变量。这也给我们一种提示我们想要走代理增强就必须走方法，不能走成员。

  1. spring 代理的设计特点

    • 依赖注入和初始化影响的是原始对象

      • 因此 cglib 不能用 MethodProxy.invokeSuper()

    • 代理与目标是两个对象，二者成员变量并不共用数据

  2. static 方法、final 方法、private 方法均无法增强

    • 进一步理解代理增强基于方法重写，这三种情况是无法被增强的

@Value 装配底层

  1. 查看需要的类型是否为 Optional，是，则进行封装（非延迟），否则向下走
  2. 查看需要的类型是否为 ObjectFactory 或 ObjectProvider，是，则进行封装（延迟），否则向下走
  3. 查看需要的类型（成员或参数）上是否用 @Lazy 修饰，是，则返回代理，否则向下走
  4. 解析 @Value 的值
    1. 如果需要的值是字符串，先解析 ${ }，再解析 #{ }
    2. 不是字符串，需要用 TypeConverter 转换
  5. 看需要的类型是否为 Stream、Array、Collection、Map，是，则按集合处理，否则向下走
  6. 在 BeanFactory 的 resolvableDependencies 中找有没有类型合适的对象注入，没有向下走
  7. 在 BeanFactory 及父工厂中找类型匹配的 bean 进行筛选，筛选时会考虑 @Qualifier 及泛型
  8. 结果个数为 0 抛出 NoSuchBeanDefinitionException 异常
  9. 如果结果 > 1，再根据 @Primary 进行筛选
  10. 如果结果仍 > 1，再根据成员名或变量名进行筛选
  11. 结果仍 > 1，抛出 NoUniqueBeanDefinitionException 异常

示例代码：

@Configuration
@SuppressWarnings("all")
public class A46 {

    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A46.class);
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();

        ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
        resolver.setBeanFactory(beanFactory);

//        test1(context, resolver, Bean1.class.getDeclaredField("home"));
//        test2(context, resolver, Bean1.class.getDeclaredField("age"));
//        test3(context, resolver, Bean2.class.getDeclaredField("bean3"));
        test3(context, resolver, Bean4.class.getDeclaredField("value"));
    }

    private static void test3(AnnotationConfigApplicationContext context, ContextAnnotationAutowireCandidateResolver resolver, Field field) {
        DependencyDescriptor dd1 = new DependencyDescriptor(field, false);
        // 获取 @Value 的内容
        String value = resolver.getSuggestedValue(dd1).toString();
        System.out.println(value);

        // 解析 ${}
        value = context.getEnvironment().resolvePlaceholders(value);
        System.out.println(value);
        System.out.println(value.getClass());

        // 解析 #{} @bean3
        Object bean3 = context.getBeanFactory().getBeanExpressionResolver().evaluate(value, new BeanExpressionContext(context.getBeanFactory(), null));

        // 类型转换
        Object result = context.getBeanFactory().getTypeConverter().convertIfNecessary(bean3, dd1.getDependencyType());
        System.out.println(result);
    }

    private static void test2(AnnotationConfigApplicationContext context, ContextAnnotationAutowireCandidateResolver resolver, Field field) {
        DependencyDescriptor dd1 = new DependencyDescriptor(field, false);
        // 获取 @Value 的内容
        String value = resolver.getSuggestedValue(dd1).toString();
        System.out.println(value);

        // 解析 ${}
        value = context.getEnvironment().resolvePlaceholders(value);
        System.out.println(value);
        System.out.println(value.getClass());
        Object age = context.getBeanFactory().getTypeConverter().convertIfNecessary(value, dd1.getDependencyType());
        System.out.println(age.getClass());
    }

    private static void test1(AnnotationConfigApplicationContext context, ContextAnnotationAutowireCandidateResolver resolver, Field field) {
        DependencyDescriptor dd1 = new DependencyDescriptor(field, false);
        // 获取 @Value 的内容
        String value = resolver.getSuggestedValue(dd1).toString();
        System.out.println(value);

        // 解析 ${}
        value = context.getEnvironment().resolvePlaceholders(value);
        System.out.println(value);
    }

    public class Bean1 {
        @Value("${JAVA_HOME}")
        private String home;
        @Value("18")
        private int age;
    }

    public class Bean2 {
        @Value("#{@bean3}") // SpringEL       #{SpEL}
        private Bean3 bean3;
    }

    @Component("bean3")
    public class Bean3 {
    }

    static class Bean4 {
        @Value("#{'hello, ' + '${JAVA_HOME}'}")
        private String value;
    }
}

重点：

  • ${ }对应的解析方法：context.getEnvironment().resolvePlaceholders
  • #{ } 对应的解析方法：context.getBeanFactory().getBeanExpressionResolver().evaluate
  • ContextAnnotationAutowireCandidateResolver 作用之一，获取 @Value 的值

@Autowired 装配底层

收获💡

  1. @Autowired 本质上是根据成员变量或方法参数的类型进行装配
  2. 如果待装配类型是 Optional，需要根据 Optional 泛型找到 bean，再封装为 Optional 对象装配
  3. 如果待装配的类型是 ObjectFactory，需要根据 ObjectFactory 泛型创建 ObjectFactory 对象装配
    • 此方法可以延迟 bean 的获取
  4. 如果待装配的成员变量或方法参数上用 @Lazy 标注，会创建代理对象装配
    • 此方法可以延迟真实 bean 的获取
    • 被装配的代理不作为 bean
  5. 如果待装配类型是数组，需要获取数组元素类型，根据此类型找到多个 bean 进行装配
  6. 如果待装配类型是 Collection 或其子接口，需要获取 Collection 泛型，根据此类型找到多个 bean
  7. 如果待装配类型是 ApplicationContext 等特殊类型
    • 会在 BeanFactory 的 resolvableDependencies 成员按类型查找装配
    • resolvableDependencies 是 map 集合，key 是特殊类型，value 是其对应对象
    • 不能直接根据 key 进行查找，而是用 isAssignableFrom 逐一尝试右边类型是否可以被赋值给左边的 key 类型
  8. 如果待装配类型有泛型参数
    • 需要利用 ContextAnnotationAutowireCandidateResolver 按泛型参数类型筛选
  9. 如果待装配类型有 @Qualifier
    • 需要利用 ContextAnnotationAutowireCandidateResolver 按注解提供的 bean 名称筛选
  10. 有 @Primary 标注的 @Component 或 @Bean 的处理
  11. 与成员变量名或方法参数名同名 bean 的处理

事件监听器

事件监听器的两种方式

  1. 实现 ApplicationListener 接口
    • 根据接口泛型确定事件类型
  2. @EventListener 标注监听方法
    • 根据监听器方法参数确定事件类型
    • 解析时机：在 SmartInitializingSingleton（所有单例初始化完成后），解析每个单例 bean

示例代码：

实现 ApplicationListener 接口：

// 事件解耦例子
@Configuration
public class A48_1 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A48_1.class);
        context.getBean(MyService.class).doBusiness();
        context.close();
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }

    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext
        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }

    @Component
    static class SmsApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(SmsApplicationListener.class);
        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(EmailApplicationListener.class);
        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送邮件");
        }
    }

}

使用@EventListener：

@Configuration
public class A48_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A48_2.class);
        context.getBean(MyService.class).doBusiness();
        context.close();
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }

    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext
        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }

    @Component
    static class SmsService {
        private static final Logger log = LoggerFactory.getLogger(SmsService.class);
        @EventListener
        public void listener(MyEvent myEvent) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailService {
        private static final Logger log = LoggerFactory.getLogger(EmailService.class);
        @EventListener
        public void listener(MyEvent myEvent) {
            log.debug("发送邮件");
        }
    }
	
	//模拟多线程	

    @Bean
    public ThreadPoolTaskExecutor executor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        return executor;
    }

    @Bean
    public SimpleApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executor) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.setTaskExecutor(executor);
        return multicaster;
    }

}

模拟事件发布器

    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster(ConfigurableApplicationContext context, ThreadPoolTaskExecutor executor) {
        return new AbstractApplicationEventMulticaster() {
            private List<GenericApplicationListener> listeners = new ArrayList<>();

            // 收集监听器
            public void addApplicationListenerBean(String name) {
                ApplicationListener listener = context.getBean(name, ApplicationListener.class);
                System.out.println(listener);
                // 获取该监听器支持的事件类型
                ResolvableType type = ResolvableType.forClass(listener.getClass()).getInterfaces()[0].getGeneric();
                System.out.println(type);

                // 将原始的 listener 封装为支持事件类型检查的 listener
                GenericApplicationListener genericApplicationListener = new GenericApplicationListener() {
                    // 是否支持某事件类型                真实的事件类型
                    public boolean supportsEventType(ResolvableType eventType) {
                        return type.isAssignableFrom(eventType);
                    }

                    public void onApplicationEvent(ApplicationEvent event) {
                        executor.submit(() -> listener.onApplicationEvent(event));
                    }
                };

                listeners.add(genericApplicationListener);
            }

            // 发布事件
            public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
                for (GenericApplicationListener listener : listeners) {
                    if (listener.supportsEventType(ResolvableType.forClass(event.getClass()))) {
                        listener.onApplicationEvent(event);
                    }
                }
            }
        };
    }

为了只实现两个核心方法，我们创建了一个AbstractApplicationEventMulticaster对ApplicationEventMulticaster接口进行了空实现，并定义为抽象类：
在这里插入图片描述

事件发布器模拟实现

  1. addApplicationListenerBean 负责收集容器中的监听器
    • 监听器会统一转换为 GenericApplicationListener 对象，以支持判断事件类型
  2. multicastEvent 遍历监听器集合，发布事件
    • 发布前先通过 GenericApplicationListener.supportsEventType 判断支持该事件类型才发事件
    • 可以利用线程池进行异步发事件优化
  3. 如果发送的事件对象不是 ApplicationEvent 类型，Spring 会把它包装为 PayloadApplicationEvent 并用泛型技术解析事件对象的原始类型

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

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

相关文章

elasticsearch 8.2.3 安装及springboot简单使用

elasticsearch 8.2.3 安装及springboot简单使用

一、下载安装 官网下载地址https://www.elastic.co/cn/downloads/elasticsearch 解压 elasticsearch-8.2.3-windows-x86_64 修改配置 elasticsearch-8.2.3\config\elasticsearch.yml # Elasticsearch Configuration # # NOTE: Elasticsearch comes with reasonable…
阅读更多...
自学大语言模型之GPT

自学大语言模型之GPT

GPT火爆的发展史 2017年6月OpenAI联合DeepMind首次正式提出的&#xff1a;Deep Reinforcement Learning from Human Preferences&#xff0c;即基于人类偏好的深度强化学习&#xff0c;简称RLHF 2017年7月的OpenAI团队提出的对TRPO算法的改进&#xff1a;PPO算法 GPT-1&#…
阅读更多...
【笔记】算法简单题

【笔记】算法简单题

题解&#xff1a; import java.util.HashMap; import java.util.Map;public class Test {//暴力解决法public static int[] twoSum(int[] nums, int target) {for(int i0;i<nums.length;i){for(int ji1;j<nums.length;j){if(nums[i]nums[j]target){int[] indexs{0,0};i…
阅读更多...
澳大利亚道路安全的AiRAP自动化审核（英）（附下载）

澳大利亚道路安全的AiRAP自动化审核（英）（附下载）

项目概况 该项目由新南威尔士州交通局&#xff08;TfNSW&#xff09;领导&#xff0c;悉尼科技大学&#xff0c;国际道路评估计划&#xff08;iRAP&#xff09;和澳大利亚地理空间数据专家Anditi的研究和协助。 该项目开展的工作是全球首创&#xff0c;其活动和成果是澳大利亚和…
阅读更多...
15、库函数开发小结

15、库函数开发小结

目录 0x01、初始化 0x02、数据输入输出 0x03、状态位、标志位 0x0001、事件 0x0002、标志位的检查与清除 0x04、外设函数分类 本节我们来总结一下ST库开发的步骤和共同点&#xff0c;在总结之前&#xff0c;我们来看一下基本所有外设都有的以下几类寄存器&#xff1a; 1…
阅读更多...
chatgpt赋能python：Python就业指南：市场现状、薪资情况及就业前景

chatgpt赋能python：Python就业指南：市场现状、薪资情况及就业前景

Python就业指南&#xff1a;市场现状、薪资情况及就业前景 Python作为一门既新颖又多用的编程语言&#xff0c;已经引起了越来越多的关注。据统计&#xff0c;在2019年&#xff0c;全球Python使用者数已经达到了960万人。而在中国&#xff0c;Python的应用也越来越普及&#x…
阅读更多...
PolyFormer：将图像分割称为顺序多边形生成

PolyFormer：将图像分割称为顺序多边形生成

文章目录 PolyFormer: Referring Image Segmentation as Sequential Polygon Generation\摘要本文方法Multi-modal Transformer EncoderRegression-based Transformer Decoder 实验结果 PolyFormer: Referring Image Segmentation as Sequential Polygon Generation\ 摘要 在…
阅读更多...
为什么会有分布式锁？分布式锁实现方案

为什么会有分布式锁？分布式锁实现方案

分布式锁是控制分布式系统之间同步访问共享资源的一种方式。分布式环境下会出现资源竞争的地方都需要分布式锁的协调。 分布式锁的作用&#xff1a;在整个系统提供一个全局、唯一的锁&#xff0c;在分布式系统中每个系统在进行相关操作的时候需要获取到该锁&#xff0c;才能执…
阅读更多...
Calibre 6.18.1 正式发布，功能强大的开源电子书工具

Calibre 6.18.1 正式发布，功能强大的开源电子书工具

导读Calibre 开源项目是 Calibre 官方出的电子书管理工具。它可以查看&#xff0c;转换&#xff0c;编辑和分类所有主流格式的电子书。Calibre 是个跨平台软件&#xff0c;可以在 Linux、Windows 和 macOS 上运行。 Calibre 6.18.1 正式发布&#xff0c;此次更新内容如下&#…
阅读更多...
数据挖掘(6.1)--神经网络

数据挖掘(6.1)--神经网络

目录 神经网络简介 BP算法 Delta学习规则的基本原理 BP神经网络的结构 BP神经网络的算法描述 神经网络训练一般步骤 后向传播算法的主要步骤 优缺点 BP算法简单举例 神经网络简介 神经网络是一种计算模型&#xff0c;它受到人脑处理信息的生物神经网络过程的启发。人…
阅读更多...
围绕工业 APT 攻击的主要问题

围绕工业 APT 攻击的主要问题

高级持续威胁 (APT) 行动在受害者网络内取得成功的关键因素包括人为因素、安全措施不足、网络安全解决方案更新和配置方面的挑战以及其他因素。 虽然其中一些原因可能看起来微不足道&#xff0c;但卡巴斯基专家在事件响应活动中经常遇到这些问题。 为帮助公司减轻相关威胁并确…
阅读更多...
win系统将脚手架的软链接指向本地脚手架

win系统将脚手架的软链接指向本地脚手架

先了解一下脚手架研发、发布、安装、调试发大致流程&#xff1a; 本地研发&#xff0c;具体研发过程略当前目录下登录npm npm login发布脚手架 npm publish安装脚手架 npm i -g xxxx&#xff08;win系统会在系统盘的nodejs文件夹下自动添加脚手架执行命令和执行文件&#xff0…
阅读更多...
94.构建样品餐部分第二节

94.构建样品餐部分第二节

上节课完成的页面是这样的 ● 之后我们设置一下图标 .meal-attribute {font-size: 1.8rem;font-weight: 500;display: flex;align-items: center;gap: 1.6rem; }.meal-img {width: 100%; }.meal-icon {height: 2.4rem;width: 2.4rem;color: #e67e22; }● 为了突出这些参数的…
阅读更多...
Go1.21 速览：新内置函数 clear、min、max 和新标准库包 cmp！

Go1.21 速览：新内置函数 clear、min、max 和新标准库包 cmp！

大家好&#xff0c;我是煎鱼。 前面给大家分享了 Go1.21 正式不支持 macOS 10.13 和 10.14 的支持。吓得我赶紧把我的 2017 款的老爷机从 10.14 升成 13.4。感觉 mbp 已经变成了暖宝宝。&#x1f605; 今天给大家分享的是 Go 1.21 中的两个双新增项&#xff0c;分别是新的 3 个…
阅读更多...
QTYX量化系统实战案例分享｜涨停股池中寻找反弹机会-202306

QTYX量化系统实战案例分享｜涨停股池中寻找反弹机会-202306

前言 “实战案例分享系列”是和大家分享一些股票量化分析工具QTYX在实战中的应用案例&#xff08;包括失败的案例&#xff09;&#xff0c;这样能够帮助大家更好地去理解QTYX中的功能设计&#xff0c;也能更好地帮助大家搭建出属于自己的量化交易系统。 关于QTYX的使用攻略可以…
阅读更多...
Clion开发STM32之链接文件进行模块的一个解耦(编程方式)

Clion开发STM32之链接文件进行模块的一个解耦(编程方式)

问题的引入 在单片机的开发过程中&#xff0c;往往涉及到驱动的移植&#xff0c;但是移植的过程中又会去添加和修改主逻辑的驱动引脚初始化或时钟初始化&#xff0c;这里面就会存在一个问题就是&#xff1a;改动的地方太多了&#xff0c;容易影响到其它功能模块。所以能不能做…
阅读更多...
200SMART CPU输入/输出接线的几个关键点

200SMART CPU输入/输出接线的几个关键点

总结来看&#xff0c;S7-200系列PLC提供4个不同的基本型号的8种CPU&#xff0c;其接线方式也可大致分为6种&#xff1a; 1.CPU SR20接线 2.CPU SR40接线 3.CPU CR40接线 4.CPU ST40接线 5. CPU SR60接线 6. CPU ST60接线 除了CPU外&#xff0c;我们还需要了解200smart PLC的数…
阅读更多...
Rocketmq面试（二）Rocketmq如何保证消息不丢失

Rocketmq面试（二）Rocketmq如何保证消息不丢失

如果想要保证消息不丢失就要知道&#xff0c;消息可能出现丢失得地方。 1.producer发送消息 2.Broker存储消息 3.Consumer消费消息 4.Broker主从切换 下面一共有9个维度可以保证消息不丢失。 目录 维度一&#xff1a;同步发送 维度二.异步发送 维度三.刷盘策略 维度四…
阅读更多...
后端——平台登录功能实战

后端——平台登录功能实战

这里写目录标题 一、登录接口设计示意图二、后端设计三、创建用户表四、后端鉴权逻辑五、登录接口实现六、使用 JWT 生成 token七、路由鉴权八、登录与测试用例服务结合九、跨域一、登录接口设计示意图 二、后端设计 三、创建用户表 db=SQLAlchemy(app
阅读更多...
华尔街新风向：多基金失英伟达机会

华尔街新风向：多基金失英伟达机会

在过去一年多的美联储暴力加息周期中&#xff0c;科技成长股一直不怎么受到主流投资者待见&#xff0c;但面对今年美股“人工智能涨个不停”的局面后&#xff0c;过去两周里大量的知名基金都在撒开脚丫子狂追高速狂飙的“英伟达列车”。 根据监管文件显示&#xff0c;包括道富…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023