Angular - Ejecutar método cuando se pierde el foco de un componente

Fuente: http://stackoverflow.com/questions/19456397/angularjs-ngchange-trigger-onblur

<div ng-controller="MyCtrl">
    <input type='text' ng-blur='blurCount = blurCount + 1'/>

    <input type='text' ng-blur='blurCount = blurCount + 1' />

    blur count: {{blurCount}}
</div>

function MyCtrl($scope) {
    $scope.blurCount = 0;
    $scope.name = 'Superhero';
}

Java - Crear Singleton sin utilizar synchronized

Para poder realizar esto tenemos que definir el bean de esta manera:


public class SingletonSinSynchronized {

private SingletonSinSynchronized() {}

public static SingletonSinSynchronized getInstance() {
               return LazySingletonSinSynchronized.INSTANCE;
    }

    private static final class LazySingletonSinSynchronized {
        private static final SingletonSinSynchronized INSTANCE =  new SingletonSinSynchronized();
    }

}

De esta manera el primer objecto que llame al método getInstance va a inicializar previamente el atributo static de la clase interna LazySingletonSinSynchronized

Javascript - Herencia

Voy a mostrar una forma de crear objectos en Javascript y definir una herencia simple para poder heredar comportamiento en común entre distintos objectos. 

Supongamos que tenemos este objecto del cual necesitamos heredar: 

function AbstractObject(options) {
    //Declaramos un método publico.
    this.getUrl = function() {
        return options.url;
     };
} 

function MyObject() {
     //Se llama al constructor del padre.
     AbstractSearch.call(this, {
           url : "myImplementationUrl"
     };
}

Ahora definimos que nuestro MyObject sea del tipo AbstractObject

MyObject.prototype = Object.create(AbstractObject.prototype);

Luego ya podemos crear objectos MyObject y utilizar el método heredado. 

var myObject = new MyObject();
myObject.getUrl();

Y eso es todo!


 

Javascript - Métodos privados y publicos

En esta oportunidad voy a plantear un ejemplo de como crear un objecto en javascript y definir métodos privados y publicos.

El siguiente código muestra una clase persona con id, firsName y lastName:

function Person(options) {
    var id = options.id;
    var firstName = options.fistName;
    var lastName = options.lastName;
   
    //Private method
    var fullName = function () {
        return firstName + " " + lastName;
    }

    //Public method
    this.getId = function () {
        return id;
    }

    //Public method
    this.getFullName = function () {
        return fullName;
    }   
}

Donde tenemos fullName como método privado y getFullName y getId como métodos publicos.

Podemos observar que utilizando "this", en ese caso, se define como publicos a estos dos métodos. En el caso del otro (fullName) se define como variable-function privada.

Por ultimo para crear una instancia y utilizar esta clase, debemos realizar los siguiente:

var persona = new Persona({
            id: 1234,
            firstName: "Juan",
            lastName: "Perez"
     }
);
console.log(persona.getFullName());
console.log(persona.getId());


Este es un simple ejemplo de como crear un objecto en javascript y poder estructurar el código sin utilizar un framework particular.

Patrones de Diseño - Patrón Observer

Este patrón permite definir distintos observadores sobre un evento particular. Generalmente se utiliza para verificar y realizar acciones cuando un objecto cambia de estado.

El diagrama de este patrón es el siguiente: 

Para mas detalle consultar este link

Para poder implementar este patrón de manera sencilla, Java introduce dos clases (una interfaz y una clase) :

•     java.util.Observer -- cualquier objeto que necesité ser notificado cuando el estado de otro objeto cambia.
•     java.util.Observable -- cualquier objeto donde el cambio de su estado sea importante y otros puedan registrarse para rebicir la notificación de ese cambio de estado. 

Ahora podemos plantear un caso de ejemplo, supongamos que en un lugar de comida rápida dispone de una pizarra electrónica donde se notifica cuando un pedido esta completo. A su vez, existen compradores que están esperando que su pedido este listo y aparezca en dicha pizarra para poder retirarlos.

Para ello creamos una clase llamada OrderBoard para simular el funcionamiento de la pizarra cuando un pedido esta listo.

La clase puede definirse de esta manera:

import java.util.Observable;

class OrderBoard extends Observable {

  public void newOrderReady(final String orderNumber) {
    //it is necessary in order to hasChanged returns true.

    setChanged();
    //Notify all observers    notifyObservers(orderNumber);
  }
}

Es importante notar que esta clase va a ser observable por distintos observadores(Compradores) 

para saber cuando su pedido esta listo. Ahora definimos los distintos observadores en una clase 

llamada Buyer de la siguiente manera: 

import java.util.Observable;
import java.util.Observer;

final class Buyer implements Observer {

  private final String orderNumber;
  private final String name;

  public Buyer(final String orderNumber, final String name) {
    this.orderNumber = orderNumber;
    this.name = name;
  }

  public void update(final Observable observable, final Object arg) {
    if(arg != null && arg.equals(orderNumber)) {
      System.out.println(name + " says: " + " This is my order!!! - " + orderNumber);
    }
  }
}
 

Tener en cuenta que OrderBoard extiende de Observable y que Buyer implementa la interfaz 

Observer. Por último creamos una clase Main para unificar todo este comportamiento:

public class Main {

    public static void main(String[] args) throws InterruptedException {
        final OrderBoard board = new OrderBoard();
        final Buyer bob = new Buyer("A1", "bob");
        final Buyer joe = new Buyer("A2", "joe");
        final Buyer george = new Buyer("A4", "george");
        final Buyer john = new Buyer("A3", "john");
        
        //Adding all the observers        board.addObserver(bob);
        board.addObserver(joe);
        board.addObserver(george);
        board.addObserver(john);

        //We complete all the orders per each user.         

         board.newOrderReady("A1");
        board.newOrderReady("A4");
        board.newOrderReady("A3");
        board.newOrderReady("A2");
    }
}
 

La salida de la ejecución de este método es: 

bob says:  This is my order!!! - A1
george says:  This is my order!!! - A4
john says:  This is my order!!! - A3
joe says:  This is my order!!! - A2

El código se puede encontrar aquí 

Espero que sea de utilidad. 

Referencias:

http://www.javaworld.com/article/2077258/learn-java/observer-and-observable.html

http://migranitodejava.blogspot.com.ar/search/label/Observer

http://docs.oracle.com/javase/7/docs/api/java/util/Observer.html

http://docs.oracle.com/javase/7/docs/api/java/util/Observable.html

http://es.wikipedia.org/wiki/Observer_%28patr%C3%B3n_de_dise%C3%B1o%29 

MELI - API - SDK - JAVA -Obtener datos con una petición GET

Estoy empezando a incursionar en las API de Mercado Libre y decidí crear una aplicación de ejemplo. 
La idea es utilizar la sdk de Java disponible para Mercado Libre para poder hacerlo. También existen para otros lenguajes como PHP, Python, entre otros. En esta github de mercado libre podes encontrar más información.

En este ejemplo vamos a utilizar la sdk de java.

Los pasos son los siguentes:

1) Para poder conectarse con las API de MELI es necesario utilizar el Aplication Manager. En ese link van a encontrar information de como crear el App id y el Secret Key.

2) Una vez que tenemos el App id (clientID) y el Secret Key(clientSecret) vamos a bajar la sdk-Java de Mercado Libre.
Para proyectos maven solamente con agregar un nuevo repositorio alcanza.

<repositories>
    ...
    <repository>
         <id>mercadolibre-snapshots</id>
         <url>https://github.com/mercadolibre/java-sdk-repo/raw/master/snapshots</url>
    </repository>
    ...
</repositories>

Y después la dependencia

<dependencies>
       ...
       <dependency>
             <groupId>com.mercadolibre</groupId>
             <artifactId>sdk</artifactId>
             <version>0.0.2-SNAPSHOT</version>
      </dependency>
      ...
</dependencies>

3) Una vez configurado su entorno vamos a proceder a realizar la comunicación con MELI.

Creamos una nueva clase llamada Site como sigue:

public class Site {

    private final String id;
    private final String name;

    public Site(final String id, final String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Site{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

Esta clase va a contener toda la información de los Sites.

Luego creamos un SiteHandler para realizar las consultas.

public class SiteHandler {
   //Nombre de los campos que vamos a obtener informacion
    private static final String ID_KEY = "id";
    private static final String NAME_KEY = "name";
    //Creamos una unica instancia de Meli.
    private final Meli meli;

    private static final SiteHandler instance = new SiteHandler();

    private SiteHandler() {
        //Aca creamos el objecto Meli con la información de su aplicación.
        meli = new Meli(clientId, clienteSecret);
    }

    public static SiteHandler getInstance() {
        return instance;
    }

    public List<Site> getAllMeliSite()  {
        //Todos los sites.
        final List<Site> newSites = new ArrayList<Site>();
        try {
            //Aqui realizamos la consulta de todos los sites.
            final Response response = meli.get("/sites/");
            //Objeto gson que sirve para "parsear" los resultados.
            final Gson gson = new Gson();
            //Convertimos desde JSON a Java creando una lista de StringMap
            final List<StringMap<String>> sites = gson.fromJson(response.getResponseBody(), List.class);
            //Convertimos los objectos StringMap a Site.
            for (final StringMap<String> entries : sites) {
                newSites.add(new Site(entries.get(ID_KEY), entries.get(NAME_KEY)));
            }
        } catch (MeliException ex) {
            //Logger error en la respuesta
            System.out.println("Error " + ex.getMessage());
        } catch (IOException e) {
            //Logger error en la transformacion usando de gson.
            System.out.println("Error " + e.getMessage());
        }
        return newSites;
    }
}

Por último creamos un objeto main para que ejecute lo anterior:

public class Main {

    public static void main(String[] args) throws Exception {
        final List<Site> sites = SiteHandler.getInstance().getAllMeliSite();

        for (final Site site: sites) {
            System.out.println(site);
        }
    }   
}

Espero que sirva este sensillo ejemplo.

El ejemplo completo lo pueden encontrar en este link


Referencias:
https://github.com/mercadolibre/java-sdk
http://developers.mercadolibre.com/application-manager/
http://www.java2blog.com/2013/11/gson-example-read-and-write-json.html
http://developers.mercadolibre.com/api-directory/#close

AngularJs - Crear un simple menú.

Estoy empezando a utilizar AngularJs (por lo cual no soy un experto) pero aquí les dejo un ejemplo sobre como crear un menú de opciones y dejar seleccionada la opción dependiendo donde se encuentra  el usuario. 
Para mayor detalle ver la referencia abajo.

1) Este es el html principal: portada.html

       <html ng-app="portada">

            <head> 

                <script src="angular.min.js">

                </script> <script src="app.js"></script> 

             </head>

             <body> 

                   <div class="clearfix">
                      <menu></menu> 

                   </div>

             </body>

        </html>

2) Creamos el html que va a ser nuestra directives  menu.html

        <ul> 

             <li ng-repeat="navLink in navLinks" ng class="navClass('{{navLink.Title}}')">
                     <a href='{{navLink.Href}}#{{navLink.Title}}'> {{navLink.LinkText}}</a>
             </li>

        </ul>

3) Creamos el archivo js para el cual vamos a crear el directives y el modulo correspondiente: app.js

(function () {
var app = angular.module('portada', []);
app.controller('menuController', ['$scope', '$location', function ($scope, $location) {
$scope.navLinks = [{
Title: 'portada',
LinkText: 'Inicio',
Href : 'portada.html'
},{
Title: 'contacto',
LinkText: 'Contacto',
Href : 'contacto.html'
}];

$scope.navClass = function (page) {
var currentRoute = $location.path().substring(1) || 'portada';
return page === currentRoute ? 'active' : '';
};   
}]);

app.directive('menu', function() {
return {
restrict: 'E',
templateUrl: 'menu.html',
controller:'menuController', 
controllerAs: 'menuController'
}
});
})();

4) Agregarle un estilo particular al clase "active"

Referencia sobre este ejemplo.