lunes, 30 de junio de 2014

Crear nuestra aplicación - II

WEBrick en funcionamiento

 Mantén este terminal abierto con el servidor web en funcionamiento, y abre un nuevo terminal para poder seguir usando las herramientas de Rails. Nuestra aplicación accederá a una base de datos, por lo que antes de continuar debemos crearla. Emplearemos MySQL... crea una base de datos llamada "blog_development" con un usuario "blogusr" y clave "blogpwd" usando tu herramienta favorita (phpMyAdmin, CocoaMySql...). Nosotros lo haremos directamente desde línea de comandos: 

$ mysql -uroot -p (...) create database blog_development default character set utf8 collate utf8_unicode_ci; grant all on blog_development.* to 'blogusr'@'localhost' identified by 'blogpwd' ; Una vez exista esta base de datos, abriremos el fichero config/database.yml y apuntaremos los datos en el apartado development: 

# config/database.yml development: adapter: mysql database: blog_development username: blogusr password: blogpwd socket: /var/run/mysqld/mysqld.sock Fíjate que en este fichero tenemos tres secciones principales, que corresponden a los tres entornos que se manejan en una aplicación Rails: development (desarrollo), test (pruebas) y production (producción). Cada entorno tendrá su propia base de datos independiente, de manera que podamos desarrollar tranquilos sin cambiar nada de la base de datos de producción, y podamos testear en una base de datos que se regenerará cada vez que lancemos la batería de tests. Pero por ahora usaremos sólo la base de desarrollo.

domingo, 29 de junio de 2014

Crear nuestra aplicación - I

El primer paso para crear una nueva aplicación Rails es crear la estructura base. Para ello abriremos un terminal de comandos y escribiremos: 
$ rails blog Esto generará un directorio llamado "blog", que es el nombre de nuestra aplicación, y dentro un montón de subdirectorios y ficheros que forman la base de nuestra aplicación. Entra en este nuevo directorio y veamos los principales elementos: 
$ cd blog $ ls app config doc log Rakefile script tmp components db lib public README test vendor Dentro de app encontrarás los ficheros correspondientes a los modelos, vistas, controladores y helpers, que forman la parte principal de nuestra aplicación (de ahí el nombre de "app", que viene de "application"). En config están los ficheros de configuración que definen el acceso a base de datos y otros, en log encontraremos los ficheros de registro de servidor (logs), la carpeta public contendrá elementos estáticos como imágenes, hojas de estilo y javascript... Fíjate que también existe una carpeta script. Contiene unas cuantas herramientas de Rails que nos ayudarán en nuestro desarrollo. Vamos a probar la primera: 

$ script/server A continuación, abre tu navegador web y dirígete a la dirección http://localhost:3000. Lo que verás es la página de bienvenida de Ruby on Rails dentro de tu nueva aplicación, y esto es porque Rails viene con su propio servidor web de serie, llamado WEBrick. Si vuelves al terminal podrás observar cómo WEBrick ha ido respondiendo a las peticiones del navegador web sirviendo los ficheros solicitados.
La página de bienvenida a nuestra aplicación Rails

sábado, 28 de junio de 2014

¿Qué es Rails?

Rails es un framework [?] creado para el desarrollo de aplicaciones web. Para entendernos, es una serie de utilidades, de herramientas para crear aplicaciones web más rápidamente que haciéndolo desde cero. Usando un framework evitamos reinventar la rueda, nos ahorramos muchísimo trabajo y podemos concentrarnos en lo que verdaderamente importa: la lógica de la aplicación, no en escribir una y otra vez los mismos formularios y scripts de proceso para crear, leer, modificar y eliminar datos en nuestra base de datos. 
Frameworks para desarrollo web hay muchos: Cake para PHP, Django para Python, Spring para Java, y muchos otros. Rails es un framework que usa el lenguaje Ruby, y por eso se conoce al conjunto como Ruby on Rails. Pero también existen otros frameworks para Ruby que no son Rails, como puede ser el microframework Camping. 
Rails fué desarrollado por el danés David Heinemeier, como una herramienta para facilitarle el trabajo al programar la aplicación web Basecamp para la empresa 37 Signals. En julio de 2004 liberó el código como software libre, y en febrero de 2005 comenzó a aceptar colaboraciones para mejorar Rails, formándose un amplio equipo de programadores, el core team.
Entre las características de Ruby on Rails podemos destacar que está basado en el patrón de diseño MVC (Modelo-Vista-Controlador [?]) con el que se separa la lógica de la presentación, que nos permite dejar de pensar siempre en SQL para pasar a pensar en objetos, que dispone de utilidades para generar rápidamente interfaces de administración, es independiente de la base de datos, podemos realizar tests continuos para garantizar que nuestra aplicación funciona como esperamos, se puede extender mediante el uso de plugins, se integra muy fácilmente con librerías de efectos como script.aculo.us... y todo ello escribiendo muy pocas líneas de código, muy claras y fáciles de entender. 
Vamos a ver todo esto mediante una serie de ejemplos prácticos, para no perdernos demasiado en la teoría.

viernes, 27 de junio de 2014

¿Qué es Ruby on Rails?

Ruby on Rails es un entorno de desarrollo web, de código abierto (open source, software libre), que nos permite construir aplicaciones web flexibles y robustas rápidamente. Las dos piezas principales de este entorno son dos: por un lado Ruby, y por otro, Rails. 

¿Qué es Ruby? 

Ruby es un lenguaje de programación enfocado a la simplicidad y a la productividad, con una sintaxis elegante y natural, que le hace muy fácil de entender. Es un lenguaje de script (no compilado), totalmente orientado a objetos. El lenguaje Ruby fué creado por Yukihiro  matz Matsumoto en 1995 cogiendo lo que más le gustaba de otros lenguajes como Perl, Smalltalk, Eiffel, Ada y Lisp. Mientras que otros lenguajes tienen tipos primitivos (como números, booleanos, ...) que no son objetos, aquí todo es un objeto y por tanto se le pueden asociar propiedades y métodos, así como redefinir o extender su comportamiento. Veamos algunos ejemplos: 

Ejemplo 1

5.times { print "Me encanta Ruby!" }

En este primer ejemplo vemos cómo el número 5 tiene un método "times" con el que tenemos un bucle, al que le pasamos el bloque entre llaves para que sea ejecutado 5 veces.

Ejemplo 2

(1..100).each do |i| print i end

En este segundo ejemplo, vemos cómo los rangos de números (1..100) tienen un método "each" con el que podemos también hacer un bucle, cogiendo cada valor en cada vuelta en el parámetro i.

Ejemplo 3

class Numeric def mas(x) self.+(x) end def par? ((self/2)*2) ==
self end def impar? !par? end end n = 5.mas 6 # n ahora vale 11

n.par? # devolverá false n.impar? # devolverá true

Aquí vemos la posibilidad de redefinir el lenguaje. Aunque la manera normal de sumar dos números es mediante el operador "+", hemos añadido un método "mas" a la clase Numeric de donde descienden todos los números para poder sumarlos con esta otra sintaxis. Como vemos, en realidad el operador "+" es azucar sintáctico para el método ".+" de la clase Numeric. 
Pero más importante que redefinirlo, sin duda es poder extenderlo: vemos en el anterior ejemplo cómo podemos ampliar la clase Numeric con métodos que nos indiquen si el número es par o impar. 
Ruby es un lenguaje completo, maduro y estable con muchísimas más características como manejo de excepciones, recolector de basura, interacción con librerías externas, multithreading independientemente del sistema operativo, y es altamente portable (funciona en GNU/Linux, UNIX, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista, DOS, BeOS, OS/2). 
Para profundizar en el lenguaje Ruby, visita la web oficial de Ruby y echa un vistazo a la presentación que hizo Sergio Gil en la Conferencia Rails 2006, titulada Ruby Mola (y por qué).

jueves, 26 de junio de 2014

Tutorial de introducción a Ruby on Rails

Ruby on Rails es un entorno de desarrollo web de código abierto que está optimizado para satisfacción de los programadores y de la productividad. Te permite escribir un buen código favoreciendo la convención antes que la configuración. 
En este tutorial introductorio aprenderemos qué es Ruby, qué es Rails y cómo crear una aplicación de ejemplo.

lunes, 23 de junio de 2014

JAVA NATI VE INTERFACE (JNI)

JNI (Java Native Interface) es el interface de programación de Java para ejecutar código nativo, es decir código compilado al lenguaje binario propio de una plataforma o sistema de ordenador. Se incluye en el JDK las herramientas necesarias para su utilización. 

JNI permite al código de Java que se ejecuta dentro de la JVM interactuar con aplicaciones y librerías escritas en otros lenguajes, como C/C++ o incluso lenguaje ensamblador. Incorpora a su vez las herramientas para ejecutar código Java desde aplicaciones desarrolladas en otros lenguajes. El entorno JNI ofrece por lo tanto a los métodos nativos utilizar objetos de Java de igual forma que el código Java puede utilizar estos objetos nativos. Tanto la parte de Java como la parte nativa de una aplicación pueden crear, actualizar y acceder a los objetos programados en Java y compartir dichos objetos.

domingo, 22 de junio de 2014

ACCESO A BASES DE DATOS (JDBC)

JDBC (Java DataBase Connectivity) es el estándar de Java para conectarse con bases de datos. Se estima que aproximadamente la mitad del software que se crea en la actualidad incorpora operaciones de lectura y escritura con bases de datos. JDBC está diseñado para ser independiente de la plataforma e incluso de la base de datos sobra la que se desee actuar. 
Para conseguir esta independencia, JDBC ofrece un sistema estándar de interconexión con las bases de datos, muy similar al SOL (Structured Otiery Languagé). Los distintos vendedores de bases de datos crean los elementos necesarios que actúan como puente entre JDBC y la propia base de datos. La versión JDBC 1.0 forma parte del JDK 1.1. Después de distintas revisiones, actualmente ha aparecido la versión JDBC 2.0. incluida en el JDK 1.2.

sábado, 21 de junio de 2014

SEGURIDAD EN JAVA

El espacio natural de trabajo de la Informática moderna y por lo tanto del lenguaje Java son las redes de ordenadores y en especial Internet. En una red como Internet, utilizada por millones de usuarios, la seguridad adquiere una importancia vital. 
Desde su aparición Java ha ido incorporando elementos destinados a proporcionar un mayor control sobre la seguridad de los datos y programas enviados a través de una red. Los distintos JDK incorporan herramientas para añadir seguridad a las aplicaciones Java: firmas digitales, transmisión segura de datos,... Java permite establecer distintos niveles de seguridad, lo que posibilita una gran flexibilidad para asignar o denegar permisos. Existe abundante información sobre estas herramientas que el lector deberá consultar en caso necesario.

viernes, 20 de junio de 2014

RMIY JAVA IDL

Tanto RMI (Reinóte Method Invocation) como Java IDL (Java Interface Definition Language) son herramientas para desarrollar aplicaciones distribuidas. Estas aplicaciones presentan la característica de que una aplicación puede ejecutar funciones y métodos en varios ordenadores distintos. Utilizando una referencia a un objeto que se encuentra en un ordenador remoto, es posible ejecutar métodos de ese objeto desde una aplicación que se ejecuta en un ordenador distinto. RMI y Java IDL proporcionan los mecanismos mediante los cuales los distintos objetos distribuidos se comunican y se transmiten la información. Son por lo tanto tecnologías que permiten la creación y uso de objetos distribuidos, esto es, objetos o programas que interactúan en diferentes plataformas y ordenadores a través de una red. 
RMI es una solución basada íntegramente en Java. Incorpora métodos para localizar los objetos remotos, comunicarse con ellos e incluso enviar un objeto de Java, "por valor", de un objeto distribuido a otro.
Java IDL permite la conectividad entre objetos distribuidos utilizando CORBA (Common Object Request Broker Architecturé). CORBA es un estándar para la interconexión entre objetos distribuidos. Existen implementaciones de CORBA en varios lenguajes, lo que posibilita comunicar objetos realizados en distintos lenguajes como Java. C/C++. COBOL. ... 
Tanto RMI como Java IDL están incluidos en el JDK 1.2 de Sun. En el caso de Java IDL se precisa de una utilidad adicional (llamada idltojava) que genera el código necesario para comunicarse con cualquier implementación CORBA.

jueves, 19 de junio de 2014

JAVA EN EL SERVIDOR: SERVLETS

Los Servlets son módulos que permiten sustituir o utilizar el lenguaje Java en lugar de los programas CGI escritos en otros lenguajes como C/C++ o Perl. Los programas CGI son aplicaciones que se ejecutan en un servidor Web en respuesta a una acción de un browser remoto (petición de una página HTML, envío de los datos de un formulario, etc.). Permiten generar páginas HTML dinámicas, esto es. páginas HTML cuyo contenido puede variar y que por lo tanto no pueden almacenarse en un fichero en el servidor. 
Los Servlets no tienen entorno gráfico ya que se ejecutan en el servidor. Reciben unos datos y su salida o respuesta son principalmente ficheros de texto HTML. 
Los servlets son desarrollados utilizando el API Java Servlet, que es una extensión de Java que hasta la fecha no forma paite de ninguno de los JDK. Es necesario instalar el software específico de Java Servlet.

miércoles, 18 de junio de 2014

JAVA EN LA RED

A diferencia de otros lenguajes de programación. Java presenta de una forma estándar para todas las plataformas y sistemas operativos, un conjunto de clases que permiten la comunicación entre aplicaciones que se ejecutan en distintos ordenadores. 

El package java.net del API de Java incluye las clases necesarias para establecer conexiones, crear servidores, enviar y recibir datos, y para el resto de operaciones utilizadas en las comunicaciones a través de redes de ordenadores. Existen además otros APIs independientes preparados especialmente para realizar unas determinadas tareas, como son Servleís, RMI y Java IDL Muchos de estos APIs utilizan internamente las clases presentes en java.net.

martes, 17 de junio de 2014

JAVABEANS

El API de JavaBeans hace posible escribir "componentes de software" en el lenguaje Java. Los componentes son elementos reutilizables que pueden incorporarse gráficamente a otros componentes como applets y aplicaciones utilizando herramientas gráficas de desarrollo. Cada componente ofrece sus características concretas (por ejemplo sus métodos públicos y sus eventos) a los entornos gráficos de desarrollo permitiendo su manipulación visual. Son análogos a otros componentes de algunos entornos visuales, como por ejemplo los controles de Visual Basic. 
El BDK (Beans Developer Kit) es un conjunto de herramientas para desarrollar JavaBeans. Se trata de un kit no incorporado en los distintos JDK de Java.

lunes, 16 de junio de 2014

JAVA 3D

El API de Java 3D™ es un conjunto de clases para crear aplicaciones y applets con elementos 3D. Ofrece a los desabolladores la posibilidad de manipular geometrías complejas en tres dimensiones. La principal ventaja que presenta este API 3D frente a otros entornos de programación 3D es que permite crear aplicaciones gráficas 3D independientes del tipo de sistema. 

Java 3D es un conjunto de clases, interfaces y librerías de alto nivel que permiten aprovechar la aceleración gráfica por hardware que incorporan muchas tarjetas gráficas, ya que las llamadas a los métodos de Java 3D son transformadas en llamadas a funciones de OpenGL o Direct3D Aunque tanto conceptualmente como oficialmente Java 3D forma parte del API JMF, se trata de unas librerías que se instalan independientemente del JMF

domingo, 15 de junio de 2014

JAVA MEDIA FRAMEWORK (JMF)

El API JMF (Java Media FrameWork) especifica una arquitectura, un protocolo de transmisión de datos y unos elementos gráficos simples y unificados para la reproducción de contenidos multimedia, esto es vídeo, audio y animaciones, principalmente. 
Los distintos JDK aparecidos hasta la publicación de este manual no incorporan este API de JMF. Es necesario instalar un software que complementa el JDK.

sábado, 14 de junio de 2014

JAVA FOUNDATION CLASSES (JFC) Y JAVA 2D

Las JFC, Java™ Foundation Classes son un conjunto de componentes y características para ayudar a construir los entornos gráficos de los programas o GUIs (Graphical User Interfaces). Incluye prácticamente todo tipo de elementos gráficos como botones, paneles, menús y ventanas, con muchas ventajas sobre el AWT. 

Swing es una paite de las JFC que permite incorporar en las aplicaciones elementos gráficos de una forma mucho más versátil y con más capacidades que utilizando el AWT básico de Java. Algunas de las características más interesantes son: 

1. Cualquier programa que utiliza componentes de Swing puede elegir el aspecto que desea para sus ventanas y elementos gráficos: entorno Windows 95/98/NT, entorno Motif (asociado a sistemas UNIX) o Metal (aspecto propio de Java, común a todas las plataformas). 

2. Cualquier componente gráfico de Swing presenta más propiedades que el correspondiente elemento del AWT. Los botones pueden incorporan imágenes, hay nuevos layonts y paneles, menús, ...

3. Posibilidad de Drag & Drop. es decir de seleccionar componentes con el ratón y arrastrar a otro lugar de la pantalla. 

En la versión JDK 1.2 se incorpora como parte de las JFC el llamado Java 2D, que permite a los desaiiolladores incorporar texto, imágenes y gráficos en dos dimensiones de gran calidad. Además da soporte para poder imprimir documentos complejos. 
A partir de la versión 1.2 de Java las JFC forman parte del propio JDK Si se desea utilizar desde la versión 1.1 es necesario instalar las JFC de forma independiente.

viernes, 13 de junio de 2014

OTRAS CAPACIDADES DE JAVA

A lo largo de este manual se han presentado algunos de los fundamentos del lenguaje Java. Debido a que Java engloba en el propio lenguaje muchos de los conceptos de la informática moderna la inclusión de todos ellos sobrepasaría ampliamente el carácter introductorio de este manual. 
No se puede sin embargo finalizar esta introducción al lenguaje Java sin una breve descripción de algunas de las capacidades más interesantes del lenguaje.

martes, 10 de junio de 2014

Externalizable

La interface Externalizable extiende Serializable. Tiene el mismo objetivo que ésta, pero no tiene ningún comportamiento automático, todo se deja en manos del programador. Externalizable tiene dos métodos que deben implementarse.

interface Externalizable {
public void writeExternal(ObjectOutput out) throws lOException;
public void readExternal(Objectlnput in) throws lOException,
ClassNotFoundException;
}

Al transformar un objeto, el método writeExternal() es responsable de todo lo que se hace. Sólo se guardará lo que dentro de éste método se indique. 
El método readExternal() debe ser capaz de recuperar lo guardado por writeExternal(). La lectura debe ser en el mismo orden que la escritura. Es importante saber que antes de llamar a este método se llama al constructor por defecto de la clase. 
Como se ve el comportamiento de Externalizable es muy similar al de Serializable.

lunes, 9 de junio de 2014

Control (le la serialización

Aunque lo mejor de la serialización es que su comportamiento automático es bueno y sencillo, existe la posibilidad de especificar cómo se deben hacer las cosas. 
La palabra clave transient permite indicar que un objeto o varible miembro no sea señalizado con el resto del objeto. Al recuperarlo, lo que esté marcado como transient será (). nuil o false (en esta operación no se llama a ningún constructor) hasta que se le dé un nuevo valor. Podría ser el caso de un password que no se quiere guardar por seguridad. 
Las variables y objetos static no son señalizados. Si se quieren incluir hay que escribir el código que lo haga. Por ejemplo, habrá que programar un método que señalice los objetos estáticos al que se llamará después de serializar el resto de los elementos. También habría que recuperarlos explícitamente después de recuperar el resto de los objetos. 
Las clases que implementan Serializable pueden definir dos métodos con los que controlar la serialización. No están obligadas a hacerlo porque una clase sin estos métodos obtiene directamente el comportamiento por defecto. Si los define serán los que se utilicen al serializar:.


private void writeObject(ObjectOutputStream stream) throws lOException
prívate void readObject(ObjectlnputStream stream) throws lOException

El primero permite indicar qué se escribe o añadir otras instrucciones al comportamiento por defecto. El segundo debe poder leer lo que escribe writeObject() Puede usarse por ejemplo para poner al día las variables que lo necesiten al ser recuperado un objeto. Hay que leer en el mismo orden en que se escribieron los objetos.
Se puede obtener el comportamiento por defecto dentro de estos métodos llamando a stream.defauítWriteObject() y streani. def auItReadObject(}. 
Para guardar explícitamente los tipos primitivos se puede utilizar los métodos que proporcionan ObjectlnputStream y ObjectOutputStream. idénticos a los de DatalnputStream y DataOutputStream (>vritelnt(). readDouble(), ...) o guardar objetos de sus clases equivalentes (Integer. Double...). 
Por ejemplo, si en una clase llamada Tierra se necesita que al serializar un objeto siempre le acompañe la constante g (9.8) definida como static el código podría ser:

static double g = 9.8;
prívate void writeObject(ObjectOutputStream stream) throws lOException {
stream.defaultWriteObject();
stream.writeDouble(g);
}
private void readObject(ObjectlnputStream stream) throws lOException {
stream.defaultReadObject() ;
g = stream.readDouble(g);
}

domingo, 8 de junio de 2014

SERIALIZACIÓN

La serialización es un proceso por el que un objeto cualquiera se puede convertir en una secuencia de bytes con la que más tarde se podrá reconstruir dicho objeto manteniendo el valor de sus variables. Esto permite guardar un objeto en un archivo o mandarlo por la red. 

Para que una clase pueda utilizar la serialización. debe implementar la interface Serializable. que no define ningún método. Casi todas las clases estándar de Java son seríalizables. La clase MiClase se podría señalizar declarándola como:

public class MiClase implements Serializable { }

Para escribir y leer objetos se utilizan las clases ObjectlnputStream y ObjectOutputStream. que cuentan con los métodos wríteObject() y reaclObject(). Por ejemplo:

ObjectOutputStream objout = new ObjectOutputStream(
new FileOutputStream("archivo.x"));
String s = new StringC'Me van a serializar");
objout.writeObject(s);

ObjectlnputStream objin = new ObjectlnputStream(new FilelnputStream("archivo.x"));
String s2 = (String)objin.readobject(); Es importante tener en cuenta que readObject() devuelve un Object sobre el que se deberá hacer un casting para que el objeto sea útil. La reconstrucción necesita que el archivo *.class esté al alcance del programa (como mínimo para hacer este casting). 
Al serializar un objeto, automáticamente se señalizan todas sus variables y objetos miembro. A su vez se señalizan los que estos objetos miembro puedan tener (todos deben ser serializables). También se reconstruyen de igual manera. Si se señaliza un lector que contiene varios Strlngs. todo ello se convierte en una serie de bytes. Al recuperarlo la reconstrucción deja todo en el lugar en que se guardó. 
Si dos objetos contienen una referencia a otro, éste 110 se duplica si se escriben o leen ambos del mismo stream. Es decir, si el mismo String esmviera contenido dos veces en el Vector, sólo se guardaría una vez y al recuperarlo sólo se crearía un objeto con dos referencias contenidas en el vector.

sábado, 7 de junio de 2014

Archivos que uo sou de texto

DatalnputStream y DataOutputStream son clases de Java 1.0 que un lian sido alteradas hasta ahora. 
Para leer y escribir datos primitivos directamente (sin convertir a/de String) siguen siendo más útiles estas dos clases. Son clases diseñadas para trabajar de manera conjunta. Una puede leer lo que la otra escribe, que en sí no es algo legible, sino el dato como una secuencia de bytes. Por ello se utilizan para almacenar datos de manera independiente de la plataforma (o para mandarlos por una red entre ordenadores muy distintos). El problema es que obligan a utilizar clases que descienden de InpntStream y OutputStream y por lo tanto algo más complicadas de utilizar. El siguiente código primero escribe en el fichero prueba.dat para después leer los datos escritos:

// Escritura de una variable double
DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("prueba.dat"))) ;
double di = 17/7;
dos.writeDouble(d);
dos.cióse();
// Lectura de la variable double
DatalnputStream dis = new DatalnputStream(
new Bufferedlnputstream(
new FilelnputStream("prueba.dat")));
double d2 = dis.readDouble();

viernes, 6 de junio de 2014

Escritura de archivos de texto

La clase PrintWriter es la más práctica para escribir un archivo de texto porque posee los métodos />ri«í(cualquier tipo) y />r?7rf/n(cualquier tipo), idénticos a los de System.out (de clase PrintStream). 

Un objeto PrintWriter se puede crear a partir de un BufferedWriter (para disponer de buffer), que se crea a partir del FileWriter al que se la pasa el nombre del archivo. Después, escribir en el archivo es tan fácil como en pantalla. El siguiente ejemplo ilustra lo anterior:

try {
FileWriter fw = new FileWriter("escribeme.txt");
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter salida = new PrintWriter(bw);
salida.println("Hola, soy la primera linea");
salida.cióse ();
// Modo append
bw = new BufferedWriter(new FileWriter("escribeme.txt", true));
salida = new PrintWriter(bw);
salida.print("Y yo soy la segunda. ");
double b = 123.45;
salida.println(b);
salida.cióse();
}
cacth(java.io.IOException idex) { }

jueves, 5 de junio de 2014

Lectura ele archivos de texto

Se puede crear un objeto BufferedReader para leer de un archivo de texto de la siguiente manera:

BufferedReader br = new BufferedReader(new FileReader("archivo.txt"));

Utilizando el objeto de tipo BufferedReader se puede conseguir exactamente lo mismo que en las secciones anteriores utilizando el método readLine() y la clase StringTokenizer. En el caso de archivos es muy importante utilizar el buffer puesto que la tarea de escribir en disco es muy lenta respecto a los procesos del programa y realizar las operaciones de lectura de golpe y una de una en lina hace mucho más eficiente el acceso. Por ejemplo:

// Lee un archivo entero de la misma manera que de teclado
String texto = new String();
try {
FileReader fr = new FileReader("archivo.txt");
entrada = new BufferedReader(fr);
String s;
while((s = entrada.readLine()) != nuil)
texto += s;
entrada.cióse();
}
catch(java.io.FileNotFoundException fnfex) {

System.out.println("Archivo no encontrado: " + fnfex);}
catch(java.io.IOException ioex) {}

martes, 3 de junio de 2014

LECTURA DE UN ARCHIVO EN UN SERVIDOR DE INTERNET

Teniendo la dilección de Internet de un archivo, la librería de Java permite leer este archivo utilizando 1111 stream. Es una aplicación muy sencilla que muestra la polivalencia del concepto de stream. 
En el package java.net existe la clase URL. que representa una dirección de Internet. Esta clase tiene el método InputStream openStream(URL dir) que abre un stream con origen en la dirección de Internet. A partir de ahí. se trata como cualquier elemento InputStream. 
Por ejemplo: //Lectura del archivo (texto HTML) URL dirección = new URL("http://wwwl.ceit.es/subdir/MiPagina.htm");

String s = new String();
String html = new String();
try {
BufferedReader br = new BufferedReader(
new InputStreamReader(
dirección.openStream()));
while((s = br.readLine()) != nuil)
html += s + '\n1;
br.close ();
}
catch(Exception e) {
System.err.println (e);
}

Clases File y FileDialog - II

Una forma típica de preguntar por un archivo es presentar un caja de diálogo. La clase java.awt.FileDialog presenta el diálogo típico de cada sistema operativo para guardar o abrir ficheros. Sus constructores son:

FileDialog(Frame fr)
FileDialog(Frame fr, String title)

FileDialog(Frame fr, String title, int type)


donde type puede ser FileDialog.LOAD o FileDialog.SAVE según la operación que se desee realizar. Es muy fácil conectar este diálogo con un Fitf. utilizando los métodos String getFi!e() y String getDirectoryO. Por ejemplo:

FileDialog fd = new FileDialog(f, "Elija un archivo");
fd.show();
File f = new File(fd.getDirectory(), fd.getFile());

lunes, 2 de junio de 2014

Clases File y FileDialog - I

Un objeto de la clase File puede representar un archivo o un directorio. Tiene los siguientes constructores:

File(String name)
File(String dir, String name)

File(File dir, String name).


Se puede dar el nombre de un archivo, el nombre y el directorio, o sólo el directorio, como path absoluto y como path relativo al directorio actual. Para saber si el archivo existe se puede llamar al método boolean exists().

File fl = new File ("c: WwindowsWnotepad.exe"); // La barra *\' se escribe
File f2 = new File("c:\\windows");    // Un directorio
File f3 = new File(f2, "notepad.exe");  // Es igual a fl


Si File representa un archivo que existe los métodos de la Tabla 9.6 dan información de él.

domingo, 1 de junio de 2014

LECTURA Y ESCRITURA DE ARCHIVOS

Aunque el manejo de archivos tiene características especiales, se puede utilizar lo dicho hasta ahora para las entradas y salidas estándar con pequeñas variaciones. Java ofrece las siguientes posibilidades: 

Existen las clases FileInputStream\ y FileOutputStream (extendiendo InputStream y OutputStream) que permiten leer y escribir bytes en archivos. Para archivos de texto son preferibles FileReader (desciende de Reader) y FileWriter (desciende de Writer). que realizan las mismas funciones. Se puede construir un objeto de cualquiera de estas cuatro clases a partir de un Stríng que contenga el nombre o la dirección en disco del archivo o con un objeto de la clase File que representa dicho archivo. Por ejemplo el código

FileReader frl = new FileReader("archivo.txt");


es equivalente a:
File f = new File("archivo.txt"); 
FileReader fx2 = new FileReader(f); 

Si no encuentran el archivo indicado, los constructores de FileReader y FilelnputStream pueden lanzar la excepción java.io.FileNotFoundException. Los constructores de FileWriter y FileOutputStream pueden lanzar java. io.IOExeeption. Si no encuentran el archivo indicado, lo crean nuevo. Por defecto, estas dos clases comienzan a escribir al comienzo del archivo. Para escribir detrás de lo que ya existe en el archivo ("append*'), se utiliza un segundo argumento de tipo boolean con valor true\ 

FileWriter fw = new FileWriter("archivo.txt", true);
Las clases que se explican a continuación permiten un manejo más fácil y eficiente que las vistas hasta ahora.