JDK8系列之使用Function函数式接口

已于 2023-01-01 14:55:15 修改
阅读量1.8k 收藏 2
点赞数 1
分类专栏： SpringBoot 文章标签： java spring boot
于 2022-12-17 22:53:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jike11231/article/details/128358154
版权

一、函数式接口是jdk8的新特性之一，函数式接口是只包含一个抽象方法声明的接口。按分类主要分为四大接口类型: Function、Consumer、Predicate、Supplier。

接口参数返回值说明
Supplier<T>无T供给型，无参，返回一个指定泛型的对象
Consumer<T>T无消费型，传入一个指定泛型的参数，无返回值
Predicate<T>TBoolean断言型，判断函数，返回true或者false
Function<T,R>TR方法型，输入一个参数，返回一个结果

也可以直接去java.util.function包里面看，jdk提供了很多函数式接口。比如

序号函数式接口描述说明
1BiConsumer<T,U>代表了一个接受两个输入参数的操作，并且不返回任何结果
2BiFunction<T,U,R>代表了一个接受两个输入参数的方法，并且返回一个结果

二、实战一：用函数式接口实现回调

员工执行业务逻辑完成任务后，老板收到回调通知。

1.Employee员工类

/**
 * 员工类
 *
 * @author zsh
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee<T, C> {
    /**
     * 员工的名字
     */
    private String name;
    /**
     * 员工处理任务的逻辑
     */
    private Function<T, C> taskFunction;

    /**
     * 处理任务的方法
     *
     * @param boss 发布任务的老板对象，包含老板名称，任务及回调
     */
    protected void doTask(Boss<T, C> boss) {
        if (null == boss || null == boss.getTask()) {
            throw new IllegalArgumentException("boss is not ready...");
        }
        if (null == this.taskFunction) {
            throw new IllegalArgumentException("employee has no skills for task...");
        }
        //执行任务的实际方法
        C callback = taskFunction.apply(boss.getTask());
        //将结果发送给老板
        boss.callback(this, callback);
    }
}

2.Boss老板类

/**
 * 老板类
 *
 * @author zsh
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss<T, C> {
    /**
     * 老板的名字
     */
    private String name;
    /**
     * 老板待发布的任务
     */
    private T task;
    /**
     * 老板处理回调的方法
     */
    private BiConsumer<Employee<T, C>, C> callbackConsumer;

    /**
     * 指定员工去完成老板的任务
     * 员工完成任务后回调老板的接口
     *
     * @param employee 指定的员工
     */
    public void assignTask(Employee<T, C> employee) {
        employee.doTask(this);
    }

    /**
     * 完成任务后的回调
     *
     * @param employee
     * @param callback
     */
    protected void callback(Employee<T, C> employee, C callback) {
        if (null != callback && null != callbackConsumer) {
            callbackConsumer.accept(employee, callback);
        }
    }
}

3.CallBackService回调service

/**
 * 回调service
 *
 * @author zsh
 */
@Service
public class CallBackService {
    /**
     * 回调方法
     */
    public <T, C> void bossAssignTask() {
        //初始化老板对象，指定名称，任务和处理回调的逻辑
        Boss<T, C> bossA = new Boss<>(
                "bossA",
                (T) "a任务",
                (e, c) -> System.out.println("BossA收到" + e.getName() + "的回调啦..." + c.toString())
        );
        //初始化员工对象，指定名称和处理任务的逻辑
        Employee<T, C> employee = new Employee<>(
                "employee",
                t -> {
                    System.out.println("【员工A】收到任务" + t.toString() + "啦...");
                    try {
                        //通过睡眠，模拟执行任务
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("【员工A】完成任务" + t.toString() + "啦...");
                    return (C) "确认了处理结果";
                });
        //老板给员工安排任务，员工完成任务后老板会收到回调
        bossA.assignTask(employee);
        //员工可以换一个处理这个任务的逻辑
        employee.setTaskFunction(t -> {
            System.out.println("【员工A新逻辑】收到任务" + t.toString() + "啦...");
            try {
                //通过睡眠，模拟执行任务
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【员工A新逻辑】完成任务" + t.toString() + "啦...");
            return (C) "确认了新逻辑处理结果";
        });
        //老板继续给员工安排任务
        bossA.assignTask(employee);
        //老板有了新任务
        bossA.setTask((T) "b任务");
        //老板继续给员工安排任务
        bossA.assignTask(employee);
        //老板有新的回调逻辑
        bossA.setCallbackConsumer((e, c) -> System.out.println("BossA新的回调方法收到" + e.getName() + "的回调啦..." + c.toString()));
        //老板继续给员工安排任务
        //bossA.assignTask(employee);
    }
}

4.CallBackController回调controller

/**
 * 回调Controller
 *
 * @author zsh
 */
@RestController
@RequestMapping("/callBackController")
public class CallBackController {
    @Autowired
    private CallBackService callBackService;

    @RequestMapping("/callBackBossAssignTask")
    public boolean callBackBossAssignTask() {
        callBackService.bossAssignTask();
        return true;
    }

}

5.测试结果

在这里插入图片描述
在这里插入图片描述

6.代码结构及下载地址

在这里插入图片描述

三、利用Function函数优化if else逻辑

1.由于Function接口的入参只支持一个参数，所以自定义一个MyFunction，支持多个参数

@FunctionalInterface
public interface MyFunction<T, R> {
    R apply(T... t);
}

2.业务服务FunctionService

@Service
public class FunctionService {
    public static Map<String, MyFunction<Object, String>> map = new HashMap<>();

    @PostConstruct
    public void init() {
        map.put("A", FunctionService::fun01);
        map.put("B", FunctionService::fun02);
        map.put("C", FunctionService::fun03);
    }

    private static String fun03(Object... o) {
        System.out.println("fun03=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "CCC";
    }

    private static String fun02(Object... o) {
        System.out.println("fun02=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "BBB";
    }

    private static String fun01(Object... o) {
        System.out.println("fun01=====>");
        for (Object o1 : o) {
            System.out.println(o1);
        }
        return "AAA";
    }

    public String getFunctionResult(String type, String value, Integer num) {
        // 以前的if-else
        /*
        if(type.equals("A")){
            fun01("a", 1);
        }else if(type.equals("B")){
            fun02("b", 2);
        }else if(type.equals("C")){
            fun03("c", 3);
        }
        */
        // 优化的if-else
        return map.get(type).apply(value, num);
    }
}

3.控制层

@RequestMapping("/functionController")
@RestController
public class FunctionController {
    @Autowired
    private FunctionService functionService;

    @RequestMapping("/doFunctionByType")
    public String doFunctionByType(String type, String value, Integer num) {
        return functionService.getFunctionResult(type, value, num);
    }
}

4.执行结果测试

结果1
在这里插入图片描述
在这里插入图片描述
结果2
在这里插入图片描述
在这里插入图片描述

5.代码结构

在这里插入图片描述

6.通过map + 函数式的方式处理if-else业务逻辑

 /**
     * 传统根据不同条件判断执行不同业务逻辑
     *
     * @param num
     * @return
     */
    public String getUserNameByNum(Integer num) {
        User user = new User();
        user.setUserName("张三丰");
        user.setRealName("三丰丰");
        String userName = "";
        switch (num) {
            case 1:
                userName = String.format("我的名字,name:%s", user.getUserName());
                break;
            case 2:
                userName = String.format("我的名字,name:,realName:%s", user.getUserName(), user.getRealName());
                break;
            default:
                break;
        }
        return userName;
    }

    //定义一个map跟Function组合使用的map
    private final ImmutableMap<Integer, Function<User, String>> PERSON_TYPE_MAP = ImmutableMap.<Integer, Function<User, String>>builder()
            .put(1, person -> String.format("武当山No1,userName:%s", person.getUserName()))
            .put(2, person -> String.format("武当山No1,userName:%s,realName:%s", person.getUserName(), person.getRealName()))
            .build();

    //调用
    public String getFunctionUserNameByNum(Integer num) {
        User user = new User();
        user.setUserName("张三丰");
        user.setRealName("三丰丰");
        return PERSON_TYPE_MAP.get(num).apply(user);
    }

//通过Function获取用户名
    @RequestMapping("/getFunctionUserNameByNum")
    public String getFunctionUserNameByNum(int num) {
        return userService.getFunctionUserNameByNum(num);
    }

在这里插入图片描述
在这里插入图片描述

四、 项目源码下载 spring-boot2.-xlearn 欢迎Star

参考资料
JDK8系列之使用Function函数式接口实现回调
java8 函数式接口 实现回调
ImmutableMap使用分析
map与函数式编程篇

懒虫虫~
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk1.8之函数式接口
liu_shi_jun的专栏
01-10 1311
jdk1.8 函数式编程之Function , Consumer, Supplier, Predicate
JDK1.8【函数式接口】【定义与使用】【源码】
04-19
JDK1.8【函数式接口】【定义与使用】【源码】 文章地址：https://blog.csdn.net/m0_37969197/article/details/124146253 * 函数式接口（类的定义与适应形式，只是一种类的定义形式，属于新增语法） * 包：java....
JDK8 Function用法详解最全
weixin_41202749的博客
10-14 3741
入口 Function<T,R> function是传一个参数返回一个参数 这个可以用场景总结一。集合遍历对于对象的处理等等 一.原生的用法 实现接口 public class FunctionObj implements Function { @Override public Object apply(Object t) { return "原生的用法实现接口"+t; } } public class Test { // p
JDK8系列之使用Function函数式接口实现回调
Nicky's blog
08-07 2230
最近项目工程安装api、service、web等进行模块划分，但是缓存用户信息的是写在一个工具类里，使用ThreadLocal进行缓存，在一个service工程里需要用到工具类，直接将工具类搬过去，显然不合适，而且如果业务分为一个独立服务之后，ThreadLocal的数据是不能被其他线程访问的，所以不合适，那么要怎么处理？ ............
jdk8新特性之Function接口的使用
拼命摸鱼的小铄
10-21 204
jdk8新特性之Function接口
掌握JDK8：（三）函数式接口Function接口详解
challenge51all的专栏
03-15 828
JDK8开始，Java在java.util.function包里面加入了很多的函数式接口。见下图。 今天我们先讲一下Function接口。 package java.util.function; import java.util.Objects; /** * Represents a function that accepts one argument and produces a...
jdk8函数式Function接口使用汇总
higherzjm的专栏
05-06 887
jdk8函数式Function接口使用汇总
jdk8新特性-四大函数式接口（Consumer、Supplier、Function、Predicate）使用样例
少说，多做
12-02 1万+
函数式接口(Functional Interface)是Java 8对一类特殊类型的接口的称呼。 这类接口只定义了唯一的抽象方法的接口，并且这类接口使用了@FunctionalInterface进行注解。在jdk8中，引入了一个新的包java.util.function, 可以使java 8 的函数式编程变得更加简便
JDK8新特性之常用函数式接口
taibaishenlong的专栏
08-05 496
常用的函数式接口主要在java.util.function包下，函数式接口是Lambda表达式使用的前提，而Lambda表达式不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型，因此，为了让Lambda表达式使用更方便，jdk提供了大量函数式接口。(常用的接口：Supplier接口、Consumer接口、Function接口、Predicate接口等) 目录 1）、Supplier接口 2）、Consumer接口 3）、Function接口 4）、Predicate 接口 1）、Su
JDK 1.8 Function 函数，函数式编程，函数式接口的用法
HEshenghuxi的博客
10-20 468
JDK 1.8 Function 函数，函数式编程，函数式接口的用法
JDK1.8新特性函数式接口
01-20
概述 对于只有一个抽象方法的接口，需要这种接口的对象，就可以提供一个lambda表达式。这种接口称为函数式接口...JDK1.8常用函数式接口 函数式接口 参数类型 返回类型 抽象方法名 描述 其他方法 Rnnnable 无
Java函数式接口Supplier接口实例详解
08-25
Java 函数式接口 Supplier 接口实例详解 Java 函数式接口 Supplier 接口实例详解是 Java 函数式编程中一个非常重要的概念。Supplier 接口是 Java 中的一种函数式接口，主要用来提供对象数据的获取。该接口只有一个...
死磕Lambda表达式（四）：常用的函数式接口
01-20
在Java8支持Lambda表达式以后，为了满足Lambda表达式的一些典型使用场景，JDK为我们提供了大量常用的函数式接口。它们主要在 java.util.function 包中，下面简单介绍几个其中的接口及其使用示例。 Supplier接口 ...
java8-函数式接口.pdf
07-08
Java 8引入了函数式接口的概念，这是一项重要的更新，旨在支持函数式编程风格。函数式接口是指只有一个抽象方法的接口，这样的设计使得接口能够被用作 Lambda 表达式的类型。Lambda 表达式是一种简洁的匿名函数表示...
Mysql批量删除大量数据
热门推荐
jike11231的博客
08-27 1万+
假设有一个表(syslogs)有1000万条记录，需要在业务不停止的情况下删除其中statusid=1的所有记录，差不多有600万条， 直接执行 DELETE FROM syslogs WHERE statusid=1 会发现删除失败，因为lock wait timeout exceed的错误。如果要用order by 必须要和 limit 联用，否则被优化掉。然后分多次执行就可以把这些记录成功删除。...
SpringBoot启动后实现自动执行其它业务方法功能
jike11231的博客
06-23 6086
一、业务应用场景 1：需要在容器启动的时候执行一些内容。比如读取配置文件，数据库连接之类的。SpringBoot给我们提供了两个接口来帮助我们实现这种需求。 2：应用服务启动时，加载一些数据和执行一些应用的初始化动作。如：删除临时文件，清除缓存信息，读取配置文件信息，数据库连接等。 对于小型项目进行定时任务的启动。 ...
SpringBoot集成ElasticSearch
jike11231的博客
05-28 5911
被逼无奈，各行各业都在卷，给自己充电学习了Elasticsearch，在学完基础知识后（其实就是CRUD😂），就去Springboot中尝试整合ES。终于抽出时间，将学习的东西整理分享在此，欢迎大家批评指正哈~
SpringBoot中SpringContextHolder工具类使用
jike11231的博客
02-15 5750
SpringContextHolder作用： 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext。 SpringContextHolder @Component public class SpringContextHolder implements ApplicationContextAware { /** * 以静态变量保存ApplicationContext,可在任意代码中取出Applicaiton
jdk17中包含的函数式接口
最新发布
09-23
在JDK 17中，包含了许多函数式接口，例如： 1. Function<T, R>: 代表一个接受一个参数并产生结果的函数。 2. Predicate<T>: 代表一个接受一个参数并返回布尔值的函数。 3. Consumer<T>: 代表一个接受一个参数并且没有返回值的操作。 4. Supplier<T>: 代表一个无参数函数，返回一个结果。 5. BiFunction<T, U, R>: 代表一个接受两个参数并产生结果的函数。 这些函数式接口可以使代码更加简洁和易读，尤其在使用Lambda表达式或方法引用时非常有用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值