• Proporcionar catálogos de elementos reusables en el diseño de sistemas software.
• Evitar la reiteración en la búsqueda de soluciones a problemas ya conocidos y solucionados anteriormente.
• Formalizar un vocabulario común entre diseñadores.
• Estandarizar el modo en que se realiza el diseño.
• Facilitar el aprendizaje de las nuevas generaciones de diseñadores condensando conocimiento ya existente.

• Imponer ciertas alternativas de diseño frente a otras.
• Eliminar la creatividad inherente al proceso de diseño.

• Se desea usar una clase existente, y su interfaz no se iguala con la necesitada.
• Cuando se desea crear una clase reusable que coopera con clases no relacionadas, es decir, las clases no tienen necesariamente interfaces compatibles.

package net.elhacker.adapter;
 
public interface Car {
 
	void fillTank();
	default void start() {
		System.out.println("Encendiendo auto...");
	}
}

package net.elhacker.adapter;
 
public class GasolineCar implements Car {
 
	public GasolineCar() {
		super(); // llamada al constructor padre
		System.out.println("Creando un auto a gasolina...");
	}
 
	@Override
	public void fillTank() {
		System.out.println("Colocando gasolina...");
	}
}
 

package net.elhacker.adapter;
 
public class GasCar implements Car {
 
	public GasCar() {
		super(); // llamada al constructor padre
		System.out.println("Creando un auto a gas...");
	}
 
	@Override
	public void fillTank() {
		System.out.println("Colocando gas...");
	}
 
}

package net.elhacker.adapter;
 
public class ElectricCar {
 
	public ElectricCar() {
		super(); // llamada al constructor padre
		System.out.println("Creando un auto eléctrico...");
	}
 
	public void connect() {
		System.out.println("Conectando motor a generador de electricidad...");
	}
}

package net.elhacker.adapter;
 
public class ElectricCarAdapter implements Car {
 
	ElectricCar electricCar;
 
	public ElectricCarAdapter() {
		electricCar = new ElectricCar();
	}
 
	@Override
	public void fillTank() {
		electricCar.connect();
 
	}
 
}

package net.elhacker.adapter;
 
public class AdapterTest {
 
	public static void main(String[] args) {
		Car gasolineCar = new GasolineCar();
		gasolineCar.fillTank();
		gasolineCar.start();
 
		System.out.println();
 
		Car gasCar = new GasCar();
		gasCar.fillTank();
		gasCar.start();
 
		System.out.println();
 
		Car electricCar = new ElectricCarAdapter();
		electricCar.fillTank();
		electricCar.start();
	}
 
}

Creando un auto a gasolina...
Colocando gasolina...
Encendiendo auto...

Creando un auto a gas...
Colocando gas...
Encendiendo auto...

Creando un auto eléctrico...
Conectando motor a generador de electricidad...
Encendiendo auto...

• Se usa para proporcionar una interfaz sencilla para un sistema complejo.
• Se quiere desacoplar un subsistema de sus clientes u otros subsistemas, haciéndolo mas independiente y portable.
• Se quiera dividir los sistemas en niveles: las fachadas serian el punto de entrada a cada nivel.

• + La principal ventaja del patrón fachada consiste en que para modificar las clases de los subsistemas, sólo hay que realizar cambios en la interfaz/fachada, y los clientes pueden permanecer ajenos a ello. Además, y como se mencionó anteriormente, los clientes no necesitan conocer las clases que hay tras dicha interfaz.
• - Como inconveniente, si se considera el caso de que varios clientes necesiten acceder a subconjuntos diferentes de la funcionalidad que provee el sistema, podrían acabar usando sólo una pequeña parte de la fachada, por lo que sería conveniente utilizar varias fachadas más específicas en lugar de una única global.

package net.elhacker.facade;
 
public class Bank {
 
	public Bank() {
 
	}
 
	public void createAccount(String account) {
		System.out.println("Creando cuenta N° "+account);
	}
}

package net.elhacker.facade;
 
public class Deposit {
 
	public Deposit() {
 
	}
 
	public void makeDeposit(double amount, String account) {
		System.out.println("Se ha depositado $"+amount+" a la cuenta "+account);
	}
 
}

package net.elhacker.facade;
 
public class Withdrawal {
 
	public Withdrawal() {
 
	}
 
	public void makeWidthdrawal(double amount, String account) {
		System.out.println("Se ha retirado $"+amount+" de la cuenta "+account);
	}
 
}

package net.elhacker.facade;
 
public class Facade {
 
public static void main(String[] args) {
 
	Bank bank = new Bank();
	Deposit deposit = new Deposit();
	Withdrawal withdrawal = new Withdrawal();
 
	bank.createAccount("9343435093");
	deposit.makeDeposit(2599.90, "9343435093");
	withdrawal.makeWidthdrawal(699.90, "9343435093");
 
	}
 
}

package net.elhacker.facade;
 
public class OperationsFacade {
 
 
	public OperationsFacade() {
	}
 
	public void createAccount(String account) {
		new Bank().createAccount(account);
	}
 
	public void makeDeposit(double amount, String account) {
		new Deposit().makeDeposit(amount, account);
	}
 
	public void makeWithdrawal(double amount, String account) {
		new Withdrawal().makeWidthdrawal(amount, account);
	}
 
}

package net.elhacker.facade;
 
public class FacadeTest {
 
	public static void main(String[] args) {
		OperationsFacade facade = new OperationsFacade();
		facade.createAccount("9343435093");
		facade.makeDeposit(2599.90, "9343435093");
		facade.makeWithdrawal(699.90, "9343435093");
	}
 
}

Creando cuenta N° 9343435093
Se ha depositado $2599.9 a la cuenta 9343435093
Se ha retirado $699.9 de la cuenta 9343435093

• Un sistema debe ser independiente de como sus objetos son creados.
• Un sistema debe ser 'configurado' con una cierta familia de productos.
• Se necesita reforzar la noción de dependencia mutua entre ciertos objetos.

• + Brinda flexibilidad al aislar a las clases concretas.
• + Facilita cambiar las familias de productos.
• - Para agregar nuevos productos se deben modificar tanto las fabricas abstractas como las concretas.

package net.elhacker.factory;
 
public abstract class Animal {
 
	protected String type;
	protected String family;
	protected String habitat;
 
	public Animal(String type, String family, String habitat) {
		this.type = type;
		this.family = family;
		this.habitat = habitat;
	}
 
	public String getType() {
		return type;
	}
 
	public void setType(String type) {
		this.type = type;
	}
 
	public String getFamily() {
		return family;
	}
 
	public void setFamily(String family) {
		this.family = family;
	}
 
	public String getHabitat() {
		return habitat;
	}
 
	public void setHabitat(String habitat) {
		this.habitat = habitat;
	}
 
	@Override
	public String toString() {
		return "Tipo de animal: "+getType()+"\nFamilia: "+getFamily()+
				"\nHábitat: "+getHabitat();
	}
}
 

package net.elhacker.factory;
 
public class Dog extends Animal {
 
	public Dog(String type, String family, String habitat) {
		super(type, family, habitat);
	}
 
}

package net.elhacker.factory;
 
public class Shark extends Animal {
 
	public Shark(String type, String family, String habitat) {
		super(type, family, habitat);
	}
 
 
}

package net.elhacker.factory;
 
public class Lion extends Animal {
 
	public Lion(String type, String family, String habitat) {
		super(type, family, habitat);
	}
 
 
}

package net.elhacker.factory;
 
public interface AbstractAnimalFactory {
 
	Animal createAnimal();
}

package net.elhacker.factory;
 
public class DogFactory implements AbstractAnimalFactory {
 
	protected String type;
	protected String family;
	protected String habitat;
 
	public DogFactory(String type, String family, String habitat) {
		this.type = type;
		this.family = family;
		this.habitat = habitat;
	}
 
	@Override
	public Animal createAnimal() {
		return new Dog(type, family, habitat);
	}
 
}

package net.elhacker.factory;
 
public class SharkFactory implements AbstractAnimalFactory {
 
	protected String type;
	protected String family;
	protected String habitat;
 
	public SharkFactory(String type, String family, String habitat) {
		this.type = type;
		this.family = family;
		this.habitat = habitat;
	}
 
	@Override
	public Animal createAnimal() {
		return new Shark(type, family, habitat);
	}
 
}

package net.elhacker.factory;
 
public class LionFactory implements AbstractAnimalFactory {
 
	protected String type;
	protected String family;
	protected String habitat;
 
	public LionFactory(String type, String family, String habitat) {
		this.type = type;
		this.family = family;
		this.habitat = habitat;
	}
 
	@Override
	public Animal createAnimal() {
		return new Lion(type, family, habitat);
	}
 
}

public LionFactory(String type, String family, String habitat)

@Override
public Animal createAnimal() {
	return new Lion(type, family, habitat);
}

package net.elhacker.factory;
 
public abstract class AnimalFactory {
 
	public static Animal create(AbstractAnimalFactory factory) {
		return factory.createAnimal();
	}
}

package net.elhacker.factory;
 
public class FactoryTest {
 
	public static void main(String[] args) {
		Animal dog = AnimalFactory.create(new DogFactory("Perro","Caninos","Doméstico"));
		Animal shark = AnimalFactory.create(new SharkFactory("Tiburón", "Lámnidos", "Mar"));
		Animal lion = AnimalFactory.create(new LionFactory("León", "Felinos", "Selva"));
 
		System.out.println(dog.toString());
		System.out.println();
		System.out.println(shark.toString());
		System.out.println();
		System.out.println(lion.toString());
	}
}

Tipo de animal: Perro
Familia: Caninos
Hábitat: Doméstico

Tipo de animal: Tiburón
Familia: Lámnidos
Hábitat: Mar

Tipo de animal: León
Familia: Felinos
Hábitat: Selva

• Cuando la aplicación requiere que solo exista una instancia de un determinado objeto.

• El primer paso es hacer el constructor privado para que no se pueda llamar y por lo tanto, no se puedan crear instancias.
• El segundo paso es crear una instancia de la clase y devolverla mediante un método estático.

package net.elhacker.singleton;
 
import java.util.HashMap;
import java.util.Map;
 
public class Configuration {
 
	private Map<String,Object> appOptions = null;
	private static Configuration config;
 
	private Configuration() {
 
	}
 
	public static Configuration getConfiguration() {
		if(config == null) {
			config = new Configuration();
		}
		return config;
	}
 
	public Map<String,Object> getAppOptions() {
		if(appOptions == null) {
			appOptions = new HashMap<>();
			appOptions.put("theme", "dark");
			appOptions.put("show_hidde_files", true);
		}
		return appOptions;
	}
 
	public void setAppOptions(Map<String,Object> appOptions) {
		this.appOptions = appOptions;
	}
 
}

package net.elhacker.singleton;
 
import java.util.Map;
 
public class SingletonTest {
 
	public static void main(String[] args) {
		Configuration cfg = Configuration.getConfiguration();
 
                // recorre el hashmap para leer las claves y valores
		for(Map.Entry<String, Object> entry: cfg.getAppOptions().entrySet()) {
			System.out.println(entry.getKey()+": "+entry.getValue());
		}
 
	}
 
}

show_hidde_files: true
theme: dark

• Eclipse Luna JEE
  
• MySQL 5.6
  
• Hibernate 4.3.8
  
• Java-JSON
  
• jBCrypt
  
  Creamos una tabla en MySQL llamada “users4login” en nuestra BBDD. Ésta tabla tendrá los siguientes atributos (vamos a mantenerlo simple):
  
  
  Código

  CREATE TABLE users4login
  (
     `user_id` INT AUTO_INCREMENT NOT NULL,
     `username` VARCHAR(45) NOT NULL,
     `email` VARCHAR(90) NOT NULL,
     `password` VARCHAR(255) NOT NULL,
     CONSTRAINT pk_user PRIMARY KEY(`user_id`)
  );

  
  A continuación ingresamos los siguientes datos:
  
  Código:

  username: Duke
  email: duke@localtest.me
  password: 12345 (hasheado en BCrypt):
  $2a$10$1Yf2nGEJWacanDyfftzpru8vcy4L5bOB6ohJ9bG4FeSg1T568DGWa

  
  
  PREPARACIÓN DEL ENTORNO
  
  Registrar el driver MySQL en Eclipse:
  
  Nos dirigimos a Eclipse y clickeamos en:
  
   
  Código:

  Window -> Preferences.

  
  Se abrirá una ventana con muchas opciones. Nos dirigimos a:
  
  
  Código:

  Data Management -> Conectivity -> Driver definitions

  
  Seleccionamos Add y se nos abrirá la siguiente ventana:
  
  
  
  Desplegamos el combo “Vendor Filter” y seleccionamos “MySQL”. Escojemos la versión 5.1. Ahora, nos dirigmos a la pestaña “JAR list”.
  Aquí hacemos click en “Add JAR/Zip” y nos mostrará un diálogo para seleccionar el conector jdbc para MySQL. Navegamos hacia donde tengamos el conector y lo seleccionamos. Una vez seleccionado el conector, hacemos clic en “OK”.
  
  NOTA: Si no tenemos el conector, lo podemos bajar de Aquí.
  
  
  
  CREACIÓN DE UN DATA SOURCE
  
  Nos dirigimos hacia “data source explorer” en Eclipse y en “Database Connections” hacemos click derecho y seleccionamos “New..”.
  
  
  
  En la ventana que nos mostrará, podemos ver todos los gestores de bases de datos. Seleccionamos MySQL y le colocamos el nombre “Users_Test”. Damos click en “Next”. Por último, colocamos los datos de nuestra BBDD y le damos finish:
  
  
  
  
  
  REGISTRAR UN SERVIDOR DE APLICACIONES (TOMCAT)
  
  Nos dirigimos a:
  
   
  Código:

  Window -> Preferences -> Server -> Runtime enviroments

  
  
  
  En la siguiente pantalla, solo indicamos la ruta donde tenemos descomprimido Tomcat 8 y le damos finish.
  
  NOTA: Si no lo tienes, lo puedes descargar desde Aquí.
  
  Aceptamos todo y nos dirigimos en la pestaña Servers del panel derecho. Aquí damos click derecho en el panel y seleccionamos:
  
  
  Código:

  New -> Server

  
  
  
  Y finalmente, seleccionamos nuestro servidor Tomcat 8 que hemos registrado y le damos finish:
  
  
  
  Ya tenemos listo nuestro IDE para poder trabajar.
  
  
  
  
  PARTE 2: CREACIÓN Y EJECUCIÓN DEL PROYECTO
  
  
  Nos dirigimos a:
  
  
  Código:

  New -> Project -> JPA Project

  
   Le colocamos el nombre “LoginDemo”. Escojemos nuestro servidor Tomcat 8, hacemos click en “Modify” y seleccionamos lo siguiente:
  
  
  
  Aceptamos y damos click en Next. Aquí nos pedirá la conexión a la BBDD para poder mapear las tablas a clases. Seleccionamos nuestra conexión y Next:
  
  
  
  Debe quedar así. Por último, en la siguiente pantalla seleccionamos la casilla “Generate web xml deployment descriptor” y le damos finish.
  
  Nuestro proyecto debe verse así:
  
  
  
  Dentro de WEB-INF hay una carpeta lib. Ésta carpeta contiene las librerías que necesita la aplicación, por lo tanto, añadimos las librerías de Hibernate, MySQL, JSON y BCrypt (éstas dos últimas las veremos más adelante). Debe quedar así:
  
  
  
  Al estar en esta carpeta, Eclipse automáticamente las agrega al classpath.
  
  Ahora, necesitamos especificar la configuración de nuestra conexión a la BBDD. El archivo persistence.xml queda así:
  
  
  Código

  <?xml version="1.0" encoding="UTF-8"?>
  <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence"
  	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
   
  	<!--  nombre de nuestra persistencia y tipo de transacción (local) -->
  	<persistence-unit name="LoginDemo" transaction-type="RESOURCE_LOCAL">
   
      <!-- proveedor jpa - hibernate -->
      <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
   
      <!-- configuracion -->
      <properties>
        <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test_db"/>
        <property name="javax.persistence.jdbc.user" value="usuario"/>
        <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
        <property name="javax.persistence.jdbc.password" value="contra"/>
        <property name="dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
        <property name="hibernate.hbm2ddl.auto" value="update"/>
        <property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
        <property name="show_sql" value="true"/>
      </properties>
   
  	</persistence-unit>
  </persistence>

  
  
• Primero le damos un nombre a la unidad de persistencia, en éste caso LoginDemo.
• Indicamos el proveedor de la persistencia. En éste caso Hibernate.
• Indicamos la configuración de la conexión.

<property name="javax.persistence.jdbc.user" value="usuario"/>
<property name="javax.persistence.jdbc.password" value="contra"/>

Click derecho en src -> New-> Package

Click derecho en com.mycompany.model.entities -> New-> JPA entities from tables

package com.mycompany.models.entities;
 
import java.io.Serializable;
import javax.persistence.*;
 
 
/**
 * The persistent class for the users4login database table.
 * 
 */
@Entity
@Table(name="users4login")
@NamedQueries({
	@NamedQuery(name="Users4login.findAll", query="SELECT u FROM User u"),
	@NamedQuery(name="Users4login.findUser", query = "SELECT u FROM User u WHERE u.username = :username OR u.email = :username")
})
public class User implements Serializable {
	private static final long serialVersionUID = 1L;
 
	@Id
	@Column(name="user_id",nullable=false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int userId;
 
	@Column(name="email",nullable=false)
	private String email;
 
	@Column(name="password",nullable=false)
	private String password;
 
	@Column(name="username",nullable=false)
	private String username;
 
	public User() {
	}
 
	public int getUserId() {
		return this.userId;
	}
 
	public void setUserId(int userId) {
		this.userId = userId;
	}
 
	public String getEmail() {
		return this.email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getPassword() {
		return this.password;
	}
 
	public void setPassword(String password) {
		this.password = password;
	}
 
	public String getUsername() {
		return this.username;
	}
 
	public void setUsername(String username) {
		this.username = username;
	}
 
}

• @Table: hace referencia a la tabla en la BBDD y el atributo name indica el nombre de la tabla. Por ésta, razón le podemos poner el nombre que queramos a la clase. Para hacerlo más sencillo, se lo he cambiado por “User” en lugar de “Users4login”.
• @Entity: indica que dicha clase es una entidad.
• @Id: Indica que dicho campo es la llave primaria.
• @GeneratedValue: indica el tipo de generación, en éste caso GenerationType.IDENTITY, indica que la llave primaria tendrá un generador AUTO_INCREMENT en MySQL.
• @Column: indica que dicho campo es una columna en la base de datos. El atributo name, indica el nombre de la columna y nullable, si el campo puede recibir null.
• @NamedQuery: especifica una consulta a la base de datos y se identifica con un nombre (atributo name).

package com.mycompany.util;
 
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
 
/**
 *
 * @author Gus
 */
public class EntityManagerUtil {
 
	private static final EntityManagerFactory emf = Persistence.createEntityManagerFactory("LoginDemo");
 
    private EntityManagerUtil() {
 
    }
 
    public static EntityManagerFactory getEntityManagerFactory()
    {
        return emf;
    }
}

package com.mycompany.util;
 
import java.util.List;
 
import javax.persistence.*;
 
import com.mycompany.models.entities.User;
 
/**
 *
 * @author Gus
 */
public class UserUtil {
 
    public static User getUser4login(String username)
    {
        EntityManager em = null;
        User user = null;
 
        /**
         * @description Obtenemos el EMF y a continuación el EM. Luego iniciamos una
         * transacción (em.getTransaction().begin()). Posteriormente cargamos la NamedQuery
         * que creamos en la clase 'User', y le asignamos el parámetro ':username' (es equivalente
         * al '?' de las sentencias preparadas), en este caso el nombre de usuario/email que recibe
         * por parámetro. Ejecuta la sentencia y guarda - si encuentra - el usuario en la variable 'user'.
         * Finalmente termina la transacción.
         * @error Pueden ocurrir dos errores: Un error al obtener el EM o al no encontrarse el usuario. 
         * @after Cerramos la conexión del EM y devolvemos la varianle 'user'.
         */
        try
        {
            em = EntityManagerUtil.getEntityManagerFactory().createEntityManager();
            em.getTransaction().begin();
            Query query = em.createNamedQuery("User.findUser",User.class);
            query.setParameter("username", username);
            @SuppressWarnings("unchecked")
			List<User> users = (List<User>) query.getResultList();
            if(!users.isEmpty())
            	user = (User) users.get(0);
            em.getTransaction().commit();
        }
        catch (Exception ex)
        {
        	ex.printStackTrace();
            try { throw new Exception("Ha ocurrido un error: "+ex.getMessage());}
            catch (Exception e) {
            	if(em.getTransaction().isActive())
            		em.getTransaction().rollback();
            }
        }
        finally
        {
            if(em != null && em.getTransaction().isActive()) {
                em.close();
            }
        }
        return user;
    }
}
 

@NamedQuery(name="Users4login.findUser", query = "SELECT u FROM User u WHERE u.username = :username OR u.email = :username")

String query = "SELECT * FROM User u WHERE u.username = ? OR u.email = ?";
ps.setString(1,”usuario”);
ps.setString(2,”email@algo.com”);

Stmt.Bind_param(“ss”,”username”,”email@algo.com”);

• Ejecutamos la sentencia: query.getResultList(). Éste método devuelve una lista de registros de acuerdo a la consulta.
• Evaluamos, si la lista no está vacía guardamos en el objeto User que creamos al inicio del método, el Usuario encontrado traído de la BBDD.
• Por último, cerramos la transacción: em.getTransaction().commit() y retornamos el objeto User declarado al principio del método, independientemente si está null (no se encontró Usuario).
• En el catch, si la la conexión del EntityManager está activa, hacemos un rollback(), que es deshacer cambios.
• En el finally, cerramos la conexión del EntityManager, sólo si ésta está activa.

package com.mycompany.util;
 
import java.util.HashMap;
import java.util.Map;
 
import org.json.JSONException;
import org.json.JSONObject;
 
public class JSONUtil {
 
	public static Map<String,Object> jsonToMap(String stringifyJSON)
	{
		JSONObject jsonObj = null;
        Map<String,Object> data = null;
        try {
			jsonObj = new JSONObject(stringifyJSON);
			data = new HashMap<>();
 
			for(byte i=0; i<jsonObj.names().length(); i++)
			{
				data.put(jsonObj.names().getString(i), jsonObj.get(jsonObj.names().getString(i)));
			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
 
        return data;
	}
}

• Crear un folder dentro de WebContent llamado resources.
• Dentro de resources crear 3 folders: css, js, img y vendor.
• Descargar jQuery 2.1.1 en su versión minificada y colocarla dentro del folder vendor.
• Descargar la hoja de estilos por ser un poco larga, y colocarla dentro del folder css.

New -> JSP file.

<%-- 
    Document   : index
    Created on : 21/01/2015, 09:51:38 AM
    Author     : Gus
--%>
 
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="resources/css/font-awesome.min.css"/>
        <link rel="stylesheet" href="resources/css/general.css"/>
        <title>Demo Login Servlet/AJAX</title>
    </head>
    <body>
 
        <section class="main-container">
 
            <header>
                <nav class="navbar">
                    <span class="header-logo"></span>
                    <h1 class="header-title">EJEMPLO LOGIN: INTEGRANDO SERVLETS Y AJAX</h1>
                </nav>
            </header>
 
            <section class="main-content">
 
                <form class="panel">
                    <section class="panel-head">
                        <span class="form-logo"></span>
                        <h1 class="panel-title">Identifíquese</h1>
                    </section>
                    <section class="panel-body">
                        <section class="form-group-hoz">
                            <label for="user">Usuario o email:</label>
                            <input type="text" id="user" name="user" class="textfield"/>
                        </section>
                        <section class="form-group-hoz">
                            <label for="pass">Contraseña:</label>
                            <input type="password" id="pass" name="pass" class="textfield"/>
                        </section>
                        <section id="error-message" class="error-message-inactive">
                        	<p class="error-message-text"></p>
                        </section>
                        <section class="form-btn-group">
                            <button type="submit" class="btn btn-primary">Aceptar</button>
                            <button type="button" class="btn btn-danger">Cancelar</button>
                        </section>
                    </section>
                </form>
            </section>
 
        </section>
 
        <script src="resources/vendor/jquery-2.1.1.min.js"></script>
        <script src="resources/js/util.js"></script>
        <script src="resources/js/call_servlet_ajax.js"></script>
    </body>
</html>
 

<input type="text" id="user" name="user" class="textfield"/>
<input type="password" id="pass" name="pass" class="textfield"/>

<button type="submit" class="btn btn-primary">Aceptar</button>
<button type="reset" class="btn btn-danger">Limpiar</button>

/**
 * @author Gus
 */
$("form").on("submit", function(e)
{
	// previene el submit normal del formulario
	e.preventDefault();
 
	var username = $("#user").val();
	var pass = $("#pass").val();
 
	var dataToSend = '{"username": "'+username+'", "password": "'+pass+'"}';
 
	$.ajax(
	{
		url: "LoginController",
		data: { data: dataToSend },
		dataType: "json",
		type: "post"
	})
	.done(function(data)
	{
		console.log("SUCCESS");
		$("#error-message > p").html(data["message"]);
		$("#error-message > p").removeClass("error-message-text").addClass("success-message-text");
		$("#error-message > p").css("padding",".25rem");
		if($("#error-message").hasClass("error-message-inactive")) {
			$("#error-message").removeClass("error-message-inactive").addClass("error-message-active");
		}
	})
	.fail(function(jqXHR, textStatus, errorThrown)
	{
		var response = JSON.parse(jqXHR.responseText);
		console.log("FAIL");
		$("#error-message > p").html(response["message"]);
		$("#error-message > p").removeClass("success-message-text").addClass("error-message-text");
		$("#error-message > p").css("padding",".25rem");
		$("#error-message").removeClass("error-message-inactive").addClass("error-message-active");
	})
	.always(function(jqXHR, textStatus, errorThrown) {
		$("#loading-icon").removeClass("fa fa-circle-o-notch fa-spin");
	});
});
 

New -> Servlet

package com.mycompany.control.servlets;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.json.JSONObject;
import org.mindrot.jbcrypt.BCrypt;
 
import com.mycompany.models.entities.User;
import com.mycompany.util.JSONUtil;
import com.mycompany.util.UserUtil;
 
 
@WebServlet(asyncSupported = true, urlPatterns = { "/LoginController" })
public class LoginController extends HttpServlet {
	private static final long serialVersionUID = 1L;
 
 
    public LoginController() {
        super();    
    }
 
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
	}
 
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
		response.setContentType("application/json");
        PrintWriter writer = response.getWriter();
 
        Map<String,Object> data = JSONUtil.jsonToMap(request.getParameter("data"));
        Map<String,Object> operationInfo; // contiene mensajes de los sucesos de la operación
		User user = UserUtil.getUser4login((String)data.get("username")); // obtiene el usuario si existe
 
		if(user != null)
		{
			operationInfo = new HashMap<>();
			// si el password ingresado coincide con el password del usuario hasheado -> Login correcto
			if(BCrypt.checkpw((String)data.get("password"), user.getPassword()))
			{
				operationInfo.put("message", "Login correcto");
			}
			else
			{
				response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
				operationInfo.put("message", "Contreña incorrecta");
			}
			writer.print(new JSONObject(operationInfo));
		}
		else
		{
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			operationInfo = new HashMap<>();
			operationInfo.put("message", "Usuario no encontrado");
 
			writer.print(new JSONObject(operationInfo));
		}
		writer.flush();
 
	}
 
}

Request.getAttribute(“data”)

jsonObj = new JSONObject(stringifyJSON);
 

<?php
 
interface ActiveRecord
{
	public function save();
	public function update();
	public function delete();
	public function find($id);
	public function all();
}

<?php
 
abstract class ActiveRecordImpl implements ActiveRecord
{
 
	public function save()
	{
 
	}
 
	public function update()
	{
 
	}
 
	public function delete()
	{
 
	}
 
	public function find($id)
	{
 
	}
 
	public function all()
	{
 
	}
 
}
 

<?php
 
public function save()
{
	$caller = REFERENCIA_AL_OBJETO_LLAMANTE;
	$callerClass = get_class($caller); // 'Customer' o 'User'
 
	// obtiene el servicio dinámicamente, de acuerdo al objeto llamante
	$service = ServiceFactory::create($callerClass);
 
	// le envía el objeto llamante al servicio Customer para que
	// lo guarde en la BD
	$service->save($caller);
}

<?php
 
public static function create($class)
{
	switch ($class) {
		case 'Customer':
			return new CustomerService();
 
		case 'User':
			return new UserService();
	}
}
 

<?php
 
class CustomerService
{
	public function save(Customer $customer)
	{
		new CustomerDAO()->save($customer);
	}
}

<?php
 
class UserService
{
	public function create(User $user)
	{
		new UserDAO()->save($user);
	}
}

<?php
 
$customer = new Customer();
$customer->username = $username;
$customer->email = $email;
$customer->password = $password;
$customer->dni = $dni;
$customer->address = $address;
 
$user = new User();
$user->username = $username;
$user->email = $email;
$user->password = $password;