Friday, March 11, 2011

Destroy a servlet session



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class DestroyAServletSession extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();
    pw.println( "<HTML><BODY>" );

    // get current session, and don't create one if it doesn't exist
    HttpSession theSession = req.getSession( false );

    // print out the session id
    if( theSession != null ) {
      pw.println( "<BR>Session Id: " + theSession.getId() );
      synchronized( theSession ) {
        // invalidating a session destroys it
        theSession.invalidate();
        pw.println( "<BR>Session destroyed" );
      }
    }

    pw.println( "</BODY></HTML>" );
    pw.close();
  }
}

Posted by at No comments:
Labels:

Delegate servlet requests to a handler



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class DelegateServletRequestsToAHandler extends HttpServlet {
  /**
   * write a method to handle HTTP requests made on the servlet
   */
  public void handleRequest( HttpServletRequest req,
                             HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    // output what type of HTTP request was made on the servlet
    pw.println( "HTTP Request Method -> " + req.getMethod() );
  }

  // delegate HTTP GETs to the handler method
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    handleRequest( req, res );
  }

  // delegate HTTP POSTs to the handler method
  public void doPost( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    handleRequest( req, res );
  }
}

Posted by at No comments:
Labels:

Delegate filter



package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

/*
   to configure this filter display every request uri and the time taken
   to complete it.  Compile this class into the WEB-INF/classes directory
   and configure you WEB-INF/web.xml file to include the following filter.

   Note how you can map the filter onto any url-pattern of your choosing.

   <web-app>
    <filter>
      <filter-name>requesttimerfilter</filter-name>
      <filter-class>com.ack.web.servlet.RequestTimerFilter</filter-class>
    </filter>
    <filter-mapping>
      <filter-name>requesttimerfilter</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>
   </web-app>
 */

public class DelegateFilter extends HttpServlet implements Filter {
  private FilterConfig filterConfig;

  public void init( FilterConfig filterConfig ) {
    this.filterConfig = filterConfig;
  }

  public void doFilter( ServletRequest request,
                        ServletResponse response,
                        FilterChain filterChain ) {
    try {
      String requestURI = ( (HttpServletRequest) request ).getRequestURI();
      System.out.println( "delegating to -> " + requestURI );
      filterChain.doFilter( request, response );


    }
    catch( ServletException sx ) {
      log( sx.getMessage() );
    }
    catch( IOException iox ) {
      log( iox.getMessage() );
    }
  }
}

Posted by at No comments:
Labels:

Create a servlet session



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class CreateAServletSession extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();
    pw.println( "<HTML><BODY>" );

    // get session, and create it if one doesn't already exist
    HttpSession theSession = req.getSession();

    // check if session is newly created
    if( theSession.isNew() ) {
      pw.println( "<P>Session: isNew</P>" );
    }
    else {
      pw.println( "<P>Session: Already Exists</P>" );
    }

    pw.println( "</BODY></HTML>" );
  }
}

Posted by at No comments:
Labels:

Buffering servlet responses



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
  */
public class BufferingServletResponses extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    // create 32K buffer
    res.setBufferSize( 32 * 1024 );

    pw.println( "everything we send now is buffered " );
    pw.println( "at the server until we reach the " );
    pw.println( "buffer size limit or we do a flush!" );

    // check to see if anything has been sent to the client
    if( res.isCommitted() ) {
      pw.println( "<br>damned, something has been sent" );
    }
    else {
      // clear the buffer, so what has gone before is lost
      res.resetBuffer();

      pw.println( "we are going to clear this as well" );

      // clears buffer, status codes and headers
      res.reset();

      // we've blanked the ContentType header so lets add it back
      res.setContentType( "text/html" );

      pw.println( "<br>but we are going to see this" );
    }

    // send what we have now
    res.flushBuffer();

    pw.println( "<br>and this will get flushed at the end of the method" );
    pw.println( "<br>current response buffer size is: " + res.getBufferSize() );
  }
}

Posted by at No comments:
Labels:

Basic authentication web resource



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Securing a web application with basic HTTP authentication
 * has been reduced to a configuration within web.xml
 *
 * to test: http://localhost/ack/servlet/protected/footie/get_time
 *
 <web-app>
 <servlet>
 <servlet-name>footie_time</servlet-name>
 <servlet-class>com.ack.web.servlet.BasicAuthenticationWebResource</servlet-class>
 </servlet>
 <servlet-mapping>
 <servlet-name>footie_time</servlet-name>
 <url-pattern>/protected/footie/get_time</url-pattern>
 </servlet-mapping>
 <security-constraint>
 <web-resource-collection>
 <web-resource-name>protected_zone</web-resource-name>
 <url-pattern>/protected/footie/*</url-pattern>
 <http-method>GET</http-method>
 <http-method>POST</http-method>
 <http-method>PUT</http-method>
 <http-method>DELETE</http-method>
 <http-method>HEAD</http-method>
 <http-method>OPTIONS</http-method>
 <http-method>TRACE</http-method>
 </web-resource-collection>
 <auth-constraint>
 <role-name>footie</role-name>
 </auth-constraint>
 <user-data-constraint>
 <transport-guarantee>NONE</transport-guarantee>
 </user-data-constraint>
 </security-constraint>
 <login-config>
 <auth-method>BASIC</auth-method>
 <realm-name>pure genius football club</realm-name>
 </login-config>
 <security-role>
 <description>the footie guys</description>
 <role-name>footie</role-name>
 </security-role>
 </web-app>
 *
 * finally we need to map from the 'footie' role name to the
 * security principal with the application server, in weblogic
 * we do the following within the supporting weblogic.xml file:
 *
 *
 <weblogic-web-app>
 <security-role-assignment>
 <role-name>footie</role-name>
 <principal-name>cleve</principal-name>
 </security-role-assignment>
 </weblogic-web-app>
 */
public class BasicAuthenticationWebResource extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "<strong>21:00 @ The Wandle Centre, Wandsworth</strong>" );
    pw.println( "<br>don't be late!" );

  }
}

Posted by at No comments:
Labels:

Background tasks



package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class BackgroundTasks extends HttpServlet {
  private Ticker ticker;

  public void init() {
    ticker = new Ticker();
    Thread t = new Thread( ticker );
    t.start();
  }

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    // this servlet processes requests and has a background
    // thread running to handle the execute of ticker objects

    // do not pass HttpServletRequest and HttpServletResponse to
    // background threads

    res.setContentType( "text/html" );
    res.getWriter().println( "check your console, i'm ticking<br>" );
  }

  public void destroy() {
    ticker.stop();
  }

}

// background task

class Ticker implements Runnable {
  private volatile boolean keepAlive = true;
  private int count;

  public synchronized void stop() {
    keepAlive = false;
  }

  public void run() {
    while( keepAlive ) {
      System.out.println( "still alive [" + ( count++ ) + "]" );
      try {
        Thread.currentThread().sleep( 5000 );
      }
      catch( InterruptedException ie ) {
        ie.printStackTrace();
      }
    }
  }
}

Posted by at No comments:
Labels:

Attachment receiver



package com.ack.webservices.jaxm.servlet;

import java.util.Iterator;
import javax.servlet.ServletException;
import javax.xml.messaging.JAXMServlet;
import javax.xml.messaging.ReqRespListener;
import javax.xml.soap.AttachmentPart;
import javax.xml.soap.MessageFactory;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPMessage;
import javax.xml.soap.SOAPPart;

/**
 * Servlet that accepts a SOAP message and looks through
 * its attachments before sending the SOAP part of the message
 * to the console and sending back a response
 *
 */
public class AttachmentReceiver extends JAXMServlet implements ReqRespListener {
  private MessageFactory fac;

  public void init() throws ServletException {
    try {
      fac = MessageFactory.newInstance();
    }
    catch( Exception ex ) {
      ex.printStackTrace();
      throw new ServletException( ex );
    }
  }

  // This is the application code for handling the message.. Once the
  // message is received the application can retrieve the soap part, the
  // attachment part if there are any, or any other information from the
  // message.

  public SOAPMessage onMessage( SOAPMessage message ) {
    System.out.println( "On message called in receiving servlet" );
    try {
      System.out.println( "\nMessage Received: " );
      System.out.println( "\n============ start ============\n" );

      // dump out attachments
      System.out.println( "Number of Attachments: " + message.countAttachments() );
      int i = 1;
      for( Iterator it = message.getAttachments(); it.hasNext(); i++ ) {
        AttachmentPart ap = (AttachmentPart) it.next();
        System.out.println( "Attachment #" + i + " content type : " +
                            ap.getContentType() );
      }

      // dump out the SOAP part of the message
      SOAPPart soapPart = message.getSOAPPart();
      System.out.println( "SOAP Part of Message:\n\n" + soapPart );
      System.out.println( "\n============ end ===========\n" );

      SOAPMessage msg = fac.createMessage();
      SOAPEnvelope env = msg.getSOAPPart().getEnvelope();

      env.getBody()
          .addChildElement( env.createName( "MessageResponse" ) )
          .addTextNode( "Right back at you" );
      return msg;
    }
    catch( Exception e ) {
      e.printStackTrace();
      return null;
    }
  }
}

Posted by at No comments:
Labels:

An included servlet



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AnIncludedServlet extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    PrintWriter pw = res.getWriter();

    /**
     * note that a servlet that has been included within another
     * servlet has access to both the original request uri, servlet
     * path, path info, context path and query string through the
     * HttpServletRequest object.
     *
     * However it also has access to these values that can be different
     * depending on how the servlet include was dispatched.  The servlet
     * engine gives you access to these though request attributes as
     * demonstrated before.
     */

    pw.println( "<h1>The Included Servlet</h1>" );
    pw.println( "<br>request uri: " +
                req.getAttribute( "javax.servlet.include.request_uri" ) );
    pw.println( "<br>context path: " +
                req.getAttribute( "javax.servlet.include.context_path" ) );
    pw.println( "<br>servlet path: " +
                req.getAttribute( "javax.servlet.include.servlet_path" ) );
    pw.println( "<br>path info: " +
                req.getAttribute( "javax.servlet.include.path_info" ) );
    pw.println( "<br>query string: " +
                req.getAttribute( "javax.servlet.include.query_string" ) );
  }
}

Posted by at No comments:
Labels:

Accessing servlet jndi environment variables



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * It is better to use environment variables within a J2EE
 * context for values that can be changed a deployment time
 * instead of Context attributes within the web.xml.  This
 * way you don't have to update the web.xml to change the
 * values.
 *
 *
 <env-entry>
 <description>the guy responsible for this site</description>
 <env-entry-name>webmaster</env-entry-name>
 <env-entry-value>x@xxx</env-entry-value>
 <env-entry-type>java.lang.String</env-entry-type>
 </env-entry>
 */
public class AccessingServletJndiEnvironmentVariables extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    String webMaster = null;
    try {
      // get a handle on the JNDI root context
      Context ctx = new InitialContext();

      // and access the environment variable for this web component
      webMaster = (String) ctx.lookup( "java:comp/env/webmaster" );
    }
    catch( NamingException ex ) {
      ex.printStackTrace();
    }

    pw.println( "the web master is -> " + webMaster );
  }
}

Posted by at No comments:
Labels:

Accessing a java mail session from a servlet



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * configure a resource reference within the web.xml file
 * that is a container managed javamail session object
 *
 <web-app>
 ...
 <resource-ref>
 <description>smtp mail out</description>
 <res-ref-name>mail/smtp</res-ref-name>
 <res-type>javax.mail.Session</res-type>
 <res-auth>CONTAINER</res-auth>
 </resource-ref>
 </web-app>
 *
 * and use your vendor specific xml file to map the
 * resource name to the jndi name, eg for weblogic
 *
 <weblogic-web-app>
 ...
 <reference-descriptor>
 <resource-description>
 <res-ref-name>mail/smtp</res-ref-name>
 <jndi-name>mail/dailyplanet</jndi-name>
 </resource-description>
 ...
 </reference-descriptor>
 </weblogic-web-app>
 *
 *
 */

public class AccessingAJavaMailSessionFromAServlet extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    try {
      // get hold of the JavaMail session
      Context ctx = new InitialContext();
      Session mailSession = (Session) ctx.lookup( "java:comp/env/mail/smtp" );

      // create a message
      Message msg = new MimeMessage( mailSession );
      msg.setSubject( "a servlet test email" );
      msg.setSentDate( new java.util.Date( System.currentTimeMillis() ) );
      msg.setText( "<h1>Hello You</h1>" );
      msg.addHeader( "Content-Type", "text/html" );
      msg.setFrom( new InternetAddress( "x@xxx" ) );
      msg.setRecipient( Message.RecipientType.TO,
                        new InternetAddress( "cleve" ) );

      // send it
      Transport.send( msg );

      // and provide feedback to the use
      pw.println( "message sent!" );
    }
    catch( Exception ex ) {
      // if we get a problem, log it
      log( "problem sending message", ex );

      // and send an error back to the client
      res.sendError( res.SC_INTERNAL_SERVER_ERROR, ex.getMessage() );
    }
  }
}

Posted by at No comments:
Labels:

Accessing a data source from a servlet



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

/**
 * web.xml configuration part of the a data source
 *
 *  <web-app>
 ...
 <resource-ref>
 <description>the database for this app</description>
 <res-ref-name>jdbc/thedatabase</res-ref-name>
 <res-type>javax.sql.DataSource</res-type>
 <res-auth>CONTAINER</res-auth>
 </resource-ref>
 ...
 </web-app>
 *
 * the vendor-specific mapping of the res-ref-name into their
 * own application server space, eg weblogic does the following
 * in a weblogic.xml file
 *
 <weblogic-web-app>
 ...
 <reference-descriptor>
 ...
 <resource-description>
 <res-ref-name>jdbc/thedatabase</res-ref-name>
 <jndi-name>jdbc/gangland</jndi-name>
 </resource-description>
 ...
 </reference-descriptor>
 ...
 </weblogic-web-app>
 */

public class AccessingADataSourceFromAServlet extends HttpServlet {

  public void init() {
    System.out.println( "### loading -> " + getServletName() + " at " +
                        new Date( System.currentTimeMillis() ).toString() );

  }

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    Connection con = null;
    try {
      Context ctx = new InitialContext();
      DataSource ds = (DataSource) ctx.lookup( "java:comp/env/jdbc/thedatabase" );
      con = ds.getConnection();
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery( "select * from enemies" );
      while( rs.next() ) {
        pw.println( rs.getString( "name" ) + "<br>" );
      }
    }
    catch( Exception ex ) {
      log( "problem accessing database", ex );
      res.sendError( res.SC_INTERNAL_SERVER_ERROR, ex.getMessage() );
    }
    finally {
      if( con != null ) {
        try {
          con.close();
        }
        catch( SQLException ex ) {
          log( "problem closing connection", ex );
        }
      }
    }
  }
}

Posted by at No comments:
Labels:

Access an ejb from a servlet



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.ack.j2ee.ejb.session.Lawyer;
import com.ack.j2ee.ejb.session.LawyerHome;

/**
 * web.xml configuration part of the an ejb component
 *
 *  <web-app>
 ...
 <ejb-ref>
 <ejb-ref-name>yoda</ejb-ref-name>
 <ejb-ref-type>Session</ejb-ref-type>
 <home>com.ack.j2ee.ejb.session.LawyerHome</home>
 <remote>com.ack.j2ee.ejb.session.Lawyer</remote>
 </ejb-ref>
 ...
 </web-app>
 *
 * the vendor-specific mapping of the res-ref-name into their
 * own application server space, eg weblogic does the following
 * in a weblogic.xml file
 *
 <weblogic-web-app>
 ...
 <reference-descriptor>
 ...
 <ejb-reference-description>
 <ejb-ref-name>yoda</ejb-ref-name>
 <jndi-name>ejb/lawyer</jndi-name>
 </ejb-reference-description>
 ...
 </reference-descriptor>
 ...
 </weblogic-web-app>
 */
public class AccessAnEjbFromAServlet extends HttpServlet {
  private Context ctx;

  public void init() throws ServletException {
    try {
      // lets share the context for ejb lookup for
      // this servlet's incoming requests
      ctx = new InitialContext();
    }
    catch( NamingException nex ) {
      throw new ServletException( "couldn't locate JNDI context", nex );
    }
  }


  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    try {
      // get reference to business interface from home interface
      Lawyer lawyer = getLawyer();

      // use the business interface
      lawyer.sendHimDown( "bad guy" );

      // let application server reclaim ejb resources
      lawyer.remove();
    }
    catch( LawyerException lex ) {
      pw.println( lex.getMessage() );
    }
    catch( Exception ex ) {
      log( "problem using the lawyer", ex );
      pw.println( ex.getMessage() );
    }

    pw.println( "well, that wasn't so bad" );
  }

  private Lawyer getLawyer() throws LawyerException {
    try {
      Object ejbObject = null;

      // get hold of the object you want by name
      synchronized( this ) {
        System.out.println( "calling on yoda..." );
        ejbObject = ctx.lookup( "java:comp/env/yoda" );
      }

      // narrow retrieved object into specific expected type
      LawyerHome home = (LawyerHome) PortableRemoteObject.
          narrow( ejbObject, LawyerHome.class );

      return home.create();
    }
    catch( Exception ex ) {
      log( "problem getting hold of a lawyer", ex );
      throw new LawyerException( ex.getMessage() );
    }
  }
}

class LawyerException extends Exception {
  public LawyerException( String str ) {
    super( str );
  }
}

/**
 *
 * This is the web.xml configuration
 *
 <web-app>
 ...
 <ejb-ref>
 <description>bring forth the yoda lawyer</description>
 <ejb-ref-name>yoda</ejb-ref-name>
 <ejb-ref-type>Session</ejb-ref-type>
 <home>com.ack.j2ee.ejb.session.LawyerHome</home>
 <remote>com.ack.j2ee.ejb.session.Lawyer</remote>
 </ejb-ref>
 </web-app>
 *
 * But the vendor-specific xml file must map this
 * ejb-ref-name to the name in the JNDI space, for
 * example, in weblogic we have the weblogic.xml,
 *
 <weblogic-web-app>
 <reference-descriptor>
 <ejb-reference-description>
 <ejb-ref-name>yoda</ejb-ref-name>
 <jndi-name>ejb/lawyer</jndi-name>
 </ejb-reference-description>
 </reference-descriptor>
 </weblogic-web-app>
 */

Posted by at No comments:
Labels:

Get security information



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class GetSecurityInformation extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    /**
     * security information made available within servlets
     */
    pw.println( "<br>user principal: " + req.getUserPrincipal().getName() );
    pw.println( "<br>authentication type: " + req.getAuthType() );
    pw.println( "<br>user in footie role: " + req.isUserInRole( "footie" ) );
    pw.println( "<br>are we using HTTPS: " + req.isSecure() );
  }
}

/**
 * Here is a dump of the web.xml file containing the security
 * configuration details.
 *
 <web-app>
 <servlet>
 <servlet-name>footie_time</servlet-name>
 <servlet-class>com.ack.web.servlet.BasicAuthenticationWebResource</servlet-class>
 </servlet>
 <servlet-mapping>
 <servlet-name>footie_time</servlet-name>
 <url-pattern>/protected/footie/get_time</url-pattern>
 </servlet-mapping>
 <servlet>
 <servlet-name>security_info</servlet-name>
 <servlet-class>com.ack.servlet.GetSecurityInfo</servlet-class>
 </servlet>
 <servlet-mapping>
 <servlet-name>security_info</servlet-name>
 <url-pattern>/protected/footie/info</url-pattern>
 </servlet-mapping>
 <security-constraint>
 <web-resource-collection>
 <web-resource-name>protected_zone</web-resource-name>
 <url-pattern>/protected/footie/*</url-pattern>
 <http-method>GET</http-method>
 <http-method>POST</http-method>
 <http-method>PUT</http-method>
 <http-method>DELETE</http-method>
 <http-method>HEAD</http-method>
 <http-method>OPTIONS</http-method>
 <http-method>TRACE</http-method>
 </web-resource-collection>
 <auth-constraint>
 <role-name>footie</role-name>
 </auth-constraint>
 <user-data-constraint>
 <transport-guarantee>NONE</transport-guarantee>
 </user-data-constraint>
 </security-constraint>
 <login-config>
 <auth-method>BASIC</auth-method>
 <realm-name>pure genius football club</realm-name>
 </login-config>
 <security-role>
 <description>the footie guys</description>
 <role-name>footie</role-name>
 </security-role>
 </web-app>
 */

Posted by at No comments:
Labels:

Generic filter



package com.ack.web.servlet;

import java.io.IOException;
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;

/**
 * provides a base implementation for servlet filters.  just
 * extend to implement your own custom filters
 */
public class GenericFilter implements Filter {
  private FilterConfig config;

  public void doFilter( final ServletRequest req,
                        final ServletResponse res,
                        FilterChain chain )
      throws ServletException, IOException {
    chain.doFilter( req, res );
  }

  public void init( FilterConfig config ) {
    setFilterConfig( config );
  }

  public void setFilterConfig( FilterConfig config ) {
    this.config = config;
  }

  public ServletContext getServletContext() {
    return getFilterConfig().getServletContext();
  }

  public FilterConfig getFilterConfig() {
    return config;
  }

  public void log( String str ) {
    getServletContext().log( str );
  }

  public void log( String str, Exception e ) {
    getServletContext().log( str, e );
  }

  public void destroy() {
  }
}

Posted by at No comments:
Labels:

Forward to a servlet by request



package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ForwardToAServletByRequest extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    // do not commit anything to the response stream before a forward

    // set in a request attribute to communicate hello to the
    // servlet we forward to
    req.setAttribute( "hello", "world" );

    // create a request dispatcher to forward
    RequestDispatcher rd =
        getServletContext().
        getRequestDispatcher( "/acceptforward/barry/white?rules=ok" );

    // and then forward
    rd.forward( req, res );
  }
}

Posted by at No comments:
Labels:

Forward to a servlet by name



package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ForwardToAServletByName extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    // do not commit anything to the response stream before a forward

    // set in a request attribute to communicate hello to the
    // servlet we forward to
    req.setAttribute( "hello", "world" );

    // create a request dispatcher by name to forward to
    // this is more limiting that getRequestDispatcher because
    // you cannot specified a query string or extra path information
    //
    // however, you can dispatch to named web components within the
    // web.xml that do not have publicised URIs
    RequestDispatcher rd =
        getServletContext().getNamedDispatcher( "receiveforward" );

    // and then forward
    rd.forward( req, res );
  }
}

Posted by at No comments:
Labels:

Servlet initialisation parameters



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * initialisation parameters inside the web.xml file
 <servlet>
 <servlet-name>initialisation</servlet-name>
 <servlet-class>com.ack.web.servlet.ServletInitialisationParameters</servlet-class>
 <init-param>
 <param-name>jdbcurl</param-name>
 <param-value>someurl</param-value>
 </init-param>
 <init-param>
 <param-name>password</param-name>
 <param-value>bah</param-value>
 </init-param>
 <init-param>
 <param-name>username</param-name>
 <param-value>foo</param-value>
 </init-param>
 </servlet>
 */
public class ServletInitialisationParameters extends HttpServlet {
  public void init() throws ServletException {
    String jdbcURL = getInitParameter( "jdbcurl" );
    String username = getInitParameter( "username" );
    String password = getInitParameter( "password" );

    try {
      if( jdbcURL == null || username == null || password == null ) {
        StringBuffer buf = new StringBuffer( "you must specify the " );
        buf.append( " 'jdbcurl', 'username', 'password' init params to -> " );
        buf.append( getClass().getName() + " within you web.xml file" );
        String msg = buf.toString();
        System.out.println( buf );
//        log( msg );
//        throw new ServletException( msg );
      }
      else {
        // possible get connection to database
      }
    }
    catch( Exception ex ) {
      log( ex.toString() );
      throw new ServletException( ex.toString() );
    }
    finally {
      // do any clean-up if you need to
    }

    log( "Completed Initialisation ->" + getClass().getName() );
  }

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "<h3>Servlet Initialisation Parameters</h3>" );
    pw.println( "<p><hr noshade><p>" );
    Enumeration e = getInitParameterNames();
    while( e.hasMoreElements() ) {
      String paramName = (String) e.nextElement();
      pw.println( "Initialisation Parameter: [ " );
      pw.println( paramName + " = " + getInitParameter( paramName ) );
      pw.println( " ]<br>" );
    }
  }

}

Posted by at No comments:
Labels:

Servlet information



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServletInformation extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "<h3>Servlet Information</h3>" );
    pw.println( "<p><hr noshade><p>" );

    pw.println( "<br>Servlet Path: " + req.getServletPath() );
    pw.println( "<br>Servlet Info: " + getServletInfo() );
  }

  // implement this method to inform others
  // what you're all about - very important and often overlooked
  public String getServletInfo() {
    return "I am a nice servlet, and this is my story...";
  }
}

Posted by at No comments:
Labels:

Servlet exception handler



package com.ack.web.servlet;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Map the location of the servlet to handle at error
 * with the supplied status code
 *
 <web-app>
 ...
 <error-page>
 <exception-type>javax.servlet.ServletException</exception-type>
 <location>/servlet/com.ack.web.servlet.ServletExceptionHandler</location>
 </error-page>
 </web-app>
 */
public class ServletExceptionHandler extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    String exceptionType = getRequestAttribute( req,
                                                "javax.servlet.error.exception_type",
                                                "status code not supplied" );
    String errorMsg = getRequestAttribute( req,
                                           "javax.servlet.error.message",
                                           "error msg not supplied" );

    // exception attribute available as of servlet 2.3 API
    Object exception = req.getAttribute( "javax.servlet.error.exception" );

    pw.println( "<h1>Custom Exception Handler</h1>" );
    pw.println( "<h2>Exception type: " + exceptionType + "</h1>" );
    pw.println( "<h2>Exception Message: " + errorMsg + "</h1>" );
    pw.println( "<p>Problem accessing: " + req.getRequestURI() + "</p>" );

    // if we have the exception dump it out to the page
    if( exception != null ) {
      ByteArrayOutputStream bos = null;
      try {
        pw.println( "<p><hr noshade><p><pre>" );
        bos = new ByteArrayOutputStream();
        PrintWriter writer = new PrintWriter( bos, true );
        ( (Exception) exception ).printStackTrace( writer );
        pw.println( bos.toString() );
      }
      finally {
        pw.println( "</pre>" );
        if( bos != null ) bos.close();
      }
    }

    // output date and time of error
    pw.println( "<p><hr><p>" );
    pw.println( new java.util.Date( System.currentTimeMillis() ) );
  }

  private String getRequestAttribute( HttpServletRequest req,
                                      String name,
                                      String defaultValue ) {
    Object value = req.getAttribute( name );
    return ( value != null ) ? value.toString() : defaultValue;
  }
}

Posted by at No comments:
Labels:

Servlet error handler



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Map the location of the servlet to handle at error
 * with the supplied status code
 *
 <web-app>
 ...
 <error-page>
 <error-code>404</error-code>
 <location>/servlet/com.ack.web.servlet.ServletErrorHandler</location>
 </error-page>
 </web-app>
 */
public class ServletErrorHandler extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    String statusCode = getRequestAttribute( req,
                                             "javax.servlet.error.status_code",
                                             "status code not supplied" );
    String errorMsg = getRequestAttribute( req,
                                           "javax.servlet.error.message",
                                           "error msg not supplied" );

    pw.println( "<h1>Error Code: " + statusCode + "</h1>" );
    pw.println( "<h2>Error Message: " + errorMsg + "</h1>" );
    pw.println( "<p>Problem accessing: " + req.getRequestURI() + "</p>" );
    pw.println( "<p><hr><p>" );
    pw.println( new java.util.Date( System.currentTimeMillis() ) );
  }

  private String getRequestAttribute( HttpServletRequest req,
                                      String name,
                                      String defaultValue ) {
    Object value = req.getAttribute( name );
    return ( value != null ) ? value.toString() : defaultValue;
  }
}

Posted by at No comments:
Labels:

Servlet destroy callback



package com.ack.web.servlet;

import java.sql.Connection;
import java.sql.SQLException;
import javax.servlet.http.HttpServlet;

public class ServletDestroyCallback extends HttpServlet {
  private Connection connection;

  /**
   * implement the servlet
   */
  public void destroy() {
    /**
     * in this servlet destroy callback method
     * remember to clean up resource allocated and
     * managed by this servlet
     */
    try {
      // for example, if the servlet has a
      // dedicated SQL connection
      if( connection != null ) {
        // be sure to close it when the servlet is destroy
        connection.close();
      }
    }
    catch( SQLException sqle ) {
      // and report problems to the web server/servlet engine log files
      log( sqle.toString() );
    }
  }
}

Posted by at No comments:
Labels:

Servlet counter



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServletCounter extends HttpServlet {
  private int instanceCount;
  private static int classCount;

  // process the HTTP get request
  public void doGet( HttpServletRequest request, HttpServletResponse response )
      throws ServletException, IOException {
    response.setContentType( "text/html" );
    PrintWriter out = new PrintWriter( response.getOutputStream() );
    out.println( "<html>" );
    out.println( "<head><title>ServletCounter</title></head>" );
    out.println( "<body>" );
    out.println( "<h3>Hit the browser refresh button!<br>" );
    out.println( "On 10, you'll get an exception, hit refresh again</h3>" );
    out.println( "<p><hr noshade><p>" );

    // when you get to 10, throw exception to cause the
    // this servlet instance to be destroyed and reloaded
    if( instanceCount > 0 && ( instanceCount / 10 ) > 0 ) {
      instanceCount = 0;
      throw new ServletException( "Hit Refresh Again" );
    }

    // synchronize on the servlet instance before updating the counter
    synchronized( this ) {
      // number of times this servlet instance has been accessed
      out.println( "<br>Servlet Instance Count -> " + instanceCount++ );
    }

    // sychronize on the servlet class before updating the class-based counter
    synchronized( ServletCounter.class ) {
      // collective total of all accesses to all servlet instances created
      // by this class
      out.println( "<br>Servlet Total Request Count -> " + classCount++ );
    }

    out.println( "</body></html>" );
    out.close();
  }
}

Posted by at No comments:
Labels:

Servlet context event notifications



package com.ack.web.servlet;

import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * Get application events for when the web application, that is
 * the servlet context, is initialised and destroyed.  Also, when
 * attributed are added, removed and replaced within the servlet
 * context.
 *
 <listener>
 <listener-class>com.ack.web.servlet.ServletContextEventNotifications</listener-class>
 </listener>
 */
public class ServletContextEventNotifications
    implements ServletContextListener, ServletContextAttributeListener {
  public void contextInitialized( ServletContextEvent evt ) {
    System.out.println( "initialised -> " + evt.getServletContext() );
  }

  public void contextDestroyed( ServletContextEvent evt ) {
    System.out.println( "destroyed -> " + evt.getServletContext() );
  }

  public void attributeAdded( ServletContextAttributeEvent evt ) {
    System.out.println( "attributed added: " + evt );
  }

  public void attributeRemoved( ServletContextAttributeEvent evt ) {
    System.out.println( "attributed removed: " + evt );
  }

  public void attributeReplaced( ServletContextAttributeEvent evt ) {
    System.out.println( "attributed replaced: " + evt );
  }
}

Posted by at No comments:
Labels:

Server information



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServerInformation extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "<h3>Server Information</h3>" );
    pw.println( "<p><hr noshade><p>" );

    pw.println( "<br>Server Information: " + getServletContext().getServerInfo() );
    pw.println( "<br>Servlet API Version: " +
                getServletContext().getMajorVersion() + "." +
                getServletContext().getMinorVersion() );
    pw.println( "<br>Server Name: " + req.getServerName() );
    pw.println( "<br>Server Port: " + req.getServerPort() );
  }
}

Posted by at No comments:
Labels:

Sending redirects



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SendingRedirects extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "going to do a redirect" );

    // content before the redirect is ignored

    // redirect to the web site
    res.sendRedirect( "http://www.sun.com" );

    // do not output anything after a redirect
    // it will not cause an error, but the sendRedirect()
    // outputs content to the response body that provides
    // enables those client that do not get automatically
    // redirected with a link to get them there!
  }
}

Posted by at No comments:
Labels:

Sending errors



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SendingErrors extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    // response buffer is cleared before error is sent
    pw.println( "this text will be cleared and not sent to the client" );

    // send error status back to client
    res.sendError( res.SC_INTERNAL_SERVER_ERROR,
                   "application error - we're stumped!" );

    // but this line is executed; use 'return' where appropriate
    pw.println( "however, this is line is executed and sent to client" );
  }

}

Posted by at No comments:
Labels:

Saaj receiving attachments servlet



package com.ack.webservices.saaj;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.soap.MessageFactory;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;

public class SaajReceivingAttachmentsServlet extends HttpServlet {
  private MessageFactory messageFactory;

  public void init() throws ServletException {
    try {
      // Initialize it to the default.
      messageFactory = MessageFactory.newInstance();
    }
    catch( SOAPException ex ) {
      throw new ServletException( "Unable to create message factory"
                                  + ex.getMessage() );
    }
  }

  public void doPost( HttpServletRequest req, HttpServletResponse resp )
      throws ServletException, IOException {

    try {
      // Get all the headers from the HTTP request.
      MimeHeaders headers = SaajUtils.getHeaders( req );

      // Get the body of the HTTP request.
      InputStream is = req.getInputStream();

      // Now internalize the contents of a HTTP request and
      // create a SOAPMessage
      SOAPMessage msg = messageFactory.createMessage( headers, is );
      SOAPMessage reply = null;

      // There are no replies in case of an OnewayListener.
      reply = onMessage( msg );

      if( reply != null ) {

        // Need to saveChanges 'cos we're going to use the
        // MimeHeaders to set HTTP response information. These
        // MimeHeaders are generated as part of the save.

        if( reply.saveRequired() ) {
          reply.saveChanges();
        }

        resp.setStatus( HttpServletResponse.SC_OK );

        SaajUtils.putHeaders( reply.getMimeHeaders(), resp );

        // Write out the message on the response stream.
        OutputStream os = resp.getOutputStream();
        reply.writeTo( os );

        os.flush();

      }
      else {
        resp.setStatus( HttpServletResponse.SC_NO_CONTENT );
      }
    }
    catch( Exception ex ) {
      throw new ServletException( "Saaj POST failed " + ex.getMessage() );
    }
  }

  // This is the application code for handling the message.. Once the
  // message is received the application can retrieve the soap part, the
  // attachment part if there are any, or any other information from the
  // message.

  public SOAPMessage onMessage( SOAPMessage message ) {
    System.out.println( "On message called in receiving servlet" );
    try {
      System.out.println( "Here's the message: " );
      message.writeTo( System.out );
      System.out.println( SaajUtils.getAttachmentReport( message ) );

      SOAPMessage msg = messageFactory.createMessage();
      SOAPEnvelope env = msg.getSOAPPart().getEnvelope();
      env.getBody()
          .addChildElement( env.createName( "Response" ) )
          .addTextNode( "This is a response" );
      return msg;

    }
    catch( Exception e ) {
      e.printStackTrace();
      return null;
    }
  }


  public void doGet( HttpServletRequest req, HttpServletResponse resp )
      throws ServletException, IOException {
    System.out.println( "### got the servlet..." );
    resp.getWriter().println( "hello you!" );
  }
}

Posted by at No comments:
Labels:

Request timer filter




package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

/*
   to configure this filter display every request uri and the time taken
   to complete it.  Compile this class into the WEB-INF/classes directory
   and configure you WEB-INF/web.xml file to include the following filter.

   Note how you can map the filter onto any url-pattern of your choosing.

  
   
      requesttimerfilter
      com.ack.web.servlet.RequestTimerFilter
   
   
      requesttimerfilter
      /*
   
  
 */

public class RequestTimerFilter extends HttpServlet implements Filter {
  private FilterConfig filterConfig;

  public void init( FilterConfig filterConfig ) {
    this.filterConfig = filterConfig;
  }

  public void doFilter( ServletRequest request,
                        ServletResponse response,
                        FilterChain filterChain ) {
    try {
      long startTime = System.currentTimeMillis();
      filterChain.doFilter( request, response );
      long endTime = System.currentTimeMillis();
      String requestURI = ( (HttpServletRequest) request ).getRequestURI();
      System.out.println( requestURI + " took -> " + ( endTime - startTime ) + " ms " );
    }
    catch( ServletException sx ) {
      log( sx.getMessage() );
    }
    catch( IOException iox ) {
      log( iox.getMessage() );
    }
  }
}

Posted by at No comments:
Labels:

Request authorization headers



package com.ack.web.servlet;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

import sun.misc.BASE64Encoder;

/**
 * This example demonstrates how to get access a web resource
 * protected using BASIC HTTP Authentication. The URL connection
 * needs to set the username and password into the Authorization
 * request header of the URL.  The username and password needs
 * to be encoded using BASE64.
 */
public class RequestAuthorizationHeaders {
  public static void main( String[] args ) throws Exception {

    // theencoder is a web resource protected using BASIC HTTP Authentication
    final String urlString = "http://localhost:8080/encodings/theencoder";
    final String userName = "admin";
    final String password = "admin";

    // open url connection
    URL url = new URL( urlString );
    HttpURLConnection con = (HttpURLConnection) url.openConnection();

    // set up url connection to get retrieve information back
    con.setRequestMethod( "GET" );
    con.setDoInput( true );

    // stuff the Authorization request header
    byte[] encodedPassword = ( userName + ":" + password ).getBytes();
    BASE64Encoder encoder = new BASE64Encoder();
    con.setRequestProperty( "Authorization",
                            "Basic " + encoder.encode( encodedPassword ) );

    // pull the information back from the URL
    InputStream is = con.getInputStream();
    StringBuffer buf = new StringBuffer();
    int c;
    while( ( c = is.read() ) != -1 ) {
      buf.append( (char) c );
    }
    con.disconnect();

    // output the information
    System.out.println( buf );
  }
}

Posted by at No comments:
Labels:

Receive servlet forward


package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


/**
 *
 * The receiving servlet of a forward, can have a different
 * uri path, servlet path, path info and query string to the
 * servlet that did the forward in the first place.
 */
public class ReceiveServletForward extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    pw.println( "
request attr: " + req.getAttribute( "hello" ) );
    pw.println( "
request uri: " + req.getRequestURI() );
    pw.println( "
servlet path: " + req.getServletPath() );
    pw.println( "
path info: " + req.getPathInfo() );
    pw.println( "
query string: " + req.getQueryString() );

  }
}

Posted by at No comments:
Labels:

Reading from an abstract resource



package com.ack.web.servlet;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * This class demonstrates how to view static resources
 * within a web application.  It is a URL based scheme
 * for reading resources within the web application.  This
 * makes it a more portable solution than the usual
 * getPathTranslated() technique that deals exclusively
 * with files.
 *
 * This class caters for web applications deployed as WAR
 * files and those that are distributed across machines.
 *
 * Note that this is not a production level implementation
 * and really opens up your web application to anyone.  It
 * is only meant as a demonstration of how to use
 * getServletContext().getResource() for reading resources
 * within a web application.
 *
 * Use As Follows:
 * http://://servlet//file_to_view
 *
 * For example to view my index.jsp page in my web apps root directory
 *
 * http://localhost:8080/ack/vf/index.jsp
 *
 * where /vf/* is mapped to the com.ack.web.servlet.ReadingFromAnAbstractResource
 */
public class ReadingFromAnAbstractResource extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    ServletOutputStream os = res.getOutputStream();
    res.setContentType( "text/plain" );


    // get the resource
    String resourcePath = req.getPathInfo();
    if( resourcePath == null ) {
      res.sendError( HttpServletResponse.SC_NOT_FOUND );
      return;
    }

    System.out.println( "about to read resource -> " + resourcePath );

    // get resource as a url
    URL resourceUrl = getServletContext().getResource( resourcePath );
    if( resourceUrl == null ) {
      res.sendError( HttpServletResponse.SC_NOT_FOUND );
      return;
    }

    // open connection to resource
    URLConnection con = null;
    try {
      con = resourceUrl.openConnection();
      con.connect();
    }
    catch( IOException ioe ) {
      res.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                     "unable to read resource: " + resourcePath );
    }

    // set the actual content type in; must check that its non-null
    String contentType = con.getContentType();
    if( contentType != null ) {
      res.setContentType( contentType );
    }

    // send resource contents back down output stream
    try {
      InputStream is = con.getInputStream();
      byte[] buf = new byte[8096];
      int bytesRead;
      while( ( bytesRead = is.read( buf ) ) != -1 ) {
        os.write( buf, 0, bytesRead );
      }
    }
    catch( IOException ioe ) {
      res.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                     "unable to send resource to client: " + resourcePath );
    }
  }
}

Posted by at No comments:
Labels:

Publishing AJMS message from a servlet



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * web.xml servlet configuration file
 *

 ...

 outgoing jms publish
 jms/topic/connection
 javax.jms.TopicConnectionFactory
 CONTAINER

 ...

 *
 * the vendor-specific web.xml file that maps the res-ref-name
 * onto the one found in the jndi name space
 *

 ...


 jms/topic/connection
 jms/akira/connectionfactory

 ...

 ...

 */

public class PublishingAJMSMessageFromAServlet extends HttpServlet {

  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    res.setContentType( "text/html" );
    PrintWriter pw = res.getWriter();

    TopicConnection topicCon = null;
    try {
      // get the topic connection factory
      Context ctx = new InitialContext();
      TopicConnectionFactory tcf
          = (TopicConnectionFactory) ctx.lookup( "java:comp/env/jms/topic/connection" );

      topicCon = tcf.createTopicConnection();

      // create topic session off the connection
      TopicSession topicSession = topicCon.
          createTopicSession( false, Session.AUTO_ACKNOWLEDGE );

      // get handle on topic, create a publisher and publish the message
      Topic topic = (Topic) ctx.lookup( "jms/topic/devilman" );
      TopicPublisher publisher = topicSession.createPublisher( topic );
      Message msg = topicSession.createTextMessage( "hello..." );
      publisher.publish( msg );

      pw.println( "published the message" );
    }
    catch( Exception ex ) {
      log( "couldn't publish the message", ex );
      res.sendError( res.SC_INTERNAL_SERVER_ERROR, ex.getMessage() );
    }

    finally {
      // close the topic connection
      if( topicCon != null ) {
        try {
          topicCon.close();
        }
        catch( JMSException jme ) {
          log( "problem closing topic con" );
        }
      }
    }
  }
}

Posted by at No comments:
Labels:

Open a file using a servlet




package com.ack.web.servlet;

import java.io.FileReader;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class OpenAFileUsingAServlet extends HttpServlet {
  public void doGet( HttpServletRequest req, HttpServletResponse res )
      throws ServletException, IOException {
    String webAppPath = getServletContext().getRealPath( "" );
    String webXMLFile = getServletContext().getRealPath( "/WEB-INF/web.xml" );
    FileReader fr = new FileReader( webXMLFile );
    for( int c = fr.read(); c != -1; c = fr.read() ) {
      System.out.print( (char) c );
    }

    res.getWriter().println( "check the console!" );
  }
}

Posted by at No comments:
Labels:

Login page in jsp




--------------
<%@ page language ="java" import="java.sql.*" %>



























User Name
Password

<%
String user=request.getParameter("t1");
String pass=request.getParameter("t2");

     try{
  
     Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
     Connection con=DriverManager.getConnection("jdbc:odbc:mydsn", "jp", "jp");
     Statement st=con.createStatement();
     ResultSet rs=st.executeQuery("select username,password from userlog");
     while(rs.next())
         {
         String username=rs.getString(1);
         String password=rs.getString(2);
         if(user.equals(username) && pass.equals(password))
             {
             %>
            
         <%}
         else
         out.println("Login Failed,Please try Againe");
         %>
      
         <%
     }
}catch(Exception e1)
{}

%>




================
LoginSuccess.jsp
-----
U sucessfuly Entered

Posted by at No comments:
Labels:

Load servlet at startup



package com.ack.web.servlet;

import javax.servlet.http.HttpServlet;

/**
 *

 earlyriser
 com.ack.web.servlet.LoadServletAtStartup
 7


 This servlet has a load-at-startup priority of 7, meaning any servlet
 with a load priority lower than 7 will be loaded before this one, and those
 greater than 7 after.  if a load-at-startup priority is not specified,
 for example , the servlet engine chooses when
 */
public class LoadServletAtStartup extends HttpServlet {

  public void init() {
    System.out.println( getServletName() + ": initialised" );
  }

}

Posted by at No comments:
Labels:

JSP servlet output stream





package com.ack.web.servlet;

import java.io.IOException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

/**
 * In the ServletOutputStream all methods converge on the write(int)
 * output method.  So it is this method that we override to customise
 * what is sent back to an HTTP client that uses the JSPServletOutputStream.
 *
 * In this case we simply replace '<' with '[' and '>' with ']', each
 * with ascii values 60, 91, 62, 93 respectively.
 *
 */
public class JSPServletOutputStream extends ServletOutputStream {
  private HttpServletResponse delegate;

  public JSPServletOutputStream( HttpServletResponse hss ) {
    delegate = hss;
  }

  public void write( int c ) throws IOException {
    if( c == 60 ) {
      delegate.getOutputStream().write( 91 );
    }
    else if( c == 62 ) {
      delegate.getOutputStream().write( 93 );
    }
    else {
      delegate.getOutputStream().write( c );
    }
  }
}

Posted by at No comments:
Labels:

JSP Http servlet response wrapper



package com.ack.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
 * JSPHttpServletResponseWrapper is used to adapt the response of a servlet.
 * The wrappers sole responsibility is to create a JSPServletOutputStream
 * off the provided HttpServletResponse.  The JSPServletOutputStream is when
 * we can customize when is streamed back to the HTTP client.  The
 * JSPHttpServletResponseWrapper provides the infrastructural scaffolding to
 * plug into our specialising output stream.
 */

public class JSPHttpServletResponseWrapper extends HttpServletResponseWrapper {
  protected ServletOutputStream stream = null;
  protected PrintWriter writer = null;
  protected HttpServletResponse origResponse = null;

  public JSPHttpServletResponseWrapper( HttpServletResponse response ) {
    super( response );
    response.setContentType("text/plain");
    origResponse = response;
  }

  public ServletOutputStream createOutputStream()
      throws IOException {
    return ( new JSPServletOutputStream( origResponse ) );
  }

  public ServletOutputStream getOutputStream()
      throws IOException {
    if( writer != null ) {
      throw new IllegalStateException( "getWriter() has already been " +
                                       "called for this response" );
    }

    if( stream == null ) {
      stream = createOutputStream();
    }

    return stream;
  }

  public PrintWriter getWriter()
      throws IOException {
    if( writer != null ) {
      return writer;
    }

    if( stream != null ) {
      throw new IllegalStateException( "getOutputStream() has already " +
                                       "been called for this response" );
    }

    stream = createOutputStream();
    writer = new PrintWriter( stream );

    return writer;
  }
}

Posted by at No comments:
Labels:
Subscribe to: Comments (Atom)