En este artículo os vamos a enseñar cómo realizar un servidor HTTP simple utilizando el lenguaje de programación Java que puedes incorporar en tus propios proyectos, con el cual puedes trabajar de forma local o procesar peticiones concurrentes limitadas.
Un servidor HTTP está ligado a una dirección IP y a un puerto concreto, y escucha las peticiones de entrada para más tarde devolverlas a los clientes. Este servidor HTTP que te vamos a enseñar a realizar hoy, es apto para ser añadido en proyectos complejos debido a su flexibilidad, para ser añadido en proyectos complejos para la prestación de elementos HTML o simplemente como servidor backend. Si estás buscando una solución para crear un servidor HTTP simple el cual puedas integrar facilmente a tus proyectos, has venido al artículo adecuado. Esperamos cumplir todas las necesidades de lo que andas buscando. ¿Estás preparado para desarrollar un servidor HTML? ¡Pues comenzamos!
Esta es la estructura de la implementación del servidor HTTP:
Desde Java 1.6 contamos con un buit-in para servidores HTTP incluido en el SDK de J2EE. Lo puedes descargar fácilmente en:
http://mvnrepository.com/artifact/com.sun.net.httpserver/http/20070405
El servidor HTTP simple que te vamos a mostrar hoy puede ser añadido a una aplicación Java siguiendo estos cuatro sencillos pasos:
- Construir un objeto servidor HTTP
- Adjuntar uno o más controladores del objeto de servidor HTTP
- Implementar el controlador HTTP para procesar peticiones GET/POST y generar respuestas
- Iniciar el servidor HTTP
Crear un servidor HTTP
La clase HttpServer te brinda la posibilidad de tener acceso a la API de un servidor HTTP a un alto nivel, que puede ser usada para construir servidores HTTP en tus propios proyectos.
int port = 9000;
HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);
System.out.println("server started at " + port);
server.createContext("/", new RootHandler());
server.createContext("/echoHeader", new EchoHeaderHandler());
server.createContext("/echoGet", new EchoGetHandler());
server.createContext("/echoPost", new EchoPostHandler());
server.setExecutor(null);
server.start();
Crear un controlador HTTP
Los controladores HTTP están asociados con el servidor HTTP para procesar las solicitudes. Cada HttpHandler se ha registrado en una ruta concreta que representa la ubicación del servicio en este servidor. Las solicitudes de una ruta URL definida se asignan al controlador http correcto. Cualquier solicitud que el controlador no pueda encontrar es rechazada con una respuesta 404.
Aquí veréis como creamos el controlador raíz para mostrar el estado del servidor:
public class RootHandler implements HttpHandler {
public void handle(HttpExchange he) throws IOException {
String response = "Server start success if you see this message" + " Port: " + port;
he.sendResponseHeaders(200, response.length());
OutputStream os = he.getResponseBody();
os.write(response.getBytes());
os.close();
}
}
Declaramos el echoHeader para mostrar cualquier información del header:
public class EchoHeaderHandler implements HttpHandler {
@Override
public void handle(HttpExchange he) throws IOException {
Headers headers = he.getRequestHeaders();
Set<Map.Entry<String, List>> entries = headers.entrySet();
String response = "";
for (Map.Entry<String, List> entry : entries)
response += entry.toString() + "n";
he.sendResponseHeaders(200, response.length());
OutputStream os = he.getResponseBody();
os.write(response.toString().getBytes());
os.close();
}
}
Proceso de peticiones GET y POST
Existen dos métodos comunes para la petición-respuesta entre un cliente y el servidor a través del protocolo HTTP.
GET - Los datos pasados por la URL
POST - Los datos pasados a través de un submit
Aquí, se crean dos manejadores para procesar los métodos GET / POST, respectivamente.
Declaramos el controlador echoGet para procesar el Get Request:
public class EchoGetHandler implements HttpHandler {
@Override
public void handle(HttpExchange he) throws IOException {
// parse request
Map<String, Object> parameters = new HashMap<String, Object>();
URI requestedUri = he.getRequestURI();
String query = requestedUri.getRawQuery();
parseQuery(query, parameters);
// send response
String response = "";
for (String key : parameters.keySet())
response += key + " = " + parameters.get(key) + "n";
he.sendResponseHeaders(200, response.length());
OutputStream os = he.getResponseBody();
os.write(response.toString().getBytes());
s.close();
}
}
Declaramos el controlador echoPost para procesar el Post Request:
public class EchoPostHandler implements HttpHandler {
@Override
public void handle(HttpExchange he) throws IOException {
// parse request
Map<String, Object> parameters = new HashMap<String, Object>();
InputStreamReader isr = new InputStreamReader(he.getRequestBody(), "utf-8");
BufferedReader br = new BufferedReader(isr);
String query = br.readLine();
parseQuery(query, parameters);
// send response
String response = "";
for (String key : parameters.keySet())
response += key + " = " + parameters.get(key) + "n";
he.sendResponseHeaders(200, response.length());
OutputStream os = he.getResponseBody();
os.write(response.toString().getBytes());
os.close();
}
}
Aquí declaramos el método estático parseQuery() para parsear los parámetros de la petición:
public static void parseQuery(String query, Map<String, Object> parameters) throws UnsupportedEncodingException {
if (query != null) {
String pairs[] = query.split("[&]");
for (String pair : pairs) {
String param[] = pair.split("[=]");
String key = null;
String value = null;
if (param.length > 0) {
key = URLDecoder.decode(param[0], System.getProperty("file.encoding"));
}
if (param.length > 1) {
value = URLDecoder.decode(param[1], System.getProperty("file.encoding"));
}
if (parameters.containsKey(key)) {
Object obj = parameters.get(key);
if (obj instanceof List<?>) {
List values = (List) obj;
values.add(value);
} else if (obj instanceof String) {
List values = new ArrayList();
values.add((String) obj);
values.add(value);
parameters.put(key, values);
}
} else {
parameters.put(key, value);
}
}
}
}
Y con esto habremos creado nuestro propio servidor HTTP simple. Esperamos que os haya gustado este tutorial y que lo sepáis aplicar a vuestros propios proyectos, para, como os he dicho antes, trabajar de manera local sin depender de ningún software externo. Nosotros te seguiremos trayendo los mejores tutoriales sobre Java que encontremos por la red. A todo esto, ¿deseas algún tutorial especifico sobre el lenguaje de programación Java? ¿Hay algo que se te atraganta? Dínoslo en los comentarios y haremos todo lo posible.
Fuente: Andy Feng