martes, 31 de enero de 2017

Integración de Spring con Maven y Eclipse

Antes de empezar con Spring lo vamos a integrar en nuestro Eclipse, para ello basca con añadir a nuestro pom.xml las siguientes lineas que hemos consultado previamente en el Central Repository de Maven:

<dependency>
<groupId>org.springframework<groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.6.RELEASE</version>
<dependency>


Con ello tendremos importados los siguientes . jar:

Después debemos hacer una configuración básica del Servlet añadiendo estas lineas:

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:web="http://java.sun.com/xml/ns/j2ee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/j2ee/web-app_2_5.xsd">

  <display-name>Springapp</display-name>

  <servlet>
    <servlet-name>springapp</servlet-name>
    <servlet-class>
          org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>/WEB-INF/spring/app-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>springapp</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>

</web-app>

Lo importante es decir en url-pattern que urls van a pasar por el MVC de Spring


Ejemplo de una estructura de la arquitectura de maven en eclipse con spring (MVC):



miércoles, 25 de enero de 2017

Hola Mundo en MAVEN ~ ECLIPSE


Como introducción a qué es MAVEN, este vídeo de una clase de Javier Moreno:

Para añadir dependencias a nuestro pom.xml tenemos esta URL donde podemos obtener el código de las dependencias a añadir.
The Central Repository


HIBERNATE

Hibernate es un Framework de persistencia de Java. En esencia, la persistencia es la pervivencia de información en memoria para trabajar con ella o para traspasarla a otro lugar.

En el caso de la programación orientada a objetos, los frameworks de persistencia como Hibernate abren una sesión para trabajar con ellos y bases de datos. Un objeto está persistido cuando éste está en la sesión de Hibernate.

En los frameworks de persistencia existe otro concepto clave: el de transacción. En la sesión de Hibernate se abre también normalmente una transacción, que es la que controla todos los pasos que hay que dar con los objetos y en caso de que exista un error o fallo en medio del proceso, hace rollback. El entorno de sesión y la transacción hacen de los frameworks de persistencia algo muy útil para trabajar con objetos y bases de datos.



Para comenzar he encontrado este enlace con un ejemplo práctico:

En el se tratan los aspectos básicos persistencia, transaccionalidad, así como los ficheros de configuración para sesiones y mapeos con las clases, también se ve como se pueden hacer distintas QUERYS de ejemplo.


Los apasos a seguir son:

1. Instalar Hibernate, para Eclipse, nos descargamos Hibernate, y copiamos las librerías que necesitemos para incluirlas en nuestro workspace, en caso de tener MAVEN, podemos configurarlo para que incluya los .jar necesarios.

2. Añadir el fichero hibernate.cfg.xml con la configuración necesaria para conectar con la BBDD.

3. Crear los POJOS y archivos hmb.xml. (Las clases y los ficheros para mapearlos.)

4. Clase para generar sesiones y controlar transacciones. OPCIONAL, si no se puede controlar en el DAO.

5. Si ya teníamos nuestros métodos para hacer la querys deben adaptarse a Hibernate para tratar las sesiones y las transacciones, que sean parecidos a esto:


  /* Method to  READ all the employees */
   public void listEmployees( ){
      Session session = factory.openSession();
      Transaction tx = null;
      try{
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list(); 
         for (Iterator iterator = 
                           employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      }catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      }finally {
         session.close(); 
      }
   }

martes, 24 de enero de 2017

Versiones de Java existentes

Actualmente existen 3 distribuciones:



 a) J2SE o simplemente Java SE: Java 2 Standard Edition o Java Standard Edition. Orientado al desarrollo de aplicaciones cliente / servidor. No incluye soporte a tecnologías para internet. Es la base para las otras distribuciones Java y es la plataforma que utilizaremos nosotros en este curso por ser la más utilizada.

 b) J2EE: Java 2 Enterprise Edition. Orientado a empresas y a la integración entre sistemas. Incluye soporte a tecnologías para internet. Su base es J2SE.

c) J2ME: Java 2 Micro Edition. Orientado a pequeños dispositivos móviles (teléfonos, tabletas, etc.). En esta imagen vemos, de forma orientativa, como J2EE “expande” a J2SE, mientras que J2ME “recorta” a J2SE al tiempo que tiene una fracción de contenido diferenciada exclusiva de J2ME. En realidad hablar de expansiones y recortes no es correcto, porque cada distribución es en sí misma distinta puesto que están concebidas con distintas finalidades. Por tanto no puede decirse que sean expansiones o recortes, pero de forma coloquial muchas veces se interpreta así.

 J2EE J2SE J2ME JAVA ¿Cuáles son las versiones y distribuciones de Java? ¿Cuál es mejor usar?
.
Podemos citar en la evolución del Java estándar:

• JDK 1.0 (1996): Primer lanzamiento del lenguaje Java.
• JDK 1.1 (1997): Mejora de la versión anterior.
• J2SE 1.2 (1998): Denominado Java 2 y el nombre "J2SE" (Java 2 Platform, Standard Edition)
• J2SE 1.3 (2000): Mejora de la versión anterior.
• J2SE 1.4 (2002): Mejora de la versión anterior.
• J2SE 5.0 (2004): Originalmente numerada 1.5. Mejora de la versión anterior.
• Java SE 6 (2006): Mejora de la versión anterior.
• Java SE 7 (2011): nueva versión que mejora la anterior. Incluyó mayor soporte para XML.
• Java SE 8 (2014):  Permite embeber JavaScript con Java, mejoras en gestión de fechas y tiempo.
• Java SE 9: nueva versión que mejora la anterior (en difusión).
• Java SE 10: nueva versión que mejora la anterior (todavía sin uso comercial).

Realizando la comprobación a día de hoy en la web oficial de ORACLE tenemos disponible para descargar la versión 8

Fuente: aprendeaprogramar.com

martes, 17 de enero de 2017

Un nuevo comienzo con ANGULAR 2

PRIMERA APP EN 10 PASOS

1. Instalar Node.js
     Para utilizar su gestor de paquetes npm.
     Url para la instalación: https://nodejs.org/en/download/


2. Crear un directorio para proyecto Angular, donde se servirá la aplicación

mkdir angular2
cd    angular2

También lo podemos crear la carpeta como siempre desde windows


3. Crear el fichero tsconfig.json 

     Este fichero es la configuración para el compilador de TypeScript:
{
    "compilerOptions": {
    "target": "es5",
    "module": "system",
    "moduleResolution": "node",
    "sourceMap": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "removeComments": false,
    "noImplicitAny": false
  },
  "exclude": [
    "node_modules",
    "typings/main",
    "typings/main.d.ts"
  ]
}


4. Añadimos el fichero typings.json

Para que TypeScript funcione correctamente:

{
  "ambientDependencies": {
    "es6-shim": "github:DefinitelyTyped/DefinitelyTyped/es6-shim/es6-shim.d.ts#7de6c3dd94feaeb21f20054b9f30d5dabc5efabd",
    "jasmine": "github:DefinitelyTyped/DefinitelyTyped/jasmine/jasmine.d.ts#7de6c3dd94feaeb21f20054b9f30d5dabc5efabd"
  }
}


5. Creamos el fichero package.json

Lo añadimos a la raíz del proyecto, nos sirve para definir las dependencias necesarias del proyecto para que el gestor de paquetes de node las gestione e instale lo necesario:

{
  "name": "angular2-prueba",
  "version": "1.0.0",
  "scripts": {
    "start": "tsc && concurrently \"npm run tsc:w\" \"npm run lite\" ",
    "tsc": "tsc",
    "tsc:w": "tsc -w",
    "lite": "lite-server",
    "typings": "typings",
    "postinstall": "typings install"
  },
  "license": "ISC",
  "dependencies": {
    "angular2": "2.0.0-beta.14",
    "systemjs": "0.19.25",
    "es6-shim": "^0.35.0",
    "reflect-metadata": "0.1.2",
    "rxjs": "5.0.0-beta.2",
    "zone.js": "0.6.6"
  },
  "devDependencies": {
    "concurrently": "^2.0.0",
    "lite-server": "^2.2.0",
    "typescript": "^1.8.9",
    "typings":"^0.7.12"
  }
}


6. Instalamos las dependencias en el proyecto

npm install


7. Creamos nuestro primer componente
Para ello creamos un nuevo subdirectorio dentro del principal:

mkdir app
cd    app
Creamos un archivo llamado app.component.ts:

// Importar el núcleo de Angular
import {Component} from 'angular2/core';
// Decorador component, indicamos en que etiqueta se va a cargar la plantilla
@Component({
    selector: 'my-app',
    template: 'Primera Prueba con Angular 2'
})
// Clase del componente donde iran los datos y funcionalidades
export class AppComponent { }


8. Creamos el main.ts dentro del directorio app

Se encarga de lanzar el framework al cargar la página:

import {bootstrap}    from 'angular2/platform/browser';
import {AppComponent} from './app.component';
bootstrap(AppComponent);


9. Creamos index.html en el directorio raíz

<html>
  <head>
    <title>Angular 2 - Hola mundo</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
 
 
    <script src="node_modules/es6-shim/es6-shim.min.js"></script>
    <script src="node_modules/systemjs/dist/system-polyfills.js"></script>
    <script src="node_modules/angular2/es6/dev/src/testing/shims_for_IE.js"></script>
    <script src="node_modules/angular2/bundles/angular2-polyfills.js"></script>
    <script src="node_modules/systemjs/dist/system.src.js"></script>
    <script src="node_modules/rxjs/bundles/Rx.js"></script>
    <script src="node_modules/angular2/bundles/angular2.dev.js"></script>
 
    <script>
      System.config({
        packages: {      
          app: {
            format: 'register',
            defaultExtension: 'js'
          }
        }
      });
      System.import('app/main')
            .then(null, console.error.bind(console));
    </script>
  </head>

  <body>
    <my-app>Cargando...</my-app>
  </body>
</html>


10. Compilamos y llamamos la aplicación.

npm start
El compilador de Typescript revisa los cambios en el código para compilarlo y lite-server cargará index.html refrescando los cambios, por lo que para ver los cambios realizados no tenemos que estar refrescando la página.
Podemos entrar con http://localhost:3000/ que carga lite-server o accediendo directamente al directorio donde esté guardado el proyecto.
Fuentes:
1.https://angularjs.org/ 2. http://victorroblesweb.es/2016/04/11/instalar-angular-2-hola-mundo/3. http://www.aprende-facilmente.com/angular-2/tutorial-de-angular-2-parte-1/

viernes, 13 de enero de 2017

Java con Angular. ¿Que necesitamos para empezar?

Actualizando conocimientos en JAVA para desarrollar aplicaciones WEB.




¿Que queremos hacer?
Queremos desarrollar nuestra propia aplicación web.

¿Cómo lo podemos hacer?
Existen multitud de lenguajes de programación y framewors, por lo que tenemos que tener claro que queremos hacer y que necesidades tenemos. En mi caso el desarrollo será básado en el MVC, si buscamos información también veremos que existen multitud de opciones, nos decantamos por JAVA con ANGULAR 2 por múltiples razones que no voy a citar ahora mismo, pero nos podríamos haber decantado por ejemplo por .NET con ANGULAR o cualquier otra tecnología básada en PHP....

¿Que necesitamos?

Lenguajes de programación:
1. HTML (Lenguaje en que se escriben la páginas web)
2. CSS (Estilos)
3. Javascript. En nuestro caso intentaremos utilizar ANGULAR como framework y en algún caso quizá se necesite JQUERY
4. JSP (Forma de enlazar HTML con script de JAVA)
5. AJAX (Para no hacer refrescos de página en cada acción que se realice)
6. JAVA (Lenguaje Orientado a Objetos)
7. SPRING (O cualquier otro framework)
8. HIBERNATE
9. MAVEN
10. SQL para la creación de una BBDD

Los lenguajes de programación pueden ser otros y los framewors también, pero es una opción tan válida como otra la que se propone. Conjugando todo lo anterior se pueden hacer webs muy potentes y dinámicas, además nos permite separar el negocio de la presentación para seguir la arquitectura a tres capas.

Servidor de aplicaciones
Por ejemplo APACHE

Servidor de BBDD
Por ejemplo MySQL, además hace falta un cliente, por ejemplo myAdmin

IDE para el desarrollo de la aplicación.
Netbeans, Eclipse, JCreator, JBuilder…
En este sentido de momento me decanto por Eclipse que es tan válido como cualquier otro.

Enlaces que pueden ser interesantes:

  1. Empezando con angular
  2. Tutorial: Creación de proyecto MAVEN con ECLIPSE



jueves, 4 de abril de 2013

Diseño adaptativo :: Responsive web design

Intentando mejorar como siempre y buscando cual es la mejor forma de hacer las cosas nos podemos encontrar con artículos como este que nos pueden servir de ayuda para a la hora de plantear nuevos diseños.

Dejo dos URLs que como se puede ver se trata del mismo artículo de Katrien De Graeve uno en español y otro en inglés en que se nos explica en que consiste el "Responsive web design":

  • http://www.desarrolloweb.com/articulos/diseno-web-adaptativo.html
  • http://msdn.microsoft.com/en-us/magazine/hh653584.aspx


Funcionamiento de RSS

Fantástica web donde nos explican que es RSS, cómo puedo leer un RSS, cómo puedo suscribirme a un canal RSS y otros aspectos básicos.

http://www.rss.nom.es

miércoles, 20 de julio de 2011

Video-tutorial de como dibujar en Illustrator CS5

Muy buen vídeo de como vectorizar y colorear una imagen con Illustrator por cortesía de Diego Verástegui.



También recomiendo este tutorial:
http://www.neoteo.com/tutorial-como-vectorizar-una-imagen-con-adobe