【吃透Java手写】5-RPC-简易版

【吃透Java手写】RPC-简易版-源码解析

  • 1 RPC
    • 1.1 RPC概念
    • 1.2 常用RPC技术或框架
    • 1.3 初始工程
      • 1.3.1 Productor-common：HelloService
      • 1.3.2 Productor：HelloServiceImpl
      • 1.3.3 Consumer
  • 2 模拟RPC
    • 2.1 Productor
    • 2.2 模拟一个RPC框架
      • 2.2.1 HttpServer
      • 2.2.2 HttpClient
      • 2.2.2 用rpc启动tomcat
      • 2.2.3 启动Productor
    • 2.3 DispatcherServlet
      • 2.3.1 Handler
      • 2.3.2 Invocation
      • 2.3.3 完善Handler
    • 2.4 注册中心LocalRegister
      • 2.4.1 Productor
    • 2.5 Handler
    • 2.6 Consumer测试
  • 3 优化
    • 3.1 ProxyFactory
    • 3.2 Consumer
    • 3.3 测试
  • 4 rpc服务注册和服务发现
    • 4.1 URL
    • 4.2 MapRemoteRegister
    • 4.3 注册中心注册
    • 4.4 负载均衡
    • 4.5 测试
      • 4.5.1 解决
    • 4.6 BootStrap
  • 5 服务重试

1 RPC

1.1 RPC概念

  1. RPC（Remote Procedure Call Protocol） 远程过程调用协议。
  2. RPC是一种通过网络从远程计算机程序上请求服务，不需要了解底层网络技术的协议。
  3. RPC主要作用就是不同的服务间方法调用就像本地调用一样便捷。

1.2 常用RPC技术或框架

  1. 应用级的服务框架：阿里的 Dubbo/Dubbox、Google gRPC、Spring Boot/Spring Cloud。
  2. 远程通信协议：RMI、Socket、SOAP(HTTP XML)、REST(HTTP JSON)。
  3. 通信框架：MINA 和 Netty

1.3 初始工程

在这里插入图片描述

1.3.1 Productor-common：HelloService

在Productor-common中创建com.sjb.HelloService

public interface HelloService {String sayHello(String name);
}

1.3.2 Productor：HelloServiceImpl

在Productor中创建com.sjb.HelloServiceImpl

public class HelloServiceImpl implements HelloService {@Overridepublic String sayHello(String name) {return "Hello, " + name;}
}

pom.xml依赖

<dependencies><dependency><groupId>org.example</groupId><artifactId>Productor-common</artifactId><version>1.0-SNAPSHOT</version></dependency>
</dependencies>

1.3.3 Consumer

在Consumer中创建com.sjb.Consumer

public class Consumer {public static void main(String[] args) {HelloService helloService = ?;System.out.println(helloService.sayHello("world"));}
}

pom.xml依赖

<dependencies><dependency><groupId>org.example</groupId><artifactId>Productor-common</artifactId><version>1.0-SNAPSHOT</version></dependency>
</dependencies>

2 模拟RPC

2.1 Productor

我们需要在springboot启动时完成一部分功能。启动时要能接收一部分功能的调用。只能通过网络来接收一定的请求，比如netty或者tomcat、socket。

在Productor中创建com.sjb.Productor

public class Productor {public static void main(String[] args) {//netty、tomcat}
}

2.2 模拟一个RPC框架

创捷sjbRPC模块，并且使Consumer模块和Productor模块依赖于sjbRPC模块

<dependency><groupId>org.example</groupId><artifactId>sjbRPC</artifactId><version>1.0-SNAPSHOT</version>
</dependency>

2.2.1 HttpServer

在sjbRPC模块中创建com.sjb.Productorcom.sjb.register.HttpServer，负责网络服务启动

public class HttpServer {public void start(String hostname, int port) {System.out.println("HttpServer start at " + hostname + ":" + port);}   
}

然后Productor就可以创建HttpServer对象调用里面的start方法

public class Productor {public static void main(String[] args) {//netty、tomcatHttpServer httpServer = new HttpServer();httpServer.start("localhost", 8080);}
}

2.2.2 HttpClient

创建com.sjb.protocol.HttpClient

public class HttpClient {public String send(String hostName, int port, Invocation invocation) {//读取用户的发送方式//http、netty、tcptry{URL url = new URL("http", hostName, port, "/");HttpURLConnection connection = (HttpURLConnection) url.openConnection();connection.setRequestMethod("POST");connection.setDoOutput(true);//配置OutputStream outputStream = connection.getOutputStream();ObjectOutputStream oos = new ObjectOutputStream(outputStream);//发送oos.writeObject(invocation);oos.flush();oos.close();//接收InputStream inputStream = connection.getInputStream();String result = IOUtils.toString(inputStream);return result;} catch (MalformedURLException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);}}
}

2.2.2 用rpc启动tomcat

为rpc添加tomcat依赖

<dependencies><dependency><groupId>org.apache.tomcat.embed</groupId><artifactId>tomcat-embed-core</artifactId><version>8.5.31</version></dependency>
</dependencies>

rpc第一步应当扫描当前模块的配置，获取需要启动的网络服务，这里写死直接启动tomcat

在com.sjb.register.HttpServer#start中

public void start(String hostname, int port) {//1.读取用户的配置（application.yaml或者Nacos配置）//2.这里启动一个TomcatTomcat tomcat = new Tomcat();Server server = tomcat.getServer();Service service = server.findService("Tomcat");Connector connector = new Connector();connector.setPort(port);Engine engine = new StandardEngine();engine.setDefaultHost(hostname);Host host = tomcat.getHost();host.setName(hostname);String contextPath = "";Context context = new StandardContext();context.setPath(contextPath);context.addLifecycleListener(new Tomcat.FixContextListener());host.addChild(context);engine.addChild(host);service.setContainer(engine);service.addConnector(connector);try{tomcat.start();tomcat.getServer().await();}catch (LifecycleException e){e.printStackTrace();}
}

2.2.3 启动Productor

public class Productor {public static void main(String[] args) {//netty、tomcatHttpServer httpServer = new HttpServer();httpServer.start("localhost", 8080);}
}

D:\Software\software_with_code\idea\jdk\jdk-17\bin\java.exe "-javaagent:D:\Software\software_with_code\idea\software\IntelliJ IDEA 2023.2\lib\idea_rt.jar=13802:D:\Software\software_with_code\idea\software\IntelliJ IDEA 2023.2\bin" -Dfile.encoding=UTF-8 -classpath D:\Code\JavaCode\handwith-Spring\handwith-Spring\RPC\Productor\target\classes;D:\Code\JavaCode\handwith-Spring\handwith-Spring\RPC\Productor-common\target\classes;D:\Code\JavaCode\handwith-Spring\handwith-Spring\RPC\sjbRPC\target\classes;D:\Software\software_with_code\apache-maven-3.9.5-bin\apache-maven-3.9.5\mvn_repo\org\apache\tomcat\embed\tomcat-embed-core\8.5.31\tomcat-embed-core-8.5.31.jar;D:\Software\software_with_code\apache-maven-3.9.5-bin\apache-maven-3.9.5\mvn_repo\org\apache\tomcat\tomcat-annotations-api\8.5.31\tomcat-annotations-api-8.5.31.jar com.sjb.Productor
5月 13, 2024 1:26:00 下午 org.apache.coyote.AbstractProtocol init
信息: Initializing ProtocolHandler ["http-nio-8080"]
5月 13, 2024 1:26:00 下午 org.apache.tomcat.util.net.NioSelectorPool getSharedSelector
信息: Using a shared selector for servlet write/read
5月 13, 2024 1:26:00 下午 org.apache.catalina.core.StandardService startInternal
信息: Starting service [Tomcat]
5月 13, 2024 1:26:00 下午 org.apache.catalina.core.StandardEngine startInternal
信息: Starting Servlet Engine: Apache Tomcat/8.5.31
5月 13, 2024 1:26:01 下午 org.apache.catalina.util.SessionIdGeneratorBase createSecureRandom
警告: Creation of SecureRandom instance for session ID generation using [SHA1PRNG] took [117] milliseconds.
5月 13, 2024 1:26:01 下午 org.apache.coyote.AbstractProtocol start
信息: Starting ProtocolHandler ["http-nio-8080"]

2.3 DispatcherServlet

大家如果学过Spring MVC的底层原理就会知道，在SpringMVC中有一个Servlet非常核心，那就是DispatcherServlet，这个DispatcherServlet需要绑定一个Spring容器，因为DispatcherServlet接收到请求后，就会从所绑定的Spring容器中找到所匹配的Controller，并执行所匹配的方法，所有的服务都会放入DispatchServlet中。我们rpc框架启动的服务也要放入DispatcherServlet

在com.sjb.protocol.HttpServer#start中

tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet());
context.addServletMappingDecoded("/*", "dispatcher");try{tomcat.start();tomcat.getServer().await();
}
catch (LifecycleException e){e.printStackTrace();

context.addServletMappingDecoded("/*", "dispatcher");接收到的请求都会交由dispatcher处理

创建com.sjb.register.DispatcherServlet

public class DispatcherServlet extends HttpServlet {@Overridepublic void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {new HttpServerHandler().handle(req, res);}
}

2.3.1 Handler

创建com.sjb.register.HttpServerHandler，因为有可能有很多请求请求dispatcher，相当于一个过滤器的作用，相当可以用每一个请求都可以用一个独立的handler类处理，也就是new一个新handler来处理。

public class HttpServerHandler {public void handle(ServletRequest req, ServletResponse res) {//处理请求}
}

2.3.2 Invocation

创建com.sjb.common.Invocation，记录传入的接口名、方法名、参数列表、参数值

implements Serializable序列化是方便解析request

public class Invocation implements Serializable {private String interfaceName;private String methodName;private Class[] paramTypes;private Object[] params;public String getInterfaceName() {return interfaceName;}public void setInterfaceName(String interfaceName) {this.interfaceName = interfaceName;}public String getMethodName() {return methodName;}public void setMethodName(String methodName) {this.methodName = methodName;}public Class[] getParamTypes() {return paramTypes;}public void setParamTypes(Class[] paramTypes) {this.paramTypes = paramTypes;}public Object[] getParams() {return params;}public void setParams(Object[] params) {this.params = params;}public Invocation(String interfaceName, String methodName, Class[] paramTypes, Object[] params) {this.interfaceName = interfaceName;this.methodName = methodName;this.paramTypes = paramTypes;this.params = params;}
}

2.3.3 完善Handler

public class HttpServerHandler {public void handle(ServletRequest req, ServletResponse res) {//处理请求-->接口，方法，参数try {Invocation invocation=(Invocation)new ObjectInputStream(req.getInputStream()).readObject();String interfaceName=invocation.getInterfaceName();} catch (IOException e) {throw new RuntimeException(e);} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}
}

这样就获取到调用请求的类的接口，那么怎么找到接口的实现类呢？如果是扫描全包查看谁实现了HelloService这样性能就非常的低。所以我们需要一个注册中心。

2.4 注册中心LocalRegister

创建com.sjb.register.LocalRegister

public class LocalRegister {private static Map<String, Class> map = new HashMap<>();public static void register(String interfaceName, Class implClass) {map.put(interfaceName, implClass);}public static Class get(String interfaceName) {return map.get(interfaceName);}
}

2.4.1 Productor

这样就可以在Productor中将接口和实现类放入，在com.sjb.Productor中

public class Productor {public static void main(String[] args) {//注册服务LocalRegister.register(HelloService.class.getName(), HelloServiceImpl.class);//netty、tomcatHttpServer httpServer = new HttpServer();httpServer.start("localhost", 8080);}
}

这样在Handler中就可以从LocalRegister的map中拿到对应的接口和实现类

2.5 Handler

添加commons-io依赖

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-io</artifactId><version>1.3.2</version>
</dependency>

public class HttpServerHandler {public void handle(ServletRequest req, ServletResponse res) {//处理请求-->接口，方法，参数try {Invocation invocation=(Invocation)new ObjectInputStream(req.getInputStream()).readObject();String interfaceName=invocation.getInterfaceName();Class implClass= LocalRegister.get(interfaceName);Method method = implClass.getMethod(invocation.getMethodName(), invocation.getParamTypes());Object result = method.invoke(implClass.newInstance(), invocation.getParams());//res.getOutputStream().write(invoke.toString().getBytes());IOUtils.write(result.toString(), res.getOutputStream());} catch (IOException e) {throw new RuntimeException(e);} catch (ClassNotFoundException e) {throw new RuntimeException(e);} catch (NoSuchMethodException e) {throw new RuntimeException(e);} catch (InvocationTargetException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);} catch (InstantiationException e) {throw new RuntimeException(e);}}
}
  • Invocation invocation=(Invocation)new ObjectInputStream(req.getInputStream()).readObject();反序列化获取invocation
  • String interfaceName=invocation.getInterfaceName();获取接口名
  • Class implClass= LocalRegister.get(interfaceName);通过注册中心获取接口实现类
  • Method method = implClass.getMethod(invocation.getMethodName(), invocation.getParamTypes());获取实现类中的方法
  • Object result = method.invoke(implClass.newInstance(), invocation.getParams());执行方法返回返回值
  • IOUtils.write(result.toString(), res.getOutputStream());写入response中

2.6 Consumer测试

public class Consumer {public static void main(String[] args) {
//        HelloService helloService = ?;
//        System.out.println(helloService.sayHello("world"));Invocation invocation = new Invocation(HelloService.class.getName(), "sayHello", new Class[]{String.class}, new Object[]{"world"});HttpClient httpClient = new HttpClient();String result = httpClient.send("localhost", 8080, invocation);System.out.println(result);}
}

输出

Hello, world

3 优化

我们想让网络调用像调用本地方法一样，创建一个HelloService对象，直接传参就好了

HelloService helloService = ?;
System.out.println(helloService.sayHello("world"));

所以我们需要在rpc框架中创建一个代理对象代理HelloService

3.1 ProxyFactory

创建com.sjb.proxy.ProxyFactory

public class ProxyFactory {public static <T> T getProxy(Class interfaceClass) {//读取用户配置Object proxyInstance = Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Invocation invocation = new Invocation(interfaceClass.getName(),method.getName(),method.getParameterTypes(),args);HttpClient httpClient = new HttpClient();String result = httpClient.send("localhost", 8080, invocation);return result;}});return (T) proxyInstance;}}

3.2 Consumer

public class Consumer {public static void main(String[] args) {
//        HelloService helloService = ?;
//        System.out.println(helloService.sayHello("world"));HelloService helloService = ProxyFactory.getProxy(HelloService.class);System.out.println(helloService.sayHello("world"));}
}

helloService.sayHello("world")调用invoke方法返回

3.3 测试

Hello, world

4 rpc服务注册和服务发现

我们希望String result = httpClient.send("localhost", 8080, invocation);在send的时候可以灵活的找到传入的接口对应的ip和端口是多少，也就是应用所对应的ip和端口是多少，所以就自然而然的想到注册中心，在Productor创建的时候，将对应服务的ip和端口保存到rpc中起来，以供其他服务使用。

在这里插入图片描述

4.1 URL

public class URL {private String hostname;private Integer port;

这样我们Productor启动的时候，不仅需要注册服务，还要注册注册中心

4.2 MapRemoteRegister

创建com.sjb.register.MapRemoteRegister

public class MapRemoteRegister {private static Map<String, List<URL>> mapRemoteRegister = new HashMap<>();public static void register(String interfaceName,URL url) {List<URL> list = mapRemoteRegister.get(interfaceName);if (list == null) {list = new java.util.ArrayList<>();}list.add(url);mapRemoteRegister.put(interfaceName, list);}public static List<URL> get(String interfaceName) {return mapRemoteRegister.get(interfaceName);}
}

4.3 注册中心注册

public class Productor {public static void main(String[] args) {//注册服务LocalRegister.register(HelloService.class.getName(), HelloServiceImpl.class);//注册中心注册URL url = new URL("localhost", 8080);MapRemoteRegister.register(HelloService.class.getName(), url);

那么在创建HelloService的代理对象时，就要读取注册中心

public class ProxyFactory {public static <T> T getProxy(Class interfaceClass) {//读取用户配置Object proxyInstance = Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Invocation invocation = new Invocation(interfaceClass.getName(),method.getName(),method.getParameterTypes(),args);HttpClient httpClient = new HttpClient();//服务发现List<URL> urls = MapRemoteRegister.get(interfaceClass.getName());//负载均衡URL url = LoadBalance.random(urls);//服务调用String result = httpClient.send(url.getHostname(), url.getPort(), invocation);return result;}});return (T) proxyInstance;}}

4.4 负载均衡

创建com.sjb.loadbalance.LoadBalance

public class LoadBalance {public static URL random(List<URL> list) {int i = new Random().nextInt(list.size());return list.get(i);}
}

4.5 测试

感觉没问题，测试一下

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.util.List.size()" because "list" is nullat com.sjb.loadbalance.LoadBalance.random(LoadBalance.java:10)at com.sjb.proxy.ProxyFactory$1.invoke(ProxyFactory.java:29)at jdk.proxy1/jdk.proxy1.$Proxy0.sayHello(Unknown Source)at com.sjb.Consumer.main(Consumer.java:11)

报错，发现在Product中

//注册服务
LocalRegister.register(HelloService.class.getName(), HelloServiceImpl.class);
//注册中心注册
URL url = new URL("localhost", 8080);
MapRemoteRegister.register(HelloService.class.getName(), url);

LocalRegister.register的调用是在Product启动的HttpServer的handler处理中，等于LocalRegister这个map还是在Product这个进程中。而MapRemoteRegister.register的存放是在Product进程中，而调用却是在Consumer中的代理方法的invoke中，自然调用不到。

4.5.1 解决

要么使用redis等统一管理，但是又涉及心跳检测等等。我们这里使用一个简单的存入一个文件，再从文件里读取

public class MapRemoteRegister {private static Map<String, List<URL>> mapRemoteRegister = new HashMap<>();public static void register(String interfaceName,URL url) {List<URL> list = mapRemoteRegister.get(interfaceName);if (list == null) {list = new java.util.ArrayList<>();}list.add(url);mapRemoteRegister.put(interfaceName, list);saveFile();}public static List<URL> get(String interfaceName) {mapRemoteRegister = getFile();return mapRemoteRegister.get(interfaceName);}public static void saveFile(){try{FileOutputStream fos = new FileOutputStream("/temp.txt");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(mapRemoteRegister);oos.close();} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);}}public static Map<String,List<URL>> getFile(){try{FileInputStream fis = new FileInputStream("/temp.txt");ObjectInputStream ois = new ObjectInputStream(fis);Map<String,List<URL>> map = (Map<String,List<URL>>)ois.readObject();ois.close();return map;} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}
}

因为我们的URL也要存入文件，所以也要序列化

public class URL implements Serializable {

再次测试，成功输出

Hello, world

在实际的分布式系统中，通常会使用专门的分布式服务注册中心（例如ZooKeeper、Consul等）来管理服务的注册和发现。这样可以确保注册信息的一致性、可靠性和可扩展性。

4.6 BootStrap

我们注册服务和注册注册中心的操作可以作为一个方法一起使用

创建com.sjb.bootstrap.BootStrap

public class BootStrap {public static void bindAndStart(Class interfaceClass, Class implClass, String hostname, Integer port) {//注册服务LocalRegister.register(interfaceClass.getName(), implClass);//注册中心注册URL url = new URL("localhost", 8080);MapRemoteRegister.register(interfaceClass.getName(), url);//netty、tomcatHttpServer httpServer = new HttpServer();httpServer.start(url.getHostname(), url.getPort());}
}

product调用的时候

public class Productor {public static void main(String[] args) {BootStrap.bindAndStart(HelloService.class, HelloServiceImpl.class, "localhost", 8080);}
}

5 服务重试

可以设置默认的重试次数，直到全部失败

在com.sjb.proxy.ProxyFactory#getProxy中

//服务发现
List<URL> urls = MapRemoteRegister.get(interfaceClass.getName());
//负载均衡
URL url = LoadBalance.random(urls);
//服务调用
String result =null;
int defaltRetry = 3;
for (int i = 0; i < defaltRetry; i++) {try {result = httpClient.send(url.getHostname(), url.getPort(), invocation);if (result != null) {break;}} catch (Exception e) {e.printStackTrace();}
}
return result;

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

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

相关文章

如何通过香港站群服务器高效实现网站内容的快速更新?

如何通过香港站群服务器高效实现网站内容的快速更新?

如何通过香港站群服务器高效实现网站内容的快速更新? 在当今激烈的数字市场竞争中&#xff0c;网站内容的快速更新对于吸引用户和保持竞争优势至关重要。而利用香港站群服务器实现这一目标&#xff0c;则具备诸多优势。下面将详细探讨如何通过香港站群服务器高效实现网站内容…
阅读更多...
ARM架构安全特性之隔离技术

ARM架构安全特性之隔离技术

安全之安全(security)博客目录导读 目录 一、保护代码和数据 二、TrustZone 三、安全世界之间的隔离 四、Secure-EL2扩展 五、保护主流计算工作负载 六、领域管理扩展(RME) 七、内存密集型可信应用程序 八、Arm动态TrustZone技术 强制执行明确定义的安全边界是安全工程…
阅读更多...
华为eNSP Pro模拟器最新版R001C10（普通账号可用）

华为eNSP Pro模拟器最新版R001C10（普通账号可用）

eNSP Pro 最新版 R001C10下载&#xff1a;&#xff08;支持AP、AC、m-lag等&#xff09; eNSP-Pro_V100R001C10_Software_X8664_qemu_release.tar.gz eNSP-Pro_V100R001C10_Software_X8664_VirtualBox_release.tar.gz 好消息&#xff01;华为终于开放了普通账号使用权限&#…
阅读更多...
智能制造数字工厂未来三年规划方案(80页ppt下载)

智能制造数字工厂未来三年规划方案(80页ppt下载)

一、资料介绍 智能制造数字工厂未来三年规划方案是一份全面而深入的战略性文件&#xff0c;旨在指导我们公司在未来三年内实现智能制造领域的跨越式发展。这份80页的PPT资料&#xff0c;以“智能制造、智能制造系统、数字化工厂、数字孪生工厂、智能工厂和数字化车间”为核心关…
阅读更多...
日志的基本用法

日志的基本用法

目标 1. 掌握如何设置日志级别 2. 掌握如何设置日志格式 3. 掌握如何将日志信息输出到文件中 1. logging模块 Python中有一个标准库模块logging可以直接记录日志 1.1 基本用法 import logging logging.debug("这是一条调试信息") logging.info("这是一条…
阅读更多...
绘制一个单级放大电路原理图过程，保姆级教程

绘制一个单级放大电路原理图过程，保姆级教程

新手在学习pads的使用最好最快的方法就是实际上手去画原理图&#xff0c;画PCB图&#xff0c;在这个过程中&#xff0c;就能够更快速得掌握PADS软件的使用。 本篇就是对于实际画原理图过程的一个记录&#xff0c;手把手教学&#xff0c;如果有纰漏或者有更好的一些技巧&#xf…
阅读更多...
经典权限五张表案例分析

经典权限五张表案例分析

文章目录 模块分析模块分析 描述五张表的关系重要知识讲解抽取成一个BaseServletSpringIOC思想(底层)实现代码IOC概述 SPI机制(为学习框架做思想和技术铺垫)SPI引入1. 标准/规范2. 具体的实现3. 调用 SPI介绍SPI练习JDBC4.0免注册驱动原理Servlet实现方式三 ServletContainerIn…
阅读更多...
GCP谷歌云有什么数据库类型，该怎么选择

GCP谷歌云有什么数据库类型，该怎么选择

GCP谷歌云提供的数据库类型主要包括&#xff1a; 关系型数据库&#xff1a;这类数据库适用于结构化数据&#xff0c;通常用于数据结构不经常发生变化的场合。在GCP中&#xff0c;关系型数据库选项包括Cloud SQL和Cloud Spanner。Cloud SQL提供托管的MySQL、PostgreSQL和SQL Se…
阅读更多...
【MySQL的内外连接】

【MySQL的内外连接】

文章目录 一、内连接二、外连接1.左外连接2.右外连接 一、内连接 基本语法&#xff1a; select 字段 from 表1 inner join 表2 on 连接条件 and 其他条件&#xff1b;&#xff08;这里的and&#xff0c;也可以修改成where&#xff0c;并且建议使用where&#xff0c;逻辑更清晰…
阅读更多...
解析小程序setData工作原理

解析小程序setData工作原理

setData 函数用于将数据从逻辑层发送到视图层&#xff08;异步&#xff09;&#xff0c;同时改变对应的 this.data 的值&#xff08;同步&#xff09;。 setData它是微信小程序提供的一个内置的接口,是用于改变逻辑层中 data下的数据的视图层 view的数据挂载在逻辑层的 data下…
阅读更多...
第5章 处理GET请求参数

第5章 处理GET请求参数

1 什么是GET请求参数 表单GET请求参数是指在HTML表单中通过GET方法提交表单数据时所附带的参数信息。在HTML表单中&#xff0c;可以通过表单元素的name属性来指定表单字段的名称&#xff0c;通过表单元素的value属性来指定表单字段的值。当用户提交表单时&#xff0c;浏览器会将…
阅读更多...
表征和基于结构的蛋白质工程：黄芪特异性皂苷乙酰转移酶-文献精读14

表征和基于结构的蛋白质工程：黄芪特异性皂苷乙酰转移酶-文献精读14

Characterization and structure-based protein engineering of a regiospecific saponin acetyltransferase from Astragalus membranaceus 表征和基于结构的蛋白质工程&#xff1a;黄芪特异性皂苷乙酰转移酶&#xff0c;一篇乙酰基转移酶文章精读分享~ 摘要 乙酰化有助于许…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023