Shulou(Shulou.com)06/03 Report--

How to get started with Dubbo quickly, in view of this problem, this article introduces the corresponding analysis and answer in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

Dubbo is needed in recent projects, and although I know that dubbo is a RPC framework, I haven't learned about it in detail. Since the project is to be used, first learn the application of Dubbo, and then understand the internal principles of Dubbo after you are proficient in using it.

At present, Dubbo is the most famous RPC service invocation framework. It is an open source SOA service governance framework of Ali. It is fully functional and supports a variety of transport and serialization schemes. The most common application of Dubbo is remote invocation.

There are four core objects on the server side in Dubbo:

ApplicationConfig: configuring current application information

ProtocolConfig: configure the protocol information for providing services

RegistryConfig: configuration registration related information

ServiceConfig: configure exposed service information

There are two core objects in the Dubbo client:

ApplicationConfig: configuring current application information

ReferenceConfig: configure referenced service information

(2) Dubbo actual combat

Next, you can get started with Dubbo in three ways. First, you will directly show the direct connection and registry implementation of dubbo through code, and then use Spring and SpringBoot to show how to use Dubbo, respectively.

Before writing dubbo-related code, we first need to define a common client service in which the service interface is stored. The service provider introduces the project, writes the implementation class, and provides the dubbo interface; the service consumer introduces the project and invokes it through the project's service interface.

Therefore, create such a module and name it dubbo-client. The overall code structure is as follows. You only need to write a service interface:

User class:

@ Datapublic class User implements Serializable {private static final long serialVersionUID =-9206514891359830486L; private Long id; private String name; private String sex;}

UserService:

Public interface UserService {User getUser (Long id);} 2.1Direct Code

Next, generate a dubbo service in direct code and invoke the dubbo service with another class:

2.1.1 introducing dependency

There are only two core dependencies, one for dubbo and the other for the above public interface methods.

Org.apache.dubbo dubbo 2.7.4.1 dubbo-client com.javayz 0.0.1-SNAPSHOT 2.1.2 write a service provider

The service provider mainly configures the following properties:

1. Application: set the name of the application and other information

2. Protocol: set the protocol for the service

3. Register: set the connection method of the service

4. Service: register the services that need to be exposed

Public class DubboProvider {public static void main (String [] args) throws IOException {/ / expose UserService service / / 1, application ApplicationConfig applicationConfig=new ApplicationConfig ("sample-provider"); / / 2, protocol-dubbo protocol ProtocolConfig protocolConfig = new ProtocolConfig (); protocolConfig.setName ("dubbo"); protocolConfig.setPort (20880) / / 3, register / / directly connected mode, not exposed to the registry RegistryConfig registryConfig=new RegistryConfig (RegistryConfig.NO_AVAILABLE); / / 4, service ServiceConfig serviceConfig=new ServiceConfig (); serviceConfig.setInterface (UserService.class); serviceConfig.setRef (new UserServiceImpl ()); / / 5, register application, protocol, register with service serviceConfig.setRegistry (registryConfig); serviceConfig.setProtocol (protocolConfig) ServiceConfig.setApplication (applicationConfig); serviceConfig.export (); System.out.println ("Service has been exposed"); System.in.read ();} 2.1.3 write service consumers

There are three main steps to the realization of consumers:

1. Configure application: set the name of the application and other information

2. Configure reference: mainly configure the information to be referenced

3. Get the interface and invoke the service.

Public class DubboConsumer {public static void main (String [] args) {/ / 1, application ApplicationConfig applicationConfig=new ApplicationConfig ("sample-consumer"); / / 2, configure reference ReferenceConfig referenceConfig=new ReferenceConfig (); referenceConfig.setApplication (applicationConfig); referenceConfig.setInterface (UserService.class) ReferenceConfig.setUrl ("dubbo://172.18.2.49:20880/com.javayz.client.service.UserService?anyhost=true&application=sample&bind.ip=172.18.2.49&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.javayz.client.service.UserService&methods=getUser&pid=5936&release=2.7.4.1&side=provider×tamp=1618036935244"); UserService userService = (UserService) referenceConfig.get (); User user = userService.getUser (1L) System.out.println (user);}}

Start the provider first, and then the consumer. If the user information is printed, the call is successful.

The Register here is directly connected, and we can also use the registry. Here, take zookeeper as an example. First, introduce zookeeper-related dependencies into the project:

Org.apache.curator curator-recipes 2.13.0 org.apache.curator curator-framework 2.13.0

The service provider modifies one place to change the RegistryConfig to the connection method of zookeeper

/ / register// directly connected without exposing the registry / / RegistryConfig registryConfig=new RegistryConfig (RegistryConfig.NO_AVAILABLE); / / exposing the dubboRegistryConfig registryConfig=new RegistryConfig through the registry ("zookeeper://192.168.78.128:2181")

The consumer also modifies a location to replace the setUrl method in referenceConfig with zookeeper:

RegistryConfig registryConfig=new RegistryConfig ("zookeeper://192.168.78.128:2181"); ReferenceConfig referenceConfig=new ReferenceConfig (); referenceConfig.setRegistry (registryConfig); referenceConfig.setApplication (applicationConfig); referenceConfig.setInterface (UserService.class) / / referenceConfig.setUrl ("dubbo://172.18.2.49:20880/com.javayz.client.service.UserService?anyhost=true&application=sample&bind.ip=172.18.2.49&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.javayz.client.service.UserService&methods=getUser&pid=5936&release=2.7.4.1&side=provider×tamp=1618036935244"); 2.2 via Spring

Through Spring, you simply take the code written above in Java to the configuration file, inject the interface into the Bean container, and create two new configuration files under the resource folder: provider.xml.

Consumer.xml

The configuration file here corresponds to the code above. Then comes the provider and consumer of the service: SpringDubboProvider

Public class SpringDubboProvider {public static void main (String [] args) throws IOException {ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext ("provider.xml"); System.out.println ("Service exposed"); System.in.read ();}}

SpringDubboConsumer

Public class SpringDubboConsumer {public static void main (String [] args) {ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext ("consumer.xml"); UserService bean = context.getBean (UserService.class); System.out.println (bean.getUser (1L));} 2.3 via SpringBoot

Create two new SpringBoot projects, one for the service provider and the other for the service consumer, to introduce the core dependencies of dubbo

Org.apache.dubbo dubbo-spring-boot-starter 2.7.4.1

The configuration here is written in application.properties, starting with the service provider:

Dubbo.application.name=dubbo-providerdubbo.registry.address=zookeeper://192.168.78.128:2181dubbo.protocol.name=dubbodubbo.protocol.port=20880

The service provider needs to write the implementation class of the service. Note here that @ Service is annotated under the dubbo package:

Import com.javayz.client.entity.User;import com.javayz.client.service.UserService;import org.apache.dubbo.config.annotation.Service;import org.springframework.stereotype.Component;@Service@Componentpublic class UserServiceImpl implements UserService {@ Override public User getUser (Long id) {User user=new User (); user.setId (id); user.setName ("javayz"); user.setSex ("man"); return user;}}

Then add a @ EnableDubbo annotation to the startup class.

The consumer of the service also writes the configuration file first:

Server.port=8081dubbo.application.name=dubbo-consumerdubbo.registry.address=zookeeper://192.168.78.128:2181

Then bring in the service object through the @ Reference annotation

@ SpringBootApplicationpublic class SpringbootconsumerApplication {@ Reference UserService userService; public static void main (String [] args) {SpringApplication.run (SpringbootconsumerApplication.class, args);} @ Bean public ApplicationRunner getBean () {return args-> {System.out.println (userService.getUser (1L));} } (3) the common configuration of dubbo is used to configure current application information to configure connection registration related information to configure protocol information for providing services, providers specify protocols, consumers passively accept to expose a service, a service can be exposed with multiple protocols, and a service can be registered with multiple registries when certain properties of ProtocolConfig and ServiceConfig are not configured. Use this default value to create a remote service agent when a ReferenceConfig property is not configured

I found more specific configuration information on the official website. You can refer to:

Https://dubbo.apache.org/zh/docs/v2.7/user/references/xml/

(4) how to realize distributed invocation through dubbo in enterprises

In an enterprise, if the consumer invokes the provider directly through RPC, it is theoretically necessary to introduce the entire Jar package of the provider into the project. But in this way, other extraneous code provided by the service will also be introduced, resulting in code contamination.

Therefore, in the actual development process, a layer of Client module will be added between the service provider and the caller. This Client is mainly written about the interface definition of Service, the return instance object of the interface and the request instance object of the interface. In a nutshell, all definitions are done in Client.

When in use, the service provider introduces the Client, then writes the implementation method, and the service consumer introduces the Client and then invokes it directly through the dubbo.

In addition, there may be multiple interface implementations in enterprise development, in which case Service can be distinguished by setting group, version and so on.

(5) Summary

These are the basic uses of Dubbo. After all, Dubbo is only a tool for RPC, and we can use it to easily expose and consume services. But it will only be used in two hours, and some of its internal configurations, some ideas and the most important principles all need to be ploughed by ourselves.

This is the answer to the question about how to get started with Dubbo quickly. I hope the above content can be of some help to you. If you still have a lot of doubts to solve, you can follow the industry information channel to learn more about it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.