¿Tienes tiempo? Entonces tenemos una canción para recomendarte. El único problema, es que dura 1000 años. De todos modos, no podrás escucharla desde el principio, porque comenzó a sonar en el año 2000, o la noche del 31 de diciembre de 1999 para ser más exacto y aún hoy continúa sonando. Esta pieza musical conocida como Longplayer fue compuesta por Jem Finer y está diseñada para durar 1000 años sin repetirse nunca. La versión que suena constantemente es generada por computadora, pero también hay versines en vivo que duran cerca de 1000 segundos.
Y aunque ya ha estado sonando desde hace una década, nuevamente es noticia porque el 16 de octubre 18 músicos utilizarán tazones cantores para representar 1000 segundos de la composición hecha por Jem Finer. Esto se llevará a cabo durante un evento organizado por The Long Now Foundation, donde varias de las mentes más importantes del Área de la Bahía de San Francisco presentarán charlas de distintos tópicos, para discutir con los presentes.
Longplayer Live : 1000 seconds from Longplayer on Vimeo.
La versión de la canción que está sonando constantemente desde el año 2000 fue diseñada por Jem Finer en su computadora y actualmente lleva sonando 10 años, 286 días, 11 horas, 06 minutos y 07 segundos (y contando…). Si quieres, puedes visitar el sitio oficial donde puedes ver exactamente cuánto lleva sonando y hasta puedes escucharla en tiempo real. Y no solo puede ser escuchada en su sitio oficial, sino que hay varios puntos en el mundo donde suena desde que comenzó, como el faro del Trinity Buoy Wharf en Londres.
Según explica el sitio oficial: “Longplayer está compuesta para tazones cantores que pueden ser tocados tanto por seres humanos como máquinas y, cuya resonancia, puede ser reproducida con mucha exactitud en forma grabada. La pieza está diseñada para poder adaptarse a los cambios imprevistos en su entorno tecnológico y social, y para perdurar como una institución autosuficiente por un largo plazo.” Esto se debe a que la canción terminará en el año 2999 y luego volverá a comenzar.
Sitio oficial: Longplayer
¿Comeremos insectos en el futuro?
La ONU quiere incentivar la creación de granjas de insectos para que la humanidad pueda consumir grandes cantidades de bichos y sustituir en parte la dieta habitual de las sociedades occidentalizadas. Argumentan que el ganado tradicional agota los recursos naturales y, sobre todo, que se podrían evitar gran parte de sus gases “traseros” de efecto invernadero, que según algunos estudios, son los principales responsables del calentamiento global ¿Tu cambiarías un buen bistec por una sabrosa ración de cucarachas a la plancha por tal de ayudar al planeta?.
No se trata de ninguna broma de mal gusto (nunca mejor dicho). El entomólogo Arnold van Huis considera el consumo de insectos en la dieta humana como una buena propuesta porque representa una serie de ventajas sobre la ecología y el bienestar de la sociedad que merecen ser valoradas. Antes de que nuestros lectores se lleven las manos a la boca en señal de una incipiente descarga de fluidos gástricos, hemos de decir que los argumentos del científico no son tan descabellados y, a poco que los analicemos desprovistos de prejuicios, la idea no nos parecerá tan horrible ni tan fuera de lugar.
Recordemos que en otras culturas se comen todo tipo de insectos con toda naturalidad e incluso algunos están considerados auténticos manjares al alcance de muy pocos bolsillos. Y a la inversa, muchas culturas encuentran absolutamente repugnante que algunos países europeos (España y Francia) degusten los caracoles como una delicatessen. Incluso los astronautas comen gusanitos de seda. Es una mera cuestión cultural que podemos entrenar puesto que el sabor de las comidas está en nuestra mente.
En otras culturas se comen bichos sin tantos traumas ni aspavientos
Huis ha escrito un documento donde expone las ventajas de incluir a los insectos en nuestro menú habitual y también propone unas directrices para que nos acostumbremos progresivamente al consumo de estos animales tan desagradables para nuestra cultura. El experto asegura que el ganado tradicional genera una enorme cantidad de gases de efecto invernadero cuando expelen por su parte trasera el metano que producen sus intestinos. La cría controlada de gusanos de la harina o de grillos, emitiría a la atmósfera 10 veces menos metano y 100 veces menos óxido nitroso. Además, el riesgo de contraer enfermedades contagiosas por comer bichos sería mucho menor ya que estos animales se encuentran a años luz de cualquier parentesco biológico con nuestra especie. Y como colofón, el experto afirma que sería mucho más barato y más sencillo producir este tipo de comida. Existen 1000 especies que son perfectamente comestibles y que aportan gran cantidad de proteínas, nutrientes y minerales. La variedad está garantizada.
Lo mejor es cuando aprieto la cebeza y sale el liquidillo ¡Sublime!
Tan racional le ha parecido a la FAO el plan de Huis que está valorando con sumo interés el documento que ha presentado. La ONU tiene la firme intención de patrocinar la implantación masiva de este tipo de industria. Por lo pronto, están incentivando la construcción de granjas de insectos en Laos y ya existen 15.000 granjeros tailandeses “cultivando” langostas en sus propios hogares. Y para evitar que en occidente sea rechazada de plano esta iniciativa, Huis propone dos fases para introducir la idea: En la primera, se convertiría a los bichos en pienso para ganado tradicional y, en la segunda, se introduciría poco a poco para el consumo humano, inicialmente en forma de pastel de carne, para que nuestros paladares se fueran acostumbrando al manjar insectívoro.
¡Camarero! de beber me pone usted un chorro de espuma de lombriz de tierra espachurrada. No muy caliente, por favor. Y me trae una sopa fluida de gusano verde de primer plato, una ensalada de larvas meneándose en su hoja, una tortilla de garrapatas rellenas, un bistec de muslo de langosta poco hecho y un pastel de antenas de grillo. ¡Ah!, y no le ponga cebolla, que luego me huele el aliento.
UNA CANCIÓN QUE DURA 1000 AÑOS (¡¡¡¡MIL AÑOS!!!!) »« Tendencias Tecnológicas-Siglo21 1era y 2da década
CIUDAD DE MÉXICO (CNNExpansión.com) — El 2010 representa un año de oportunidades en donde las compañías ya en recuperación tienen la oportunidad de subirse al barco tecnológico para poder mejorar sus operaciones y costos, al mismo tiempo que integran innovación a sus negocios.
Aquí te presentamos las 6 tendencias tecnológicas para 2010 de acuerdo con Citrix, empresa especializada en tecnología de la información (TI).
1. El reinado de los smartphones
La movilidad se convierte en una de las tendencias principales del año, con cada vez más personas acudiendo almercado de teléfonos inteligentes para poder utilizarlos como herramientas de trabajo, aunado a la introducción de más empresas como Google al sector.
La consultora Gartner prevé que 1,200 millones de personas dispondrán de terminales con capacidad para conectarse a la Web y realizar operaciones de comercio electrónico móvil a finales de 2010, impulsando la convergencia entre movilidad e Internet.
La importancia de contar con equipos que cuentan con conexión a Internet reside en la posibilidad de comunicarse en cualquier lugar, en cualquier momento y de la manera más inmediata posible.
2. La virtualización
«El 2010 será probablemente un año definitivo para la virtualización de escritorios. Se estima que el gasto destinado a la adquisición del hardware y del software para puestos de trabajo supone normalmente entre el 20 y el 30% del coste total del equipo, mientras el 70-80% restante corresponde a la gestión de tecnología de información (TI) del dispositivo durante su ciclo de vida», afirma la compañía Citrix.
En específico la virtualización de escritorios tiene actualmente un tamaño de mercado de 35 millones de servidores en todo el mundo, y tiene el potencial de impactar a más de 600 millones de usuarios contando solamente los entornos corporativos
La virtualización de escritorios permite a los usuarios acceder a sus archivos desde cualquier lugar en cualquier momento, además elimina las funciones de mantenimiento y mejora el almacenamiento de la información.
«Ahora que Windows 7 ya está disponible y la economía muestra sus primeros signos de recuperación, el punto de inflexión para la adopción masiva de la virtualización de escritorios ha llegado», afirma la empresa.
3. Viva la nube
La posibilidad de contar con servicios «en la nube» o de «cloud computing» serán más palpables en el 2010 con el empuje de empresas como Google y su sistema operativo Google Chrome que mantendrá almacenada en un espacio virtual la información que tienen los usuarios en sus computadoras.
Citrix considera que los centros de datos corporativos se convertirán en clouds internos, mientras las Pymes se apoyarán en clouds externos para administrar sus servicios TI.
4. Las tecnologías populares en el trabajo
Con la introducción de equipos como los iPhone, el Google Nexus, las netbooks y otros dispositivos creados para el consumidor promedio, las empresas se ven en la necesidad de integrarlos dentro de sus medios de trabajo por el creciente deseo de sus empleados de utilizar su tecnología preferida en el trabajo.
«En este sentido, los trabajadores de la generación digital a menudo alternan su equipo personal con el corporativo como herramienta de trabajo, por lo que las empresas deben comenzar a asumir los nuevos comportamientos de los usuarios sin por ello renunciar a una política de reglas comunes», considera Citrix.
5. El ahorro de energía
Una tendencia que supera al entorno tecnológico es el cuidado del medioambiente y del consumo de energía.
Por un lado las empresas buscan bajar sus costos por consumo de energía con equipos de mayor rendimiento y por el otro, las naciones pretenden realizar un esfuerzo global para disminuir las emisiones de gases de efecto invernadero generadas por el consumo de electricidad.
Ante esto las empresas están optando más por equipos y aplicaciones que consumen menor energía, así como la opción del teletrabajo, de acuerdo con Citrix.
6. Más de un sistema operativo
La tecnología «hypervisor» que permite que varios sistemas operativos coexistan en el mismo equipo posibilita a los usuarios a acceder a sus perfiles personales y profesionales sin tener que cambiar de equipo.
¿Comeremos insectos en el futuro? »« NUEVAS TECNOLOGÍAS 2010
Nuevos diseños de edificios en Corea
Computadora con tres pantallas
Pantalla Curva de Apple
Mesa-Computadora
Celular compacto y transparente
Lapicera Nokia con 1.3MB de memoria para grabar lo que escribís
Celulares touch screen con pantallas anexables
Extrañas computadoras de Samsung
Celular/computadora con pantalla extensible
Reproductor de DVD…
…y sus controles remotos
Celular touch screen con forma de brújula
Nuevo diseño de mouse
Pantallas flexibles de Sony
Computadora y lámpara de pie
Hermoso diseño de canilla (o grifo)
Novedosa bañadera
Baño oculto
Ropa que carga energía durante el día e ilumina de noche
Control remoto multiuso
Cocina futurista
Ducha con luces
Muebles inteligentes
Puente de un solo punto de apoyo en Malasia
Papel electrónico para correcciones sencillas
Puertas lámparas
Bicicleta para toda la familia
Mesa de comedor y de pool[size=18][/size]
Oficina plegable
Nueva cámara de Samsung
[color=blue]Nuevo reproductor de MP3[/color]
Estación de cocina móvil
Nueva caja fuerte touch screen
Nuevo diseño de peceras
Pantallas de TV plegables
Y?¿?¿ que les parecio?.. comenten si? nos vemos en la proxima!
Tendencias Tecnológicas-Siglo21 1era y 2da década »« EVOLUCIÓN DEL WINDOWS
El sistema operativo Windows de la compañía Microsoft a tenido varias versiones cada una con modificaciones en la apariencia. Cabe señalar que el peor de todas estas versiones a sido el Windows Milenium tanto en apariencia como en funcionalidad. Actualmente el Mejor sistema operativo es el Windows 7 que por los gráficos, funcionalidad y facilidad de compatibilidad nos da una percepción de mezcla entre el Windows Xp y el Windows Vista.
La evolución gráfica se muestra a continuación con la ayuda de imágenes de las pantallas (capturas de pantalla).
WINDOWS 1.0
Lanzado en Noviembre de 1985, es la primera versión con interfaz gráfica. Agrega soporte para mouse y permite ejecutar varias tareas a la vez. Detalles como la Papelera de Reciclaje y la opción de poner una ventana encima de la otra no pudieron ser implementadas por problemas legales con Apple. AUNQUE DEBO INFORMARLES QUE EL PARADIGMA DE LAS VENTANAS Y EL MOUSE LO HIZO LA COMPAÑÍA XEROX.
Windows 2.0:
Windows 2.0:
Windows se expandió en el mercado con esta nueva vesión, y varios de los problemas de patentes con Apple ya habían sido solucionados.
Windows 3.0
Lanzado en el 1990. Aquí comenzó a competir realmente con el sistema operativo de Mac. El sistema incluía una nueva forma de organizar archivos, mejores gráficos y un manejo de memoria optimizado. En sólo dos años se vendieron más de 10 millones de copias. Todo un éxito.
Windows 3.11:
Técnicamente una lavada de cara de la versión anterior, pero con varios agregados: soporte para fuentes TrueType escalables, capacidades multimedia y mucho más.
Windows 3.11 NT:
El Windows 3.11 totalmente mejorado, pensado para uso profesional, mucho más robusto. NT estaba escrito para procesadores de 32 bits, a diferencia de la versión 3.11. El sistema operativo solo mantuvo una parte del mercado ya que poseía poco soporte de hardware (para los fabricantes era muy complejo crear drivers compatibles)
Windows 95:
Un lavado de cara para Windows, totalmente renovado e introduciendo el botón Start y la barra de tareas (que hasta hoy se mantienen), Windows 95 llegó para quedarse por unos años. Venía incluído Internet Explorer, introduciendo la navegación en la web.
Windows 98:
Windows 98 incluye soporte para múltiples monitores, WebTV y particiones más grandes gracias al nuevo sistema FAT32. Esta versión incorpora el Internet Explorer dentro de la interfaz. Luego se lanzó la segunda edición con algunas funciones extra.
Windows 2000:
Fue lanzado en el año 2000 como una actualización del Windows NT. Fue el primero en poder actualizarse automáticamente por internet.
Windows ME:
También conocido como “Mistake Edition” (imaginen por qué). Lleno de problemas de compatibilidad y estabilidad, esta versión de Windows fue un paso al XP. Microsoft dio poco soporte al sistema ya que rápidamente se lanzó la nueva versión. Resultó ser un fracaso total, ya que recibió quejas de más del 75% de los clientes que habían comprado esta versión de Windows.
Windows XP:
La versión más estable de Windows. Lanzada en el año 2001 y utilizada hasta hoy. Fusiona características de la línea NT y 9X. Funciona con mayor velocidad, sin los famosos cuelgues y mucho más estable. Definitivamente vale la pena.
Windows Vista
Una versión de las más discutidas. Agrega efectos visuales asombrosos y varias opciones innovadoras como mejor control en las cuentas de usuarios, firewall bi-direccional, mayor seguridad, anti spyware, Windows Search, la barra del costado, y mucho más.
windows 7
Las listas Jump Listque permiten localizar rápidamente los archivos con los que se ha trabajado recientemente. Haga clic con el botón secundario en un icono de programa de la barra de tareas para ver una lista de los archivos abiertos recientemente. Además, puede anclar a una lista Jump List los archivos que use periódicamente. Algunas listas Jump List muestran comandos para las tareas habituales, como reproducir música o vídeos.
Windows 7 simplifica el trabajo con las ventanas en el escritorio. Ahora dispone de formas más intuitivas para abrir, cerrar, organizar y cambiar el tamaño de las ventanas.
Para maximizar una ventana, arrástrela por el borde hasta la parte superior de la pantalla, y para devolverla a su tamaño original, arrástrela fuera de la parte superior de la pantalla. Arrastre una ventana por el borde inferior para expandirla verticalmente.
Para comparar el contenido de dos ventanas, arrástrelas a dos lados opuestos de la pantalla. El tamaño de cada ventana cambiará para ocupar la mitad de la pantalla.
PANTALLAS DE INICIO.
A continuación mostraremos las pantallas de inicio desde el windows 1.0 hasta el windows7.
Microsoft Windows el sistema operativo más usado del mundo, pero tal vez no conozcas su evolución a través del tiempo desde el lanzamiento de la versión 1.0 en 1985.
Por eso a continuación podrás ver la evolución del OS más popular del mundo desde otra perspectiva, viendo sus pantallas de inicio de sus versiones más significativas de su historia hasta llegar al día de hoy con la versión nueva versión que está por llegar Windows 7.
Windows 1.0
En 1985 Microsoft publicó la primera versión de Windows, una interfaz gráfica de usuario (GUI) para su propio sistema operativo (MS-DOS) que había sido incluido en el IBM PC y ordenadores compatibles desde 1981.
Windows 2.0
Apareció en 1987, y fue un poco más popular que la versión inicial. Gran parte de esta popularidad la obtuvo de la inclusión en forma de versión «run-time» de nuevas aplicaciones gráficas de Microsoft, Microsoft Excel y Microsoft Word para Windows.
Windows 3.0
La primera versión realmente popular de Windows fue la versión 3.0, publicada en 1990. Ésta se benefició de las mejoradas capacidades gráficas para PC de esta época, y también del microprocesador 80386, que permitía mejoras en las capacidades multitarea de las aplicaciones Windows.
Windows 3.1
En respuesta a la aparición de OS/2 2.0 , Microsoft desarrolló Windows 3.1, que incluía diversas pequeñas mejoras a Windows 3.0 (como las fuentes escalables TrueType), pero que consistía principalmente en soporte multimedia.
Windows NT
Siendo un sistema operativo completamente nuevo, Windows NT sufrió problemas de compatibilidad con el hardware y el software existentes. También necesitaba gran cantidad de recursos y éstos estaban solamente disponibles en equipos grandes y caros. No fue muy popular.
Windows 95
Microsoft adoptó «Windows 95» como nombre de producto para Chicago cuando fue publicado en agosto de 1995. Chicago iba encaminado a incorporar una nueva interfaz gráfica que compitiera con la de OS/2.
Windows 98
El 25 de junio de 1998 llegó Windows 98. Incluía nuevos controladores de hardware y el sistema de ficheros FAT32 (también soportado por Windows 95 OSR 2 y OSR 2.5) que soportaba particiones mayores a los 2 GB permitidos por Windows 95. Dio soporte también a las nuevas tecnologías como DVD, FireWire, USB o AGP. Era novedosa también la integración del explorador de Internet en todos los ámbitos del sistema.
Windows Millenium Edition (ME)
En 2000 Microsoft introdujo Windows ME, que era una copia de Windows 98 con más aplicaciones añadidas. Windows ME fue un proyecto rápido de un año para rellenar el hueco entre Windows 98 y el nuevo Windows 2000.
Windows 2000
Una nueva versión de Windows NT muy útil para los administradores de sistemas y con una gran cantidad de servicios de red y lo más importante: admitía dispositivos Plug&Play que venían siendo un problema con Windows NT.
Windows XP
La unión de Windows NT/2000 y la familia de Windows 9.x se alcanzó con Windows XP puesto en venta en 2001 en su versión Home y Professional. Windows XP usa el núcleo de Windows NT. Incorpora una nueva interfaz y hace alarde de mayores capacidades multimedia. Además dispone de otras novedades como la multitarea mejorada, soporte para redes inalámbricas y asistencia remota.
Windows Vista
Windows Vista apareció en el mercado el 30 de enero de 2007. Cabe destacar los continuos retrasos en las fechas de entrega del sistema operativo, ha sido criticado por su falta de compatibilidad, entre otras cosas, haciendo que la mayoría de los usuarios regresen a su antecesor Windows XP.
Esta es la historia de Windows en imágenes, hasta el día de hoy. Se puede ver claramente como han evolucionado los sistemas no sólo en el aspecto gráfico sino en la interfase, comodidad e integración con periféricos externos.
¿Qué sistema operativo te a gustado más?. ¿Qué cosas de los antigüos windows te gustaría que tenga el windows7?
POR FAVOR NO TE OLVIDES DE COMENTAR.
Aqui se presenta el código de los servlet que determina si el usuario es bloqueado,
en este caso los usuarios que no son administradores(se los bloquea)
package DAW;
import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.servlet.http.*;
/**
*
* @author estudiante
*/
public class controller2 extends HttpServlet{
/** Creates a new instance of NewClass */
protected void processRequest(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException{
String usuario=req.getParameter(«usuario»);
String password=req.getParameter(«pasword»);
res.setContentType(«text/html; charset=UTF-8»);
//PrintWriter out = res.getWriter();
if(usuario.equalsIgnoreCase(«admin») && password.equalsIgnoreCase(«admin»)){
String nextJSP = «/pagina4.jsp»;
RequestDispatcher rd = getServletContext().getRequestDispatcher(nextJSP);
rd.forward(req, res);
}else
res.sendError(401,»Usted esta bloqueado»);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
processRequest(request, response);
}
/** Handles the HTTP <code>POST</code> method.
* @param request servlet request
* @param response servlet response
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
processRequest(request, response);
}
/** Returns a short description of the servlet.
*/
public String getServletInfo() {
return «Short description»;
}
}
Aqui se presenta el código de los servlet que determina si el usuario es bloqueado,
en este caso los usuarios que no son estudiantes(se los bloquea)
package DAW;
import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.servlet.http.*;
/**
*
* @author estudiante
*/
public class controller extends HttpServlet{
/** Creates a new instance of NewClass */
protected void processRequest(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException{
String usuario=req.getParameter(«usuario»);
String password=req.getParameter(«pasword»);
res.setContentType(«text/html; charset=UTF-8»);
//PrintWriter out = res.getWriter();
if(usuario.equalsIgnoreCase(«estud») && password.equalsIgnoreCase(«estud»)){
String nextJSP = «/pagina3.jsp»;
RequestDispatcher rd = getServletContext().getRequestDispatcher(nextJSP);
rd.forward(req, res);
}else
res.sendError(401,»Usted esta bloqueado»);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
processRequest(request, response);
}
/** Handles the HTTP <code>POST</code> method.
* @param request servlet request
* @param response servlet response
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
processRequest(request, response);
}
/** Returns a short description of the servlet.
*/
public String getServletInfo() {
return «Short description»;
}
}
Para poder vereficar el rol de estudiante se utiliza el siguiente filtro:
package DAW;
import java.io.*;
import java.net.*;
import java.util.*;
import java.text.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
/**
*
* @author Daniel
*/
public class FilterLogin2 implements Filter {
// The filter configuration object we are associated with. If
// this value is null, this filter instance is not currently
// configured.
private FilterConfig filterConfig = null;
public FilterLogin2() {
}
private void doBeforeProcessing(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
if (debug) log(«FilterLogin2:DoBeforeProcessing»);
//
// Write code here to process the request and/or response before
// the rest of the filter chain is invoked.
//
//
// For example, a logging filter might log items on the request object,
// such as the parameters.
//
/*
for (Enumeration en = request.getParameterNames(); en.hasMoreElements(); ) {
String name = (String)en.nextElement();
String values[] = request.getParameterValues(name);
int n = values.length;
StringBuffer buf = new StringBuffer();
buf.append(name);
buf.append(«=»);
for(int i=0; i < n; i++) {
buf.append(values[i]);
if (i < n-1)
buf.append(«,»);
}
log(buf.toString());
}
*/
}
private void doAfterProcessing(ServletRequest request, ServletResponse response) throws IOException, ServletException {
if (debug) log(«FilterLogin2:DoAfterProcessing»);
//
// Write code here to process the request and/or response after
// the rest of the filter chain is invoked.
//
//
// For example, a logging filter might log the attributes on the
// request object after the request has been processed.
//
/*
for (Enumeration en = request.getAttributeNames(); en.hasMoreElements(); ) {
String name = (String)en.nextElement();
Object value = request.getAttribute(name);
log(«attribute: » + name + «=» + value.toString());
}
*/
//
//
// For example, a filter might append something to the response.
//
/*
PrintWriter respOut = new PrintWriter(response.getWriter());
respOut.println(«<P><B>This has been appended by an intrusive filter.</B>»);
*/
}
/**
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
* @param chain The filter chain we are processing
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet error occurs
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletResponse res=(HttpServletResponse)response;
if (debug) log(«FilterLogin2:doFilter()»);
doBeforeProcessing(request, response);
Throwable problem = null;
try {
String user = request.getParameter(«usuario»);
String pass = request.getParameter(«pasword»);
if(user.equalsIgnoreCase(«admin») && pass.equalsIgnoreCase(«admin»)){
chain.doFilter(request, response);
}else
res.sendError(401,»Usted esta bloqueado»);
}
catch(Throwable t) {
//
// If an exception is thrown somewhere down the filter chain,
// we still want to execute our after processing, and then
// rethrow the problem after that.
//
problem = t;
t.printStackTrace();
}
doAfterProcessing(request, response);
//
// If there was a problem, we want to rethrow it if it is
// a known type, otherwise log it.
//
if (problem != null) {
if (problem instanceof ServletException) throw (ServletException)problem;
if (problem instanceof IOException) throw (IOException)problem;
sendProcessingError(problem, response);
}
}
/**
* Return the filter configuration object for this filter.
*/
public FilterConfig getFilterConfig() {
return (this.filterConfig);
}
/**
* Set the filter configuration object for this filter.
*
* @param filterConfig The filter configuration object
*/
public void setFilterConfig(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
/**
* Destroy method for this filter
*
*/
public void destroy() {
}
/**
* Init method for this filter
*
*/
public void init(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
if (filterConfig != null) {
if (debug) {
log(«FilterLogin2:Initializing filter»);
}
}
}
/**
* Return a String representation of this object.
*/
public String toString() {
if (filterConfig == null) return («FilterLogin2()»);
StringBuffer sb = new StringBuffer(«FilterLogin2(«);
sb.append(filterConfig);
sb.append(«)»);
return (sb.toString());
}
private void sendProcessingError(Throwable t, ServletResponse response) {
String stackTrace = getStackTrace(t);
if(stackTrace != null && !stackTrace.equals(«»)) {
try {
response.setContentType(«text/html»);
PrintStream ps = new PrintStream(response.getOutputStream());
PrintWriter pw = new PrintWriter(ps);
pw.print(«<html>\n<head>\n<title>Error</title>\n</head>\n<body>\n»); //NOI18N
// PENDING! Localize this for next official release
pw.print(«<h1>The resource did not process correctly</h1>\n<pre>\n»);
pw.print(stackTrace);
pw.print(«</pre></body>\n</html>»); //NOI18N
pw.close();
ps.close();
response.getOutputStream().close();;
}
catch(Exception ex){ }
}
else {
try {
PrintStream ps = new PrintStream(response.getOutputStream());
t.printStackTrace(ps);
ps.close();
response.getOutputStream().close();;
}
catch(Exception ex){ }
}
}
public static String getStackTrace(Throwable t) {
String stackTrace = null;
try {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
pw.close();
sw.close();
stackTrace = sw.getBuffer().toString();
}
catch(Exception ex) {}
return stackTrace;
}
public void log(String msg) {
filterConfig.getServletContext().log(msg);
}
private static final boolean debug = true;
}
Para poder vereficar el rol de administrador se utiliza el siguiente filtro:
package DAW;
import java.io.*;
import java.net.*;
import java.util.*;
import java.text.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
/**
*
* @author Daniel
*/
public class FiltroLogin implements Filter {
// The filter configuration object we are associated with. If
// this value is null, this filter instance is not currently
// configured.
private FilterConfig filterConfig = null;
public FiltroLogin() {
}
private void doBeforeProcessing(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
if (debug) log(«FiltroLogin:DoBeforeProcessing»);
//
// Write code here to process the request and/or response before
// the rest of the filter chain is invoked.
//
//
// For example, a logging filter might log items on the request object,
// such as the parameters.
//
/*
for (Enumeration en = request.getParameterNames(); en.hasMoreElements(); ) {
String name = (String)en.nextElement();
String values[] = request.getParameterValues(name);
int n = values.length;
StringBuffer buf = new StringBuffer();
buf.append(name);
buf.append(«=»);
for(int i=0; i < n; i++) {
buf.append(values[i]);
if (i < n-1)
buf.append(«,»);
}
log(buf.toString());
}
*/
}
private void doAfterProcessing(ServletRequest request, ServletResponse response) throws IOException, ServletException {
if (debug) log(«FiltroLogin:DoAfterProcessing»);
//
// Write code here to process the request and/or response after
// the rest of the filter chain is invoked.
//
//
// For example, a logging filter might log the attributes on the
// request object after the request has been processed.
//
/*
for (Enumeration en = request.getAttributeNames(); en.hasMoreElements(); ) {
String name = (String)en.nextElement();
Object value = request.getAttribute(name);
log(«attribute: » + name + «=» + value.toString());
}
*/
//
//
// For example, a filter might append something to the response.
//
/*
PrintWriter respOut = new PrintWriter(response.getWriter());
respOut.println(«<P><B>This has been appended by an intrusive filter.</B>»);
*/
}
/**
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
* @param chain The filter chain we are processing
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet error occurs
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletResponse res=(HttpServletResponse)response;
if (debug) log(«FiltroLogin:doFilter()»);
doBeforeProcessing(request, response);
Throwable problem = null;
try {
String user = request.getParameter(«usuario»);
String pass = request.getParameter(«pasword»);
if(user.equalsIgnoreCase(«estud») && pass.equalsIgnoreCase(«estud»)){
chain.doFilter(request, response);
}else
res.sendError(401,»Su nombre de usuario» + user + » esta bloqueado para esta opcion, «);
}
catch(Throwable t) {
//
// If an exception is thrown somewhere down the filter chain,
// we still want to execute our after processing, and then
// rethrow the problem after that.
//
problem = t;
t.printStackTrace();
}
doAfterProcessing(request, response);
//
// If there was a problem, we want to rethrow it if it is
// a known type, otherwise log it.
//
if (problem != null) {
if (problem instanceof ServletException) throw (ServletException)problem;
if (problem instanceof IOException) throw (IOException)problem;
sendProcessingError(problem, response);
}
}
/**
* Return the filter configuration object for this filter.
*/
public FilterConfig getFilterConfig() {
return (this.filterConfig);
}
/**
* Set the filter configuration object for this filter.
*
* @param filterConfig The filter configuration object
*/
public void setFilterConfig(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
/**
* Destroy method for this filter
*
*/
public void destroy() {
}
/**
* Init method for this filter
*
*/
public void init(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
if (filterConfig != null) {
if (debug) {
log(«FiltroLogin:Initializing filter»);
}
}
}
/**
* Return a String representation of this object.
*/
public String toString() {
if (filterConfig == null) return («FiltroLogin()»);
StringBuffer sb = new StringBuffer(«FiltroLogin(«);
sb.append(filterConfig);
sb.append(«)»);
return (sb.toString());
}
private void sendProcessingError(Throwable t, ServletResponse response) {
String stackTrace = getStackTrace(t);
if(stackTrace != null && !stackTrace.equals(«»)) {
try {
response.setContentType(«text/html»);
PrintStream ps = new PrintStream(response.getOutputStream());
PrintWriter pw = new PrintWriter(ps);
pw.print(«<html>\n<head>\n<title>Error</title>\n</head>\n<body>\n»); //NOI18N
// PENDING! Localize this for next official release
pw.print(«<h1>The resource did not process correctly</h1>\n<pre>\n»);
pw.print(stackTrace);
pw.print(«</pre></body>\n</html>»); //NOI18N
pw.close();
ps.close();
response.getOutputStream().close();;
}
catch(Exception ex){ }
}
else {
try {
PrintStream ps = new PrintStream(response.getOutputStream());
t.printStackTrace(ps);
ps.close();
response.getOutputStream().close();;
}
catch(Exception ex){ }
}
}
public static String getStackTrace(Throwable t) {
String stackTrace = null;
try {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
pw.close();
sw.close();
stackTrace = sw.getBuffer().toString();
}
catch(Exception ex) {}
return stackTrace;
}
public void log(String msg) {
filterConfig.getServletContext().log(msg);
}
private static final boolean debug = true;
}
Aqui se encuentra el código de la página(2, 5, 1) que solicita el nombre de usuario y controseña
<%@page contentType=»text/html»%>
<%@page pageEncoding=»UTF-8″%>
<%–
The taglib directive below imports the JSTL library. If you uncomment it,
you must also add the JSTL library to the project. The Add Library… action
on Libraries node in Projects view can be used to add the JSTL 1.1 library.
–%>
<%–
<%@taglib uri=»http://java.sun.com/jsp/jstl/core» prefix=»c»%>
–%>
<!DOCTYPE HTML PUBLIC «-//W3C//DTD HTML 4.01 Transitional//EN»
«http://www.w3.org/TR/html4/loose.dtd«>
<html>
<head>
<link rel=»stylesheet» type=»text/css» media=»screen» href=»tema.css» />
<meta http-equiv=»Content-Type» content=»text/html; charset=UTF-8″>
<title>JSP Page</title>
</head>
<body>
<h1>Deber Servlet</h1>
<form name=»formulario» method=»GET» target=»_self» action=»Descarga»>
<div align=»center»>
<fieldset>
<legend id=»sombreado»>Parametros</legend>
<table class=»punteado» cellspacing=»4″ cellpadding=»0″>
<tr>
<td width=»95″><label >Usuario:</label></td>
<td><input type=»text» name=»usuario» size=»20″ /></td></tr>
<tr><td width=»95″><label >Password:</label></td>
<td><input type=»password» name=»pasword» size=»20″ maxlength=»20″ /></td></tr>
<tr> <td></td></tr>
<tr>
<td></td>
<td><a href=»javascript:document.formulario.submit()»><img class=»ima» src=»imagenes/btningresar.png» title=»Ingresar al Sistema»/></a> </td>
<!– <input type=»submit» value=»enviar» /> –>
</tr>
</table>
</fieldset>
</div>
</form>
</body>
</html>
Cargando ...