0 comentarios

Tecnología de Informacion

Actualmente la Tecnología de Información más conocida como la “TI” es “el estudio, diseño, desarrollo, puesta en práctica, ayuda o gerencia de los sistemas informáticos computarizados. Esta tecnología de información se ha expandido asociándose con las computadoras y las tecnologías a fines aplicadas a la toma de decisiones de las personas cambiando la forma tradicional de hacer las cosas.



COBIT
Control Objetives for Information and related technology
CObIT es una herramienta que permite a los gerentes comunicarse y salvar la brecha existente entre los requerimientos de control, aspectos técnicos y riesgos de negocio.
CObIT habilita el desarrollo de una política clara y de buenas prácticas de control de TI a través de organizaciones, a nivel mundial. El objetivo de CObIT es proporcionar estos objetivos de control, dentro del marco referencial definido, y obtener la aprobación y el apoyo de las entidades comerciales, gubernamentales y profesionales en todo el mundo.
Cobit ha tenido varias ediciones, siendo publicada la primera en 1996; la segunda edicion en 1998; la tercera edicion en 2000(edicion on-line estuvo disponible en 2003); y la cuarta edición en Diciembre de 2005, y la versión 4.1 esta disponible desde Mayo de 2007.

Descargar aqui
http://rapidshare.com/files/268577052/tecnologia_de_informacion.docx.html
read more
4 comentarios

RMI Chat

RMI es un mecanismo ofrecido por Java para invocar un método de manera remota. Forma parte del entorno estándar de ejecución de Java y provee de un mecanismo simple para la comunicación de servidores en aplicaciones distribuidas basadas exclusivamente en Java

Codigo de Servidor- Cliente

RmiServidor.java


import java.net.InetAddress;
import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.*;
import javax.swing.JFrame;

public class RmiServidor extends UnicastRemoteObject implements InterfazReceptorMensajes {
private static GUIServidor ventana;
private int estePuerto;
private String estaIP;
private Registry registro;

public RmiServidor() throws RemoteException {
try {
// obtener la direccion de este host.
estaIP = (InetAddress.getLocalHost()).toString();
} catch (Exception e) {
throw new RemoteException("No se puede obtener la direccion IP.");
}
estePuerto = 3232; // asignar el puerto que se registra
ventana.anadirEntradas("Conexion establecida por...\nEsta direccion=" + estaIP + ", y puerto=" + estePuerto);
try {
// crear el registro y ligar el nombre y objeto.

registro = LocateRegistry.createRegistry(estePuerto);
registro.rebind("rmiServidor", this);
} catch (RemoteException e) {
throw e;
}}

public void recibirMensaje(String texto) throws RemoteException {
ventana.anadirEntradas(texto);
}

public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
ventana = new GUIServidor();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try {
new RmiServidor();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
}

RmiCliente.java

import java.rmi.*;
import java.rmi.registry.*;
import javax.swing.*;

import java.awt.*;
import java.awt.event.*;


public class RmiCliente extends JFrame implements ActionListener {
private JTextField cajaEnviar;

private JButton botonEnviar;

private JLabel estado;

private static InterfazReceptorMensajes rmiServidor;

private static Registry registro;

private static String direccionServidor = "192.168.100.1";

private static String puertoServidor = "3232";

public RmiCliente() {
super("Cliente RMI");
getContentPane().setLayout(new BorderLayout());
cajaEnviar = new JTextField();
cajaEnviar.addActionListener(this);
botonEnviar = new JButton("Enviar");
botonEnviar.addActionListener(this);
estado = new JLabel("Estado...");

getContentPane().add(cajaEnviar);
getContentPane().add(botonEnviar, BorderLayout.EAST);
getContentPane().add(estado, BorderLayout.SOUTH);

setSize(300, 100);
setVisible(true);
}

public void actionPerformed(ActionEvent e) {
if (!cajaEnviar.getText().equals("")) {
enviarMensaje(cajaEnviar.getText());
cajaEnviar.setText("");
}
}

private static void conectarseAlServidor() {
try {
// obtener el registro
registro = LocateRegistry.getRegistry(direccionServidor,
(new Integer(puertoServidor)).intValue());
// creando el objeto remoto
rmiServidor = (InterfazReceptorMensajes) (registro
.lookup("rmiServidor"));
} catch (RemoteException e) {
e.printStackTrace();
} catch (NotBoundException e) {
e.printStackTrace();
}
}

private void enviarMensaje(String mensaje) {
estado.setText("Enviando " + mensaje + " a " + direccionServidor + ":"
+ puertoServidor);
try {
// llamando el metodo remoto
rmiServidor.recibirMensaje(mensaje);
estado.setText("El mensaje se ha enviado!!!");
} catch (RemoteException re) {
re.printStackTrace();
}
}

static public void main(String args[]) {
JFrame.setDefaultLookAndFeelDecorated(true);
conectarseAlServidor();
RmiCliente ventana = new RmiCliente();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
read more
0 comentarios

UDP Chat

UDP son las siglas de Protocolo de Datagrama de Usuario es un protocolo no orientado a conexión de la capa de transporte del modeloTCP/IP.

En la familia de protocolos de Internet. UDP proporciona una sencilla interfaz entre la capa de red y la capa de aplicación. UDP no otorga garantías para la entrega de sus mensajes y el origen UDP no retiene estados de los mensajes UDP que han sido enviados a la red. UDP.

Codigo Servidor - Cliente
Servidor.java

// Servidor que recibe y envía paquetes de/a un cliente.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Servidor extends JFrame {
private JTextArea areaPantalla;
private DatagramSocket socket;

// configurar GUI y DatagramSocket
public Servidor()
{
super( "Servidor" );

areaPantalla = new JTextArea();
getContentPane().add( new JScrollPane( areaPantalla ),
BorderLayout.CENTER );
setSize( 400, 300 );
setVisible( true );

// crear objeto DatagramSocket para enviar y recibir paquetes
try {
socket = new DatagramSocket( 5000 );
}

// procesar los problemas que pueden ocurrir al crear el objeto DatagramSocket
catch( SocketException excepcionSocket ) {
excepcionSocket.printStackTrace();
System.exit( 1 );
}

} // fin del constructor de Servidor

// esperar a que lleguen los paquetes, mostrar los datos y repetir el paquete al cliente
private void esperarPaquetes()
{
while ( true ) { // iterar infinitamente

// recibir paquete, mostrar su contenido, devolver copia al cliente
try {

// establecer el paquete
byte datos[] = new byte[ 100 ];
DatagramPacket recibirPaquete =
new DatagramPacket( datos, datos.length );

socket.receive( recibirPaquete ); // esperar el paquete

// mostrar la información del paquete recibido
mostrarMensaje( "\nPaquete recibido:" +
"\nDel host: " + recibirPaquete.getAddress() +
"\nPuerto del host: " + recibirPaquete.getPort() +
"\nLongitud: " + recibirPaquete.getLength() +
"\nContenido:\n\t" + new String( recibirPaquete.getData(),
0, recibirPaquete.getLength() ) );

enviarPaqueteACliente( recibirPaquete ); // enviar paquete al cliente
}

// procesar los problemas que pueden ocurrir al manipular el paquete
catch( IOException excepcionES ) {
mostrarMensaje( excepcionES.toString() + "\n" );
excepcionES.printStackTrace();
}

} // fin de instrucción while

} // fin del método esperarPaquetes

// repetir el paquete al cliente
private void enviarPaqueteACliente( DatagramPacket recibirPaquete )
throws IOException
{
mostrarMensaje( "\n\nRepitiendo datos al cliente..." );

// crear paquete a enviar
DatagramPacket enviarPaquete = new DatagramPacket(
recibirPaquete.getData(), recibirPaquete.getLength(),
recibirPaquete.getAddress(), recibirPaquete.getPort() );

socket.send( enviarPaquete ); // enviar el paquete
mostrarMensaje( "Paquete enviado\n" );
}

// método utilitario que es llamado desde otros subprocesos para manipular a
// areaPantalla en el subproceso despachador de eventos
private void mostrarMensaje( final String mensajeAMostrar )
{
// mostrar el mensaje del subproceso de ejecución despachador de eventos
SwingUtilities.invokeLater(
new Runnable() { // clase interna para asegurar que la GUI se actualice apropiadamente

public void run() // actualiza areaPantalla
{
areaPantalla.append( mensajeAMostrar );
areaPantalla.setCaretPosition(
areaPantalla.getText().length() );
}

} // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater
}

public static void main( String args[] )
{
JFrame.setDefaultLookAndFeelDecorated(true);
Servidor aplicacion = new Servidor();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
aplicacion.esperarPaquetes();
}

}

Cliente.java
// Cliente que envía y recibe paquetes a/de un servidor.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Cliente extends JFrame {
private JTextField campoIntroducir;
private JTextArea areaPantalla;
private DatagramSocket socket;

// configurar GUI y DatagramSocket
public Cliente()
{
super( "Cliente" );

Container contenedor = getContentPane();

campoIntroducir = new JTextField( "Escriba aquí el mensaje" );
campoIntroducir.addActionListener(
new ActionListener() {
public void actionPerformed( ActionEvent evento )
{
// crear y enviar el paquete
try {
areaPantalla.append( "\nEnviando paquete que contiene: " +
evento.getActionCommand() + "\n" );

// obtener mensaje del campo de texto y convertirlo en arreglo byte
String mensaje = evento.getActionCommand();
byte datos[] = mensaje.getBytes();

// crear enviarPaquete
DatagramPacket enviarPaquete = new DatagramPacket( datos,
datos.length, InetAddress.getLocalHost(), 5000 );

socket.send( enviarPaquete ); // enviar paquete
areaPantalla.append( "Paquete enviado\n" );
areaPantalla.setCaretPosition(
areaPantalla.getText().length() );
}

// procesar los problemas que pueden ocurrir al crear o enviar el paquete
catch ( IOException excepcionES ) {
mostrarMensaje( excepcionES.toString() + "\n" );
excepcionES.printStackTrace();
}

} // fin de actionPerformed

} // fin de la clase interna

); // fin de la llamada a addActionListener

contenedor.add( campoIntroducir, BorderLayout.NORTH );

areaPantalla = new JTextArea();
contenedor.add( new JScrollPane( areaPantalla ),
BorderLayout.CENTER );

setSize( 400, 300 );
setVisible( true );

// crear objeto DatagramSocket para enviar y recibir paquetes
try {
socket = new DatagramSocket();
}

// atrapar los problemas que pueden ocurrir al crear objeto DatagramSocket
catch( SocketException excepcionSocket ) {
excepcionSocket.printStackTrace();
System.exit( 1 );
}

} // fin del constructor de Cliente

// esperar a que lleguen los paquetes del Servidor, mostrar el contenido de los paquetes
private void esperarPaquetes()
{
while ( true ) { // iterar infinitamente

// recibir el paquete y mostrar su contenido
try {

// establecer el paquete
byte datos[] = new byte[ 100 ];
DatagramPacket recibirPaquete = new DatagramPacket(
datos, datos.length );

socket.receive( recibirPaquete ); // esperar un paquete

// mostrar el contenido del paquete
mostrarMensaje( "\nPaquete recibido:" +
"\nDel host: " + recibirPaquete.getAddress() +
"\nPuerto del host: " + recibirPaquete.getPort() +
"\nLongitud: " + recibirPaquete.getLength() +
"\nContenido:\n\t" + new String( recibirPaquete.getData(),
0, recibirPaquete.getLength() ) );
}

// procesar los problemas que pueden ocurrir al recibir o mostrar el paquete
catch( IOException excepcion ) {
mostrarMensaje( excepcion.toString() + "\n" );
excepcion.printStackTrace();
}

} // fin de instrucción while

} // fin del método esperarPaquetes

// método utilitario que es llamado desde otros subprocesos para manipular a
// areaPantalla en el subproceso despachador de eventos
private void mostrarMensaje( final String mensajeAMostrar )
{
// mostrar mensaje del subproceso de ejecución despachador de eventos
SwingUtilities.invokeLater(
new Runnable() { // clase interna para asegurar que la GUI se actualice apropiadamente

public void run() // actualiza areaPantalla
{
areaPantalla.append( mensajeAMostrar );
areaPantalla.setCaretPosition(
areaPantalla.getText().length() );
}

} // fin de la clase interna

); // fin de la llamada a SwingUtilities.invokeLater
}

public static void main( String args[] )
{
JFrame.setDefaultLookAndFeelDecorated(true);
Cliente aplicacion = new Cliente();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
aplicacion.esperarPaquetes();
}

}
read more
0 comentarios

BASE DE DATOS CON JAVA PARTE 2

ejemplo 2103
import java.io.*;
import java.net.*;
import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class java2103 extends Applet {
static final int puerto = 6700;
String cadConsulta = "No hay consulta todavia";
String cadResultado = "No hay resultados";
Button boton;
TextArea texto;
List lista;

public void init() {
setLayout( new GridLayout( 5,1 ) );
texto = new TextArea( 20,40 );
lista = new List();
boton = new Button( "Ejecutar Consulta" );
boton.addActionListener( new MiActionListener() );

add( new Label( "Escribir la consulta aqui..." ) );
add( texto );
add( boton );
add( new Label( "y examinar los resultados aqui" ) );
add( lista );

resize( 800,800 );
}

void abreSocket() {
Socket s = null;
try {
s = new Socket( getCodeBase().getHost(),puerto );
BufferedReader sinstream =
new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintStream soutstream = new PrintStream( s.getOutputStream() );

soutstream.println( texto.getText() );
lista.removeAll();
cadResultado = sinstream.readLine();
while( cadResultado != null ) {
lista.add( cadResultado );
cadResultado = sinstream.readLine();
}
} catch( IOException e ) {
System.err.println( e );
} finally {
try {
if( s != null )
s.close();}
catch( IOException e ) {}
}
}


class MiActionListener implements ActionListener {
public void actionPerformed( ActionEvent evt ) {
abreSocket();
}
}
}

ejemplo 2104
import java.net.URL;
import java.awt.*;
import java.sql.*;
import java.awt.event.*;

public class java2104 extends Frame implements MouseListener {

Button botConexion = new Button( " Conexión a la Base de Datos " );
Button botConsulta = new Button( " Ejecutar Consulta " );

TextField txfConsulta = new TextField( 40 );
TextArea txaSalida = new TextArea( 10,75 );
TextField txfUsuario = new TextField( 40 );
TextField txfClave = new TextField( 40 );
TextField txfUrl = new TextField( 40 );
String strUrl = "";
String strUsuario = "";
String strClave = "";
// El objeto Connection es parte del API de JDBC, y debe ser lo
// con la Base de Datos
Connection con;

public static void main( String args[] ) {
java2104 ventana = new java2104();

// Se recoge el evento de cierre de la ventana
ventana.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent evt ) {
System.exit( 0 );
}
} );

ventana.setSize( 450,300 );
ventana.setTitle( "Tutorial de Java, JDBC" );
ventana.pack();
ventana.setVisible( true );
}

public java2104() {

txfConsulta.setEditable( true );
txfUsuario.setEditable( true );
txfUrl.setEditable( true );
txaSalida.setEditable( false );

GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints gbCon = new GridBagConstraints();

setLayout( gridbag );

setFont( new Font( "Helvetica",Font.PLAIN,12 ) );
setBackground( Color.orange );

gbCon.weightx = 1.0;
gbCon.weighty = 0.0;
gbCon.anchor = GridBagConstraints.CENTER;
gbCon.fill = GridBagConstraints.NONE;
gbCon.gridwidth = GridBagConstraints.REMAINDER;
add( new Label( "Usuario" ) );
gridbag.setConstraints( txfUsuario,gbCon );
add( txfUsuario );
add( new Label( "Clave de Acceso" ) );
gridbag.setConstraints( txfClave,gbCon );
add( txfClave );
add( new Label( "URL de la Base de Datos" ) );
gridbag.setConstraints( txfUrl,gbCon );
add( txfUrl );
// Ahora viene la fila en que está el botón de Conexión a la
// base de datos, fijamos los constraints para que eso sea así
// y lo añadimos
gridbag.setConstraints( botConexion,gbCon );
add( botConexion );

botConexion.addMouseListener( this );

// su envío al driver JDBC
add( new Label( "Consulta SQL" ) );
gridbag.setConstraints( txfConsulta,gbCon );
add( txfConsulta );
gridbag.setConstraints( botConsulta,gbCon );
add( botConsulta );
botConsulta.addMouseListener( this );

Label labResultado = new Label( "Resultado" );
labResultado.setFont( new Font( "Helvetica",Font.PLAIN,16 ) );
labResultado.setForeground( Color.blue );
gridbag.setConstraints( labResultado,gbCon );
gbCon.weighty = 1.0;
add( labResultado );

gridbag.setConstraints( txaSalida,gbCon );
txaSalida.setForeground( Color.white );
txaSalida.setBackground( Color.black );
add( txaSalida );
}


public void mouseClicked( MouseEvent evt ) {

if( evt.getComponent() == botConsulta ) {
System.out.println( txfConsulta.getText() );
txaSalida.setText( Select( txfConsulta.getText() ) );
}

if( evt.getComponent() == botConexion ) {
// Se fijan las variables globales de usaurio, clave y url a
// los valores que se hayan introducido en los campos
strUsuario = txfUsuario.getText();
strClave = txfClave.getText();
strUrl = txfUrl.getText();


try {

Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
// La conexión aquí se realiza indicando la URL de la base de
// datos y el usuario y clave que dan acceso a ella
con = DriverManager.getConnection( strUrl,strUsuario,strClave );
// Si la conexión ha sido satisfactoria, cambiamos el rótulo
// del botón de conexión, para que indique que si se pulsa lo
// que se realiza será la "Reconexión"
botConexion.setLabel( "Reconexión a la Base de Datos" );
txaSalida.setText( "Conexion establecida con "+strUrl );
} catch( Exception e ) {
// Se presenta la información correspondiente al error, tanto
// en la consola como en la zona de salida de la ventana
e.printStackTrace();
txaSalida.setText( e.getMessage() );
}
}
}
public void mouseEntered( MouseEvent evt ) {}
public void mouseExited( MouseEvent evt ) {}
public void mousePressed( MouseEvent evt ) {}
public void mouseReleased( MouseEvent evt ) {}

// Este es el método que realiza la consulta
public String Select( String consulta ) {
String resultado="";
int cols;
int pos;

try {
// En primer lugar, se instancia la clase Statement, que es

Statement sentencia = con.createStatement();

ResultSet rs = sentencia.executeQuery( consulta );

cols = ( rs.getMetaData() ).getColumnCount();

while( rs.next() ) {
// Se recorre ahora cada una de las columnas de la fila, es
// decir, cada celda, una a una
for( pos=1; pos <= cols; pos++ ) {
// Este es el método general para obetener un resultado. el

resultado += rs.getString( pos )+" ";
}

// Para cada fila que se revise, se le añade un retorno de
// carro, para que la siguiente fila empiece en otra línea
resultado += "\n";
}

sentencia.close();
} catch( Exception e ) {
e.printStackTrace();
resultado = e.getMessage();
}

return resultado;
}
}
read more
0 comentarios

BASE DE DATOS CON JAVA PARTE 1

Una base de datos es una serie de tablas que contienen información ordenada en alguna estructura que facilita el acceso a esas tablas, ordenarlas y seleccionar filas de las tablas según criterios específicos. Las bases de datos generalmente tienen índices asociados a alguna de sus columnas, de forma que el acceso sea lo más rápido posible.

EJEMPLOS:
ejemplo 2101

import java.sql.*;

class java2101 {
static public void main( String[] args ) {
Connection conexion;
Statement sentencia;
ResultSet resultado;
System.out.println( "Iniciando programa." );
// Se carga el driver JDBC-ODBC
try {
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
} catch( Exception e ) {
System.out.println( "No se pudo cargar el puente JDBC-ODBC." );
return;
}
try {
// Se establece la conexión con la base de datos
conexion = DriverManager.getConnection( "jdbc:odbc:Tutorial","","" );
sentencia = conexion.createStatement();
try {
// Se elimina la tabla en caso de que ya existiese
sentencia.execute( "DROP TABLE AMIGOS" );
} catch( SQLException e ) {};

// Esto es código SQL
sentencia.execute( "CREATE TABLE AMIGOS ("+
" NOMBRE VARCHAR(15) NOT NULL, " +
" APELLIDOS VARCHAR(30) NOT NULL, " +
" CUMPLE DATETIME) " );
sentencia.execute( "INSERT INTO AMIGOS " +
"VALUES('JOSE','GONZALEZ','03/15/1973')" );
sentencia.execute( "INSERT INTO AMIGOS " +
"VALUES('PEDRO','GOMEZ','08/15/1961')" );
sentencia.execute( "INSERT INTO AMIGOS " +
"VALUES('GONZALO','PEREZ', NULL)" );
} catch( Exception e ) {
System.out.println( e );
return;
}
System.out.println( "Creacion finalizada." );
}
}

ejemplo 2102

import java.io.*;
import java.net.*;
import java.util.*;
import java.sql.*;

public class java2102 extends Thread {
public static final int PUERTO = 6700;
ServerSocket socketEscucha;

public java2102() {
try {
socketEscucha = new ServerSocket( PUERTO );
} catch( IOException e ) {
System.err.println( e );
}
this.start();
}

public void run() {
try {
while( true ) {
Socket socketCliente = socketEscucha.accept();
SQLConexion c = new SQLConexion( socketCliente );
}
} catch( IOException e ) {
System.err.println( e );
}
}

public static void main( String[] argv ) {
new java2102();
}
}


class SQLConexion extends Thread {
protected Socket cliente;
protected BufferedReader in;
protected PrintStream out;
protected String consulta;

public SQLConexion( Socket socketCliente ) {
cliente = socketCliente;
try {
in = new BufferedReader( new InputStreamReader( cliente.getInputStream() ) );
out = new PrintStream( cliente.getOutputStream() );
} catch( IOException e ) {
System.err.println( e );
try {
cliente.close();
} catch( IOException e2 ) {};
return;
}
this.start();
}

public void run() {
try {
consulta = in.readLine();
System.out.println( "Lee la consulta <" + consulta + ">" );
ejecutaSQL();
} catch( IOException e ) {}
finally {
try {
cliente.close();
} catch( IOException e ) {};
}
}

public void ejecutaSQL() {
Connection conexion; // Objeto de conexión a la base de datos
Statement sentencia; // Objeto con la sentencia SQL
ResultSet resultado; // Objeto con el resultado de la consulta SQL
ResultSetMetaData resultadoMeta;
boolean mas; // Indicador de si hay más filas
String driver = "jdbc:odbc:Tutorial";
String usuario = "";
String clave = "";
String registro;
int numCols, i;

try {
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
conexion = DriverManager.getConnection( driver,usuario,clave );

sentencia = conexion.createStatement();
resultado = sentencia.executeQuery( consulta );

mas = resultado.next();
if( !mas ) {
out.println( "No hay mas filas." );
return;
}

resultadoMeta = resultado.getMetaData();
numCols = resultadoMeta.getColumnCount();
System.out.println( numCols + " columnas en el resultado.");
while( mas ) {
// Se construye la cadena de respuesta
registro = "";
for( i=1; i <= numCols; i++ ) {
registro = registro.concat( resultado.getString(i)+" " );
}
out.println( registro );
System.out.println( registro );
mas = resultado.next();
}

resultado.close();
sentencia.close();
conexion.commit();
conexion.close();
} catch( Exception e ) {
System.out.println( e.toString() );
}
}
}
read more
0 comentarios

SMTP

(Simple Mail Transfer Protocol) protocolo simple de transferencia de correo, es el protocolo que se utiliza para que dos servidores de correo intercambien mensajes, usa normalmente el puerto 25 en el servidor para establecer la conexión.
Un cliente SMTP se contacta con el servidor SMTP del host destino para entregarle directamente el correo, este nos da seguridad en al entrega al receptor ya que espera que sea guardado con éxito.

Herramienta a utilizar:


-QK SMTP

- Librerias :
*Para descargar el API JavaMail, http://java.sun.com/products/javamail/downloads/index.html
*Para descargar JAF Activation, http://java.sun.com/products/javabeans/glasgow/jaf.html

Compilación
javac JavaMailSamples.java
java JavaMailSamples

Codigo
import javax.activation.*;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Properties;

public class JavaMailSamples
{
public static void main(String[] args)
{
SendAuthentication.Send();
}
}
class SendAuthentication
{
public static void Send()
{
String host ="192.168.1.33";//Suponiendo que el servidor SMTPsea la propia máquina
String from ="locas@brujas.com";
String to = "lu-lucy20@hotmail.com";

System.out.println ("Prueba para enviar un mail..." + new java.util.Date());
Properties prop = new Properties();
prop.put("mail.smtp.host", host);
/*Esta línea es la que indica al API que debe autenticarse*/
prop.put("mail.smtp.auth", "true");
/*Añadir esta linea si queremos ver una salida detallada del programa*/
//prop.put("mail.debug", "true");
try{
SMTPAuthentication auth = new SMTPAuthentication();
Session session = Session.getInstance(prop , auth );
Message msg = getMessage(session, from, to);
System.out.println ("Enviando ..." );
Transport.send(msg);
System.out.println ("Mensaje enviado ok!");
}
catch (Exception e)
{
ExceptionManager.ManageException(e);
}
}
private static MimeMessage getMessage(Session session, String from, String to)
{
try{
MimeMessage msg = new MimeMessage(session);
msg.setText("El mail desde java. Este mensaje a utilizado autenticacion en el servidor.");
msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
msg.setFrom(new InternetAddress(from,"JavaMail en accion"));
return msg;
}
catch (java.io.UnsupportedEncodingException ex)
{
ExceptionManager.ManageException(ex);
return null;
}
catch (MessagingException ex)
{
ExceptionManager.ManageException(ex);
return null;
}
}
}
class SMTPAuthentication extends javax.mail.Authenticator
{
public PasswordAuthentication getPasswordAuthentication()
{
String username = "locas@brujas.com";
String password = "123456";
return new PasswordAuthentication(username, password);
}
}
class ExceptionManager
{
public static void ManageException (Exception e)
{
System.out.println ("Se ha producido una exception");
System.out.println (e.getMessage());
e.printStackTrace(System.out);
}
}
read more
0 comentarios

SOKETS CHAT

cliente.java

aplicacion cliente del chat simple desarrollado en java.
compilar con :
javac cliente.java
ejecutar con :
java cliente [direccion ip o nombre del equipo servidor]
***********************************************************************/

// Librerias Necesarias
import java.awt.*; // modo grafico
import java.io.*; // entrada/salida
import java.net.*; // funciones de red

public class cliente extends Frame {

// elementos de la ventana
static Button enviar = new Button("Enviar");
static Button cerrar = new Button("Cerrar");
static TextArea texto = new TextArea(10,40);
static TextField mensaje = new TextField(40);

// Componentes de la comunicacion
static Socket servidor; // socket servidor
static InetAddress direccion; // direccion del servidor
static String mensa = "";
static PrintStream ps; // flujo de salida
static DataInputStream datos; // flujo de entrada

// funcion principal
public static void main( String args[]) {

//crear instancia ventana
new cliente();

//crear socket cliente relacionado con el servidor
try{
direccion = getdir(args); // llamada a getdirs()
servidor = new Socket(direccion, 5000); // creacion del socket servidor
activar();

// inicializar el flujo de salida con los datos del servidor
ps = new PrintStream(servidor.getOutputStream());
// inicializar el flujo de entrada
datos = new DataInputStream(servidor.getInputStream());

texto.append("Conectado con el servidor ...\n");

// ciclo de recepcion de mensajes
while((mensa = datos.readLine()) != null){
texto.append("Servidor dice : "+mensa+"\n");
};

texto.append("Desconectado del servidor ...\n");
cerrarconexion();
desactivar();

}catch (IOException e) { // en caso de error de entrada/salida
System.out.println("Error al conectar con el servidor");
System.exit(1);
};
}

// funcion que grafica
public cliente() {

// titulo de la ventana
setTitle("Java Chat Cliente");

// elementos de la ventana
Panel pan = new Panel();
pan.add(enviar);
pan.add(cerrar);

Panel pan1 = new Panel();
pan1.add(mensaje);

Panel pan2 = new Panel();
pan2.add(texto);

add("North",pan2);
add("Center",pan1);
add("South",pan);

enviar.disable();
texto.disable();
mensaje.disable();

// tama¤o constante
setResizable(false);

// organizar y mostrar
pack();
show();
}
public boolean action(Event ev, Object arg) {

// eventos en los botones

// click en el boton cerrar
if((ev.target == cerrar)&&(ev.id == 1001)){
cerrarconexion();
System.exit(0);
}

// click en el boton enviar
if((ev.target == enviar)&&(ev.id == 1001)){
if(!mensaje.getText().equals("")){
ps.println(mensaje.getText()); // enviar el contenido de texto
texto.append("Cliente dice : "+mensaje.getText()+"\n");
mensaje.setText("");
}
}
return(true);
}

// esta funcion habilita los elementos de la ventana
public static void activar(){
enviar.enable();
mensaje.enable();
}

// esta funcion deshabilita los elementos de la ventana
public static void desactivar(){
enviar.disable();
mensaje.disable();
}

// funcion que convierte la direccion ip o el nombre del equipo donde esta
// corriendo el socket servidor que se pasa como parametro al programa
public static InetAddress getdir(String ar[]){
InetAddress tem = null;
try{
// si no hay argumentos tomar localhost
if(ar.length == 0){
tem = InetAddress.getLocalHost();
}
// si hay convertirla de string a inetaddress
if(ar.length == 1){
tem = InetAddress.getByName(ar[0]);
}
// error en la direccion
}catch(UnknownHostException e){
texto.append("Error en la direccion.");
}
return(tem);
}

// funcion que cierra la conexion con el servidor
public static void cerrarconexion(){
try{
servidor.close();
}catch(IOException e){
texto.append("Error al cerrar el cliente");
};
desactivar();
}
}
**************************************************************************

servidor.java
aplicacion servidora del chat simple desarrollado en java.
compilar con :
javac servidor.java
ejecutar con :
java servidor
***********************************************************************/

// Librerias Necesarias
import java.awt.*; // modo grafico
import java.io.*; // entrada/salida
import java.net.*; // funciones de red

public class servidor extends Frame {

// elementos de la ventana
static Button enviar = new Button("Enviar");
static Button cerrar = new Button("Cerrar");
static TextArea texto = new TextArea(10,40);
static TextField mensaje = new TextField(40);

// Componentes de la comunicacion
static ServerSocket servido; // socket servidor
static Socket cliente; // socket para manejar los clientes
static String mensa = "";
static PrintStream ps; // flujo de salida
static DataInputStream datos; // flujo de entrada

// funcion principal
public static void main( String args[]) {

// crear instancia ventana
new servidor();

// crear socket servidor en el puerto 5000
// se puede cambiar a nuestro gusto
try{
servido = new ServerSocket(5000);
// error al crear el servidor
}catch (IOException e) {
System.out.println("Error al crear el Socket Servidor");
System.exit(1);
};

// ciclo para el tratamiento de los clientes
do{
try{

texto.append("Esperando Cliente ...\n");

//esperar cliente
cliente = servido.accept();
activar();
texto.append("Llego un cliente. Respondele ...\n");

// inicializacion de las estructuras para la lectura/escritura
// con los datos del cliente
ps = new PrintStream(cliente.getOutputStream());
datos = new DataInputStream(cliente.getInputStream());

// ciclo de recepcion de mensajes
while((mensa = datos.readLine()) != null){
texto.append("Cliente dice : "+mensa+"\n");
};

texto.append("\nTerminando la conexion con el cliente.\n");
cerrarconexion();
texto.append("\nEl cliente se ha desconectado.\n");

}catch (IOException e) {
texto.append("Error de Lectura / Escritura en los Sockets\n");
desactivar();
};
}while(true); // ciclo infinito. se desconecta un cliente y esperamos
// otro. para salir debemos dar click en el boton cerrar
}

// funcion que grafica
public servidor() {

// titulo de la ventana
setTitle("Java Chat Servidor");

// elementos de la ventana
Panel pan = new Panel();
pan.add(enviar);
pan.add(cerrar);

Panel pan1 = new Panel();
pan1.add(mensaje);

Panel pan2 = new Panel();
pan2.add(texto);

add("North",pan2);
add("Center",pan1);
add("South",pan);

enviar.disable();
texto.disable();
mensaje.disable();

// tama¤o constante
setResizable(false);

// organizar y mostrar
pack();
show();
}

public boolean action(Event ev, Object arg) {

// eventos en los botones

// click en el boton cerrar
if((ev.target == cerrar)&&(ev.id == 1001)){
cerrarconexion();
System.exit(0);
}
// click en el boton enviar
if((ev.target == enviar)&&(ev.id == 1001)){
if(!mensaje.getText().equals("")){
ps.println(mensaje.getText());
texto.append("Servidor dice : "+mensaje.getText()+"\n");
mensaje.setText("");
}
}
return(true);
}

// esta funcion habilita los elementos de la ventana
public static void activar(){
enviar.enable();
mensaje.enable();
}

// esta funcion deshabilita los elementos de la ventana
public static void desactivar(){
enviar.disable();
mensaje.disable();
}

// funcion que cierra la conexion con el cliente
public static void cerrarconexion(){
try{
cliente.close();
}catch(IOException e){
texto.append("Error al cerrar el cliente");
};
desactivar();
}
}
read more
Metodos y Funciones del Objeto String

Dentro de un objeto de la clases String o StringBuffer, Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. A este array se accede a través de las funciones miembro de la clase.

Los strings u objetos de la clase String se pueden crear explícitamente o implícitamente. Para crear un string implícitamente basta poner una cadena de caracteres entre comillas dobles. Por ejemplo, cuando se escribe

System.out.println("El primer programa");

Java crea un objeto de la clase String automáticamente.

Para crear un string explícitamente escribimos

String str=new String("El primer programa");

También se puede escribir, alternativamente

String str="El primer programa";

Para crear un string nulo se puede hacer de estas dos formas

String str="";
String str=new String();

Un string nulo es aquél que no contiene caracteres, pero es un objeto de la clase String. Sin embargo,

String str;

está declarando un objeto str de la clase String, pero aún no se ha creado ningún objeto de esta clase.

Convertir un número a string

int valor=10;
String str=String.valueOf(valor);


Convertir un string en número

String str=" 12 ";
String str1=str.trim();
read more
0 comentarios

Sobrecarga

Sobrecarga

En programación orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos o más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más funciones con el mismo nombre realizan acciones diferentes. El compilador usará una u otra dependiendo de los parámetros usados. A esto se llama también sobrecarga de funciones.

También existe la sobrecarga de operadores que al igual que con la sobrecarga de funciones se le da más de una implementación a un operador.

Sobrecarga de métodos


Algunos métodos en una clase pueden tener el mismo nombre. Estos métodos deben contar con diferentes argumentos. El compilador decide que método invocar comparando los argumentos. Se generara un error si los métodos solo varían en el tipo de retorno.

public class Articulo {
private float precio;
public void setPrecio() {
precio = 3.50;
}
public void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
}
}
read more


Data Mining
La minería de datos (DM, Data Mining) consiste en la extracción no trivial de información que reside de manera implícita en los datos. Dicha información era previamente desconocida y podrá resultar útil para algún proceso. En otras palabras, la minería de datos prepara, sondea y explora los datos para sacar la información oculta en ellos.

Bajo el nombre de minería de datos se engloba todo un conjunto de técnicas encaminadas a la extracción de conocimiento procesable, implícito en las bases de datos. Está fuertemente ligado con la supervisión de procesos industriales ya que resulta muy útil para aprovechar los datos almacenados en las bases de datos.

Las bases de la minería de datos se encuentran en la inteligencia artificial y en el análisis estadístico. Mediante los modelos extraídos utilizando técnicas de minería de datos se aborda la solución a problemas de predicción, clasificación y segmentación.
TCP/IP
Familia de protocolos de Internet es un conjunto de protocolos de red en la que se basa Internet y que permiten la transmisión de datos entre redes de computadoras. En ocasiones se le denomina conjunto de protocolos TCP/IP, en referencia a los dos protocolos más importantes que la componen: Protocolo de Control de Transmisión (TCP) y Protocolo de Internet (IP), que fueron los dos primeros en definirse, y que son los más utilizados de la familia. Existen tantos protocolos en este conjunto que llegan a ser más de 100 diferentes, entre ellos se encuentra el popular HTTP (HyperText Transfer Protocol), que es el que se utiliza para acceder a las páginas web, además de otros como el ARP (Address Resolution Protocol) para la resolución de direcciones, el FTP (File Transfer Protocol) para transferencia de archivos, y el SMTP (Simple Mail Transfer Protocol) y el POP (Post Office Protocol) para correo electrónico, TELNET para acceder a equipos remotos, entre otros.
El TCP/IP es la base de Internet, y sirve para enlazar computadoras que utilizan diferentes sistemas operativos, incluyendo PC, minicomputadoras y computadoras centrales sobre redes de área local (LAN) y área extensa (WAN). TCP/IP fue desarrollado y demostrado por primera vez en 1972 por el Departamento de Defensa de los Estados Unidos, ejecutándolo en ARPANET, una red de área extensa de dicho departamento.
Clases
Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. El conocimiento de las clases es fundamental para poder entender los programas Java.
Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. Esto puede despistar a los programadores de C++, que pueden definir métodos fuera del bloque de la clase, pero esta posibilidad es más un intento de no separarse mucho y ser compatible con C, que un buen diseño orientado a objetos. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una clase.
Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos. En C la unidad fundamental son los ficheros con código fuente, en Java son las clases. De hecho son pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave import (equivalente al #include) puede colocarse al principio de un fichero, fuera del bloque de la clase. Sin embargo, el compilador reemplazará esa sentencia con el contenido del fichero que se indique, que consistirá, como es de suponer, en más clases.

Tipos de Clases
Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:
abstract
Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.
final
Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.
public
Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.
synchronizable
Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.
Hilos
Un hilo es una secuencia de instrucciones que está controlada por un planificador que se comporta como un flujo de control secuencial. El planificador gestiona el tiempo de ejecución del procesador y asigna de alguna manera dicho tiempo a los diferentes hilos actualmente presentes.

Normalmente los hilos de un proceso (en este contexto el proceso es lo que se suele llamar así en el ámbito de sistemas operativos) suelen tener acceso a todos los recursos disponibles al proceso, es decir, actuan sobre una memoria compartida.
8:34 | Posted in Java

La Máquina Virtual Java (JVM) es un sistema multihilo. Es decir, es capaz de ejecutar varios hilos de ejecución simultáneamente. La JVM gestiona todos los detalles, asignación de tiempos de ejecución, prioridades, etc., de forma similar a como gestiona un Sistema Operativo múltiples procesos. La diferencia básica entre un proceso de Sistema Operativo y un Thread Java es que los hilos corren dentro de la JVM, que es un proceso del Sistema Operativo y por tanto comparten todos los recursos, incluida la memoria y las variables y objetos allí definidos.

A este tipo de procesos donde se comparte los recursos se les llama a veces procesos ligeros (lightweight process). Java da soporte al concepto de Thread desde el propio lenguaje, con algunas clases e interfaces definidas en el paquete java.lang y con métodos específicos para la manipulación de Threads en la clase Object.

Desde el punto de vista de las aplicaciones los hilos son útiles porque permiten que el flujo del programa sea divido en dos o más partes, cada una ocupándose de alguna tarea de forma independiente. Por ejemplo un hilo puede encargarse de la comunicación con el usuario, mientras que otros actúan en segundo plano, realizando la transmisión de un fichero, accediendo a recursos del sistema (cargar sonidos, leer ficheros ...), etc. De hecho, todos los programas con interface gráfico (AWT o Swing) son multihilo porque los eventos y las rutinas de dibujado de las ventanas corren en un hilo distinto al principal

ejemplo:

public MiHilo extends Thread
{
public void run()
{
// Aquí el código pesado que tarda mucho
}
};
...
MiHilo elHilo = new MiHilo();
elHilo.start();
System.out.println("Yo sigo a lo mio");
read more
0 comentarios

Java









Bitset
Los contenedores tipo bitset están pensados para almacenar bits. Es decir, conjuntos de N valores 0/1 denominados máscaras de bits ("Bitmask types"). En cierto sentido un bitset es el contenedor más simple del mundo, contiene un número máximo N (determinado en el momento de su definición) de elementos tipo bit. Podríamos considerar que un bitset es como una matriz de bits, de forma que podría establecerse un cierto paralelismo:

bit mb[125]; // L1: matriz de bits de 125 elementos

bitset <125> bs; // L2: bitset de 125 elementos


Naturalmente la sentencia L1 es solo didáctica, no es posible en C++ porque no existe un tipo bit nativo. En cambio L2 si es correcta; define un contenedor bs de tipo bitset de 125 elementos.
Vector
8:33 Posted in Java
El vector es muy facil de utilizar. Aunque los métodos más habituales en su manipulación son addElement() para insertar elementos en el Vector, elementAt() para recuperarlos y elements() para obtener una Enumeration con el número de elementos del Vector, lo cierto es que hay más métodos, pero no es el momento de relacionarlos todos, así que, al igual que sucede con todas las librerías de Java, se remite al lector a que consulte la documentación electrónica que proporciona Javasoft, para conocer los demás métodos que componen esta clase.

Las colecciones estándar de Java contienen el método toString(), que permite obtener una representación en forma de String de sí mismas, incluyendo los objetos que contienen. Dentro de Vector, por ejemplo, toString() va saltando a través de los elementos del Vector y llama al método toString() para cada uno de esos elementos.

Hashtable
Una Hashtable, tabla hash, es una implementación concreta de un Dictionary. Se puede utilizar una instancia de Hashtable para almacenar objetos arbitrarios que están indexados por cualquier otro objeto arbitrario. La utilización más habitual de una Hashtable es utilizar un String como clave para almacenar objetos como valores. El ejemplo java818.java, crea una tabla hash para almacenar información acerca del Tutorial.import java.util.Dictionary;
import java.util.Hashtable;
class java818 {
public static void main( String args[] ) {
Hashtable ht = new Hashtable();

ht.put( "titulo","Tutorial de Java" );
ht.put( "autor","Agustin Froufe" );
ht.put( "email","froufe@arrakis.es" );
ht.put( "patria","Spain" );
ht.put( "edad",new Integer( 31 ) );
show( ht );
}
static void show( Dictionary d ) {
System.out.println( "Titulo: " + d.get( "titulo" ) );
System.out.println( "Autor: " + d.get( "autor" ) );
System.out.println( "E-mail: " + d.get( "email" ) );
System.out.println( "Pais: " + d.get( "patria" ) );
System.out.println( "Edad: " + d.get( "edad" ) );
}
}

Stack
Un Stack es una Pila, o una colección de tipo LIFO (last-in, first-out). Es decir, lo último que se coloque en la pila será lo primero que se saque. Como en todas las colecciones de Java, los elementos que se introducen y sacan de la pila son Object, así que hay que tener cuidado con el moldeo a la hora de sacar alguno de ellos.

Los diseñadores de Java, en vez de utilizar un Vector como bloque para crear un Stack, han hecho que Stack derive directamente de Vector, así que tiene todas las características de un Vector más alguna otra propia ya del Stack. El ejemplo siguiente, es una demostración muy simple del uso de una Pila que consisten en leer cada una de las líneas de un array y colocarlas en un String.

Cada línea en el array diasSemana se inserta en el Stack con push() y posteriormente se retira con pop(). Para ilustrar una afirmación anterior, también se utilizan métodos propios de Vector sobre el Stack. Esto es posible ya que en virtud de la herencia un Stack es un Vector, así que todas las operaciones que se realicen sobre un Vector también se podrán realizar sobre un Snack.
read more
0 comentarios

Ausencia

Un suspiro, una mirada triste,
la voz quebrantada y un sin fin
de lagrimas en mis ojos
es lo que me ha dejado
tu ausencia...

Ausencia que me lastima,
porque quisiera sentir el
aroma de tu presencia...

Ausencia que a la vez
me provoca un alivio al
haberme enseñado que en
el mundo no todo es
color de rosa...

Ausencia que me hace saber
que en este mundo hay personas
con los mas bellos sueños,
y que a su vez hay quienes como tú
que se encargan de convertirlos en pesadillas...

Ausencia que me mete
un sin fin de ideas en mi mente,

las cuales para extraños
son locuras, pero para mi
tienen que ser indiferentes.

Pero como hacer si aun te amo
a pesar de todo el daño que
me hiciste, tendré que sobrevivir
hasta que el tiempo
...deje mi corazon
totalmente ausente.
read more
0 comentarios

sobre mentiras.





A veces me pregunto porque hay muchas personas en la vida a las que les cuesta ser sinceras, incluso con ellas mismas.


Es triste, son personas que están tan acostumbradas a mentir que ya casi no saben distinguir cuando dicen la verdad. Son capaces de creerse su propio mundo de fantasía.


Seguro que todos en algún momento de nuestras vidas nos hemos topado con alguien así.

Amí me despiertan lástima...


Al fin y al cabo las mentiras siempre salen a la luz, y duele mucho más descubrir una mentira cuando pasa mucho tiempo...


Es como si todo lo que pensaste de esa persona no tiene ya sentido. Como si hubieses vivido una situación irreal, o como si hubieses perdido el tiempo siendo franca con alguien que no se lo merece.


Hoy pensé algo, que esas personas que mienten, ni siquiera se merecen que las personas sinceras perdamos nuestro tiempo en desenmascararlos.


Tal vez no sea justo que les rompamos su micro mundo de felicidad.


Por lo que la próxima vez que creáis que alguien os esta mintiendo o os mintió, limitaros a mirarle fijamente a los ojos.


A veces una mirada, vale más que mil palabras...
read more
1 comentarios

Du3ñ@ d3 mi ViD@



El 12 de enero de hace algunos años nació una niña que vino a llenar de alegría el hogar de un matrimonio a la que esperaban con mucha ilusión. Con alguna u otra dificultad pasa pero con muchísimas alegrías fue creciendo poco a poco descubriendo verdades de la vida que se nos van presentando en el sendero de nuestro camino conociendo la amistad y junto con ella el amor el gran sentimiento que cada una de las personas podemos sentir y no cabe olvidar las travesuras que un dia ella llego a pasar travesuras y aventuras que solo quedaran en su memoria y su corazon ... al paso de los años se convirtió en una mujer que un día, al igual que hacen las orugas, salió de su capullo y abrió sus alas en busca de su destino y de su felicidad, bueno estoy en eso ahora jeje ... esa mujer pues SOY YO definitivamente. Como es la vida no? de interesante exitante y ala vez misteriosa, hoy en dia pues tengo 20 añitos todavia joven :P con muchos sueños y metas por alcanzar, por conocer mas de la vida pero poco a poco lo ire haciendo tengo mucho tiempo por seguir viviendo aunque como dice el refran la vida nadie la tiene comprada pero se le hace la lucha no?; hace un tiempito sera que alguien muy especial entro en mi vida alguien con quien me siento segura quien me enseño varias cosas de la vida que ignoraba ya ire describiendo a la persona especial mas adelante por ahora pues solo les digo eso .
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------


echar el tiempo hacia atras ya no sirve de nada , pero el que nos queda por delante quisieramos vivirlo en paz
read more