javaで関数を包む？関数を引数に取りたい？

Question

while (true) {
    try {
        func(arg1, arg2);
        break;
    catch (error e) {
        // 解決したあとに、もう一度関数を叩いてほしい。
        // 例外処理の内容は全て同じ。
        // 何回か失敗する事もある。
        continue;
    }
}

このfuncを包んでいる処理を他の関数でもやりたく、いい感じな書き方を知りたいです(その都度whileを書くのを避けたい)。
引数、戻り値は同じではなく、関数ごとに異なります。

フェーズのようなenumを作って、全体を包んでflagのような感じで、、みたいなのは思いつきましたが。。

enum Phase {
    FIRST,
    SECOND,
    THIRD;
}

var flag = Phase.FIRST;
while (true) {
    try {
        if (flag == Phase.FIRST) {
            func1();
            flag = Phase.SECOND;
        }
        if (flag == Phase.SECOND) {
            func2(arg);
            flag = Phase.THIRD;
        }

        // ...

        break;
    } catch (error e) {
        // 処理
        continue;
    }
}

pythonだったら以下のような解決策が思い浮かびます。

def execute(func, *args, **kwargs):
    while True:
        try:
            return func(*args, **kwargs)
        except Exception:
            # 解決する
            input("enter")
            continue

def api():
    # 例外が発生する可能性がある処理
    pass

execute(api)
execute(api2, arg1, arg2)
# ...

これは関数自体を引数にすることができ、可変長引数が柔軟である必要があります。

どのように検索したら良いのか分からなく、皆様のお知恵を拝借したいです。

Comments

[jimbe]

python でのコードを書いて頂いて、それを java でするにはどうしたら良いか? という感じにすると具体的で分かり易いと思うのですが、如何でしょうか。

[xebme]

Java標準の関数型インターフェイスは例外を投げられないので、自分で例外を投げる関数型インターフェースを定義するか、Optionalを使ってorElseGetで再試行するなどの方針が考えられます。再試行の無限ループも考えてみたいところです。

プログラムを具体化しなければなりません。jimbeさんのおっしゃるように　pythonのコードを提示していただくのが近道かなと思います。

[ABC-..]

コメントありがとうございます。

pythonのコードを追加しました。
javaで実現するにはどうするかなのですが、調べてみて、javaで関数を引数に取るには引数、戻り値の型が同じである必要があるようです(引数、戻り値は関数ごとに違う)。
なので難しいですかね…

>再試行の無限ループも考えてみたいところです。
ここの例外は人が解決するので無限ループは考慮しなくて大丈夫です。
リミットなども設ける予定です。

Answer 1

すでに解決済みですがメモを残しておきます。やっていることはpythonと変わりません。

@FunctionalInterface
public interface BiFunction<T,U,V> {

	V apply(T x, U y) throws Exception;
	
	static <T,U,V> Optional<V> execute(BiFunction<T,U,V> f, T x, U y) {
		Optional<V> result = Optional.empty();
		for (int i = 0; i < 3; ++i) {
			try {
				V value = f.apply(x, y);
				result = Optional.of(value);
				break;
			} catch (Exception e) {
				//e.printStackTrace();
			}
		}
		return result;
	}

}

利用例です。

public class BiFunctionUsage {

	public static void main(String[] args) {
		
		var a = BiFunction.execute((x, y) -> x * y, 2.5, 5.8);
		System.out.println(a.orElse(null));
		
		var b = BiFunction.execute((x, y) -> {if (y == 0) throw new Exception("Divide by Zero."); else return x/y;}, 2.5, 0);
		System.out.println(b.orElse(null));
		
		var c = BiFunction.execute((x, y) -> x + y, "5 + 6 = ", (5+6) );
		System.out.println(c.orElse(null));
		
	}

}

関数型インターフェイスから例外を投げるのは推奨されていません。例外を投げるとStreamのパイプライン処理が中断してしまうから、純粋関数にならないから、といった理由が挙げられています。

しかし、SQLExceptionのように、トランザクションをロールバックする目的で投げざるをえないことがあります。やむをえない場合を除いて、例外の代わりにOptionalを使ってください。

Comments

[ABC-..]

このようなインターフェースもあるのですね。
回答ありがとうございます。

Answer 2

垢抜けない感じですが^^;

public class Main {
  public static void main(String[] args) {
    int a1 = execute(new Api1());
    String a2 = execute(new Api2(100, "ABC"));
    System.out.println("a1="+a1+", a2="+a2);
  }

  static <T> T execute(Func<T> func) {
    while(true) {
      try {
        return func.exec();
      } catch(Func.Exception e) {
        //input("enter")
      }
    }
  }
}

abstract class Func<T> {
  static class Exception extends Throwable {}
  abstract T exec() throws Func.Exception;
}

class Api1 extends Func<Integer> {
  public Integer exec() throws Func.Exception {
    System.out.println("api1 の処理");
    return -123;
  }
}
class Api2 extends Func<String> {
  final int arg1;
  final String arg2;
  Api2(int arg1, String arg2) {
    this.arg1 = arg1;
    this.arg2 = arg2;
  }
  public String exec() throws Func.Exception {
    System.out.println("api2 の処理 (arg1="+arg1+",arg2='"+arg2+"')");
    return "XYZ";
  }
}

api1 の処理
api2 の処理 (arg1=100,arg2='ABC')
a1=-123, a2=XYZ

リトライ自体を Func に入れてしまって main は例外時の処理を渡す形にも出来ます。

public class Main {
  public static void main(String[] args) {
    Func.Retry retry = (e) -> {
      //input("enter")
    };
    int a1 = new Api1().executeWithRetry(retry);
    String a2 = new Api2(100, "ABC").executeWithRetry(retry);
    System.out.println("a1="+a1+", a2="+a2);
  }
}

abstract class Func<T> {
  static class Exception extends Throwable {}
  interface Retry {
    void onRetry(Exception cause);
  }
  T executeWithRetry(Retry retry) {
    while(true) {
      try {
        return exec();
      } catch(Func.Exception e) {
        if(retry != null) retry.onRetry(e);
      }
    }
  }
  abstract T exec() throws Func.Exception;
}

Comments

[xebme]

例外を投げる関数型インターフェイスはアノテーションをつけてください。次のように書くと、例外が発生するラムダ式を引数として渡せるようになります。

import java.sql.SQLException;
@FunctionalInterface
public interface SQLFunction<T, U> {
U apply(T in) throws SQLException;
}

[jimbe]

Func<T> は interface で良かったですね。ありがとうございます。

[ABC-..]

なるほど。。
その関数専用のRunnableのような物を作って～という感じですよね。

勉強になりました。
回答ありがとうございました。