web开发要学多久，118页Vue面试题总结

最新推荐文章于 2024-10-10 10:08:22 发布
最新推荐文章于 2024-10-10 10:08:22 发布
阅读量103 收藏
点赞数
分类专栏： 程序员 文章标签： 面试 前端 大前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60196831/article/details/119034276
版权

分布式apollo简介

Apollo（阿波罗）是携程框架部门研发的开源配置管理中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性。

本文主要介绍如何使用apollo与springboot实现动态刷新配置，如果之前不了解apollo可以查看如下文档

https://github.com/ctripcorp/apollo

学习了解一下apollo，再来查看本文

正文

apollo与spring实现动态刷新配置本文主要演示2种刷新，一种基于普通字段刷新、一种基于bean上使用了@ConfigurationProperties刷新

1、普通字段刷新

a、pom.xml配置

        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-client</artifactId>
            <version>1.6.0</version>
        </dependency>

b、客户端配置AppId，Apollo Meta Server

此配置有多种方法，本示例直接在application.yml配置，配置内容如下

app:
  id: ${spring.application.name}
apollo:
  meta: http://192.168.88.128:8080,http://192.168.88.129:8080
  bootstrap:
    enabled: true
    eagerLoad:
      enabled: true

c、项目中启动类上加上@EnableApolloConfig注解，形如下

@SpringBootApplication
@EnableApolloConfig(value = {"application","user.properties","product.properties","order.properties"})
public class ApolloApplication {

	public static void main(String[] args) {

		SpringApplication.run(ApolloApplication.class, args);
	}

}

@EnableApolloConfig不一定要加在启动类上，加在被spring管理的类上即可

d、在需刷新的字段上配置@Value注解，形如

    @Value("${hello}")
    private String hello;

通过以上三步就可以实现普通字段的动态刷新

2.bean使用@ConfigurationProperties动态刷新

bean使用@ConfigurationProperties注解目前还不支持自动刷新，得编写一定的代码实现刷新。目前官方提供2种刷新方案

  • 基于RefreshScope实现刷新
  • 基于EnvironmentChangeEvent实现刷新
  • 本文再提供一种，当bean上如果使用了@ConditionalOnProperty如何实现刷新

a、基于RefreshScope实现刷新

1、pom.xml要额外引入

    <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-context</artifactId>
            <version>2.0.3.RELEASE</version>
        </dependency>

2、bean上使用@RefreshScope注解

@Component
@ConfigurationProperties(prefix = "product")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@RefreshScope
public class Product {

    private Long id;

    private String productName;

    private BigDecimal price;

}

3、利用RefreshScope搭配@ApolloConfigChangeListener监听实现bean的动态刷新，其代码实现如下

 @ApolloConfigChangeListener(value="product.properties",interestedKeyPrefixes = {"product."})
    private void refresh(ConfigChangeEvent changeEvent){

        refreshScope.refresh("product");

        PrintChangeKeyUtils.printChange(changeEvent);
    }

b、基于EnvironmentChangeEvent实现刷新

利用spring的事件驱动配合@ApolloConfigChangeListener监听实现bean的动态刷新，其代码如下

@Component
@Slf4j
public class UserPropertiesRefresh implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @ApolloConfigChangeListener(value="user.properties",interestedKeyPrefixes = {"user."})
    private void refresh(ConfigChangeEvent changeEvent){
        applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));

        PrintChangeKeyUtils.printChange(changeEvent);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

}

c、当bean上有@ConditionalOnProperty如何实现刷新

当bean上有@ConditionalOnProperty注解时，上述的两种方案可以说失效了，因为@ConditionalOnProperty是一个条件注解，当不满足条件注解时，bean是没法注册到spring容器中的。如果我们要实现此种情况的下的动态刷新，我们就得自己手动注册或者销毁bean了。其实现流程如下

1、当满足条件注解时，则手动创建bean，然后配合@ApolloConfigChangeListener监听该bean的属性变化。当该bean属性有变化时，手动把属性注入bean。同时刷新依赖该bean的其他bean

2、当不满足条件注解时，则手动从spring容器中移除bean，同时刷新依赖该bean的其他bean

其刷新核心代码如下

public class OrderPropertiesRefresh implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @ApolloConfig(value = "order.properties")
    private Config config;

    @ApolloConfigChangeListener(value="order.properties",interestedKeyPrefixes = {"order."},interestedKeys = {"model.isShowOrder"})
    private void refresh(ConfigChangeEvent changeEvent){
        for (String basePackage : listBasePackages()) {
            Set<Class> conditionalClasses = ClassScannerUtils.scan(basePackage, ConditionalOnProperty.class);
            if(!CollectionUtils.isEmpty(conditionalClasses)){
                for (Class conditionalClass : conditionalClasses) {
                    ConditionalOnProperty conditionalOnProperty = (ConditionalOnProperty) conditionalClass.getAnnotation(ConditionalOnProperty.class);
                    String[] conditionalOnPropertyKeys = conditionalOnProperty.name();
                    String beanChangeCondition = this.getChangeKey(changeEvent,conditionalOnPropertyKeys);
                    String conditionalOnPropertyValue = conditionalOnProperty.havingValue();
                    boolean isChangeBean = this.changeBean(conditionalClass, beanChangeCondition, conditionalOnPropertyValue);
                    if(!isChangeBean){
                        // 更新相应的bean的属性值，主要是存在@ConfigurationProperties注解的bean
                        applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));
                    }
                }
            }
        }

        PrintChangeKeyUtils.printChange(changeEvent);
        printAllBeans();
    }

    /**
     * 根据条件对bean进行注册或者移除
     * @param conditionalClass
     * @param beanChangeCondition bean发生改变的条件
     * @param conditionalOnPropertyValue
     */
    private boolean changeBean(Class conditionalClass, String beanChangeCondition, String conditionalOnPropertyValue) {
        boolean isNeedRegisterBeanIfKeyChange = this.isNeedRegisterBeanIfKeyChange(beanChangeCondition,conditionalOnPropertyValue);
        boolean isNeedRemoveBeanIfKeyChange = this.isNeedRemoveBeanIfKeyChange(beanChangeCondition,conditionalOnPropertyValue);
        String beanName = StringUtils.uncapitalize(conditionalClass.getSimpleName());
        if(isNeedRegisterBeanIfKeyChange){
            boolean isAlreadyRegisterBean = this.isExistBean(beanName);
            if(!isAlreadyRegisterBean){
                this.registerBean(beanName,conditionalClass);
                return true;
            }
        }else if(isNeedRemoveBeanIfKeyChange){
            this.unregisterBean(beanName);
            return true;
        }
        return false;
    }

    /**
     * bean注册
     * @param beanName
     * @param beanClass
     */
    public void registerBean(String beanName,Class beanClass) {
        log.info("registerBean->beanName:{},beanClass:{}",beanName,beanClass);
        BeanDefinitionBuilder beanDefinitionBurinilder = BeanDefinitionBuilder.genericBeanDefinition(beanClass);
        BeanDefinition beanDefinition = beanDefinitionBurinilder.getBeanDefinition();
        setBeanField(beanClass, beanDefinition);
        getBeanDefinitionRegistry().registerBeanDefinition(beanName,beanDefinition);

    }

    /**
     * 设置bean字段值
     * @param beanClass
     * @param beanDefinition
     */
    private void setBeanField(Class beanClass, BeanDefinition beanDefinition) {
        ConfigurationProperties configurationProperties = (ConfigurationProperties) beanClass.getAnnotation(ConfigurationProperties.class);
        if(ObjectUtils.isNotEmpty(configurationProperties)){
            String prefix = configurationProperties.prefix();
            for (String propertyName : config.getPropertyNames()) {
                String fieldPrefix = prefix + ".";
                if(propertyName.startsWith(fieldPrefix)){
                    String fieldName = propertyName.substring(fieldPrefix.length());
                    String fieldVal = config.getProperty(propertyName,null);
                    log.info("setBeanField-->fieldName:{},fieldVal:{}",fieldName,fieldVal);
                    beanDefinition.getPropertyValues().add(fieldName,fieldVal);
                }
            }
        }
    }

    /**
     * bean移除
     * @param beanName
     */
    public void unregisterBean(String beanName){
        log.info("unregisterBean->beanName:{}",beanName);
        getBeanDefinitionRegistry().removeBeanDefinition(beanName);
    }

    public  <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }

    public  <T> T getBean(Class<T> clz) {
        return (T) applicationContext.getBean(clz);
    }

    public boolean isExistBean(String beanName){
        return applicationContext.containsBean(beanName);
    }

    public boolean isExistBean(Class clz){
        try {
            Object bean = applicationContext.getBean(clz);
            return true;
        } catch (BeansException e) {
            // log.error(e.getMessage(),e);
        }
        return false;
    }

    private boolean isNeedRegisterBeanIfKeyChange(String changeKey,String conditionalOnPropertyValue){
        if(StringUtils.isEmpty(changeKey)){
            return false;
        }
        String apolloConfigValue = config.getProperty(changeKey,null);
        return conditionalOnPropertyValue.equals(apolloConfigValue);
    }

    private boolean isNeedRemoveBeanIfKeyChange(String changeKey,String conditionalOnPropertyValue){
        if(!StringUtils.isEmpty(changeKey)){
            String apolloConfigValue = config.getProperty(changeKey,null);
            return !conditionalOnPropertyValue.equals(apolloConfigValue);
        }

        return false;

    }

    private boolean isChangeKey(ConfigChangeEvent changeEvent,String conditionalOnPropertyKey){
        Set<String> changeKeys = changeEvent.changedKeys();
        if(!CollectionUtils.isEmpty(changeKeys) && changeKeys.contains(conditionalOnPropertyKey)){
            return true;
        }
        return false;
    }

    private String getChangeKey(ConfigChangeEvent changeEvent, String[] conditionalOnPropertyKeys){
        if(ArrayUtils.isEmpty(conditionalOnPropertyKeys)){
            return null;
        }
        String changeKey = null;
        for (String conditionalOnPropertyKey : conditionalOnPropertyKeys) {
            if(isChangeKey(changeEvent,conditionalOnPropertyKey)){
                changeKey = conditionalOnPropertyKey;
                break;
            }
        }

        return changeKey;
    }

    private BeanDefinitionRegistry getBeanDefinitionRegistry(){
        ConfigurableApplicationContext configurableContext = (ConfigurableApplicationContext) applicationContext;
        BeanDefinitionRegistry beanDefinitionRegistry = (DefaultListableBeanFactory) configurableContext.getBeanFactory();
        return beanDefinitionRegistry;
    }

    private List<String> listBasePackages(){
        ConfigurableApplicationContext configurableContext = (ConfigurableApplicationContext) applicationContext;
        return AutoConfigurationPackages.get(configurableContext.getBeanFactory());
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public  void printAllBeans() {
        String[] beans = applicationContext.getBeanDefinitionNames();
        Arrays.sort(beans);
        for (String beanName : beans) {
            Class<?> beanType = applicationContext.getType(beanName);
            System.out.println(beanType);
        }
    }

}

如果条件注解的值也是配置在apollo上，可能会出现依赖条件注解的bean的其他bean，在项目拉取apollo配置时，就已经注入spring容器中，此时就算条件注解满足条件，则引用该条件注解bean的其他bean，也会拿不到条件注解bean。此时有2种方法解决，一种是在依赖条件注解bean的其他bean注入之前，先手动注册条件注解bean到spring容器中，其核心代码如下

@Component
@Slf4j
public class RefreshBeanFactory implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        Config config = ConfigService.getConfig("order.properties");
        List<String> basePackages = AutoConfigurationPackages.get(configurableListableBeanFactory);
        for (String basePackage : basePackages) {
            Set<Class> conditionalClasses = ClassScannerUtils.scan(basePackage, ConditionalOnProperty.class);
            if(!CollectionUtils.isEmpty(conditionalClasses)){
                for (Class conditionalClass : conditionalClasses) {
                    ConditionalOnProperty conditionalOnProperty = (ConditionalOnProperty) conditionalClass.getAnnotation(ConditionalOnProperty.class);
                    String[] conditionalOnPropertyKeys = conditionalOnProperty.name();
                    String beanConditionKey = this.getConditionalOnPropertyKey(config,conditionalOnPropertyKeys);
                    String conditionalOnPropertyValue = conditionalOnProperty.havingValue();
                    this.registerBeanIfMatchCondition((DefaultListableBeanFactory)configurableListableBeanFactory,config,conditionalClass,beanConditionKey,conditionalOnPropertyValue);
                }
            }
        }

    }

    private void registerBeanIfMatchCondition(DefaultListableBeanFactory beanFactory,Config config,Class conditionalClass, String beanConditionKey, String conditionalOnPropertyValue) {
        boolean isNeedRegisterBean = this.isNeedRegisterBean(config,beanConditionKey,conditionalOnPropertyValue);
        String beanName = StringUtils.uncapitalize(conditionalClass.getSimpleName());
        if(isNeedRegisterBean){
                this.registerBean(config,beanFactory,beanName,conditionalClass);

        }

    }

    public void registerBean(Config config,DefaultListableBeanFactory beanFactory, String beanName, Class beanClass) {
        log.info("registerBean->beanName:{},beanClass:{}",beanName,beanClass);
        BeanDefinitionBuilder beanDefinitionBurinilder = BeanDefinitionBuilder.genericBeanDefinition(beanClass);
        BeanDefinition beanDefinition = beanDefinitionBurinilder.getBeanDefinition();
        setBeanField(config,beanClass, beanDefinition);
        beanFactory.registerBeanDefinition(beanName,beanDefinition);

    }

    private void setBeanField(Config config,Class beanClass, BeanDefinition beanDefinition) {
        ConfigurationProperties configurationProperties = (ConfigurationProperties) beanClass.getAnnotation(ConfigurationProperties.class);
        if(ObjectUtils.isNotEmpty(configurationProperties)){
            String prefix = configurationProperties.prefix();
            for (String propertyName : config.getPropertyNames()) {
                String fieldPrefix = prefix + ".";
                if(propertyName.startsWith(fieldPrefix)){
                    String fieldName = propertyName.substring(fieldPrefix.length());
                    String fieldVal = config.getProperty(propertyName,null);
                    log.info("setBeanField-->fieldName:{},fieldVal:{}",fieldName,fieldVal);
                    beanDefinition.getPropertyValues().add(fieldName,fieldVal);
                }
            }
        }
    }

    public boolean isNeedRegisterBean(Config config,String beanConditionKey,String conditionalOnPropertyValue){
        if(StringUtils.isEmpty(beanConditionKey)){
            return false;
        }
        String apolloConfigValue = config.getProperty(beanConditionKey,null);
        return conditionalOnPropertyValue.equals(apolloConfigValue);
    }

    private String getConditionalOnPropertyKey(Config config, String[] conditionalOnPropertyKeys){
        if(ArrayUtils.isEmpty(conditionalOnPropertyKeys)){
            return null;
        }
        String changeKey = null;
        for (String conditionalOnPropertyKey : conditionalOnPropertyKeys) {
            if(isConditionalOnPropertyKey(config,conditionalOnPropertyKey)){
                changeKey = conditionalOnPropertyKey;
                break;
            }
        }

        return changeKey;
    }

    private boolean isConditionalOnPropertyKey(Config config,String conditionalOnPropertyKey){
        Set<String> propertyNames = config.getPropertyNames();
        if(!CollectionUtils.isEmpty(propertyNames) && propertyNames.contains(conditionalOnPropertyKey)){
            return true;
        }
        return false;
    }

}

其次利用懒加载的思想，在使用条件注解bean时，使用形如下方法

Order order = (Order) SpringContextUtils.getBean("order");

总结

本文主要介绍了常用的动态刷新，但本文的代码示例实现的功能不局限于此，本文的代码还实现如何通过自定义注解与apollo整合来实现一些业务操作，同时也实现了基于hystrix注解与apollo整合，实现基于线程隔离的动态熔断，感兴趣的朋友可以复制文末链接到浏览器，进行查看

apollo基本上是能满足我们日常的业务开发要求，但是对于一些需求，比如动态刷新线上数据库资源啥，我们还是得做一定的量的改造，好在携程也提供了apollo-use-cases，在里面可以找到常用的使用场景以及示例代码，其链接如下

https://github.com/ctripcorp/apollo-use-cases

感兴趣的朋友，可以查看下。

最后

前端CSS面试题文档，JavaScript面试题文档，Vue面试题文档，大厂面试题文档，需要的读者可以戳这里免费领取！

，实现基于线程隔离的动态熔断，感兴趣的朋友可以复制文末链接到浏览器，进行查看

apollo基本上是能满足我们日常的业务开发要求，但是对于一些需求，比如动态刷新线上数据库资源啥，我们还是得做一定的量的改造，好在携程也提供了apollo-use-cases，在里面可以找到常用的使用场景以及示例代码，其链接如下

https://github.com/ctripcorp/apollo-use-cases

感兴趣的朋友，可以查看下。

最后

前端CSS面试题文档，JavaScript面试题文档，Vue面试题文档，大厂面试题文档，需要的读者可以戳这里免费领取！

[外链图片转存中…(img-kbkVbgKM-1627022365248)]

[外链图片转存中…(img-FstB4x7C-1627022365251)]

node.js高级知识点
关注
专栏目录
springboot+apollo+mybatis动态切换数据库
BroY499的博客
06-12 1387
这是一个可以动态获取配置并生效，不用重启服务的框架。 https://github.com/apolloconfig/apollo-build-scripts 搭建方式就不多说了，参考文档 四、Apollo更新后刷新数据库配置 五、配置文件 5.1 项目配置 5.2 Apollo 配置 spring.datasource.read.url = jdbc:mysql://127.0.0.1:3306/test?user=root&password=******&serverTimezone=Asia/Sh
apollo动态切换mysql数据源_apollo与springboot集成实现动态刷新配置
weixin_33603551的博客
03-03 926
分布式apollo简介Apollo(阿波罗)是携程框架部门研发的开源配置管理中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性。本文主要介绍如何使用apollo与springboot实现动态刷新配置，如果之前不了解apollo可以查看如下文档学习了解一下apollo，再来查看本文正文apollo与spring实现动态刷新配置本文主要...
apollo动态切换mysql数据源_springboot连接redis并动态切换database
weixin_42471590的博客
02-15 465
springboot连接redis并动态切换database众所周知，redis多有个db，在jedis中可以使用select方法去动态的选择redis的database，但在springboot提供的StringRedisTemplate中确，没有该方法，好在StringRedisTemplate预留了一个setConnectionFactory方法，本文主为通过修改ConnectionFact...
apollo动态切换mysql数据源_使用Apollo动态修改线上数据源
weixin_42297675的博客
02-02 491
前言最近需要实现一个功能，动态刷新线上数据源环境，下面来使用Apollo配置中心和Spring提供的AbstractRoutingDataSource来实现。具体实现Apollo是携程开源的统一配置中心，和springboot无缝衔接并且不需要安装其他软件就可以直接使用，可以实时推送最新的配置文件。Spring提供的AbstractRoutingDataSource用于动态管理数据源，可以动态更新...
vue面试题+web前端笔试题面试题汇总+前端优化总结+《Vue-框架开发》真题
06-20
- Vue面试题可能涵盖Vue的组件通信、生命周期、状态管理、性能优化等。 5. **《Vue-框架开发》期末考试试题** 这份文档可能包含Vue.js框架开发的深度问题，可能涵盖高级话题如Vuex的实现原理、Vue Router的配置...
web前端开发流程图，118页Vue面试题总结，完整PDF
m0_57064830的博客
06-10 9070
前言 年前准备换工作，总结了一波面试最频繁的面试问题跟大家交流。此文章是关于浏览器的常见问题，大概面试10家遇到6家提问类似问题（主要是大厂和中厂）。目前入职滴滴出行成都团队。 腾讯 一面 自我介绍 简单聊了一下教育背景，问了一下专业学过的课程 为什么选择前端开发 深挖了一下前端开发的项目经历 算法题：给一篇文章，统计文章中出现次数最多的单词，给出单词和次数（注意可能存在多个次数最大的单词） 讲一下正则表达式 了解网络通信吗，讲一下https 项目中有遇到过跨域吗，讲一下跨域 了解XSS攻击吗 了解les
web前端开发培训心得，118页Vue面试题总结
m0_60305230的博客
07-22 335
这篇文章我很早就想写了，工作至今（10年）我对于技术这个东西的体会也越来越多。今天触发我动键盘敲字的是一个事情：我在准备做一个golang内存模型的ppt，准备节后给组内同学分享。但是过程中遇到问题，就谷歌了一下，搜出了我自己16年写的一篇文章。。。我才记起来，16年我看雨痕大神的书的时候，研究过一阵子的内存模型。我越阅读文章越尴尬，倒不是因为文章有错误，而是因为我对这段知识点没有任何印象。于是，我和小白读者一样，重新和16年当时的我进行了知识的沟通。 于是我发了这么一篇微博： 对于这个事情，我首先是很庆
apollo切换mysql到达梦数据库
JAdroid的博客
11-27 1370
这个类是hibernate-core包下的，主要是针对schema、table、column等名称的转换，在之后的启动微服务中需要配置上对应的参数，要在这个。如果是用的apollo自带的eureka，则在参数中不需要配置eureka相关参数，最后执行启动就可以了。
采用最新版本SpringBoot2+MyBatis+Mysql+Apollo+Redis+Rabbitmq集成例子
03-13
采用最新版本SpringBoot2+MyBatis+Mysql+Apollo+Redis+Rabbitmq集成例子
apollo修改配置刷新bean_SpringBoot指定数据源配置 - 小窝蜗
weixin_39949584的博客
10-22 184
1.结合junit加载数据源开发、测试、生产都有各自的数据库，这样需要配置的数据源不一样。每次部署时修改配置过于繁琐，此时，可以使用Spring的Profile来配置多个数据源，运行前指定需要加载的数据源即可。 采用spring结合junit做演示，使用oracle和mysql做数据源区别演示，Profile名指定为oracle和mysql，junit测试时，使用@ActiveProfile...
携程 Apollo 配置中心 | 学习笔记（十五）| 如何通过Apollo配置中心与Spring Boot DataSource实现动态数据切换数据源
Coder编程的博客
06-28 4016
欢迎关注专栏，正文马上开始！
SpringBoot中如何通过AOP实现多数据源动态切换？
悠杨的专栏
11-25 1320
本文介绍了SpringBoot中，通过AOP实现多数据源动态切换的方法。
用Apollo来实现动态更新datasource
weixin_34233679的博客
08-01 3108
2019独角兽企业重金招聘Python工程师标准>>> ...
apollo客户端如何实时刷新配置数据？
最新发布
qq_27496129的博客
10-10 663
具体的 “RemoteConfigRepository.this.trySync();”请查看前文中对应的逻辑。
apollo动态切换mysql数据源_Apollo入门引导(二)：连接数据源
weixin_31083103的博客
02-15 815
从多个数据源获取数据。Apollo 入门引导 - 目录：完成时间：10 分钟现在已经构建了 schema，接下来需要将数据源连接到 Apollo 服务。数据源是存储用于填充 schema 字段数据的任何数据库、服务或 API。 GraphQL API 可以与几种数据源的任何组合进行交互。Apollo 提供了一个 DataSource 类，可以扩展该类以处理特定类型数据源的交互逻辑。在本节中，将扩展...
apollo配置中心源码针对相关数据源切换(mysql,oracle,达梦)
轩之宇的博客
06-15 971
apollo源码改在不同数据源切换
spring boot 配置中心 apollo 动态修改mysql数据源
weixin_42524843的博客
12-26 845
https://www.cnblogs.com/weiqihome/p/11939180.html
"深度学习Vue.js：面试题精华总结
Vue面试题总结 Vue.js是一个用于创建用户界面的开源JavaScript框架，也可以用于创建单页应用的Web应用框架。它在开发者中享有很高的满意度，并且在GitHub上也备受关注。本文将从浅入深来总结Vue.js相关的重点知识，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值