ผมเองมักจะลืมว่า เจ้าเมธอดทั้งสามตัวนี้มันต่างกันตรงใหน เขียนผิดเขียนถูกอยู่นั่นแหละ รำคาญตัวเองก็เลยมาเขียนในบล๊อกเอาไว้กันลืม และเผื่อจะมีผู้สนใจร่วมคอมเม้นต์มาแลกเปลี่ยนความรู้ความคิดเห็นกัน

RequestDispatcher.forward() เป็นการทำงานที่อยู่บนเซิร์บเวอร์ แต่ response.sendRedirect() ทำงานอยู่บนบราวเซอร์. เมื่อมีการเรียกใช้งาน RequestDispatcher.forward(), servlet engine จะำทำการ Transfer control ของ HTTP request ที่ได้รับมาตั้งแต่แรกและยังทำงานอยู่ที่ Servlet หรือ ที่ JSP ยังทำการที่ Servlet อื่น. แต่เมื่อทำการเรียกใช้งาน response.sendRedirect() การส่งภาระให้กับบราวเซอร์คืนกลับไปจัดการเอง เหมือนทำให้ท้องแล้วไม่รับผิดชอบยังใงยังงั้น อ๊อบเจ็คต์ Request Response ก็ให้บราวเซอร์ทำการ Route ไปหา Servlet อื่นหรือหน้า JSP อื่นตัวเก่าก็ไม่เหลืออะไร

ส่วน RequestDispatcher.forward() และ PageContext.forward() จะมีหน้าที่เหมือนๆ กันแต่ PageContext.forward() จะเป็น Method Helper ให้กับทาง RequestDispacher.forward() อีกทีหนึ่งนั่นเอง

Java is an object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s. Unlike conventional languages which are generally designed either to be compiled to native (machine) code, or to be interpreted from source code at runtime, Java is intended to be compiled to a bytecode, which is then run (generally using JIT compilation) by a Java Virtual Machine.

The language itself borrows much syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java is only distantly related to JavaScript, though they have similar names and share a C-like syntax.

Java was started as a project called “Oak” by James Gosling in June 1991. Gosling’s goals were to implement a virtual machine and a language that had a familiar C-like notation but with greater uniformity and simplicity than C/C++. The first public implementation was Java 1.0 in 1995. It made the promise of “Write Once, Run Anywhere”, with free runtimes on popular platforms. It was fairly secure and its security was configurable, allowing for network and file access to be limited. The major web browsers soon incorporated it into their standard configurations in a secure “applet” configuration. popular quickly. New versions for large and small platforms (J2EE and J2ME) soon were designed with the advent of “Java 2″. Sun has not announced any plans for a “Java 3″.

In 1997, Sun approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a proprietary de facto standard that is controlled through the Java Community Process. Sun makes most of its Java implementations available without charge, with revenue being generated by specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) which is a subset of the SDK, the primary distinction being that in the JRE the compiler is not present.

Philosophy

There were five primary goals in the creation of the Java language:

1. It should use the object-oriented programming methodology.
2. It should allow the same program to be executed on multiple operating systems.
3. It should contain built-in support for using computer networks.
4. It should be designed to execute code from remote sources securely.
5. It should be easy to use by selecting what was considered the good parts of other object-oriented languages.

To achieve the goals of networking support and remote code execution, Java programmers sometimes find it necessary to use extensions such as CORBA, Internet Communications Engine, or OSGi.

Object orientation

The first characteristic, object orientation (“OO”), refers to a method of programming and language design. Although there are many interpretations of OO, one primary distinguishing idea is to design software so that the various types of data it manipulates are combined together with their relevant operations. Thus, data and code are combined into entities called objects. An object can be thought of as a self-contained bundle of behavior (code) and state (data). The principle is to separate the things that change from the things that stay the same; often, a change to some data structure requires a corresponding change to the code that operates on that data, or vice versa. This separation into coherent objects provides a more stable foundation for a software system’s design. The intent is to make large software projects easier to manage, thus improving quality and reducing the number of failed projects.

Another primary goal of OO programming is to develop more generic objects so that software can become more reusable between projects. A generic “customer” object, for example, should have roughly the same basic set of behaviors between different software projects, especially when these projects overlap on some fundamental level as they often do in large organizations. In this sense, software objects can hopefully be seen more as pluggable components, helping the software industry build projects largely from existing and well-tested pieces, thus leading to a massive reduction in development times. Software reusability has met with mixed practical results, with two main difficulties: the design of truly generic objects is poorly understood, and a methodology for broad communication of reuse opportunities is lacking. Some open source communities want to help ease the reuse problem, by providing authors with ways to disseminate information about generally reusable objects and object libraries.

Platform independence

The second characteristic, platform independence, means that programs written in the Java language must run similarly on diverse hardware. One should be able to write a program once and run it anywhere.

This is achieved by most Java compilers by compiling the Java language code “halfway” to bytecode (specifically Java bytecode)—simplified machine instructions specific to the Java platform. The code is then run on a virtual machine (VM), a program written in native code on the host hardware that interprets and executes generic Java bytecode. Further, standardized libraries are provided to allow access to features of the host machines (such as graphics, threading and networking) in unified ways. Note that, although there’s an explicit compiling stage, at some point, the Java bytecode is interpreted or converted to native machine instructions by the JIT compiler.

There are also implementations of Java compilers that compile to native object code, such as GCJ, removing the intermediate bytecode stage, but the output of these compilers can only be run on a single architecture.

Sun’s license for Java insists that all implementations be “compatible”. This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support the RMI and JNI interfaces and had added platform-specific features of their own. In response, Microsoft no longer ships Java with Windows, and in recent versions of Windows, Internet Explorer cannot support Java applets without a third-party plug-in. However, Sun and others have made available Java run-time systems at no cost for those and other versions of Windows.

The first implementations of the language used an interpreted virtual machine to achieve portability. These implementations produced programs that ran more slowly than programs compiled to native executables, for instance written in C or C++, so the language suffered a reputation for poor performance. More recent JVM implementations produce programs that run significantly faster than before, using multiple techniques.

The first technique is to simply compile directly into native code like a more traditional compiler, skipping bytecodes entirely. This achieves good performance, but at the expense of portability. Another technique, known as just-in-time compilation (JIT), translates the Java bytecodes into native code at the time that the program is run which results in a program that executes faster than interpreted code but also incurs compilation overhead during execution. More sophisticated VMs use dynamic recompilation, in which the VM can analyze the behavior of the running program and selectively recompile and optimize critical parts of the program. Dynamic recompilation can achieve optimizations superior to static compilation because the dynamic compiler can base optimizations on knowledge about the runtime environment and the set of loaded classes. JIT compilation and dynamic recompilation allow Java programs to take advantage of the speed of native code without losing portability.

Portability is a technically difficult goal to achieve, and Java’s success at that goal has been mixed. Although it is indeed possible to write programs for the Java platform that behave consistently across many host platforms, the large number of available platforms with small errors or inconsistencies led some to parody Sun’s “Write once, run anywhere” slogan as “Write once, debug everywhere”.

Platform-independent Java is however very successful with server-side applications, such as Web services, servlets, and Enterprise JavaBeans, as well as with Embedded systems based on OSGi, using Embedded Java environments.

Automatic garbage collection

One idea behind Java’s automatic memory management model is that programmers should be spared the burden of having to perform manual memory management. In some languages the programmer allocates memory to create any object stored on the heap and is responsible for later manually deallocating that memory to delete any such objects. If a programmer forgets to deallocate memory or writes code that fails to do so in a timely fashion, a memory leak can occur: the program will consume a potentially arbitrarily large amount of memory. In addition, if a region of memory is deallocated twice, the program can become unstable and may crash. Finally, in non garbage collected environments, there is a certain degree of overhead and complexity of user-code to track and finalize allocations.

In Java, this potential problem is avoided by automatic garbage collection. The programmer determines when objects are created, and the Java runtime is responsible for managing the object’s lifecycle. The program or other objects can reference an object by holding a reference to it (which, from a low-level point of view, is its address on the heap). When no references to an object remain, the Java garbage collector automatically deletes the unreachable object, freeing memory and preventing a memory leak. Memory leaks may still occur if a programmer’s code holds a reference to an object that is no longer needed—in other words, they can still occur but at higher conceptual levels.

The use of garbage collection in a language can also affect programming paradigms. If, for example, the developer assumes that the cost of memory allocation/recollection is low, they may choose to more freely construct objects instead of pre-initializing, holding and reusing them. With the small cost of potential performance penalties (inner-loop construction of large/complex objects), this facilitates thread-isolation (no need to synchronize as different threads work on different object instances) and data-hiding. The use of transient immutable value-objects minimizes side-effect programming.

Comparing Java and C++, it is possible in C++ to implement similar functionality (for example, a memory management model for specific classes can be designed in C++ to improve speed and lower memory fragmentation considerably), with the possible cost of extra development time and some application complexity. In Java, garbage collection is built-in and virtually invisible to the developer. That is, developers may have no notion of when garbage collection will take place as it may not necessarily correlate with any actions being explicitly performed by the code they write. Depending on intended application, this can be beneficial or disadvantageous: the programmer is freed from performing low-level tasks, but at the same time loses the option of writing lower level code.

Syntax

The syntax of Java is largely derived from C++. However, unlike C++, which combines the syntax for structured, generic, and object-oriented programming, Java was built from the ground up to be virtually fully object-oriented: everything in Java is an object with the exceptions of atomic datatypes (ordinal and real numbers, boolean values, and characters) and everything in Java is written inside a class.

Applet

Java applets are programs that are embedded in other applications, typically in a Web page displayed in a Web browser.

// Hello.java
import java.applet.Applet;
import java.awt.Graphics;

public class Hello extends Applet {
public void paint(Graphics gc) {
gc.drawString(“Hello, world!”, 65, 95);
}
}

This applet will simply draw the string “Hello, world!” in the rectangle within which the applet will run. This is a slightly better example of using Java’s OO features in that the class explicitly extends the basic “Applet” class, that it overrides the “paint” method and that it uses import statements.

<!– Hello.html –>
<html>
<head>
<title>Hello World Applet</title>
</head>
<body>
<applet code=”Hello” width=”200″ height=”200″>
</applet>
</body>
</html>

An applet is placed in an HTML document using the <applet> HTML element. The applet tag has three attributes set: code=”Hello” specifies the name of the Applet class and width=”200″ height=”200″ sets the pixel width and height of the applet. (Applets may also be embedded in HTML using either the object or embed element, although support for these elements by Web browsers is inconsistent.

Servlet

Java servlets are server-side Java EE components that generate responses to requests from clients.

// Hello.java
import java.io.*;
import javax.servlet.*;

public class Hello extends GenericServlet {
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException
{
response.setContentType(“text/html”);
PrintWriter pw = response.getWriter();
pw.println(“Hello, world!”);
pw.close();
}
}

The import statements direct the Java compiler to include all of the public classes and interfaces from the java.io and javax.servlet packages in the compilation. The Hello class extends the GenericServlet class; the GenericServlet class provides the interface for the server to forward requests to the servlet and control the servlet’s lifecycle.

The Hello class overrides the service(ServletRequest, ServletResponse) method defined by the Servlet interface to provide the code for the service request handler. The service() method is passed a ServletRequest object that contains the request from the client and a ServletResponse object used to create the response returned to the client. The service() method declares that it throws the exceptions ServletException and IOException if a problem prevents it from responding to the request.

The setContentType(String) method in the response object is called to set the MIME content type of the returned data to “text/html”. The getWriter() method in the response returns a PrintWriter object that is used to write the data that is sent to the client. The println(String) method is called to write the “Hello, world!” string to the response and then the close() method is called to close the print writer, which causes the data that has been written to the stream to be returned to the client.

Swing application

Swing is the advanced graphical user interface library for the Java SE platform.

// Hello.java
import javax.swing.*;

public class Hello extends JFrame {
Hello() {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
add(new JLabel(“Hello, world!”));
pack();
}

public static void main(String[] args) {
new Hello().setVisible(true);
}
}

The import statement directs the Java compiler to include all of the public classes and interfaces from the javax.swing package in the compilation. The Hello class extends the JFrame class; the JFrame class implements a window with a title bar with a close control.

The Hello() constructor initializes the frame by first calling the setDefaultCloseOperation(int) method inherited from JFrame to set the default operation when the close control on the title bar is selected to WindowConstants.DISPOSE_ON_CLOSE—this causes the JFrame to be disposed of when the frame is closed (as opposed to merely hidden), which allows the JVM to exit and the program to terminate. Next a new JLabel is created for the string “Hello, world!” and the add(Component) method inherited from the Container superclass is called to add the label to the frame. The pack() method inherited from the Window superclass is called to size the window and layout its contents.

The main() method is called by the JVM when the program starts. It instantiates a new Hello frame and causes it to be displayed by calling the setVisible(boolean) method inherited from the Component superclass with the boolean parameter true. Note that once the frame is displayed, exiting the main method does not cause the program to terminate because the AWT event dispatching thread remains active until all of the Swing top-level windows have been disposed.

Look and feel

The default look and feel of GUI applications written in Java using the Swing toolkit is very different from native applications. It is possible to specify a different look and feel through the pluggable look and feel system of Swing. Clones of Windows, GTK and Motif are supplied by Sun. Apple also provides an Aqua look and feel for Mac OS X. Though prior implementations of these look and feels have been considered lacking, Swing in Java SE 6 addresses this problem by using more native widget drawing routines of the underlying platforms. Alternatively, third party toolkits such as wx4j or SWT may be used for increased integration with the native windowing system.

Lack of OO purity and facilities

Java’s primitive types are not objects. Primitive types hold their values in the stack rather than being references to values. This was a conscious decision by Java’s designers for performance reasons. Because of this, Java is not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to write as if primitive types are their wrapper classes, and freely interchange between them for improved flexibility. Java designers decided not to implement certain features present in other OO languages, including:

* multiple inheritance
* operator overloading
* class properties
* tuples

Java Runtime Environment

The Java Runtime Environment or JRE is the software required to run any application deployed on the Java Platform. End-users commonly use a JRE in software packages and Web browser plugins. Sun also distributes a superset of the JRE called the Java 2 SDK (more commonly known as the JDK), which includes development tools such as the Java compiler, Javadoc, and debugger.

Above article originally from wikipedia.org. Above article is available under GNU Free Documentation License.

I have a class that performs logging for a servlet.
This class is wrapped up inside a jar and is used in a number of unrelated wars that are deployed in the same tomcat instance.
In order to log useful information the class in the jar file needs to know something that it is human-understandable and unique for the servlet in which is it deployed.

This has been bothering me for a couple of weeks, but I’ve just worked out how to do it:

public class ConfigReporter implements ApplicationListener
{
    private String artifactName;

    @Override
    public void onApplicationEvent( ApplicationEvent event )
    {
        if( event instanceof ContextRefreshedEvent )
        {
            ContextRefreshedEvent refreshEvent = (ContextRefreshedEvent)event;
            this.artifactName = "Unknown";
            if( refreshEvent.getApplicationContext() instanceof WebApplicationContext )
            {
                WebApplicationContext webCtx = (WebApplicationContext)refreshEvent.getApplicationContext();
                this.artifactName = webCtx.getServletContext().getContextPath();
            }
            startup();
        }
        else if( event instanceof ContextClosedEvent )
        {
            shutdown();
        }
    }

The startup method does the actual logging, but it’s the context path from the web servlet context that is the good stuff.
On tomcat this gives the same name that the tomcat manager servlet uses in its list of apps.
The technique should work with any servlet container, but results will vary (i.e. the name given by jetty is not the same as the name given by tomcat).

Clearly this is dependent upon the war file, but if the user deviates from the standard (maven) naming structure then they should still recognise their alternative name in my list.

JFastCGI est un projet sous licence BSD démarré il y a quelques mois maintenant. Le but est de permettre a un container de servlet (type tomcat ou jetty) de servir des pages générées par une application compatible fastCGI.

Cela permet par exemple de servir des pages PHP interprétées par le moteur PHP officiel sans avoir a utiliser un serveur apache.

La version 1.1 est “en prod”, et la version 2.0, qui introduit la notion de pool de connexion entre une application tomcat et plusieurs “serveurs” fastcgi est en cours de tests (j’en ai profité pour créer un ensemble de tests unitaires, utilisant mockrunner). Elle permettra un énorme gain de performance pour les applications fortement sollicitées !

La version 2.0 ajoute aussi une meilleur intégration avec Spring, en implémentant HttpRequestHandler.

Des contacts ont même étés pris avec l’équipe de développement de Glassfish, dont jfastcgi pourrait devenir un module optionnel de la version 3 …

Bref, cette librairie semble promise a un bel avenir, et permet d’utiliser les serveurs en java de manière moins “fermée” mais ce projet demande à gagner en maturité, votre aide est la bienvenue !

Con la ayuda de este ejemplo(bueno, el de la version 2.5 que aparece en los comentarios), pude crear un servlet que ejecuta y despliega un reporte de BIRT.
Para establecer el valor de un parámetro desde este servlet, a través del Report Engine API, hay que utilizar la interfaz IRunAndRenderTask (no he visto si se puede con alguna otra).
Lo primero es obtener una referencia a esta interfaz mediante:

IRunAndRenderTask task = birtReportEngine.createRunAndRenderTask( design );

y luego simplemente utilizar el método setParameterValue de la siguiente forma:

task.setParameterValue(“Name”, “Value”);

Fuente:
Integrating BIRT with PHP

добавить в web.xml:

<context-param>
<param-name>managerData</param-name>
<param-value>http://localhost/managerData</param-value>
</context-param>


читаем из jsp:
${initParam.managerData}

читаем из servlet’а:
getServletContext().getInitParameter(“managerData”);

I have a Rails application where users can log in and do stuff. For one of the actions a user can perform, I actually use a Java web application integrated in the Rails application. Because I don’t want a malicious user that is not logged in to the application to surf directly to the Java application, I need a system where my Java application is only accessible for users logged in to the Rails application. I used a Servlet Filter that contacts the Rails application in the background and asks if the user is logged in. Only then is the user allowed to proceed.

First I built an a controller in Rails with an action that checks if the user is logged in. In my application this is available at the url localhost:3000/session/check.

Now I want my Java web application to first request the Rails session check and when it returns false it should redirect to the login page instead of serving the Java servlets. I used a Java servlet filter for this job. I created the filter in a separate project, here is the source code:

Now the only thing we have to do is place the classes in our web application and change the web.xml as follows:

Below are two logs from the Java web application:

Logged out: (the Rails session id is from a previous session and thus invalid)

Rails session id is BAh7CToQX2NzcmZfdG9rZW4iMVUyeFJWWWVzc1hUZFNPRDR2dkFUb3lONVFaQlJrVmsxR1h0VzVaS3RmUFU9Og9zZXNzaW9uX2lkIiUyOTg2NDc2NzY0N2RlMGU1OWExMTFiOTUwMTk0Zjg2MCIQaW5pdGlhbF91cmkiDS9tYW1taWUvIgpmbGFzaElDOidBY3Rpb25Db250cm9sbGVyOjpGbGFzaDo6Rmxhc2hIYXNoewAGOgpAdXNlZHsA--41ae001042b16ee26966fc931d11719bc51d7b71
urlString=http://media.ibbt.be/mammie/session/check
rails returned: false
authentication failed!
valid_user=false, redirecting to /RedirectServlet

Logged in:

Rails session id is BAh7CiIJdXNlcm86CVVzZXIHOhZAYXR0cmlidXRlc19jYWNoZXsAOhBAYXR0cmlidXRlc3sdIg5qb2JfdGl0bGUiF1NpdGUgQWRtaW5pc3RyYXRvciIRb2ZmaWNlX3Bob25lMCIPdXBkYXRlZF9hdCIYMjAwOS0xMC0wOCAxMTo1OToxNiIKdGl0bGUiF3NpdGUgYWRtaW5pc3RyYXRvciIYb3JnYW5pc2F0aW9uX3JlZ2lvbjAiDXVzZXJuYW1lIgphZG1pbiIMY291bnRyeSIHQkUiGW9yZ2FuaXNhdGlvbl9hZGRyZXNzMCIHaWQiBjEiHG9yZ2FuaXNhdGlvbl9kZXBhcnRtZW50MCIWb3JnYW5pc2F0aW9uX2NpdHkwIhRhc3Npc3RhbnRfcGhvbmUwIg9maXJzdF9uYW1lIgphZG1pbiITaGFzaGVkX3Bhc3dvcmQiLWI0NzIwODY3MGU2YmU1ODdhNjE1YTcwZDMzZGRkYmVkNmNhMGNiZjAiD29mZmljZV9mYXgwIhFvcmdhbmlzYXRpb24wIg5sYXN0X25hbWUiFnRoZSBhZG1pbmlzdHJhdG9yIhBhZmZpbGlhdGlvbjAiFm9yZ2FuaXNhdGlvbl90eXBlMCIPY3JlYXRlZF9hdCIYMjAwOS0xMC0wOCAxMTo1OToxNiIKZW1haWwiHmthcmVsLmJyYWVja21hbkBnbWFpbC5jb20iEW1vYmlsZV9waG9uZTAiHW9yZ2FuaXNhdGlvbl9wb3N0YWxfY29kZTAiGW9yZ2FuaXNhdGlvbl9jb3VudHJ5MDoPc2Vzc2lvbl9pZCIlMjk4NjQ3Njc2NDdkZTBlNTlhMTExYjk1MDE5NGY4NjA6EF9jc3JmX3Rva2VuIjFVMnhSVlllc3NYVGRTT0Q0dnZBVG95TjVRWkJSa1ZrMUdYdFc1Wkt0ZlBVPSIQaW5pdGlhbF91cmkiDS9tYW1taWUvIgpmbGFzaElDOidBY3Rpb25Db250cm9sbGVyOjpGbGFzaDo6Rmxhc2hIYXNoewAGOgpAdXNlZHsA--9857ba6780010c041df44eabbfa5f3943ecbe218
urlString=http://media.ibbt.be/mammie/session/check
rails returned: true
authentication successful!

One of the cool things about EJB’s is the fact that you no longer need to do certain things, like go to the JNDI context, and search for your EJB.  You can let the @EJB tag do it for you (for example).

Writing a simple application to talk to a local EJB should be as simple as

@EJB
 private SimpleStatelessEJBLocal simpleStateless;
 ...
 simpleStateless.someLocalMethod();
 ...

But what I found was a null pointer exception.
So taking the application down to the simplest app.

• One servlet.
• One statless session bean.
• Using Jdeveloper 10.1.3.5 (I can’t use 11g as I need oc4j 10.1.3.5, I know I can get around it.. more on that later)
• One local OC4J 10.1.3.5 instance.

Deploying this application and after much playing around, the null pointer was gone, and this error remained.

[Oracle Containers for J2EE 10g (10.1.3.5.0) ]

9/10/19 16:52:14.779 SimpleTwoWEB: Servlet error
java.lang.ClassCastException: com.evermind.server.ejb.StatelessSessionDefaultLocalHomeImpl cannot be cast to au.edu.rmit.its.qas.ejb.SimpleStatelessEJBLocal

This puzzled me for an hour or so, but through an obscure post on coderanch I found the problem.  It seems that JDeveloper 10.1.3.x creates web projects in web 2.4 compliance, but in order to run DI you need to run web container version 2.5.  Testing this out, I changed the web.xml from this:

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee">

changing to…

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"   xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  id="WebApp_ID" version="2.5">

And like magic is worked.

Now according to two OTN Discussions:

If you have a look at the J2EE 5 spec, the classes where DI is supported are listed on page 64.

Component classes supporting injection
Servlet: servlets, servlet filters, event listeners
JSP: tag handlers, tag library event listeners
JSF: scoped managed beans
JAX-WS: service endpoints, handlers
EJB: beans, interceptors
Java EE platform: main class (static), login callback handler

OTN  Link 1

OTN Link 2

Review of Java Servlets and JSP by David Madouros

I’m torn after reading Murach’s Java Servlets & JSP book, 2nd Ed. I read the first version when I was making the transition from mainframe programming to Java programming and found the information to be extremely helpful for getting up and running very quickly. With the authors’ assistance I had a database server, a servlet container, and a ‘hello world’ web app running within a couple of hours. On the other hand, reading the second edition as an experienced Java developer made me cringe. Ultimately, I have to side with the my experienced side. Especially when I consider how well the format of Murach books tends to make them canonical references and how easy it would have been for the authors to teach better practices.

The cover of the book makes at least three claims:

• Get off to a quick start
• Build professional web sites
• Handle databases like a pro

Get Off to a Quick Start
The authors get off to a great start by helping the reader to download, install, some basic tools including a servlet container, a database server, and an IDE. They guide the reader with step by step instructions for installing both Tomcat and MySQL — bonus points for recommending the latest versions of each. However, I’m stumped by their choice of IDE — NetBeans — and their claims that it is a top notch IDE. Technically, I suppose it is third, but in my experience it’s a distant third well behind Eclipse and IntelliJ.
Build Professional Web Sites
I take issue with much of the material presented in the book and how it lends itself to creating ‘professional’ web sites. For starters, the authors provide an excellent introduction to HTML. Too bad XHTML is the current standard. The authors state that they’d rather discuss HTML than XHTML because they feel that XHTML is too difficult to teach in a single chapter. I thought this was ridiculous, but assumed they would at least promote well-formed HTML — boy, was I wrong. They consistently use of malformed HTML in their examples and go as far as mentioning the lack of unquoted attributes as a good thing! This is bad, but it gets worse because a couple of chapters later they have to discuss well-formed HTML before they can teach the reader how to use JSTL.
The authors discuss both JSP and Servlet technologies in separate chapters and demonstrate how to create ‘complete’ websites with each technology. I suppose this is necessary to teach the underlying technologies, but I wish that the authors had down played their use a little more. They do eventually discuss MVC (model 2) and state that it is a better solution, but they take the easy way out by saying that sometimes straight JSP and straight Servlet implementations are except- able.
My final grumble about creating professional websites has to do with the chapter on custom tags. While using the classic tag mechanism was a pleasure (not!), the simple tag mechanism is exactly what it claims to be — simpler — and much more straight forward. However, the authors only mention the classic mechanism — no mention of SimpleTagSupport and no mention of tag files. Long live SKIP_BODY!
Now for the good stuff… My favorite chapter in the entire book has to be chapter 9 because they give a high-level summary of JavaBeans and JSP tags stating that they are outdated and rarely used anymore — replaced by JSTL. The only reason the authors even mention them is that the reader may need to know about them to support legacy applications. I wish the rest of the book gave more of these disclaimers.
Finally, the authors really do a good job of describing the technologies. I just wish that they’d promote best practices and shun bad ones more often.

Handle Databases Like a Pro
The authors give a good overview of SQL and then move on to coding straight JDBC code. However, they choose to close the connection inside of the try block rather than follow the best practice of closing the connection in the finally block. Also, they mention the differences between Statement and PreparedStatement and seem to lean towards Statement unless there is a need to execute the same statement repeatedly, but throughout the entire discussion there is no mention of cross site scripting prevention as one of the benefits of the PreparedStatement (not that PreparedStatement completely eliminates the threat of XSS, but it greatly reduces it).

Summary
In summary, this book is a disappointment. The subject of web development involves many technologies: CSS, HTML/XHTML, Java, Servlets, JSP, JSTL, EL, SQL, Http, and Javascript; and this doesn’t include the various frameworks (Struts, JSF, Spring, Hibernate, GWT, etc.) The authors make a valiant effort to cover all the base technologies, but there’s just too much to cover in a single book and be able to make the claim that the reader will have all the skills necessary to create professional websites. This book barely manages to cover the basics. I give the authors an A for effort, but a D for execution. Having said that, if you don’t understand any of the technologies (other than Java) and read the book with the understanding that this is just the beginning, this might be the book for you.

public static boolean isMobileDevice(HttpServletRequest request){

return isMobileDevice(ua,accept,xwp);
}

public static boolean isMobileDevice(String userAgent, String accept, String xWapProfile){

return ua.matches(".*(ipod|iphone).*")
|| ua.matches(".*android.*")
|| ua.matches(".*opera mini.*")
|| ua.matches(".*blackberry.*")
|| ua.matches(".*(palm|hiptop|avantgo|plucker|xiino|blazer|elaine).*")
|| ua.matches(".*windows ce; (ppc;|smartphone;|iemobile).*")
|| a.matches(".*text/vnd\\.wap\\.wml.*")
|| a.matches(".*application/vnd\\.wap\\.xhtml\\+xml.*")
|| (xWapProfile != null);
}

Du liebe Zeit, schon wieder viertel nach 2. Jetzt aber ins Bett

—-

kurz mal was festhalten

java ap (EE) runterladen (gibts auch ohne alles!, ca 100MB)

Eclipse runterladen

installieren

Eclipse -> Help -> Install (new) Software

http://download.eclipse.org/webtools/updates/

WTP (Web Tools Platform) auswählen

File > New > Web > Dyn Web Proj

Erstellen

Dann auf dem Projekt links im Projekt Explorer rechte Maustaste > New > Servlet

Erstellen

dann rechte Maustaste Properties > Java Build Path > Libraries > Add External Jars > C:\Sun\SDK\lib\j2ee.jar auswählen

Dann im Projekt src… Klasse.java sollte alles grün sein

dort dann die doGet ändern auf:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

response.setContentType( “text/html” );

PrintWriter out = response.getWriter();

out.println( “<html>” );

out.println( “<h3> Hallo, mein erstes Servlet meldet sich </h3>” );

out.println( “</html>” );

out.close();

}

damit auch was rauskommt

Servlet ist also gebaut…

Jetzt müssen wir noch ein WAR draus machen

Auf Project -> Export > WAR…

Dann aufn Tomcat kopieren

tomcat erst mal starten:

rsync:~ # cd /root/java/apache-tomcat-6.0.20/bin/

rsync:~/java/apache-tomcat-6.0.20/bin # sh startup.sh

WAR ins Webapp dir kopieren:

C:\..>pscp de.bla.dest.war root@192.168.178.49:/root/java/apache-tomcat-6.0.20/webapps/.

Mal in den Manager gucken:

http://192.168.178.49:8080/manager/html

Passwortproblem?

in /root/java/apache-tomcat-6.0.20/conf/tomcat-users.xml

eins definieren

<tomcat-users>

<user username=”admin” password=”geheim” roles=”admin,manager”/>

</tomcat-users>

dort ist unser war zu sehen

Im Project Webcontent > Web-INF > lib > web.xml

…

<servlet-mapping>

…

…<url-pattern>/MeinTest</url-pattern>

findet sich die URL

http://192.168.178.49:8080/projekt-ear-name/Klassenname (src.Klasse)

also zB

http://192.168.178.49:8080/de.bla.dest/MeinTest

Fertig…

—————————————————–

Schritt 2:

Servlet ändern:

..doGet(..

…

out.println( “</html>” );

out.close();

}

nach

..doGet(..

…

PrintENV(request, out);

PrintParams(request, response, out);

out.println( “time”+new SimpleDateFormat(“dd-MM-yyyy HH:mm:ss”).format(new Date()) );

out.println( “</html>” );

out.close();

}

private void PrintENV(HttpServletRequest request, PrintWriter out) {

out.println(“” +

“<B>Request Method: </B>” +

request.getMethod() + “<BR>\n” +

“<B>Request URI: </B>” +

request.getRequestURI() + “<BR>\n” +

“<B>Request Protocol: </B>” +

request.getProtocol() + “<BR><BR>\n” +

“<TABLE BORDER=1 >\n” +

“<TR BGCOLOR=\”#FFAD00\”>\n” +

“<TH>Header Name<TH>Header Value”);

Enumeration headerNames = request.getHeaderNames();

while(headerNames.hasMoreElements()) {

String headerName = (String)headerNames.nextElement();

out.println(“<TR><TD>” + headerName);

out.println(”    <TD>” + request.getHeader(headerName));

}

out.println(“</TABLE>”);

}

private void PrintParams(HttpServletRequest request,

HttpServletResponse response, PrintWriter out) {

// Get the value of a request parameter; the name is case-sensitive

String name = “param”;

String value = request.getParameter(name);

if (value == null) {

// The request parameter ‘param’ was not present in the query string

// e.g. http://hostname.com?a=b

} else if (“”.equals(value)) {

// The request parameter ‘param’ was present in the query string but has no value

// e.g. http://hostname.com?param=&a=b

}

out.println(name+’=');

// Get the value of the request parameter

value = request.getParameter(name);

// If the request parameter can appear more than once in the query string, get all values

String[] values = request.getParameterValues(name);

for (int i=0; i<values.length; i++) {

out.println(”    ”+values[i]+”<br>”);

}

}

Einfach rüberkopieren, Tomcat startet WAR selbst neu

Aufrufen:

http://192.168.178.49:8080/de.bla.dest/MeinTest?bla=bull

————————————————————————————–

im web.xml steht

<servlet>

<servlet-class>de.bla.dest.MeinTest</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>MeinTest</servlet-name>

<url-pattern>/MeinTest</url-pattern>

</servlet-mapping>

wir wollen alles was hinter MeinTest kommt mit MeinTest verarbeiten,

also ändern

<url-pattern>/MeinTest/*</url-pattern>

dann geht auch hinten an der url was anzuhängen:

http://192.168.178.49:8080/de.bla.dest/MeinTest/x/y.html?bla=bull

auszulesen in request.getRequestURI():  /de.bla.dest//MeinTest/x/y.html

————————————————————————————–

Root.WAR

um eine /index.html auszuliefern Rechte Maustaste aufm Projekt

Exportname nach ROOT.war ändern und in webapps kopieren…

zusätzlich im webinf:

<servlet-mapping>

<servlet-name>MeinTest</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

Wirds nicht deployed, dann das webapps/ROOT/.. Verzeichnis löschen, erneut deployen (bzw server neu starten)

Nachher gehts von selbst

————————————————————————————–

ein einfachs Pom für maven:

<?xml version=”1.0″ encoding=”UTF-8″?>

<project xmlns=”http://maven.apache.org/POM/4.0.0″

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”>

<modelVersion>4.0.0</modelVersion>

<groupId>Example</groupId>

<artifactId>Example</artifactId>

<packaging>war</packaging>

<version>0.0.1</version>

<dependencies>

<dependency>

<groupId>tomcat</groupId>

<artifactId>servlet-api</artifactId>

<version>5.5.23</version>

<scope>provided</scope>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<artifactId>maven-compiler-plugin</artifactId>

<configuration>

<source>1.5</source>

<target>1.5</target>

</configuration>

</plugin>

</plugins>

</build>

</project>

A web application consists of web components, static resource files such as images, and helper classes and libraries. In the Java 2 platform, web components provide the dynamic extension capabilities for a web server.

Web Components :

• Java Servlets
• JSP
• Web Services endpoint

Web Container :

• Web components are supported by the services of a runtime platform called a web container.
• A web container provides services such as request dispatching, security, concurrency, and life-cycle management. It also gives web components access to APIs such as naming, transactions, and email.

Web application deployment descriptor (DD) : The configuration information is maintained in a text file in XML format called a web application deployment descriptor.

Java Web Application Request Handling

Java Web Application Technologies

Java Web Application Technologies

Servlets are Java programming language classes that dynamically process requests and construct responses.

Servlets are best suited for service-oriented applications (web service endpoints are implemented as servlets) and the control functions of a presentation-oriented application, such as dispatching requests and handling nontextual data.

JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content.

JSP pages are more appropriate for generating text-based markup such as HTML, Scalable Vector Graphics (SVG), Wireless Markup Language (WML), and XML.

Web Application Life Cycle

The process for creating, deploying, and executing a web application can be summarized as follows :

1. Develop the web component code.
2. Develop the web application deployment descriptor.
3. Compile the web application components and helper classes referenced by the components.
4. Optionally package the application into a deployable unit.
5. Deploy the application into a web container.
6. Access a URL that references the web application.

Web Module

Web Resources : In the Java EE architecture, web components and static web content files such as images are called web resources.

Web Module : A web module is the smallest deployable and usable unit of web resources.

In addition to web components and web resources, a web module can contain other files :

• Server-side utility classes (database beans, shopping carts, and so on). Often these classes conform to the JavaBeans component architecture.
• Client-side classes (applets and utility classes).

Structure of Web Module

Top level directory is – Document Root of the application

Document Root contains :

1. JSP pages
2. Client side classes and archives
3. Static web resources, such as images
4. WEB-INF (Sub Directory) contains -
   • web.xml : The web application deployment descriptor
   • Tag library descriptor files
   • classes : A directory that contains server-side classes: servlets, utility classes, and JavaBeans components
   • tags : A directory that contains tag files, which are implementations of tag libraries
   • lib : A directory that contains JAR archives of libraries called by server-side classes

If your web module does not contain any servlets, filter, or listener components then it does not need a web application deployment descriptor.

You can also create application-specific subdirectories in -

• document root or
• WEB-INF/classes/ directory

You can deploy Web Module into any web container that conforms to the Java Servlets Specification.

To deploy a WAR on the Application Server, the file must also contain a Runtime Deployment Descriptor.

Runtime Deployment Descriptor : The runtime deployment descriptor is an XML file that contains information such as the context root of the web application and the mapping of the portable names of an application’s resources to the Application Server’s resources.

The Application Server web application runtime DD is named sun-web.xml and is located in the WEB-INF directory along with the web application DD.

Web Module Structure

Packaging Web Modules
To build the hello1 application with NetBeans IDE, follow these instructions :

1. Select File?Open Project.
2. In the Open Project dialog, navigate to tut-install/javaeetutorial5/examples/web/
3. Select the hello1 folder.
4. Select the Open as Main Project check box.
5. Click Open Project.
6. In the Projects tab, right-click the hello1 project and select Build.

To build the hello1 application using the Ant utility, follow these steps:

1. In a terminal window, go to tut-install/javaeetutorial5/examples/web/hello1/.
2. Type ant. This command will spawn any necessary compilations, copy files to the tut-install/javaeetutorial5/examples/web/hello1/build/ directory, create the WAR file, and copy it to the tut-install/javaeetutorial5/examples/web/hello1/dist/ directory.

Deploying a WAR File
Context Root : A context root identifies a web application in a Java EE server.

• You specify the context root when you deploy a web module.
• A context root must start with a forward slash (/) and end with a string.

Setting the Context Root :
In a packaged web module for deployment on the Application Server, the context root is stored in sun-web.xml.
To edit the context root, do the following :

1. Expand your project tree in the Projects pane of NetBeans IDE.
2. Expand the Web Pages and WEB-INF nodes of your project.
3. Double-click sun-web.xml.
4. In the editor pane, click Edit As XML.
5. Edit the context root, which is enclosed by the context-root element.

You can deploy a WAR file to the Application Server in a 4 ways:

• Copying the WAR into the domain-dir/autodeploy/ directory.
• Using the Admin Console.
• By running asadmin or ant to deploy the WAR.
• Using NetBeans IDE.

Deploying a Packaged Web Module
If you have deployed the hello1 application, before proceeding with this section, undeploy the application by following one of the procedures described in Undeploying Web Modules.

Deploying with the Admin Console

1. Expand the Applications node.
2. Select the Web Applications node.
3. Click the Deploy button.
4. Select the radio button labeled “Package file to be uploaded to the Application Server.”
5. Type the full path to the WAR file (or click on Browse to find it), and then click the OK button.
6. Click Next.
7. Type the application name.
8. Type the context root.
9. Select the Enabled box.
10. Click the Finish button.

Deploying with asadmin
To deploy a WAR with asadmin, open a terminal window or command prompt and execute
=> asadmin deploy full-path-to-war-file

Deploying with Ant
To deploy a WAR with the Ant tool, open a terminal window or command prompt in the directory where you built and packaged the WAR, and execute
=> ant deploy

Deploying with NetBeans IDE
To deploy a WAR with NetBeans IDE, do the following:

1. Select File?Open Project.
2. In the Open Project dialog, navigate to your project and open it.
3. In the Projects tab, right-click the project and select Undeploy and Deploy.

Testing Deployed Web Modules

• By default, the application is deployed to host localhost on port 8080.
• The context root of the web application is hello1 suppose.

To test the application, follow these steps:

1. Open a web browser.
2. Enter the following URL in the web address box : http://localhost:8080/hello1
3. Enter your name, and click Submit.

Listing Deployed Web Modules
To use the Admin Console :

1. Open the URL http://localhost:4848/asadmin in a browser.
2. Expand the nodes Applications?Web Applications.

Use the asadmin command as asadmin list-components

Updating Web Modules

1. Recompile any modified classes.
2. If you have deployed a packaged web module, update any modified components in the WAR.
3. Redeploy the module.
4. Reload the URL in the client.

Dynamic Reloading

• If dynamic reloading is enabled, you do not have to redeploy an application or module when you change its code or deployment descriptors.
• This capability is useful in a development environment, because it allows code changes to be tested quickly.
• Not recommended for a production environment, however, because it may degrade performance.

To enable dynamic reloading, use the Admin Console:

1. Select the Applications Server node.
2. Select the Advanced tab.
3. Check the Reload Enabled box to enable dynamic reloading.
4. Enter a number of seconds in the Reload Poll Interval field to set the interval at which applications and modules are checked for code changes and dynamically reloaded.
5. Click the Save button.

In addition, to load new servlet files or reload deployment descriptor changes, you must do the following:

1. Create an empty file named .reload at the root of the module :
   domain-dir/applications/j2ee-modules/context-root/.reload
2. Explicitly update the .reload file’s time stamp each time you make these changes. On UNIX, execute
   touch .reload

For JSP pages, changes are reloaded automatically at a frequency set in the Reload Poll Interval field. To disable dynamic reloading of JSP pages, set the Reload Poll Interval field value to –1.

Undeploying Web Modules
To use NetBeans IDE:

1. Ensure the Sun Java System Application Server is running.
2. In the Runtime window, expand the Sun Java System Application Server instance and the node containing the application or module.
3. Right-click the application or module and choose Undeploy.

To use the Admin Console:

1. Open the URL http://localhost:4848/asadmin in a browser.
2. Expand the Applications node.
3. Select Web Applications.
4. Click the check box next to the module you wish to undeploy.
5. Click the Undeploy button.

Use the asadmin command as “asadmin undeploy context-root“
To use the Ant tool, execute the following command in the directory where you built and packaged the WAR:
“ant undeploy”

Configuring Web Applications

Mapping URLs to Web Components
When a request is received by the web container it must determine which web component should handle the request. It does so by mapping the URL path contained in the request to a web application and a web component.

A URL path contains the context root and an alias
“http://host:port/context-root/alias”

The Component Alias

1. The alias identifies the web component that should handle a request.
2. The alias path must start with a forward slash (/) and end with a string or a wildcard expression with an extension (for example, *.jsp).
3. Since web containers automatically map an alias that ends with *.jsp, you do not have to specify an alias for a JSP page unless you wish to refer to the page by a name other than its file name.

Declaring Welcome Files

1. The welcome files mechanism allows you to specify a list of files that the web container will use for appending to a request for a URL (called a valid partial request) that is not mapped to a web component.
2. If a web container receives a valid partial request, the web container examines the welcome file list and appends to the partial request each welcome file in the order specified and checks whether a static resource or servlet in the WAR is mapped to that request URL. The web container then sends the request to the first resource in the WAR that matches.
3. If no welcome file is specified, the Application Server will use a file named index.XXX, where XXX can be html or jsp, as the default welcome file. If there is no welcome file and no file named index.XXX, the Application Server returns a directory listing.

To specify a welcome file in the web application deployment descriptor, do the following:

• Open web.xml
• Specify the JSP pages using welcome-file elements and include these elements inside a welcome-file-list element. The welcome-file element defines the JSP page to be used as the welcome page.

Setting Initialization Parameters
You can pass initialization parameters to the context or to a web component.

To add a context parameter, do the following:

1. Open web.xml.
2. Using the following elements to add a context parameter
   • A param-name element that specifies the context object
   • A param-value element that specifies the parameter to pass to the context object
   • A context-param element that encloses the previous two elements

To add a web component initialization parameter, do the following:

1. Open web.xml.
2. Using the following elements to add a context parameter
   • A param-name element that specifies the name of the initialization parameter
   • A param-value element that specifies the value of the initialization parameter
   • An init-param element that encloses the previous two elements

Mapping Errors to Error Screens
When an error occurs during execution of a web application, you can have the application display a specific error screen according to the type of error.

To set up error mappings, do the following:

1. Open web.xml
2. Using the following elements
   • An exception-type element specifying either the exception or the HTTP status code that will cause the error page to be opened.
   • A location element that specifies the name of a web resource to be invoked when the status code or exception is returned. The name should have a leading forward slash (/).
   • An error-page element that encloses the previous two elements.
     You can have multiple error-page elements in your deployment descriptor.

Declaring a Reference to a Resource

1. The @Resource annotation is used to declare a reference to a resource such as a data source, an enterprise bean, or an environment entry.
2. This annotation is equivalent to declaring a resource-ref element in the deployment descriptor.
3. The @Resource annotation is specified on a class, method or field.
4. The container is responsible for injecting references to resources declared by the @Resource annotation and mapping it to the proper JNDI resources.

Example

If you have multiple resources that you need to inject into one component, you need to use the @Resources annotation to contain them, as shown by the following example

Declaring a Reference to a Web Service

1. The @WebServiceRef annotation provides a reference to a web service.
2. WebServiceRef uses the wsdlLocation element to specify the URI of the deployed service’s WSDL file.

Example

REFERENCES

1. http://java.sun.com/javaee/5/docs/tutorial/doc/geysj.html
2. http://java.sun.com/javaee/5/docs/tutorial/doc/bnadx.html
3. http://java.sun.com/javaee/5/docs/tutorial/doc/

For one of the applications that I’m maintaining, I was performing several manual validations on the tables a few times a day; in order to facilitate this tasks, I created a stored procedure to handle them and then send an email with the results using MSSQL mail service.
Also, I wanted this procedure to be executed several times a day, that’s why I decided to use Quartz in order to create a scheduled job for my web application that will call my recently created procedure.

First, I created the class that will represent the Job I want to execute. This class must implement the class

org.quartz.Job, overriding the method execute(..)

package com.dashboard.util;
import org.apache.log4j.Logger;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import com.dashboard.forms.DashboardForm;
import com.dashboard.services.IService;
import com.dashboard.services.ValuationHealthCheckService;

public class ValuationHealthCheckJob implements Job {
    private static final Logger logger = Logger.getLogger(ValuationHealthCheckService.class);

    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        DashboardForm form = new DashboardForm();
        form.setEmailTo("xxxxx.yyyyy@domain.com");
        IService service = new ValuationHealthCheckService();
        try {
            service.execute(form);
        } catch (Exception e) {
            logger.error(e);
        }
    }
}

As you can see, the body of the method execute is really simple. A DashboardForm class, which is simply a java bean with a field “emailTo” and then the creation and execution of my service class. The service class will take care of connecting to the database and execute the stored procedure that will verify the tables and send an email with the result.
Here’s the ValuationHealthCheckService class:


package com.dashboard.services;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.apache.log4j.Logger;
import com.dashboard.forms.DashboardForm;

public class ValuationHealthCheckService implements IService {

    private static final Logger logger = Logger.getLogger(ValuationHealthCheckService.class);

    @Override
    public void execute(Object o) throws NamingException, SQLException {
        DashboardForm form = (DashboardForm) o;
        Connection con = null;
        Context ctx = new InitialContext();

        DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/MarginDB");
        con = ds.getConnection();
        String populateAttrs = "{call p_ValuationHealthCheck(?,?)}";

        logger.info("{call p_ValuationHealthCheck(?,?)}");

        if (form.getEmailTo() == null || form.getEmailTo().equals("")) {
            throw new RuntimeException("You must specify at least one email recipient.");
        }

        PreparedStatement populateAttrsStmt = con.prepareStatement(populateAttrs);
        populateAttrsStmt.setString(1, form.getEmailTo());
        populateAttrsStmt.setString(2, form.getEmailCC());
        populateAttrsStmt.execute();
        con.close();
    }
}

I’m retrieving the database connection using the datasource I have defined in Tomcat.
After that, I needed to create the servlet in order to setup the schedule for the job.


import java.text.ParseException;
import javax.servlet.http.HttpServlet;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import com.dashboard.util.ValuationHealthCheckJob;

public class QuartzServlet extends HttpServlet {

    public QuartzServlet() throws SchedulerException, ParseException {
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();
        // Specify the class of the job I want to execute
        JobDetail jd = new JobDetail("ValuationHealthCheck", "AppGroup", ValuationHealthCheckJob.class);
        // Create a CRON expression
        CronTrigger ct = new CronTrigger("cronTrigger", "cronTrigger", "0 0 15-19 * * ?");
        // Add into the Scheduler the job and the trigger
        sched.scheduleJob(jd, ct);
        sched.start();
    }

}

And as a final step, I needed to define the servlet in the web.xml file.

    <servlet>
        <servlet-name>quartz</servlet-name>
        <servlet-class>
            com.dashboard.servlets.QuartzServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>


Just restart the Tomcat so the servlet (and our job) is loaded. From now on, our job will be executed using the cron expression we defined in the servlet: 0 0 15-19 . This means that the job will be executed everyday, every hour from 15 (3:00 PM) to 19 (7:00PM).

–

Just a note: Make sure you have the JAR file for Quartz in the WEB-INF/lib directory. I’m using maven for my web project so you just need to include the Quartz dependency in the pom.xml:

    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>quartz</artifactId>
        <version>1.6.0</version>
        <scope>compile</scope>
    </dependency>


–

That’s all. This was the simplest solution I found for my problem (due to lack of time). However, I will work on the integration with Spring as soon as I have free time.
For more information on Quartz: http://www.opensymphony.com/quartz/

Introduction:

We the developers, exert much effort to write perfect code. Regrettably, some times we may met with an exception or error conditions. While surfing the net, So many questions pointed out, how to handle the exceptions in JSF by showing a custom page instead of Java Stack trace. This article is consecrated for the peoples who wants to handle the exceptions perfectly in their application.

Other frameworks like Struts, provides a better way to handle exceptions by configuring <global-exceptions> in struts-config.xml. Like Struts, JSF 1.2 and below does not provide the notion of a global exception. Now JSF 2.0 have the features of handling exceptions. But this article is all about handling exceptions in JSF1.2.

Better way to handle exception:

Surrounding all the Java beans by try/catch can handle all kinds of exceptions this technique is called checked exceptions. but no coders wants all of their java bean methods to be surrounded by try/catch. Instead there is a alternate technique to handle exceptions called Unchecked exceptions. You want to implement any one of the two approaches, if not a default handler is found and  process the exception, resulting the web page in a stack trace.

Unchecked Exceptions:

The goal of this technique is to give you control to catch all the exceptions and let you navigate to an appropriate custom JSP page to generate the error response. To invoke this technique, create a new class that implements javax.faces.event.ActionListener interface.

Note: It is important that your class is a subclass of this class.

public class ExceptionHandlingActionListener extends ActionListenerImpl

implements ActionListener{..}

Then, implement the public void method handleBeanAction(ActionEvent event). This method should invoke the “normal” inherited processAction(ActionEvent event) method, which catches any exceptions and return the navigational string “exceptionOccured”.

public void handleBeanAction(ActionEvent event)
{
try
{
    super.processAction(event);
}
catch (Exception exception)
{
    FacesContext facesContext = FacesContext.getCurrentInstance();
    Application application = facesContext.getApplication();
    NavigationHandler navigationHandler =  application.getNavigationHandler();
    navigationHandler.handleNavigation( facesContext, null,“exceptionOccured”);
    facesContext.renderResponse();
}
}

So by using the above method, when an exception occured, it will be caught in the catch block and the error occured page will be navigated to a custom jsp page.

Configration in faces-config:

<application>
<action-listener>
com.mypackagename.ExceptionHandlingActionListener
</action-listener>
</application>

Then implement the navigation rule ,

<navigation-rule>
<navigation-case>
<from-outcome>
exceptionCaught
</from-outcome>
<to-view-id>/mypages/exceptionPage.jsp</to-view-id>
</navigation-case>
</navigation-rule>

Then create a custom exception page in JSP (exceptionPage.jsp). So that when the navigation string “exceptionCaught” occured, the page will be navigated to the desired custom JSP page.

HTTP Status Code Exceptions:

In order to handle HTTP Status code errors like 404 and 500, configure in your web.xml

<error-page>
<error-code>404</error-code>
<location>/mypages/404.html</location>
</error-page>

Likewise State 500 in the error code, to handle HTTP Status code error 500

Note:

In this handling the response page must be an HTML page. So that we can avoid reentrant error in processing the response.

Delegating FacesServlet:
An other way to handle exception is to delegating FacesServlet. To say simple, wrapping the FacesServlet by implementing our own custom FacesServlet. Delegating FacesServlet will work only for the JSF1.1.01 and above. Thanks for the resources provided in the site jroller.

FacesServletWrapper.java

package com.mypackage;
import java.io.IOException;
import javax.faces.webapp.FacesServlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class FacesServletWrapper extends HttpServlet
{
    private FacesServlet facesServletDelegate;
    private static final String ERROR_PAGE = "serverErrorPage";
    private String serverErrorPage;
public void init(ServletConfig servletConfig) throws ServletException
{
    facesServletDelegate= new FacesServlet();
    facesServletDelegate.init(servletConfig);
    serverErrorPage = servletConfig.getInitParameter(ERROR_PAGE);
}
public void destroy()
{
    facesServletDelegate.destroy();
}
public ServletConfig getServletConfig()
{
    return facesServletDelegate.getServletConfig();
}
public String getServletInfo()
{
    return facesServletDelegate.getServletInfo();
}
public void service(ServletRequest request, ServletResponse response)
            throws ServletException, IOException
{
    try
    {
        facesServletDelegate.service(request,response);
    }
    catch(Throwable e)
    {
        redirectToServerErrorPage((HttpServletRequest) request,
                           (HttpServletResponse) response);
    }
}
private void redirectToServerErrorPage(HttpServletRequest request,
             HttpServletResponse response) throws IOException
{
    if (!serverErrorPage.equals(""))
    {
        response.sendRedirect(request.getContextPath() + serverErrorPage);
    }
}

Configuration in web.xml:

Note: As stated below, replace the FacesServlet servlet description with the FacesServletWrapper

<servlet>
<servlet-name>FacesServlet</servlet-name>
<servlet-class>com.mypackage.FacesServletWrapper</servlet-class>
<init-param>
<param-name>serverErrorPage</param-name>
<param-value>/faces/mypages/serverErrorPage.jsp</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

Once replacing the FacesServlet servlet description with the FacesServletWrapper, dont forget to specify the servlet-mapping description as stated below

<servlet-mapping>
<servlet-name>FacesServlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>

The preceding code, wrapping the FacesServlet works perfectly with Tomcat. But if anyone uses Glassfish(Sun Java System Application Server). You may get an exception some thing like the below.

java.lang.RuntimeException:  Exception in handleBeforeEvent.

If you met with the same kind of exception. Here is the solution to resolve this error, implement servlet interface instead of extending HttpServlet. So I hope this article clearly explains, the several ways to handle exceptions in JSF. If you find this article is quite useful, Dont forget to share with me by your valuable comments. Have a joyous code day.

Şuan yaptığım projede, JSP sayfası içerisinde, textboxlar yardımı ile  girdi olarak aldığım inputlarımı Servletler aracılığı ile mysql database’ime atıyorum. Fakat Türkçe karakter sorunu yaşadım. Internetten araştırdığımda bir kaç farklı yol buldum fakat hiç birisi derdime derman olmadı. Bulduğum yollardan bazılarını harmanlayarak kullanınca en sonun Türkçe karakter sorunumu aşabildim:)

Birilerinin işine yarar ümidi ile uyguladığım adımları paylaşayım;
1- Öncelikle mysql’den karakter setini UTF8 seçiyoruz.
2- Java class’ı tarafında, Connection’ı tanımlarken normal adresten daha fazlasını kullanıyoruz;
normal adres: jdbc:mysql://localhost:[portnumarası]/[db ismi]
kullanılması gereken:
jdbc:mysql://localhost:[portnumarası]/[db ismi]?useUnicode=true&characterEncoding=UTF-8

3 - Verileri JSP sayfasından verileri çekmeden önce;  request.setCharacterEncoding(“ISO-8859-9″); yazıyoruz..

artık database’imize girdiğimiz Türkçe karakterler olması gerektiği gibi görüntülenecek.