在Java中，一段需要重复执行的逻辑，最常见的方式是抽取为一个方法。但方法只能归属于类，调用方式相对固定，无法像参数一样灵活传递。如果要让同一段代码块在不同线程、不同条件或不同回调场景下被复用，就需要把代码块本身当作一个对象来对待。Java 8之后，函数式接口配合Lambda表达式让这种写法变得非常自然：代码块可以实现为函数式接口的实例，既能保存起来，也能作为入参传给其他方法。

先理清：方法、代码块与函数式接口的关系

传统面向对象写法中，代码块通常放在方法体内。比如一个记录日志的代码块写成logMessage()方法，调用时直接logMessage()。这已经能完成重复执行，但假设现在要把它作为回调传给定时任务，或者需要在某个事务前后执行，就不得不依赖匿名内部类。匿名内部类的问题在于模板代码太多，真正关心的动作被淹没在new Runnable()和public void run()中。

函数式接口解决的核心问题是：只保留一个抽象方法，让它代表一个明确的行为。Java编译器会检查被标注为@FunctionalInterface的接口是否满足这个约束。下面是一个最简单的自定义函数式接口，它描述了一个无参数、无返回值的代码块。

@FunctionalInterface
interface Task {
    void execute();
}
public class Demo {
    public static void main(String[] args) {
        Task task = () -> System.out.println("任务被执行");
        task.execute();
        task.execute();
    }
}

这里Task接口把一段代码块抽象成了execute()方法，而Lambda表达式() -> System.out.println("任务被执行")就是这段代码块的函数化表示。相比匿名内部类，不需要写new Task()，也不用重复声明方法名。这个实例可以赋值给变量、放入集合、作为方法参数传递，这是代码块可重复执行的前提。

需要注意的是，函数式接口并不是只能使用Lambda表达式。方法引用、构造器引用也可以形成函数式接口实例。比如Task task = System.out::println;在方法签名匹配时同样成立。函数化的关键不是Lambda语法本身，而是把行为抽象为对象这一层结构。

内置函数式接口：根据返回值和参数选择正确类型

虽然可以随时定义自己的函数式接口，但Java标准库已经提供了一批高频接口。如果每次执行不返回结果、也不接收参数，可以使用Runnable；需要返回结果并且允许抛出受检异常时，可以选Callable。很多人在第一步就纠结用哪个接口，其实判断维度只有三个：输入参数、返回值、是否抛出异常。

下面的表格简单比较了几种常见接口的语义。

以Supplier<T>为例，它不代表立即计算，而是定义一个可以提供结果的代码块。这非常适合封装可能多次执行、或者需要延迟执行的值。

import java.util.function.Supplier;
public class SupplierDemo {
    public static void main(String[] args) {
        Supplier<Double> randomSupplier = () -> Math.random() * 100;
        System.out.println(randomSupplier.get());
        System.out.println(randomSupplier.get());
    }
}

这段代码中，randomSupplier并不是一个固定的随机数，而是一个可重复调用的行为。每次get()都会重新执行内部的Math.random() * 100。如果把代码块直接写成一个变量值double random = Math.random() * 100;，就无法在多次调用时获得新的结果。这是函数化结构比单纯变量更灵活的地方。

如果代码块需要接收参数但不需要返回，例如打印接收到的字符串，可以用Consumer<T>。Lambda表达式左侧写参数，右侧写执行体。这样可以把处理逻辑抽离出来，重复用于不同输入。

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<String> printer = message -> System.out.println("收到: " + message);
        List<String> messages = Arrays.asList("hello", "world");
        messages.forEach(printer);
    }
}

这里printer作为一个可重复执行的处理动作，被forEach多次调用。选择内置接口时，要优先考虑语义是否清晰。例如Consumer通常意味着消费数据并产生副作用，如果代码块需要返回新值，就不要硬用Consumer再通过外部变量回传，那样会破坏函数式结构的可读性。

自定义函数式接口：让代码块的意图更明确

标准接口虽然覆盖了很多场景，但一旦代码块需要两个参数，或者需要声明受检异常，内置接口就不能直接满足。例如有些代码块需要处理数据库连接，逻辑里会抛出SQLException。此时可以定义一个自己的函数式接口，在抽象方法上声明异常。

@FunctionalInterface
interface SqlAction {
    void run() throws Exception;
}
public class CustomInterfaceDemo {
    public static void main(String[] args) {
        SqlAction action = () -> {
            // 模拟可能失败的数据库操作
            if (System.currentTimeMillis() % 2 == 0) {
                throw new Exception("连接失败");
            }
            System.out.println("SQL执行成功");
        };
        try {
            action.run();
        } catch (Exception e) {
            System.out.println("捕获异常: " + e.getMessage());
        }
    }
}

自定义接口的优势在于方法名和参数列表可以传达业务含义。例如SqlAction比Runnable更清楚它表示数据库动作，而不是普通的线程任务。这样做不会增加运行时成本，因为函数式接口实例仍然由Lambda表达式在编译期动态生成，性能与匿名内部类基本一致，但可读性更好。

还可以通过泛型来增强自定义接口的复用性。例如定义一个带输入输出的Operation<I,O>，可以适配多种转换场景。不过一旦自定义接口与标准库接口语义重复，应优先使用标准接口，减少类数量。自定义接口的价值在于异常声明、多参数、以及更有语义的抽象方法名。

函数化结构如何封装重复执行的横切逻辑

可重复执行的代码块最常见的落地场景之一，是把重试、计时、事务等横切逻辑封装成统一模板。传统写法会在每个业务方法里写for循环和try-catch，导致重复代码很多。如果把业务代码块作为Supplier<T>传入一个重试方法，模板就只写一次。

import java.util.function.Supplier;
public class RetryUtil {
    public static <T> T executeWithRetry(Supplier<T> action, int maxAttempts) {
        Exception lastException = null;
        for (int i = 0; i < maxAttempts; i++) {
            try {
                return action.get();
            } catch (Exception e) {
                lastException = e;
                System.out.println("第 " + (i + 1) + " 次执行失败，准备重试");
            }
        }
        throw new RuntimeException("重试 " + maxAttempts + " 次后仍然失败", lastException);
    }
    public static void main(String[] args) {
        String result = executeWithRetry(() -> {
            // 模拟不稳定远程调用
            if (Math.random() > 0.3) {
                throw new IllegalStateException("远程服务暂不可用");
            }
            return "remote result";
        }, 3);
        System.out.println(result);
    }
}

这里的executeWithRetry方法把可重复执行的代码块封装成一个参数action。业务方只需要通过Lambda表达式描述自己真正要执行的动作，重试策略由工具方法统一控制。这样既避免了每个调用点复制粘贴重试循环，也能让代码块在失败时被重复调度。

同样原理可以用于计时模板。例如需要统计某段代码的执行耗时，不必在每次调用前后都写System.currentTimeMillis()。可以接收一个Runnable或Supplier<T>，在模板中完成计时和日志输出。事务边界也可以这样处理：方法内部先开启事务，调用传入的代码块，成功则提交，失败则回滚。此时代码块作为核心动作，被事务模板包裹并重复用于不同业务。

组合多个代码块：用默认方法构建执行链

函数式接口除了抽象方法，还可以包含default方法和静态方法。这意味着代码块不仅能单独执行，还能像管道一样组合。例如Consumer的andThen方法可以把两个消费动作串起来，先执行一个，再执行另一个。这在重复执行的批处理流程中非常有用。

import java.util.function.Consumer;
public class ComposeDemo {
    public static void main(String[] args) {
        Consumer<String> validate = input -> {
            if (input == null || input.trim().isEmpty()) {
                throw new IllegalArgumentException("输入不能为空");
            }
        };
        Consumer<String> save = input -> System.out.println("保存数据: " + input);
        Consumer<String> validateAndSave = validate.andThen(save);
        validateAndSave.accept("java-function");
    }
}

andThen返回的是一个新的Consumer，它把两个动作合并成一个可重复执行的代码块。当业务规则变化时，可以继续追加处理节点，而不用修改已有节点。这种组合能力来自函数式接口中的默认方法，它让代码块结构从一次性的动作变成可编排的流程。

类似地，Predicate提供and、or和negate方法，用于组合过滤条件；Function提供andThen和compose方法，实现连续转换。组合后的实例仍然是函数式接口，可以继续作为参数传递，因此非常适合构建灵活的可重复执行逻辑。

总结

Java定义可重复执行代码块的关键，不是简单抽取方法，而是把代码块函数化。通过函数式接口和Lambda表达式，代码块可以成为对象、参数和返回值。内置接口负责覆盖常见场景，自定义接口解决异常声明和语义表达问题，默认方法则让代码块具备组合能力。理解这套结构后，重试、计时、事务等横切逻辑可以统一封装，业务代码只需要关注真正要执行的那段动作。最终代码的重复度更低，扩展点也更清晰。