热门标签 | HotTags
当前位置:  开发笔记 > 前端 > 正文

Android实现使用流媒体播放远程mp3文件的方法

这篇文章主要介绍了Android实现使用流媒体播放远程mp3文件的方法,结合实例形式分析了Android远程播放音频文件的相关步骤与实现技巧,需要的朋友可以参考下

本文实例讲述了Android实现使用流媒体播放远程mp3文件的方法。分享给大家供大家参考,具体如下:

package com.shadow.util;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import com.shadow.service.AudioPlayService.LocalBinder;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
/**
 * MediaPlayer does not yet support streaming from external URLs so this class provides a pseudo-streaming function
 * by downloading the content incrementally & playing as soon as we get enough audio in our temporary storage.
 */
public class StreamingMediaPlayer extends Service{
  private static final int INTIAL_KB_BUFFER = 96*10/8;//assume 96kbps*10secs/8bits per byte
  private TextView textStreamed;
  private ImageButton playButton;
  private ProgressBar  progressBar;
  // Track for display by progressBar
  private long mediaLengthInKb, mediaLengthInSeconds;
  private int totalKbRead = 0;
  // Create Handler to call View updates on the main UI thread.
  private final Handler handler = new Handler();
  private MediaPlayer   mediaPlayer;
  private File downloadingMediaFile;
  private boolean isInterrupted;
  private Context context;
  private int counter = 0;
  private static Runnable r;
  private static Thread playerThread;
  private LocalBinder localBinder = new LocalBinder();
  private MediaPlayer player;
  private boolean isPause = false;   //播放器是否处于暂停状态
  private boolean isSame = false;   //所点播歌曲是否是当前播放歌曲
  private Integer position = -1;    //设置播放标记
  private List music_name;   //歌曲列表
  private List music_path;
   public StreamingMediaPlayer(Context context,TextView textStreamed, ImageButton  playButton, Button  streamButton,ProgressBar  progressBar)
   {
     this.cOntext= context;
    this.textStreamed = textStreamed;
    this.playButton = playButton;
    this.progressBar = progressBar;
  }
  /**
   * Progressivly download the media to a temporary location and update the MediaPlayer as new content becomes available.
   */
  public void startStreaming(final String mediaUrl, long  mediaLengthInKb, long  mediaLengthInSeconds) throws IOException {
    this.mediaLengthInKb = mediaLengthInKb;
    this.mediaLengthInSecOnds= mediaLengthInSeconds;
    r = new Runnable() {
      public void run() {
        try {
          Log.i("downloadAudioIncrement", "downloadAudioIncrement");
          downloadAudioIncrement(mediaUrl);
        } catch (IOException e) {
          Log.e(getClass().getName(), "Unable to initialize the MediaPlayer for fileUrl=" + mediaUrl, e);
          return;
        }
      }
    };
    playerThread = new Thread(r);
    playerThread.start();
    //new Thread(r).start();
  }
  /**
   * Download the url stream to a temporary location and then call the setDataSource
   * for that local file
   */
  public void downloadAudioIncrement(String mediaUrl) throws IOException {
    URLConnection cn = new URL(mediaUrl).openConnection();
    cn.addRequestProperty("User-Agent","NSPlayer/10.0.0.4072 WMFSDK/10.0");
    cn.connect();
    InputStream stream = cn.getInputStream();
    if (stream == null) {
      Log.e(getClass().getName(), "Unable to create InputStream for mediaUrl:" + mediaUrl);
    }
    downloadingMediaFile = new File(context.getCacheDir(),"downloadingMedia.dat");
    // Just in case a prior deletion failed because our code crashed or something, we also delete any previously
    // downloaded file to ensure we start fresh. If you use this code, always delete
    // no longer used downloads else you'll quickly fill up your hard disk memory. Of course, you can also
    // store any previously downloaded file in a separate data cache for instant replay if you wanted as well.
    if (downloadingMediaFile.exists()) {
      downloadingMediaFile.delete();
    }
    FileOutputStream out = new FileOutputStream(downloadingMediaFile);
    byte buf[] = new byte[16384];
    int totalBytesRead = 0, incrementalBytesRead = 0;
    do {
      int numread = stream.read(buf);
      if (numread <= 0)
        break;
      out.write(buf, 0, numread);
      totalBytesRead += numread;
      incrementalBytesRead += numread;
      totalKbRead = totalBytesRead/1000;
      testMediaBuffer();
        fireDataLoadUpdate();
    } while (validateNotInterrupted());
        stream.close();
    if (validateNotInterrupted()) {
        fireDataFullyLoaded();
    }
  }
  private boolean validateNotInterrupted() {
    if (isInterrupted) {
      if (mediaPlayer != null) {
        mediaPlayer.pause();
        //mediaPlayer.release();
      }
      return false;
    } else {
      return true;
    }
  }
  /**
   * Test whether we need to transfer buffered data to the MediaPlayer.
   * Interacting with MediaPlayer on non-main UI thread can causes crashes to so perform this using a Handler.
   */
  private void testMediaBuffer() {
    Runnable updater = new Runnable() {
      public void run() {
        if (mediaPlayer == null) {
          // Only create the MediaPlayer once we have the minimum buffered data
          if ( totalKbRead >= INTIAL_KB_BUFFER) {
            try {
              startMediaPlayer();
            } catch (Exception e) {
              Log.e(getClass().getName(), "Error copying buffered conent.", e);
            }
          }
        } else if ( mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000 ){
          // NOTE: The media player has stopped at the end so transfer any existing buffered data
          // We test for <1second of data because the media player can stop when there is still
          // a few milliseconds of data left to play
          transferBufferToMediaPlayer();
        }
      }
    };
    handler.post(updater);
  }
  private void startMediaPlayer() {
    try {
      File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");
      // We double buffer the data to avoid potential read/write errors that could happen if the
      // download thread attempted to write at the same time the MediaPlayer was trying to read.
      // For example, we can't guarantee that the MediaPlayer won't open a file for playing and leave it locked while
      // the media is playing. This would permanently deadlock the file download. To avoid such a deadloack,
      // we move the currently loaded data to a temporary buffer file that we start playing while the remaining
      // data downloads.
      moveFile(downloadingMediaFile,bufferedFile);
      Log.e(getClass().getName(),"Buffered File path: " + bufferedFile.getAbsolutePath());
      Log.e(getClass().getName(),"Buffered File length: " + bufferedFile.length()+"");
      mediaPlayer = createMediaPlayer(bufferedFile);
      // We have pre-loaded enough content and started the MediaPlayer so update the buttons & progress meters.
      mediaPlayer.start();
      startPlayProgressUpdater();
      playButton.setEnabled(true);
    } catch (IOException e) {
      Log.e(getClass().getName(), "Error initializing the MediaPlayer.", e);
      return;
    }
  }
  public void pausePlayer(){
    try {
      getMediaPlayer().pause();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public void startPlayer(){
    getMediaPlayer().start();
  }
  public void stopPlayer(){
    getMediaPlayer().stop();
  }
  /**
   * 根据文件创建一个mediaplayer对象
   */
  private MediaPlayer createMediaPlayer(File mediaFile)
  throws IOException {
    MediaPlayer mPlayer = new MediaPlayer();
    mPlayer.setOnErrorListener(
        new MediaPlayer.OnErrorListener() {
          public boolean onError(MediaPlayer mp, int what, int extra) {
            Log.e(getClass().getName(), "Error in MediaPlayer: (" + what +") with extra (" +extra +")" );
            return false;
          }
        });
    // It appears that for security/permission reasons, it is better to pass a FileDescriptor rather than a direct path to the File.
    // Also I have seen errors such as "PVMFErrNotSupported" and "Prepare failed.: status=0x1" if a file path String is passed to
    // setDataSource(). So unless otherwise noted, we use a FileDescriptor here.
    FileInputStream fis = new FileInputStream(mediaFile);
    mPlayer.setDataSource(fis.getFD());
    mPlayer.prepare();
    return mPlayer;
}

package com.shadow.util;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import com.shadow.service.AudioPlayService.LocalBinder;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
/**
 * MediaPlayer does not yet support streaming from external URLs so this class provides a pseudo-streaming function
 * by downloading the content incrementally & playing as soon as we get enough audio in our temporary storage.
 */
public class StreamingMediaPlayer extends Service{
  private static final int INTIAL_KB_BUFFER = 96*10/8;//assume 96kbps*10secs/8bits per byte
  private TextView textStreamed;
  private ImageButton playButton;
  private ProgressBar  progressBar;
  // Track for display by progressBar
  private long mediaLengthInKb, mediaLengthInSeconds;
  private int totalKbRead = 0;
  // Create Handler to call View updates on the main UI thread.
  private final Handler handler = new Handler();
  private MediaPlayer   mediaPlayer;
  private File downloadingMediaFile;
  private boolean isInterrupted;
  private Context context;
  private int counter = 0;
  private static Runnable r;
  private static Thread playerThread;
  private LocalBinder localBinder = new LocalBinder();
  private MediaPlayer player;
  private boolean isPause = false;   //播放器是否处于暂停状态
  private boolean isSame = false;   //所点播歌曲是否是当前播放歌曲
  private Integer position = -1;    //设置播放标记
  private List music_name;   //歌曲列表
  private List music_path;
   public StreamingMediaPlayer(Context context,TextView textStreamed, ImageButton  playButton, Button  streamButton,ProgressBar  progressBar)
   {
     this.cOntext= context;
    this.textStreamed = textStreamed;
    this.playButton = playButton;
    this.progressBar = progressBar;
  }
  /**
   * Progressivly download the media to a temporary location and update the MediaPlayer as new content becomes available.
   */
  public void startStreaming(final String mediaUrl, long  mediaLengthInKb, long  mediaLengthInSeconds) throws IOException {
    this.mediaLengthInKb = mediaLengthInKb;
    this.mediaLengthInSecOnds= mediaLengthInSeconds;
    r = new Runnable() {
      public void run() {
        try {
          Log.i("downloadAudioIncrement", "downloadAudioIncrement");
          downloadAudioIncrement(mediaUrl);
        } catch (IOException e) {
          Log.e(getClass().getName(), "Unable to initialize the MediaPlayer for fileUrl=" + mediaUrl, e);
          return;
        }
      }
    };
    playerThread = new Thread(r);
    playerThread.start();
    //new Thread(r).start();
  }
  /**
   * Download the url stream to a temporary location and then call the setDataSource
   * for that local file
   */
  public void downloadAudioIncrement(String mediaUrl) throws IOException {
    URLConnection cn = new URL(mediaUrl).openConnection();
    cn.addRequestProperty("User-Agent","NSPlayer/10.0.0.4072 WMFSDK/10.0");
    cn.connect();
    InputStream stream = cn.getInputStream();
    if (stream == null) {
      Log.e(getClass().getName(), "Unable to create InputStream for mediaUrl:" + mediaUrl);
    }
    downloadingMediaFile = new File(context.getCacheDir(),"downloadingMedia.dat");
    // Just in case a prior deletion failed because our code crashed or something, we also delete any previously
    // downloaded file to ensure we start fresh. If you use this code, always delete
    // no longer used downloads else you'll quickly fill up your hard disk memory. Of course, you can also
    // store any previously downloaded file in a separate data cache for instant replay if you wanted as well.
    if (downloadingMediaFile.exists()) {
      downloadingMediaFile.delete();
    }
    FileOutputStream out = new FileOutputStream(downloadingMediaFile);
    byte buf[] = new byte[16384];
    int totalBytesRead = 0, incrementalBytesRead = 0;
    do {
      int numread = stream.read(buf);
      if (numread <= 0)
        break;
      out.write(buf, 0, numread);
      totalBytesRead += numread;
      incrementalBytesRead += numread;
      totalKbRead = totalBytesRead/1000;
      testMediaBuffer();
        fireDataLoadUpdate();
    } while (validateNotInterrupted());
        stream.close();
    if (validateNotInterrupted()) {
        fireDataFullyLoaded();
    }
  }
  private boolean validateNotInterrupted() {
    if (isInterrupted) {
      if (mediaPlayer != null) {
        mediaPlayer.pause();
        //mediaPlayer.release();
      }
      return false;
    } else {
      return true;
    }
  }
  /**
   * Test whether we need to transfer buffered data to the MediaPlayer.
   * Interacting with MediaPlayer on non-main UI thread can causes crashes to so perform this using a Handler.
   */
  private void testMediaBuffer() {
    Runnable updater = new Runnable() {
      public void run() {
        if (mediaPlayer == null) {
          // Only create the MediaPlayer once we have the minimum buffered data
          if ( totalKbRead >= INTIAL_KB_BUFFER) {
            try {
              startMediaPlayer();
            } catch (Exception e) {
              Log.e(getClass().getName(), "Error copying buffered conent.", e);
            }
          }
        } else if ( mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000 ){
          // NOTE: The media player has stopped at the end so transfer any existing buffered data
          // We test for <1second of data because the media player can stop when there is still
          // a few milliseconds of data left to play
          transferBufferToMediaPlayer();
        }
      }
    };
    handler.post(updater);
  }
  private void startMediaPlayer() {
    try {
      File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");
      // We double buffer the data to avoid potential read/write errors that could happen if the
      // download thread attempted to write at the same time the MediaPlayer was trying to read.
      // For example, we can't guarantee that the MediaPlayer won't open a file for playing and leave it locked while
      // the media is playing. This would permanently deadlock the file download. To avoid such a deadloack,
      // we move the currently loaded data to a temporary buffer file that we start playing while the remaining
      // data downloads.
      moveFile(downloadingMediaFile,bufferedFile);
      Log.e(getClass().getName(),"Buffered File path: " + bufferedFile.getAbsolutePath());
      Log.e(getClass().getName(),"Buffered File length: " + bufferedFile.length()+"");
      mediaPlayer = createMediaPlayer(bufferedFile);
      // We have pre-loaded enough content and started the MediaPlayer so update the buttons & progress meters.
      mediaPlayer.start();
      startPlayProgressUpdater();
      playButton.setEnabled(true);
    } catch (IOException e) {
      Log.e(getClass().getName(), "Error initializing the MediaPlayer.", e);
      return;
    }
  }
  public void pausePlayer(){
    try {
      getMediaPlayer().pause();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public void startPlayer(){
    getMediaPlayer().start();
  }
  public void stopPlayer(){
    getMediaPlayer().stop();
  }
  /**
   * 根据文件创建一个mediaplayer对象
   */
  private MediaPlayer createMediaPlayer(File mediaFile)
  throws IOException {
    MediaPlayer mPlayer = new MediaPlayer();
    mPlayer.setOnErrorListener(
        new MediaPlayer.OnErrorListener() {
          public boolean onError(MediaPlayer mp, int what, int extra) {
            Log.e(getClass().getName(), "Error in MediaPlayer: (" + what +") with extra (" +extra +")" );
            return false;
          }
        });
    // It appears that for security/permission reasons, it is better to pass a FileDescriptor rather than a direct path to the File.
    // Also I have seen errors such as "PVMFErrNotSupported" and "Prepare failed.: status=0x1" if a file path String is passed to
    // setDataSource(). So unless otherwise noted, we use a FileDescriptor here.
    FileInputStream fis = new FileInputStream(mediaFile);
    mPlayer.setDataSource(fis.getFD());
    mPlayer.prepare();
    return mPlayer;
  }
  /**
   * 把缓存转化成mediaplay对象
   * Transfer buffered data to the MediaPlayer.
   * NOTE: Interacting with a MediaPlayer on a non-main UI thread can cause thread-lock and crashes so
   * this method should always be called using a Handler.
   */
  private void transferBufferToMediaPlayer() {
    try {
      // First determine if we need to restart the player after transferring data...e.g. perhaps the user pressed pause
      boolean wasPlaying = mediaPlayer.isPlaying();
      int curPosition = mediaPlayer.getCurrentPosition();
      // Copy the currently downloaded content to a new buffered File. Store the old File for deleting later.
      File oldBufferedFile = new File(context.getCacheDir(),"playingMedia" + counter + ".dat");
      File bufferedFile = new File(context.getCacheDir(),"playingMedia" + (counter++) + ".dat");
      // This may be the last buffered File so ask that it be delete on exit. If it's already deleted, then this won't mean anything. If you want to
      // keep and track fully downloaded files for later use, write caching code and please send me a copy.
      bufferedFile.deleteOnExit();
      moveFile(downloadingMediaFile,bufferedFile);
      // Pause the current player now as we are about to create and start a new one. So far (Android v1.5),
      // this always happens so quickly that the user never realized we've stopped the player and started a new one
      mediaPlayer.pause();
      // Create a new MediaPlayer rather than try to re-prepare the prior one.
      mediaPlayer = createMediaPlayer(bufferedFile);
      mediaPlayer.seekTo(curPosition);
      // Restart if at end of prior buffered content or mediaPlayer was previously playing.
      //  NOTE: We test for <1second of data because the media player can stop when there is still
      // a few milliseconds of data left to play
      boolean atEndOfFile = mediaPlayer.getDuration() - mediaPlayer.getCurrentPosition() <= 1000;
      if (wasPlaying || atEndOfFile){
        mediaPlayer.start();
      }
      // Lastly delete the previously playing buffered File as it's no longer needed.
      oldBufferedFile.delete();
    }catch (Exception e) {
      Log.e(getClass().getName(), "Error updating to newly loaded content.", e);
    }
  }
  private void fireDataLoadUpdate() {
    Runnable updater = new Runnable() {
      public void run() {
        //textStreamed.setText((totalKbRead + " Kb read"));
        float loadProgress = ((float)totalKbRead/(float)mediaLengthInKb);
        //progressBar.setSecondaryProgress((int)(loadProgress*100));
      }
    };
    handler.post(updater);
  }
  private void fireDataFullyLoaded() {
    Runnable updater = new Runnable() {
      public void run() {
          transferBufferToMediaPlayer();
          // Delete the downloaded File as it's now been transferred to the currently playing buffer file.
          downloadingMediaFile.delete();
        //textStreamed.setText(("Audio full loaded: " + totalKbRead + " Kb read"));
      }
    };
    handler.post(updater);
  }
  //TODO 这个方法应该可以控制歌曲的播放
  public MediaPlayer getMediaPlayer() {
    return mediaPlayer;
  }
  public void startPlayProgressUpdater() {
    float progress = (((float)mediaPlayer.getCurrentPosition()/1000)/mediaLengthInSeconds);
    progressBar.setProgress((int)(progress*100));
    if (mediaPlayer.isPlaying()) {
      Runnable notification = new Runnable() {
        public void run() {
          startPlayProgressUpdater();
        }
      };
      handler.postDelayed(notification,1000);
    }
  }
  public void interrupt() {
    playButton.setEnabled(false);
    isInterrupted = true;
    validateNotInterrupted();
  }
  /**
   * Move the file in oldLocation to newLocation.
   */
  public void moveFile(File  oldLocation, File  newLocation)
  throws IOException {
    if ( oldLocation.exists( )) {
      BufferedInputStream reader = new BufferedInputStream( new FileInputStream(oldLocation) );
      BufferedOutputStream writer = new BufferedOutputStream( new FileOutputStream(newLocation, false));
      try {
        byte[] buff = new byte[8192];
        int numChars;
        while ( (numChars = reader.read( buff, 0, buff.length ) ) != -1) {
          writer.write( buff, 0, numChars );
         }
      } catch( IOException ex ) {
        throw new IOException("IOException when transferring " + oldLocation.getPath() + " to " + newLocation.getPath());
      } finally {
        try {
          if ( reader != null ){
            writer.close();
            reader.close();
          }
        } catch( IOException ex ){
          Log.e(getClass().getName(),"Error closing files when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
        }
      }
    } else {
      throw new IOException("Old location does not exist when transferring " + oldLocation.getPath() + " to " + newLocation.getPath() );
    }
  }
  /**
   * 獲取service中的播放器对象
   * @return 播放器对象
   */
  public MediaPlayer getPlayer() {
    return this.player;
  }
  @Override
  public void onStart(Intent intent, int startId) {
    super.onStart(intent, startId);
    /**
     * 1.现在需要的就是做从PlayActivity里获取歌曲列表,和歌曲路径,歌曲手名
     *    并存放到各个集合里
     * 2.之后就是对对这些数组进行处理
     */
    music_name = new ArrayList();
    music_path = new ArrayList();
    String info = intent.getStringExtra("info");
    //sOngPath= intent.getStringExtra("songPath");
    Toast.makeText(getApplicationContext(), "歌曲播放异常", Toast.LENGTH_SHORT).show();
    player = new MediaPlayer();
    try {
      playMusic(info);
    } catch (Exception e) {
      Toast.makeText(getApplicationContext(), "歌曲播放异常", Toast.LENGTH_SHORT).show();
      e.printStackTrace();
    }
  }
  //播放音乐
  private void playMusic(String info) throws Exception {
    if ("play".equals(info)) {
      if (isPause) {// 暂停后,继续播放
        player.start();
        isPause = false;
      } else if (isSame) {// 如果现在播放和与所点播歌曲时同一首,继续播放所选歌曲
        player.start();
      } else {// 点播某一首歌曲
        play();
      }
    } else if ("pause".equals(info)) {
      player.pause();// 暂停
      isPause = true;
    } else if ("before".equals(info)) {
      playBefore();// 播放上一首
    } else if ("after".equals(info)) {
      playAfter();// 播放下一首
    }
  }
  private void play() throws Exception {
    //TODO 获取歌曲路径
    try {
      Log.i("playtest", "playtest");
    //  myApp.setPlaying_position(position); //设置歌曲 当前的播放标记
      player.reset();
      //player.setDataSource(songPath);
      player.start();
      //musicName = music_name.get(position);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  private void playBefore() throws Exception {
    if (position == 0) {
      position = music_name.size() - 1;
    } else {
      position--;
    }
    play();
  }
  private void playAfter() throws Exception {
    if (position == 0) {
      position = music_name.size() + 1;
    } else {
      position++;
    }
    play();
  }
  public class LocalBinder extends Binder {
    public StreamingMediaPlayer getService() {
      return StreamingMediaPlayer.this;
    }
  }
  @Override
  public void onDestroy() {
    super.onDestroy();
  }
  @Override
  public boolean onUnbind(Intent intent) {
    return super.onUnbind(intent);
  }
  @Override
  public IBinder onBind(Intent intent) {
    return localBinder;
  }
}

更多关于Android相关内容感兴趣的读者可查看本站专题:《Android多媒体操作技巧汇总(音频,视频,录音等)》、《Android开发入门与进阶教程》、《Android视图View技巧总结》、《Android编程之activity操作技巧总结》、《Android操作SQLite数据库技巧总结》、《Android操作json格式数据技巧总结》、《Android数据库操作技巧总结》、《Android文件操作技巧汇总》、《Android编程开发之SD卡操作方法汇总》、《Android资源操作技巧汇总》及《Android控件用法总结》

希望本文所述对大家Android程序设计有所帮助。


推荐阅读
  • 本文介绍了在开发Android新闻App时,搭建本地服务器的步骤。通过使用XAMPP软件,可以一键式搭建起开发环境,包括Apache、MySQL、PHP、PERL。在本地服务器上新建数据库和表,并设置相应的属性。最后,给出了创建new表的SQL语句。这个教程适合初学者参考。 ... [详细]
  • 在说Hibernate映射前,我们先来了解下对象关系映射ORM。ORM的实现思想就是将关系数据库中表的数据映射成对象,以对象的形式展现。这样开发人员就可以把对数据库的操作转化为对 ... [详细]
  • Android JSON基础,音视频开发进阶指南目录
    Array里面的对象数据是有序的,json字符串最外层是方括号的,方括号:[]解析jsonArray代码try{json字符串最外层是 ... [详细]
  • 高质量SQL书写的30条建议
    本文提供了30条关于优化SQL的建议,包括避免使用select *,使用具体字段,以及使用limit 1等。这些建议是基于实际开发经验总结出来的,旨在帮助读者优化SQL查询。 ... [详细]
  • 使用正则表达式爬取36Kr网站首页新闻的操作步骤和代码示例
    本文介绍了使用正则表达式来爬取36Kr网站首页所有新闻的操作步骤和代码示例。通过访问网站、查找关键词、编写代码等步骤,可以获取到网站首页的新闻数据。代码示例使用Python编写,并使用正则表达式来提取所需的数据。详细的操作步骤和代码示例可以参考本文内容。 ... [详细]
  • 本文介绍了如何使用PHP向系统日历中添加事件的方法,通过使用PHP技术可以实现自动添加事件的功能,从而实现全局通知系统和迅速记录工具的自动化。同时还提到了系统exchange自带的日历具有同步感的特点,以及使用web技术实现自动添加事件的优势。 ... [详细]
  • 使用nodejs爬取b站番剧数据,计算最佳追番推荐
    本文介绍了如何使用nodejs爬取b站番剧数据,并通过计算得出最佳追番推荐。通过调用相关接口获取番剧数据和评分数据,以及使用相应的算法进行计算。该方法可以帮助用户找到适合自己的番剧进行观看。 ... [详细]
  • YOLOv7基于自己的数据集从零构建模型完整训练、推理计算超详细教程
    本文介绍了关于人工智能、神经网络和深度学习的知识点,并提供了YOLOv7基于自己的数据集从零构建模型完整训练、推理计算的详细教程。文章还提到了郑州最低生活保障的话题。对于从事目标检测任务的人来说,YOLO是一个熟悉的模型。文章还提到了yolov4和yolov6的相关内容,以及选择模型的优化思路。 ... [详细]
  • 开发笔记:加密&json&StringIO模块&BytesIO模块
    篇首语:本文由编程笔记#小编为大家整理,主要介绍了加密&json&StringIO模块&BytesIO模块相关的知识,希望对你有一定的参考价值。一、加密加密 ... [详细]
  • Oracle10g备份导入的方法及注意事项
    本文介绍了使用Oracle10g进行备份导入的方法及相关注意事项,同时还介绍了2019年独角兽企业重金招聘Python工程师的标准。内容包括导出exp命令、删用户、创建数据库、授权等操作,以及导入imp命令的使用。详细介绍了导入时的参数设置,如full、ignore、buffer、commit、feedback等。转载来源于https://my.oschina.net/u/1767754/blog/377593。 ... [详细]
  • mysql-cluster集群sql节点高可用keepalived的故障处理过程
    本文描述了mysql-cluster集群sql节点高可用keepalived的故障处理过程,包括故障发生时间、故障描述、故障分析等内容。根据keepalived的日志分析,发现bogus VRRP packet received on eth0 !!!等错误信息,进而导致vip地址失效,使得mysql-cluster的api无法访问。针对这个问题,本文提供了相应的解决方案。 ... [详细]
  • ubuntu用sqoop将数据从hive导入mysql时,命令: ... [详细]
  • 本文介绍了iOS数据库Sqlite的SQL语句分类和常见约束关键字。SQL语句分为DDL、DML和DQL三种类型,其中DDL语句用于定义、删除和修改数据表,关键字包括create、drop和alter。常见约束关键字包括if not exists、if exists、primary key、autoincrement、not null和default。此外,还介绍了常见的数据库数据类型,包括integer、text和real。 ... [详细]
  • 如何在php中将mysql查询结果赋值给变量
    本文介绍了在php中将mysql查询结果赋值给变量的方法,包括从mysql表中查询count(学号)并赋值给一个变量,以及如何将sql中查询单条结果赋值给php页面的一个变量。同时还讨论了php调用mysql查询结果到变量的方法,并提供了示例代码。 ... [详细]
  • Oracle seg,V$TEMPSEG_USAGE与Oracle排序的关系及使用方法
    本文介绍了Oracle seg,V$TEMPSEG_USAGE与Oracle排序之间的关系,V$TEMPSEG_USAGE是V_$SORT_USAGE的同义词,通过查询dba_objects和dba_synonyms视图可以了解到它们的详细信息。同时,还探讨了V$TEMPSEG_USAGE的使用方法。 ... [详细]
author-avatar
_卟苴
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有