簡析JAVA8函式式介面

可飛發表於2021-04-27
Java函式

一，定義

“有且只有一個抽象方法的介面”----函式式介面的定義。
@FunctionalInterface
public interface Ifun{
    void test();
}

如上就是一個簡單的函式式介面的定義。@FunctionalInterface就表示這是一個函式式介面，你不定義也可以，其實這就是個編譯選項，用來強制驗證你到底是不是函式式介面。像這樣的介面，我們就可以使用Lambda表示式來進行函數語言程式設計，呼叫方式為()-{}，如下：

public class Test {
    public static void funTest(Ifun ifun) {
        ifun.test();
    }

    public static void main(String[] args) {
        Test.funTest(() -> {
            System.out.println("hello world!");
        });
    }
}

out:

"hello world!"

程式碼還是比較簡單的，現在開發用到最多的場景還是流這一塊的操作，替換了以前的比較醜陋的一些遍歷操作，你可以說他只是一種語法糖的包裝，但是不可否認確實帶來程式碼上的簡潔和書寫上的流暢。

具體我自己的體會就是：

函式式介面只提供了資料和行為，但是行為的實現放在每個具體的業務場景中。

這個其實有點像匿名內部類的變種的感覺，它只是表現形式上和匿名內部類相似，但是和它又有些不一樣，它提供了更加豐富的操作過程。

下面通過JAVA四大內建函式式介面，結合例子來具體瞭解下這句話。

二，四大內建函式式介面

1. Consumer介面

上面是機翻，雖然有些句子表述不太準確，但是大概的意思我們都能理解，消費介面就是一個接受引數然後進行消費處理的操作，甚至於把異常處理的過程都寫了很清楚。下面看個例子：

public class Test {
    public static void consumerIt(Consumer<String> cook, Consumer<String> eat) {
        cook.andThen(eat).accept("煮飯,吃飯");
    }

    public static void main(String[] args) {
        Test.consumerIt((i) -> {
            System.out.println(i.split(",")[0]);
        }, (i) -> {
            System.out.println(i.split(",")[1]);
        });
    }
}

out:
煮飯
吃飯

你得先煮飯，才能吃飯，在函式定義中我們就已經把這個順序給固定了，同時給了入參，所以我們後續只要把對應的每個步驟的具體實現過程進行處理就行了。這邊要注意的一點是，這裡雖然有先後順序，但是沒有因果關係，不知道這麼表述有沒有問題，意思就是andThen裡after的入參跟之前的入參是一樣的，不是說你before裡執行處理過的資料再給after，after裡的也是原始入參，這一點其實在原始碼中已經寫的很清楚，而且Consumer介面本來也只執行處理，並沒有返回，所以這一點一定要弄清楚，不小心有時會弄混。

  • 原始碼應用

    /**
     * 檢查spring容器裡是否有對應的bean,有則進行消費
     *
     * @param clazz    class
     * @param consumer 消費
     * @param <T>      泛型
     */
    private <T> void getBeanThen(Class<T> clazz, Consumer<T> consumer) {
        if (this.applicationContext.getBeanNamesForType(clazz, false, false).length > 0) {
            consumer.accept(this.applicationContext.getBean(clazz));
        }
    }

        // TODO 注入填充器
        this.getBeanThen(MetaObjectHandler.class, globalConfig::setMetaObjectHandler);
        // TODO 注入主鍵生成器
        this.getBeanThen(IKeyGenerator.class, i -> globalConfig.getDbConfig().setKeyGenerator(i));
        // TODO 注入sql注入器
        this.getBeanThen(ISqlInjector.class, globalConfig::setSqlInjector);
        // TODO 注入ID生成器
        this.getBeanThen(IdentifierGenerator.class, globalConfig::setIdentifierGenerator);

Mybatis-plus這一段查詢bean進行消費的處理應用的就是很簡單但是經典。

2.Supplier介面

Supplier介面很簡單，就一個無參的get方法，用來獲取一個泛型物件資料，說白了就是提供一個資料生成。下面看個例子：

public class Test {
    public static String supplierGet(Supplier<String> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        System.out.println(Test.supplierGet(() -> "hello world!"));
    }
}

out:
hello world!

  • 原始碼應用

public class ClientHttpRequestFactorySupplier implements Supplier<ClientHttpRequestFactory> {

	private static final Map<String, String> REQUEST_FACTORY_CANDIDATES;

	static {
		Map<String, String> candidates = new LinkedHashMap<>();
		candidates.put("org.apache.http.client.HttpClient",
				"org.springframework.http.client.HttpComponentsClientHttpRequestFactory");
		candidates.put("okhttp3.OkHttpClient", "org.springframework.http.client.OkHttp3ClientHttpRequestFactory");
		REQUEST_FACTORY_CANDIDATES = Collections.unmodifiableMap(candidates);
	}

	@Override
	public ClientHttpRequestFactory get() {
		for (Map.Entry<String, String> candidate : REQUEST_FACTORY_CANDIDATES.entrySet()) {
			ClassLoader classLoader = getClass().getClassLoader();
			if (ClassUtils.isPresent(candidate.getKey(), classLoader)) {
				Class<?> factoryClass = ClassUtils.resolveClassName(candidate.getValue(), classLoader);
				return (ClientHttpRequestFactory) BeanUtils.instantiateClass(factoryClass);
			}
		}
		return new SimpleClientHttpRequestFactory();
	}

}

springboot中ClientHttpRequestFactory的生成就是實現的Supplier介面，它基於類路徑上的可用實現來檢測首選候選物件。

3.Function介面


Function介面表示用來接受一個引數併產生結果的函式，同時跟Consumer介面很相似，他也有一個後置函式andThen，同時還有一個前置函式compose。

Function介面乍一看跟Consumer介面很像，但是區別是他是有返回引數的，而Consumer介面沒有，他是有因果關係。具體我們看下例子：

public class Test {
    public static String funGet(Function<String, String> before, Function<String, String> function, Function<String, String> after) {
        return function.compose(before).andThen(after).apply("煮飯,吃飯,洗碗");
    }

    public static void main(String[] args) {
        System.out.println(Test.funGet((t) -> {
            System.out.println(t.split(",")[0]);
            t = t.substring(t.indexOf(",") + 1);
            return t;
        }, (t) -> {
            System.out.println(t.split(",")[0]);
            t = t.substring(t.indexOf(",") + 1);
            return t;
        }, (t) -> t));
    }
}

out:
煮飯
吃飯
洗碗

上面就看出來了，他是before->fun->after這麼一個流程，並且每一步的輸入都是上一步的輸出，這樣就很清楚了。

  • 原始碼應用

  @Test
  void testWithCallable() {
    test(mapper -> mapper.getUserWithCallableAndUnset(new RowBounds(5, 3)), 0);
    test(mapper -> mapper.getUserWithCallableAndDefault(new RowBounds(4, 3)), 1);
    test(mapper -> mapper.getUserWithCallableAndForwardOnly(new RowBounds(3, 3)), 2);
    test(mapper -> mapper.getUserWithCallableAndScrollInsensitive(new RowBounds(2, 2)), 2);
    test(mapper -> mapper.getUserWithCallableAndScrollSensitive(new RowBounds(1, 1)), 1);
  }

  private void test(Function<Mapper, List<User>> usersSupplier, int expectedSize) {
    try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
      Mapper mapper = sqlSession.getMapper(Mapper.class);
      List<User> users = usersSupplier.apply(mapper);
      Assertions.assertEquals(expectedSize, users.size());
    }
  }

mybaits裡這一段單元測試執行mapper來獲得userList就用的很經典，雖然沒有用到before和after，但是確實常用的就是apply更多一點，再有就是其實我們現實開發中用到最多的funciton介面應該是map。

類似於valueList.stream().map(ValueText::getValue).collect(Collectors.toSet())這種我們常用的map操作，其實操作的就是一個funciton。

4.Predicate介面


我們先來看下Predicate的字面意思：數理邏輯中表示一個個體的性質和兩個或兩個以上個體間關係的詞。看起來似明非明的，其實很簡單就是個true or false。

其實就是用來做表示式驗證的，輸入一個引數，返回表示式是否成立的結果true or false。 具體我們看下例子：

public class Test {
    public static boolean preGet(Predicate<String> predicate) {
        return predicate.test("我是帥哥");
    }

    public static void main(String[] args) {
        System.out.println(Test.preGet((t) -> t.contains("帥哥")
        ));
    }
}

out:

true

Predicate介面還是比較容易理解的，其它幾個方法：and，negate，or，isEqual光從字面上都能理解，無非就是常用的判斷用語，所以就不一一展示了。

  • 原始碼應用

abstract class IsTestableMethod implements Predicate<Method> {

	private final Class<? extends Annotation> annotationType;
	private final boolean mustReturnVoid;

	IsTestableMethod(Class<? extends Annotation> annotationType, boolean mustReturnVoid) {
		this.annotationType = annotationType;
		this.mustReturnVoid = mustReturnVoid;
	}

	@Override
	public boolean test(Method candidate) {
		// Please do not collapse the following into a single statement.
		if (isStatic(candidate)) {
			return false;
		}
		if (isPrivate(candidate)) {
			return false;
		}
		if (isAbstract(candidate)) {
			return false;
		}
		if (returnsVoid(candidate) != this.mustReturnVoid) {
			return false;
		}

		return isAnnotated(candidate, this.annotationType);
	}

}

junit中的IsTestableMethod就是比較典型的用法，實現test方法去判斷測試方法的型別。其實我們常用的stream操作filter(m -> m.getValue() > 1)中的filter方法用來過濾就是用的Predicate。

三，其它

在java.util.function包下其實不僅僅是這四大介面，其它也有其它好幾個它們的變種，無非是把泛型改成具體型別等一系列操作，有興趣的話，具體可以到對應的路徑下去檢視。

相關文章