JSP: what all the encoding declarations mean

2010-12-19T17:39:00.000Z

When you see a JSP document, you might wonder why it specifies the UTF-8 encoding three or four times. This is a post about what those declarations mean. A sample JSP document <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

Comments policy

2010-11-21T14:09:00.000Z

Comments are moderated and will not appear until I approve them. I don't live on the blog, so it may take me some time to see and respond to your comment. I won't publish comments with e-mail addresses in them. If you post a question and I don't respond, I just may not know the answer off the top of my head and may not feel like putting in the research to answer it. You'll have more luck on

Java: System.console(), IDEs and testing

2010-09-19T16:56:00.002+01:00

The method System.console() can return null if there is no console device present. This comes as a surprise to people when they run their code in an IDE. This post is about overcoming such problems. Is it worth using java.io.Console at all? The Console class in Java 6 has the following constraints: It is final, so you can't provide your own implementation directly There is no service

Java: "Content is not allowed in prolog" - causes of this XML processing error

2010-09-16T23:16:00.001+01:00

Content is not allowed in prolog is an error generally emitted by the Java XML parsers when data is encountered before the

Java: a fluent I/O API (4/4)

2010-08-01T16:52:00.002+01:00

This is the fourth post about my experiments with a fluent I/O API. This post covers conclusions and limitations of the implementation. You can find downloads and source repository details further down the page. Conclusions In my first post, I outlined some of the goals of the API. Here's a run down of how the API measures up. Goal: reduce the amount of code required for I/O operations In

Java: a fluent I/O API (3/4)

2010-08-01T16:16:00.001+01:00

This is the third post about my experiments with a fluent I/O API. This post covers how the API enhances exception handling. Eliminating unnecessary catch blocks This code compresses a string into an array of bytes: private static byte[] gzip(String data) { ByteArrayOutputStream buffer = new ByteArrayOutputStream(); try { OutputStream gzip = new

Java: a fluent I/O API (2/4)

2010-08-01T16:15:00.001+01:00

This is the second post about my experiments with a fluent I/O API. This post covers how to extend the API. Doctoring streams Let's look at some of the API's Doctor implementations. The code uses some static imports to keep things clean: import static demo.fluentio.Closers.closer; import static demo.fluentio.Doctors.DETECT_BOM; import static demo.fluentio.Doctors.bom;

Java: a fluent I/O API (1/4)

2010-08-01T15:46:00.001+01:00

I've been experimenting with fluent API design. You can find the sources in part 4. I've often been frustrated with the verbosity of Java I/O. Handling close with decorators got better with the introduction of the Closeable interface, but there's still a bit of boilerplate. This post describes a new fluent API to wrapper around the existing I/O API. Goals The goals of this API are:

I18N: comparing character encoding in C, C#, Java, Python and Ruby

2010-04-17T19:30:00.000+01:00

Don't assume that the character handling conventions you've learnt in one language/platform will automatically apply in others. I've selected a cross-section of popular languages to contrast the different ways character encoding is handled. Topics Character data types Transcoding C C# Java Python Ruby Notes Resources Character data types Character data is always going to

Scala: implementing a "did you mean..?" spelling corrector

2010-01-12T16:56:00.005Z

I was looking at Scala again and decided to implement Peter Norvig's algorithm for suggesting spelling correction suggestions. I suggest you go read How to Write a Spelling Corrector for the clever stuff. This implementation is limited to the English alphabet. You'll need the big.txt file or a similar set of training data. Spell check in Java Spell check in Scala Did you mean ..?

Java: safe character handling and URL building

2009-12-17T12:49:00.005Z

This post discusses HTTP URLs in Java and how to avoid data loss due to encoding/escaping issues. Special mention is made of the query part, since it is frequently used to store data. Background Why are there problems? Anatomy of a URI URIs and HTTP HTML query encoding URIs in Java code The URL class The URI class URLEncoder and URLDecoder A

Java: application to check binary class versions

2009-11-26T12:40:00.003Z

Here's a simple application based on the code from a previous post. You can run it on .class files, .jar files or directories (it'll recursively search them for .class files). It will tell you what version of Java the contained code was compiled for. Download: javaClassVersionLib_1.1.zip

Java: how to use an IllegalArgumentException

2009-11-17T23:38:00.004Z

Calling my web log Illegal Argument Exception seemed like a clever idea at the time. It is probably just a recipe for confusing Java neophytes searching for their program errors. I should've listened to what my granny used to tell me about clarity, precision, and terseness when choosing identifiers. To make up for it, here's a short post about IllegalArgumentException (the exception type).

JSF: working with component identifiers (id/clientId)

2009-10-09T18:19:00.006+01:00

This is a post about how to work with IDs in JavaServer Faces. You may find this useful if you want to use JavaScript with JSF. Example ID developer sets on a JSF component: foo1 What JSF might render in the resultant HTML: j_id_jsp_115874224_691:table1:0:foo1 This is a revised version of JSF: working with component IDs (id vs clientId), though you don't need to read that. This post fixes

Java: character inspector application

2009-09-18T21:41:00.001+01:00

This is a small application that's useful for solving character encoding bugs. If you've ever wanted to find out exactly what characters you have, or what bytes they encode to with a specific encoding, this app may do the trick. DOWNLOAD HERE If you want to know more about character encoding in Java, read Java: a rough guide to character encoding. Sources All the sources are available in a

JSF: a custom format panel control for localising component layout

2009-08-01T13:43:00.009+01:00

This post describes a custom JavaServer Faces component for controlling the flow layout of controls based on localised strings. The h:outputFormat component The h:outputFormat control is a standard JSF control for formatting strings. It is often used with resource bundles. This is a faces-config.xml declaration for adding two languages to a JSF application and defining a resource bundle

Java: finding class versions

2009-07-22T23:02:00.006+01:00

The JVM versions your Java classes will run on is often determined by how you compile them. Failure to take care with your classes and dependencies can lead to an UnsupportedClassVersionError. This post demonstrates how to check your class files. The class file format Information on the Java binary format can be found in The Java Virtual Machine Specification. The ClassFile Structure defines

Java: effective Unicode

2009-07-18T14:57:00.002+01:00

This is my attempt at a list of maxims to abide by when working with text in Java, in the vein of Effective Java or The Ten Commandments of Unicode. It is also a summary of another post on character encoding. The list is in no way comprehensive. 1: Understand how UTF-8 differs from ASCII (and CP437, and Windows-1252, and ISO-8859-1, and ISO-8859-15, and MacRoman, etc.) Understand how using

Java: using XPath with namespaces and implementing NamespaceContext

2009-05-28T11:11:00.003+01:00

XPath is a handy expression language for running queries on XML. This post is about how to use it with XML namespaces in Java (javax.xml.xpath). This Java code and uses an XPath expression to extract the value of the bar attribute from a simple document: XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); String xml = "

JSF: using component IDs in a data table (h:dataTable vs clientId)

2009-05-27T18:17:00.008+01:00

Updated 2009/11/24 This post is obsolete; go read this one instead: JSF: working with component identifiers The approach described in this post may fail if the component identifiers are not unique within the view. I've written about how to use a custom function to get the clientId before. You can download the code from here. Below is an example that uses the id:cachedClientId function in a

Java: dynamically loading scripting engines (Groovy, JRuby and Jython)

2009-05-26T16:38:00.003+01:00

Java 6 (via JSR 223) added scripting language support to the standard library. The JVM ships with the Mozilla Rhino JavaScript engine included. Where an engine is available, it is easy to add support for other JVM scripting languages. It is useful to be able to load these engines dynamically. This Java 6 code uses the URLClassLoader class to load and invoke a selection of engines at runtime:

JSF: IDs and clientIds in Facelets

2009-05-19T12:28:00.005+01:00

Updated 2009/11/24 This post is obsolete; go read this one instead: JSF: working with component identifiers The approach described in this post may fail if the component identifiers are not unique within the view. Facelets is an alternative view technology to traditional JavaServer Pages and was designed with JavaServer Faces (JSF) in mind. I've written before about how IDs work in JSF and

Java: a rough guide to character encoding

2009-05-01T19:51:00.011+01:00

It can be tricky figuring out the difference between character handling code that works and code that just appears to work because testing did not encounter cases that exposed bugs. This is a post about some of the pitfalls of character handling in Java. Topics: Unicode in source files Unicode and Java data types How long is a (piece of) String? Encodings Stream encoding

Java: Unicode on the Windows command line

2009-04-10T13:34:00.002+01:00

By default, Java encodes Strings sent to System.out in the default code page. On Windows XP, this means a lossy conversion to an "ANSI" code page. This is unfortunate, because the Windows Command Prompt (cmd.exe) can read and write Unicode characters. This post describes how to use JNA to work round this problem. This post is a follow-up to I18N: Unicode at the Windows command prompt (C++; .Net;

I18N: Unicode at the Windows command prompt (C++; .Net; Java)

2009-04-09T20:37:00.014+01:00

Strange things can happen when working with characters. It is important to understand why problems occur and what can be done about them. This post is about getting Unicode to work at the Windows command prompt (cmd.exe). Topics: "Penny wise and pound foolish" - a character corruption example Character encodings and code pages Switching the Windows console to Windows-1252

Java: using JPDA to write a debugger

2009-03-11T10:28:00.001Z

The Java Platform Debugger Architecture (JPDA) API included in the JDK lets you connect to a Java debug session and receive debug events. This code allows you to do the same things you would normally do with jdb or an IDE debugger. This is useful if you want to write your own debug, diagnostics or metrics tools. Here is some sample code that will be debugged:

Java: finding the validation mechanism for an arbitrary XML document

2009-02-21T13:37:00.004Z

Unfortunately, there is no 100% foolproof process for determining how to validate an arbitrary XML document. If you are receiving a document, you should not leave choosing the validation mechanism to a remote party (e.g. downloading a DTD using its document-specified URI). Doing so opens your application to, at the very least, a potential denial-of-service attack. A validation mechanism may not

JSF: working with component IDs (id vs clientId)

2009-02-16T13:26:00.015Z

Updated 2009/10/17 WARNING: this post is obsolete; go read this one instead. JavaServer Faces components generate their own HTML element id attributes. How to work with these generated IDs is a source of much confusion among JSF neophytes. This post aims to explain what is going on and provides sample code that should make working with IDs a little bit easier. Example JSF control in a JSP:

I18N: a non-technical software bug

2009-02-03T17:45:00.018Z

Can you spot the problem with the following dialog? I expect the developers of the Steam installer are making trade-offs for the benefit of younger users - providing visuals to help match them with their language. However, using flags in software products is generally a bad idea. These flags belong to a few (not even the majority) of the sovereign states that use English as an official

Java: automating the equals method

2008-12-24T16:38:00.003Z

I spend quite a lot of time writing Java code. I got to thinking about the time I spent implementing, testing, maintaining and just paging over equals /hashCode implementations. These common building blocks tend to work much the same way in most classes and I wondered if there were a way to make them go away. Implementing equals, hashCode and toString The DataStructure class below shows a

Java: how not to make a mess of stream handling

2008-10-02T12:14:00.019+01:00

This article was written with Java 6 in mind. Updated 2008/12/16. /** * Writes "Hello, World!" to a file. */ public static void main(String[] args) { try { byte[] data = "Hello, World!".getBytes("UTF-8"); OutputStream out = new FileOutputStream("output.txt"); //if write throws an error out.write(data); //then

Ant: automated deployment to WebSphere Application Server

2008-08-18T18:37:00.009+01:00

It can be useful to automate deployment of enterprise applications to servers during development, either to automatically set up test builds or perform build verification during the kitting process. WebSphere Application Server (WAS) comes with a number of Ant tasks that can be used for this. Ant in WAS WAS comes with its own version of Ant. It should be run using the ws_ant.sh script (

HOWTO: Subversion in RAD7 on Fedora 8

2008-08-16T14:56:00.012+01:00

A quick HOWTO on setting up Rational Application Developer 7 as a Subversion client on Fedora 8. Subversion [user@fedora8 ~]$ yum list | grep subversion subversion.i386 1.4.4-7 installed subversion-javahl.i386 1.4.4-7 installed Subversion is probably pre-installed; the JNI bindings for the Subversion

Java: int versus Integer

2008-08-05T15:41:00.007+01:00

Changes in the Java language have blurred the functions of int and java.lang.Integer. However, every Java developer should understand the distinction between the two. Confusion arises because the two sets of code in the method below seem to be the same: /* Java 5 syntax */ public static void main(String[] args) { // adding ints int a = 1; int b = 1;

Java: using XMLBeans to edit web.xml

2008-08-01T15:20:00.004+01:00

XMLBeans is a Java API and set of utilities for working with XML. The code that follows demonstrates how to use it to manipulate a J2EE web.xml (version 2.5) document. Generating Java Beans from a Schema The XMLBeans scomp tool (schema compiler) is used to generate beans from a schema. It requires a Java compiler to do this. Here is the tool in action: C:>%XMLBEANS_HOME%\bin\scomp -src .\

Java: determining the version of an XML document

2008-07-31T00:52:00.002+01:00

When working with XML in Java, it is not uncommon to want to work with the data using strongly typed objects that enforce the document structure. That is, you want to use Java Beans rather than a Document Object Model (DOM). A number of technologies can be used to automate this transformation, such as the Apache Commons Digester (a rules-based entity mapper) or XMLBeans (which provides

Java: class names

2008-06-30T13:36:00.001+01:00

In Java, it is possible to get a String representation of a class by calling the Class.getName() method. Since Java 1.5 (AKA Java 5), it has been possible to get the canonical name using Class.getCanonicalName(). javadoc: java.lang.Class For many classes, these two methods will return identical values. Things get more interesting when it comes to some of the more esoteric types such as

C: hex dump application

2008-05-26T00:01:00.002+01:00

A C version of PrintHex to avoid a dependency on Mono. Compilation, usage and output: $ gcc phex.c -o phex $ ./phex phex.h 23 69 6E 63 6C 75 64 65 20 3C 73 74 64 69 6F 2E #include ____void print 46 69 6C 65 41 73 48 65 78 28 46 49 4C 45 2A 20 FileAsHex(FILE* 66 69 6C 65 29 3B 0D 0A 63 68 61 72 20 74 6F 56

C: Hello, World!

2008-05-25T14:26:00.001+01:00

gcc (GCC) 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2) #include int main() { printf("Hello, World!\n"); return 0; }

Java: generating a DOS executable

2008-05-01T22:59:00.001+01:00

By incrementally changing instructions in an assembly language, it is possible to build up a picture of how the bytes relate to the assembly instructions (without going to the trouble of actually reading the documentation). Note that, for these trivial examples at least, there is no difference between the binaries generated by NASM and the equivalent MS Debug instructions. NASM version

Assembler: Hello, World! [2]

2008-05-01T18:29:00.000+01:00

NASM version 0.98.39 compiled on Feb 25 2005 DOS, 16bit, x86 ;syntax expected by NASM ;DOS, x86, 16bit org 100h ;start at address 100 mov ax,0200h ;AH=2 mov dx,0048h ;'H' int 21h ;int 21,2 (print char) mov dx,0065h ;'e' int 21h mov dx,006Ch ;'l' int 21h mov dx,006Ch ;'l' int 21h mov dx,006Fh ;'o' int 21h mov dx,002Ch ;',' int 21h mov dx,0020h ;' ' int 21h

Assembler: using debug.exe to write DOS programs

2008-05-01T09:29:00.001+01:00

C:\WINDOWS\system32\debug.exe Windows (XP) still comes with Debug. C:\test>DEBUG -a 0C8A:0100 mov ax,0200 0C8A:0103 mov dx,0041 0C8A:0106 int 21 0C8A:0108 int 20 0C8A:010A -h 010A 0100 020A 000A -n PCHAR.COM -rcx CX 0000 :000A -w Writing 0000A bytes -q C:\test>PCHAR.COM A The above is the console output for writing a 10 byte executable in assembly language. All the application does

Assembler: Hello, World!

2008-05-01T00:25:00.001+01:00

DOS, x86, 16bit, debug.exe mov ax,0200 mov dx,0048 int 21 mov dx,0065 int 21 mov dx,006C int 21 mov dx,006C int 21 mov dx,006F int 21 mov dx,002C int 21 mov dx,0020 int 21 mov dx,0057 int 21 mov dx,006F int 21 mov dx,0072 int 21 mov dx,006C int 21 mov dx,0064 int 21 mov dx,0021 int 21 int 20

C#: file hex dump application

2008-04-30T21:37:00.001+01:00

A simple application for printing file contents as hexadecimal. Usage For multiple bytes per line: C:\> PrintHex.exe -h PrintHex.cs Sample output: 75 73 69 6E 67 20 53 79 73 74 65 6D 3B 0D 0A 75 using System;__u 73 69 6E 67 20 53 79 73 74 65 6D 2E 49 4F 3B 0D sing System.IO;_ 0A 0D 0A 2F 2A 2A 0D 0A 2A 20 41 70 70 6C 69 63 ___/**__* Applic 61 74 69 6F 6E 20 66 6F 72 20 70 72

C#: Hello, World!

2008-04-29T11:26:00.000+01:00

using System; public class HelloWorld { public static void Main(String[] args) { Console.WriteLine("Hello, World!"); } }

Java: using EL outside J2EE

2008-04-22T13:05:00.002+01:00

${example.expression.language.expression} If you have done much JSP programming, you will be familiar with the Expression Language (EL), also now known as the Unified Expression Language. EL is used in JSPs to help remove business logic from the view while keeping the data content dynamic. Uses for EL can go beyond J2EE platforms and it is relatively easy to incorporate it into your own

Java: finding binary class dependencies with BCEL

2008-04-14T00:05:00.001+01:00

Sometimes you need to find all the dependencies for a binary class. You might have a project that depends on a large product and want to figure out the minimum set of libraries to copy to create a build environment. You might want to check for missing dependencies during the kitting process. package foo; public class Bar implements Runnable {

Java: finding the application directory

2008-04-09T12:30:00.002+01:00

EDIT 2009/05/28: It has been pointed out to me that a far easier way to do all this is using this method: URL url = Location.class.getProtectionDomain() .getCodeSource().getLocation(); ...which makes everything below here pointless. You live and learn! If you are writing a rich client application, you may want to find the place where the system owner has

Java: synchronizing on an ID

2008-04-08T18:37:00.007+01:00

If you are a Java programmer, you will be familiar with synchronized blocks. Object myObject = //some instance synchronized(myObject) { //do some thread-sensitive //work on myObject } Sometimes, you want to synchronize on a transient object - a resource that isn't going to stay in memory. For example, there is nothing in the Servlet 2.5 MR6 specification that says a

Java: Hello, World!

2008-04-08T10:44:00.000+01:00

public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }

Illegal Argument Exception

JSF: managed beans without JSF dependencies

JSF: mocking FacesContext for unit tests

JSP: arbitrary attributes on JSF controls

WebSphere AS: RAD vs WSDL2Java for JAX-RPC client SOAP bindings

Java: JAX-WS web services and clients

TAM WebSEAL: authentication and the iPad

JavaScript: validating UTF-8 string lengths in the browser