Javafx 重新启动、暂停和恢复剪辑将挂起音乐播放器的gui，同时按暂停和播放可从停止点恢复播放

此程序是一个音乐播放器，允许用户从剪辑对象和音频输入流中选择.wav文件、播放、暂停、恢复和重新启动音乐文件。音频输入流加载由用户通过FileChooser确定的文件。通过选择文件，按play（播放）、pause（暂停），然后再次播放，程序可以播放、暂停和恢复，但不能使用重新启动方法或通过相应按钮调用的resume（恢复）方法播放。相反，程序将挂起，直到单击X按钮。我认为这与resetaudiostream方法有关，但我不确定是什么。可能与结束旧剪辑并创建新剪辑实例有关。请检查逻辑，让我知道是什么导致它挂起，以及如何补救

包装样品

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.VBox;
import javafx.stage.FileChooser;
import javafx.stage.Stage;

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;


public class Main extends Application {
    static File musicfile;
    static Long currentFrame;
    static Clip clip;
    static String status = "play";
    static AudioInputStream audioInputStream;
    static String filePath;
    public void SimpleAudioPlayer()
            throws UnsupportedAudioFileException,
            IOException, LineUnavailableException
    {
        // create AudioInputStream object
        audioInputStream =
                AudioSystem.getAudioInputStream(new File(filePath).getAbsoluteFile());

        // create clip reference
        clip = AudioSystem.getClip();

        // open audioInputStream to the clip
        clip.open(audioInputStream);

        clip.loop(Clip.LOOP_CONTINUOUSLY);
    }
    @Override
    public void start(Stage primaryStage) throws Exception{
        Parent root = FXMLLoader.load(getClass().getResource("sample.fxml"));
        primaryStage.setTitle("Music Player");
        GridPane gp = new GridPane();

        Button selectFile = new Button("Select File");
        GridPane.setConstraints(selectFile, 0,0);
        selectFile.setOnAction(event->{
            FileChooser filechooser = new FileChooser();
            // create AudioInputStream object
            try {
                musicfile = filechooser.showOpenDialog(null);
                audioInputStream = AudioSystem.getAudioInputStream(musicfile);

                clip = AudioSystem.getClip();

                // open audioInputStream to the clip
                clip.open(audioInputStream);

            }catch(IOException | UnsupportedAudioFileException | LineUnavailableException e){
                e.printStackTrace();
            }
        });
        Button play = new Button("Play");
        GridPane.setConstraints(play, 1,0);
        play.setOnAction(event->{
            if(status == "play") {


                    clip.loop(Clip.LOOP_CONTINUOUSLY);

            }
            play();

        });
        Button pause = new Button("Pause");
        GridPane.setConstraints(pause, 2,0);
        pause.setOnAction(event -> pause());

        Button restart = new Button("Restart");
        GridPane.setConstraints(restart, 0,1);
        restart.setOnAction(event -> {
            try{
            restart();
        }
        catch(IOException | UnsupportedAudioFileException | LineUnavailableException e){
        e.printStackTrace();}
        });
        Button resume = new Button("Resume");
        GridPane.setConstraints(resume, 1,1);
        resume.setOnAction(event -> {
            try {
                resumeAudio();
            }catch(IOException | LineUnavailableException | UnsupportedAudioFileException e){
                e.printStackTrace();
        }
        });
        gp.getChildren().addAll(play,selectFile, pause, restart, resume);
        primaryStage.setScene(new Scene(gp, 300, 275));
        primaryStage.show();
    }

    public void play()
    {
        //start the clip
        clip.start();

        status = "play";
    }

    // Method to pause the audio
    public  void pause()
    {
        if (status.equals("paused"))
        {
            System.out.println("audio is already paused");
            return;
        }
        currentFrame =
                clip.getMicrosecondPosition();
        clip.stop();
        status = "paused";
    }

    // Method to resume the audio
    public void resumeAudio() throws UnsupportedAudioFileException,
            IOException, LineUnavailableException
    {
        if (status.equals("play"))
        {
            System.out.println("Audio is already "+
                    "being played");
            return;
        }
        clip.close();
        resetAudioStream();
        clip.setMicrosecondPosition(currentFrame);
        status = "play";
        play();
    }

    // Method to restart the audio
    public void restart() throws IOException, LineUnavailableException,
            UnsupportedAudioFileException
    {
        clip.stop();
        clip.close();
        resetAudioStream();
        currentFrame = 0L;
        clip.setMicrosecondPosition(0);
        status = "play";
        play();
    }

    // Method to stop the audio
    public void stop() throws UnsupportedAudioFileException,
            IOException, LineUnavailableException
    {
        currentFrame = 0L;
        clip.stop();
        clip.close();
    }

    // Method to jump over a specific part
    public void jump(long c) throws UnsupportedAudioFileException, IOException,
            LineUnavailableException
    {
        if (c > 0 && c < clip.getMicrosecondLength())
        {
            clip.stop();
            clip.close();
            resetAudioStream();
            currentFrame = c;
            clip.setMicrosecondPosition(c);
            this.play();
        }
    }

    // Method to reset audio stream
    public void resetAudioStream() throws UnsupportedAudioFileException, IOException,
            LineUnavailableException
    {
        audioInputStream = AudioSystem.getAudioInputStream(musicfile);
        clip = AudioSystem.getClip();
        clip.open(audioInputStream);
        clip.loop(Clip.LOOP_CONTINUOUSLY);
    }
    public static void main(String[] args) {
        launch(args);
    }
}

导入javafx.application.application；
导入javafx.fxml.fxmloader；
导入javafx.scene.Parent；
导入javafx.scene.scene；
导入javafx.scene.control.Button；
导入javafx.scene.layout.GridPane；
导入javafx.scene.layout.VBox；
导入javafx.stage.FileChooser；
导入javafx.stage.stage；
导入javax.sound.sampled.*；
导入java.io.File；
导入java.io.IOException；
公共类主扩展应用程序{
静态文件音乐文件；
静态长帧；
静电夹；
静态字符串状态=“播放”；
静态音频输入流音频输入流；
静态字符串文件路径；
public void simpleudioplayer（）
抛出不支持的DaudioFileException，
IOException，LineUnavailableException
{
//创建AudioInputStream对象
音频输入流=
getAudioInputStream（新文件（filePath）.getAbsoluteFile（））；
//创建剪辑引用
clip=AudioSystem.getClip（）；
//打开音频输入流到剪辑
clip.open（音频输入流）；
卡环（连续卡环）；
}
@凌驾
public void start（Stage primaryStage）引发异常{
父根=FXMLLoader.load（getClass（）.getResource（“sample.fxml”）；
primaryStage.setTitle（“音乐播放器”）；
GridPane gp=新的GridPane（）；
按钮选择文件=新建按钮（“选择文件”）；
setConstraints（selectFile，0,0）；
选择file.setOnAction（事件->{
FileChooser FileChooser=newfilechooser（）；
//创建AudioInputStream对象
试一试{
musicfile=filechooser.showOpenDialog（null）；
audioInputStream=AudioSystem.getAudioInputStream（音乐文件）；
clip=AudioSystem.getClip（）；
//打开音频输入流到剪辑
clip.open（音频输入流）；
}捕获（IOException | UnsupportedAudioFileException | LineUnavailableException e）{
e、 printStackTrace（）；
}
});
按钮播放=新按钮（“播放”）；
设置约束（play，1,0）；
播放设置动作（事件->{
如果（状态=“播放”）{
卡环（连续卡环）；
}
play（）；
});
按钮暂停=新按钮（“暂停”）；
设置约束（暂停，2,0）；
pause.setOnAction（事件->暂停（））；
按钮重启=新按钮（“重启”）；
setConstraints（重新启动，0,1）；
restart.setOnAction（事件->{
试一试{
重启（）；
}
捕获（IOException | UnsupportedAudioFileException | LineUnavailableException e）{
e、 printStackTrace（）；}
});
按钮恢复=新按钮（“恢复”）；
设置约束（resume，1,1）；
resume.setOnAction（事件->{
试一试{
恢复音频（）；
}捕获（IOException | LineUnavailableException | UnsupportedAudioFileException e）{
e、 printStackTrace（）；
}
});
gp.getChildren（）.addAll（播放、选择文件、暂停、重新启动、恢复）；
初级阶段。背景场景（新场景（gp，300275））；
primaryStage.show（）；
}
公共游戏
{
//开始剪辑
clip.start（）；
status=“play”；
}
//方法暂停音频
公共空间暂停（）
{
if（status.equals（“暂停”））
{
System.out.println（“音频已暂停”）；
返回；
}
当前帧=
clip.getMicrosecondPosition（）；
clip.stop（）；
status=“暂停”；
}
//方法恢复音频
public void resumeAudio（）引发UnsupportedAudioFileException，
IOException，LineUnavailableException
{
如果（状态相等（“播放”））
{
System.out.println（“音频已存在”+
“正在播放”）；
返回；
}
clip.close（）；
重置音频流（）；
clip.setMicrosecondPosition（当前帧）；
status=“play”；
play（）；
}
//方法重新启动音频
public void restart（）引发IOException、LineUnavailableException、，
不支持DaudioFileException
{
clip.stop（）；
clip.close（）；
重置音频流（）；
currentFrame=0L；
clip.setMicrosecondPosition（0）；
status=“play”；
play（）；
}
//方法停止音频
public void stop（）引发不支持的DaudioFileException，
IOException，LineUnavailableException
{
currentFrame=0L；
clip.stop（）；
clip.close（）；
}
//方法跳过特定零件
public void jump（长c）抛出不支持的DaudioFileException、IOException、，
LineUnavailableException
{
如果（c>0&&cimport java.net.URI;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.GridPane;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaPlayer.Status;
import javafx.stage.Stage;
import javafx.util.Duration;

public class Main extends Application {

    private MediaPlayer player;
    private static final long JUMP_BY = 5000;//millis 

    @Override
    public void start(Stage primaryStage) throws Exception{

        URI uri = new URI("http://traffic.libsyn.com/dickwall/JavaPosse373.mp3");
        Media media = new Media(uri.toString());
        //OR Media media = new Media("http://traffic.libsyn.com/dickwall/JavaPosse373.mp3");
        player = new MediaPlayer(media);
        player.setOnError(() -> System.out.println(media.getError().toString()));

        GridPane gp = new GridPane();
        gp.setHgap(10);

        Button play = new Button("Play");
        GridPane.setConstraints(play, 0,0);
        play.setOnAction(event->  playAudio());

        Button pause = new Button("Pause");
        GridPane.setConstraints(pause, 1,0);
        pause.setOnAction(event -> pauseAudio());

        Button resume = new Button("Resume");
        GridPane.setConstraints(resume, 2,0);
        resume.setOnAction(event -> resumeAudio());

        Button stop = new Button("Stop");
        GridPane.setConstraints(stop, 3,0);
        stop.setOnAction(event ->  stopAudio());

        Button restart = new Button("Restart");
        GridPane.setConstraints(restart, 4,0);
        restart.setOnAction(event ->  restartAudio());

        Button jump = new Button("Jump >");
        GridPane.setConstraints(jump, 5,0);
        jump.setOnAction(event ->  jump(JUMP_BY));

        Label time = new Label();
        GridPane.setConstraints(time, 6,0);
        time.textProperty().bind( player.currentTimeProperty().asString("%.4s") );

        gp.getChildren().addAll(play, pause, resume, stop, restart, jump, time);
        primaryStage.setScene(new Scene(gp, 400, 45));
        primaryStage.show();
    }

    //play audio 
    public void playAudio()
    {
        player.play();
    }

    //pause audio
    public  void pauseAudio()
    {
        if (player.getStatus().equals(Status.PAUSED))
        {
            System.out.println("audio is already paused");
            return;
        }
        player.pause();
    }

    //resume audio
    public void resumeAudio()
    {
        if (player.getStatus().equals(Status.PLAYING))
        {
            System.out.println("Audio is already playing");
            return;
        }
        playAudio();
    }

    //restart audio
    public void restartAudio()
    {
        player.seek(Duration.ZERO);
        playAudio();
    }

    // stop audio
    public void stopAudio()
    {
       player.stop();
    }

    //jump by c millis 
    public void jump(long c)
    {
        player.seek(player.getCurrentTime().add(Duration.millis(c)));
    }

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