Spring Cloud OpenFeign底层实现原理

Spring Cloud OpenFeign底层实现原理

先说一下写这篇文章的一个原因，就是我被面试官吊打了，我只知道OpenFeign底层采用了RestTemplate进行调用，采用了动态代理，但是具体怎么实现的我就母鸡了。为了防止同样的地方摔倒，我决定我现在这里爬起来。

一 、简介

OpenFeign是Spring Cloud 在Feign的基础上支持了Spring MVC的注解，如@RequesMapping等等。
OpenFeign的@FeignClient可以解析SpringMVC的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务。

二、OpenFeign的使用

1. 引入依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. 启动类添加@EnableFeignClients注解

@EnableDiscoveryClient
@SpringBootApplication
@EnableFeignClients(basePackages = {"xx.xx"})
@ComponentScan(basePackages = {"xx.xx"})
public class TagApplication {public static void main(String[] args) {SpringApplication application = new SpringApplication(TagApplication.class);}
}

3. 编写业务类

@FeignClient(name = "user-service")
public interface BaseFeignApi {@GetMapping("/list")List<User> getList();
}

三、OpenFeign实现原理

1.@EnableFeignClients(basePackages = {"xx.xx"})注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {String[] value() default {};String[] basePackages() default {};Class<?>[] basePackageClasses() default {};Class<?>[] defaultConfiguration() default {};Class<?>[] clients() default {};
}

2.FeignClientsRegistrar类

2.1 FeignClientsRegistrar类
class FeignClientsRegistrarimplements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {....
}
2.2ImportBeanDefinitionRegistrar()函数
public interface ImportBeanDefinitionRegistrar {default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {this.registerBeanDefinitions(importingClassMetadata, registry);}default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {}
}

FeignClientsRegistrar本质是一个ImportBeanDefinitionRegistrar,并且持有环境变量和资源加载器的能力,FeignClientsRegistrar重写了registerBeanDefinitions方法,该方法在容器上下文刷新(启动时调用refresh)时被调用,调用时机此处不展开分析,我们看一下.

2.3FeignClientsRegistrar#registerBeanDefinitions()函数
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {// 处理@EnableFeignClients注解上的属性配置，将配置注册到容器仲registerDefaultConfiguration(metadata, registry);// 核心方法：注册@FeignClient对应的接口，奖@FeignClient注册到容器中registerFeignClients(metadata, registry);
}
2.4FeignClientsRegistrar#registerFeignClients()函数
	public void registerFeignClients(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {// 创建Spring内置的扫描器ClassPathScanningCandidateComponentProvider scanner = getScanner();scanner.setResourceLoader(this.resourceLoader);Set<String> basePackages;Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);// 获取 EnableFeignClients 注解中的 clients 属性值final Class<?>[] clients = attrs == null ? null: (Class<?>[]) attrs.get("clients");if (clients == null || clients.length == 0) {// 添加过滤器：过滤器所有被 @FeignClient 标记接口scanner.addIncludeFilter(annotationTypeFilter);basePackages = getBasePackages(metadata);}else {final Set<String> clientClasses = new HashSet<>();basePackages = new HashSet<>();for (Class<?> clazz : clients) {basePackages.add(ClassUtils.getPackageName(clazz));clientClasses.add(clazz.getCanonicalName());}AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {@Overrideprotected boolean match(ClassMetadata metadata) {String cleaned = metadata.getClassName().replaceAll("\\$", ".");return clientClasses.contains(cleaned);}};scanner.addIncludeFilter(new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));}// 处理@FeignClient类，解析for (String basePackage : basePackages) {Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);for (BeanDefinition candidateComponent : candidateComponents) {if (candidateComponent instanceof AnnotatedBeanDefinition) {// verify annotated class is an interfaceAnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();Assert.isTrue(annotationMetadata.isInterface(),"@FeignClient can only be specified on an interface");Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());String name = getClientName(attributes);registerClientConfiguration(registry, name,attributes.get("configuration"));// 重点方法，注入FeignClient对象registerFeignClient(registry, annotationMetadata, attributes);}}}}

第一部分是为了找到@Feignclient标识的接口类，第二部分就是对找出的接口类进行处理了处理，主要关注registerClientConfiguration和registerFeignClient函数。

其中registerClientConfiguration是为了处理@FeignClient#configuration属性的，在这个函数会往spirng容器中添加#{serviceName}.FeignClientSpecification作为名字的FeignClientSpecification类对象，例如user-center.FeignClientSpecification。

而registerFeignClient函数则是处理接口类的主要方法了。我们在之前考虑到，我们在接口上填写了@FeignClient注解，在之后程序中我们可以直接引用这个接口对象来调用接口上的函数，理论分析一波：接口如果没有实现类，是不能直接在spring中直接进行注入并调用相应的方法的，一定需要我们去实现这个接口，那么我们可以想到，OpenFeign中一定做了这样的操作。

接下来我们看一下registerFeignClient函数

2.5registerFeignClient()函数
	private void registerFeignClient(BeanDefinitionRegistry registry,AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {String className = annotationMetadata.getClassName();// 创建一个 BeanDefinitionBuilder 对象，用于构建并注入 FeignClientFactoryBeanBeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);// 参数校验validate(attributes);// 设置BeanDefinition参数definition.addPropertyValue("url", getUrl(attributes));definition.addPropertyValue("path", getPath(attributes));String name = getName(attributes);definition.addPropertyValue("name", name);String contextId = getContextId(attributes);definition.addPropertyValue("contextId", contextId);definition.addPropertyValue("type", className);definition.addPropertyValue("decode404", attributes.get("decode404"));definition.addPropertyValue("fallback", attributes.get("fallback"));definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);String alias = contextId + "FeignClient";AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be// nullbeanDefinition.setPrimary(primary);String qualifier = getQualifier(attributes);if (StringUtils.hasText(qualifier)) {alias = qualifier;}BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,new String[] { alias });// 注入接口实例BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);}

3. 接口代理对象的构建

3.1FeignClientFactoryBean类

OpenFeign 接口代理对象的构建，主要是通过 Spring 的扩展接口 FactoryBean<T> 来实现的。在上面的代码中，通过解析 FeignClient 对象，构建成一个 FeignClientFactoryBean 对象，Spring 在注入对应接口是，会调用 FeignClientFactoryBean 对象中的 getObject() 方法，返回注入对应的代理对象。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

class FeignClientFactoryBeanimplements FactoryBean<Object>, InitializingBean, ApplicationContextAware {@Overridepublic Object getObject() throws Exception {// 获取目标对象return getTarget();}/*** 获取目标对象* @param <T> the target type of the Feign client* @return a {@link Feign} client created with the specified data and the context* information*/<T> T getTarget() {FeignContext context = this.applicationContext.getBean(FeignContext.class);Feign.Builder builder = feign(context);// 判断当前 FeignClient 注解中的url是否为空，如果不为空，直接通过url的调用if (!StringUtils.hasText(this.url)) {if (!this.name.startsWith("http")) {this.url = "http://" + this.name;}else {this.url = this.name;}this.url += cleanPath();// 返回目标对象return (T) loadBalance(builder, context,new HardCodedTarget<>(this.type, this.name, this.url));}if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {this.url = "http://" + this.url;}String url = this.url + cleanPath();Client client = getOptional(context, Client.class);if (client != null) {if (client instanceof LoadBalancerFeignClient) {// not load balancing because we have a url,// but ribbon is on the classpath, so unwrapclient = ((LoadBalancerFeignClient) client).getDelegate();}if (client instanceof FeignBlockingLoadBalancerClient) {// not load balancing because we have a url,// but Spring Cloud LoadBalancer is on the classpath, so unwrapclient = ((FeignBlockingLoadBalancerClient) client).getDelegate();}builder.client(client);}Targeter targeter = get(context, Targeter.class);// 返回目标对象return (T) targeter.target(this, builder, context,new HardCodedTarget<>(this.type, this.name, url));}
}
3.2 Targeter#target()函数

HystrixTargeter类实现了Targeter。

class HystrixTargeter implements Targeter {@Overridepublic <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,FeignContext context, Target.HardCodedTarget<T> target) {if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {return feign.target(target);}feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName(): factory.getContextId();SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);if (setterFactory != null) {builder.setterFactory(setterFactory);}Class<?> fallback = factory.getFallback();if (fallback != void.class) {return targetWithFallback(name, context, target, builder, fallback);}Class<?> fallbackFactory = factory.getFallbackFactory();if (fallbackFactory != void.class) {return targetWithFallbackFactory(name, context, target, builder,fallbackFactory);}// 返回目标对象return feign.target(target);}
}
3.3 Feign对象

feign.target(target)函数

public abstract class Feign {public <T> T target(Target<T> target) {// 创建代理对象return this.build().newInstance(target);}public abstract <T> T newInstance(Target<T> target);/*** 构建 Feign对象*/public Feign build() {Client client = (Client)Capability.enrich(this.client, this.capabilities);Retryer retryer = (Retryer)Capability.enrich(this.retryer, this.capabilities);List<RequestInterceptor> requestInterceptors = (List)this.requestInterceptors.stream().map((ri) -> {return (RequestInterceptor)Capability.enrich(ri, this.capabilities);}).collect(Collectors.toList());Logger logger = (Logger)Capability.enrich(this.logger, this.capabilities);Contract contract = (Contract)Capability.enrich(this.contract, this.capabilities);Options options = (Options)Capability.enrich(this.options, this.capabilities);Encoder encoder = (Encoder)Capability.enrich(this.encoder, this.capabilities);Decoder decoder = (Decoder)Capability.enrich(this.decoder, this.capabilities);// 创建代理对象的 InvocationHandler 工厂实例InvocationHandlerFactory invocationHandlerFactory = (InvocationHandlerFactory)Capability.enrich(this.invocationHandlerFactory, this.capabilities);QueryMapEncoder queryMapEncoder = (QueryMapEncoder)Capability.enrich(this.queryMapEncoder, this.capabilities);Factory synchronousMethodHandlerFactory = new Factory(client, retryer, requestInterceptors, logger, this.logLevel, this.decode404, this.closeAfterDecode, this.propagationPolicy, this.forceDecoding);ParseHandlersByName handlersByName = new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder, this.errorDecoder, synchronousMethodHandlerFactory);return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);}
}

点击进入newInstance()函数

3.4ReflectiveFeign 对象

ReflectiveFeign继承了Feign

public class ReflectiveFeign extends Feign {
/*** 创建代理对象*/@Overridepublic <T> T newInstance(Target<T> target) {Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();// 解析模板：将方法解析，封装为MethodHandlerfor (Method method : target.type().getMethods()) {if (method.getDeclaringClass() == Object.class) {continue;} else if (Util.isDefault(method)) {DefaultMethodHandler handler = new DefaultMethodHandler(method);defaultMethodHandlers.add(handler);methodToHandler.put(method, handler);} else {methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));}}InvocationHandler handler = factory.create(target, methodToHandler);// 创建代理对象T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),new Class<?>[] {target.type()}, handler);for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {defaultMethodHandler.bindTo(proxy);}return proxy;}
}

看到这里就比较清晰了,把接口中的方法和默认实现放到Map<Method, MethodHandler>中然后使用InvocationHandlerFactory.Default()创建InvocationHandler,然后使用jdk动态代理生成接口的代理并返回,这里主要看一下Feign的InvocationHandler实现:

  static class FeignInvocationHandler implements InvocationHandler {private final Target target;private final Map<Method, MethodHandler> dispatch;FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {this.target = checkNotNull(target, "target");this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {if ("equals".equals(method.getName())) {try {Object otherHandler =args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;return equals(otherHandler);} catch (IllegalArgumentException e) {return false;}} else if ("hashCode".equals(method.getName())) {return hashCode();} else if ("toString".equals(method.getName())) {return toString();}return dispatch.get(method).invoke(args);}}

四、服务调用

正如我们前边所说,通过@Autowired或者@Resource注入的时候,注入的是被封装之后的代理类实现,
jdk动态代理持有的是ReflectiveFeign.FeignInvocationHandler类型的InvocationHandler,那么具体调用的时候,会调用FeignInvocationHandler#invoke()方法

4.1 FeignInvocationHandler对象
static class FeignInvocationHandler implements InvocationHandler { private final Target target;private final Map<Method, MethodHandler> dispatch;FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {this.target = checkNotNull(target, "target");this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {if ("equals".equals(method.getName())) {try {Object otherHandler =args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;return equals(otherHandler);} catch (IllegalArgumentException e) {return false;}} else if ("hashCode".equals(method.getName())) {return hashCode();} else if ("toString".equals(method.getName())) {return toString();}// 执行方法return dispatch.get(method).invoke(args);}}

前几个判断分支都是调用了Object的基本方法,最后dispatch.get(method).invoke(args)才是接口的业务方法调用,dispatch的类型是Map<Method, MethodHandler>,是接口中方法与MethodHandler的映射关系,而MethodHandler又被SynchronousMethodHandler.Factory封装成SynchronousMethodHandler(实现了MethodHandler):

4.2 SynchronousMethodHandler类

SynchronousMethodHandler类实现了MethodHandler。那么dispatch.get(method).invoke(args)最终调用的就是SynchronousMethodHandler#invoke()方法:

final class SynchronousMethodHandler implements MethodHandler {@Overridepublic Object invoke(Object[] argv) throws Throwable {// 构建请求的一个模版RequestTemplate template = buildTemplateFromArgs.create(argv);Options options = findOptions(argv);Retryer retryer = this.retryer.clone();while (true) {try {// 可以看到调用的时候默认是带有重试能力,默认是5次,具体调用交给executeAndDecode来实现:return executeAndDecode(template, options);} catch (RetryableException e) {try {retryer.continueOrPropagate(e);} catch (RetryableException th) {Throwable cause = th.getCause();if (propagationPolicy == UNWRAP && cause != null) {throw cause;} else {throw th;}}if (logLevel != Logger.Level.NONE) {logger.logRetry(metadata.configKey(), logLevel);}continue;}}}
}

可以看到调用的时候默认是带有重试能力,默认是5次,具体调用交给executeAndDecode来实现:

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {Request request = targetRequest(template);if (logLevel != Logger.Level.NONE) {logger.logRequest(metadata.configKey(), logLevel, request);}Response response;long start = System.nanoTime();try {// 通过 Client执行，进行远程调用response = client.execute(request, options);} catch (IOException e) {if (logLevel != Logger.Level.NONE) {logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));}throw errorExecuting(request, e);}long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);boolean shouldClose = true;try {if (logLevel != Logger.Level.NONE) {response =logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);}if (Response.class == metadata.returnType()) {if (response.body() == null) {return response;}if (response.body().length() == null ||response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {shouldClose = false;return response;}// Ensure the response body is disconnectedbyte[] bodyData = Util.toByteArray(response.body().asInputStream());return response.toBuilder().body(bodyData).build();}if (response.status() >= 200 && response.status() < 300) {if (void.class == metadata.returnType()) {return null;} else {Object result = decode(response);shouldClose = closeAfterDecode;return result;}} else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {Object result = decode(response);shouldClose = closeAfterDecode;return result;} else {throw errorDecoder.decode(metadata.configKey(), response);}} catch (IOException e) {if (logLevel != Logger.Level.NONE) {logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);}throw errorReading(request, response, e);} finally {if (shouldClose) {ensureClosed(response.body());}}}

核心是client.execute(),我们选择性看一下Default默认的实现:

@Override
public Response execute(Request request, Options options) throws IOException {HttpURLConnection connection = convertAndSend(request, options);return convertResponse(connection, request);
}

很明显,最终服务调用会委托给HttpURLConnection来执行,然后组装结果和状态码返回调用,到这里openfeign的服务调用就分析完了,为了帮助理解和有更直观的概念,我们看一下服务调用时序图:

在这里插入图片描述
图是我在网上找了一张，是OkHttpClient的，原理都是一样的，大家凑活看一下。

注意：

我们知道OpenFeign的底层默认会交给HttpURLConnection处理，HttpURLConnection是不支持连接池的。所以这里我们可以配置为HttpClient 或OkHttpClient等进行一个优化。具体配置如下：

feign:client:config:default:# 日志级别，这里是我本地开发环境设置为FULL，生产环境不建议设置为FULL，可以设置为HEADloggerLevel: FULL# 使用httpclient   httpclient:enabled: truemax-connections: 200max-connections-per-route: 50# OpenFeign第一次加载慢是因为底层采用了懒加载的方式，我们这里采用了饥饿加载的方式ribbon:eager-load:enabled: trueclients: easyexcelService

五、总结

  1. 通过 @EnableFeignCleints 触发 Spring 应用程序对 classpath 中 @FeignClient 修饰类的扫描
  2. 解析到 @FeignClient 修饰类后， Feign 框架通过扩展 Spring Bean Deifinition 的注册逻辑， 最终注册一个 FeignClientFacotoryBean 进入 Spring 容器
  3. Spring 容器在初始化其他用到 @FeignClient 接口的类时， 获得的是 FeignClientFacotryBean 产生的一个代理对象 Proxy.
  4. 基于 java 原生的动态代理机制， 针对 Proxy 的调用， 都会被统一转发给 Feign 框架所定义的一个 InvocationHandler ， 由该 Handler 完成后续的 HTTP 转换， 发送， 接收， 翻译HTTP响应的工作

感觉这块的逻辑还是有点难度的，我debug源码三四次才搞懂OpenFeign底层是如何创建代理对象，如何实现调用的。想要了解OpenFeign底层原理的同学可以自己手动debug一下源码看一看具体的执行流程。

纸上得来终觉浅，绝知此事要躬行。

参考：

  • https://blog.csdn.net/weixin_41821642/article/details/129874394?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171325961116800188518011%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=171325961116800188518011&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allbaidu_landing_v2~default-5-129874394-null-null.142v100pc_search_result_base4&utm_term=openfeign%E5%BA%95%E5%B1%82%E8%B0%83%E7%94%A8%E5%8E%9F%E7%90%86&spm=1018.2226.3001.4187

  • https://blog.csdn.net/bz120413/article/details/122215774?ops_request_misc=&request_id=&biz_id=102&utm_term=openfeign%E5%BA%95%E5%B1%82%E8%B0%83%E7%94%A8%E5%8E%9F%E7%90%86&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-3-122215774.142v100pc_search_result_base4&spm=1018.2226.3001.4187

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

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

相关文章

【可靠数据传输的原理】

【可靠数据传输的原理】

文章目录 可靠数据传输的原理可靠数据传输&#xff08;rdt&#xff09;的原理可靠数据传输&#xff1a;问题描述Rdt1.0&#xff1a; 在可靠信道上的可靠数据传输Rdt2.0&#xff1a;具有比特差错的信道rdt2.0&#xff1a;FSM描述rdt2.0&#xff1a;没有差错时的操作rdt2.0&#…
阅读更多...
数图可视化品类空间管理系统入编《零售门店数字化赋能专项报告（2024年）》

数图可视化品类空间管理系统入编《零售门店数字化赋能专项报告（2024年）》

数图可视化品类空间管理系统荣幸入编中国连锁经营协会发布的 《零售门店数字化赋能专项报告&#xff08;2024年&#xff09;》&#xff0c;报告以零售门店为切入点&#xff0c;通过引入“5P”的技术框架及梳理业内配套最佳实践方案&#xff0c;理出一套科学的、完整的零售门店数…
阅读更多...
内存管理（C/C++）

内存管理（C/C++）

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ &#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1…
阅读更多...
C语言转型之路：从C到C++的类与对象初探

C语言转型之路：从C到C++的类与对象初探

欢迎来CILMY23的博客 本篇主题为 C语言转型之路&#xff1a;从C到C的类与对象初探 个人主页&#xff1a;CILMY23-CSDN博客 个人专栏系列&#xff1a; Python | C语言 | 数据结构与算法 | C 感谢观看&#xff0c;支持的可以给个一键三连&#xff0c;点赞关注收藏。 写在前头…
阅读更多...
蜂窝物联：蜂窝云平台全介绍

蜂窝物联：蜂窝云平台全介绍

蜂窝云平台 PART 01 PC端展示平台 GIS地图 将地块嵌入到GIS地图展示&#xff0c;可以清晰展示各个地块所在地里位置&#xff0c;可以点击各个地块&#xff0c;在该界面可以清晰查看所选择地块的设备数据、监控画面、设备开关控制、基地介绍、基地图片等信息。 界面支持个化…
阅读更多...
【35分钟掌握金融风控策略8】策略评审

【35分钟掌握金融风控策略8】策略评审

目录 策略自动化开发系统 策略评审 策略评审流程 档案管理 策略评审文档设计和撰写 策略自动化开发系统 当前&#xff0c;金融机构大多注重提升金融风控相关的科技实力&#xff0c;希望依托科技降低风控门槛&#xff0c;提高风控效率&#xff0c;降低风控成本。 单维度策…
阅读更多...
快速掌握缓存技术：学习多个缓存供应商(ehcache,redis,memcached,jetcache,j2cache)

快速掌握缓存技术：学习多个缓存供应商(ehcache,redis,memcached,jetcache,j2cache)

缓存技术 缓存模拟缓存Spring缓存技术第三方缓存技术Ehcache缓存供应Redis缓存memcached缓存&#xff08;国内&#xff09; jetcache缓存供应商jetcache的基本使用设置外部服务设置本地服务 jetcache方法缓存j2cache 缓存 什么是缓存 缓存是一种介于数据永久存储介质与数据应用…
阅读更多...
C++ | Leetcode C++题解之第38题外观数列

C++ | Leetcode C++题解之第38题外观数列

题目&#xff1a; 题解&#xff1a; class Solution { public:string countAndSay(int n) {string prev "1";for (int i 2; i < n; i) {string curr "";int start 0;int pos 0;while (pos < prev.size()) {while (pos < prev.size() &&…
阅读更多...
【Elasticsearch】Elasticsearch 从入门到精通（一）：基本介绍

【Elasticsearch】Elasticsearch 从入门到精通（一）：基本介绍

Elasticsearch 从入门到精通&#xff08;一&#xff09;&#xff1a;基本介绍 1.Elasticsearch2.Elasticsearch 使用案例3.Elasticsearch 对比 Solr4.Elasticsearch 基本概念及架构4.1 Elasticsearch 基本概念4.1.1 索引 index4.1.2 映射 mapping4.1.3 字段 Field4.1.4 类型 Ty…
阅读更多...
基于SkyEye运行Qt：著名应用程序开发框架

基于SkyEye运行Qt：著名应用程序开发框架

Qt是一个著名的跨平台的C图形用户界面应用程序开发框架&#xff0c;目前包括Qt Creator、Qt Designer等等快速开发工具&#xff0c;还支持2D/3D图形渲染、OpenGL&#xff0c;允许真正的组件编程&#xff0c;是与GTK、MFC、OWL、ATL一样的图形界面库。使用Qt开发的软件可以做到一…
阅读更多...
【cygwin】工具安装apt-cyg

【cygwin】工具安装apt-cyg

目录 下载安装查看是否安装成功安装软件 下载 git clone https://github.com/transcode-open/apt-cyg.git安装 cd apt-cyg mv apt-cyg /usr/local/bin/ 查看是否安装成功 apt-cyg --help安装软件 apt-cyg install nano
阅读更多...
C++：模板详解

C++：模板详解

模板详解 1.函数模板1.概念2.语法3.原理4.实例化1.隐式实例化2.显示实例化 5.匹配原则 2.类模板1.格式2.实例化 3.非类型模板参数注意点 4.特化1.概念2.函数模板特化1.前提2.语法说明3.示例 3.类模板特化1.全特化2.偏特化/半特化3.选择顺序 4.按需实例化 5.模板的分离编译1.分离…
阅读更多...
lementui el-menu侧边栏占满高度且不超出视口

lementui el-menu侧边栏占满高度且不超出视口

做了几次老是忘记&#xff0c;这次整理好逻辑做个笔记方便重复利用&#xff1b; 问题&#xff1a;elementui的侧边栏是占不满高度的&#xff1b;但是使用100vh又会超出视口高度不美观&#xff1b; 解决办法&#xff1a; 1.获取到侧边栏底部到视口顶部的距离 2.获取到视口的高…
阅读更多...
运行django

运行django

确保app被注册 urls.py中编写url 视图对应关系 命令行启动 python manage.py runserver
阅读更多...
Bootstrap 5 保姆级教程（十一）：模态框 提示框

Bootstrap 5 保姆级教程（十一）：模态框 提示框

一、模态框 1.1 创建模态框 以下实例创建了一个简单的模态框效果 &#xff1a; <div class"container mt-3"><h3>模态框实例</h3><p>点击按钮打开模态框</p><button type"button" class"btn btn-primary" d…
阅读更多...
有哪些网站设计教程

有哪些网站设计教程

网站设计教程是帮助人们学习如何设计和开发网站的资源&#xff0c;它们提供了从基础知识到高级技巧的全方位指导。无论您是初学者还是经验丰富的开发者&#xff0c;都可以从这些教程中获益。下面是一些广受欢迎的网站设计教程&#xff0c;它们涵盖了各种技术和工具&#xff1a;…
阅读更多...
轻量级SQLite可视化工具Sqliteviz

轻量级SQLite可视化工具Sqliteviz

什么是 Sqliteviz &#xff1f; Sqliteviz 是一个单页面离线优先的渐进式网络应用&#xff08;PWA&#xff09;&#xff0c;用于完全客户端的 SQLite 数据库或 CSV 文件的可视化。 所谓完全客户端&#xff0c;就是您的数据库永远不会离开您的计算机。使用 sqliteviz&#xff0c…
阅读更多...
2024 抖音欢笑中国年之渲染技术实践与探索

2024 抖音欢笑中国年之渲染技术实践与探索

SAR Creator是一款基于 Typescript 的高性能、轻量化的互动解决方案&#xff0c;目前支持了浏览器和跨端框架平台&#xff0c;服务于字节内部的各种互动业务。 前言 抖音在2024年春节期间推出了欢笑中国年系列活动&#xff0c;为用户带来了全新的体验和乐趣。而SAR Creator则为…
阅读更多...
01 MySQL--概念、三范式、表、字段设计方法与规范

01 MySQL--概念、三范式、表、字段设计方法与规范

1. 定义 1.1 SQL的分类 DQL - 数据查询语言&#xff08;Data Query Language, DQL&#xff09;负责进行数据查询而不会对数据本身进行修改的语句。 SELECT、FROM、WHERE、GROUP BY、HAVING、ORDER BY。DDL - 数据定义语言 (Data Definition Language, DDL) 负责数据结构定义与…
阅读更多...
【RV1106的ISP使用记录之基础知识】硬件连接关系与设备树的构建

【RV1106的ISP使用记录之基础知识】硬件连接关系与设备树的构建

RV1106具备2个mipi csi2 dphy硬件&#xff0c;1个VICAP硬件和1个ISP硬件。其中&#xff1a; 1、mipi csi2 dphy 用于对数据流的解析&#xff0c;支持MIPC,LVDS,DVP三种接口&#xff1b; 2、VICAP用于数据流的捕获&#xff1b; 3、ISP用于对图像数据进行处理&#xff1b; 这三个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023