Spring底层架构核心概念解析

BeanDefinition

BeanDefinition表示Bean定义,BeanDefinition中存在很多属性用来描述一个Bean的特点.比如:

  • beanClass:表示Bean类型
  • scope:表示Bean作用域,单例/原型等
  • lazyInit:表示Bean是否懒加载
  • initMethodName:表示Bean初始化时要执行的方法
  • destoryMethodName:表示Bean销毁时要执行的方法
  • …

再Spring中,我们经常会通过以下几种方式来定义Bean:

  1. <bean/>
  2. @Bean
  3. @Component/@Service/@Controller

这些可以称之为 申明式定义Bean.

还可以 编程式定义Bean,那就是直接通过BeanDefinition

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    // 生成一个BeanDefinition对象
    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
    // 设置beanClass为User.class
    beanDefinition.setBeanClass(User.class);
    // 注册到ApplicationContext中
    context.registerBeanDefinition("user",beanDefinition);
    System.out.println(context.getBean("user"));
}

// com.fanqiechaodan.entity.User@2034b64c

还可以通过BeanDefinition设置一个Bean的其他属性

// 设置作用域
beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
// 设置初始化方法
beanDefinition.setInitMethodName("init");
// 设置懒加载
beanDefinition.setLazyInit(true);

和申明式事务,编程式事务类似,通过<bean/>,@Bean,@Component等申明方式所定义的Bean,最终都会被Spring解析为对应的BeanDefinition对象,并放入Spring容器中.

BeanDefinitionReader

BeanDefinitionReader(BeanDefinition读取器),这些BeanDefinitionReader在使用Spring时用的少,但在Spring源码中用的多,相当于Spring的基础设置

AnnotatedBeanDefinitionReader

可以直接把某个类转换为BeanDefinition,并解析该类上的注解

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    AnnotatedBeanDefinitionReader beanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
    // 将User.class解析为BeanDefinition
    beanDefinitionReader.register(User.class);
    System.out.println(context.getBean("user"));
}

注意:它能解析的注解是:@Conditional,@DependsOn,@Description,@Lazy,@Primary,@Role,@Scope

XmlBeanDefinitionReader

可以解析<bean/>标签

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(context);
    // 返回注册Bean的数量
    int i = beanDefinitionReader.loadBeanDefinitions("spring.xml");
    System.out.println(context.getBean("user"));
}

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner是扫描器,但是它的作用与BeanDefinitionReader类似,它可以进行扫描,扫描某个包路径,对扫描的类进行解析,比如:扫描到的类如果存在@Component注解,那么就会把这个类解析为一个BeanDefinition.

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    ClassPathBeanDefinitionScanner beanDefinitionScanner = new ClassPathBeanDefinitionScanner(context);
    beanDefinitionScanner.scan("com.fanqiechaodan");
    System.out.println(context.getBean("userService"));
}

BeanFactory

BeanFactory表示Bean工厂,所以很明显,BeanFactory会负责创建Bean,并且提供获取Bean的API.

而ApplicationContext是BeanFactory的一种,在Spring源码中,是这么定义的:

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
            // ...
}

首先,在Java中,接口时可以 多继承 的,我们发现ApplicationContext继承了ListableBeanFactory和HierarchicalBeanFactory,而ListableBeanFactory和HierarchicalBeanFactory都继承至BeanFactory,等同ApplicationContext继承了BeanFactory,ApplicationContext也是BeanFactory的一种,拥有BeanFactory支持的所有功能,不过ApplicationContext比BeanFactory更加强大,ApplicationContext还继承了其他接口,也就表示ApplicationContext还拥有其他的功能.比如MessageSource(国际化),ApplicationEventPublisher(事件发布)等等.

在Spring源码实现中,当我们new一个ApplicationContext时,其底层会new一个BeanFactory出来,当使用ApplicationContext的某些方法时,比如getBean(),底层调用的是BeanFactory的getBean().

在Spring源码中,BeanFactory接口存在一个非常重要的实现类:DefaultListableBeanFactory.所以我们可以直接来使用 DefaultListableBeanFactory,而不用使用ApplicationContext的某个实现类

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
    beanDefinition.setBeanClass(User.class);
    beanFactory.registerBeanDefinition("user",beanDefinition);
    System.out.println(beanFactory.getBean("user"));
}

DefaultListableBeanFactory是非常强大的,支持很多功能,可以通过查看DefaultListableBeanFactory的类继承实现结构来看

在这里插入图片描述

它实现了很多接口,表示它拥有很多功能:

  1. AliasRegistry:支持别名功能,一个名字可以对应多个别名
  2. BeanDefinitionRegistry:可以注册,保存,移出,获取某个BeanDefinition
  3. BeanFactory:Bean工厂,可以根据某个Bean的名字/类型/别名获取某个Bean对象
  4. SingletonBeanRegistry:可以注册,获取某个单例Bean
  5. SimpleAliasRegistry:它是一个类,实现了AliasRegistry接口中所定义的功能,支持别名
  6. ListableBeanFactory:在BeanFactory的基础上,增加了其他功能,可以获取所有BeanDefinition的beanNames,可以根据某个类型获取对应的beanNames,可以根据某个类型获取{类型:对应的Bean}的映射关系
  7. HierarchicalBeanFactory:在BeanFactory的基础上,增加了获取父BeanFactory的功能
  8. DefaultSingletonBeanRegisty:它是一个类,实现了SingletonBeanRegistry接口,拥有了直接注册,获取某个单例Bean的功能
  9. ConfigurableBeanFactory:在HierarchicalBeanFactory和SingletonBeanRegistry的基础上,添加了设置父BeanFactory,类加载器(表示可以指定某个类加载器进行类的加载),设置Spring EL表达式解析器(表示可以解析EL表达式),设置类型转化服务(表示可以进行类型转化),可以添加BeanPostprocessor(表示支持Bean的后置处理器),可以合并BeanDefinition,可以销毁某个Bean等等功能
  10. FactoryBeanRegistrySupport:支持了FactoryBean的功能
  11. AutowireCapableBeanFactory:直接继承了BeanFactory,在BeanFactory的基础上,支持创建Bean的过程中能对Bean进行自动装配
  12. AbstractBeanFactory:继承了FactoryBeanRegistrySupport,实现了ConfigurableBeanFactory,这个BeanFactory的功能已经很全面了,但是不能自动装配和获取beanNames
  13. ConfigurableListableBeanFactory:继承了ListableBeanFactory,AutowireCapableBeanFactory,ConfigurableBeanFactory
  14. AbstractAutowireCapableBeanFactory:继承了AbstractBeanFactory,实现了AutowireCapableBeanFactory拥有了自动装配的功能
  15. DefaultListableBeanFactory:直接或间接的继承/实现以上所有类或接口.所以DefaultListableBeanFactory的功能很强大

ApplicationContext

ApplicationContext是个接口,实际上也是一个BeanFactory,不过比BeanFactory更加强大,比如:

  1. HierarchicalBeanFactory:拥有获取父BeanFactory的功能
  2. ListableBeanFactory:拥有获取beanNames的功能
  3. ResourcePatternResolver:资源加载器,可以一次性获取多个资源(文件资源等等)
  4. EnvironmentCapable:可以获取运行时环境,没有设置运行时环境功能
  5. ApplicationEventPublisher:拥有广播事件的功能,没有添加事件监听的功能
  6. MessageSource:拥有国际化功能

ApplicationContext有两个比较重要的实现类:

  1. AnnotationConfigApplicationContext
  2. ClassPathXmlApplicationContext

AnnotationConfigApplicationContext

在这里插入图片描述

  1. ConfigurableApplicationContext:继承了ApplicationContext接口,增加了事件监听器,添加BeanFactoryPostProcessor,设置Environment,获取ConfigurableListableBeanFactory等功能
  2. AbstractApplicationContext:实现了ConfigurableApplicationContext接口
  3. GenericApplicationContext:继承了AbstractApplicationContext,实现了BeanDefinitionRegistry接口,拥有了所有ApplicationContext的功能,并且可以注册BeanDefinition,这个类内置了一个DefaultListableBeanFactory属性
  4. AnnotationConfigRegistry:可以单独注册某个类为BeanDefinition,可以处理该类上的@Configuration注解@Bean注解,同时可以扫描
  5. AnnotationConfigApplicationContext:继承了GenericApplicationContext,实现了AnnotationConfigRegistry接口,拥有了以上所有的功能

ClassPathXmlApplicationContext

在这里插入图片描述

它也是继承了AbstractApplicationContext,但是相对于AnnotationConfigApplicationContext而言,功能没有AnnotationConfigApplicationContext强大,比如不能注册BeanDefinition

国际化

先定义一个MessageSource

@Bean
public MessageSource messageSource() {
    ResourceBundleMessageSource res = new ResourceBundleMessageSource();
    res.setBasename("en_CN");
    res.setDefaultEncoding("UTF-8");
    return res;
}

en_CN.properties

test=测试

有了这个Bean,可以在任意想要进行国际化的地方使用MessageSource,同时因为ApplicationContext继承了MessageSource,也拥有国际化的功能

public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    System.out.println(context.getBean("messageSource"));
    System.out.println(context.getMessage("test", null, new Locale("en_CN")));
}

// 测试

资源加载

ApplicationContext还拥有资源加载的功能

public static void main(String[] args) throws IOException {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    Resource userService = context.getResource("file://C:\\devspace\\fanqiechaodan-spring\\src\\main\\java\\com\\fanqiechaodan\\service\\UserService.java");
    System.out.println(userService.contentLength());
    System.out.println(userService.getFilename());
    System.out.println();

    Resource baidu = context.getResource("https://www.baidu.com/");
    System.out.println(baidu.contentLength());
    System.out.println(baidu.getURL());
    System.out.println();

    Resource spring = context.getResource("classpath:spring.xml");
    System.out.println(spring.contentLength());
    System.out.println(spring.getURL());
    System.out.println();

    Resource[] resources = context.getResources("classpath:com/fanqiechaodan/entity/*.class");
    for (Resource resource : resources) {
        System.out.println(resource.contentLength());
        System.out.println(resource.getURL());
    }
}
    
//  213
//  UserService.java
//  
//  2443
//  https://www.baidu.com/
//  
//  513
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/spring.xml
//  
//  296
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/com/fanqiechaodan/entity/Address.class
//  672
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/com/fanqiechaodan/entity/User.class

获取运行时环境

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    Map<String, Object> systemEnvironment = context.getEnvironment().getSystemEnvironment();
    System.out.println(systemEnvironment);
    System.out.println();

    Map<String, Object> systemProperties = context.getEnvironment().getSystemProperties();
    System.out.println(systemProperties);
    System.out.println();

    MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
    System.out.println(propertySources);

    System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding"));
}

事件发布

先定义一个事件监听器

@Bean
public ApplicationListener applicationListener() {
    return event -> System.out.println("接收到一个事件");
}

在发布事件

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    context.publishEvent("aaa");
}

类型转化

在Spring源码中,有可能需要把String转成其他类型,所以在Spring源码中提供了一些技术来更方便的做对象的类型转化,关于类型转化Spring有很多应用.

PropertyEditor

这其实是JDK中提供的类型转化工具类

public class String2UserPropertyEditor extends PropertyEditorSupport implements PropertyEditor {

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        User user = new User();
        user.setName(text);
        this.setValue(user);
    }
}

public static void main(String[] args) {
    String2UserPropertyEditor editor = new String2UserPropertyEditor();
    editor.setAsText("testName");
    User user = (User) editor.getValue();
    System.out.println(user.getName());
}

如何向Spring中注册PropertyEditor:

@Bean
public CustomEditorConfigurer customEditorConfigurer(){
    CustomEditorConfigurer editorConfigurer = new CustomEditorConfigurer();
    Map<Class<?>, Class<? extends PropertyEditor>> map = new HashMap<>();
    // 表示String2UserPropertyEditor可以将String转换为User
    // 在Spring源码中,如果发现当前对象是String,需要的类型为User
    // 就会使用String2UserPropertyEditor来做类型转化
    map.put(User.class, String2UserPropertyEditor.class);
    editorConfigurer.setCustomEditors(map);
    return editorConfigurer;
}

假设现在有以下Bean:

@Service
public class UserService {

    @Value("test")
    private User user;

    public void test(){
        System.out.println(user.getName());
    }
}

使用@Value可以完成对User的赋值

ConversionService

Spring中提供的类型转化服务,它比PropertyEditor更强大

public class String2UserConverter implements ConditionalGenericConverter {
    @Override
    public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
        return sourceType.getType().equals(String.class) && targetType.getType().equals(User.class);
    }

    @Override
    public Set<ConvertiblePair> getConvertibleTypes() {
        return Collections.singleton(new ConvertiblePair(String.class, User.class));
    }

    @Override
    public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        User user = new User();
        user.setName((String) source);
        return user;
    }
}

public static void main(String[] args) {
    DefaultConversionService conversionService = new DefaultConversionService();
    conversionService.addConverter(new String2UserConverter());
    User user = conversionService.convert("testName", User.class);
    System.out.println(user.getName());
}

如何向Spring中注册ConversionService

@Bean
public ConversionServiceFactoryBean conversionServiceFactoryBean(){
    ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
    conversionServiceFactoryBean.setConverters(Collections.singleton(new String2UserConverter()));
    return conversionServiceFactoryBean;
}

TypeConverter

整合了PropertyEditor和ConversionService的功能,是Spring内部用的

public static void main(String[] args) {
    SimpleTypeConverter simpleTypeConverter = new SimpleTypeConverter();
    // 整合PropertyEditor
    //        simpleTypeConverter.registerCustomEditor(User.class,new String2UserPropertyEditor());
    // 整合ConversionService
    DefaultConversionService conversionService = new DefaultConversionService();
    conversionService.addConverter(new String2UserConverter());
    simpleTypeConverter.setConversionService(conversionService);
    User test = simpleTypeConverter.convertIfNecessary("test", User.class);
    System.out.println(test.getName());
}

OrderComparator

OrderComparator是Spring所提供的一种比较器,可以用来根据@Order注解或实现Ordered接口来执行值进行比较,从而可以进行排序

@Data
public class A implements Ordered {

    @Override
    public int getOrder() {
        return 1;
    }

}

@Data
public class B implements Ordered {
    @Override
    public int getOrder() {
        return 0;
    }

}

public static void main(String[] args) {
    A a = new A();
    B b = new B();

    OrderComparator orderComparator = new OrderComparator();
    System.out.println(orderComparator.compare(a,b));
    System.out.println();

    List list = new ArrayList<>();
    list.add(a);
    list.add(b);

    // 按order值升序排序
    list.sort(orderComparator);
    System.out.println(list);
}


//  1
//
//  [B(), A()]

另外,Spring中还提供了一个OrderComparator的子类:AnnotationAwreOrderComparator,它支持用@Oder来指定order值

@Data
@Order(1)
public class A {

}

@Data
@Order(0)
public class B {

}

public static void main(String[] args) {
    A a = new A();
    B b = new B();

    OrderComparator orderComparator = new OrderComparator();
    System.out.println(orderComparator.compare(a,b));
    System.out.println();

    List list = new ArrayList<>();
    list.add(a);
    list.add(b);

    // 按order值升序排序
    list.sort(orderComparator);
    System.out.println(list);
}


//  1
//
//  [B(), A()]

BeanPostProcessor

BeanPostProcessor表示Bean后置处理器

@Component
public class BeanPostProcessorDemo implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)){
            System.out.println("userService初始化前");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)){
            System.out.println("userService初始化后");
        }
        return bean;
    }
}

一个BeanPostProcessor可以在任意一个Bean的初始化之前以及初始化之后去额外的做一些用户自定义的逻辑,当然,我们可以通过判断beanName来进行针对性处理(针对某个Bean或某部分Bean)

我们可以通过定义BeanPostProcessor来干涉Spring创建Bean的过程.

BeanFactoryPostProcessor

BeanFactoryPostProcessor表示Bean工厂的后置处理器,其实和BeanPostProcessor类似,BeanPostProcessor是干涉Bean的创建过程,BeanFactoryPostProcessor是干涉BeanFactory的创建过程.

@Component
public class BeanFactoryProcessorDemo implements BeanFactoryPostProcessor {

    /**
     * 可以对beanFactory进行加工
     *
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("加工beanFactory");
    }
}

FactoryBean

我们可以通过BeanPostProcessor来干涉Bean创建的过程,如果想要一个Bean完全由我们来创建同样是可以的.

@Component
public class FactoryBeanDemo implements FactoryBean {
    
    @Override
    public Object getObject() throws Exception {
        return new UserService();
    }

    @Override
    public Class<?> getObjectType() {
        return UserService.class;
    }
}

通过上面这段代码,我们自己创建了一个UserService.并且它将成为Bean.但是通过这种方式创建的Bean.只会经过 初始化后,其他Spring的生命周期是不会经过的,比如依赖注入.而通过@Bean/@Service等等注解定义的Bean是会经过完整的Bean生命周期的.

ExcludeFilter和IncludeFilter

这两个Filter是Spring扫描过程中用来过滤的.ExcludeFilter表示 排除过滤器,IncludeFilter表示 包含过滤器.

/**
 * 扫描com.fanqiechaodan这个包下的所有类
 * 但是排除UserService即使它上面有@Component/@Service也不会注册成Bean
 */
@ComponentScan(value = "com.fanqiechaodan",
        excludeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class
        )})
public class AppConfig {
    
}

/**
 * 扫描com.fanqiechaodan这个包下的所有类
 * 包含UserService即使它上面没有@Component/@Service也会注册成Bean
 */
@ComponentScan(value = "com.fanqiechaodan",
        includeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class
        )})
public class AppConfig {
    
}

FilterType分为:

  1. ANNOTATION:表示是否包含某个注解
  2. ASSIGNABLE_TYPE:表示是否是某个类
  3. ASPECTJ:表示是否符合某个Aspectj表达式
  4. REGEX:表示是否符合某个正则表达式
  5. CUSTOM:自定义

MetadataReader,ClassMetadata,AnnotationMetadata

在Spring中需要去解析类的信息,比如类名,类中的方法,类上的注解,这些都可以称之为类的元数据,所以Spring对类的元数据做了抽象,并提供了一些工具类.

MetadataReader表示类的元数据读取器,默认实现类为 SimpleMetadataReader

public static void main(String[] args) throws IOException {
    SimpleMetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();

    // 构造一个MetadataReader
    MetadataReader metadataReader = metadataReaderFactory.getMetadataReader("com.fanqiechaodan.service.UserService");

    // 得到了一个ClassMetadata,并获取类名
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    System.out.println(classMetadata.getClassName());

    // 获取一个AnnotationMetadata,并获取类上的注解信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
    for (String annotationType : annotationTypes) {
        System.out.println(annotationType);
    }
}

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

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

相关文章

消费管理系统

消费管理系统

阅读更多...
文章解读与仿真程序复现思路——电工技术学报EI\CSCD\北大核心《计及台风时空特性和灵活性资源协同优化的配电网弹性提升策略》

文章解读与仿真程序复现思路——电工技术学报EI\CSCD\北大核心《计及台风时空特性和灵活性资源协同优化的配电网弹性提升策略》

本专栏栏目提供文章与程序复现思路&#xff0c;具体已有的论文与论文源程序可翻阅本博主免费的专栏栏目《论文与完整程序》 论文与完整源程序_电网论文源程序的博客-CSDN博客https://blog.csdn.net/liang674027206/category_12531414.html 电网论文源程序-CSDN博客电网论文源…
阅读更多...
SpringBootWeb 篇-入门了解 Spring Cache 、Spring Task 与 WebSocket 框架

SpringBootWeb 篇-入门了解 Spring Cache 、Spring Task 与 WebSocket 框架

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 Spring Cache 概述 1.1 Spring Cache 具体使用 1.1.1 引入依赖 1.1.2 Spring Cache 相关注解的介绍 2.0 Spring Task 概述 2.1 cron 表达式 2.2 Spring Task 使用…
阅读更多...
程序猿大战Python——函数——拆包和交换变量值与引用

程序猿大战Python——函数——拆包和交换变量值与引用

拆包 目标&#xff1a;了解拆包的使用。 先来看看在现实生活中的拆包。比如&#xff0c;张同学背着背包来教室上课后&#xff0c;需要从背包中拿出电脑、鼠标、数据线、电源线等&#xff0c;这个过程就是拆包! 接着&#xff0c;看一下在Python程序中的拆包&#xff1a;把组合形…
阅读更多...
基于单片机和GP2Y1010AU粉尘传感器的空气质量检测仪设计

基于单片机和GP2Y1010AU粉尘传感器的空气质量检测仪设计

摘要 随着社会的发展，随着工业的发展，其给人们的生活带来很多便利。然而，工业生产过程中会产生很多对人体有害的因素，比如煤炭开采、水泥生产等行业中的粉尘污染。其在各种危害因素中对人体健康的影响最为严重。粉尘对人体的危害最直接、最严重的是引起尘肺病。当粉尘浓度过…
阅读更多...
云原生技术实现Devops自动化运维

云原生技术实现Devops自动化运维

云原生技术实现Devops自动化运维 随着云计算和DevOps理念的普及&#xff0c;云原生技术在自动化运维中的应用日益广泛。本文将探讨云原生技术如何通过容器化、微服务架构、CI/CD流水线等手段&#xff0c;提升DevOps自动化运维的效率和灵活性&#xff0c;并通过案例分析具体应用…
阅读更多...
Day01_Ajax入门

Day01_Ajax入门

文章目录 学习目标一、AJAX 概念和 axios 使用1. 目标2. 讲解2.1 什么是 AJAX ?2.2 什么是服务器&#xff1f;2.3 为何学 AJAX ?2.4 怎么学 AJAX ?2.5 例子2.6 axios语法 二、认识 URL1. 目标2. 讲解2.1 为什么要认识 URL ?2.2 什么是 URL &#xff1f;2.3 URL的组成 &…
阅读更多...
架构设计 - WEB项目的基础序列化配置

架构设计 - WEB项目的基础序列化配置

摘要&#xff1a;web项目中做好基础架构(redis&#xff0c;json)的序列化配置有重要意义 支持复杂数据结构&#xff1a;Redis 支持多种不同的数据结构&#xff0c;如字符串、哈希表、列表、集合和有序集合。在将这些数据结构存储到 Redis 中时&#xff0c;需要将其序列化为字节…
阅读更多...
IT入门知识博客文章大纲（0/10）

IT入门知识博客文章大纲（0/10）

IT入门知识博客文章大纲 引言 什么是IT&#xff1f; 信息技术&#xff08;Information Technology&#xff09;&#xff0c;互联网技术是指在计算机技术的基础上开发建立的一种信息技术 。互联网技术通过计算机网络的广域网使不同的设备相互连接&#xff0c;加快信息的传输速度…
阅读更多...
【JavaEE精炼宝库】多线程（6）线程池

【JavaEE精炼宝库】多线程（6）线程池

目录 一、线程池的概念及优势 1.1 线程池的概念&#xff1a; 1.2 线程池的优势&#xff1a; 二、工厂模式 三、标准库中的线程池 3.1 标准库线程池参数解释&#xff1a; 3.1.1 corePoolSize | maximumPoolSize&#xff1a; 3.1.2 keepAliveTime | unit&#xff1a; 3.1…
阅读更多...
Vue50-mixin混入

Vue50-mixin混入

一、为什么要使用 mixin混入 两个组件共享一个配置。 二、使用 mixin混入 2-1、创建一个混合js文件 2-2、引入混合js文件 1、局部混合 在每个组件中都引入混合js文件 注意&#xff1a; 混合就是复用配置&#xff0c;vm实例中的所有的配置项&#xff0c;都能在混合.js文件中写…
阅读更多...
【计算机毕业设计】基于Springboot的毕业生实习与就业管理系统【源码+lw+部署文档】

【计算机毕业设计】基于Springboot的毕业生实习与就业管理系统【源码+lw+部署文档】

包含论文源码的压缩包较大&#xff0c;请私信或者加我的绿色小软件获取 免责声明&#xff1a;资料部分来源于合法的互联网渠道收集和整理&#xff0c;部分自己学习积累成果&#xff0c;供大家学习参考与交流。收取的费用仅用于收集和整理资料耗费时间的酬劳。 本人尊重原创作者…
阅读更多...
新旧torch中傅里叶变换实现（fft）

新旧torch中傅里叶变换实现（fft）

由泰勒级数我们知道&#xff0c;一个函数可以被分解成无穷个幂函数叠加的形式&#xff0c;于是同样地&#xff0c;一个周期函数也可以被分解成多个周期函数叠加&#xff0c;于是自然而然地&#xff0c;三角函数符合这个需求&#xff0c;由傅里叶级数我们可以将周期函数分解成无…
阅读更多...
Qwen2大语言模型微调、导出、部署实践

Qwen2大语言模型微调、导出、部署实践

上篇文章&#xff1a; Qwen1.5大语言模型微调实践_qwen1.5 7b微调-CSDN博客 我们介绍了Qwen1.5 大语言模型使用LLaMA-Factory 来微调&#xff0c;这篇文章我们介绍一下微调后模型的导出、部署。 一、模型导出 在webui 界面训练好模型之后点击“Export”选项卡&#xff0c;然…
阅读更多...
linux 部署瑞数6实战(维普，药监局)第一部分

linux 部署瑞数6实战(维普，药监局)第一部分

声明 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01;wx 本文章未经许可禁止转载&…
阅读更多...
ICML24麻省理工提出使用更少的条件独立性测试来发现因果关系新方法

ICML24麻省理工提出使用更少的条件独立性测试来发现因果关系新方法

【摘要】众多科学领域的核心问题围绕着理解因果关系这一基本问题。然而,大多数基于约束的因果发现算法,包括广受欢迎的PC算法,通常会进行指数级数量的条件独立性(CI)测试,在各种应用中造成局限。为解决这一问题,我们的工作重点是表征在减少CI测试数量的情况下,可以了解潜在因果…
阅读更多...
POC EXP | woodpecker插件编写

POC EXP | woodpecker插件编写

woodpecker插件编写 目录 woodpecker介绍woodpecker使用插件编写 安装环境 woodpecker-sdkwoodpecker-request 创建Maven项目 Confluence OGNL表达式注入漏洞插件编写 创建Package包和Class类编写POC 漏洞POC代码编写导出jar包将jar包放入woodpecker的plugin目录运行woodpeck…
阅读更多...
UML与设计模式

UML与设计模式

1、关联关系 关联关系用于描述不同类的对象之间的结构关系&#xff0c;它在一段时间内将多个类的实例连接在一起。关联关系是一种静态关系&#xff0c;通常与运行状态无关&#xff0c;而是由“常识”、“规则”、“法律”等因素决定的&#xff0c;因此关联关系是一种强关联的关…
阅读更多...
MPC质心跟随控制（CoM Tracking Control）

MPC质心跟随控制（CoM Tracking Control）

MPC质心跟随 在人形机器人中，质心（CoM）的跟随控制是保持机器人稳定和协调运动的关键技术之一。模型预测控制（MPC）是一种先进的控制方法，通过解决在线优化问题来控制机器人质心的位置和速度。下面我们详细介绍如何使用MPC实现质心跟随控制。 MPC基本原理 模型预测控制是…
阅读更多...
Iptables深入浅出

Iptables深入浅出

1、iptables的基本概念 众所周知iptables是Linux系统下自带免费的包过滤防火墙。其实不然&#xff0c;iptables其实不是真正的防火墙&#xff0c;我们可以把它理解成一个客户端代理&#xff0c;用户通过iptables这个代理&#xff0c;将用户的安全设定执行到对应的”安全框架”…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站