SpringBoot整合JavaFX中操作数据库，JdbcTemplate，Mybatis

SpringBoot整合JavaFX

这几天学习了一下SpringBoot整合JavaFX，学习了几种在SpringBoot中启动JavaFX的方式。
我在做登录验证的时候，想从数据库中查询数据，遇到了问题。一直报空指针异常。

Caused by: java.lang.NullPointerException: Cannot invoke
"org.springframework.jdbc.core.JdbcTemplate.queryForList(String)"because “this.jdbcTemplate” is null

本来不操作数据库，项目是可以正常启动的。正常的登录，跳转。但是我想在登录的时候验证一下账号密码，然后就加了查数据库的操作。结果一直报错，用mybatis报错，用jdbctemplate也报错。。
仔细想想，这个应该是JavaFX和SpringBoot的兼容问题吧

通过不断的寻找，我解决了这个问题。就是使用配置类
下面我将用两种 SpringBoot启动JavaFX程序的方式来展示解决办法。
希望能帮助到需要的同学们

第一个项目 实现 CommandLineRunner接口

CommandLineRunner接口是SpringBoot框架中的接口，在CommandLineRunner接口下，SpringBoot会改为命令行启动，这时候修改main方法，并且实现接口中的run方法。

1.创建一个SpringBoot项目，Maven中添加需要的依赖。我用的是jdk17。。。javafx20

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yzlshdg</groupId>
    <artifactId>SpringBoot-CommandLineRunner</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBoot-CommandLineRunner</name>
    <description>SpringBoot-CommandLineRunner</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <!--JavaFX依赖-->
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-controls</artifactId>
            <version>20</version>
        </dependency>
        <!--fxml依赖-->
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-fxml</artifactId>
            <version>19.0.2.1</version>
        </dependency>
        <!--jdbc依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.主配置文件application.properties

#数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=9ccchina
spring.datasource.url=jdbc:mysql://localhost:3306/yzlshdg

3.编写启动类,实现CommandLineRunner接口

import javafx.application.Application;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


/**
 * SpringBoot项目
 */

@SpringBootApplication
public class SpringBootCommandLineRunnerApplication implements CommandLineRunner {


    //改造main方法
    public static void main(String[] args) {
       SpringApplication app = new SpringApplication(SpringBootCommandLineRunnerApplication.class);
       app.run(args);
    }


    //重写接口中的run的方法
    @Override
    public void run(String... args) throws Exception {
        //javafx中的类      这个类是javafx的类
        Application.launch(MainApp.class,args);
    }
}

4.编写JavaFX的程序类，这个类要继承JavaFX中的Application
我这里做的是，把从数据库中查询到的数据，展示到JavaFX的表格中

import com.yzlshdg.entity.BaGua;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.image.Image;
import javafx.stage.Stage;



import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

//不加这个注解,就加载不了配置类。  配置类所在的包
@ComponentScan(basePackages = "com.yzlshdg.config")
public class MainApp extends Application {


     //Spring的上下文对象
    private ConfigurableApplicationContext context;

    //重写初始化的方法，在这里创建Spring的上下文对象
    @Override
    public void init() throws Exception {
        //先创建一个构造器对象 参数是当前类
        SpringApplicationBuilder builder = new SpringApplicationBuilder(MainApp.class);
        //运行构建器，调用run方法来创造Spring上下文对象，参数是一个字符串数组
        //getParameters().getRaw().toArray(new String[0])获取的是启动参数，并转换成字符串数组
        context = builder.run(getParameters().getRaw().toArray(new String[0]));
    }
    
    @Override
    public void start(Stage stage) throws Exception {

/*    //加载fxml文件
       AnchorPane root = FXMLLoader.load(getClass().getResource("/fxml/app.fxml"));*/


        //创建可观察的列表，用来存数据
        ObservableList<BaGua> data = FXCollections.observableArrayList();

        //创建表
        TableView<BaGua> table = new TableView<>();
//        table.setPrefWidth(969.0);
//        table.prefHeight(620.0);
        //创建列
        TableColumn eight = new TableColumn<>("八卦");
        eight.setPrefWidth(95.20001524686813);
        TableColumn shiW = new TableColumn<>("事物");
        shiW.setPrefWidth(95.20001524686813);
        TableColumn fuH = new TableColumn<>("符号");
        fuH.setPrefWidth(95.20001524686813);
        TableColumn fangX = new TableColumn<>("方向");
        fangX.setPrefWidth(95.20001524686813);
        TableColumn jieQ = new TableColumn<>("节气");
        jieQ.setPrefWidth(95.20001524686813);
        TableColumn yueF = new TableColumn<>("月份");
        yueF.setPrefWidth(95.20001524686813);
        TableColumn yueX = new TableColumn<>("月相");
        yueX.setPrefWidth(95.20001524686813);
        TableColumn zhouY = new TableColumn<>("周易");
        zhouY.setPrefWidth(319.2000732421875);


        //把数据放入对应的列
        eight.setCellValueFactory(new PropertyValueFactory<>("eight"));
        shiW.setCellValueFactory(new PropertyValueFactory<>("shiW"));
        fuH.setCellValueFactory(new PropertyValueFactory<>("fuH"));
        fangX.setCellValueFactory(new PropertyValueFactory<>("fangX"));
        jieQ.setCellValueFactory(new PropertyValueFactory<>("jieQ"));
        yueF.setCellValueFactory(new PropertyValueFactory<>("yueF"));
        yueX.setCellValueFactory(new PropertyValueFactory<>("yueX"));
        zhouY.setCellValueFactory(new PropertyValueFactory<>("zhouY"));


                           //从Spring容器中获取JdbcTemplate实例，用于执行数据库操作。执行数据库查询操作，第一个参数是SQL查询语句
        List<BaGua> list = context.getBean(JdbcTemplate.class).query("select * from 先天八卦",
                //第二个参数是一个lambda表达式，用于处理查询结果
            // 这是一个lambda表达式，用于处理查询结果。它接收两个参数：ResultSet rs表示查询结果集，int rowNum表示当前行号 从0开始
                (rs, rowNum) -> {
              //通过ResultSet对象的getString()方法获取名为"八卦"的列的值，并赋给eightVal变量
                    String eightVal = rs.getString("八卦");
                    String shiWVal = rs.getString("事物");
                    String fuHVal = rs.getString("符号");
                    String fangXVal = rs.getString("方向");
                    String jieQVal= rs.getString("节气");
                    String yueFVal = rs.getString("月份");
                    String yueXVal = rs.getString("月相");
                    String zhouYVal = rs.getString("周易");
                    //根据从查询结果中提取的值，创建一个新的BaGua对象，并返回该对象。这个类是数据模型类
                    return new BaGua(eightVal,shiWVal,fuHVal,fangXVal,jieQVal,yueFVal,yueXVal,zhouYVal);
                });

        //foreach循环遍历这个集合
        for(BaGua baGua:list) {
           data.add(new BaGua(baGua.getEight(),baGua.getShiW(),baGua.getFuH(),baGua.getFangX()
           ,baGua.getJieQ(),baGua.getYueF(),baGua.getYueX(),baGua.getZhouY()));
        }


        //把列放到表格中
        table.getColumns().addAll(eight,shiW,fuH,fangX,jieQ,yueF,yueX,zhouY);
        //把数据放入表中
        table.setItems(data);


        stage.setWidth(969);
        stage.setHeight(720);
        stage.getIcons().add(new Image("/image/xx.jpg"));
        stage.setScene(new Scene(table));
        stage.setTitle("JavaFX程序");
        stage.show();
    }
}

5.实体类。数据模型

mport javafx.beans.property.SimpleStringProperty;

/**
 * 数据的实体类，javafx中用到的 数据模型类
 */
public class BaGua {
    //属性都是SimpleStringProperty的
    //SimpleStringProperty是JavaFX中的一个类，它用于将字符串属性与JavaFX控件进行绑定
    private final SimpleStringProperty eight;
    private final SimpleStringProperty shiW;
    private final SimpleStringProperty fuH;
    private final SimpleStringProperty fangX;
    private final SimpleStringProperty jieQ;
    private final SimpleStringProperty yueF;
    private final SimpleStringProperty yueX;
    private final SimpleStringProperty zhouY;


    public BaGua(String eight, String shiW, String fuH, String fangX, String jieQ, String yueF, String yueX, String zhouY) {
        this.eight = new SimpleStringProperty(eight);
        this.shiW = new SimpleStringProperty(shiW);
        this.fuH =new SimpleStringProperty(fuH);
        this.fangX = new SimpleStringProperty(fangX);
        this.jieQ = new SimpleStringProperty(jieQ);
        this.yueF = new SimpleStringProperty(yueF);
        this.yueX = new SimpleStringProperty(yueX);
        this.zhouY = new SimpleStringProperty(zhouY);
    }

    public String getEight() {
        return eight.get();
    }

    public SimpleStringProperty eightProperty() {
        return eight;
    }

    public void setEight(String eight) {
        this.eight.set(eight);
    }

    public String getShiW() {
        return shiW.get();
    }

    public SimpleStringProperty shiWProperty() {
        return shiW;
    }

    public void setShiW(String shiW) {
        this.shiW.set(shiW);
    }

    public String getFuH() {
        return fuH.get();
    }

    public SimpleStringProperty fuHProperty() {
        return fuH;
    }

    public void setFuH(String fuH) {
        this.fuH.set(fuH);
    }

    public String getFangX() {
        return fangX.get();
    }

    public SimpleStringProperty fangXProperty() {
        return fangX;
    }

    public void setFangX(String fangX) {
        this.fangX.set(fangX);
    }

    public String getJieQ() {
        return jieQ.get();
    }

    public SimpleStringProperty jieQProperty() {
        return jieQ;
    }

    public void setJieQ(String jieQ) {
        this.jieQ.set(jieQ);
    }

    public String getYueF() {
        return yueF.get();
    }

    public SimpleStringProperty yueFProperty() {
        return yueF;
    }

    public void setYueF(String yueF) {
        this.yueF.set(yueF);
    }

    public String getYueX() {
        return yueX.get();
    }

    public SimpleStringProperty yueXProperty() {
        return yueX;
    }

    public void setYueX(String yueX) {
        this.yueX.set(yueX);
    }

    public String getZhouY() {
        return zhouY.get();
    }

    public SimpleStringProperty zhouYProperty() {
        return zhouY;
    }

    public void setZhouY(String zhouY) {
        this.zhouY.set(zhouY);
    }
}

6.配置类

使用 配置类 解决 Caused by: java.lang.NullPointerException: Cannot invoke
"org.springframework.jdbc.core.JdbcTemplate.queryForList(String)"because “this.jdbcTemplate” is null

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

/**
 * 配置类  。。在SpringBoot整合JavaFX中，使用操作数据库的框架，会有问题。可能是程序之间的通信的问题
 *    使用这个配置类，来解决数据库持久层注入为null的问题。 这个配置注入的是 JdbcTemplate
 */
@Configuration
public class DataSourceConfig {

     //读取配置文件中的属性
    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

    //用来返回一个数据源对象
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }

    //返回一个JdbcTemplate对象，使用@Bean注解将其添加到Spring容器中
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

运行效果：成功的查出了数据，并展示在表格中

注意：JavaFX的主程序类需要加上包扫描的注解

@ComponentScan(basePackages = “配置类包名”)

第二个项目 SpringBoot主启动类直接继承JavaFX中的Application类

SpringBoot的主启动类直接继承Application类，修改main方法中的调用，调用launch(args)即可


1.创建SpringBoot项目，添加Maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yzlshdg</groupId>
    <artifactId>SpringBoot-JavaFX-03</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBoot-JavaFX-03</name>
    <description>SpringBoot-JavaFX-03</description>
    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-controls</artifactId>
            <version>20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.配置文件application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/yzlshdg
spring.datasource.username=root
spring.datasource.password=9ccchina
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

3.编写SpringBoot主启动类，继承Application

import com.yzlshdg.entity.BaGua;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.image.Image;
import javafx.stage.Stage;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

/**
 * SpringBoot整合JavaFX JdbcTemplate
 * 使用JdbcTemplate查询数据库
 */

@SpringBootApplication
public class SpringBootJavaFx03Application extends Application {

    //在JavaFX应用程序中，通常会通过SpringApplicationBuilder手动创建一个Spring应用程序上下文
    //定义一个私有的ConfigurableApplicationContext属性context，我们可以在整个应用程序中保留对上下文的引用。
   // 这样，我们就能够在需要的时候轻松地从上下文中获取其他的Bean实例
   private ConfigurableApplicationContext context;
      
    public static void main(String[] args) {
        //修改后的main方法
        launch(args);
    }

    //init() 方法是JavaFX应用程序的生命周期方法之一，它在应用程序启动之前被调用。在这个方法中，我们可以执行一些初始化操作。
    @Override
    public void init() throws Exception {
        //通过 SpringApplicationBuilder 创建了一个 Spring 应用程序上下文，并将其赋值给 context 属性
        SpringApplicationBuilder builder = new SpringApplicationBuilder(SpringBootJavaFx03Application.class);
        //运行构建器：使用 builder.run(...) 方法运行构建器，该方法接受一个字符串数组作为参数。
        //在这里，我们通过 getParameters().getRaw().toArray(new String[0]) 获取启动参数，
        // 并将其转换为字符串数组传递给构建器。这样做可以将启动参数传递给 Spring Boot 应用程序
        //赋值给 context 属性：将返回的 ConfigurableApplicationContext 对象赋值给 context 属性，
        // 以便在应用程序的其他地方可以访问和使用该上下文对象
        context = builder.run(getParameters().getRaw().toArray(new String[0]));
    }

    @Override
    public void start(Stage stage) throws Exception {
        /*    //加载fxml文件
       AnchorPane root = FXMLLoader.load(getClass().getResource("/fxml/app.fxml"));*/


        //创建可观察的列表，用来存数据
        ObservableList<BaGua> data = FXCollections.observableArrayList();

        //创建表
        TableView<BaGua> table = new TableView<>();

        //创建列
        TableColumn eight = new TableColumn<>("八卦");
        eight.setPrefWidth(95.20001524686813);
        TableColumn shiW = new TableColumn<>("事物");
        shiW.setPrefWidth(95.20001524686813);
        TableColumn fuH = new TableColumn<>("符号");
        fuH.setPrefWidth(95.20001524686813);
        TableColumn fangX = new TableColumn<>("方向");
        fangX.setPrefWidth(95.20001524686813);
        TableColumn jieQ = new TableColumn<>("节气");
        jieQ.setPrefWidth(95.20001524686813);
        TableColumn yueF = new TableColumn<>("月份");
        yueF.setPrefWidth(95.20001524686813);
        TableColumn yueX = new TableColumn<>("月相");
        yueX.setPrefWidth(95.20001524686813);
        TableColumn zhouY = new TableColumn<>("周易");
        zhouY.setPrefWidth(319.2000732421875);


        //把数据放入对应的列
        eight.setCellValueFactory(new PropertyValueFactory<>("eight"));
        shiW.setCellValueFactory(new PropertyValueFactory<>("shiW"));
        fuH.setCellValueFactory(new PropertyValueFactory<>("fuH"));
        fangX.setCellValueFactory(new PropertyValueFactory<>("fangX"));
        jieQ.setCellValueFactory(new PropertyValueFactory<>("jieQ"));
        yueF.setCellValueFactory(new PropertyValueFactory<>("yueF"));
        yueX.setCellValueFactory(new PropertyValueFactory<>("yueX"));
        zhouY.setCellValueFactory(new PropertyValueFactory<>("zhouY"));


        //从Spring容器中获取JdbcTemplate实例，用于执行数据库操作。执行数据库查询操作，第一个参数是SQL查询语句
        List<BaGua> list = context.getBean(JdbcTemplate.class).query("select * from 先天八卦",
                //第二个参数是一个lambda表达式，用于处理查询结果
                // 这是一个lambda表达式，用于处理查询结果。它接收两个参数：ResultSet rs表示查询结果集，int rowNum表示当前行号 从0开始
                (rs, rowNum) -> {
                    //通过ResultSet对象的getString()方法获取名为"八卦"的列的值，并赋给eightVal变量
                    //getString()中的参数是数据库中的字段名
                    String eightVal = rs.getString("八卦");
                    String shiWVal = rs.getString("事物");
                    String fuHVal = rs.getString("符号");
                    String fangXVal = rs.getString("方向");
                    String jieQVal= rs.getString("节气");
                    String yueFVal = rs.getString("月份");
                    String yueXVal = rs.getString("月相");
                    String zhouYVal = rs.getString("周易");
                    //根据从查询结果中提取的值，创建一个新的BaGua对象，并返回该对象。这个类是数据模型类
                    return new BaGua(eightVal,shiWVal,fuHVal,fangXVal,jieQVal,yueFVal,yueXVal,zhouYVal);
                });

        //foreach循环遍历这个集合
        for(BaGua baGua:list) {
            data.add(new BaGua(baGua.getEight(),baGua.getShiW(),baGua.getFuH(),baGua.getFangX()
                    ,baGua.getJieQ(),baGua.getYueF(),baGua.getYueX(),baGua.getZhouY()));
        }


        //把列放到表格中
        table.getColumns().addAll(eight,shiW,fuH,fangX,jieQ,yueF,yueX,zhouY);
        //把数据放入表中
        table.setItems(data);


        stage.setWidth(969);
        stage.setHeight(720);
        stage.getIcons().add(new Image("/image/xx.jpg"));
        stage.setScene(new Scene(table));
        stage.setTitle("JavaFX程序");
        stage.show();
    }
    
}

4.实体类

import javafx.beans.property.SimpleStringProperty;

/**
 * 数据的实体类，javafx中用到的 数据模型类
 */
public class BaGua {

 // SimpleStringProperty是JavaFX中的一个类，它用于将字符串属性与JavaFX控件进行绑定
    private final SimpleStringProperty eight;
    private final SimpleStringProperty shiW;
    private final SimpleStringProperty fuH;
    private final SimpleStringProperty fangX;
    private final SimpleStringProperty jieQ;
    private final SimpleStringProperty yueF;
    private final SimpleStringProperty yueX;
    private final SimpleStringProperty zhouY;




    public BaGua(String eight, String shiW, String fuH, String fangX, String jieQ, String yueF, String yueX, String zhouY) {
        this.eight = new SimpleStringProperty(eight);
        this.shiW = new SimpleStringProperty(shiW);
        this.fuH =new SimpleStringProperty(fuH);
        this.fangX = new SimpleStringProperty(fangX);
        this.jieQ = new SimpleStringProperty(jieQ);
        this.yueF = new SimpleStringProperty(yueF);
        this.yueX = new SimpleStringProperty(yueX);
        this.zhouY = new SimpleStringProperty(zhouY);
    }

    public String getEight() {
        return eight.get();
    }

    public SimpleStringProperty eightProperty() {
        return eight;
    }

    public void setEight(String eight) {
        this.eight.set(eight);
    }

    public String getShiW() {
        return shiW.get();
    }

    public SimpleStringProperty shiWProperty() {
        return shiW;
    }

    public void setShiW(String shiW) {
        this.shiW.set(shiW);
    }

    public String getFuH() {
        return fuH.get();
    }

    public SimpleStringProperty fuHProperty() {
        return fuH;
    }

    public void setFuH(String fuH) {
        this.fuH.set(fuH);
    }

    public String getFangX() {
        return fangX.get();
    }

    public SimpleStringProperty fangXProperty() {
        return fangX;
    }

    public void setFangX(String fangX) {
        this.fangX.set(fangX);
    }

    public String getJieQ() {
        return jieQ.get();
    }

    public SimpleStringProperty jieQProperty() {
        return jieQ;
    }

    public void setJieQ(String jieQ) {
        this.jieQ.set(jieQ);
    }

    public String getYueF() {
        return yueF.get();
    }

    public SimpleStringProperty yueFProperty() {
        return yueF;
    }

    public void setYueF(String yueF) {
        this.yueF.set(yueF);
    }

    public String getYueX() {
        return yueX.get();
    }

    public SimpleStringProperty yueXProperty() {
        return yueX;
    }

    public void setYueX(String yueX) {
        this.yueX.set(yueX);
    }

    public String getZhouY() {
        return zhouY.get();
    }

    public SimpleStringProperty zhouYProperty() {
        return zhouY;
    }

    public void setZhouY(String zhouY) {
        this.zhouY.set(zhouY);
    }
}

5.配置类

使用 配置类 解决 Caused by: java.lang.NullPointerException: Cannot invoke
"org.springframework.jdbc.core.JdbcTemplate.queryForList(String)"because “this.jdbcTemplate” is null

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {
     //读取配置文件属性
    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
     
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }
    //把这个对象交给Spring容器
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

6.编写启动入口类 解决，错误: 缺少 JavaFX 运行时组件, 需要使用该组件来运行此应用程序

/**
 * 启动入口。。。 解决  错误: 缺少 JavaFX 运行时组件, 需要使用该组件来运行此应用程序
 */
public class App {
    public static void main(String[] args) {
        SpringBootJavaFx03Application.main(args);
    }
}

第一种方式跟第二种方式有一点区别，第二种方式不用加@ComponentScan(basePackages = “配置类包名”)这个注解

第二种方式直接在SpringBoot主启动类中写代码，似乎没有那么好

为了解决这个问题，百度了两天啊。JavaFX的案例很少，太不容易了 主要是解决这个数据库操作的问题，别的代码就可以继续写了