Callback в чистом виде, это когда вы сформировали задачу и отправили её выполнять какому то там процессу, но не ждёте её завершения и продолжаете работать, а чтобы к вам мог вернутся результат работы, вы для воркера передаёте ссылку на свой класс с кастом в интерфейс калбека в котором обьявлен метод, при помощи которого воркер может вернуть данные. Вся работа происходит асинхронно без блокировок и ожиданий. В этом смысл калбеков, так как некоторые задачи могут идти долго, а некоторые быстро, но каллер не должен об этом заботиться, он просто предоставляет интерфейс для ответа и продолжает работу.
import java.util.ArrayList;
import java.util.Random;
/**
*
* @author mutagen
*/
public class CallBackDemo {
public static void main(String[] args) {
Caller caller = new Caller();
for (int i = 0; i < 10; i++) {
new Worker(caller).start();
}
// итого у нас 9 воркеров отработали и вернули ответ по калбеку в коллекцию
System.out.println(caller.getStatuses());
}
static class Caller implements Callback {
private ArrayList<Integer> statuses = new ArrayList<>();
public ArrayList<Integer> getStatuses() {
return statuses;
}
@Override
public void callMeBack(int status) {
// тут может быть логика куда вернутся данные, может быть коллекция, я выбрал попроще
synchronized (statuses) {
statuses.add(status);
}
}
}
static interface Callback {
// подготовим интерфейс по которому нам будут возвращать данные
void callMeBack(int status);
}
static class Worker extends Thread {
private Callback cb;
public Worker(Callback cb) {
this.cb = cb;
}
int pleaseDoMeAFavor() {
return new Random().nextInt();
}
@Override
public void run() {
// выполним работу
int st = pleaseDoMeAFavor();
// и вернём данные вызывающему по калбек интерфейсу
cb.callMeBack(st);
}
}
}
Допустим, мы разрабатываем фреймворк. У нас есть определенный шаблон действий, в котором только один пункт мы не можем прописать жестко и в этом месте необходимо, чтобы пользователь вставил свой функционал. Это можно сделать абстрактным методом, но в этом случае проблема: во-первых мы не сможем динамически менять такие «вставки», во-вторых, для 1000 функционалов мы получим огромную иерархию наследования. Кроме того, так как множественное наследование в Java не поддерживается, наследование можно использовать только в отдельных случаях. В этом случае можно использовать коллбэки.
Яркий пример использования колбэков — Spring-овские темплейты для работы с JDBC — они исполняют общие функции самостоятельно, передавая пользователю только такие операции, как обработка ResultSet-ов.
У нас есть темплейтный класс:
package callbacks;
import java.util.Arrays;
import java.util.List;
public class Template {
private ICustomOperation callback;
public Template(ICustomOperation callback) {
this.callback = callback;
}
public void setCallback(ICustomOperation callback) {
this.callback = callback;
}
public void processData(List<String> lines) {
for (String line : lines) {
System.out.println("Input: " + line);
line = "[" + line + "]";
System.out.println("Standart operation 1 result : " + line);
line = line.replaceAll(" ", "_");
System.out.println("Standart operation 2 result : " + line);
line = callback.evaluate(line); // здесь мы будем передавать контроль над обработкой пользователю
System.out.println("Custom operation result : " + line);
line = line.toLowerCase();
System.out.println("Standart operation 3 result : " + line);
}
}
}
Есть колбэк-интерфейс:
package callbacks;
public interface ICustomOperation {
public String evaluate(String input);
}
И различные его реализации:
package callbacks;
public class CustomOperation implements ICustomOperation {
public String evaluate(String input) {
return "CUSTOM: " + input;
}
}
package callbacks;
public class AnotherCustomOperation implements ICustomOperation {
public String evaluate(String input) {
return "ANOTHER CUSTOM: " + input;
}
}
Теперь запуск:
Template template = new Template(new CustomOperation());
List<String> data = Arrays.asList(new String[] { "first line", "SEcOnD LiNe" });
template.processData(data);
template.setCallback(new AnotherCustomOperation());
template.processData(data);
Есть ещё одно применение: допустим, у нас есть объект, у которого private метод, который вы не хотите делать public или protected. Вы вызваете метод другого класса и изнутри него хотите сделать вызов нашего private-метода.Это можно сделать следующим образом:
package callbacks;
package callbacks;
public class PrivateFieldHolder {
private OuterCaller outerCaller;
public OuterCaller getOuterCaller() {
return outerCaller;
}
public void setOuterCaller(OuterCaller outerCaller) {
this.outerCaller = outerCaller;
}
public void publicMethod() {
System.out.println("Holder: public method call");
// здесь хитрая штука: мы передаем в вызов метода
// внешнего класса коллбэк, который
// является анонимным классом внутри данного класса
// т.к. этот анонимный класс видит private-метод, то мы
// можем поместить внутрь callPrivateMethod вызов этого
// private-метода. Таким образом при вызове
// callPrivateMethod во внешнем классе позволит обратиться
// к private-методу этого класса.
outerCaller.callFromOutsidePrivateMethod(new IPrivateMethodCallback() {
public void callPrivateMethod(String caller) {
privateMethod(caller);
}
});
}
private void privateMethod(String caller) {
System.out.println(caller + ": private method call");
}
}
Колбэк-интерфейс:
package callbacks;
public interface IPrivateMethodCallback {
public void callPrivateMethod(String caller);
}
Внешний класс, которому нужно вызвать private-метод:
package callbacks;
public class OuterCaller {
public void callFromOutsidePrivateMethod(IPrivateMethodCallback callback) {
System.out.println("Outer method call");
callback.callPrivateMethod("Outer caller");
}
}
Теперь запуск:
PrivateFieldHolder pfh = new PrivateFieldHolder(); OuterCaller oc = new OuterCaller(); pfh.setOuterCaller(oc); pfh.publicMethod();
