• JavaFx自定义事件

    关于JavaFx自定义事件: 

    JavaFX Documentation Projecthttps://fxdocs.github.io/docs/html5/index.html#_event_handling上面的文档已经做了简要说明,但是在实际应用中发现其并不够详细，搜索现有网上的自定义事件其内容大都并不十分清晰，因此写篇博客站在我的角度描述一下这个问题，我这里使用的JDK8。

    首先我的需求：

    如图所示，需求十分清晰，就是做一个点击按钮计数器，当点击按钮，下面的计数器的数字会发生变化。

    实现方式一： 

    1. import javafx.application.Application;
    2. import javafx.scene.Scene;
    3. import javafx.scene.control.Button;
    4. import javafx.scene.control.Label;
    5. import javafx.scene.layout.VBox;
    6. import javafx.stage.Stage;
    7.  
    8. import java.util.concurrent.atomic.AtomicInteger;
    9.  
    10. public class EventTestApp extends Application {
    11.  
    12.     public static AtomicInteger atomicInteger = new AtomicInteger();
    13.  
    14.     public static final String labelPrefix = "点击次数：";
    15.  
    16.     @Override
    17.     public void start(Stage primaryStage) throws Exception {
    18.         Button btn = new Button();
    19.         btn.setText("点击加一");
    20.         Label label = new Label(labelPrefix + "0");
    21.         btn.setOnAction(event -> {
    22. //            设置Label显示文字
    23.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    24.         });
    25.  
    26.         VBox root = new VBox();
    27.         root.getChildren().addAll(btn, label);
    28.  
    29.         Scene scene = new Scene(root, 300, 250);
    30.  
    31.         primaryStage.setTitle("javaFx自定义事件测试");
    32.         primaryStage.setScene(scene);
    33.         primaryStage.show();
    34.     }
    35.  
    36.     public static void main(String[] args) {
    37.         launch(args);
    38.     }
    39. }

    实现方式非常简单，就是当按钮发生点击时引用Label实例，然后设置Label的值，同时也可以看到一些缺陷： 就是Label的初始化必须在Button的前面。

    实现方式二：

    1. import javafx.application.Application;
    2. import javafx.scene.Scene;
    3. import javafx.scene.control.Button;
    4. import javafx.scene.control.Label;
    5. import javafx.scene.layout.VBox;
    6. import javafx.stage.Stage;
    7.  
    8. import java.util.concurrent.atomic.AtomicInteger;
    9.  
    10. public class EventTestApp extends Application {
    11.  
    12.     public static AtomicInteger atomicInteger = new AtomicInteger();
    13.  
    14.     public static final String labelPrefix = "点击次数：";
    15.  
    16.     @Override
    17.     public void start(Stage primaryStage) throws Exception {
    18.         Button btn = new Button();
    19.         btn.setText("点击加一");
    20.  
    21.         btn.setOnAction(event -> {
    22.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    23. //            发射自定义事件
    24.             btn.fireEvent(userEvent);
    25.         });
    26.  
    27.         Label label = new Label(labelPrefix + "0");
    28. //         添加自定义事件处理方法
    29.         label.addEventFilter(UserEvent.ANY,event -> {
    30. //            设置Label显示文字
    31.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    32.         });
    33.  
    34.         VBox root = new VBox();
    35.         root.getChildren().addAll(btn, label);
    36.  
    37.  
    38.  
    39.         Scene scene = new Scene(root, 300, 250);
    40.  
    41.         primaryStage.setTitle("javaFx自定义事件测试");
    42.         primaryStage.setScene(scene);
    43.         primaryStage.show();
    44.     }
    45.  
    46.     public static void main(String[] args) {
    47.         launch(args);
    48.     }
    49. }

    1. import javafx.event.Event;
    2. import javafx.event.EventType;
    3.  
    4. public class UserEvent extends Event {
    5.     public static final EventType ANY = new EventType<>(Event.ANY, "ANY");
    6.  
    7.     public static final EventType CLICKED = new EventType<>(ANY,"CLICKED");
    8.  
    9.  
    10.     public UserEvent(EventType eventType) {
    11.         super(eventType);
    12.     }
    13.  
    14.  
    15. }

    由于这种方式我们使用了自定义事件，因此创建了自定义事件的类，当按钮点击时，创建自定义事件，然后发送事件，同时在Lable初始化后监听了该事件，此时我们发现Button与Lable实现了解耦。

    然而一切看起来十分美好，但是当点击按钮时，却发现Label并未做出任何反应，此时按照开头文档，应该是没有问题的才对。

    开启Debug模式，调试 

    1.  
    2. //            发射自定义事件
    3.             btn.fireEvent(userEvent);

    看他做了什么。

    简单的调试过后，我们发现其实调用的是 com.sun.javafx.event.EventUtil.fireEvent()方法，他其实是一个静态方法。

    EventUtil类

    1.     public static Event fireEvent(EventTarget eventTarget, Event event) {
    2.         // 通过调试发现,此时event.getTarget()为null,而eventTarget为button
    3.         if (event.getTarget() != eventTarget) {
    4.             // 顾名思义,似乎是一个事件拷贝的方法
    5.             event = event.copyFor(event.getSource(), eventTarget);
    6.             // 重要的是当该方法执行完成event.getTarget()竟然指向了button,也就是说事件发射源和接收者指向了同一个组件
    7.         }
    8.  
    9.         if (eventDispatchChainInUse.getAndSet(true)) {
    10.             // the member event dispatch chain is in use currently, we need to
    11.             // create a new instance for this call
    12.             return fireEventImpl(new EventDispatchChainImpl(),
    13.                                  eventTarget, event);
    14.         }
    15.  
    16.         try {
    17.             return fireEventImpl(eventDispatchChain, eventTarget, event);
    18.         } finally {
    19.             // need to do reset after use to remove references to event
    20.             // dispatchers from the chain
    21.             eventDispatchChain.reset();
    22.             eventDispatchChainInUse.set(false);
    23.         }
    24.     }

    我把调试的发现写在了代码里，由于事件发射源与事件接收者是同一个组件，那么我就可以直接给button添加EventHandler。

    于是代码更新为：

    1. import javafx.application.Application;
    2. import javafx.scene.Scene;
    3. import javafx.scene.control.Button;
    4. import javafx.scene.control.Label;
    5. import javafx.scene.layout.VBox;
    6. import javafx.stage.Stage;
    7.  
    8. import java.util.concurrent.atomic.AtomicInteger;
    9.  
    10. public class EventTestApp extends Application {
    11.  
    12.     public static AtomicInteger atomicInteger = new AtomicInteger();
    13.  
    14.     public static final String labelPrefix = "点击次数：";
    15.  
    16.     @Override
    17.     public void start(Stage primaryStage) throws Exception {
    18.         Button btn = new Button();
    19.         btn.setText("点击加一");
    20.  
    21.         btn.setOnAction(event -> {
    22.             System.out.println("btn发送事件");
    23.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    24. //            发射自定义事件
    25.             btn.fireEvent(userEvent);
    26.         });
    27.         btn.addEventHandler(UserEvent.ANY,event -> {
    28.             System.out.println("btn接收到事件"); 
    29.         });
    30.         Label label = new Label(labelPrefix + "0");
    31. //         添加自定义事件处理方法
    32.         label.addEventFilter(UserEvent.ANY,event -> {
    33. //            设置Label显示文字
    34.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    35.             System.out.println("Label接收到事件");
    36.         });
    37.  
    38.         VBox root = new VBox();
    39.         root.getChildren().addAll(btn, label);
    40.  
    41.  
    42.  
    43.         Scene scene = new Scene(root, 300, 250);
    44.  
    45.         primaryStage.setTitle("javaFx自定义事件测试");
    46.         primaryStage.setScene(scene);
    47.         primaryStage.show();
    48.     }
    49.  
    50.     public static void main(String[] args) {
    51.         launch(args);
    52.     }
    53. }

    运行代码,并且点击按钮，得到结果是

    发现果然是button把事件发送给了自己。

    那么问题就来了，为什么button会把事件发送给自己，而不是Label呢，其实通过调试我们也可以发现，一个重要的参数是EventTarget。而EventTarget是一个接口。

    EventTarget类
    1. public interface EventTarget {
    2.  
    3.     EventDispatchChain buildEventDispatchChain(EventDispatchChain tail);
    4. }

    然后找EventTarget的子类，发现都是一些control下的类,比如Button、Pane、Box等组件。

    那么是不是我们在发射组件时指定EventTarget就可以了呢？已知，EventTarget的子类时control下的类，那么我们的Label应该也是EventTarget的实例

    于是启动类变更为：

    1. import javafx.application.Application;
    2. import javafx.event.Event;
    3. import javafx.scene.Scene;
    4. import javafx.scene.control.Button;
    5. import javafx.scene.control.Label;
    6. import javafx.scene.layout.VBox;
    7. import javafx.stage.Stage;
    8.  
    9. import java.util.concurrent.atomic.AtomicInteger;
    10.  
    11. public class EventTestApp extends Application {
    12.  
    13.     public static AtomicInteger atomicInteger = new AtomicInteger();
    14.  
    15.     public static final String labelPrefix = "点击次数：";
    16.  
    17.     @Override
    18.     public void start(Stage primaryStage) throws Exception {
    19.         Button btn = new Button();
    20.         btn.setText("点击加一");
    21.         Label label = new Label(labelPrefix + "0");
    22.         btn.setOnAction(event -> {
    23.             System.out.println("btn发送事件");
    24.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    25. //            发射自定义事件
    26.             btn.fireEvent(userEvent);
    27.             Event.fireEvent(label,userEvent);
    28.         });
    29.         btn.addEventHandler(UserEvent.ANY,event -> {
    30.             System.out.println("btn接收到事件");
    31.         });
    32.  
    33. //         添加自定义事件处理方法
    34.         label.addEventFilter(UserEvent.ANY,event -> {
    35. //            设置Label显示文字
    36.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    37.             System.out.println("Label接收到事件");
    38.         });
    39.  
    40.         VBox root = new VBox();
    41.         root.getChildren().addAll(btn, label);
    42.         Scene scene = new Scene(root, 300, 250);
    43.         primaryStage.setTitle("javaFx自定义事件测试");
    44.         primaryStage.setScene(scene);
    45.         primaryStage.show();
    46.     }
    47.  
    48.     public static void main(String[] args) {
    49.         launch(args);
    50.     }
    51. }

    启动，点击按钮：

    发现Label监听到了事件，但是缺点也是十分明显,就是Label的初始化依然在Button的前面,似乎又回到开始的地方,那么有没有现成的方案去获取
    EventTarget呢,其实是有的,通过kookup()方法进行查找,不过在查找对应EventTarget之前,需要先将EventTarget设置一个标识，即通过setId()方法。此时启动类变更为：

    1. import javafx.application.Application;
    2. import javafx.event.Event;
    3. import javafx.scene.Node;
    4. import javafx.scene.Scene;
    5. import javafx.scene.control.Button;
    6. import javafx.scene.control.Label;
    7. import javafx.scene.layout.VBox;
    8. import javafx.stage.Stage;
    9.  
    10. import java.util.concurrent.atomic.AtomicInteger;
    11.  
    12. public class EventTestApp extends Application {
    13.  
    14.     public static AtomicInteger atomicInteger = new AtomicInteger();
    15.  
    16.     public static final String labelPrefix = "点击次数：";
    17.  
    18.     @Override
    19.     public void start(Stage primaryStage) throws Exception {
    20.         Button btn = new Button();
    21.         btn.setText("点击加一");
    22.  
    23.         btn.setOnAction(event -> {
    24.             System.out.println("btn发送事件");
    25.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    26. //            发射自定义事件
    27. //            btn.fireEvent(userEvent);
    28.             Node lookup = btn.getScene().lookup("#test-label");
    29.             Event.fireEvent(lookup,userEvent);
    30.         });
    31.         btn.addEventHandler(UserEvent.ANY,event -> {
    32.             System.out.println("btn接收到事件");
    33.         });
    34.  
    35.         Label label = new Label(labelPrefix + "0");
    36. //        设置EventTarget的id
    37.         label.setId("test-label");
    38. //         添加自定义事件处理方法
    39.         label.addEventFilter(UserEvent.ANY,event -> {
    40. //            设置Label显示文字
    41.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    42.             System.out.println("Label接收到事件");
    43.         });
    44.  
    45.         VBox root = new VBox();
    46.         root.getChildren().addAll(btn, label);
    47.         Scene scene = new Scene(root, 300, 250);
    48.         primaryStage.setTitle("javaFx自定义事件测试");
    49.         primaryStage.setScene(scene);
    50.         primaryStage.show();
    51.     }
    52.  
    53.     public static void main(String[] args) {
    54.         launch(args);
    55.     }
    56. }

    启动，执行结果为：

    此时Label组件执行了,而button的监听并没有执行,这说明如果指定了EventTarget那么只有指定的EventTarget才能被触发,当然如何让button也能执行呢,其实我们只需要发送多次事件即可,如同代码中的注释。

    同时可以看到在使用lookup()方法之前,需要先执行getScene()方法,这是因为寻找EventTarget是从上到下寻找,因此我们从Scene开始找就一定可以找到。

    关于javaFx的结构图,我从网上找了一张。

    同时采用了lookup()方法,组件间不需要相互持有引用,因此组件初始化顺序就变得灵活了。

    以上我们的代码是直接写在启动类中的，其实这并不符合我们的开发直觉，因为不管CS程序还是BS程序，都有一些公共的区域，比如页头区域，页尾，按钮组区域等，因此我们需要把内容单独写到一个组件中。

    自定义一个组件，把内容放在自定义组件中。

    1. import javafx.scene.control.Button;
    2. import javafx.scene.control.Label;
    3. import javafx.scene.layout.VBox;
    4.  
    5. import java.util.concurrent.atomic.AtomicInteger;
    6.  
    7. public class CustomPane extends VBox {
    8.  
    9.     public static AtomicInteger atomicInteger = new AtomicInteger();
    10.  
    11.     public static final String labelPrefix = "点击次数：";
    12.  
    13.     public CustomPane() {
    14.         Button btn = new Button();
    15.         btn.setText("点击加一");
    16.         btn.setOnAction(event -> {
    17.             System.out.println("btn发送事件");
    18.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    19. //            发射自定义事件
    20.             btn.fireEvent(userEvent);
    21.         });
    22.         btn.addEventHandler(UserEvent.ANY,event -> {
    23.             System.out.println("btn接收到事件");
    24.         });
    25.         Label label = new Label(labelPrefix + "0");
    26. //         添加自定义事件处理方法
    27.         label.addEventFilter(UserEvent.ANY,event -> {
    28. //            设置Label显示文字
    29.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    30.             System.out.println("Label接收到事件");
    31.         });
    32.  
    33.         getChildren().addAll(btn, label);
    34. //        自定义组件添加监听
    35.         addEventHandler(UserEvent.ANY,e->{
    36.             System.out.println("自定义组件接收到事件");
    37. //            设置Label显示文字
    38.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    39.         });
    40.     }
    41. }

     启动类精简为：

    1. import javafx.application.Application;
    2. import javafx.scene.Scene;
    3. import javafx.stage.Stage;
    4.  
    5. public class EventTestApp extends Application {
    6.  
    7.  
    8.  
    9.     @Override
    10.     public void start(Stage primaryStage) throws Exception {
    11.         Scene scene = new Scene(new CustomPane(), 300, 250);
    12.         primaryStage.setTitle("javaFx自定义事件测试");
    13.         primaryStage.setScene(scene);
    14.         primaryStage.show();
    15.     }
    16.  
    17.     public static void main(String[] args) {
    18.         launch(args);
    19.     }
    20. }

    启动，点击按钮得到结果：

    Label没有监听到事件在意料之中，因为上面代码在发射事件时并没有指定EventTarget,但是在自定义组件的代码里同时设置了监听，结果也监听到了。并且由于Label是在自定义组件中进行初始化的，那么自定义组件本身自然可以也引用的到Label。

    那么为什么自定义组件本身也可以监听的到事件呢？

    继续调试：

    在com.sun.javafx.event.EventUtil类中找到该方法：

    1.     private static Event fireEventImpl(EventDispatchChain eventDispatchChain,
    2.                                        EventTarget eventTarget,
    3.                                        Event event) {
    4. //  eventTarget.buildEventDispatchChain(eventDispatchChain)是个十分重要的方法,即构建事件分发链。
    5. //  构建好后的分发链包含了Buuton的父节点即自定义组件,因此自定义组件也可以监听事件,可以试试在启动类
    6. //  中添加addEventHandler(),其实是添加不上的。
    7.         final EventDispatchChain targetDispatchChain =
    8.                 eventTarget.buildEventDispatchChain(eventDispatchChain);
    9.         return targetDispatchChain.dispatchEvent(event);
    10.     }

    我们看看是如何构建事件分发链的。

    javafx.scene.Node类
    1.     public EventDispatchChain buildEventDispatchChain(
    2.             EventDispatchChain tail) {
    3.  
    4.         if (preprocessMouseEventDispatcher == null) {
    5.             preprocessMouseEventDispatcher = (event, tail1) -> {
    6.                 event = tail1.dispatchEvent(event);
    7.                 if (event instanceof MouseEvent) {
    8.                     preprocessMouseEvent((MouseEvent) event);
    9.                 }
    10.  
    11.                 return event;
    12.             };
    13.         }
    14.  
    15.         tail = tail.prepend(preprocessMouseEventDispatcher);
    16.  
    17.         // prepend all event dispatchers from this node to the root
    18.         Node curNode = this;
    19.         do {
    20.             if (curNode.eventDispatcher != null) {
    21.                 final EventDispatcher eventDispatcherValue =
    22.                         curNode.eventDispatcher.get();
    23.                 if (eventDispatcherValue != null) {
    24.                     tail = tail.prepend(eventDispatcherValue);
    25.                 }
    26.             }
    27.             // 重点是这个方法
    28.             final Node curParent = curNode.getParent();
    29.             curNode = curParent != null ? curParent : curNode.getSubScene();
    30.         } while (curNode != null);
    31.  
    32.         if (getScene() != null) {
    33.             // prepend scene's dispatch chain
    34.             tail = getScene().buildEventDispatchChain(tail);
    35.         }
    36.  
    37.         return tail;
    38.     }

    这个方法是Node类即节点类，我们在方法里面看到了getParent()方法,疑问也就可以解答了，在构建了事件分发链时取了父节点。同时我们在看看节点链类的大致结构：

    com.sun.javafx.event.EventDispatchChainImpl

    1. public class EventDispatchChainImpl implements EventDispatchChain {
    2.     /** Must be a power of two. */
    3.     private static final int CAPACITY_GROWTH_FACTOR = 8;
    4.     
    5.     private EventDispatcher[] dispatchers;
    6.  
    7.     private int[] nextLinks;
    8.  
    9.     private int reservedCount;
    10.     private int activeCount;
    11.     private int headIndex;
    12.     private int tailIndex;
    13.  
    14.     public EventDispatchChainImpl() {
    15.     }
    16.  
    17.      /** 略 */
    18.       
    19.     /**
    20.      * 重点方法 事件分发
    21.     */
    22.     @Override
    23.     public Event dispatchEvent(final Event event) {
    24.         if (activeCount == 0) {
    25.             return event;
    26.         }
    27.  
    28.         // push current state
    29.         final int savedHeadIndex = headIndex;
    30.         final int savedTailIndex = tailIndex;
    31.         final int savedActiveCount = activeCount;
    32.         final int savedReservedCount = reservedCount;
    33.  
    34.         final EventDispatcher nextEventDispatcher = dispatchers[headIndex];
    35.         headIndex = nextLinks[headIndex];
    36.         --activeCount;
    37.         // 重点
    38.         final Event returnEvent =
    39.                 nextEventDispatcher.dispatchEvent(event, this);
    40.  
    41.         // pop saved state
    42.         headIndex = savedHeadIndex;
    43.         tailIndex = savedTailIndex;
    44.         activeCount = savedActiveCount;
    45.         reservedCount = savedReservedCount;
    46.  
    47.         return returnEvent;
    48.     }
    49.  
    50. }

    里面包含了需要分发的数组。还有一个分发函数dispatchEvent()。它最终又调用了其他方法。

    第三种方式：

    通过第二种方式，其实就已经讲明白了事件分发是怎么回事，其实第三种方式是用来说明我认为最合适的方式，由于前面已经说明了EventTarget，那么我们在日常开发时，尽量要做到组件化,比如按钮组就是一个组件，里面是很多的按钮，内容显示区是单独的一个组件，因此，我们创建两个自定义组件,一个组件专门用来放置按钮，一个组件专门用来控制Label，按钮组件发射事件，Label组件监听组件并响应变化。

    自定义按钮组件

    1. import com.sun.javafx.event.EventUtil;
    2. import javafx.geometry.Insets;
    3. import javafx.geometry.Pos;
    4. import javafx.scene.Node;
    5. import javafx.scene.control.Button;
    6. import javafx.scene.layout.Background;
    7. import javafx.scene.layout.BackgroundFill;
    8. import javafx.scene.layout.CornerRadii;
    9. import javafx.scene.layout.HBox;
    10. import javafx.scene.paint.Color;
    11.  
    12. /**
    13.  * 自定义Button组件
    14.  */
    15. public class ButtonPane extends HBox {
    16.  
    17.  
    18.     public ButtonPane() {
    19.         setPrefHeight(30);
    20.         setAlignment(Pos.CENTER);
    21. //        设置子组件间距
    22.         setSpacing(30);
    23.         Color blue = Color.BLUE;
    24. //        四个角半径即填充有弧度
    25.         CornerRadii cornerRadii = new CornerRadii(0);
    26.         Insets insets = new Insets(0, 0, 0, 0);
    27.         BackgroundFill backgroundFill = new BackgroundFill(blue, cornerRadii, insets);
    28.         setBackground(new Background(backgroundFill));
    29.  
    30.         Button btn = new Button("点击+1");
    31.         Button btn2 = new Button("生成随机数");
    32.  
    33.         btn.setOnAction(event -> {
    34.  //           注意构造方法中选择正确的事件类型
    35.             UserEvent userEvent = new UserEvent(UserEvent.CLICKED);
    36.             Node eventTarget = btn.getScene().lookup("#LabelPane");
    37. //            发射自定义事件(点击+1)
    38.             EventUtil.fireEvent(eventTarget, userEvent);
    39.         });
    40.  
    41.         btn2.setOnAction(event -> {
    42.  //           注意构造方法中选择正确的事件类型
    43.             UserEvent userEvent = new UserEvent(UserEvent.RANDOM);
    44.             Node eventTarget = btn2.getScene().lookup("#LabelPane");
    45. //            发射自定义事件(随机数)
    46.             EventUtil.fireEvent(eventTarget, userEvent);
    47.         });
    48.  
    49.         getChildren().addAll(btn, btn2);
    50.     }
    51. }

    自定义Label组件

    1. import javafx.geometry.Insets;
    2. import javafx.geometry.Pos;
    3. import javafx.scene.control.Label;
    4. import javafx.scene.layout.Background;
    5. import javafx.scene.layout.BackgroundFill;
    6. import javafx.scene.layout.CornerRadii;
    7. import javafx.scene.layout.HBox;
    8. import javafx.scene.paint.Color;
    9.  
    10. import java.util.Random;
    11. import java.util.concurrent.atomic.AtomicInteger;
    12. /**
    13.  * 自定义Label组件
    14.  */
    15. public class LabelPane extends HBox {
    16.  
    17.     public static AtomicInteger atomicInteger = new AtomicInteger();
    18.  
    19.     public static final String labelPrefix = "点击次数：";
    20.  
    21.     public static final String label2Prefix = "随机数：";
    22.  
    23.     public LabelPane() {
    24.         setId("LabelPane");
    25.         setPrefHeight(30);
    26.         setAlignment(Pos.CENTER);
    27. //        设置子组件间距
    28.         setSpacing(30);
    29.         Color green = Color.GREEN;
    30. //        四个角半径即填充有弧度
    31.         CornerRadii cornerRadii = new CornerRadii(0);
    32.         Insets insets = new Insets(0, 0, 0, 0);
    33.         BackgroundFill backgroundFill = new BackgroundFill(green, cornerRadii, insets);
    34.         setBackground(new Background(backgroundFill));
    35.  
    36.         Label label = new Label(labelPrefix + "0");
    37.         Label label2 = new Label(label2Prefix + "0");
    38. //        添加自定义事件处理方法(点击+1),注意此处类型要设置正确
    39.         addEventHandler(UserEvent.CLICKED, event -> {
    40. //            设置Label显示文字
    41.             label.setText(labelPrefix + atomicInteger.incrementAndGet());
    42.         });
    43. //        添加自定义事件处理方法(随机数),注意此处类型要设置正确
    44.         addEventHandler(UserEvent.RANDOM, event -> {
    45. //            设置Label显示文字
    46.             label2.setText(label2Prefix + new Random().nextInt());
    47.         });
    48.  
    49.         getChildren().addAll(label, label2);
    50.     }
    51. }

    自定义事件类：

    1. import javafx.event.Event;
    2. import javafx.event.EventType;
    3.  
    4. /**
    5.  * 自定义事件类
    6.  */
    7. public class UserEvent extends Event {
    8.     public static final EventType ANY = new EventType<>(Event.ANY, "ANY");
    9.  
    10.     /**
    11.      * 点击+1 事件类型
    12.      */
    13.     public static final EventType CLICKED = new EventType<>(ANY,"CLICKED");
    14.  
    15.     /**
    16.      * 随机数 事件类型
    17.      */
    18.     public static final EventType RANDOM = new EventType<>(ANY,"RANDOM");
    19.  
    20.  
    21.     public UserEvent(EventType eventType) {
    22.         super(eventType);
    23.     }
    24.  
    25.  
    26. }

    启动类

    1. import javafx.application.Application;
    2. import javafx.scene.Scene;
    3. import javafx.scene.layout.VBox;
    4. import javafx.stage.Stage;
    5.  
    6. public class EventTestApp extends Application {
    7.  
    8.     @Override
    9.     public void start(Stage primaryStage) throws Exception {
    10.         VBox root = new VBox();
    11. //        初始化自定义组件
    12.         ButtonPane buttonPane = new ButtonPane();
    13.         LabelPane labelPane = new LabelPane();
    14. //        将初始化好的组件,放入到根布局中
    15.         root.getChildren().addAll(buttonPane, labelPane);
    16. //        根布局设置到场景中
    17.         Scene scene = new Scene(root, 300, 250);
    18.         primaryStage.setTitle("javaFx自定义事件测试");
    19.         primaryStage.setScene(scene);
    20.         primaryStage.show();
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.         launch(args);
    25.     }
    26. }

    最终效果展示：

     

  • 相关阅读:
    学习八股文的知识点～～1
    谈谈HMI 的自动化生成技术
    Python爬虫-IP隐藏技术与代理爬取
    Android相机调用-CameraX【外接摄像头】【USB摄像头】
    【论文精读】Attention is all you need
    Android 13.0 首次开机进入Launcher3前黑屏几秒的几种情况问题的总结
    Django实现音乐网站 ⒂
    排序算法-堆排序和TopK算法
    【前端】前端权限管理的实现方式：基于Vue项目的详细指南
    基于PHP+MySQL学生创新作品展示系统的设计与实现
  • 原文地址：https://blog.csdn.net/kanyun123/article/details/127814063