任性之闲来无事
任性之闲来无事

SOFABoot源码解析之JVM服务

1.SOFABoot源码解析

1.1  JVM服务

1.1.1 服务发布

        以SOFABoot自带的RPC案例sofaboot-sample-with-rpc为例，详细描述SOFABoot JVM服务发布过程。

        在此提前说明，源码分析主要分析主流程，以及本人认为比较重要的一些内容，对于其它部分，大家可以基于本文档，自行研读。

        RPC案例的SpringXML配置文件内容如下：

1. 
2.  3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.         xmlns:sofa="http://sofastack.io/schema/sofaboot"
5.         xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
6.              http://sofastack.io/schema/sofaboot  http://sofastack.io/schema/sofaboot.xsd"
7.         default-autowire="byName">
8.   
9.      
10.     
11.            
12.         
13.        
14.  
15.  
16.         
17.     
18.  
19.     
20.  
21.

        在SpringXML配置文件中：

        1.   通过XML元素bean定义PersonService接口实现类PersonServiceImpl；

        2.   通过XML元素sofa：service以jvm格式发布PersonService接口服务；

        启动本应用，启动流程在《启动原理》中已经详细描述，在此不再详述，直接从SpringXML配置文件加载Bean定义开始分析。

        一、   注册ServiceFactoryBean类对应的Bean定义

        调用AnnotationConfigEmbeddedWebApplicationContext（AbstractApplicationContext）.refresh())方法刷新Spring应用上下文过程，通过invokeBeanFactoryPostProcessors(beanFactory)方法调用beanFactory中所有实现了BeanFactoryPostProcessor接口的类。当调用到ConfigurationClassPostProcessor类processConfigBeanDefinitions方法时，在循环处理@Configuration配置类过程中，调用ConfigurationClassBeanDefinitionReader类loadBeanDefinitions(configClasses)方法，处理解析完成的@Configuration配置类。此时，其中有一步是调用ConfigurationClassBeanDefinitionReader类loadBeanDefinitionsFromImportedResources(configClass.getImportedResources())方法，加载@ImportResource注解里面配置的SpringXML配置文件中定义的Bean。在这个方法中，使用XMLBeanDefinitionReader加载SpringXML配置文件中定义的Bean。

        接下来就是SpringXML配置文件中各种标签的解析过程。

        对于XML标签bean，由于是最基本的SpringXML标签，大家都比较熟悉了，在此不再详述。

        对于XML标签sofa：service，其处理过程如下：

        XMLBeanDefinitionReader类调用DefaultBeanDefinitionDocumentReader类registerBeanDefinitions方法注册Bean定义。

        DefaultBeanDefinitionDocumentReader类调用BeanDefinitionParserDelegate类parseCustomElement方法解析自定义的XML元素。

        在此，对于XML标签sofa：service，根据命名空间sofa对应的值http://sofastack.io/schema/sofaboot，在spring.handlers(此文件位于infra-sofa-boot-starter.jar)文件中，查找到XML标签的处理类SofaBootNamespaceHandler：

1.  http\://sofastack.io/schema/sofaboot=com.alipay.sofa.infra.config.spring.namespace.handler.SofaBootNamespaceHandler

        在SofaBootNamespaceHandler类中，调用findParserForElement方法，查找指定XML元素的解析类，此处service对应的BeanDefinitionParser解析类为com.alipay.sofa.runtime.spring.parser.ServiceDefinitionParser。

        使用ServiceDefinitionParser类把SpringXML配置文件中sofa：service标签定义的服务转换为ServiceFactoryBean，并注册到Spring应用上下文中。

        二、  创建ServiceFactoryBean类的实例

        调用AnnotationConfigEmbeddedWebApplicationContext（AbstractApplicationContext）.refresh())方法刷新Spring应用上下文过程，通过finishBeanFactoryInitialization(beanFactory)方法实例化beanFactory中所有剩余的非延迟初始化的单例对象。

        当实例化ServiceFactoryBean时，由于ServiceFactoryBean实现了Initializing接口，所以在调用ServiceFactoryBean类的初始化方法时，会调用ServiceFactoryBean类的afterPropertiesSet方法，进行实例的初始化操作。

        到现在为止，开始JVM服务发布流程：

        1.   根据XML标签sofa:service所包含的子标签sofa:binding.*（一个或多个，此处是sofa:binding.jvm），解析出服务发布的类型，此处是jvm服务。

        2.   创建DefaultImplementation实例implementation，并设置其属性ref为SpringXML文件中sofa-service元素的ref属性中指定的接口实现，此处为SpringXML文件中id为personServiceImpl的com.alipay.sofa.boot.examples.demo.rpc.bean.PersonServiceImpl类的实例。

        3.   创建Service接口的实现ServiceImpl，其中，服务接口类型为com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService，接口模式为spring（表明此引用服务来自于SpringXML配置文件），target为ref（即id为personServiceImpl的PersonServiceImpl实例）。

        4.   如果解析出的bindings为空，则把JvmBinding增加到bindings列表中。此处，由于在SpringXML文件中只配置了binding.jvm，在第一步parseBindings方法中，由于jvm没有对应的BindingConverter实现，所以导致bindings为空。

        5.   把解析出的binding（此处为JvmBinding）增加到service实例的属性bindings列表中。

        6.   创建ServiceComponent实例componentInfo。

        7.   从sofaRuntimeContext实例中获取组件管理器实例componentManager，并调用其register方法注册刚才创建的服务组件componentInfo，具体注册操作在doRegister方法完成：

1.  private ComponentInfo doRegister(ComponentInfo ci) {
2.          ComponentName name = ci.getName();
3.          if (isRegistered(name)) {
4.              SofaLogger.error("Component was alreadyregistered: {0}", name);
5.              return getComponentInfo(name);
6.          }
7.   
8.          try {
9.              ci.register();
10.         } catch (Throwable e) {
11.             SofaLogger.error(e, "Failed toregister component: {0}", ci.getName());
12.             return null;
13.         }
14.  
15.         SofaLogger.info("Registeringcomponent: {0}", ci.getName());
16.  
17.         try {
18.             ComponentInfo old = registry.putIfAbsent(ci.getName(), ci);
19.             if (old != null) {
20.                 SofaLogger.error("Component wasalready registered: {0}", name);
21.                 return old;
22.             }
23.             if (ci.resolve()) {
24.                 typeRegistry(ci);
25.                 ci.activate();
26.             }
27.         } catch (Throwable e) {
28.             ci.exception(new Exception(e));
29.             SofaLogger.error(e, "Failed tocreate the component {0}", ci.getName());
30.         }
31.  
32.         return ci;
33.     }

  在组件管理器中注册组件的主要处理逻辑如下：

  • 获取组件名称，此处为service:com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService。
  • 判断组件管理器componentManager中是否存在指定名字的组件。如果有，则直接从组件管理器获取组件，并返回。如果没有，则继续注册流程。
  • 调用组件ServiceComponent类的register方法，更新组件状态为registered。
  • 把组件置入组件管理器的registry中（ConcurrentMap）。
  • 调用组件ServiceComponent类的resolve方法，更新组件状态为resolved。
  • 把组件置入组件管理器的resolvedRegistry中（ConcurrentMap>）。
  • 调用组件ServiceComponent的activate方法，激活组件，并更新组件状态为activated。
1.      public void activate() throwsServiceRuntimeException {
2.   
3.          activateBinding();
4.          super.activate();
5.      }

    调用activateBinding方法，激活服务组件的所有Binding。

1.  private void activateBinding() {
2.   
3.          Object target = service.getTarget();
4.          ……略
5.          if (service.hasBinding()) {
6.              boolean allPassed = true;
7.              Set bindings =service.getBindings();
8.              for(Binding binding : bindings) {
9.                  BindingAdapterbindingAdapter = this.bindingAdapterFactory
10.                     .getBindingAdapter(binding.getBindingType());
11.  
12.                 if (bindingAdapter == null) {
13.                     throw newServiceRuntimeException(……略);
14.                 }
15.  
16.                 Object outBindingResult;
17.                 ……略
18.                 try {
19.                     outBindingResult =bindingAdapter.outBinding(service, binding, target,
20.                         getContext());
21.                 } catch (Throwable t) {
22.                     allPassed = false;
23.                    ……略
24.                     continue;
25.                 }
26.                 if(!Boolean.FALSE.equals(outBindingResult)) {
27.                     ……略
28.                 } else {
29.                     binding.setHealthy(false);
30.                     SofaLogger.info("<31.                         binding.getBindingType(),service);
32.                 }
33.             }
34.  
35.             if (!allPassed) {
36.                 throw new ServiceRuntimeException(……略);
37.             }
38.         }
39.  
40.         SofaLogger.info("Register Service- {0}", service);
41.     }

    activateBinding方法主要处理逻辑如下：

  • 获取服务的目标类target；
  • 依次遍历服务所有Binding，分别为每种Binding发布服务，具体过程如下：根据Binding类型（此处为jvm），获取BindingAdapter接口的实现，此处为：com.alipay.sofa.runtime.service.binding.JvmBindingAdapter。调用JvmBindingAdapter类outBinding方法，对外发布服务：
1.      public Object outBinding(Object contract,JvmBinding binding, Object target,
2.                               SofaRuntimeContextsofaRuntimeContext) {
3.          return null;
4.      }

        由于是JVM服务，即只在同一个JVM中同一个应用的不同模块之间可以访问，同一个JVM中不同应用及JVM外部应用无法访问，所以此处outBinding方法为空方法，不对外提供任何服务。

        由此可以看出，发布JVM服务只是把服务组件置入组件管理器的registry中（ConcurrentMap），然后把服务组件的状态设置为activated，表示服务发布成功。

1.1.2 服务引用

        以SOFABoot自带的RPC案例sofaboot-sample-with-rpc为例，详细描述SOFABoot JVM服务引用过程。

        在此提前说明，源码分析主要分析主流程，以及本人认为比较重要的一些内容，对于其它部分，大家可以基于本文档，自行研读。

        RPC案例的SpringXML配置文件内容如下：

1. 
2.  3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.         xmlns:sofa="http://sofastack.io/schema/sofaboot"
5.         xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
6.              http://sofastack.io/schema/sofaboot   http://sofastack.io/schema/sofaboot.xsd"
7.         default-autowire="byName">
8.   
9.      
10.     
11.            
12.         
13.        
14.  
15.  
16.         
17.     
18.  
19.     
20.  
21.

        在SpringXML配置文件中：

        1.   通过XML元素bean定义PersonService接口实现类PersonServiceImpl；

        2.   通过XML元素sofa：reference引用jvm格式的PersonService接口服务；

        启动本应用，启动流程在《启动原理》中已经详细描述，在此不再详述，直接到从SpringXML配置文件加载Bean定义开始分析。

        一、   注册ReferenceFactoryBean类对应的Bean定义

        调用AnnotationConfigEmbeddedWebApplicationContext（AbstractApplicationContext）.refresh())方法刷新Spring应用上下文过程，通过invokeBeanFactoryPostProcessors(beanFactory)方法调用beanFactory中所有实现了BeanFactoryPostProcessor接口的类。

        当调用到ConfigurationClassPostProcessor类processConfigBeanDefinitions方法时，在循环处理@Configuration配置类过程中，调用ConfigurationClassBeanDefinitionReader类loadBeanDefinitions(configClasses)方法，处理解析完成的@Configuration配置类。此时，其中有一步是调用ConfigurationClassBeanDefinitionReader类loadBeanDefinitionsFromImportedResources(configClass.getImportedResources())方法，加载@ImportResource注解里面配置的SpringXML配置文件中定义的Bean。在这个方法中，使用XMLBeanDefinitionReader加载SpringXML配置文件中定义的Bean。

        接下来就是SpringXML配置文件中各种标签的解析过程。

        对于XML标签bean，由于是最基本的SpringXML标签，大家都应用比较熟悉了，在此不再详述。

        对于XML标签sofa：reference，其处理过程如下：

        XMLBeanDefinitionReader类调用DefaultBeanDefinitionDocumentReader类registerBeanDefinitions方法注册Bean定义；

        DefaultBeanDefinitionDocumentReader类调用BeanDefinitionParserDelegate类parseCustomElement方法解析自定义的XML元素。

        在此，对于XML标签sofa：reference，根据命名空间sofa对应的值http://sofastack.io/schema/sofaboot，在spring.handlers(此文件位于infra-sofa-boot-starter.jar)文件中，查找到XML标签的处理类SofaBootNamespaceHandler：

1.  http\://sofastack.io/schema/sofaboot=com.alipay.sofa.infra.config.spring.namespace.handler.SofaBootNamespaceHandler

在SofaBootNamespaceHandler类中，调用findParserForElement方法，查找指定XML元素的解析类，此处service对应的BeanDefinitionParser解析类为com.alipay.sofa.runtime.spring.parser.ReferenceDefinitionParser。

使用ReferenceDefinitionParser类把SpringXML配置文件中sofa：reference标签定义的服务转换为ReferenceFactoryBean，并注册到Spring应用上下文中。

        二、   创建ReferenceFactoryBean类的实例

        调用AnnotationConfigEmbeddedWebApplicationContext（AbstractApplicationContext）.refresh())方法刷新Spring应用上下文。

        当通过onRefresh() 方法调用createEmbeddedServletContainer方法，在调用DefaultListableBeanFactory类doGetBeanNamesForType(ResolvableType type, booleanincludeNonSingletons, boolean allowEagerInit)方法，获取类型为org.springframework.boot.context.embedded.EmbeddedServletContainerFactory的Bean名字时，会遍历beanFactory中所有beanDefinitionNames，判断每个beanName所代表的Bean定义RootBeanDefinition中beanClass是否与EmbeddedServletContainerFactory类型相匹配。当调用org.springframework.beans.factory.support.AbstractBeanFactory.isTypeMatch方法判断名为personReferenceRest的BeanDefinition对应的实例与EmbeddedServletContainerFactory是否类型匹配。由于XML标签sofa:reference被解析为ReferenceFactoryBean类，该类实现了FactoryBean接口，表明其为工厂Bean，所以为了查看此工厂Bean创建的实例的具体类型，必须实例化此工厂Bean，即ReferenceFactoryBean。至此，又会调用AbstractBeanFactory的getObject方法，获取此ReferenceFactoryBean创建的具体实例。

        当实例化ReferenceFactoryBean时，由于ReferenceFactoryBean实现了Initializing接口，所以在调用ReferenceFactoryBean类的初始化方法时，会调用ReferenceFactoryBean类的afterPropertiesSet方法，进行实例的初始化操作。

        到现在为止，开始JVM服务引用流程：

        1.  根据XML标签sofa:reference所包含的子标签sofa:binding.*（一个或多个，此处是sofa:binding.jvm），解析出服务引用的类型，此处是jvm服务。

        2.  设置ReferenceFactoryBean的bindings属性。由于在SpringXML文件中只配置了binding.jvm，并且jvm没有对应的BindingConverter实现，所以bindings为空。

        3.  创建Reference接口的实现ReferenceImpl，其中，引用的服务接口类型为com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService，接口模式为spring（表明此引用服务来自于SpringXML配置文件），jvmFirst为true（表示优先使用JVM服务，即在同一个JVM内部同一个应用不同模块之间服务调用方式）。

        4.  如果bindings为空，则把JvmBinding增加到bindings；

        5.  把bindings中第一个Binding（此处为JvmBinding）增加到reference实例的属性bindings集合中。

        6.  调用ReferenceRegisterHelper类registerReference方法：

1.  public static ObjectregisterReference(Reference reference,
2.                                             BindingAdapterFactorybindingAdapterFactory,
3.                                             SofaRuntimePropertiessofaRuntimeProperties,
4.                                             SofaRuntimeContextsofaRuntimeContext) {
5.          Binding binding = (Binding)reference.getBindings().toArray()[0];
6.   
7.          if(!binding.getBindingType().equals(JvmBinding.JVM_BINDING_TYPE)
8.              &&!sofaRuntimeProperties.isDisableJvmFirst() && reference.isJvmFirst()) {
9.              reference.addBinding(new JvmBinding());
10.         }
11.  
12.         ComponentManager componentManager =sofaRuntimeContext.getComponentManager();
13.         ReferenceComponent referenceComponent =new ReferenceComponent(reference,
14.             new DefaultImplementation(),bindingAdapterFactory, sofaRuntimeProperties,
15.             sofaRuntimeContext);
16.  
17.         if(componentManager.isRegistered(referenceComponent.getName())) {
18.             returncomponentManager.getComponentInfo(referenceComponent.getName())
19.                 .getImplementation().getTarget();
20.         }
21.  
22.         ComponentInfo componentInfo =componentManager.registerAndGet(referenceComponent);
23.         return componentInfo.getImplementation().getTarget();
24.  
25.     }

    注册Reference组件的主要步骤：

  • 获取reference实例包含的binding，此处为JvmBinding类型；
  • 如果binding不是JvmBinding类型，disableJvmFirst属性为false（表明全局开启jvmFirst），jvmFirst为true，则增加JvmBinding到reference实例的属性bindings集合中。此处binding为JvmBinding，所以直接跳过，继续后续流程；
  • 从sofaRuntimeContext实例中获取组件管理器实例componentManager；
  • 创建ReferenceComponent实例；
  • 判断组件管理器componentManager中是否存在指定名字的组件，例如：名称为reference:com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService:#342780926，如果有，则直接从组件管理器获取组件，并返回组件的实现的代理。如果没有，则在组件管理器中注册刚才创建的ReferenceComponent实例。具体的组件注册在doRegister方法中实现：
1.  private ComponentInfodoRegister(ComponentInfo ci) {
2.          ComponentName name = ci.getName();
3.          if (isRegistered(name)) {
4.              SofaLogger.error("Componentwas already registered: {0}", name);
5.              return getComponentInfo(name);
6.          }
7.   
8.          try {
9.              ci.register();
10.         } catch (Throwable e) {
11.             SofaLogger.error(e, "Failed toregister component: {0}", ci.getName());
12.             return null;
13.         }
14.  
15.         SofaLogger.info("Registeringcomponent: {0}", ci.getName());
16.  
17.         try {
18.             ComponentInfo old = registry.putIfAbsent(ci.getName(), ci);
19.             if (old != null) {
20.                 return old;
21.             }
22.             if (ci.resolve()) {
23.                 typeRegistry(ci);
24.                 ci.activate();
25.             }
26.         } catch (Throwable e) {
27.              ……略
28.         }
29.  
30.         return ci;
31.     }

    在组件管理器中注册组件的主要过程如下：

  • 调用组件ComponentInfo类的register方法，更新组件状态为registered。
  • 把组件置入组件管理器的registry中（ConcurrentMap）。
  • 调用组件ComponentInfo类的resolve方法，更新组件状态为resolved。
  • 把组件置入组件管理器的resolvedRegistry中（ConcurrentMap>）。
  • 调用组件ComponentInfo类的activate方法，激活组件，并更新组件状态为activated。
1.  public void activate() throwsServiceRuntimeException {
2.          if (reference.hasBinding()) {
3.              Binding candidate = null;
4.              Set bindings =reference.getBindings();
5.              if (bindings.size() == 1) {
6.                  candidate =bindings.iterator().next();
7.              } else if (bindings.size() > 1){
8.                  Object backupProxy = null;
9.                  for (Binding binding :bindings) {
10.                     if(JvmBinding.JVM_BINDING_TYPE.getType().equals(binding.getName())) {
11.                         candidate = binding;
12.                     } else {
13.                         backupProxy = createProxy(reference, binding);
14.                     }
15.                 }
16.                 if (candidate != null) {
17.                     ((JvmBinding)candidate).setBackupProxy(backupProxy);
18.                 }
19.             }
20.  
21.             Object proxy = null;
22.             if (candidate != null) {
23.                 proxy = createProxy(reference, candidate);
24.             }
25.  
26.             this.implementation = newDefaultImplementation();
27.             implementation.setTarget(proxy);
28.         }
29.  
30.         super.activate();
31.         latch.countDown();
32.     }

    在ComponentInfo类activate方法中，主要处理逻辑如下：

  • 获取ReferenceImpl中所有Binding。

        此处需要注意的是，在rpc.xsd文件中，规定XML标签sofa-reference只能有0个或1个Binding子元素。其可选子元素：binding.jvm、binding.bolt、binding.rest、binding.dubbo。

        如果设置多个Binding子元素，则在实例化时抛异常。

        如果不设置Binding子元素，则默认为JvmBinding。

        这个隐含的规则从这部分代码中无法体现，但影响其下面的处理逻辑。

        由此可知，Binding的个数只能为1或2。

        当Binding的个数当为1时，则只能是JvmBinding或其他类型Binding之一。

        当Binding的个数当为2时，则只能是JvmBinding和其他类型Binding之一。

        在下述三种情况下，ReferenceImpl中所有Binding的个数为1：

        ★ 当未设置Binding子元素，而采用默认的JvmBinding；

        ★ 设置Binding子元素为JvmBinding；

        ★ 设置一个其他类型的Binding，但disableJvmFirst为false，并且jvmFirst为true。

        在下述情况下，ReferenceImpl中所有Binding的个数为2：

        ★ 设置一个其他类型的Binding，但disableJvmFirst为true，或jvmFirst为false。

  • 如果Binding个数为1，其处理逻辑为：

        ★ 设置candidate（候选Binding）为当前Binding；

  • 如果Binding个数为2，其处理逻辑为：

        ★ 如果Binding类型为jvm，则设置candidate为JvmBinding。

        ★ 如果Binding类型为其它类型的Binding，如RestBinding，则调用createProxy(reference,binding)方法，根据Binding类型创建代理对象。

        ★ 设置JvmBinding的备选代理对象（backupProxy）为刚才创建的其它类型Binding的代理对象。

  • 如果candidate不为null，则调用createProxy(reference,candidate)方法，为候选Binding(candidate)创建代理对象proxy。否则，proxy为null。
  • 创建DefaultImplementation实例，并设置ReferenceComponent实例target属性为刚才为candidate创建的代理对象proxy。

    上述逻辑稍微有点复杂，简单来说就是：

  • 在优先使用JVM服务的前提下，如果配置了一个其它类型的服务，如Rest服务，则把它作为JVM服务的备选服务。当JVM服务不可用时，使用备选服务。如果没有配置其它类型服务，则JVM服务没有备选服务，当JVM服务不可用时，则服务不可用，调用失败。
  • 在不优先使用JVM服务的前提下，则只能使用配置的其它类型的服务，如Rest服务。

    在此案例中，设置candidate为JvmBinding。由于只设置了JvmBinding，没有设置其它类型的Binding，所以JvmBinding的备选代理对象为null。这样当JvmBinding不可用时，无备选方案可用。

    在此，我们主要关注一下通过createProxy方法为JvmBinding创建代理对象的过程：

1.  private Object createProxy(Referencereference, Binding binding) {
2.          BindingAdapterbindingAdapter = bindingAdapterFactory.getBindingAdapter(binding
3.              .getBindingType());
4.          ……略
5.          Object proxy;
6.          try {
7.              proxy = bindingAdapter.inBinding(reference,binding, sofaRuntimeContext);
8.          } finally {
9.              ……略
10.         return proxy;
11.     }

        根据Binding类型，通过BindingAdapterFactoryImpl类getBindingAdapter方法，获取指定Binding类型的Binding适配器，此处是JvmBindingAdapter。

        调用JvmBindingAdapter类inBinding方法创建代理对象：

1.      public Object inBinding(Object contract,JvmBinding binding,
2.                              SofaRuntimeContextsofaRuntimeContext) {
3.          return createServiceProxy((Contract)contract, binding, sofaRuntimeContext);
4.      }

        调用createServiceProxy方法：

1.  private Object createServiceProxy(Contractcontract, JvmBinding binding,
2.                                        SofaRuntimeContextsofaRuntimeContext) {
3.          ClassLoader newClassLoader;
4.          ClassLoader appClassLoader =sofaRuntimeContext.getAppClassLoader();
5.          Class javaClass =contract.getInterfaceType();
6.   
7.          try {
8.              Class appLoadedClass =appClassLoader.loadClass(javaClass.getName());
9.   
10.             if (appLoadedClass == javaClass) {
11.                 newClassLoader =appClassLoader;
12.             } else {
13.                 newClassLoader =javaClass.getClassLoader();
14.             }
15.         } catch (ClassNotFoundException e) {
16.             newClassLoader =javaClass.getClassLoader();
17.         }
18.  
19.         ClassLoader oldClassLoader =Thread.currentThread().getContextClassLoader();
20.  
21.         try {
22.             Thread.currentThread().setContextClassLoader(newClassLoader);
23.             ServiceProxy handler = newJvmServiceInvoker(contract, binding, sofaRuntimeContext);
24.             ProxyFactory factory = newProxyFactory();
25.             if (javaClass.isInterface()) {
26.                 factory.addInterface(javaClass);
27.             } else {
28.                 factory.setTargetClass(javaClass);
29.                 factory.setProxyTargetClass(true);
30.             }
31.             factory.addAdvice(handler);
32.             return factory.getProxy();
33.         } finally {
34.             Thread.currentThread().setContextClassLoader(oldClassLoader);
35.         }
36.     }

    在createServiceProxy方法中，创建服务代理的主要步骤如下：

  • 从sofaRuntimeContext获取应用类加载器appClassLoader，此处为：sun.misc.Launcher$AppClassLoader实例；
  • 设置javaClass为入参contract的getInterfaceType方法返回的接口类型，此处为com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService；
  • 使用应用类加载器appClassLoader加载服务接口PersonService；
  • 设置newClassLoader为javaClass对应的Class对象的类加载器；
  • 设置oldClassLoader为当前线程的上下文类加载器；
  • 设置当前线程的上下文类加载器为newClassLoader；
  • 设置handler，此处为ServiceProxy抽象类的子类JvmServiceInvoker的实例。该类继了ServiceProxy，而ServiceProxy实现了org.aopalliance.intercept.MethodInterceptor接口，表示此处创建AOP代理的方法拦截器。该AOP代理拦截器拦截对proxyClass指定的接口（例如：com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService）的方法调用，具体流程在后面详述；
  • 创建AOP代理工厂类org.springframework.aop.framework.ProxyFactory的实例factory；
  • 配置factory：如果javaClass为接口，则factory的interfaces列表中增加javaClass。否则，设置factory的targetClass为javaClass，proxyTarget为true；
  • 把指定的AOP advice实例handler增加到advice链尾部；
  • 调用factory的getProxy方法，为指定服务创建AOP代理对象。由于目标类是接口，则使用JDK动态代理技术。Spring使用JDK来生成代理对象，具体的生成代码放在org.springframework.aop.framework.JdkDynamicAopProxy这个类中。JdkDynamicAopProxy 同时实现了AopProxy和InvocationHandler接口，InvocationHandler是JDK动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。invoke主流程可以简述为：获取可以应用到此方法上的通知链（InterceptorChain），如果有，则应用通知，并执行joinpoint；如果通知链为空，则直接反射执行joinpoint。

    关于AOP代理对象的更多细节，在此不详细描述，有兴趣的同学自己在网上查资料看看。

    至此，JvmBinding的AOP代理对象创建完毕，此代理对象的handler为JdkDynamicAopProxy，实现了PersonService接口。

    接下来，创建DefaultImplementation实例，并设置ReferenceComponent实例target属性为刚才创建的candidate代理对象。

    设置ReferenceFactoryBean的proxy为刚才创建的AOP代理对象。这样，当其它类引用某个服务的ReferenceFactoryBean类时，由于此类为工厂Bean，所以通过getObject方法获取的实际对象为AOP代理对象。这样对生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。

    至此，JvmBinding类型的服务的代理对象创建完成。

1.1.3  客户端调用

        当我们在SpringXML文件中使用sofa:reference引用服务以后，就可以在其它类中引用创建的指定接口的代理对象，并像调用本地Java类那样，调用接口的某个方法。

        以下通过在Spring应用上下文中按照名字personReferenceJvm查找com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService接口的代理对象，然后调用其sayName方法，描述客户端调用Jvm服务的流程：

1.  public static void main(String[] args)throws InterruptedException {
2.       
3.        ConfigurableApplicationContext ac =SpringApplication.run(SofaBootRpcDemoApplication.class, args);
4.       
5.        PersonService personService = (PersonService)ac.getBean("personReferenceJvm");
6.       
7.        personService.sayName("Mike");
8.   
9.      }

        通过ConfigurableApplicationContext类getBean方法，获取名字为personReferenceJvm的实例，此时返回PersonService接口的AOP代理对象。此代理对象的handler为JdkDynamicAopProxy，实现了PersonService接口。

1.  public Object invoke(Object proxy, Methodmethod, Object[] args) throws Throwable {
2.       MethodInvocationinvocation;
3.       ObjectoldProxy = null;
4.       booleansetProxyContext = false;
5.   
6.       TargetSourcetargetSource = this.advised.targetSource;
7.       ClasstargetClass = null;
8.       Objecttarget = null;
9.   
10.      try{
11.          if(!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
12.              //The target does not implement the equals(Object) method itself.
13.              returnequals(args[0]);
14.          }
15.          elseif (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
16.              //The target does not implement the hashCode() method itself.
17.              returnhashCode();
18.          }
19.          elseif (method.getDeclaringClass() == DecoratingProxy.class) {
20.              //There is only getDecoratedClass() declared -> dispatch to proxy config.
21.              returnAopProxyUtils.ultimateTargetClass(this.advised);
22.          }
23.          elseif (!this.advised.opaque && method.getDeclaringClass().isInterface()&&
24.                  method.getDeclaringClass().isAssignableFrom(Advised.class)){
25.              //Service invocations on ProxyConfig with the proxy config...
26.              returnAopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
27.          }
28.  
29.          ObjectretVal;
30.  
31.          if(this.advised.exposeProxy) {
32.              //Make invocation available if necessary.
33.              oldProxy= AopContext.setCurrentProxy(proxy);
34.              setProxyContext= true;
35.          }
36.  
37.          //May be null. Get as late as possible to minimize the time we "own"the target,
38.          //in case it comes from a pool.
39.          target= targetSource.getTarget();
40.          if(target != null) {
41.              targetClass= target.getClass();
42.          }
43.  
44.          //Get the interception chain for this method.
45.          List chain =this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
46.  
47.          //Check whether we have any advice. If we don't, we can fallback on direct
48.          //reflective invocation of the target, and avoid creating a MethodInvocation.
49.          if(chain.isEmpty()) {
50.              //We can skip creating a MethodInvocation: just invoke the target directly
51.              //Note that the final invoker must be an InvokerInterceptor so we know it does
52.              //nothing but a reflective operation on the target, and no hot swapping or fancyproxying.
53.              Object[]argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
54.              retVal= AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
55.          }
56.          else{
57.              //We need to create a method invocation...
58.              invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
59.              //Proceed to the joinpoint through the interceptor chain.
60.              retVal = invocation.proceed();
61.          }
62.  
63.          //Massage return value if necessary.
64.          ClassreturnType = method.getReturnType();
65.          if(retVal != null && retVal == target &&returnType.isInstance(proxy) &&
66.                  !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())){
67.              //Special case: it returned "this" and the return type of the method
68.              //is type-compatible. Note that we can't help if the target sets
69.              //a reference to itself in another returned object.
70.              retVal= proxy;
71.          }
72.          elseif (retVal == null && returnType != Void.TYPE &&returnType.isPrimitive()) {
73.              thrownew AopInvocationException(
74.                      "Nullreturn value from advice does not match primitive return type for: " +method);
75.          }
76.          returnretVal;
77.      }
78.      finally{
79.          if(target != null && !targetSource.isStatic()) {
80.              //Must have come from TargetSource.
81.              targetSource.releaseTarget(target);
82.          }
83.          if(setProxyContext) {
84.              //Restore old proxy.
85.              AopContext.setCurrentProxy(oldProxy);
86.          }
87.      }
88. }

        获取PersonService接口sayName方法拦截器链，此处只有一个，即[com.alipay.sofa.runtime.service.binding.JvmBindingAdapter$JvmServiceInvoker@4d45094f]。

        为sayName方法创建一个ReflectiveMethodInvocation实例invocation，表示一个方法调用。

        调用ReflectiveMethodInvocation的proceed方法，执行拦截器链：

1.  public Object proceed() throws Throwable {
2.       //  We start with an index of -1 and incrementearly.
3.       if(this.currentInterceptorIndex ==this.interceptorsAndDynamicMethodMatchers.size() - 1) {
4.           returninvokeJoinpoint();
5.       }
6.       ObjectinterceptorOrInterceptionAdvice =            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
7.       if(interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher){
8.           ……略
9.       }
10.      else{
11.          //It's an interceptor, so we just invoke it: The pointcut will have
12.          //been evaluated statically before this object was constructed.
13.          return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
14.      }
15. }

        从interceptorsAndDynamicMethodMatchers中获取指定位置的拦截器，此处为com.alipay.sofa.runtime.service.binding.JvmBindingAdapter$JvmServiceInvoker的一个实例。

        调用JvmBindingAdapter$JvmServiceInvoker的invoke方法：

1.  public Object doInvoke(MethodInvocationinvocation) throws Throwable {
2.              if (binding.isDestroyed()) {
3.                  throw newIllegalStateException(……略);
4.              }
5.              ……略
6.              Object retVal;
7.              Object targetObj = this.getTarget();
8.   
9.              if ((targetObj == null ||((targetObj instanceof Proxy) && binding.hasBackupProxy()))) {
10.                 targetObj =binding.getBackupProxy();
11.                 ……略
12.             }
13.  
14.             if (targetObj == null) {
15.                 throw newIllegalStateException(……略);
16.             }
17.  
18.             ClassLoader tcl = Thread.currentThread().getContextClassLoader();
19.             try {
20.                 pushThreadContextClassLoader(sofaRuntimeContext.getAppClassLoader());
21.                 retVal = invocation.getMethod().invoke(targetObj,invocation.getArguments());
22.             } catch (InvocationTargetExceptionex) {
23.                 throw ex.getTargetException();
24.             } finally {
25.                ……略
26.                 popThreadContextClassLoader(tcl);
27.             }
28.  
29.             return retVal;
30.         }

        调用JvmBindingAdapter$JvmServiceInvoker的getTarget方法，获取目标类：

1.  protected Object getTarget() {
2.              if (this.target == null) {
3.                  ComponentName componentName =ComponentNameFactory.createComponentName(
4.                      ServiceComponent.SERVICE_COMPONENT_TYPE,getInterfaceName(),
5.                      contract.getUniqueId());
6.                  ComponentInfo componentInfo =sofaRuntimeContext.getComponentManager()
7.                      .getComponentInfo(componentName);
8.   
9.                  if (componentInfo != null) {
10.                     this.target =componentInfo.getImplementation().getTarget();
11.                 }
12.             }
13.  
14.             return target;
15.         }

        根据服务接口类型为服务组件创建ComponentName实例componentName，此处组件名的字符串值为service:com.alipay.sofa.boot.examples.demo.rpc.bean.PersonService；

        从sofaRuntimeContext实例获取组件管理器，然后调用组件管理器getComponentInfo方法，获取名为componentName的服务组件，即ServiceComponent实例；

        调用ServiceComponent类getImplementation方法，获取服务组件的属性implementation的值，即DefaultImplementation实例；

        最后，调用DefaultImplementation的getTarget方法，获取服务具体实现类实例，此处为PersonServiceImpl的实例。此值是在ServiceFactoryBean初始化时设置的。

        获取到target以后，判断target是否为null。如果为null，则设置target为候选代理对象（在一个接口发布多种类型的服务时，如Jvm、Rest等，则会为Jvm类型的服务设置一个候选，以便在Jvm服务不可用时，使用备选服务）。此处不为null，则继续服务调用。

        最后，通过Java反射机制，调用目标对象的某个方法，此处为PersonServiceImpl类sayName方法。到此为止，Jvm服务调用完成，返回结果。

1.1.4 服务端响应

        由于JVM服务调用是同一个JVM内Java本地方法调用，所以直接执行目标方法，并返回处理结果。

你可能感兴趣的:(SOFABoot,SpringBoot,SOFABoot,JVM服务,AOP代理对象,JVM服务发布与引用)

  • plc编程和python的联系_通过Python与西门子PLC通信 weixin_39788960 plc编程和python的联系
    供大家想要与西门子PLC通信的朋友使用1、该程序是通过pythonsnap7连接西门子1200、1500系列PLC并按照I、Q、M区采集打印信息；2、用户打开应用程序之前，要将目录下的snap7.dll、snap7.lib拷贝到C盘system32或syswow64目录下，具体根据系统版本而定；3、填写config配置文件和csv文件，其中config文件每行代表意思分别是：——》plc_ip=1
  • 自强学堂django学习笔记 人菜就要多透虚
    视图与网址进阶这里学到了正则表达式的解释url(r'^add/(\d+)/(\d+)/$',calc_views.add2,name='add2'),用括号括起来的意思是保存为一个子组，每一个子组将作为一个参数，被views.py中的对应视图函数接收。模板模板是可以继承的：以一个HTML文件为基础，拓展出其他的HTML模板模板进阶模板HTML上接收到一个参数是这么表示的{{string}}用两层花
  • java sqlite json_是否可以在SQLite中存储和查询JSON？ 西琴小竹 javasqlitejson
    我需要将JSON对象存储在SQLite数据库中,然后对它进行复杂的查询.我做了这样一张桌子：+--------------------------------------+|document|property|string|number|+--------------------------------------+|foo|"title"|"test"||+-------------------
  • 如何提升原力值-小白专享 快速实现赚钱小目标 肉三 道爷我悟了程序员创富业界资讯经验分享
    CSDN原力值提升秘籍：全面攻略与实战指南在CSDN这个充满技术活力的社区，原力值是衡量用户活跃度和影响力的重要指标。高原力值不仅代表着你在社区中的威望，还能为你带来更多的机会和资源。那么，如何才能有效提升原力值呢？今天，就为大家详细揭秘。一、内容创作：夯实基础，打造优质输出（一）发布高质量原创文章高质量原创文章是提升原力值的核心要素。它要求内容不仅要准确无误，更要深入、全面且具有独特的见解。例如
  • @EnableFeignClients 和 @FeignClient 在自动装配时失败 ‘FeignContext’ NoSuchBeanDefinitionException 肉三 Javajava开发语言
    我正在编写的微服务需要与我们平台中的其他微服务进行通信。对于这一尝试，对我们来说理想的解决方案是SpringCloudNetflixFeign，它实现了@FeignClient。但是，当我尝试时遇到以下异常@AutowiredReviewProvider：Causedby:org.springframework.beans.factory.NoSuchBeanDefinitionException
  • 为什么使用 char[] 而不是 String 作为密码存储的类型？ 肉三 Javajava开发语言
    在Swing中，密码字段有一个getPassword()(returnschar[])方法，而不是通常的getText()(returnsString)方法。同样，我遇到了一个建议不要使用它String来处理密码。为什么String说密码会有安全隐患呢？感觉用起来很不方便char[]。将密码收集并存储在类型的对象中似乎合乎逻辑java.lang.String。但是，这里有一个警告：Object类型
  • 使用RAG-Chroma与OpenAI构建高效问答系统 srudfktuffk 人工智能python
    在AI驱动的应用场景中，检索增强生成(Retrieval-AugmentedGeneration,RAG)是一种强大的技术，可以提升问答系统的精度和效能。在这篇文章中，我们将深入探讨如何使用Chroma与OpenAI结合，构建一个基于RAG的问答系统。技术背景介绍RAG是一种结合信息检索（IR）和自然语言生成（NLG）的技术。它通过先检索与问题相关的信息，然后生成答案，提高了问答系统的准确性和相关
  • 【YOLOv8改进 - 检测头】 RT-DETR检测头，解决传统目标检测器中非极大值抑制（NMS）所带来的速度和准确性之间的平衡问题 YOLO大师 YOLO人工智能论文阅读目标检测yolov8
    YOLO目标检测创新改进与实战案例专栏专栏目录：YOLO有效改进系列及项目实战目录包含卷积，主干注意力，检测头等创新机制以及各种目标检测分割项目实战案例专栏链接:YOLO基础解析+创新改进+实战案例介绍摘要YOLO系列因其在速度和准确性之间的合理平衡，已成为实时目标检测中最受欢迎的框架。然而，我们观察到YOLO的速度和准确性受到非极大值抑制（NMS）的负面影响。最近，基于Transformer的端
  • 使用Neo4j-Semantic-Ollama构建智能交互代理 safHTEAHE neo4joracle数据库python
    在现代应用中，结合图数据库与语义层的智能代理能够极大提升数据交互的效率和灵活性。本文将展示如何使用Neo4j-Semantic-Ollama模板来开发一个能够通过语义层与Neo4j图数据库交互的智能代理。我们将关注其如何利用Mixtral作为JSON格式的代理，通过用户意图与数据库进行交互。技术背景介绍Neo4j是一种高性能的图数据库，它适合于处理结构复杂的数据。在此基础上，加入语义层可以让应用程
  • 3d高斯泼溅学习 便携与感知组，研ing 3d
    椭球集就是一堆3d高斯椭球集之位置与形状：协方差矩阵(包括旋转矩阵和缩放矩阵)，要大多数都能表达实体的位置，实体的位置和形状要落在大概率范围内椭球集之球谐函数：代表球面上不同位置的值基函数，拟合颜色和形状1.球谐函数在形状上的拟合，阶数越高就越能描述原来的真实形状(用多项式(基函数)和傅立叶变换拟合)3d高斯Splatting里面用的是4阶的，参数量有16个拟合的函数r＝f(θ，φ)2.球谐函数在
  • Zerox：AI驱动的万能OCR工具，精准识别复杂布局并输出Markdown格式，支持PDF、DOCX、图片等多种文件格式 蚝油菜花 每日AI项目与应用实例人工智能ocrpdf人工智能开源
    ❤️如果你也关注AI的发展现状，且对AI应用开发非常感兴趣，我会每日分享大模型与AI领域的最新开源项目和应用，提供运行实例和实用教程，帮助你快速上手AI技术，欢迎关注我哦！微信公众号｜搜一搜：蚝油菜花快速阅读功能：支持零样本OCR识别，兼容PDF、DOCX、图片等多种格式文件。技术：基于GPT-4o-mini模型，能够处理复杂布局文档，输出Markdown格式结果。应用：提供API接口，便于集成到
  • FastAPI教程：快速构建高性能API 迪小莫学AI fastapipython
    FastAPI教程：快速构建高性能API介绍FastAPI是一个现代的、快速的（高性能）Web框架，用于构建APIs，基于标准的Python类型提示。它非常适合用于构建高效、易于维护的API服务。FastAPI支持自动生成文档，输入数据验证和异步编程，且性能接近Go和Node.js。本教程目标本教程将带领你构建一个简单的FastAPI应用，包括：1.创建FastAPI项目2.定义和处理API端点3
  • IGModel——提高基于 GNN与Attention 机制的方法在药物发现中的实用性 Jackie_AI 计算机视觉stablediffusion自然语言处理语言模型Imagen
    IGModel——提高基于GNN与Attention机制的方法在药物发现中的实用性导言深度学习在药物发现（发现治疗药物）领域的应用以及传统方法面临的挑战。药物（尤其是我们将在本文中讨论的被称为抑制剂的药物）通过与在人体中发挥不良功能的蛋白质结合并改变这些蛋白质的功能来发挥治疗效果。因此，在设计药物时，必须优化这些结合的亲和力和药理特性，并准确预测蛋白质与药物之间的相互作用。近年来，人们尤其提倡使用
  • 基于大数据的商品推荐系统的设计与实现 JAVA编码选手 个人作品案例展示分享大数据springbootmavenvue.js后端javascript
    摘要在当今互联网时代，随着电子商务的快速发展，各行各业都面临着海量数据的挑战和机遇，电子商务极大地改变了商业运作的方式，为消费者和企业带来了前所未有的便利和机会。该毕业设计以京东商品数据为来源，设计与实现基于大数据的电商商品推荐系统。通过对电商商品数据进行深度挖掘，可以发现消费趋势、产品热门度、价格以及地区差异等信息，为市场营销和产品策略提供重要参考。利用Java语言及SpringBoot框架、M
  • Arm64架构的Linux服务器安装tomcat并部署war包 木枫Free 服务器架构linuxtomcatarm运维
    一、下载Tomcat打开浏览器，访问ApacheTomcat官方网站。在下载页面中，选择适合arm64架构的版本。一般来说，可以选择Tomcat的二进制发行版（BinaryDistributions）中的.tar.gz压缩包。我这里下载的是tomcat9二、安装Tomcat将下载的Tomcat压缩包上传到欧鹏操作系统的服务器上，或者使用命令行工具（如wget）直接下载到服务器上。解压Tomcat压
  • 利用Ollama和OpenAI实现多查询RAG检索 jkgSFS 前端javascript开发语言python
    在这篇文章中，我们将探讨如何结合使用Ollama和OpenAI的多查询检索技术（RAG）来增强信息检索的准确性和效率。多查询检索器是一种查询转换的例子，它基于用户的输入查询生成多个不同视角的查询。对于每个查询，系统检索一组相关文档，并合并所有查询的独特联合体以进行答案合成。技术背景介绍RAG（Retrieval-AugmentedGeneration）是一种结合检索与生成的技术，它通过在生成答案之
  • 欧派家居被下调盈利预测：销售费用创新高，零售经销渠道压力不小 港湾商业观察 用户运营
    《港湾商业观察》王璐在房地产等多重因素冲击之下，上半年不少家居上市公司交出的业绩答卷都不尽理想，这其中也包括了消费者所熟知的“家居一哥”欧派家居（603833.SH）。从2023年下半年开始，胡歌的代言令全民对欧派家居印象更加深刻。上个月的中秋节时，欧派携手胡歌发布的2分钟10秒短片《明月如家》，也引发诸多关注。然而，种种措施似乎依然未能止住双位数下滑的业绩走势，欧派家居下半年可谓挑战重重。零售经
  • 【OpenCV 】第三章: 图像运算：加法运算、位运算、掩码、位平面分解、加密、数字水印、脸部打码 宝贝儿好 OpenCVopencv图像处理python算法
    第三章:图像运算图像加法运算1、"+"2、cv2.add()函数3、图像加权和：cv2.addWeighted()函数图像位运算(位逻辑运算)1、按位与运算：cv2.bitwise_and()函数2、按位或运算：cv2.bitwise_or()函数3、按位非运算：cv2.bitwise_not()函数4、按位异或运算：cv2.bitwise_xor()函数掩模(掩码)参数图像与数值的运算图像位平面
  • 华为HCIE面试问题-基于丢包问题处理步骤 eNSPLAB 华为HCIE面试问题华为面试职场和发展课程设计计算机网络安全网络
    文章目录思路定位1、流控方式统计丢包类型1.1拓扑图1.2原理讲解2、延迟问题2.1拓扑图2.2背景2.3原因2.4解决办法3、友商设备pingAR设备存在丢包，AR设备ping友商设备不丢包3.1原因3.2解决办法思路定位1、流控方式统计丢包类型1.1拓扑图1.2原理讲解R1与R2进行ping测试，使用ACL抓报文，用流统界定问题，配置如下：Aclnumber3333//配置ACLRule10p
  • Pytorch 自学笔记（三）：利用自定义文本数据集构建Dataset和DataLoader JimmyTotoro Pytorch自学笔记pytorch笔记人工智能
    Pytorch自学笔记（三）1.Dataset与DataLoader1.1torch.utils.data.Dataset1.2torch.utils.data.DataLoaderPytorch自学笔记系列的第三篇。针对Pytorch的Dataset和DataLoader进行简单的介绍，同时，介绍如何使用自定义文本数据集构建Dataset和DataLoader，以实现数据集的随机采样与batch
  • python PLC_IP协议 Modbus应用(一） Kamach_83 tcp/ip网络python模块测试
    在Python中与PLC建立通信，通常需要进行以下步骤：1.确定PLC的通信协议：不同的PLC厂商和型号可能采用不同的通信协议，例如Modbus、OPCUA、Profinet等。需要确定您的PLC使用的是哪种通信协议（本文为modbustcp）。2.安装相应的Python库：根据您所选择的PLC通信协议，在Python中安装相应的库。本文使用Modbus协议，故安装`pymodbus`库3.连接到
  • C 语言奇幻之旅 - 第03篇：C 语言基本语法 码力全開 C语言奇幻之旅c语言开发语言windows个人开发物联网
    文章目录引言1.程序结构：C语言的骨架1.1头文件引用1.1.1头文件的类型1.1.2`#include`的工作原理1.2main()函数-程序的入口1.2.1main()函数的参数1.2.2main()函数的返回值1.3一个简单的C程序示例1.4注意事项2.注释：代码的备忘录2.1单行注释2.2多行注释2.4条件编译与伪注释2.5注释的重要性2.6注释的最佳实践3.标识符与关键字：C语言的词汇3
  • Spring Boot中HttpMessageConverters的使用与实践 2501_90323865 springboot前端后端个人开发
    在SpringBoot应用开发中，HttpMessageConverters是一个非常实用的工具，它允许我们灵活地管理HTTP消息转换器（HttpMessageConverter），从而实现对请求和响应数据的自定义处理。本文将通过具体实例，详细介绍如何在SpringBoot中使用HttpMessageConverters来添加、替换默认转换器，以及如何将自定义转换器注册为Bean。一、HttpMe
  • MySQL进阶：SQL高级技巧 - 窗口函数（Window Function） 墨夶 数据库学习资料1mysqlsqlandroid
    MySQL进阶：SQL高级技巧-窗口函数（WindowFunction）❓引言：为什么需要了解窗口函数❓窗口函数（WindowFunction）是SQL标准中的一个高级特性，它允许用户在不改变查询结果集行数的情况下，对每一行执行聚合计算或其他复杂的计算。这些计算是基于当前行与结果集中其他行之间的关系进行的。窗口函数在处理复杂的统计分析问题时非常有用，例如移动平均、累计总和、百分比排名等。本文将深入
  • 基于CISCO PACKET TRACER企业网仿真的设计与实现 QWQ雨落轻尘 网络
    第1章背景1.1设计背景随着企业信息化建设不断深入，企业的生产业务系统、经营管理系统、办公自动化系统均得到大力发展，对于企业园区网的建设要求越来越高。传统园区网建设初期往往面临网络拓扑相对混乱，不便于对网络性能瓶颈进行正确评估和有效扩容，给日常网络管理也带来很大难度，对于网络可靠性考虑不够，网络中既存在单点故障导致网络可靠性低、影响企业生产和经营管理行为，同时也存在网络过度冗余、造成投资浪费的现象
  • 深入探秘 Java 网络编程：从基础到多线程服务器的全方位指南 2的n次方_ java网络服务器
    我的主页：2的n次方_Java作为一门功能强大的编程语言，不仅在桌面应用、移动开发、后端开发等领域表现出色，还在网络编程中拥有广泛的应用。网络编程涉及在两个或多个设备之间通过网络进行通信，这对于构建分布式系统、客户端-服务器应用程序、以及互联网服务至关重要。在这篇博客中，我们将详细探讨Java网络编程的基础知识，并通过代码示例展示如何在Java中实现网络通信。1.Java网络编程基础Java网络编
  • 2.6 聚焦：Word Embedding 少林码僧 AI大模型应用实战专栏wordembedding
    聚焦：WordEmbeddingWordEmbedding（词嵌入）是一种将词语转化为低维向量表示的技术，使得词语在数学空间中具有语义上的相似性。它是自然语言处理（NLP）中不可或缺的一部分，为文本数据提供了强大的表示能力。与传统的基于词频的词袋模型（Bag-of-Words）相比，WordEmbedding能够捕捉到词语之间更深层的语义和上下文信息。1.词嵌入的定义与作用WordEmbeddin
  • DETRs with Collaborative Hybrid Assignments Training论文阅读与代码 分享总结快乐 论文阅读
    关键词：协作混合分配训练【目标检测】Co-DETR：ATSS+FasterRCNN+DETR协作的先进检测器（ICCV2023）-CSDN博客摘要：在这篇论文中，作者观察到在DETR中将过少的Query分配为正样本，采用一对一的集合匹配，会导致对编码器输出的监督稀疏，严重损害编码器的区分特征学习，反之亦然，也会影响解码器中的注意力学习。为了缓解这个问题，作者提出了一种新颖的协同混合分配训练方案，名
  • SQLite 3.48.0 发布，有哪些更新？ 不剪发的Tony老师 SQLitesqlite数据库
    SQLite开发团队于2025年1月14日发布了SQLite3.48.0版本，我们来解读一下新版本的改进功能。EXPLAINQUERYPLANSQLite使用EXPLAINQUERYPLAN命令获取查询语句的执行计划，新版本改进了执行计划输出结果中的覆盖索引优化信息：sqlite>createtablet1(idint,nametext,priceint,desctext);sqlite>crea
  • 计算机创造的奇迹——C语言 UnwaterBreathing Cc语言开发语言
    一.简介C语言是一种较早的程序设计语言，诞生于1972年的贝尔实验室。1972年，DennisRitchie设计了C语言，它继承了B语言的许多思想，并加入了数据类型的概念及其他特性。尽管C语言是与UNIX操作系统一起被开发出来的，但它不只支持UNIX。C是一种通用（广泛可用）的编程语言。程序设计语言实与编译器是一体的，C编译器有著名的GCC（GNUCompilerCollection）等。广泛应用
  • jQuery 键盘事件keydown ,keypress ,keyup介绍 107x jsjquerykeydownkeypresskeyup
    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码 $('input').keyup(funciton(){      
  • AngularJS中的Promise bijian1013 JavaScriptAngularJSPromise
    一.Promise         Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。         为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
  • c++ 用数组实现栈类 CrazyMizzz 数据结构C++
    #include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
  • java和c语言的雷同 麦田的设计者 java递归scaner
    软件启动时的初始化代码，加载用户信息2015年5月27号 从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：      a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 不会再继续执行。      b、for循环相比于whi
  • LINUX环境并发服务器的三种实现模型 被触发 linux
    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1  循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
  • Oracle数据库查询指令 肆无忌惮_ oracle数据库
    20140920   单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录   -- 查看emp表   desc emp  
  • ext右下角浮动窗口 知了ing JavaScriptext
    第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
  • 浅谈REDIS数据库的键值设计 矮蛋蛋 redis
    http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
  • maven编译可执行jar包 alleni123 maven
    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
  • 人力资源在现代企业中的作用 百合不是茶 HR 企业管理
    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
  • Linux自启动设置详解 bijian1013 linux
    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 阅读之前建议先看一下附图。 本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
  • Spring Aop Schema实现 bijian1013 javaspringAOP
    本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
  • 【Gson七】Gson预定义类型适配器 bit1129 gson
    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，   DateTypeAdapter   public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。   Spark Streaming的解决方案是累加器，工作原理是，定义
  • linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 幸运的是systemtap的安装包里带了inodewatch.stp，位
  • java-两种方法求第一个最长的可重复子串 bylijinnan java算法
    import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
  • Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan javanetty
    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 文章里面提到的操作，每一步都能在Netty里面找到对应的代码 其中Reactor里面的Acceptor就对应Netty的ServerBo
  • servelt filter listener 的生命周期 cngolon filterlistenerservelt生命周期
    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
  • jmpopups获取input元素值 ctrain JavaScript
    jmpopups 获取弹出层form表单 首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 我们必须到jmpopups生成的代码中去查找这个值，$(
  • vi查找替换命令详解 daizj linux正则表达式替换查找vim
    一、查找 查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串 使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找 字符串匹配 pattern是需要匹配的字符串，例如： 1:  /abc<En
  • 对网站中的js,css文件进行打包 dcj3sjt126com PHP打包
    一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
  • php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
    在开发Yii 时，在程序中定义了如下方式：        if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
  • linux 文件格式（1） sed工具 eksliang linuxlinux sed工具sed工具linux sed详解
    转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介       sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
  • Android应用程序获取系统权限 gqdy365 android
    引用 如何使Android应用程序获取系统权限         第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：         1. 在应用程序的AndroidManifest.xml中的manifest节点
  • HoverTree开发日志之验证码 hvt .netC#asp.nethovertreewebform
    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
  • JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
    译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 基于 JSON API 的客户端还能够充分利用缓存，
  • 数据结构随记_2 lx.asymmetric 数据结构笔记
    第三章 栈与队列 一．简答题 1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  3. 向栈中压入元素的操作是先  移动栈顶指针&n
  • Linux下的监控工具dstat 网络接口 linux
    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
  • C 语言初级入门--二维数组和指针 1140566087 二维数组c/c++指针
    /* 二维数组的定义和二维数组元素的引用 二维数组的定义： 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法： 类型名 数组名[常量表达式1][常量表达式2] 二维数组的引用： 引用二维数组元素时必须带有两个下标，引用形式如下： 例如： int a[3][4];  引用：
  • 10点睛Spring4.1-Application Event wiselyman application
    10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段 应按照如下部分实现bean之间的消息通讯 继承ApplicationEvent类实现自己的事件 实现继承ApplicationListener接口实现监听事件 使用ApplicationContext发布消息