Como usar Beans en JSP
En nuestro articulo de hoy trataremos sobre el uso de beans dentro de
nuestras páginas jsp, este material está incluido dentro de nuestro Máster en desarrollo de aplicaciones web empresariales con Java EE.
Los famosos java beans que se utilizan en JavaEE, se pueden utilizar en jsp, las principales características son:
• Los JavaBeans son objetos Java que cumplen ciertas características en cuanto a su diseño.
• Se utilizan para reducir al máximo el código Java insertado en una página JSP. En lugar de meterlo directamente en el fichero JSP se mete en un objeto y éste se llama desde el JSP.
• Permite separar la lógica de ejecución (en el JavaBean) de la presentación (en el servlet generado)
Se encapsula el código Java en un objeto (JavaBean) y se instancia y usa con el JSP.
-Si se usa un JavaBean en una página habrá que definir la clase
correspondiente, creando los métodos set y get para los atributos definidos • Dentro del servlet generado se puede llamar a métodos de un JavaBean que se encarguen de realizar ciertas operaciones y el servlet muestra el resultado de las mismas
• Ventaja del traslado de la lógica a un JavaBean – Separación de interfaz de la implementación
Ejemplo
1.- Clase beans
public class LenguajeBean { private String nombre; private String lenguaje; public LenguajeBean() {}
public void setNombre(String nombre) { this.nombre=nombre;
}
public String getNombre(){ return nombre;
}
public void setLenguaje(String lenguaje){ this.lenguaje=lenguaje;
}
public String getLenguaje() { return lenguaje;
}
public String getcomentariosLenguaje (){ if (lenguaje.equals(“Java”)){
return “El rey de los lenguaje Orientados a objetos”; }
else if (lenguaje.equals(“C++”)){ return “Demasiado complejo”;
} else if (lenguaje.equals(“Perl”)){
return “OK si te gusta el códigoincomprensible”; }else {
return “Lo siento, no conozco ellenguaje ” + lenguaje ; }
} }
Certificaciones oficiales AEPI para
Java, Android y JavaScript
Hoy vamos a tratar el programa de certificaciones oficiales que la Asociación
Española de Programadores Informáticos – AEPI va a poner en marcha en breve. ¿Te gustaría certificarte en JavaSE, Android o JavaScript?
AEPI te brinda la posibilidad a través de su programa de certificaciones oficiales poseer una nueva cualificación profesional de cara al exigente mercado laboral.
¿Cuáles son las certificaciones?
Actualmente nuestro programa de certificaciones consta de las siguientes: Certificación Profesional JavaSE – AEPI (CPJSEA)
Certificación Profesional Android – AEPI (CPAA) Certificación Profesional JavaScript – AEPI (CPJSA)
Próximamente ampliaremos nuestro programa de certificaciones a otras tecnologías.
¿Cuales son los requisitos para poder certificarme?
No existe ningún tipo de requisito. Cada 4 meses abriremos el plazo de presentación de solicitudes para que cualquier persona que lo desee pueda presentarse al examen.
¿En qué consiste el examen?
El examen es presencial en nuestras instalaciones, consta de un total de 60 preguntas, las cuales se responden por escrito, las preguntas contendrán teoría y resolución de problemas a partes iguales. Tendrás 1 hora para acabar tu examen. Para aprobar necesitarás responder correctamente 50 preguntas.
¿Qué ventajas tiene certificarme?
Contar con una certificación es dotar a nuestra carrera profesional de
credenciales que nos permiten asegurar a una entidad (organización, empresa, etc) cierto nivel de conocimiento y/o habilidades que un tercero ha validado, y que por cierto esta entidad también confía. Podemos hacer una analogía con la infraestructura que soporta a los certificados digitales, quien los emite es un tercero en que nosotros y cualquier otro confía.
Beneficios de las Certificaciones
1) Optar a nuevos puestos de trabajo o mejorar el existente y aumentos de sueldo.
2) Contar con el respaldo de una gran institución como es la Asociación Española de Programadores Informáticos.
3) Las certificaciones AEPI son validas en todo el mundo.
4) Mayor confianza acerca de nuestro conocimiento o habilidades. 5) Mayor productividad.
¿Cuál es el precio de la certificación?
La tasa de examen tiene un precio de 150 Euros.
¿Qué obtengo al certificarme?
Una vez superado con éxito el examen, recibirás tu certificación junto con un carné profesional que podrás llevar siempre contigo y así poder demostrar que estás certificado por AEPI.
Cualquier empresa que lo desee podrá ponerse en contacto con nosotros para confirmar la validez de tu certificación.
Actualmente estamos trabajando con grandes empresas para que tu certificación tenga un gran reconocimiento laboral y peso internacional.
¿Cuál es la próxima convocatoria?
El próximo examen será el Sábado 18 de Octubre a las 10 de la mañana. El plazo de presentación desolicitudes comenzará el Lunes 1 de Septiembre.
Trabajo con sesiones en PHP
En nuestro artículo de hoy nos vamos a centrar en como trabajar con las sesiones en PHP, este artículo es parte de nuestro curso profesional de PHP6 y MYSQL
Cuando queremos utilizar variables de sesión en una página tenemos que iniciar la sesión con la siguiente función:
session_start ()
Inicia una sesión para el usuario o continúa la sesión que pudiera tener abierta en otras páginas. Al hacer session_start() PHP internamente recibe el identificador de sesión almacenado en la cookie o el que se envíe a través de la URL. Si no existe tal identificador se sesión, simplemente lo crea.
Nota: Si en el php.ini se ha definido la variable session.auto_start = 1 se inicializa automáticamente la sesión en cada página que visita un usuario, sin que se tenga que hacer el session_start()
La sesión se tiene que inicializar antes de escribir cualquier texto en la página. Esto es importante y de no hacerlo así corremos el riesgo de recibir un error.
Una vez iniciada la sesión podemos utilizar variables de sesión a través de $_SESSION, que es un array asociativo, donde se accede a cada variable a partir de su nombre, de este modo:
Ejemplo de código para definir una variable de sesión: <? session_start(); ?> <html> <head>
<title>Generar variable de sesión</title> </head>
<body> <?
$_SESSION[“mivariabledesesion”] = “Hola este es el valor de la variable de sesión”;
?> </body> </html>
Con lo visto, vamos a proponer el ejemplo clásico de utilización de una
sesión: un contador. Este contador deberá aumentar de una unidad cada vez que recargamos la página o apretamos al enlace:
<? session_register(‘contador’); ?> <HTML> <HEAD> <TITLE>contador.php</TITLE> </HEAD> <BODY> <? If (isset($contador)==0) {$contador=0;} ++$contador;
echo “<a href=”contador.php”>Has recargado esta página $contador veces</a>”; ?>
</HTML>
La condición if tiene en cuenta la posibilidad de que la
variable $contador no haya sido todavía inicializada. La función isset se encarga de dar un valor cero cuando una variable no ha sido inicializada. Otras funciones útiles para la gestión de sesiones son:
Función Descripción
Session_id() Nos devuelve el identificador dela sesión
Session_destroy() Da por abandonada la sesióneliminando variables e identificador.
Session_unregister(‘variable’) Abandona una variable sesión
Paso por referencia de una tupla en
C/C++
En nuestro artículo de hoy os mostraremos como pasar por referencia un tupla en c/c++
Sea la tupla t_trol: typedef struct trol{ int x,y;
}t_trol;
Se puede tener una función de inicialización con un puntero de tipo t_trol* como parámetro: void init(t_trol*p) { p->x=rand()%800; p->y=rand()%600; p->color=rand()%256; }
Y en alguna parte, la llamada: t_trol t;
init(&t); // paso de la dirección de la struct t_trol
En el caso de la tabla de punteros, no hay que olvidar asignar los punteros. En efecto, si se escribe por ejemplo:
t_trol* ALL[10]; int i;
for (i=0; i<10; i++){
init(ALL[i]); // ¡ERROR! ALL[i] NO ASIGNADO }
provoca un error de ejecución, ALL[i] no tiene una dirección de memoria reservada. Por lo tanto, hay que añadir previamente la asignación de memoria (sea en el mismo sitio, o en cualquier otra parte en el programa):
ALL[i]=(t_trol*)malloc(sizeof(t_trol)); init(ALL[i]); // OK, ALL[i] ASIGNADO }
Espero que este artículo te sea de utilidad o que simplemente te haya gustado, si es así compártenos¡¡¡
Mini tutorial JavaMail – Enviar
correos con adjuntos en JavaMail
(Parte IV)
Vamos con nuestra última parte de este mini tutorial de JavaMail.
Suponemos que ya te has bajado JavaMail y JAF, además de que has leído -o sabes- cómo enviar un correo simple con JavaMail.
Ahora que ya sabemos recibir correos con JavaMail y hemos visto más o menos la estructura que tiene un correo compuesto, vamos a enviar nuestro propio correo compuesto: un texto con una imagen adjunta.
Para el ejemplo usaremos una cuenta de gmail. Aunque mencionaré aquí como conectarse, puedes ver aquí los detalles de la conexión con gmail para el envío de correos.
Habíamos visto que un correo compuesto tiene más o menos una estructura de árbol. Cada nodo del árbol tiene como datos una clase MultiPart. Las hojas del árbol son las que contienen la información del correo, es decir, el texto, la imagen, etc.
Clases implicadas
Las clases que necesitamos para enviar un correo con adjuntos con JavaMail son
Session y Transport para la conexión con gmail y envio del mensaje. MimeMessage, MimeMultiPart y MimeBodyPart Para construir el mensaje. Obtención de Session
Como mencionamos en el envio de un correo sencillo, necesitamos obtener una instancia de Session y para ello necesitamos previamente rellenar una
variable Properties.
Properties props = new Properties();
props.put(“mail.smtp.host”, “smtp.gmail.com”);
props.setProperty(“mail.smtp.starttls.enable”, “true”); props.setProperty(“mail.smtp.port”,”587″);
props.setProperty(“mail.smtp.user”, “[email protected]”); props.setProperty(“mail.smtp.auth”, “true”);
Session session = Session.getDefaultInstance(props, null); session.setDebug(true);
Los detalles de estos valores que hemos rellenado puedes verlos en el enlace anterior.
Con esto ya tenemos instanciada la clase Session. Vamos ahora a construir el mensaje
Construir un correo de texto con un adjunto
Lo primero vamos a construir las dos partes del mensaje. El texto y la
imagen. Para ello, instanciamos dos clases MimeBodyPart y las rellenamos con los datos.
Empezamos con la de texto, que es más sencilla BodyPart texto = new MimeBodyPart();
texto.setText(“Texto del mensaje”);
todo para que sea un texto plano -text/plain en MIME type-.
El adjunto con la imagen también es sencillo. Supongamos que tenemos la imagen en un fichero D:\futbol.gif -por supuesto, de una extensión conocida por
java-También debemos crear un MimeBodyPart, pero esta vez llamamos al
método setContent(). A este método hay que pasarle un DataHandler, que es una clase capaz de manejar los datos que vayan en esta parte. Para instanciar ese DataHandler debemos darle una fuente de datos. La fuente, puesto que tenemos la imagen en fichero, puede ser una claseFileDataSource, capaz de leer un fichero con datos y saber de qué tipo es (imagen, audio, etc). En resumen, el código sería este
BodyPart adjunto = new MimeBodyPart();
adjunto.setDataHandler(new DataHandler(new FileDataSource(“d:/futbol.gif”))); adjunto.setFileName(“futbol.gif”);
La llamada a setFileName() es opcional. Haciéndola le daremos al receptor del correo posibilidad de saber el nombre del fichero de imagen. Si no lo
ponemos, no pasa nada.
Juntar el texto y la imagen adjunta
Ahora debemos juntar estas dos partes en una única parte compuesta.
Para ello, instanciamos una clase MimeMultiPart y le añadimos ambos cachos. La clase MimeMultiPart no es más que una parte más de un correo, pero que está a su vez compuesta de otras partes -el texto y la imagen en nuestro caso-. Podemos ir añadiendo aquí todas las imagenes y otros ficheros que queramos.
MimeMultipart multiParte = new MimeMultipart(); multiParte.addBodyPart(texto);
multiParte.addBodyPart(adjunto);
Ya está. Ahora sólo nos falta el mensaje en sí, algo a lo que podamos dar un destinatario de correo, un asunto -subject-, etc.
Construir el mensaje de correo
El mensaje a construir es simplemente una instancia de MimeMessage. Al instanciarlo debemos pasarle el objeto Session que obtuvimos anteriormente. También debemos rellenar los campos de destinatario y demás. Y finalmente también debemos rellenar el contenido, metiendo nuestro MimeMultipart anterior.
Los detalles de los campos subject, to y from puedes verlos en el envío de un mensaje sencillo con JavaMail.
El código quedaría así
MimeMessage message = new MimeMessage(session); // Se rellena el From
message.setFrom(new InternetAddress(“[email protected]”)); // Se rellenan los destinatarios
message.addRecipient(Message.RecipientType.TO, new InternetAddress(“[email protected]”));
// Se rellena el subject message.setSubject(“Hola”);
// Se mete el texto y la foto adjunta. message.setContent(multiParte);
Ya tenemos compuesto el total del correo. Ahora sólo queda enviarlo
Enviar el correo
Ya lo vimos en el ejemplo sencillo de envio de correo con JavaMail. Sólo tenemos que hacer lo siguiente.
Transport t = session.getTransport(“smtp”); t.connect(“[email protected]”,”la password”); t.sendMessage(message,message.getAllRecipients()); t.close();
del envio del correo.
Realizamos la conexión dando usuario -correo de gmail de la cuenta que estemos usando- y la clave.
Enviamos el mensaje con sendMessage(). Ojo, no uses el método send() a secas, porque ese no tiene en cuenta los parámetros de conexión.
