Conexion a un SFTP

Ahora modificaremos el proyecto que realizamos en la entrada anterior.

Segimos utilizando la libreria jscape.

1.- Modificamos la interfaz agregando

           public Sftp getSftp();

2.- La anterior implementacion que teniamos nos pedira que la modifiquemos agregando el metodo, para hacerlo facil que solo retorne un null

3.- Creamos la siguiente implementacion que llamaremos SFTPImpl y sustituiremos nuesta variable ftp por una sftp

          private Sftp sftp;
          //agregamos sus metodos set y get

4.- El resto del codigo queda de la siguiente casi igual siendo el metodo desconectar en ves de que haga referencia a el ftp sera al sftp, el que cambia y por poco es el metodo conectar


          public boolean conectar() {
          try {
          SshParameters parametros = new SshParameters(
                    getDatosConexion().getDominio(), 
                    getDatosConexion().getUsuario(), 
                    getDatosConexion().getPassword()
          );
          sftp = new Sftp(parametros);
          sftp.connect();
          sftp.setBinary();
          System.out.println("Conectado al SFTP...");
          return true;          } catch (SftpException e) {
          System.out.println("Error al conectar al SFTP");         
          return false;
          }
         
          public boolean desconectar() {
          if(sftp!=null){
                     if(sftp.isConnected()){

                             sftp.disconnect();
                             return true;
                     }
          }
          return false;
          }


5.- En el metodo main solo hay que cambiar la referencia a la implementacion y listo ya podemos conectar a un servidor sftp


***una opcion para servidor sftp gratis puede ser: core FTP mini-sftp-server

Conexion a un FTP

Esta ocacion hablare un poco de como conectarnos a un ftp,sftp, y ftps

Empesaremos con la conexion a un ftp

1.- Crearemos un proyecto con 3 paquetes
          com.conexion.bean
          com.conexion.configuracion
          com.conexion.main


2.- Utilizaremos la libreria jscape.jar para realizar el uso del ftp, podremos utilziar otra libreria, pero utilizare esta por la facilidad de crear una conexion a un sftp


3.- En el paquete bean crearemos uno llamado DatosConexion con los siguientes datos
          dominio
          usuario
          password
           //sus metodos get y set

4.- En el paquete com.conexion.configuracion crearemos una Interfaz, q en mi caso llamare IConfiguracionConexion que tendra los siguientes metodos
          public boolean conectar();
          public boolean desconectar();
          public void setDatosConexion getDatosConexion();
          public DatosConexion getDatosConexion();
          public Ftp getFtp();
**Ftp proviene de la libreria jscape y en especifico com.jscape.inet.ftp.Ftp

5.- En el mismo paquete crearemos la prime implementacion, que llamare ConexionFTPImpl y contendra
          private DatosConexion datosConexion;
          private Ftp ftp;
          //sus metodos get y set

/*
creamos un nuevo ftp con los datos de conexion que tenemos
le agregamos un escuchador a nuestro ftp
intentamos establecer la conexion con el ftp
le indicamos que los datos que enviaremos o recibiremos seran tipop binario
recordemos que un ftp puede convertir la informacion a binario o a codigo ascii
para enviarla o recibirla
*/
          public boolean conectar(){
          try{
                    ftp = new Ftp(
                              getDatosConexion().getDominio() , 
                              getDatosConexion().getUsuario() , 
                              getDatosConexion().getPassword()
                              );
                     ftp.addFtpListener(this); 
                     ftp.connect();
                     ftp.setBinary();
                     System.out.println("Conectado al FTP..."); 
                     return true;

          }catch(FtpException e){
                    System.out.println("Error al conectar al ftp");
          }
          return false;

          }  

          public boolean desconectar(){
          if(ftp!=null){
                    if(ftp.isConnected()){
                              ftp.disconnect();
                              System.out.println("Desconectado del ftp...");

                    }
                    return true;
          }
          return false;
          }  

6.- En nuestro paquete main crearemos una clase Principal donde pondremos nuestro metodo main agregando nuestro codigo
          IConfiguracionConexion conexion = new ConexionFTPImpl();
          conexion.setDatosConexion(new DatosConexion());   
          conexion.getDatosConexion().setDominio("127.0.0.1");
          conexion.getDatosConexion().setPassword("java-limos-pass");
          conexion.getDatosConexion().setUsuario("java-limos");          conexion.conectar();          conexion.desconectar();


7.- Para el ejemplo utilize FileZilla Server, que es mi servidor ftp, dando un usuario "java-limos" y un pass "java-limos-pass"

Primeros Pasos Con Spring I

Cuantas veces nos ha pasado que estamos realizando bien guerreros algun programita, lo ejecutamos y hoooo sale un tremendo "NullPointerException" revisamos y es que no inicializamos una variable.

Cuantas veces estamos trabajando con interfaces y se nos ocurre utilizar una implementacion distinta, pues no hay mas remedio que recompilar nuestra aplicacion...

Esto es muy molesto, mas cuando lo que se requiere es velocidad a programar (no cuenta que sea molesto por que apenas estamos aprendiendo, si ese es el caso, este post no es para ti o te haras simplemente mañoso ...)

Una de las bendiciones más basicas que nos proporciona Spring, es que nos olvidamos de las instancias, ya que todo o casi todo lo inyectamos,  no tenemos que recompilar una aplicacion para utilizar una nueva implementacion de una interfaz en nuestro sistema.

Bueno empesemos :)

Si utilidamos un IDE como NetBeans, MyEclipce, Eclipce ... basta con crear un proyecto con caracteristicas de Spring. a lo cual nos creara un archivito casi siempre en la carpeta src casi siempre se llama applicationContext.xml que tiene las siguientes caracteristicas:

1.- La version y codificacion del archivo: casi siempre 

< ?xml version="1.0" encoding="UTF-8"? > casi siempre lo que cambia es la codificacion.


2.- Los esquemas para utilizar los beans de spring que van dentro de un bloque beans


< beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" >

< /beans >

Dentro de ese bloque mapearemos nuestras clases para que se inyecten al momento de ser utilizadas, esto reemplazaara a las instancias de clases que normalmente realizamos

Supongamos que tenemos dos clases, la primera imprime en pantalla un hola mundo mas un texto y la segunda llama a la primera agregandole el texto deceado

public class Impresora{
          public void imprimirTexto(String texto){
                    System.out.println("hola mundo desde: " + texto);
          }
}

public class Textos{
          public Impresora miImpresora;

          public void setMiImpresora(Impresora miImpresora){
                     this.miImpresora = miImpresora;

          }  
          public Impresora getMiImpresora(){
                     return miImpresora;

          }
          public void mandaAImprimir(){
                     getMiImpresora().imprimirTexto("Java-Limos.blogger");
          }
} 

NOTA: Para utilizar a miImpresora, cuando lo haciamos de la manera tradicional, muchos acostumbrabamos no encapsular la clase, para el caso de la inyeccion con spring tenemos que utilizarlo, aparte es una buena practica :)

Asumamos que tenemos nuestras dos clases en un paquete llamado "ejemplo.spring.basico", entonces procedamos a mapear nuestras clases en nuestro archivo applicationContext.xml

Dentro de nuesto bloque beans mapearemos nuestras dos clases


< bean
          class="ejemplo.spring.basico.Impresora" id="laImpresora"
/ >


Si observas dentro del bloque bean, mapeamos nuestra clase y le agregamos un identificador, esto es para ayudarnos a encontrarlo, es como si volviedamos a declarar una variable, pero esta ves en el xml


A continuacion mapearemos el segundo bean


< bean class="ejemplo.spring.basico.Textos" id="losTextos" >
          <property name="miImpresora" ref="laImpresora"/>
< / bean >

Si observas este nuevo bean, tiene una propiedad llamada "miImpresora" que no es mas que la variable miImpresora que contiene la clase Textos, y tambien tiene una referencia a "laImpresora" que es como identificamos en nuestro xml a la clase Impresora.


Ahora para que se vea aun mas, hay que crear una tercera clase con la cual inicializaremos nuestro applicationContext.xml


public class Test{
          public static void main( String args [ ] ){

                    BeanFactory fabricaDeBeans = new XmlBeanFactory ( new ClassPathResource( "/applicationContext.xml" ) );


                    Textos misTextos = (Textos)fabricaDeBeans.getBean(Textos.class); 

                    misTextos.mandaAImprimir();
          }        
}

Ahora si ejecutan su aplicacion en pantalla veran reflejado: hola mundo desde Java-Limos.blogger

QUE DIFERENCIA HAY ?

En la clase Textos nunca hicimos una instancia hacia Impresora, solo nos dedicamos a llamarla y en el caso de Impresora a darle funcionalidad

QUIEN HISO LA INSTANCIA?

La instancia se hiso desde el applicationContext, y fue responsabilidad de Spring realizar la tarea. 

QUE GANAMOS AL REALIZAR ESTO?

Tal ves escribimos mas, pero la ventaja es que spring se encarga de cargar todos los objetos mapeados antes de realizar cualquier otra cosa, por lo tanto las instancias no se realizan en tiempo de ejecucion.

Los objetos mapeados los podemos manipular para que un solo bean pueda comportarse como instancias diferentes ( en el caso de que se utilize ese bean en diferentes clases)  o podemos modificar su ambiente para que se comporte como un solo bean para todas las instancias que utilizemos.

Da mas velocidad a nuestras aplicaciones al ser Spring el que se encargue de la gestion de nuestros objetos

En el siguiente post veremos la parte de las interfaces. que es mas interesate