Java asynchronous callback instance Parsing

Java asynchronous callback instance Parsing

What is callback? Today, I took a silly screenshot and asked, and then Chen daniu replied, "just a callback ...". At this time, tens of millions of Grass-mud horses fly

Haha, looking at the source code, enjoying the role of this callback in the Code is really beautiful. Summary.

1. What is callback?

Callback. The callback between the caller and the called user must be called first. So in Baidu encyclopedia, the following is true:

There are always some interfaces between software modules. In terms of calling methods, they can be divided into three types: Synchronous call, callback and asynchronous call.

Callback is a special call, and the three methods are also a little different.

1. synchronous callback, that is, blocking, one-way.

2. Callback, that is, two-way gears similar to the bicycle ).

3. asynchronous calls: notifications are sent through asynchronous messages.

Ii. asynchronous callback java case in CS)

For example, the following scenario is simulated: the client sends the msg to the server, and the server calls back the message to the client five seconds after processing. The Code is as follows:

Callback interface class:

 
 

  
  
/**
  
  
* @ Author Jeff Lee
  
  
* @ Since 2015-10-21 21:34:21
  
  
* Callback mode-callback Interface Class
  
  
*/
  
  
Public interface CSCallBack {
  
  
Public void process (String status );
  
  
}
 
 

Simulate the client:

 
 

  
  
/**
  
  
* @ Author Jeff Lee
  
  
* @ Since 2015-10-21 21:25:14
  
  
* Callback mode-simulate the client class
  
  
*/
  
  
Public class Client implements CSCallBack {
  
  
 
  
  
Private Server server;
  
  
 
  
  
Public Client (Server server ){
  
  
This. server = server;
  
  
}
  
  
 
  
  
Public void sendMsg (final String msg ){
  
  
System. out. println ("client: sent message:" + msg );
  
  
New Thread (new Runnable (){
  
  
@ Override
  
  
Public void run (){
  
  
Server. getClientMsg (Client. this, msg );
  
  
}
  
  
}). Start ();
  
  
System. out. println ("client: asynchronous transmission successful ");
  
  
}
  
  
 
  
  
@ Override
  
  
Public void process (String status ){
  
  
System. out. println ("client: Server callback status:" + status );
  
  
}
  
  
}
 
 

Simulated Server:

 
 

  
  
/**
  
  
* @ Author Jeff Lee
  
  
* @ Since 2015-10-21 21:24:15
  
  
* Callback mode-simulate the server class
  
  
*/
  
  
Public class Server {
  
  
 
  
  
Public void getClientMsg (CSCallBack csCallBack, String msg ){
  
  
System. out. println ("server: the server receives the message sent by the Client:" + msg );
  
  
 
  
  
// Simulate data processing on the server
  
  
Try {
  
  
Thread. sleep (5*1000 );
  
  
} Catch (InterruptedException e ){
  
  
E. printStackTrace ();
  
  
}
  
  
System. out. println ("server: Data Processing successful, return success 200 ");
  
  
String status = "200 ";
  
  
CsCallBack. process (status );
  
  
}
  
  
}
 
 

Test class:

 
 

  
  
/**
  
  
* @ Author Jeff Lee
  
  
* @ Since 2015-10-21 21:24:15
  
  
* Callback mode-test class
  
  
*/
  
  
Public class CallBackTest {
  
  
Public static void main (String [] args ){
  
  
Server server = new Server ();
  
  
Client client = new Client (server );
  
  
 
  
  
Client. sendMsg ("Server, Hello ~ ");
  
  
}
  
  
}
 
 

Run the following test class:

Client: The sent message is Server, Hello ~
Client: the message is sent asynchronously.
Server: the Server receives the following message from the client: Server, Hello ~

Here we simulate the server's data processing time and wait for 5 seconds)
Server: data is processed successfully, and 200 is returned.
Client: Server callback status: 200

Analyze the code step by step. The core is summarized as follows:

1. The interface is used as a method parameter, and its actual incoming reference points to the implementation class.

2. In the sendMsg method of the Client, the parameter is final, because it can be used by a new internal thread. Asynchronous is embodied here.

3. Call getClientMsg () of the server. The parameter is passed to the first vertex of the Client ).

It is worth mentioning that

-The open source code is on my gitHub ~

Iii. Callback application scenarios

What scenarios are callback currently used in? From operating system to developer call:

1. Message Mechanism on Windows Platform

2. Call the interface asynchronously to respond to the business logic based on the returned status.

3. The Filter in Servlet is based on the callback function and must be supported by containers.

Supplement: The difference between Filter and Interceptor is that the Interceptor is based on the Java reflection mechanism and has nothing to do with the container. But it is similar to the callback mechanism.

In short, this design allows the underlying code to call the subroutine of the high-level definition Implementation Layer, enhancing the flexibility of the program.

Iv. Mode Comparison

The Filter and Intercepter are similar. In fact, the interface callback mechanism is similar to the observer mode in a design mode:

Observer mode:

GOF said-"defines an object's one-to-many dependency. When the status of an object changes, all objects dependent on it are notified and updated ." It is implemented through the interface callback method, that is, it is the embodiment of callback.

Interface callback:

The difference with the observer mode is that it is a principle rather than a specific implementation.

5. Experiences

The four steps are summarized as follows:

The mechanism is the principle.

Mode.

Remember specific scenarios and common patterns.

Then, we will have a deep understanding of the principles.