HALLAR EL FACTORIAL DE UN NUMERO UTILIZANDO UNA FUNCION

CODIGO:
Double factorial (double var1)
{
Double resultado = 1;
Double a;
for (a = 1; a<= var1;a++)
{
resultado = a * resulatdo;
}
return resultado;
}
Private void boton1 mouseClicked()
{
Double r=0;
Double result = 0;
r= double.parse double (txt1.getText());
result = factorial(r);
txt.setText(String.value of(result));
}

STRUTS EN JAVA

"Struts" es un proyecto Open-Source creado por la fundación Apache que facilita el desarrollo de aplicaciones con JSP's/Servlets diseñadas alrededor de paradigma "MVC" ("Model-View-Controller"); además Struts ofrece varias funcionalidades requeridas por las aplicaciones más complejas en ambientes Web de Java:

• Diseño de "Templates/Tiles" para aplicaciones tipo Portal.
• Utilización de Java Beans.
• Servlet Controlador con diversas funcionalidades.
• Tags para ambientes JSP's con lógica de ejecución.

POP3 EN JAVA

El significado de las siglas POP es Post Office Protocol (Protocolo de Oficina de Correos).

Al contrario de otros protocolos creados con anterioridad como el SMTP el POP no necesita una conexión permanente a Internet, puesto que es en el momento de la conexión cuando solicita al servidor el envío de la correspondencia almacenada en el servidor para dicho usuario.

Si se está permanentemente conectado a internet pueden configurarse los programas cliente de correo de tal forma que la petición al servidor de correo se efectúe automáticamente cada cierto tiempo y de esta forma avise al usuario de que tiene correo pendiente de recibir.

La situación actual es que se utiliza el protocolo SMTP para el envío de correo y para la recepción de correo se utiliza el protocolo POP, pero ya en su tercera versión desde su aparición, el POP3.


Definición y significado de POP

Articulos Relacionados
-SMTPSMTP (Simple Mail Transfer Protocol). Protocolo Simple de Trasferencia de Correo. Protocolo que se usa para trasmitir correo electrónico entre servidores. ...

-SOHOSOHO Acrónimo de Small Office-Home Office (Pequeña Oficina-Oficina en Casa). Ues un término que se aplica para denominar a los aparatos destinados a un uso profesiona o semiprofesional pero que,...

-MHSMHS (Message Handling System). Sistema de Correo electrónico, que se basa en el protocolo X.400. ...

-XPLOITXPLOIT Programa que utiliza un Bug para provocar determinados efectos, como conseguir información privada mediante un servidor de correo electrónico. ...

-Número de Puerto de ProtocoloNúmero de Puerto de Protocolo Número entero pequeño usado para identificar un programa de aplicación en una computadora remota.



CODIGO:

import com.jscape.inet.pop.*;
import com.jscape.inet.mime.*;
import com.jscape.inet.email.*;
import java.util.Enumeration;
import java.io.*;

public class PopAttachmentsExample {
private static File messagesDir = new File("msg");
private static File attachmentsDir = new File("attach");
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

// get messages from Pop mailbox
public void getMessages(String hostname, String username, String password)
throws PopException, MimeException, IOException { // ensure that messages directory is valid
if(!messagesDir.exists()) {
messagesDir.mkdir();
}

// ensure that attachments directory is valid
if(!attachmentsDir.exists()) {
attachmentsDir.mkdir();
}

// connect and login
Pop pop = new Pop(hostname,username,password);
pop.connect();

System.out.println("Retrieving messsages...");
Enumeration messages = pop.getMessages();
if(!messages.hasMoreElements()) {
System.out.println("No messages found");
}

// write messages to disk
int msgnum = 0;
while(messages.hasMoreElements()) {
++msgnum;
EmailMessage msg = (EmailMessage)messages.nextElement();
File f = new File(messagesDir,"msg" + msgnum + ".txt");
FileOutputStream fout = new FileOutputStream(f);
fout.write(msg.getMessage());
fout.close();
System.out.println("Retrieved message: " + f.getAbsoluteFile());

// write attachments to disk
int attachnum = 0;
Enumeration attachments = msg.getAttachments();
while(attachments.hasMoreElements()) {
++attachnum;
Attachment attach = (Attachment)attachments.nextElement();
String attachmentFileName = attach.getFilename();
if(attachmentFileName == null) {
attachmentFileName = "attachment" + msgnum + "-" + attachnum;
}

String fileName = attach.getFilename();
if(fileName == null) {
fileName = System.currentTimeMillis() + ".txt";
}
File attFile = new File(attachmentsDir,fileName);
FileOutputStream attOut = new FileOutputStream(attFile);
try { attOut.write(attach.getFileData());
attOut.close();
System.out.println("Retrieved attachment: " + attFile.getAbsoluteFile());
}
catch(Exception e) {
throw new PopException("unable to decode file attachment");
}
}
}
pop.disconnect();
}

public static void main(String[] args) {
String hostname;
String username;
String password;

try {
System.out.print("Enter Pop3 hostname (e.g. mail.domain.com): ");
hostname = reader.readLine();
System.out.print("Enter Pop3 Username: ");
username = reader.readLine();
System.out.print("Enter Pop3 Password: ");
password = reader.readLine();
PopAttachmentsExample example = new PopAttachmentsExample();
example.getMessages(hostname,username,password);
}
catch(Exception e) {
e.printStackTrace();
}
}
}

SOCKET CON CHAT

socket (enchufe), es un método para la comunicación entre un programa del cliente y un programa del servidor en una red. Un socket se define como el punto final en una conexión. Los sockets se crean y se utilizan con un sistema de peticiones o de llamadas de función a veces llamados interfaz de programación de aplicación de sockets (API, application programming interface).

Un socket es también una dirección de Internet, combinando una dirección IP (la dirección numérica única de cuatro partes que identifica a un ordenador particular en Internet) y un número de puerto (el número que identifica una aplicación de Internet particular, como FTP, Gopher, o WWW).

Codigo del Servidor- Cliente


Servidor.java

// Configurar un servidor que reciba una conexión de un cliente, envíe
// una cadena al cliente y cierre la conexión.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Servidor extends JFrame {
private JTextField campoIntroducir;
private JTextArea areaPantalla;
private ObjectOutputStream salida;
private ObjectInputStream entrada;
private ServerSocket servidor;
private Socket conexion;
private int contador = 1;

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

Container contenedor = getContentPane();

// crear campoIntroducir y registrar componente de escucha
campoIntroducir = new JTextField();
campoIntroducir.setEditable( false );
campoIntroducir.addActionListener(
new ActionListener() {

// enviar mensaje al cliente
public void actionPerformed( ActionEvent evento )
{
enviarDatos( evento.getActionCommand() );
campoIntroducir.setText( "" );
}
}
);

contenedor.add( campoIntroducir, BorderLayout.NORTH );

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

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

} // fin del constructor de Servidor

// configurar y ejecutar el servidor
public void ejecutarServidor()
{
// configurar servidor para que reciba conexiones; procesar las conexiones
try {

// Paso 1: crear un objeto ServerSocket.
servidor = new ServerSocket( 12345, 100 );

while ( true ) {

try {
esperarConexion(); // Paso 2: esperar una conexión.
obtenerFlujos(); // Paso 3: obtener flujos de entrada y salida.
procesarConexion(); // Paso 4: procesar la conexión.
}

// procesar excepción EOFException cuando el cliente cierre la conexión
catch ( EOFException excepcionEOF ) {
System.err.println( "El servidor terminó la conexión" );
}

finally {
cerrarConexion(); // Paso 5: cerrar la conexión.
++contador;
}

} // fin de instrucción while

} // fin del bloque try

// procesar problemas con E/S
catch ( IOException excepcionES ) {
excepcionES.printStackTrace();
}

} // fin del método ejecutarServidor

// esperar que la conexión llegue, después mostrar información de la conexión
private void esperarConexion() throws IOException
{
mostrarMensaje( "Esperando una conexión\n" );
conexion = servidor.accept(); // permitir al servidor aceptar la conexión
mostrarMensaje( "Conexión " + contador + " recibida de: " +
conexion.getInetAddress().getHostName() );
}

// obtener flujos para enviar y recibir datos
private void obtenerFlujos() throws IOException
{
// establecer flujo de salida para los objetos
salida = new ObjectOutputStream( conexion.getOutputStream() );
salida.flush(); // vaciar búfer de salida para enviar información de encabezado

// establecer flujo de entrada para los objetos
entrada = new ObjectInputStream( conexion.getInputStream() );

mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
}

// procesar la conexión con el cliente
private void procesarConexion() throws IOException
{
// enviar mensaje de conexión exitosa al cliente
String mensaje = "Conexión exitosa";
enviarDatos( mensaje );

// habilitar campoIntroducir para que el usuario del servidor pueda enviar mensajes
establecerCampoTextoEditable( true );

do { // procesar los mensajes enviados por el cliente

// leer el mensaje y mostrarlo en pantalla
try {
mensaje = ( String ) entrada.readObject();
mostrarMensaje( "\n" + mensaje );
}

// atrapar problemas que pueden ocurrir al tratar de leer del cliente
catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
mostrarMensaje( "\nSe recibió un tipo de objeto desconocido" );
}

} while ( !mensaje.equals( "CLIENTE>>> TERMINAR" ) );

} // fin del método procesarConexion

// cerrar flujos y socket
private void cerrarConexion()
{
mostrarMensaje( "\nFinalizando la conexión\n" );
establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir

try {
salida.close();
entrada.close();
conexion.close();
}
catch( IOException excepcionES ) {
excepcionES.printStackTrace();
}
}

// enviar mensaje al cliente
private void enviarDatos( String mensaje )
{
// enviar objeto al cliente
try {
salida.writeObject( "SERVIDOR>>> " + mensaje );
salida.flush();
mostrarMensaje( "\nSERVIDOR>>> " + mensaje );
}

// procesar problemas que pueden ocurrir al enviar el objeto
catch ( IOException excepcionES ) {
areaPantalla.append( "\nError al escribir objeto" );
}
}

// 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
}

// método utilitario que es llamado desde otros subprocesos para manipular a
// campoIntroducir en el subproceso despachador de eventos
private void establecerCampoTextoEditable( final boolean editable )
{
// 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() // establece la capacidad de modificar a campoIntroducir
{
campoIntroducir.setEditable( editable );
}

} // 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.ejecutarServidor();
}

} // fin de la clase Servidor
*********************************************************************

Cliente.java

// Cliente que lee y muestra la información que le envía 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 ObjectOutputStream salida;
private ObjectInputStream entrada;
private String mensaje = "";
private String servidorChat;
private Socket cliente;

// inicializar servidorChat y configurar GUI
public Cliente( String host )
{
super( "Cliente" );

servidorChat = host; // establecer el servidor al que se va a conectar este cliente

Container contenedor = getContentPane();

// crear campoIntroducir y registrar componente de escucha
campoIntroducir = new JTextField();
campoIntroducir.setEditable( false );
campoIntroducir.addActionListener(
new ActionListener() {

// enviar mensaje al servidor
public void actionPerformed( ActionEvent evento )
{
enviarDatos( evento.getActionCommand() );
campoIntroducir.setText( "" );
}
}
);

contenedor.add( campoIntroducir, BorderLayout.NORTH );

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

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

} // fin del constructor de Cliente

// conectarse al servidor y procesar mensajes del servidor
private void ejecutarCliente()
{
// conectarse al servidor, obtener flujos, procesar la conexión
try {
conectarAServidor(); // Paso 1: crear un socket para realizar la conexión
obtenerFlujos(); // Paso 2: obtener los flujos de entrada y salida
procesarConexion(); // Paso 3: procesar la conexión
}

// el servidor cerró la conexión
catch ( EOFException excepcionEOF ) {
System.err.println( "El cliente termino la conexión" );
}

// procesar los problemas que pueden ocurrir al comunicarse con el servidor
catch ( IOException excepcionES ) {
excepcionES.printStackTrace();
}

finally {
cerrarConexion(); // Paso 4: cerrar la conexión
}

} // fin del método ejecutarCliente

// conectarse al servidor
private void conectarAServidor() throws IOException
{
mostrarMensaje( "Intentando realizar conexión\n" );

// crear Socket para realizar la conexión con el servidor
cliente = new Socket( InetAddress.getByName( servidorChat ), 12345 );

// mostrar la información de la conexión
mostrarMensaje( "Conectado a: " +
cliente.getInetAddress().getHostName() );
}

// obtener flujos para enviar y recibir datos
private void obtenerFlujos() throws IOException
{
// establecer flujo de salida para los objetos
salida = new ObjectOutputStream( cliente.getOutputStream() );
salida.flush(); // vacíar búfer de salida para enviar información de encabezado

// establecer flujo de entrada para los objetos
entrada = new ObjectInputStream( cliente.getInputStream() );

mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
}

// procesar la conexión con el servidor
private void procesarConexion() throws IOException
{
// habilitar campoIntroducir para que el usuario del cliente pueda enviar mensajes
establecerCampoTextoEditable( true );

do { // procesar mensajes enviados del servidor

// leer mensaje y mostrarlo en pantalla
try {
mensaje = ( String ) entrada.readObject();
mostrarMensaje( "\n" + mensaje );
}

// atrapar los problemas que pueden ocurrir al leer del servidor
catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
mostrarMensaje( "\nSe recibió un objeto de tipo desconocido" );
}

} while ( !mensaje.equals( "SERVIDOR>>> TERMINAR" ) );

} // fin del método procesarConexion

// cerrar flujos y socket
private void cerrarConexion()
{
mostrarMensaje( "\nCerrando conexión" );
establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir

try {
salida.close();
entrada.close();
cliente.close();
}
catch( IOException excepcionES ) {
excepcionES.printStackTrace();
}
}

// enviar mensaje al servidor
private void enviarDatos( String mensaje )
{
// enviar objeto al servidor
try {
salida.writeObject( "CLIENTE>>> " + mensaje );
salida.flush();
mostrarMensaje( "\nCLIENTE>>> " + mensaje );
}

// procesar los problemas que pueden ocurrir al enviar el objeto
catch ( IOException excepcionES ) {
areaPantalla.append( "\nError al escribir el objeto" );
}
}

// 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 de la GUI
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
}

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

public void run() // establece la capacidad de modificar campoIntroducir
{
campoIntroducir.setEditable( editable );
}

} // fin de la clase interna

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

public static void main( String args[] )
{
JFrame.setDefaultLookAndFeelDecorated(true);
Cliente aplicacion;

if ( args.length == 0 )
aplicacion = new Cliente( "192.168.100.1" );
else
aplicacion = new Cliente( args[ 0 ] );

aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
aplicacion.ejecutarCliente();
}

} // fin de la clase Cliente

RMI CON CHAT

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. Si se requiere comunicación entre otras tecnologías debe utilizarse CORBA o SOAP en lugar de RMI.

RMI se caracteriza por la facilidad de su uso en la programación por estar específicamente diseñado para Java; proporciona paso de objetos por referencia (no permitido por SOAP), recolección de basura distribuida (Garbage Collector distribuido) y paso de tipos arbitrarios (funcionalidad no provista por CORBA).

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);
}
}

CORBA

CORBA

CODIGO:

Calculadora.idl

module ejemplo {
interface Calculadora {
long sumar(in long a, in long b);
long restar(in long a, in long b);
long multiplicar(in long a, in long b);
long dividir(in long a, in long b);
readonly attribute long contadorOperaciones;
};
};

*****************************

EjemploCliente

import org.omg.CosNaming.*;

import ejemplo.*; // Importar las clases e interfaces generados a partir del IDL

public class EjemploCliente {

public static void main(String[] args) {
try {
// 1. Inicializar ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);

// 2.1 Obtener instancia del servidor de nombres (initial naming context)
org.omg.CORBA.Object ncCorba = orb.resolve_initial_references("NameService");
NamingContextExt nc = NamingContextExtHelper.narrow(ncCorba);

// 2.2 Construir el nombre del objeto y obtener ref. desde servidor de nombres
org.omg.CORBA.Object calculadoraCorba = nc.resolve(nc.to_name("Calculadora"));

// 2.4 Convertir el objeto CORBA al tipo Calculadora (narrow)
Calculadora calculadora = CalculadoraHelper.narrow(calculadoraCorba);

// 3 Invocar métodos remotos
int resultado;
resultado = calculadora.sumar(100, 20);
System.out.println("Sumar 100 y 20 : " + resultado);

resultado = calculadora.restar(100, 20);
System.out.println("Restar 100 y 20 : " + resultado);

resultado = calculadora.multiplicar(100, 20);
System.out.println("Multiplicar 100 y 20 : " + resultado);

resultado = calculadora.dividir(100, 20);
System.out.println("Dividir 100 y 20 : " + resultado);

int contador = calculadora.contadorOperaciones();
System.out.println("Numero de operaciones realizadas : " + contador);
}
catch (Exception e) {
System.out.println("Error:" + e.getMessage());
System.exit(1);
}
}
} // Fin EjemploCliente

************************************
EjemploServidor

import org.omg.PortableServer.*;
import org.omg.CosNaming.*;


import ejemplo.*; // Importar las clases e interfaces generados a partir del IDL

public class EjemploServidor {

public static void main(String[] args) {
try {
// 1. Inicializar ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);

// 2.1 Obtener POA raiz
POA raizPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

// 2.2 Activar el POA manager
raizPOA.the_POAManager().activate();

// 3.1 Crear instancia de la implementación (servant)
CalculadoraImpl calculadoraServant = new CalculadoraImpl();

// 3.2 Registrar en el POA y obtener referencia al objeto (IOR)
org.omg.CORBA.Object calculadoraCorba = raizPOA.servant_to_reference
(calculadoraServant);

// 4.1 Obtener el initial naming context
org.omg.CORBA.Object ncCorba = orb.resolve_initial_references("NameService");
NamingContextExt nc = NamingContextExtHelper.narrow(ncCorba);

// 4.2 Asociar un nombre (en el primer nivel)
nc.rebind(nc.to_name("Calculadora"), calculadoraCorba);

// 5 Quedar a la espera de peticiones
System.out.println("Proceso servidor en espera ... ");
orb.run();
} catch (Exception e) {
System.out.println("Error:" + e.getMessage());
System.exit(1);

}
}
} // Fin EjemploServidor

****************************

CalculadoraImpl

import ejemplo.CalculadoraPOA;
// Importar la superclase generada a partir del IDL


public class CalculadoraImpl extends CalculadoraPOA {
private int contador;

public CalculadoraImpl(){
contador = 0;
}

public int sumar(int a, int b){
System.out.println("Servant CalculadoraImpl:
operacion sumar("+a+","+b+")");

contador++;
return (a + b);
}

public int restar(int a, int b){
System.out.println("Servant CalculadoraImpl:
operacion restar("+a+","+b+")");

contador++;
return (a - b);
}

public int multiplicar(int a, int b){
System.out.println("Servant CalculadoraImpl:
operacion multiplicar("+a+","+b+")");

contador++;
return (a * b);
}


public int dividir(int a, int b){
System.out.println("Servant CalculadoraImpl:
operacion dividir("+a+","+b+")");

contador++;
return (a / b);
}

public int contadorOperaciones(){
System.out.println("Servant CalculadoraImpl:
operacion contadorOperaciones()");

return (contador);
}
}
************************************
_CalculadoraStub

package ejemplo;


/**
* ejemplo/_CalculadoraStub.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

public class _CalculadoraStub extends
org.omg.CORBA.portable.ObjectImpl implements ejemplo.Calculadora
{

public int sumar (int a, int b)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out =
_request ("sumar", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
int $result = $in.read_long ();
return $result;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
return sumar (a, b );
} finally {
_releaseReply ($in);
}
} // sumar

public int restar (int a, int b)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("restar", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
int $result = $in.read_long ();
return $result;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
return restar (a, b );
} finally {
_releaseReply ($in);
}
} // restar

public int multiplicar (int a, int b)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("multiplicar", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
int $result = $in.read_long ();
return $result;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
return multiplicar (a, b );
} finally {
_releaseReply ($in);
}
} // multiplicar

public int dividir (int a, int b)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("dividir", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
int $result = $in.read_long ();
return $result;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
return dividir (a, b );
} finally {
_releaseReply ($in);
}
} // dividir

public int contadorOperaciones ()
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("_get_contadorOperaciones", true);
$in = _invoke ($out);
int $result = $in.read_long ();
return $result;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
return contadorOperaciones ( );
} finally {
_releaseReply ($in);
}
} // contadorOperaciones

// Type-specific CORBA::Object operations
private static String[] __ids = {
"IDL:ejemplo/Calculadora:1.0"};

public String[] _ids ()
{
return (String[])__ids.clone ();
}

private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
{
String str = s.readUTF ();
String[] args = null;
java.util.Properties props = null;
org.omg.CORBA.Object obj = org.omg.CORBA.ORB.init (args, props).string_to_object (str);
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
_set_delegate (delegate);
}

private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
{
String[] args = null;
java.util.Properties props = null;
String str = org.omg.CORBA.ORB.init (args, props).object_to_string (this);
s.writeUTF (str);
}
} // class _CalculadoraStub

*************************
Calculadora

package ejemplo;


/**
* ejemplo/Calculadora.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

public interface Calculadora extends CalculadoraOperations, org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity
{
} // interface Calculadora


****************************************
_CalculadoraHelper
package ejemplo;


/**
* ejemplo/CalculadoraHelper.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

abstract public class CalculadoraHelper
{
private static String _id = "IDL:ejemplo/Calculadora:1.0";

public static void insert (org.omg.CORBA.Any a, ejemplo.Calculadora that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}

public static ejemplo.Calculadora extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}

private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().create_interface_tc (ejemplo.CalculadoraHelper.id (), "Calculadora");
}
return __typeCode;
}

public static String id ()
{
return _id;
}

public static ejemplo.Calculadora read (org.omg.CORBA.portable.InputStream istream)
{
return narrow (istream.read_Object (_CalculadoraStub.class));
}

public static void write (org.omg.CORBA.portable.OutputStream ostream, ejemplo.Calculadora value)
{
ostream.write_Object ((org.omg.CORBA.Object) value);
}

public static ejemplo.Calculadora narrow (org.omg.CORBA.Object obj)
{
if (obj == null)
return null;
else if (obj instanceof ejemplo.Calculadora)
return (ejemplo.Calculadora)obj;
else if (!obj._is_a (id ()))
throw new org.omg.CORBA.BAD_PARAM ();
else
{
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl)obj)._get_delegate ();
ejemplo._CalculadoraStub stub = new ejemplo._CalculadoraStub ();
stub._set_delegate(delegate);
return stub;
}
}

public static ejemplo.Calculadora unchecked_narrow (org.omg.CORBA.Object obj)
{
if (obj == null)
return null;
else if (obj instanceof ejemplo.Calculadora)
return (ejemplo.Calculadora)obj;
else
{
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl)obj)._get_delegate ();
ejemplo._CalculadoraStub stub = new ejemplo._CalculadoraStub ();
stub._set_delegate(delegate);
return stub;
}
}

}

CalculadoraHolder
package ejemplo;

/**
* ejemplo/CalculadoraHolder.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

public final class CalculadoraHolder implements org.omg.CORBA.portable.Streamable
{
public ejemplo.Calculadora value = null;

public CalculadoraHolder ()
{
}

public CalculadoraHolder (ejemplo.Calculadora initialValue)
{
value = initialValue;
}

public void _read (org.omg.CORBA.portable.InputStream i)
{
value = ejemplo.CalculadoraHelper.read (i);
}

public void _write (org.omg.CORBA.portable.OutputStream o)
{
ejemplo.CalculadoraHelper.write (o, value);
}

public org.omg.CORBA.TypeCode _type ()
{
return ejemplo.CalculadoraHelper.type ();
}

}

CalculadoraOperations
package ejemplo;


/**
* ejemplo/CalculadoraOperations.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

public interface CalculadoraOperations
{
int sumar (int a, int b);
int restar (int a, int b);
int multiplicar (int a, int b);
int dividir (int a, int b);
int contadorOperaciones ();
} // interface CalculadoraOperations


CalculadoraPOA
package ejemplo;


/**
* ejemplo/CalculadoraPOA.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from calculadora.idl
* martes 2 de diciembre de 2008 14H07' CET
*/

public abstract class CalculadoraPOA extends org.omg.PortableServer.Servant
implements ejemplo.CalculadoraOperations, org.omg.CORBA.portable.InvokeHandler
{

// Constructors

private static java.util.Hashtable _methods = new java.util.Hashtable ();
static
{
_methods.put ("sumar", new java.lang.Integer (0));
_methods.put ("restar", new java.lang.Integer (1));
_methods.put ("multiplicar", new java.lang.Integer (2));
_methods.put ("dividir", new java.lang.Integer (3));
_methods.put ("_get_contadorOperaciones", new java.lang.Integer (4));
}

public org.omg.CORBA.portable.OutputStream _invoke (String $method,
org.omg.CORBA.portable.InputStream in,
org.omg.CORBA.portable.ResponseHandler $rh)
{
org.omg.CORBA.portable.OutputStream out = null;
java.lang.Integer __method = (java.lang.Integer)_methods.get ($method);
if (__method == null)
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);

switch (__method.intValue ())
{
case 0: // ejemplo/Calculadora/sumar
{
int a = in.read_long ();
int b = in.read_long ();
int $result = (int)0;
$result = this.sumar (a, b);
out = $rh.createReply();
out.write_long ($result);
break;
}

case 1: // ejemplo/Calculadora/restar
{
int a = in.read_long ();
int b = in.read_long ();
int $result = (int)0;
$result = this.restar (a, b);
out = $rh.createReply();
out.write_long ($result);
break;
}

case 2: // ejemplo/Calculadora/multiplicar
{
int a = in.read_long ();
int b = in.read_long ();
int $result = (int)0;
$result = this.multiplicar (a, b);
out = $rh.createReply();
out.write_long ($result);
break;
}

case 3: // ejemplo/Calculadora/dividir
{
int a = in.read_long ();
int b = in.read_long ();
int $result = (int)0;
$result = this.dividir (a, b);
out = $rh.createReply();
out.write_long ($result);
break;
}

case 4: // ejemplo/Calculadora/_get_contadorOperaciones
{
int $result = (int)0;
$result = this.contadorOperaciones ();
out = $rh.createReply();
out.write_long ($result);
break;
}

default:
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);
}

return out;
} // _invoke

// Type-specific CORBA::Object operations
private static String[] __ids = {
"IDL:ejemplo/Calculadora:1.0"};

public String[] _all_interfaces (org.omg.PortableServer.POA poa, byte[] objectId)
{
return (String[])__ids.clone ();
}

public Calculadora _this()
{
return CalculadoraHelper.narrow(
super._this_object());
}

public Calculadora _this(org.omg.CORBA.ORB orb)
{
return CalculadoraHelper.narrow(
super._this_object(orb));
}

SMTP EN JAVA

Enviar emails a través de un servidor SMTP autenticado con Java

El Correo Electrónico:

El correo electrónico es un servicio de red que permite intercambiar mensajesentre distintos usuarios de manera asíncrona; estos mensajes pueden contener o noficheros adjuntos. Según la el diccionario de la RAE el correo electrónico se definecomo: «Sistema de comunicación personal por ordenador a través de redes informáticas».

Muestra el funcionamiento básico del envío y recepción de unmensaje de correo electrónico entre dos usuarios llamados A y B.Los pasos que se siguen para enviar un mensaje desde A hasta B son:1.-El usuario A se prepara para enviar un correo electrónico al usuario B. Esteprocedimiento se puede realizar de dos formas:1.1.-El usuario A usa un programa de tipo MUA (Mail User Agent o Agentede Usuario de Correo), que son programas que se usan para crear y enviar(entre otras funciones) correos electrónicos, y entre los que se puedendestacar Microsoft Office Outlook , Mozilla Thunderbird, Eudora,Pegasus, etc. El usuario compone el mensaje y selecciona la opción deenviar. El MUA del usuario A le indica al servidor de correo de este usuario quién está enviando el mensaje y quiénes son los destinatarios, ya continuación envía el mensaje usando el protocolo SMTP (Simple MailTransfer Protocol - Protocolo Simple de Transferencia de CorreoElectrónico). Cuando el servidor recoge el mensaje y acepta transferirlohasta su destino, el MUA informa al usuario A que el envió ha tenidoéxito.1.2.-El usuario A usa directamente su servidor de correo electrónico vía web.Esta forma de acceder al correo electrónico se conoce como WebMail oCorreo Web. Se trata de un servicio que permite el acceso al correomediante páginas web, usando para ello un navegador. Para ello, elusuario ha de autenticarse en el servidor introduciendo su nombre deusuario y contraseña; a continuación compone el mensaje y selecciona laopción de enviar. Entre las ventajas de este método se puede decir que losmensajes no se descargan al ordenador, es posible acceder desde cualquiermáquina sin que tenga que tener ningún software específico (todos lossistemas operativos suelen incluir un navegador web) y la creación de unacuenta de correo es más sencilla que desde un programa MUA. Laprincipal desventaja es que el espacio de almacenamiento de mensajes selimita a lo que ofrece el servidor de correo, en lugar de la capacidad dealmacenamiento del propio disco duro que ofrece un programa MUA.Además requiere una conexión permanente a Internet mientras lo usemosy los mensajes ocupan bastante más espacio pues van embebidos enHTML, lo que implica que tardan más en enviarse.2.-El mensaje es almacenado en el servidor de correo del usuario A
.3.-El servidor de correo del usuario A solicita al del usuario B el nombre delservidor al que tiene que enviar el mensaje. El servidor del usuario B se conocegracias a la parte de la dirección de correo que sigue a la arroba, ej. @gmail.com.4.-El servidor de correo del usuario B le responde al del usuario A, enviándole unregistro MX (MX record), que es un registro de correo. En este registro constanlas direcciones de correo que pertenecen a un dominio concreto y la máquina quese corresponde con cada dirección. Así cuando se envía un correo, se compruebaen la lista de registros MX de ese dominio si contiene esa dirección de correo, noaceptándola en caso contrario. En el registro MX pueden aparecer distintasmáquinas, estableciéndose prioridades entre ellas o balanceando la carga decorreo por las distintas máquinas. Por ejemplo un servidor le devolverá al otrouna lista con una serie de máquinas en orden de prioridad. Si al enviar el correoa la primera máquina esta fallase o estuviese saturada, se enviaría a la segunda,y así sucesivamente.5.-El servidor de correo del usuario A envía entonces el mensaje al servidorcorrespondiente a esa dirección de correo, usando el protocolo SMTP. 6.-El mensaje es almacenado en el servidor de correo del usuario B y se coloca enel buzón de correo del usuario.7.-El último paso sería la lectura del mensaje por parte del usuario B, lo que sepuede llevar a cabo de 3 formas:7.1.-El usuario B accede directamente a su servidor de correo vía webmail ylee sus mensajes del servidor sin descargarlos.
El usuario B accede a su correo a través de un programa de tipo MUA. Silo hace de esta forma tiene dos opciones:7.2.1.-Descargar los mensajes a su máquina usando el protocolo POP3(
Post Office Protocol
- Protocolo de Oficina Postal versión 3).7.2.2.-Descargar los mensajes a su máquina o leerlos directamente enel servidor usando el protocolo IMAP (
Internet Message AccessProtocol
- Protocolo de Internet para el Acceso a MensajesElectrónicos)

SMTP (Simple Mail Transfer Protocol)

El protocolo SMTP es un protocolo que se usa para el envío de correoelectrónico (Protocolo Simple de Transferencia de Correo Electrónico). SMTPtransfiere los mensajes desde la máquina cliente al servidor, quedándose este últimocon el mensaje, si se trata del destino final, o transfiriéndolo a otro servidor, tambiénvía SMTP, para que el mensaje llegue al servidor del destinatario. El protocolocompleto está descrito en los RFC 821 y 822, donde se define el funcionamiento deSMTP y el formato de mensaje respectivamente. Estos RFC han sido actualizados porlos RFC 2821 y 2822 (http://www.faqs.org/rfcs/rfc2821.html yhttp://www.faqs.org/rfcs/rfc2822.html).Algunas de las características de SMTP son las siguientes:• Utiliza el puerto 25 para establecer la conexión.• Se pueden comunicar entre sí servidores de plataformas distintas.• Dos sistemas que intercambien correo mediante SMTP no necesitan unaconexión activa, ya que posee sistema de almacenamiento y reenvío demensajes, es decir, si el receptor no está disponible el mensaje será reenviadoposteriormente.Algunos de los principales problemas de SMTP en su forma original son:• Falta de soporte para idiomas distintos del inglés pues solo acepta caracteresASCII de 7 bits, lo que impedía usar caracteres propios de otros idiomascomo la ñ o los acentos.• Los datos no viajan de forma segura.• Facilita la expansión del spam, pues no requiere autenticación en el servidor.Estos problemas se han ido solventando con distintas revisiones de SMTP.El uso de códigos de 8 bits se puede conseguir empleando ESMTP (Extended SMTP-SMTP Extendido) o mediante extensiones MIME. También existe una revisión para trabajar con SMTP seguro sobre TLS , lo que permite un transporte más seguro de los datos; esta revisión se define en el RFC 3207. Por último, comentar la extensióndefinida en el RFC 2554 que introduce el comando AUTH, lo que permiteautenticación frente al servidor. Si bien los problemas que planteaba el SMTP básico se han mejorado, elproblema del spam sigue sin solucionarse, por lo que ya se proponen mecanismosalternativos para definir una infraestructura de correo, como Internet Mail 2000(http://www.im2000.org./).La API JavaMailJavaMail es una API opcional a la versión estándar de Java (J2SDK) queproporciona funcionalidades de correo electrónico, a través del paquete javax.mail.Permite realizar desde tareas básicas como enviar, leer y componer mensajes, hastatareas más sofisticadas como manejar gran variedad de formatos de mensajes y datos,y definir protocolos de acceso y transporte. Aunque a primera vista pueda parecer quesu utilidad se orienta a construir clientes de correo-e de tipo Outlook, ThunderBird,etc., su aplicación se puede generalizar a cualquier programa Java que necesite enviary/o recibir mensajes, como por ejemplo, aplicaciones de intranets, páginas JSP, etc.JavaMail soporta, por defecto, los protocolos de envío y recepción SMTP,IMAP, POP3 y las versiones seguras de estos protocolos SMTPS, IMAPS, POP3S(estos 3 últimos a partir de la versión JDK 1.3.2), si bien puede implementar otrosprotocolos. El envío y recepción son independientes del protocolo, aunque podremosnecesitar usar un protocolo u otro según nuestras necesidades
Posibilidades de JavaMail
JavaMail está diseñada para facilitar las funcionalidades más comunes, sibien también posee características más avanzadas, que permiten sacar el máximopartido a los estándares de correo electrónico. Las funciones más importantes sedetallan a continuación:• Componer y enviar un mensaje: el primer paso que ha de realizar cualquieraplicación que pretenda enviar un correo electrónico es componer elmensaje. Es posible crear un mensaje de texto plano, es decir, un mensaje sinadjuntos que contenga exclusivamente texto formado por caracteres ASCII;pero es igualmente sencillo componer mensajes más completos quecontengan adjuntos. También se pueden componer mensajes que contengancódigo HTML e incluso imágenes embebidas en el texto.• Descargar Mensajes: se pueden descargar los mensajes desde la carpeta quese indique ubicada en el servidor que en ese momento se esté usando. Estosmensajes pueden ser de texto plano, contener adjuntos, HTML, etc.• Usar flags (banderines): para indicar, por ejemplo, que un mensaje ha sidoleído, borrado, etc., en función de cuáles de estos flags estén soportados porel servidor. • Establecer una conexión segura: actualmente algunos servidores de correorequieren de una conexión segura, ya sea para descargar el correoalmacenado en ellos, o para enviar mensajes a través de ellos. JavaMailofrece la posibilidad de establecer este tipo de conexiones, indicando que setrata de una conexión segura, además de poder indicar otros parámetros, enalgunos casos necesarios, como el puerto donde establecer la conexión. Estacapacidad está disponible desde la versión de JDK 1.3.2• Autenticarse en un servidor: ciertos servidores requieren autenticación ya nosólo para leer sino también para enviar. JavaMail ofrece también laposibilidad de autenticación a la hora de enviar un correo.• Definir protocolos: JavaMail soporta por defecto los protocolos de envío yrecepción SMTP, IMAP, POP3, (y sus correspondiente seguros a partir dela versión de JDK 1.3.2), si bien puede implementar otros protocolos. Parausar otros protocolos, o desarrollar por nuestra cuenta soporte para algúnprotocolo no definido por defecto en JavaMail, podemos es posible consultarla página de Sun, http://java.sun.com/products/javamail/Third_Party.html
,donde se detallan una serie de protocolos que podemos usar, y que no seofrecen por defecto con JavaMail ya que no son estándares. • Manejar adjuntos: JavaMail ofrece la posibilidad de añadir adjuntos a losmensajes de salida, así como obtener y manipular los adjuntos contenidos enun mensaje de entrada.• Búsquedas: JavaMail ofrece la posibilidad de buscar mensajes dentro de lacuenta de correo en el propio servidor -sin necesidad de descargar todo elcorreo- que concuerden con un criterio de búsqueda previamente definido.Para ello dispone de varias clases que permiten buscar mensajes con un subject determinado, un from concreto, etc., devolviendo un array con losmensajes que cumplan estos criterios. En el capítulo 7 veremos esto con másdetenimiento.• Acuse de recibo y prioridad: Se puede incluir un acuse de recibo en losmensajes de salida, para que el remitente sepa si un mensaje ha sido leído ono por el destinatario, si bien no todos los servidores soportan estafuncionalidad. Además se puede establecer la prioridad de un mensaje deforma muy sencilla.

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 ="172.16.18.29";//Suponiendo que el servidor SMTPsea la propia máquina
String from ="lizbeth@unitek.com";
String to = "genesis_dcta@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!");

}

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 = "lizbeth@unitek.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);

}

}

E-COMMERCE

Es la parte de e-business aplicada a las transacciones comerciales.
El e-commerce es, básicamente, el uso de medios electrónicos, para realizar la totalidad de actividades involucradas en la gestión de negocios: ofrecer y demandar productos y/o servicios, buscar socios y tecnologías, hacer las negociaciones con su contraparte, seleccionar el transporte y los seguros que más le convengan, realizar los trámites bancarios, pagar, cobrar, comunicarse con los vendedores de su empresa, recoger los pedidos; es decir todas aquellas operaciones que requiere el comercio”.
El e-commerce , a través de Internet, implica la utilización de esta red como medio para facilitar el intercambio de bienes y servicios. La forma más avanzada es aquella en la que un cliente: visualiza, selecciona y formaliza la adquisición de productos o servicios cuya descripción está disponible en un servidor conectado a Internet.

Las empresas pueden colocar el catálogo completo de sus productos o servicios en Internet, y dar acceso abierto a sus potenciales clientes a una enorme vidriera virtual, así como también, renovar estos productos, dialogar con sus clientes y por lo tanto ajustarse a sus necesidades.

El comercio electrónico, o el e-commerce, es un término muy amplio. El e-commerce se da entre el negocio y los consumidores y también entre un negocio y otro, para el intercambio de datos electrónicos (EDI) es un formato para las redes privadas del excedente de la información del negocio de cambio.

Después de ver las definiciones podemos notar que existen diferencias entre ambos términos, el comercio electrónico forma parte del negocio en línea, y no comprende todo el e-business. Es por esto que no podemos decir que el e-business es igual al e-commerce, sino que el e-commerce es un componente más del e-business.

Dentro del comercio electrónico tenemos varias acciones que podemos realizar como son: la transferencia electrónica de fondos, manejo de la cadena de producción, el e-marketing (marketing orientado a Internet), y el procesamiento de transacciones en línea. Estos son algunos de los elementos que pueden estar comprendidos dentro del e-commerce, no es necesario implementar todos ellos para hablar de e-commerce.

Quizás el tipo de comercio electrónico (e-commerce) más difundido es el carrito de compras, es en el cual el cliente selecciona los productos que quiere comprar, ingresa sus datos, y envía el pedido. El pago puede ser tanto por los medios tradicionales, o directamente puede ser realizado en línea (el cliente ingresa su número de tarjeta de crédito, se verifican sus datos, y se debita automáticamente el importe de la operación de su cuenta). Este tipo de e-commerce, es a la fecha el más popular y gran número de empresas en la red lo manejan.

CLASES

Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos.

Las cartacteristicas de una clase son las siguientes:

1) Todas las variables y funciones de Java deben pertenecer a una clase.
2) Si una clase deriva de otra (extends), hereda todas sus variables y métodos.
3) Java tiene una jerarquía de clases estándar de la que pueden derivar las clases que crean los usuarios.
4) En Java no hay herencia múltiple.
5) En un fichero se pueden definir varias clases, pero en un fichero no puede haber más que una clase public.
6) Si una clase contenida en un fichero no es public, no es necesario que el fichero se llame como la clase.
7) Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se aplican por medio de la referencia this.
8) Las clases se pueden agrupar en packages, introduciendo una línea al comienzo del fichero (package packageName;).

Tipos de Clases

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.

EJEMPLO ROBOT:

SOBRE CARGA DE FUNCIONES

La sobrecarga se refiere a la posibilidad de tener dos o mas 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.

1. 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.

CONSTRUCTORES

El constructor es un tipo especifico de metodo que siempre tiene el mismo nombre que la clase y se utiliza para construir objetos de esa clase. No tiene tipo de dato especifico de retorno, ni siquiera void. Esto se debe a que el tipo especifico que debe devolver un constructor de clase es el propio tipo de la clase. En este caso, pues, no se puede especificar un tipo de retorno, ni se puede colocar ninguna sentencia que devuelva un valor. Los constructores pueden sobrecargarse, y aunque puedan contener codigo, su funcion primordial es incializar el nuevo objeto que se instancia de la clase.

ejemplo1:

String status;

int temperature;

int speed;

robot(String atr1,int atr2,int atr3)

{

status=atr1;

temperature=atr2;

speed=atr3;

}

void checktemperature()

{

if(temperature>=100)

{

status="regresa al cubil";

speed=6;

}

}

void Showattributes(){

System.out.println("status" + status);

System.out.println("temperature" + temperature);

System.out.println("speed" + speed);

}

EJERCICIOS RESUELTOS DE JAVA

"CONVERTIR DE NUMEROS A LETRA"

String numeroAletras (int numero)
{
/*06*/String unidades="uno dos tres cuatrocinco seis siete ocho nueve ";
/*10*/String diecis="once doce trece catorce quince dieciseis diesisietedieciocho diecinueve";
/*12*/String veintis="veintiuno veintidos veintitres veinticuatroveinticinco veintiseis veintisiete veintiocho veintinueve ";
/*09*/String decenas="diez veinte treinta cuarenta cincuentasesenta setenta ochenta noventa ";
/*13*/String centenas="cien doscientos trescientos cuatrocientosquinientos seiscientos setecientos ochocientos novescientos ";

String elnumero;
elnumero = String.valueOf(numero);
int largo = elnumero.length();
int uni;
int dec;
int die;
int vei;
int cen;
int cie;
String resultado=" ";

//Recibiendo Unidades
if(largo==1 && numero>0)
//Si la longitud del número ingresado es igual a uno y además si el nú--
//mero ingresado es mayor que cero, entonces...
{
uni=Integer.parseInt(elnumero.substring(largo-1,1));
String textuni=unidades.substring((uni-1)*6, (uni*6));
//Mostrando resultado: uno ... ...nueve
resultado=textuni;
//Si se ingresa cero(0) el sistema devuelve cero
}
else{
if (numero==0)
resultado="cero";}
//Recibiendo las Decenas
if(largo==2)
{
uni=Integer.parseInt(elnumero.substring(largo-1,2));
//Si el último número, es decir la unidad es igual a cero entonces mos--
//tramos sólo las decenas
if(uni==0)
{
dec=Integer.parseInt(elnumero.substring(largo-2,1));
String textdec=decenas.substring((dec-1)*9,(dec*9));
//Mostrando resultado: veinte ... ... noventa
resultado=textdec;
}
else
{
String textuni=unidades.substring((uni-1)*6, (uni*6));

dec=Integer.parseInt(elnumero.substring(largo-2,1));
String textdec=decenas.substring((dec-1)*9,(dec*9));
//Mostrando resultado: treinta y uno ... ... noventa y nueve
resultado=textdec+" y "+textuni;
//Si la decena empieza con 1
if (dec==1)
{
die=Integer.parseInt(elnumero.substring(largo-1,2));
String textdie=diecis.substring((die-1)*10, (die*10));
//Mostrando resultado: once ... ... diecinueve
resultado=textdie;
}
//Si la decena empieza con 2
if (dec==2)
{
vei=Integer.parseInt(elnumero.substring(largo-1,2));
String textvei=veintis.substring((vei-1)*12, (vei*12));
//Mostrando resultado: veintiuno ... ... veintinueve
resultado=textvei;
}

}
}

//Recibiendo las centenas
if(largo==3)
{
uni=Integer.parseInt(elnumero.substring(largo-1,3));
dec=Integer.parseInt(elnumero.substring(largo-2,2));
cen=Integer.parseInt(elnumero.substring(largo-3,1));

if(uni==0 && dec==0)
{
//cen=Integer.parseInt(elnumero.substring(largo-3,1));
String textcen=centenas.substring((cen-1)*13,(cen*13));
//Mostrando resultado: cien ... ... novecientos
resultado=textcen;
}
else
{
String textuni=unidades.substring((uni-1)*6, (uni*6));
cen=Integer.parseInt(elnumero.substring(largo -3,1));

if (dec>2 && cen==1)
{
String textdec=decenas.substring((dec-1)*9,(dec*9));
//Mostrando resultado: ciento treinta y uno ... ... ciento no---
//venta y nueve
resultado="ciento "+textdec+" y "+textuni;
}
else
{
//Si la decena empieza con 0
if (dec==0 && cen==1)
{
resultado="ciento "+textuni;
}
else
{
if(dec==0 && cen>1)
{
cen=Integer.parseInt(elnumero.substring(largo -3,1));
String textcen=centenas.substring((cen-1)*13,(cen*13));
resultado=textcen+textuni;
}
}
//Si la decena empieza con 1
if (dec==1)
{
die=Integer.parseInt(elnumero.substring(largo-1,3));
String textdie=diecis.substring((die-1)*10, (die*10));
//Mostrando resultado: once ... ... diecinueve
resultado="ciento "+textdie;
}
//Si la decena empieza con 2
if (dec==2)
{
vei=Integer.parseInt(elnumero.substring(largo-1,3));
String textvei=veintis.substring((vei-1)*12, (vei*12));
//Mostrando resultado: veintiuno ... ... veintinueve
resultado="ciento "+textvei;
}
}
}
}

TEORIA DE JAVA

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.

Enumeraciones

En cualquier clase de colección, debe haber una forma de meter cosas y otra de sacarlas; después de todo, la principal finalidad de una colección es almacenar cosas. En un Vector, el método addElement() es la manera en que se colocan objetos dentro de la colección y llamando al método elementAt() es cómo se sacan. Vector es muy flexible, se puede seleccionar cualquier cosa en cualquier momento y seleccionar múltiples elementos utilizando diferentes índices.

Si se quiere empezar a pensar desde un nivel más alto, se presenta un inconveniente: la necesidad de saber el tipo exacto de la colección para utilizarla. Esto no parece que sea malo en principio, pero si se empieza implementando un Vector a la hora de desarrollar el programa, y posteriormente se decide cambiarlo a List, por eficiencia, entonces sí es problemático.

El concepto de enumerador, o iterador, que es su nombre más común en C++ y OOP, puede utilizarse para alcanzar el nivel de abstracción que se necesita en este caso. Es un objeto cuya misión consiste en moverse a través de una secuencia de objetos y seleccionar aquellos objetos adecuados sin que el programador cliente tenga que conocer la estructura de la secuencia . Además, un iterador es normalmente un objeto ligero, lightweight, es decir, que consumen muy pocos recursos, por lo que hay ocasiones en que presentan ciertas restricciones; por ejemplo, algunos iteradores solamente se puede mover en una dirección.

La Enumeration en Java es un ejemplo de un iterador con esas características, y las cosas que se pueden hacer son:

* Crear una colección para manejar una Enumeration utilizando el método elements(). Esta Enumeration estará lista para devolver el primer elemento en la secuencia cuando se llame por primera vez al método nextElement().
* Obtener el siguiente elemento en la secuencia a través del método nextElement().
* Ver si hay más elementos en la secuencia con el método hasMoreElements().

Y esto es todo. No obstante, a pesar de su simplicidad, alberga bastante poder. Para ver cómo funciona, el ejemplo java412.java, es la modificación de anterior, en que se utilizaba el método elementAt() para seleccionar cada uno de los elementos. Ahora se utiliza una enumeración para el mismo propósito, y el único código interesante de este nuevo ejemplo es el cambio de las líneas del ejemplo original

for( int i=0; i < style="font-weight: bold;">Tipos de Colecciones

Con el JDK 1.0 y 1.1 se proporcionaban librerías de colecciones muy básicas, aunque suficientes para la mayoría de los proyectos. En el JDK 1.2 ya se amplía esto y, además, las anteriores colecciones han sufrido un profundo rediseño. A continuación se verán cada una de ellas por separado para dar una idea del potencial que se ha incorporado a Java.

Vector

El Vector es muy simple y fácil 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. En caso, por poner un ejemplo, de querer imprimir la dirección de la clase, parecería lógico referirse a ella simplemente como this (los programadores C++ estarán muy inclinados a esta posibilidad), así que tendríamos el código que muestra el ejemplo java413.java y que se reproduce en las siguientes líneas.

import java.util.*;

public class java413 {
public String toString() {
return( "Direccion del objeto: "+this+"\n" );
}

public static void main( String args[] ) {
Vector v = new Vector();

for( int i=0; i < style="font-weight: bold;">BitSet

Se llama así lo que en realidad es un Vector de bits. Lo que ocurre es que está optimizado para uso de bits. Bueno, optimizado en cuanto a tamaño, porque en lo que respecta al tiempo de acceso a los elementos, es bastante más lento que el acceso a un array de elementos del mismo tipo básico.

Además, el tamaño mínimo de un BitSet es de 64 bits. Es decir, que si se está almacenando cualquier otra cosa menor, por ejemplo de 8 bits, se estará desperdiciando espacio.

En un Vector normal, la colección se expande cuando se añaden más elementos. En el BitSet ocurre los mismo pero ordenadamente. El ejemplo java414.java, muestra el uso de esta colección.

Se utiliza el generador de números aleatorios para obtener un byte, un short y un int, que son convertidos a su patrón de bits e incorporados al BitSet.

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, java415.java, 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 Stack, como por ejemplo, elementAt().

Hashtable

Un Vector permite selecciones desde una colección de objetos utilizando un número, luego parece lógico pensar que hay números asociados a los objetos. Bien, entonces ¿qué es lo que sucede cuando se realizan selecciones utilizando otros criterios? Un Stack podría servir de ejemplo: su criterio de selección es "lo último que se haya colocado en el Stack". Si rizamos la idea de "selección desde una secuencia", nos encontramos con un mapa, un diccionario o un array asociativo. Conceptualmente, todo parece ser un vector, pero en lugar de acceder a los objetos a través de un número, en realidad se utiliza otro objeto. Esto nos lleva a utilizar claves y al procesado de claves en el programa. Este concepto se expresa en Java a través de la clase abstracta Dictionary. El interfaz para esta clase es muy simple:

* size(), indica cuántos elementos contiene,
* isEmpty(), es true si no hay ningún elemento,
* put( Object clave,Object valor), añade un valor y lo asocia con una clave
* get( Object clave ), obtiene el valor que corresponde a la clave que se indica
* remove( Object clave ), elimina el par clave-valor de la lista
* keys(), genera una Enumeration de todas las claves de la lista
* elements(), genera una Enumeration de todos los valores de la lista

Todo es lo que corresponde a un Diccionario (Dictionary), que no es excesivamente difícil de implementar. El ejemplo java416.java es una aproximación muy simple que utiliza dos Vectores, uno para las claves y otro para los valores que corresponden a esas claves.

import java.util.*;

public class java416 extends Dictionary {
private Vector claves = new Vector();
private Vector valores = new Vector();
public int size() {
return( claves.size() );
}
public boolean isEmpty() {
return( claves.isEmpty() );
}

public Object put( Object clave,Object valor ) {
claves.addElement( clave );
valores.addElement( valor );
return( clave );
}

public Object get( Object clave ) {
int indice = claves.indexOf( clave );
// El metodo indexOf() devuelve -1 si no encuentra la clave que se
// esta buscando
if( indice == -1 )
return( null );
return( valores.elementAt( indice ) );
}

public Object remove(Object clave) {
int indice = claves.indexOf( clave );

if( indice == -1 )
return( null );
claves.removeElementAt( indice );
Object valorRetorno = valores.elementAt( indice );
valores.removeElementAt( indice );
return( valorRetorno );
}

public Enumeration keys() {
return( claves.elements() );
}

public Enumeration elements() {
return( valores.elements() );
}

// Ahora es cuando se prueba el ejemplo
public static void main( String args[] ) {
java416 ej = new java416();
for( char c='a'; c <= 'z'; c++ ) ej.put( String.valueOf( c ),String.valueOf( c ).toUpperCase() ); char[] vocales = { 'a','e','i','o','u' }; for( int i=0; i < 19="526," 18="533," 17="460," 16="513," 15="521," 14="495," 13="512," 12="483," 11="488," 10="487," 9="514," 8="523," 7="497," 6="487," 5="489," 3="509," 2="503," 1="475," 0="505}" numero =" n;" numero ="="" oscuridad =" Math.random()"> 0.5;

public String toString() {
if( oscuridad )
return( "Seis semanas mas de Invierno!" );
else
return( "Entrando en la Primavera!" );
}
}

public class java419 {
public static void main(String args[]) {
Hashtable ht = new Hashtable();

for( int i=0; i < 10; i++ )
ht.put( new Oso2( i ),new Prediccion() );
System.out.println( "ht = "+ht+"\n" );

System.out.println( "Comprobando la prediccion para el oso #3:");
Oso2 oso = new Oso2( 3 );
if( ht.containsKey( oso ) )
System.out.println( (Prediccion)ht.get( oso ) );
}
}

El método hashCode() devuelve el número que corresponde a un Oso como un identificador, siendo el programador el responsable de que no haya dos números iguales. El método hashCode() no es necesario que devuelva un identificador, sino que eso es necesario porque equals() debe ser capaz de determinar estrictamente cuando dos objetos son equivalentes.

El método equals() realiza dos comprobaciones adicionales, una para comprobar si el objeto es null, y, en caso de que no lo sea, comprobar que sea una instancia de Oso, para poder realizar las comparaciones, que se basan en los números asignados a cada objeto Oso. Cuando se ejecuta este nuevo programa, sí se produce la salida correcta. Hay muchas clases de la librería de Java que sobreescriben los métodos hashCode() y equals() basándose en el tipo de objetos que son capaces de crear.

Las tablas Hash son utilizadas también por muchas clases de la librería estándar de Java, por ejemplo, para obtener las propiedades del sistema se usa la clase Properties que hereda directamente de Hashtable. Y además, contiene una segunda Hashtable en donde guarda las propiedades del sistema que se usan por defecto.

Aishwarya Rai

pero kien va a tener dudas de ke esta mujer, ¿es la mujer mas bella del planeta?

pues k no les kede dudas a nadie ps si, Aishwarya Rai, es sin duda la mujer mas bella del planeta gandora de del miss mundo 1994 y declarada como la miss mas bella de todos los certamenes de belleza.

mas...

MI INFANCIA

la infancia es una etapa que tal vez o kizas muchos de nosotros no recordamos con claridad. kizas basta con solo preguntar a algun familliar de mas edad k nosotros.
la infancia para es un a etapa de la vida muy bella, etapa en donde uno aprende a desarrollarse, a formarse de alguna manera...

mi infancia no fue una infancia muy distinta k digamos als demas infancias de los demas niños de mi epoca de niñez, segun lo k recuerdo mi vida infantil transcurrio en un distrito de arequipa, distrito de la joya, komo se sabe la joya es una irrigacion por lo tanto mi vida infantil se desarrollo en ese lugar rodeada de bastante naturaleza y mucha paz.

las anecdotas de la vida infantil, kizas uno mismo no las recuerde bien, pero me apego al relato de mis tios k me dijieron k de niña era muy traviesa, y alegre, cosa k kreo k aun mantengo, la alegria por la vida.

bueno para no aburrir a nadie mi infancia no fue tan importante o transcendental komo yo kisiera, se desarrollo en un ambiente tipico de la vida cotidiana de las personas...
en resumen kreo k mi infancia fue algo normal.