devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java程序添加背景音乐_java添加背景音乐

作者：Guff_9hys | 2024-06-26 14:40:13

赞

踩

java添加背景音乐

在写Java程序的时候常常需要播放背景音乐，其实实现只需两步即可。

1.首先需要下载一个jar包

最近有许多网友反应说原来的下载地址不能用了，这里提供一个最新下载地址：jlayer-1.0.1.jar，下载完成直接导入jar即可，亲测可用。

网址：http://www.javazoom.net/javalayer/javalayer.html

下载完成，解压后找到如图所示的包导入到项目中去。

2.然后， 只需将下面的几行代码粘入程序中即可，即粘即用，如果出现错误多半是jar包没有正确导入。

  1. import java.io.BufferedInputStream;
  2. import java.io.File; 
  3. import java.io.FileInputStream; 
  4. import java.io.FileNotFoundException; 
  5. import javazoom.jl.decoder.JavaLayerException; 
  6. import javazoom.jl.player.*; 
  7.  
  8. class Play0 extends Thread{
  9.     Player player;
  10.     String music;
  11.     public Play0(String file) {
  12.         this.music = file;
  13.     }
  14.      public void run() {
  15.         try {
  16.             play();     
  17.         } catch (FileNotFoundException | JavaLayerException e) {
  18.              e.printStackTrace();
  19.         }
  20.     }
  21.     public void play() throws FileNotFoundException, JavaLayerException { 
  22.         BufferedInputStream buffer = new BufferedInputStream(new FileInputStream(music)); 
  23.         player = new Player(buffer); 
  24.         player.play(); 
  25.     } 
  26. }

上面的代码实则是将播放程序放入线程中去，然后再在需要播放音乐的地方写入如下代码，开启线程。

new Play0("C:\\Users\\ds_surk\\Desktop\\My soul.mp3").start();

如需结束播放则需要这样写。

  1. Play0 play0 = new Play0("C:\\Users\\ds_surk\\Desktop\\My soul.mp3");
  2.         play0.start();  //开启
  3.         play0.stop();   //结束

如果看不懂，直接粘即可，只需将 "C:\\Users\\ds_surk\\Desktop\\My soul.mp3" 替换成自己想要播放的音乐即可，格式为MP3。

后记：

由于原有代码过期，现根据已有的问题，特作统一回复。

1.Java多线程的stop方法过期，如何停止播放？

直接放代码吧，简单粗暴。

  1. public class Music {
  2.  
  3.     public static void main(String[] args) {
  4.         String file = "C:\\Users\\surk\\Desktop\\1.mp3";
  5.  
  6.         Play play = new Play(file);
  7.         Player player = play.getPlayer();
  8.         // 开启
  9.         play.start();
  10.         try {
  11.             Thread.sleep(2000);
  12.             // 输出当前播放的位置(时间)
  13.             System.out.println(player.getPosition());
  14.             Thread.sleep(4000);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         // 输出是否播放完毕
  19.         System.out.println(player.isComplete());
  20.         //结束
  21.         play.stop();
  22.     }
  23.  
  24. }
  25.  
  26. class Play implements Runnable {
  27.  
  28.     private Player player = null;
  29.     private Thread thread = null;
  30.  
  31.     public Play(String file) {
  32.         try {
  33.             player = new Player(new FileInputStream(file));
  34.         } catch (JavaLayerException | FileNotFoundException e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38.  
  39.     public void run() {
  40.         try {
  41.             player.play();
  42.         } catch (JavaLayerException ex) {
  43.             System.err.println("Problem playing audio: " + ex);
  44.         }
  45.     }
  46.  
  47.     public void start() {
  48.         thread = new Thread(this, "Player thread");
  49.         thread.start();
  50.     }
  51.  
  52.     public void stop() {
  53.         player.close();
  54.         thread = null;
  55.     }
  56.  
  57.     public Player getPlayer() {
  58.         return player;
  59.     }
  60.  
  61. }

2.如何暂停？

首先现有的Player类是没有提供暂停方法的，所以想要暂停播放，需要一些技巧。

Player只提供了播放和停止方法，然后还有一个AdvancedPlayer类，它提供的方法会多些，

于是根据AdvancedPlayer类有如下代码，来实现暂停播放。

  1. public class Music {
  2.  
  3.     public static void main(String[] args) {
  4.         String file = "C:\\Users\\surk\\Desktop\\1.mp3";
  5.  
  6.         Play play = new Play(file);
  7.         // 开启
  8.         play.start();
  9.         try {
  10.             Thread.sleep(5000);
  11.             // 暂停
  12.             play.stop();
  13.             Thread.sleep(2000);
  14.             // 重新播放
  15.             play.start();
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         //结束
  20.         play.stop();
  21.         System.out.println("stop!");
  22.     }
  23.  
  24. }
  25.  
  26. class Play implements Runnable {
  27.  
  28.     private final String file;
  29.     private AdvancedPlayer player = null;
  30.     private Thread thread = null;
  31.     public int pauseFrame = 0;
  32.  
  33.     public Play(String file) {
  34.         this.file = file;
  35.     }
  36.  
  37.     public void run() {
  38.         // 每次开始需要重新创建AdvancedPlayer，否则会报错
  39.         createPlayer();
  40.         play();
  41.     }
  42.  
  43.     public void start() {
  44.         thread = new Thread(this, "Player thread");
  45.         thread.start();
  46.     }
  47.  
  48.     public void stop() {
  49.         player.stop();
  50.         thread = null;
  51.     }
  52.  
  53.     protected void play() {
  54.         try {
  55.             player.play(pauseFrame, Integer.MAX_VALUE);
  56.         } catch (JavaLayerException ex) {
  57.             System.err.println("Problem playing audio: " + ex);
  58.         }
  59.     }
  60.  
  61.     protected void createPlayer() {
  62.         try {
  63.             player = new AdvancedPlayer(new FileInputStream(file));
  64.             // 这里设置一个监听器，来监听停止事件，记录停止帧
  65.             player.setPlayBackListener(new PlaybackListener() {
  66.                 @Override
  67.                 public void playbackFinished(PlaybackEvent event) {
  68.                     pauseFrame = event.getFrame();
  69.                 }
  70.             });
  71.         } catch (JavaLayerException | IOException e) {
  72.             e.printStackTrace();
  73.         }
  74.     }
  75. }

大致思路是通过监听停止事件来记录停止时的帧，然后从停止帧继续播放。这样重新播放时就可以从上次暂停的地方继续。但是，这里有坑！！！我发现，无论是event.getFrame()还是Player类的player.getPosition()方法均不能正确的获取帧！

所以你会发现，当重新播放时，它播放的点并不是上次暂停的地方！！

不过，总归思路是行的通的！只要正确的找到帧，就可以成功实现暂停，在播放的需求。

来看AdvancedPlayer类源码，其中有一个decodeFrame()方法用来解析帧，不难发现，它每次只解析一帧，所以，可以继承AdvancedPlayer类，重写该方法，就可以达到记录帧的目的了！

直接放代码。

  1. public class Music {
  2.  
  3.     public static void main(String[] args) {
  4.         String file = "C:\\Users\\surk\\Desktop\\1.mp3";
  5.  
  6.         Play play = new Play(file);
  7.         // 开启
  8.         play.start();
  9.         try {
  10.             Thread.sleep(14000);
  11.             // 暂停
  12.             play.stop();
  13.             Thread.sleep(1000);
  14.             // 重新播放
  15.             play.start();
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         //结束
  20.         play.stop();
  21.         System.out.println("stop!");
  22.     }
  23.  
  24. }
  25.  
  26. class Play implements Runnable {
  27.  
  28.     private final String file;
  29.     private MyPlayer player = null;
  30.     private Thread thread = null;
  31.     public int pauseFrame = 0;
  32.  
  33.     public Play(String file) {
  34.         this.file = file;
  35.     }
  36.  
  37.     public void run() {
  38.         // 每次开始需要重新创建AdvancedPlayer，否则会报错
  39.         createPlayer();
  40.         play();
  41.     }
  42.  
  43.     public void start() {
  44.         thread = new Thread(this, "Player thread");
  45.         thread.start();
  46.     }
  47.  
  48.     public void stop() {
  49.         // 在停止的时候,记录停止帧
  50.         pauseFrame = player.getFrame();
  51.         player.close();
  52.         thread = null;
  53.     }
  54.  
  55.     protected void play() {
  56.         try {
  57.             player.play(pauseFrame, Integer.MAX_VALUE);
  58.         } catch (JavaLayerException ex) {
  59.             System.err.println("Problem playing audio: " + ex);
  60.         }
  61.     }
  62.  
  63.     protected void createPlayer() {
  64.         try {
  65.             player = new MyPlayer(new FileInputStream(file));
  66.         } catch (FileNotFoundException | JavaLayerException e) {
  67.             e.printStackTrace();
  68.         }
  69.     }
  70. }
  71.  
  72. class MyPlayer extends AdvancedPlayer {
  73.  
  74.     /**
  75.      * 当前帧
  76.      */
  77.     @Getter
  78.     private int frame = 0;
  79.  
  80.     public MyPlayer(InputStream stream) throws JavaLayerException {
  81.         super(stream);
  82.     }
  83.  
  84.     /**
  85.      * 重写decodeFrame方法,每次解析,记录帧+1
  86.      */
  87.     protected boolean decodeFrame() throws JavaLayerException {
  88.         frame++;
  89.         return super.decodeFrame();
  90.     }
  91.  
  92. }

这里选择在停止时获取帧，没有使用监听器来获取帧，因为它记录的帧是不对的！

在测试时，发现重新播放时可能会丢失一两帧，不过影响不大，可以在停止时少记录两帧(pauseFrame = player.getFrame()-2;)就可以了。

3.如何循环播放？

同样的，无论是AdvancedPlayer类还是Player类，都没有提供循环播放的方法，所以，这个也需要自己去实现。

这个实现比较简单，直接放代码。

  1. public class Music {
  2.  
  3.     public static void main(String[] args) {
  4.         String file = "C:\\Users\\surk\\Desktop\\2.mp3";
  5.  
  6.         Play play = new Play(file);
  7.         // 开启
  8.         play.start();
  9.         try {
  10.             Thread.sleep(5000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.         System.out.println("stop!");
  15.     }
  16.  
  17. }
  18.  
  19. class Play implements Runnable {
  20.  
  21.     private final String file;
  22.     private AdvancedPlayer player = null;
  23.     private Thread thread = null;
  24.  
  25.     public Play(String file) {
  26.         this.file = file;
  27.     }
  28.  
  29.     public void run() {
  30.         // 每次开始需要重新创建AdvancedPlayer，否则会报错
  31.         createPlayer();
  32.         play();
  33.     }
  34.  
  35.     public void start() {
  36.         thread = new Thread(this, "Player thread");
  37.         thread.start();
  38.     }
  39.  
  40.     public void stop() {
  41.         player.stop();
  42.         thread = null;
  43.     }
  44.  
  45.     protected void play() {
  46.         try {
  47.             player.play();
  48.         } catch (JavaLayerException ex) {
  49.             System.err.println("Problem playing audio: " + ex);
  50.         }
  51.     }
  52.  
  53.     protected void createPlayer() {
  54.         try {
  55.             player = new AdvancedPlayer(new FileInputStream(file));
  56.             // 这里设置一个监听器，来监听停止事件
  57.             player.setPlayBackListener(new PlaybackListener() {
  58.                 @Override
  59.                 public void playbackFinished(PlaybackEvent event) {
  60.                     // 当播放完毕后,会触发该事件,再次调用start()即可!
  61.                     start();
  62.                 }
  63.             });
  64.         } catch (JavaLayerException | IOException e) {
  65.             e.printStackTrace();
  66.         }
  67.     }
  68. }

可以通过监听停止事件，重新调用start()。就可以循环播放啦！

4.如何暂停播放+循环播放？

这个问题嘛，结合已有代码，自己实现吧！

提示一下。

1.你需要注意暂停帧(pauseFrame)的重置。

2.AdvancedPlayer类有两个停止方法，close()和stop()，其中stop会触发停止事件，close则不会触发停止事件。这样就可以通过close方法来实现暂停，通过stop方法来实现停止播放。

总体来说，jLayer这个jar包，年代过于久远，功能很有限，只能说凑合能用，它的源码读起来不是很困难，读读源码大概就知道怎么回事了，所以想要实现更多的功能，一是自己写:)，二是寻找其他jar包。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/759654
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号