To talk about Dubbo, let’s start with RPC:
Concept:
Remote Procedure Call (RPC) : a protocol that requests services from Remote computer programs over the network without understanding the underlying network technology. It makes calling a remote program locally as if it were calling a local program.
The RPC protocol assumes the existence of some transport protocol, such as TCP or UDP, to carry information data between communication programs. In the OSI network communication model (seven-layer model), RPC spans both the transport layer and the application layer. RPC makes it easier to develop applications including network distributed multiprograms.
RPC call procedure:
-
The client invokes the service as a local service
-
The Client stub acts as the proxy and then handles the call and its parameters
-
The Client stub sends calls to the remote system over TCP or UDP
-
The Server Stub processes the calls and parameters sent by the Client stub
-
The Server Stub invokes the service that is actually provided
-
The Server Stub processes the reply and sends it to the client
Dubbo
What is dubbo?
Dubbo is the core framework of Alibaba’s SOA servitization governance scheme. It is a distributed service framework and is committed to providing high-performance and transparent RPC remote service invocation scheme and SOA service governance scheme.
Soa: “Service-oriented architecture”, which provides an architectural style and concept rather than a technology or product. SOA advocates encapsulating and hosting the business functions of different applications as “services”, usually in the form of interfaces and contracts that are exposed and made available to external applications (by exchanging messages) to make different systems reusable.
2. The technical architecture diagram of Dubbo is as follows:
Let’s explain the architecture diagram:
-
A) Consumer B) Provider C) Container D) Container
-
B. The service provider starts and then registers the service.
-
C, Monitor is a Monitor. The dotted line in the figure shows that the Consumer and Provider send messages asynchronously to the Monitor. The Consumer and Provider store the information to the local disk and send messages once every 1 minute on average. Monitor is optional throughout the architecture.
-
D. The Monitor function needs to be configured separately. If it is not configured or configured, the failure of Monitor does not affect service invocation.
3. Dubbo service consumer calls the process
The figure above shows the main process of service consumption:
First, the private void init() method of ReferenceConfig class will check and initialize all configuration information, and then call the private T createProxy(Map Map) to create the proxy. The consumer finally gets the proxy of the service. CreateProxy then calls the Invoker refer(Class Type, URL URL) method of the Protocol interface implementation to generate the Invoker instance (shown in red in the figure above), which is key to service consumption. Next, the Invoker is converted to the interface (such as HelloWorld) required by the client through the ProxyFactory ProxyFactory, the service proxy is created and returned.
Initialization process on the consumer side
-
1. Encapsulate the information referenced by the service into a URL and register it in the ZK registry;
-
2. Listen for services in the registry to go up and down;
-
3. Connect to the service provider and create the NettyClient object;
-
4. Wrap this information into a call chain on the consumer side of DubboInvoker, create a service proxy for the consumer side of Invoker instance and return it;
The service reference process on the consumer side
-
1. Call the provider through the load balancing policy;
-
2. Select the URL of one of the services to establish a connection with the provider Netty, use ProxyFactory to create remote communication, or local communication, Invoker sent to the Netty server;
-
3. After receiving the Invoker message, the server finds the local Invoker and processes the Invocation.
-
4. Obtain asynchronous or synchronous processing results;
-
Asynchrony does not require a return value: call the exchangeclient.send () method directly;
-
Synchronization requires a return value: use the exchangeclient.request () method to return a ResponseFuture that blocks until the server returns the response;
The simplest instance of Dubbo
Packages required by both service providers and consumers (here I create a New Maven project as a POM project, writing common project dependencies to POM.xml)
The overall project structure is
The pom. XML file contains the following contents
The < project XMLNS = "http://maven.apache.org/POM/4.0.0" XMLNS: xsi = "http://www.w3.org/2001/XMLSchema-instance" Xsi: schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" >
The < modelVersion > 4.0.0 < / modelVersion >
<groupId>com.test</groupId>
<artifactId>dubbo-demo</artifactId>
< version > 0.0.1 - the SNAPSHOT < / version >
<packaging>pom</packaging>
<properties>
< motan version > 0.3.0 < / motan. Version >
<! -- GA version is widely used inside Alibaba: 2.4.9, strongly recommended -->
< dubbo version > 2.5.3 < / dubbo version >
< dubbox version > 2.8.4 < / dubbox version >
< spring version > 4.3.6. RELEASE < / spring. Version >
< Java version > 1.7 < / Java. Version >
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
The < version > 2.5.3 < / version >
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.github.sgroschupf</groupId>
<artifactId>zkclient</artifactId>
< version > 0.1 < / version >
</dependency>
<! -- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
The < version > 1.6.11 < / version >
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
The < version > 1.6.11 < / version >
</dependency>
</dependencies>
<modules>
<module>demo-api</module>
<module>dubbo-consumer</module>
<module>dubbo-provider</module>
</modules>
</project>
Copy the codeDefine the service interface in demo-API (note that both service providers and consumers need to rely on this project)
package com.test;
public interface DemoService{
String sayHello(String name);
}
Copy the codeService provider implementation
The project structure
Implementing an interface
package com.test;
import org.springframework.stereotype.Service;
import com.test.DemoService;
@Service("demoService")
public class DemoServiceImpl implements DemoService{
@Override
public String sayHello(String name) {
// TODO Auto-generated method stub
return name;
}
}
Copy the codeClaim exposure service:
<? The XML version = "1.0" encoding = "utf-8"? >
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://code.alibabatech.com/schema/dubbo
http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<! -- Provider application information for calculating dependencies -->
<dubbo:application name="dubbo_provider" />
<! -- Use zooKeeper registry to expose service address -->
"Dubbo: registry address =" zookeeper: / / 127.0.0.1:2181 "/ >
<! Expose service on port 20880 with dubbo
<dubbo:protocol name="dubbo" port="20880" />
<! Declare the service interface to be exposed -->
<dubbo:service interface="com.test.DemoService" ref="demoService" />
</beans>
Copy the codeScan the service annotations in springMVC.xml and import the relevant Dubbo configuration in dubbo-provider.xml
<? The XML version = "1.0" encoding = "utf-8"? >
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.0.xsd"
default-autowire="byName">
<aop:aspectj-autoproxy />
<context:component-scan base-package="com.test" />
<import resource="classpath:dubbo-provider.xml" />
</beans>
Copy the codeLoad the Spring configuration and start the service:
package com.test;
import java.io.IOException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:springmvc.xml");
context.start();
System.out.println("Dubbo provider start..." );
try {
System.in.read(); // Press any key to exit
} catch (IOException e) {
e.printStackTrace();
}
}
}
Copy the codeService consumer implementation
The project structure
Declare the services that need to be consumed in dubo-consumer.xml
<? The XML version = "1.0" encoding = "utf-8"? >
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://code.alibabatech.com/schema/dubbo
http://code.alibabatech.com/schema/dubbo/dubbo.xsd ">
<! -- Consumer application name, used to calculate dependencies, not matching conditions, not the same as provider -->
<dubbo:application name="dubbo_consumer" />
<! Expose discovery service addresses with multicast broadcast registries -->
"Dubbo: registry protocol =" zookeeper "address =" zookeeper: / / 127.0.0.1:2181 "/ >
<! Create a remote service proxy that can use demoService as a local bean -->
<dubbo:reference id="demoService" interface="com.test.DemoService" />
</beans>
Copy the codeScan the service annotations in springMVC.xml and bring in the relevant Dubbo configuration in dubbo-consumer.xml
<? The XML version = "1.0" encoding = "utf-8"? >
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.0.xsd"
default-autowire="byName">
<aop:aspectj-autoproxy />
<context:component-scan base-package="com.test" />
<import resource="classpath:/dubbo-consumer.xml" />
</beans>
Copy the codeLoad the Spring configuration and invoke the service:
package com.test;
import java.io.IOException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "classpath:springmvc.xml" });
context.start();
DemoService demoService = (DemoService) context.getBean("demoService");
System.out.println(demoservice.sayHello (" ha ha ha "));
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Copy the codeThe call succeeds if the following results occur
Service providers and consumers can be seen through the Dubo-admin management background
The disclosing party:
Consumer:
Recommended reading
-
[JVM] class loading, connection, and initialization procedures
-
The full set of learning video resources for 2018 has been organized! Free to share!
-
Docker Core Technology Video tutorial
-
Ant Class 2 without encryption -Java video tutorial
-
Java logging system summary in detail
-
【 resources sharing 】Spring Cloud micro-service combat video course
-
Concurrent programming ThreadLocal keyword
-
Rounding BlockingQueue
-
Springmvc source code analysis summary
-
MyBatis architecture source code interpretation
Our official account will give you benefits from time to time, including learning resources, etc. Please look forward to it!
If you can’t use the content in your work now, you can forward it to your friend circle or favorite first, so that you can find it easily when you use it.
In addition, you are welcome to pay attention to the public account or add wechat friends to learn and communicate with each other.