Java callback mechanism

In this case, we will not discuss some of the callback terms and operating mechanism, first of all, why there is a callback such a call? The emergence of synchronous and asynchronous mechanisms do not need to say, we know that the callback mechanism why it appears? In our real life, there is a situation where a boss is busy, he has no time to stare at his employees, and then he tells his employees to finish the current events and tell him the results of his work. This example is actually a callback + asynchronous example, another example, a programmer wrote a program A, which reserved the callback function interface, and encapsulated the program, Programmer b Let a call its own program B in a method, so he through the interface in a called back to the method in B, You may be indefinitely here, and you will continue to explain why the callback occurred. Next we turn the above example into code, and see many people on the net finally confusing async and callbacks, so the example does not add an asynchronous call. (Note: Callbacks are not a solution to the problem of long call times, it's asynchronous!) ）

Start by creating a callback interface that tells the boss how to find his way through the job: Leave the boss's office address:

/**  * This interface is a way of contacting, whether it is a phone number or a contact address, as  * The owner must implement this interface  * @author Administrator  *  */Public Interface Callbackinterface {public        void execute ();  }

Create callback object, is the boss himself, because the staff to call him after the work, so the boss must implement callback interface, or where employees go to find the Boss?

/**  * The boss is a top-level application, the lower-level application (employees) is not aware of the  method, so he wants to be the lower-level application (employee) Call must implement this interface  * @author Administrator  *  */ Public  class Boss implements Callbackinterface {            @Override public      Void execute () {          System.out.println ("Roger It!! "+ System.currenttimemillis ());                }  }

Create the control class, which is the employee object, he must hold the boss's address (callback interface), even if the boss changed stubble and stubble, the office is unchanged, always find the corresponding boss

/**  * Employee class, it must be remembered that this is an underlying class, the bottom layer is not aware of the upper service  * @author Administrator * * */Public  class Employee {        private Callbackinterface callBack = null;            Tell the boss the contact way, that is, register public      void Setcallback (Callbackinterface callBack) {          this.callback = callBack;      }            Workers work public      void Dosome () {          //1. Started working for          (int i=0;i<10;i++) {System.out.println ("" "              + i +" " It's done! ");          }                    2. Tell the boss to finish          Callback.execute ();      }  }

In this example, you can compare it with the example of programmer A and programmer B.

Looking at the example above, some people may think that this is not interface-oriented programming? How can it be a callback, and you think about it, our interface-oriented programming call relationship? In layer three, when the business layer calls the data layer, it does not need to pass the business layer itself to the data layer, and this is an upper layer call the underlying relationship, such as when we use the framework, the general direct call to the framework provided by the API can be, but the callback is different, when the framework does not meet the requirements, We want the framework to call its own class method, how to do it? There's no way to change the frame. Many excellent frameworks are almost all related interfaces, we just need to implement the relevant interface, we can complete the registration, and then let the framework to call our own class at the appropriate time, remember when we use struts, when we write the action, we need to inherit the action class, Then implement the Execute () method, write our own business logic code in the Execute () method, and complete the processing of the user request. This makes it possible to guess that the framework and the container provide a large number of callback interfaces to suit individual customization.

Do you understand the above example? We can now imagine the difference between filter and interceptor, the biggest difference between the two is that filter is based on a callback function that requires container support, no container is unable to callback the Dofilter () method, Interceptor is based on the reflection mechanism of Java, and is not related to containers. Does it confuse reflection with callbacks? See my blog about the Java Dynamic Agent: http://blog.csdn.net/bjyfb/article/details/7350256

In short, to be clear, the first thing is to understand the reason for the callback function, that is, the application of the scene, in order to clear the callback mechanism, otherwise less effort.

Finally, to give an example, in order to make our function close to perfect, we will part of the function of outsourcing to others, let others personalized customization, as for others how to achieve regardless, I have to do is to define the relevant interface, this design allows the underlying code to invoke high-level defined subroutines, enhance program flexibility, And reflection are similar, I think this is the real reason for the callback

Java callback mechanism