Когда вам нужно общаться между различными приложениями, вам, вероятно, понадобится мост. В вашем случае я бы предложил использовать сервис Minecraft RCON (должен быть включен в конфигурации) или плагин, который делает что-то подобное, например Websend.

Код Websend фактически доступен на Github, если вы хотите узнать, как работает плагин.

Связь между PHP и Java через сокеты

Шаг 1:

Создайте java-сервер

Я создал хороший API для таких ситуаций. вы можете использовать их, если хотите:

ЧатСервер

все, что вам нужно сделать, это создать новый экземпляр этого класса

package com.weebly.foxgenesis.src;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.io.*;

public final class ChatServer implements Runnable 
{  
    private final int CLIENTMAXIMUM;
    private ChatServerThread clients[];
    private ServerSocket server = null;
    private Thread       thread = null;
    private int clientCount = 0;
    private final ServerReciever output;
    private List<ConnectHandler> connectHandlers = new ArrayList<ConnectHandler>();
    private List<QuitHandler> quitHandlers = new ArrayList<QuitHandler>();

    /**
     * creates a new ChatServer for connection between clients
     * @param a ServerReciever implementing class
     */
    public ChatServer(ServerReciever a)
    {  
        CLIENTMAXIMUM = a.getMaximunClients();
        output = a;
        clients = new ChatServerThread[CLIENTMAXIMUM];
        try
        {  
            server = new ServerSocket();
            server.bind(new InetSocketAddress(output.getHost(), output.getPort()));
            log(server);
            start(); 
        }
        catch(IOException ioe)
        {  
            error("Can not bind to port " + a.getPort() + ": " + ioe.getMessage()); 
        }
    }

    /**
     * Force the Server to handle a msg
     */
    public void add(String text)
    {
        output.handle(text);
    }

    /**
     * Force the Server to handle an error
     */
    public void error(String text)
    {
        output.handleError(text);
    }

    /**
     * Log to the server
     */
    public void log(Object text)
    {
        output.handleLog(text);
    }

    /**
     * send a message to a specific client
     * @param ID ID of client
     * @param msg
     */
    public void send(int ID, String msg)
    {
        clients[findClient(ID)].send(msg);
        add(msg);
    }


    /**
     * Called by runnable
     */
    public void run()
    { 
        while (thread != null)
        {  
            try
            {   
                if(clientCount != CLIENTMAXIMUM){
                    log("Waiting for a client ..."); 
                    addThread(server.accept()); 
                }
            }
            catch(IOException ioe)
            {  
                error("Server accept error: " + ioe); 
                stop(); 
            }
        }

    }

    private void start()  
    { 
        if (thread == null)
        {  
            thread = new Thread(this); 
            thread.start();
        }
    }

    /**
     * Stops the server 
     */
    @SuppressWarnings("deprecation")
    public void stop()   
    { 
        if (thread != null)
        { 
            thread.stop(); 
            thread = null;
        }
    }

    private int findClient(int ID)
    {  
        for (int i = 0; i < clientCount; i++)
            if (clients[i].getID() == ID)
                return i;
        return -1;
    }

    /**
     * sends a message to a 
     * @param ID
     * @param input
     */
    public synchronized void handle(int ID, String input)
    {  
        StringTokenizer t = new StringTokenizer(input);
        String[] arg = new String[t.countTokens()];
        for(int i=0; t.hasMoreElements(); i++)
            arg[i] = t.nextToken(",");
        if(arg[0] == "new")
            switch(input)
            {
            case".bye":
            {
                clients[findClient(ID)].send(".bye");
                remove(ID); 
                break;
            }
            default:
            {
                for (int i = 0; i < clientCount; i++)
                    clients[i].send(input); 
                break;
            }
            }
    }
    /**
     * sends a message to all clients
     * @param input message to send
     */
    public void sendAll(String input)
    {
        for (int i = 0; i < clientCount; i++)
            clients[i].send(input); 
    }

    /**
     * remove a selected ID
     * @param ID ID of client
     */
    @SuppressWarnings("deprecation")
    public synchronized void remove(int ID)
    {  
        int pos = findClient(ID);
        if (pos >= 0)
        {  
            ChatServerThread toTerminate = clients[pos];
            log("Removing client thread " + ID + " at " + pos);
            if (pos < clientCount-1)
                for (int i = pos+1; i < clientCount; i++)
                    clients[i-1] = clients[i];
            clientCount--;
            QuitEvent e = new QuitEvent(toTerminate.getID());
            e.setGameBreaking(true);
            for(QuitHandler a: quitHandlers)
                a.quit(e);
            try
            {  
                toTerminate.close(); }
            catch(IOException ioe)
            {  
                error("Error closing thread: " + ioe); 
            }
            toTerminate.stop(); 
        }
    }

    private void addThread(Socket socket)
    {  
        if (clientCount < clients.length)
        { 
            log("Client accepted: " + socket);
            clients[clientCount] = new ChatServerThread(this, socket);
            try
            { 
                clients[clientCount].open(); 
                clients[clientCount].start();  
                ClientConnectEvent e = new ClientConnectEvent(clients[clientCount],clients[clientCount].getID());
                clientCount++; 
                for(ConnectHandler a: connectHandlers)
                    a.connect(e);
            }
            catch(IOException ioe)
            {  
                error("Error opening thread: " + ioe); 
            }
        }
        else
            error("Client refused: maximum " + clients.length + " reached.");
    }

    public String toString()
    {
        return "ChatServer{;host=" + output.getHost() + ";port=" + output.getPort() + ";clients=" + clientCount + ";}";
    }

    public int getAmountOfClients()
    {
        return clientCount;
    }

    public void addConnectHandler(ConnectHandler handler)
    {
        connectHandlers.add(handler);
    }

    public void removeConnectHandler(ConnectHandler handler)
    {
        connectHandlers.remove(handler);
    }

    public int getMaxClients()
    {
        return CLIENTMAXIMUM;
    }

    public void addQuitHandler(QuitHandler quitHandler) 
    {
        quitHandlers.add(quitHandler);
    }
    public void removeQuitHandler(QuitHandler quithandler)
    {
       quitHandlers.remove(quithandler);
    }
}

ChatServerThread

Используется ChatServer в качестве клиентских соединений

package com.weebly.foxgenesis.src;
import java.net.*;
import java.io.*;

public final class ChatServerThread extends Thread
{  
    private ChatServer server = null;
    private Socket socket = null;
    private int ID = -1;
    private DataInputStream  streamIn  =  null;
    private DataOutputStream streamOut = null;

    public ChatServerThread(ChatServer server, Socket socket)
    {  
        super();
        this.server = server;
        this.socket = socket;
        this.ID = socket.getPort();
    }
    @SuppressWarnings("deprecation")
    public void send(String msg)
    {   
        try
        {  
            streamOut.writeUTF(msg);
            streamOut.flush();
        }
        catch(IOException ioe)
        {  
            server.error(ID + " ERROR sending: " + ioe.getMessage());
            server.remove(ID);
            stop();
        }
    }

    public int getID()
    { 
        return ID;
    }

    @SuppressWarnings("deprecation")
    @Override
    public void run()
    {  
        server.log("Server Thread " + ID + " running.");
        while (true)
        {  
            try
            {  
                server.handle(ID, streamIn.readUTF());
            }
            catch(IOException ioe)
            {  
                server.error(ID + " ERROR reading: " + ioe.getMessage());
                server.remove(ID);
                stop();
            }
        }
    }

    public void open() throws IOException
    {  
        streamIn = new DataInputStream(new 
                BufferedInputStream(socket.getInputStream()));
        streamOut = new DataOutputStream(new
                BufferedOutputStream(socket.getOutputStream()));
    }

    public void close() throws IOException
    {  
        if (socket != null)    socket.close();
        if (streamIn != null)  streamIn.close();
        if (streamOut != null) streamOut.close();
    }
}

ClientConnectEvent

package com.weebly.foxgenesis.src;

public class ClientConnectEvent extends ConnectionEvent
{
    private final ChatServerThread client;

    public ClientConnectEvent(ChatServerThread client, int clientID)
    {
        super(clientID);
        this.client = client;
    }

    public ChatServerThread getClient()
    {
        return client;
    }

    @Override
    public boolean isConnectionBreaking(){return false;}
}

ConnectHandler

package com.weebly.foxgenesis.src;

public interface ConnectHandler 
{
    public void connect(ClientConnectEvent e);
}

ClientQuitEvent

package com.weebly.foxgenesis.src;

public class ClientQuitEvent extends ConnectionEvent
{
    public ClientQuitEvent(int clientID)
    {
        super(clientID);
    }

    @Override
    public boolean isConnectionBreaking() 
    {
        return true;
    }
}

QuitHandler

package com.weebly.foxgenesis.src;

public interface QuitHandler 
{
    public void quit(ClientQuitEvent e);
}

СерверПолучатель

package com.weebly.foxgenesis.src;

public interface ServerReciever 
{
    public void handle(String msg);
    public void handleError(String msg);
    public int getPort();
    public int getMaximunClients();
    public void handleLog(Object text);
    public String getHost();
}

ConnectionEvent

package com.weebly.foxgenesis.src;

public abstract class ConnectionEvent 
{
    public abstract boolean isConnectionBreaking();
    private int clientID;
    public ConnectionEvent(int clientID)
    {
        this.clientID = clientID;
    }

    public int getClientID()
    {
        return clientID;
    }
}

Шаг 2:

Подключить сервер к Bukkit

я привел пример того, как подключить сервер к bukkit, создав новый плагин.

public class MyPlugin extends JavaPlugin
{
     @Override
     public void onEnable()
     {
        ChatServer server = new ChatServer(new ServerReciever()
        {
            @Override
            public void handle(String msg){handleMsg(msg);}

            @Override
            public void handleError(String msg){handleErr(msg);}

            @Override
            public int getPort(){return 25567}

            @Override
            public int getMaximunClients(){return 100;}

            @Override
            public void handleLog(Object text){log(text);}

            @Override
            public String getHost(){return "localhost";}
        }
   }
   public void handleLog(Object text)
   {
      System.out.println(text);
   }
   public void handelErr(String msg)
   {
     System.err.println(msg);
   }
   public void handleMsg(String msg)
   {
     if(msg.equalsIgnoreCase("reload"))
           Bukkit.reloadOrSomething(); //i don't know the void off the top of my head
   }
}

Шаг 3:

Порт Форвард

если вы не знаете, что это такое, погуглите. в сети есть отличные уроки. вы хотите перенаправить порт, который вы установили в коде.

Шаг 4:

Отправить сообщение на сервер

я не знаю PHP, но все, что вам нужно сделать, это отправить сообщение в кодировке UTF-8 на IP-адрес сервера на порт, который вы жестко закодировали выше.

Шаг 5:

НАСЛАЖДАЙТЕСЬ!