Fatal编程技术网
  • java/
  • 如何使用java作为服务器来流式播放音乐？

如何使用java作为服务器来流式播放音乐？

java stream

如何使用java作为服务器来流式播放音乐？,java,stream,webserver,mp3,Java,Stream,Webserver,Mp3,我正在尝试一个简单的http java代码， 如果我在文件位置使用chrome(http://localhost:8888/somefile.mp3) 它工作正常，但如果我在iphone上使用safari，则会抛出错误： java.net.SocketException:管道破裂 但如果我使用LAMP或任何php服务器，它都可以正常工作。 我怎样才能使它与java一起工作呢 这是http服务器： package com.streamternet; import java.io.Buffere

我正在尝试一个简单的http java代码， 如果我在文件位置使用chrome(http://localhost:8888/somefile.mp3) 它工作正常，但如果我在iphone上使用safari，则会抛出错误： java.net.SocketException:管道破裂 但如果我使用LAMP或任何php服务器，它都可以正常工作。 我怎样才能使它与java一起工作呢

这是http服务器：

package com.streamternet;


import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URLDecoder;
import java.util.StringTokenizer;

public class HTTPServer extends Thread {

static final String HTML_START =
        "<html>" +
                "<title>HTTP Server in java</title>" +
                "<body>";

static final String HTML_END =
        "</body>" +
                "</html>";

Socket connectedClient = null;
BufferedReader inFromClient = null;
DataOutputStream outToClient = null;


public HTTPServer(Socket client) {
    connectedClient = client;
}

public void run() {

    try {

        System.out.println( "The Client "+
                connectedClient.getInetAddress() + ":" + connectedClient.getPort() + " is connected");

        inFromClient = new BufferedReader(new InputStreamReader (connectedClient.getInputStream()));
        outToClient = new DataOutputStream(connectedClient.getOutputStream());

        String requestString = inFromClient.readLine();
        String headerLine = requestString;

        StringTokenizer tokenizer = new StringTokenizer(headerLine);
        String httpMethod = tokenizer.nextToken();
        String httpQueryString = tokenizer.nextToken();

        StringBuffer responseBuffer = new StringBuffer();
        responseBuffer.append("<b> This is the HTTP Server Home Page.... </b><BR>");
        responseBuffer.append("The HTTP Client request is ....<BR>");

        System.out.println("The HTTP request string is ....");
        while (inFromClient.ready())
        {
            // Read the HTTP complete HTTP Query
            responseBuffer.append(requestString + "<BR>");
            System.out.println(requestString);
            requestString = inFromClient.readLine();
        }

        if (httpMethod.equals("GET")) {
            if (httpQueryString.equals("/")) {
                // The default home page
                sendResponse(200, responseBuffer.toString(), false);
            } else {
                //This is interpreted as a file name
                String fileName = httpQueryString.replaceFirst("/", "");
                fileName = URLDecoder.decode(fileName);
                fileName="/"+fileName;
                if (new File(fileName).isFile()){
                    sendResponse(200, fileName, true);
                }
                else {
                    sendResponse(404, "<b>The Requested resource not found ....</b>", false);
                }
            }
        }
        else sendResponse(404, "<b>The Requested resource not found ...." +
                "Usage: http://127.0.0.1:5000 or http://127.0.0.1:5000/</b>", false);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void sendResponse (int statusCode, String responseString, boolean isFile) throws Exception {

    String statusLine = null;
    String serverdetails = "Server: Java HTTPServer";
    String contentLengthLine = null;
    String fileName = null;
    String contentTypeLine = "Content-Type: text/html" + "\r\n";
    FileInputStream fin = null;

    if (statusCode == 200)
        statusLine = "HTTP/1.1 200 OK" + "\r\n";
    else
        statusLine = "HTTP/1.1 404 Not Found" + "\r\n";

    if (isFile) {
        fileName = responseString;
        fin = new FileInputStream(fileName);
        contentLengthLine = "Content-Length: " + Integer.toString(fin.available()) + "\r\n";
        if (!fileName.endsWith(".htm") && !fileName.endsWith(".html"))
            contentTypeLine = "Content-Type: audio/mpeg\r\n";
    }
    else {
        responseString = HTTPServer.HTML_START + responseString + HTTPServer.HTML_END;
        contentLengthLine = "Content-Length: " + responseString.length() + "\r\n";
    }

    outToClient.writeBytes(statusLine);
    outToClient.writeBytes(serverdetails);
    outToClient.writeBytes(contentTypeLine);
    outToClient.writeBytes(contentLengthLine);
    outToClient.writeBytes("Connection: close\r\n");
    outToClient.writeBytes("\r\n");

    if (isFile) 
        sendFile(fin, outToClient);
    else 
        outToClient.writeBytes(responseString);

    outToClient.close();
}

public void sendFile (FileInputStream fin, DataOutputStream out) throws Exception {
    byte[] buffer = new byte[1024] ;
    int bytesRead;

    while ((bytesRead = fin.read(buffer)) != -1 ) {
        out.write(buffer, 0, bytesRead);
        out.flush();
    }
    fin.close();
}

public static void main (String args[]) throws Exception {

    ServerSocket Server = new ServerSocket (8888);

    System.out.println ("TCPServer Waiting for client on port 8888");

    while(true) {
        Socket connected = Server.accept();
        (new HTTPServer(connected)).start();
    }
}
}

package com.streamternet；
导入java.io.BufferedReader；
导入java.io.DataOutputStream；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.InputStreamReader；
导入java.net.InetAddress；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.net.url解码器；
导入java.util.StringTokenizer；
公共类HTTPServer扩展线程{
静态最终字符串HTML\u开始=
"" +
“java中的HTTP服务器”+
"";
静态最终字符串HTML\u结束=
"" +
"";
Socket connectedClient=null；
BufferedReader INFOROMCLIENT=null；
DataOutputStream outToClient=null；
公共HTTPServer（套接字客户端）{
connectedClient=客户端；
}
公开募捐{
试一试{
System.out.println（“客户机”+
connectedClient.getInetAddress（）+“：“+connectedClient.getPort（）+”已连接”）；
INFOROMCLIENT=new BufferedReader（新的InputStreamReader（connectedClient.getInputStream（））；
outToClient=新的DataOutputStream（connectedClient.getOutputStream（））；
String requestString=inFromClient.readLine（）；
字符串标题行=请求字符串；
StringTokenizer标记器=新的StringTokenizer（标题线）；
字符串httpMethod=tokenizer.nextToken（）；
字符串httpQueryString=tokenizer.nextToken（）；
StringBuffer responseBuffer=新的StringBuffer（）；
append（“这是HTTP服务器主页……
”；
append（“HTTP客户端请求是……
”；
System.out.println（“HTTP请求字符串为…”）；
while（informclient.ready（））
{
//阅读HTTP完整HTTP查询
追加（requestString+“
”）；
System.out.println（请求字符串）；
requestString=inFromClient.readLine（）；
}
if（httpMethod.equals（“GET”））{
if（httpQueryString.equals（“/”）{
//默认主页
sendResponse（200，responseBuffer.toString（），false）；
}否则{
//这被解释为一个文件名
字符串文件名=httpQueryString.replaceFirst（“/”，“”）；
fileName=urldecker.decode（文件名）；
fileName=“/”+文件名；
if（新文件（fileName）.isFile（））{
sendResponse（200，文件名，true）；
}
否则{
sendResponse（404，“未找到请求的资源…”，false）；
}
}
}
else sendResponse（404，“未找到请求的资源…”+
“用法：http://127.0.0.1:5000 或http://127.0.0.1:5000/“，假）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
public void sendResponse（int statusCode、字符串responseString、boolean isFile）引发异常{
字符串statusLine=null；
String serverdetails=“Server:Java-HTTPServer”；
字符串contentLengthLine=null；
字符串文件名=null；
String contentTypeLine=“内容类型：text/html”+“\r\n”；
FileInputStream fin=null；
如果（状态代码==200）
statusLine=“HTTP/1.1 200正常”+“\r\n”；
其他的
statusLine=“HTTP/1.1 404未找到”+“\r\n”；
if（isFile）{
fileName=responseString；
fin=新文件输入流（文件名）；
contentLengthLine=“内容长度：”+Integer.toString（fin.available（））+“\r\n”；
如果（！fileName.endsWith（“.htm”）和&！fileName.endsWith（“.html”））
contentTypeLine=“内容类型：音频/mpeg\r\n”；
}
否则{
responseString=HTTPServer.HTML\u START+responseString+HTTPServer.HTML\u END；
contentLengthLine=“内容长度：”+responseString.Length（）+“\r\n”；
}
outToClient.writeBytes（状态行）；
outToClient.writeBytes（服务器详细信息）；
outToClient.writeBytes（contentTypeLine）；
outToClient.writeBytes（contentLengthLine）；
outToClient.writeBytes（“连接：关闭\r\n”）；
outToClient.writeBytes（“\r\n”）；
if（isFile）
发送文件（fin、outToClient）；
其他的
outToClient.writeBytes（responseString）；
outToClient.close（）；
}
public void sendFile（FileInputStream fin，DataOutputStream out）引发异常{
字节[]缓冲区=新字节[1024]；
int字节读取；
而（（bytesRead=fin.read（buffer））！=-1）{
out.write（缓冲区，0，字节读取）；
out.flush（）；
}
fin.close（）；
}
公共静态void main（字符串args[]）引发异常{
ServerSocket服务器=新的ServerSocket（8888）；
System.out.println（“TCPServer正在端口8888上等待客户端”）；
while（true）{
Socket connected=Server.accept（）；
（新的HTTPServer（已连接））.start（）；
}
}
}
首先，这不是流式传输，这只是一个简单的HTTP请求-响应对话。看看你的服务器，它似乎在很多方面都坏了，甚至很难说为什么Chrome能够下载任何东西

我放了一个，只是为了好玩。它还远未完成，不可配置，只支持
GET
请求，但是如果您不想依赖其他服务器或框架，我认为这是一个很好的起点。它只能给出两种响应：
200ok
和
404notfound
。在类路径上搜索资源，并将其与基于扩展的MIME类型信息一起发送到客户端。您可能想添加MP3 MIME，但请注意，这只是一个玩具，仅用于显示HTTP的基本功能< 
public class TinyHTTPServer {

    public static void main(String[] args) throws IOException {

        ServerSocket server = new ServerSocket(8888);

        while (true) {
            final Socket connection = server.accept();
            new Thread(new Runnable(){
                public void run() {
                    RequestHandler handler = new RequestHandler();
                    handler.handle(connection);
                }
            }).start();
        }
    }

    public static class RequestHandler {

        public void handle(Socket socket) {
            try {
                Scanner scanner = new Scanner(socket.getInputStream(), "US-ASCII");
                String path = getPath(scanner.nextLine());

                Response response = find(path);

                PrintStream out = new PrintStream(socket.getOutputStream());

                for (String header : response.headers) {
                    out.print(header);
                    out.print("\r\n");
                }

                out.print("\r\n");
                if (response.url != null)
                    writeEntity(response.url.openStream(), socket.getOutputStream());
                out.print("\r\n");

                out.flush();
            } catch (Exception exception) {
                exception.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private String getPath(String requestLine) throws IOException {
            Matcher matcher = Pattern.compile("GET (/\\S*) HTTP/1\\.1").matcher(requestLine);
            matcher.find();
            return matcher.group(1);
        }

        private Response find(String path) {

            if (path.equals("/"))
                path = "/index.html";

            Response response = new Response();
            URL url = RequestHandler.class.getResource(path);

            if (url == null) {
                response.headers.add("HTTP/1.1 404 NOT FOUND");
            } else {
                response.url = url;
                response.headers.add("HTTP/1.1 200 OK");

                String type = "application/octet-stream";
                String extension = url.toString();

                if (extension.endsWith(".mp3"))
                    type = "audio/mp3";
                else if (extension.endsWith(".html"))
                    type = "text/html; charset=utf-8";

                response.headers.add("Content-Type: " + type);
            }

            return response;
        }

        private void writeEntity(InputStream in, OutputStream out) throws IOException {
            byte[] buffer = new byte[1024];
            int read = -1;

            while ((read = in.read(buffer, 0, buffer.length)) > -1) {
                out.write(buffer, 0, read);
            }
        }

    }

    public static class Response {

        public List<String> headers = new LinkedList<String>();
        public URL url;

    }
}