Java8,函数式编程应用:

持续更新中：

函数式(Functional)接口 什么是函数式(Functional)接口 只包含一个抽象方法的接口，称为函数式接口。

你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式
抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽 象方法上进行声明）。

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检 查它是否是一个函数式接口。同时 javadoc
也会包含一条声明，说明这个 接口是一个函数式接口。

在java.util.function包下定义了Java 8 的丰富的函数式接口:

package com.ly.frauddataplatform.luoyan;

//TODO: 需要在接口上定义@FunctionalInterface注解,表示这是一个函数式的接口
//TODO: MyFunc<R,T>这里是标明泛型
@FunctionalInterface
public interface MyFunc<R,T> {
    /**
     * @Author luoyan
     * @Description: 函数式编程
     * @Date 2024/3/4 20:42
     * @param t: 入参,泛型可以传任何类型
     * @return R: 返回参数,泛型可以传任何类型
    **/
    R getValue(T t);
}

这里是自定义的函数式编程的自定义的实现接口方式：

    //TODO: 这里自定义一个方法,这个方法可以实现前置通知,后置通知,可以在调用方法的前后做一些公用的操作.
    //TODO: 在调用到自己的实现方法中的时候,去设计实现自己所需要的代码逻辑流程.
    /**
     * @Author luoyan
     * @Description: 封装的方法,泛型中<R,T>:这个是声明泛型,R:返回的类型,也可以修改R为String,T为String.那么入参和出现就必须是String的类型.
     * @Date 2024/3/4 20:46 
     * @param myFunc: 这个是函数方法
     * @param name: 入参
     * @return R
    **/
    public <R,T> R toUpDate(MyFunc<R, T> myFunc, T name){
        System.out.println("前置通知");
        //TODO: 调用自己设定订代码逻辑流程.
        R value = myFunc.getValue(name);
        System.out.println(value);
        System.out.println("后置通知");
        return myFunc.getValue(name);
    }
    
    //TODO: 使用一个方法进行测试.
    @Test
    public void testDemoOne(){
        //TODO: 这里实现自己的代码逻辑.
        //TODO: 这里name是T,也就是入参,"1231"是R,也就是出参,可以自己随意定义,因为是泛型.
        String s = toUpDate(str -> {
            System.out.println(str);
            return "1231";
        }, true);
        
        System.out.println(s);
    }

函数式接口：有且仅有一个抽象方法的接口

Java 中的函数式编程体现就是 Lambda 表达式，所以函数式接口就是可以使用于 Lambda 使用的接口只有确保接口中有且仅有一个抽象方法，Java 中的 Lambda 才能顺利地进行推导。

如何检测一个接口是不是函数式接口呢？

@FunctionalInterface 注解，放在接口定义的上方，如果接口是函数接口，编译通过；如果不是，编译失败。

注意：

我们自己定义函数式接口的时候，@FunctionalInterface 是可选的，就算我们不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上注解。

Java 8 在 java.util.function 包下预定了大量的函数式接口供我们使用，常用如下：

• Supplier 接口
• Consumer 接口
• Predicate 接口
• Function 接口

Supplier接口

方法	说明
T get()	生产数据的接口

源码展示：

Supplier 接口被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的 get 方法就会生产什么类型的数据供我们使用。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据，如下：
可以看到输出得值是String和1，这里也就是调用到了方法自己顶的代码逻辑流程中。

@Test
void supplier_test() {
    String string = getString(() -> "String");
    log.info(string);
    Integer integer = getInteger(() -> 1);
    log.info(integer + "");
}

String getString(Supplier<String> supplier) {
    return supplier.get();
}

Integer getInteger(Supplier<Integer> supplier) {
    return supplier.get();
}

Consumer

方法	说明
void accept(T t)	消费一个指定泛型的数据
default Consumer andThen(Consumer<? super T> after)	消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合

源码展示：

① accept

@FunctionalInterface
public interface Consumer<T> {

    /**
     * 消费一个指定泛型的数据
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * 默认方法
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

对于 accept() 方法，它是消费，如下：

@Test
void consumer_test() {
    consumer_accept(100, money -> log.info("本次消费: " + money));
}

/**
 * 定义一个方法
 *
 * @param money    传递一个int类型的 money
 * @param consumer
 */
void consumer_accept(Integer money, Consumer<Integer> consumer) {
    consumer.accept(money);
}

② andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是一步接一步操作。例如两个步骤组 合的情况：

@Test
void consumer_andThen_test() {
    consumer_andThen("abcdefg",
            // 先转为大写
            str -> log.info(str.toUpperCase()),
            // 在转为小写
            str -> log.info(str.toLowerCase()));
}

void consumer_andThen(String str, Consumer<String> consumer1, Consumer<String> consumer2) {
    consumer1.andThen(consumer2).accept(str);
}

例子：

String[] array = { "张三,女", "李四,女", "王五,男" };

让它们按照以下格式打印：

姓名: XX 性别: XX

@Test
void printInfo() {
    String[] array = {"张三,女", "李四,女", "王五,男"};
    printInfo(array,
            str -> System.out.print("姓名: " + str.split(",")[0]),
            str -> System.out.println(" 性别: " + str.split(",")[1])
    );
}
void printInfo(String[] arr, Consumer<String> consumer1, Consumer<String> consumer2) {
    for (String s : arr) {
        consumer1.andThen(consumer2).accept(s);
    }
}

结果如下：

很明显consumer1调用了自己的System.out.print(“姓名: " +str.split(”,“)[0])这个流程，然后在调用了System.out.println(” 性别: " +str.split(“,”)[1])这个流程，把参数array作为s传入到了这个流程中，也就是印证了源码中的(T t) -> {accept(t); after.accept(t); }流程。

Predicate：函数接口

方法	说明
boolean test(T t)	对给定的参数进行判断（判断逻辑由 Lambda 表达式实现)，返回一个布尔值
default Predicate negate()	返回一个逻辑的否定，对应逻辑非（ ! ）
default Predicate and (Predicate other)	返回一个组合判断，对应短路与（&&）
default Predicate or (Predicate other)	返回一个组合判断，对应短路或（

源码展示：

① test()
可以用来判断某个值是否满足条件，如下：

/**
 * 判断字符串的长度是否满足条件
 */
@Test
void predicate_test() {
    boolean predicate = predicate_test("predicate", str -> str.length() > 10);
    System.out.println(predicate);
}

boolean predicate_test(String str, Predicate<String> predicate) {
    boolean b = predicate.test(str);
    return b;
}

② and() && or()
这两个是相对的，且和或的关系，会短路，如下：

/**
 * 判断字符串是否以 A 开头,并且 equals B
 */
@Test
void predicate_and_test() {
    boolean b = predicate_and("A", x -> x.startsWith("A"), y -> y.equals("B"));
    System.out.println(b);
}
boolean predicate_and(String str, Predicate<String> predicate1, Predicate<String> predicate2) {
    boolean b = predicate1.and(predicate2).test(str);
    return b;
}

输出: false
   
/**
 * 判断字符串是否以 A 开头,或者 equals B
 */
@Test
void predicate_or_test() {
    boolean b = predicate_or("A", x -> x.startsWith("A"), y -> y.equals("B"));
    System.out.println(b);
}
boolean predicate_or(String str, Predicate<String> predicate1, Predicate<String> predicate2) {
    boolean b = predicate1.or(predicate2).test(str);
    return b;
}

输出: true

③ negate()
该方法就是对 test() 取反，该方法的源码如下：

default Predicate<T> negate() {
    return (t) -> !test(t);
}

例子：

/**
 * 判断字符串的长度是否大于 5
 */
@Test
void predicate_negate_test() {
    Predicate<String> predicate = s -> s.length() > 5;
    boolean b1 = predicate.test("predicate");
    System.out.println(b1); // true
    
    boolean b2 = predicate.negate().test("predicate");
    System.out.println(b2); // false
}

第二个例子：

Predicate<Integer> predicate = n ->{
    if (n > 4){
        return true;
    }
    return false;
};

Predicate<Integer> and = predicate.and(k -> {
    if (k < 6) {
        return true;
    }
    return false;
}).or(t -> {
    if (t == 10) {
        return true;
    }
    return false;
});
boolean test1 = and.test(5);
System.out.println(test1);

Function
该接口通常用于对参数进行处理，转换然后返回一个新的值。

方法	说明
R apply(T t)	根据类型 T 的参数获取类型 R 的结果
default Function<T,V> andThen(Function after)	返回一个组合函数，首先将该函数应用于其输入，然后将 after函数应用于结果

源码展示：

这里使用：Function接口来实现。此接口的特点：有入参，有出参，可以直接很好的使用。还有其他的函数。

比如：只需要入参，不需要出参，可以根据自己的情况而定。

① apply()
该方法根据类型 T 的参数获取类型 R 的结果。 例如：将 String 类型转换为 int 类型。

@Test
void function_test() {
    int i = function_apply("1234", x -> Integer.valueOf(x));
    System.out.println(i);
}

/**
 * 吧字符串类型转为 int 类型
 * @param str
 * @param fun
 * @return
 */
int function_apply(String str, Function<String, Integer> fun) {
    Integer apply = fun.apply(str);
    return apply;
}

② andThen()

@Test
void function_andThen_test() {
    double d = function_andThen("10", x -> Integer.parseInt(x) + 10, y -> Double.valueOf(y));
    System.out.println(d);
}

/**
 * 把 String 类型转为 Integer 加10，然后再转为 Double 类型
 */
double function_andThen(String str, Function<String, Integer> fun1, Function<Integer, Double> fun2) {
    double apply = fun1.andThen(fun2).apply(str);//自动拆箱
    return apply;
}

实际开发中，举一个例子：
比如我们要使用前置要做的事情，然后调用方法自己的逻辑，最后在执行一个后置要做的事情，其中前置流程和后置流程都是共有的流程。那么就可以使用函数式的变成去封装方法，然后每个地方都可以直接调用。这样很方便。

如果没有函数式编程，我们可能会想到反射的方式，传入一个类，一个方法，然后通过反射的方式去调用这个类中的某个方法，从而可以达到这种实现，但是太麻烦了。

目前我们需要对于redis进行上锁，然后解锁，中间是走自己的流程，那么我们就可以使用函数式编程：

package com.elong.fraud.rcenginedataconvert.constants;

import com.elong.fraud.rcenginedataconvert.model.dto.TryLockParamData;
import com.ly.tcbase.cacheclient.CacheClientHA;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.function.Function;

/**
 * @Author luoyan
 * @Description: redis锁
 * @Date 2024年01月18日 10:38
 * @Version: V1.0
 */
@Component
public class RedissionTemplate {

    @Resource
    private CacheClientHA cacheClientHa;

    /**
     * @Author luoyan
     * @Description:
     * @Date 2024/1/19 15:15
     * @param tryLockParamData: 入参值.
     *                        LockKey:key,
     *                        param:请求参数
     * @param consumer: Function<T,R> 
     *                T:入参,
     *                R:返回参数
     * @return R
    **/
    public <R> R tryLock(TryLockParamData tryLockParamData, Function<Object,R> consumer){
        //TODO: 前置通知，对于参数进行校验
        String lockKey = tryLockParamData.getLockKey();
        if (ObjectUtils.isEmpty(lockKey)){
            return null;
        }
        //TODO: 前置通知，进行上锁
        String lockVal = UUID.randomUUID().toString();
        Boolean lock = cacheClientHa.String().setnx(lockKey, 60L, lockVal);
        try {
            long millis = System.currentTimeMillis();
            while (!lock) {
                //等待锁释放
                try {
                    if (System.currentTimeMillis() - millis > 3000) {
                        throw new RuntimeException("程序异常,未获取锁！");
                    }
                    Thread.sleep(100);
                } catch (Exception ignore) {
                }
                lock = cacheClientHa.String().setnx(lockKey, 60L, lockVal);
            }
            //TODO: 这里去调用自己的代码流程
            return consumer.apply(tryLockParamData.getParam());
        }finally {
            //TODO: 后置通知，去进行解锁。
            if (lockVal.equals(cacheClientHa.String().setcas(lockKey, lockVal, lockVal))) {
                cacheClientHa.Key().del(lockKey);
            }
        }
    }
}

第一处调用：
这里是重复调用公用的redis上锁流程，然后自己实现自己的代码逻辑流程。

private JSONObject saveOrUpdateOriginData(JSONObject newValue, String uniqueId, String sourceName) {
    //分布式锁
    String lockKey = String.format(RedisCacheConstants.DATA_SOURCE_DETAIL_LOCK_FORMAT, sourceName, uniqueId);
    //TODO:new TryLockParamData(lockKey)：入参。逗号后面就是函数方法，也就是自己的代码逻辑。
    JSONObject newValReturn = redissionTemplate.tryLock(new TryLockParamData(lockKey), consumer -> {
		//TODO: 自己的代码逻辑流程，先上锁，然后走这里的代码逻辑流程，最后进行解锁。
        return newVal;
    });
    return newValReturn == null ? new JSONObject() : newValReturn;
}

第二处调用：
这里就是再次调用redis进行上锁，实现自己的代码逻辑流程。

//分布式锁
String lockKey = String.format(RedisCacheConstants.FEATURE_LIST_UPDATE_LOCK_FORMAT, uniqueId);
//TODO:new TryLockParamData(lockKey)：入参。逗号后面就是函数方法，也就是自己的代码逻辑。
redissionTemplate.tryLock(new TryLockParamData(lockKey), rLock -> {
	//TODO: 自己的代码逻辑流程，先上锁，然后走这里的代码逻辑流程，最后进行解锁。
    //先执行更新，更新失败执行插入
    int update = dcdbFraudMapper.update(origin.getTableName(), fieldList, StrUtil.toUnderlineCase(origin.getUpdateKey()), uniqueId);
    if (update == 0) {
        boolean insert = dcdbFraudMapper.insert(origin.getTableName(), fieldList);
    }
    return null;
});

可以看到上面两处的调用使用函数式编程非常方便且代码也很美观，不用其他的方式就能够快速的实现，对于同事的阅读和理解也是非常快速的。

如果对你有帮助，或是有一些启发的话，制作不易，还请点赞收藏！！！感谢感谢。