Java编写一个可以导入曲库，有数据库的闹钟

以下是一个简单的Java闹钟程序，可以导入曲库，使用数据库来存储闹钟设置：

1. 引入依赖

在项目的pom.xml中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
        <version>3.4.5</version>
    </dependency>
    <dependency>
        <groupId>org.xerial</groupId>
        <artifactId>sqlite-jdbc</artifactId>
        <version>3.36.0.3</version>
    </dependency>
    <dependency>
        <groupId>com.github.albfernandez</groupId>
        <artifactId>JavaFXMediaPlayer</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

其中，HikariCP用于连接池管理，sqlite-jdbc用于访问SQLite数据库，JavaFXMediaPlayer用于播放音乐。

2. 创建数据库

在项目中创建一个SQLite数据库，包含两个表：alarm和song。

alarm表用于存储闹钟设置，包含以下字段：

| 字段名 | 类型 | 描述 |
|--------|----------|----------|
| id | INTEGER | 主键 |
| time | TEXT | 闹钟时间 |
| songId | INTEGER | 音乐ID |

song表用于存储曲库，包含以下字段：

| 字段名 | 类型 | 描述 |
|--------|---------|----------|
| id | INTEGER | 主键 |
| name | TEXT | 歌曲名称 |
| path | TEXT | 歌曲路径 |

SQLite数据库可以使用任意SQLite管理工具创建。

3. 创建Java类

创建Alarm和Song两个Java类，分别对应数据库中的两个表。

Alarm.java：

public class Alarm {
    private int id;
    private String time;
    private int songId;

    public Alarm(int id, String time, int songId) {
        this.id = id;
        this.time = time;
        this.songId = songId;
    }

    // 省略getter和setter方法
}

Song.java：

public class Song {
    private int id;
    private String name;
    private String path;

    public Song(int id, String name, String path) {
        this.id = id;
        this.name = name;
        this.path = path;
    }

    // 省略getter和setter方法
}

创建AlarmClock类，实现闹钟功能。

AlarmClock.java：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javafx.application.Application;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.stage.Stage;
import org.sqlite.SQLiteConfig;
import org.sqlite.SQLiteDataSource;

import javax.sql.DataSource;
import java.nio.file.Paths;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

public class AlarmClock extends Application {
    private static final String DB_URL = "jdbc:sqlite:alarmclock.db";

    private DataSource dataSource;
    private List<Song> songs;
    private MediaPlayer mediaPlayer;

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 初始化数据源
        initDataSource();

        // 加载曲库
        loadSongs();

        // 加载闹钟设置
        List<Alarm> alarms = loadAlarms();

        // 设置闹钟
        setAlarms(alarms);

        // 启动JavaFX应用程序
        primaryStage.show();
    }

    @Override
    public void stop() throws Exception {
        // 关闭数据源
        if (dataSource != null) {
            dataSource.getConnection().close();
        }

        // 停止播放器
        if (mediaPlayer != null) {
            mediaPlayer.stop();
        }
    }

    private void initDataSource() throws SQLException {
        SQLiteConfig config = new SQLiteConfig();
        config.setJournalMode(SQLiteConfig.JournalMode.WAL);
        config.setSynchronous(SQLiteConfig.SynchronousMode.NORMAL);

        SQLiteDataSource sqliteDataSource = new SQLiteDataSource(config);
        sqliteDataSource.setUrl(DB_URL);

        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDataSource(sqliteDataSource);
        hikariConfig.setMaximumPoolSize(10);

        dataSource = new HikariDataSource(hikariConfig);

        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement()) {
            // 创建alarm表
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS alarm(" +
                    "id INTEGER PRIMARY KEY AUTOINCREMENT," +
                    "time TEXT NOT NULL," +
                    "songId INTEGER NOT NULL)");

            // 创建song表
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS song(" +
                    "id INTEGER PRIMARY KEY AUTOINCREMENT," +
                    "name TEXT NOT NULL," +
                    "path TEXT NOT NULL)");
        }
    }

    private void loadSongs() throws SQLException {
        songs = new ArrayList<>();

        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM song")) {
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String path = rs.getString("path");

                Song song = new Song(id, name, path);
                songs.add(song);
            }
        }
    }

    private List<Alarm> loadAlarms() throws SQLException {
        List<Alarm> alarms = new ArrayList<>();

        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM alarm")) {
            while (rs.next()) {
                int id = rs.getInt("id");
                String time = rs.getString("time");
                int songId = rs.getInt("songId");

                Alarm alarm = new Alarm(id, time, songId);
                alarms.add(alarm);
            }
        }

        return alarms;
    }

    private void setAlarms(List<Alarm> alarms) {
        for (Alarm alarm : alarms) {
            LocalDateTime alarmTime = LocalDateTime.parse(alarm.getTime());
            AlarmTask task = new AlarmTask(alarmTime, alarm.getSongId());
            new Thread(task).start();
        }
    }

    private class AlarmTask implements Runnable {
        private LocalDateTime alarmTime;
        private int songId;

        public AlarmTask(LocalDateTime alarmTime, int songId) {
            this.alarmTime = alarmTime;
            this.songId = songId;
        }

        @Override
        public void run() {
            while (true) {
                LocalDateTime now = LocalDateTime.now();
                if (now.isEqual(alarmTime)) {
                    playSong(songId);
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void playSong(int songId) {
            Song song = findSongById(songId);
            if (song != null) {
                Media media = new Media(Paths.get(song.getPath()).toUri().toString());
                mediaPlayer = new MediaPlayer(media);
                mediaPlayer.play();
            }
        }

        private Song findSongById(int songId) {
            for (Song song : songs) {
                if (song.getId() == songId) {
                    return song;
                }
            }
            return null;
        }
    }

    public static void main(String[] args) {
        launch(args);
    }
}

该程序使用HikariCP连接池来管理数据库连接，使用SQLiteDataSource访问SQLite数据库。在initDataSource方法中，创建了alarm和song两个表。在loadSongs方法中，从song表中加载曲库。在loadAlarms方法中，从alarm表中加载闹钟设置。在setAlarms方法中，为每个闹钟设置创建一个AlarmTask，并在指定时间播放音乐。在AlarmTask中，使用JavaFXMediaPlayer播放音乐。

在启动JavaFX应用程序时，程序会加载曲库和闹钟设置，并为每个闹钟设置创建一个AlarmTask。当闹钟时间到达时，AlarmTask会播放指定的音乐。

请注意，该程序只是一个简单的示例程序，仅用于演示Java中如何实现带有数据库和曲库的闹钟功能。在实际应用中，可能需要考虑更多的因素，如安全性、性能等，以实现更稳定、更可靠的闹钟功能。