`

Reading a file from the local file system and saving it as binary data, using Grails

2010-01-18T18:49:00.008-05:00

I'm relatively new to Grails and recently ran into some difficulty when attempting to save a file, read in from the local file system, as a long-blob to MySQL. Most of the documentation I found dealt with saving of single files, uploaded by users of the website front-end. My situation was a little different. My application needed to accept jar file uploads through the front-end, requiring that I extract and recreate the entire jar's directory structure onto the server's local file system, before further processing and validation. The original data contained in these files would ultimately have to be saved to the database. One of these file types were java class files and needed to be stored into a MySQL database long_blob field as binary data.

Below is the way I created the domain class for these class files. I've omitted some fields for the sake of simplicity. Our class files' binary data will be stored into the 'byteCode' field. The code in the mapping closure is needed to make this work.

package org.netbeans.portals.admin

import java.sql.Blob;

class FileClass {
String fileName;
Blob byteCode;
Date createdAt = new Date();

static constraints = {
fileName(unique: true, nullable: false)
byteCode(nullable: false)
createdAt(nullable: false)
}

static mapping = {
columns {
byteCode type: "blob"
}
}
}

Below, is some simple code that returns a java.sql.Blob object, provided the path to a file, as a String. It converts the file into byte array, using the 'getBytesFromFile' method listed beneath it. using Hibernate's 'createBlob' method gives us the required sql blob which we can simple assign to our FileClass object's byteCode field.

    def getSqlBlobFromFile(String path) {
file = new File(path)
bytes = this.getBytesFromFile(file)
java.sql.Blob sqlBlob = null
if (bytes) {
sqlBlob = org.hibernate.Hibernate.createBlob(bytes)
}
return sqlBlob
}

***DISCLAIMER: I did not write the code, below.***
This is one of countless examples of converting a file to a byte array that can be found throughout the web. Unfortunately, I do not recall where I found it.

    private static byte[] getBytesFromFile(File file) throws IOException {
InputStream is = new FileInputStream(file);
// Get the size of the file
long length = file.length();
if (length > Integer.MAX_VALUE) {
// File is too large
return null
}
// Create the byte array to hold the data
byte[] bytes = new byte[(int)length];
// Read in the bytes
int offset = 0;
int numRead = 0;
while (offset < bytes.length
&& (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
offset += numRead;
}
// Ensure all the bytes have been read in
if (offset < bytes.length) {
throw new IOException("Could not completely read file "+file.getName());
}
// Close the input stream and return bytes
is.close();
return bytes;
}

I hope this helps

Java Resource Injection

2010-01-12T11:31:00.006-05:00

If you are creating an API it may be necessary to provide resources to the API client. Many APIs use XML configuration files, resource files, or additional helper classes / methods to provide access to resources. All of which increase the learning curve required to utilize your code. Ideally your API should simplify resource provisioning and consumption. My personal preference is to follow the current trend towards annotations as an API convention.

In this post I will cover the convention of resource utilization via annotation and I will cover how to inject the resource by utilizing Java reflection. To clarify the convention, the client needs to annotate one or more fields and the fields must be of the proper Java type. If the client meets the conditions, the API container will automatically assign an appropriate resource to the client's field member even of the field is not public.

To demonstrate how this is done I will create a simple client:


package sample;

import java.sql.Connection;
import java.sql.SQLException;
import javax.naming.NamingException;

public class InjectionClient {
//field to be injected with required jndi name property
@ResourceProvider(jndiName="jdbc/MyPool")
private ConnectionProvider provider;

public void foo(String sql)
throws NamingException, SQLException {
Connection con = null;

try {
// provider already set by container
con = provider.getConnection();

// ... do something useful
} finally {
try { 
if (con != null) con.close(); 
} catch (SQLException ex) {}
}
}
}

Notice how simple and clean the code is for the client to consume the resource. Simply define a member of the correct type and annotate accordingly. Next lets look at the annotation being used by the client:


package sample;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// Annotation to be used for field declarations
@Target(ElementType.FIELD)
// Record annotation in the class file and make it available at run time
@Retention(RetentionPolicy.RUNTIME)
public @interface ResourceProvider {
String jndiName();
}

In this case the annotation tells the client that a jndi name is require. It also tells the client that the annotation is used for field declarations which will be recorded in the class file and will be accessible during runtime. The nice part of the annotation as part of an API is that most Java IDE's will help validate the proper usage of the annotation.

Finally lets take a look at the injection code:


package sample;

import java.lang.reflect.Field;

public class Injector {
public static void injectConnectionResource(Object o)
throws IllegalArgumentException, IllegalAccessException {
ResourceProvider a;

// iterate threw the fields
for (Field field : o.getClass().getDeclaredFields()) {
// set accessibility just in case the field is private
field.setAccessible(true);

// get the required annotation
a = field.getAnnotation(ResourceProvider.class);

// validate type and annotation
if (a != null && field.getType().isAssignableFrom(ConnectionProvider.class)) {
// inject
field.set(o, new ConnectionProvider(a.jndiName()));
}
}
}
}

To complete the example below is the code for the actual resource provider:


package sample;

import java.sql.Connection;
import java.sql.SQLException;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class ConnectionProvider {
private String jndiName;

public ConnectionProvider(String jndiName) {
this.jndiName = jndiName;
}

public Connection getConnection() throws NamingException, SQLException {
InitialContext context = new InitialContext();
DataSource dataSource = (DataSource) context.lookup(jndiName);
Connection con = dataSource.getConnection();

return con;
}
}

There are 2 gotchas with this approach:

1)If the field is set to anything other than public you may have an issue. Refection allows you to suppress Java language access checking but this only works if the no security manager is present. If a security manager is present then the “suppressAccessChecks” reflection permission must not be flagged as true.

2)Reflection is slow, painfully slow.

Gotcha's aside, resource injection via reflection based on annotation convention is a great approach to simplify an API.

JAXB Part .1 - Marshall a String to an Object / unMarshall an Object to a String

2010-01-11T11:15:00.006-05:00

When i first started using JAXB in my integration projects. Examples are what helped me the most in understanding how to properly use JAXB in my projects. What i discovered during my searches is the fact that there aren't many good examples to cover all aspects of the process. So i figured I'd add to the library of online examples. So this is part 1 of various installments i'll be doing to cover JAXB.

First up, let's explore the JAVA packages we'll need to import into the class that will be handling the JAXB calls. In this example we'll demonstrate how to use JAXB to unmarshall a String that contains XML that corresponds to a validate XSD Schema that has a JAXB class associated with it.

For this exmaple we'll use this Schema:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://xml.netbeans.org/schema/SimpleString"
xmlns:tns="http://xml.netbeans.org/schema/SimpleString"
elementFormDefault="qualified">
<xsd:element name="simple">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="stringOne" minOccurs="1" maxOccurs="1"/>
<xsd:element name="stringTwo" minOccurs="1" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

Once a JAXB Binding as been generated within you project using the above XSD. Classes will be generated to be used to access the XML tree elements. The targetNamespace defined within the .XSD will be used to define the package name unless otherwise provided when creating the JAXB binding.


org.netbeans.xml.schema.simplestring.simple;
org.netbeans.xml.schema.simplestring.ObjectFactory;

In this case we will be using "org.netbeans.xml.schema.simplestring.simple" for this example.

1. javax.xml.bind.JAXBContext : This is the class needed to do any marshalling or unmarshalling of Objects and Strings. A JAXBContext will be used to create an instance for handling the class.

Example Code:


import org.netbeans.xml.schema.simplestring.simple;
JAXBContext jbc = JAXBContext.newInstance("simple");

2. Now we will create an unMarshaller instance.
Unmarshaller unmarshaller = jbc.createUnmarshaller();

too be continued...

CFML on Glassfish with SMITH open source CFML engine. Part 1

2010-01-11T10:50:00.000-05:00

i was wondering weather SMITH could run correctly on Glassfish… Well so far so good, all it takes is a .WAR file of the application. Deploy it as a Web application with the correct context root, and that’s all she needs to get up and running… Screen shots and detailed instructions will come soon…

JAVA SERVLET - Requested URI

2009-12-22T17:00:00.009-05:00

I recently had an issue dealing with a Java Servlet. The Java Servlet was configured to handle errors via the web.xml file using the Error Pages configuration XML elements. This worked just fine as I've been able to handle a variety of errors. From 404 errors to 503, allowing me to serve up any message i want as the response to the request. Weather it be a web browser or server application.
But the one problem i had was trying to obtain the correct value of the URI that was requested. You would think that calling the method "getRequestURI()" of the HttpServletRequest would do the trick... But not so....


//Using the full class name for reference only, 
//the parameter name should be used instead
String uri = HttpServletRequest.getRequestURI();
System.out.println("URI: " + uri);

Since the Java Servlet was set to deploy to the context root of the server. The above code resulted in this output: URI: /myServletExceptionHandler

This would be great if i made a request to "http://www.mydomain.com/myServletExceptionHandler"
But my test request was made to "http://www.mydomain.com/build/table" and that's what i was expecting to see once i printed the value of "getRequestURI()" But that wasn't the case.
So after some heavy digging around, i stumbled apon a solution that was embedded within the attributes of the request.

String uri = null;
uri = HttpServletRequest.getAttribute("javax.servlet.error.request_uri");
System.out.println("URI: " + uri);

The above code resulted in this output: URI: /build/table

This was great, since i had made my request to "http://www.mydomain.com/build/table" the code was outputting the correct results. But there's a catch here.... This only worked when there was an error thrown and handled by the Servlet, but if no error was thrown, the output was: URI: (blank no output shown). The value remained null, and would throw an error if processed further. So here comes an if statement and the use of the "getRequestedURI()" method.

String uri = null;
uri = HttpServletRequest.getAttribute("javax.servlet.error.request_uri");
if (uri == null) {
//in case there's no URI given
uri = HttpServletRequest.getRequestURI();
}
System.out.println("URI: " + uri);

This did the trick, if an error was thrown the Original requested URI would be pulled from the attributes of the HttpServletRequest class, extracting the "javax.servlet.error.request_uri" value. If the String Object remains null, and attempt is made to retrive a value from the "getRequestedURI()" method of the HttpServletRequest class... And were done....

JAVA SERVLET - Getting the SOAPACTION from a SOAPMESSAGE posted to a Java servlet.

2009-12-22T12:55:00.001-05:00

I've been working on a project that utilizes a Java servlet to accept POST via the doPost method of a class that extends the HttpServlet class.

In order to get the SOAPACTION from a SOAPMESSAGE POST, you will need to parse the MimeHeaders of the request (HttpServletRequest).

NOTE: I purposely left out some imports and other methods not need for this post to shorten the content length. Error handling and such forth is being left out for simplicity of the post.
First you will need a MimeHeaders Object to store the Request.


import saaj.SaajUtils
import javax.xml.soap.MimeHeader;
import import javax.xml.soap.MimeHeaders;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

protected void 
doPost(HttpServletRequest req, 
HttpServletResponse resp) throws ServletException, IOException {
try
MimeHeader mh = SaajUtils.getHeaders(req);

}catch (Exception ex) {
Logger.getLogger("Exception").log(Level.SEVERE, null, ex);
//Return a server error if things go wrong to simplify things for the post
resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}

I used the SaajUtils class, which included methods to parse MimeHeaders, i will include that class later in this post.

Next we will use a method to parse the MimeHeader returned and extract the SOAPACTION from the MimeHeaders. This method will accept an Iterator Object to loop over. In order to get the Iterator Object, you will need to call the "getAllHeaders()" of the MimeHeader returned by the SaajUtils class method call.


private String getSoapAction(Iterator allHeaders) {
String soapAction = null;
while (allHeaders.hasNext()) {
MimeHeader header = (MimeHeader) allHeaders.next();
if (header.getName().equalsIgnoreCase("soapaction")) {
soapAction = header.getValue().replaceAll("\"", "");
}
}
return soapAction;
}


//Now add these lines
Iterator iterator = mh.getAllHeaders();
String soapAction = getSoapAction(iterator);


//Here's our SaajUtils class used

package saaj;

import java.io.ByteArrayInputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.StringTokenizer;
import javax.activation.DataHandler;
import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;
import javax.xml.soap.AttachmentPart;
import javax.xml.soap.MimeHeader;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;

/**
*
* @author Aalford
*/
public class SaajUtils {

/**
* extract the MIME header information from within the HTTP Request
* @param req the http request
* @return MimeHeaders as defined within the SAAJ API
*/
public static MimeHeaders getHeaders(HttpServletRequest req) {
Enumeration enumeration = req.getHeaderNames();
MimeHeaders headers = new MimeHeaders();

while( enumeration.hasMoreElements() ) {
String headerName = (String) enumeration.nextElement();
String headerValue = req.getHeader( headerName );

StringTokenizer values = new StringTokenizer( headerValue, ",");
while (values.hasMoreTokens()) {
headers.addHeader(headerName, values.nextToken().trim());
}
}
return headers;
}

/**
* stuff the MIME headers into the HTTP response
* @param headers the SAAJ MIME headers
* @param res the Http servlet response
*/
public static void putHeaders(MimeHeaders headers, HttpServletResponse res) {
for (Iterator it = headers.getAllHeaders(); it.hasNext();) {
MimeHeader header = (MimeHeader) it.next();
String[] values = headers.getHeader(header.getName());
if (values.length == 1) {
res.setHeader(header.getName(), header.getValue());
} else {
StringBuffer concat = new StringBuffer();
for (int i = 0; i < values.length; i++) {if (i != 0) {concat.append(',');}concat.append(values[i]);}res.setHeader(header.getName(), concat.toString());}}}public static void attachBytes(SOAPMessage soapMessage, byte[] theBytes, String contentType)throws SOAPException {AttachmentPart attachment = soapMessage.createAttachmentPart();attachment.setContent(new ByteArrayInputStream(theBytes), contentType);soapMessage.addAttachmentPart(attachment);}public static void attachUrlContents(SOAPMessage soapMessage, String urlLocation, String contentType)throws SOAPException, MalformedURLException {URL url = new URL(urlLocation);AttachmentPart attachment = soapMessage.createAttachmentPart(new DataHandler(url));attachment.setContentType(contentType);soapMessage.addAttachmentPart(attachment);}public static String getAttachmentReport(SOAPMessage soapMessage) throws SOAPException {int numOfAttachments = soapMessage.countAttachments();Iterator attachments = soapMessage.getAttachments();StringBuffer buf = new StringBuffer("Number of attachments: ");buf.append(numOfAttachments);while (attachments.hasNext()) {buf.append("\n--------------------------------------------\n");AttachmentPart attachment = (AttachmentPart) attachments.next();buf.append("\nContent Location: " + attachment.getContentLocation());buf.append("\nContent Id: " + attachment.getContentId());buf.append("\nContent Size: " + attachment.getSize());buf.append("\nContent Type: " + attachment.getContentType());}return buf.toString();}}

And that sum's it up


import saaj.SaajUtils
import javax.xml.soap.MimeHeader;
import import javax.xml.soap.MimeHeaders;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

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

MimeHeader mh = SaajUtils.getHeaders(req);
Iterator iterator = mh.getAllHeaders();
String soapAction = getSoapAction(iterator);
String message = "SOAPACTION: " + soapAction;
//Set the return status to SuccessFul HTTP/1.1 200 OK
resp.setContentType("text/xml");

//Using a method of the "HttpServletResponse" class
resp.setStatus(resp.SC_OK);


//Finally output the information to the browser

out.println("");
out.println(message);
out.println("");


}catch (Exception ex) {
Logger.getLogger("Exception").log(Level.SEVERE, null, ex);
//Return a server error if things go wrong to simplify things for the post
resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}

private String getSoapAction(Iterator allHeaders) {
String soapAction = null;
while (allHeaders.hasNext()) {
MimeHeader header = (MimeHeader) allHeaders.next();
if (header.getName().equalsIgnoreCase("soapaction")) {
soapAction = header.getValue().replaceAll("\"", "");
}

}
return soapAction;
}

JAVA SERVLET - Getting the Client Requestor IP Address and or Host name

2009-12-22T12:25:00.000-05:00

This is fairly simple to do, yet few know how easy it is.

The "HttpServletRequest" class has two methods that work to your advantage, as they do exactly what they specify by name.

1. getRemoteAddr() - Returns a String Object of the requesting server IP Address
2. getRemoteHost() - Returns a String Object of the requesting server HOST NAME

for example, the method below responds to POST made against the HOST server. If i wanted to print the IP Address and Host name of the requester. The code would be such.

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

//We will need a PrintWriter in-order to print information back to the browser without flushing an OutputStream.
PrintWriter out = resp.getWriter();

//Let's set the message String object variable with information to output.
String message = "The Requestor IP: " + req.getRemoteAddr() + " Requestor Host name: " + req.getRemoteHost();

//Set the return status to SuccessFul HTTP/1.1 200 OK
resp.setContentType("text/xml");

//Using a method of the "HttpServletResponse" class
resp.setStatus(resp.SC_OK);

//Finally output the information to the browser
out.println("");
out.println(message);
out.println("");

}

Simple and Clean