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

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

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

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

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

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