Ironic programmer: Java

Showing posts with label Java. Show all posts

Tuesday, May 19, 2015

RESTful Service on an embedded Glassfish/Payara

Last posts were about making a RESTFul service and run it on Jersey with an embedded Jetty.
This time I will set up a more Java EE like solution with the same REST Resource, but instead run it on an embedded Glassfish (actually, I will go for Payara). I will take the same model as before. Next part I will also add a JSF 2.2 client to use the RESTful service.

I will create this as a maven multi module with a parent project and two subprojects. One will be a web-project and the other will be a "runner" for the embedded Glassfish. I will not use maven to run, but will create a class that will run the embedded Glassfish with the war-file from the other project.

As it is pretty easy I use NetBeans to create maven projects for me.

The structure will be like this:

embgf

task-web
gf-runner
pack-dist

task-web

To start with, instead of having to set up a Servlet on "/api" path, we will create a configuration class that extends JAX_RSs Application.

And this will be the class for the Task service.

package se.ironic.task.boundary;

import java.net.URI;
import java.util.List;
import java.util.Optional;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import se.ironic.task.model.Task;

/**
 *
 * @author Ironic
 */
@Path("tasks")
public class TaskResource {
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<task> getAll() {
        return TaskCache.INST.getTasks();
    }
    
    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public Response create(Task task) {
        TaskCache.INST.putTask(task);
        URI id = URI.create("tasks/" + task.getId());
        Response resp = Response.created(id).build();
        return resp;
    }

@GET
    @Produces(MediaType.APPLICATION_JSON)
    @Path("{id}")
    public Response getTask(@PathParam("id") String id) {
        Optional<task> task = TaskCache.INST.getTask(id);
        Response resp = null;
        if (task.isPresent()) {
            resp = Response.ok(task.get()).build();
        } else {
            resp = Response.noContent().build();
        }
        return resp;
    }
    
    @PUT @Consumes(MediaType.APPLICATION_JSON)
    @Path("{id}")
    public Response update(Task task) {
        // Just replace the one there
        TaskCache.INST.putTask(task);
        return Response.ok().build();
    }
    
    @DELETE
    @Path("{id}")
    public Response delete(@PathParam("id") String id) {
        System.out.println("Deleting task: " + id);
        TaskCache.INST.removeTask(id);
        return Response.ok().build();
    }
}

The service will be available at [http://localhost:2001/task-web/api/tasks] (depending what you use as port and contextRoot)
Just to have some Tasks to start with since we have a simple cache in a HashMap, we create a startup bean to create some.

gf-runner

Embedded Payara

Trying to follow [http://www.payara.co.uk/using_payara_embedded_and_payara_micro_with_mav] I ran in to some issues. The dependency on that page does not really work, it end up with the following message:

There is a bug-report on this. But to get on, I will download the jar and do a "quickie" and add it as a system dependency and get on.

The code to get up and running with the war-file from task-web on an embedded Payara is just a few lines:

package se.ironic.gfrunner;

import java.io.File;
import org.glassfish.embeddable.BootstrapProperties;
import org.glassfish.embeddable.GlassFish;
import org.glassfish.embeddable.GlassFishException;
import org.glassfish.embeddable.GlassFishProperties;
import org.glassfish.embeddable.GlassFishRuntime;

public class EmbeddedGFRunner {

public static void main(String[] args) throws GlassFishException {
        if(args.length != 3) {
            System.out.println("Usage > EmbeddedGFRunner \"port\" \"deployable.war\" \"contextRoot\"");
            System.exit(1);
        }
        int port = Integer.parseInt(args[0]);
        BootstrapProperties bootstrap = new BootstrapProperties();
        GlassFishRuntime runtime = GlassFishRuntime.bootstrap();
        GlassFishProperties glassfishProperties = new GlassFishProperties();
        glassfishProperties.setPort("http-listener", port);
        GlassFish glassfish = runtime.newGlassFish(glassfishProperties);
        glassfish.start();
        glassfish.getDeployer().deploy(new File(args[1]), "--contextroot", args[2]);
    }
}

pack-dist

As I am a bit lazy and want to avoid copy jars manually I created a pom-project just to copy dependencies. The needed jar file will end up in the root folders under ./dist/, I also added a bat file to start the embedded Payara with the following content:

I also tried the jersey-client from the previous post with s slight modification for the context-path and it still works. (or you can start the payara with "/" as context path)

In next part I will add a JSF client on top of this service to show some nice stuff in Java EE 7 and JSF 2.2.

[The full project can be found at: https://bitbucket.org/pejomstd/embedded-gf-payara]

Saturday, May 2, 2015

REST with Jersey and Jetty part 3

Adding JSON support.

The first two parts in this small series of posts were about setting up the server and be able to run it with Jersey. [REST with Jersey and Jetty part 1, REST with Jersey and Jetty part 2].

This time there will be a bit more work. And I will take it step by step.

The service we will implement will handle tasks. To start with, there will only be one task list where all tasks will go.

The api will be the following.
Task class:

package model;

import java.util.Date;
import java.util.UUID;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Task {
    private String id;
    private String title;
    private String description;
    private Date dueDate;

public Task() {
    }
    
    public static Task of(String title, String description, Date dueDate) {
        UUID randomUUID = UUID.randomUUID();
        return new Task(randomUUID.toString(), title, description, dueDate);
    }

private Task(String id, String title, String description, Date dueDate) {
        this.id = id;
        this.title = title;
        this.description = description;
        this.dueDate = dueDate;
    }

// getters/setters

@Override
    public String toString() {
        return "Task{" + "id=" + id + ", title=" + title + ", description=" + description + ", dueDate=" + dueDate + '}';
    }
    
    
    
}

To start with we add support for getting the list, there will be some hardcoding until we have the working JSON support, since the first thing we want is a working Jersey with JSON support, not to complicate things further. When we have that, we can start adding functionality. But in the end, we will try to support:

list all
show a single task
create a task
update a task
remove a task
show range of tasks
get task count

But starting with some hardcoded stuff, to get the server running with JSON, this will be the stating point for the TaskResource

If you start the server and try to surf to this [http://localhost:2001/api/tasks] will yield the following in the log.

so we need to add some stuff to have JSON support.

Well, just a shor Googling, and it was pretty easy to add. [http://stackoverflow.com/questions/25474223/jersey-rest-messagebodywriter-not-found-for-media-type-application-jso] gives a hint. Just added moxy and it works to get JSON with the @GET.

So lets go for some real coding. We will add a simple cache, To avoid having a database for this simple example it will only contain a map with the tasks.

Lets start with some simple support of the cache:

Lets first add a method to create a task and one for getting a specific task.

To test this, we will need to also add a method to get a single task and a client to test it.

First, the client.

package app;

import java.net.URI;
import java.util.Date;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import model.Task;

public class JerseyClient {

public static void main(String[] args) {
        Client client = ClientBuilder.newClient();
        WebTarget postTarget = client.target("http://localhost:2001").path("api").path("tasks");
        Response postResponse = postTarget.request(MediaType.APPLICATION_JSON)
                .post(Entity.json(Task.of("Testclient", "Using test client to create", new Date())));
        
        System.out.println(postResponse.getStatus());
        URI location = postResponse.getLocation();
        
        System.out.println(location);
        
        WebTarget getTarget = client.target(location);
        Response getResponse = getTarget.request(MediaType.APPLICATION_JSON).get();
        
        System.out.println(getResponse.getStatus());
        System.out.println(getResponse.readEntity(Task.class));
    }
}

So far the client just adds a Task, gets the URI to the created Task and then gets it using the @GET for the methods added above.

Next step, fix the getAll().
The client cannot handle a List without wrapping it in a GenericType, but that is really all there is too it, we can still return List from the method.

The only thing we need to add now is update and delete. We will also add some code to test it in the client.

I also made some changes in the client:

public static void main(String[] args) {
    Client client = ClientBuilder.newClient();
    List<uri> locations = new ArrayList<>();
        
    WebTarget target = client.target("http://localhost:2001").path("api").path("tasks");
        
    Response postResponse = target.request(MediaType.APPLICATION_JSON)
            .post(Entity.json(Task.of("Testclient1", "Using test client to create", new Date())));
    locations.add(postResponse.getLocation());
        
    postResponse = target.request(MediaType.APPLICATION_JSON)
            .post(Entity.json(Task.of("Testclient2", "Using test client to create", new Date())));
    locations.add(postResponse.getLocation());
        
    postResponse = target.request(MediaType.APPLICATION_JSON)
            .post(Entity.json(Task.of("Testclient3", "Using test client to create", new Date())));
    locations.add(postResponse.getLocation());
        
        
    // Get first one
    WebTarget getTarget = client.target(locations.get(0));
    Response getResponse = getTarget.request(MediaType.APPLICATION_JSON).get();
    
    System.out.println(getResponse.getStatus());
    System.out.println(getResponse.readEntity(Task.class));
       
    // Change second one
    getTarget = client.target(locations.get(1));
    getResponse = getTarget.request(MediaType.APPLICATION_JSON).get();
    Task aTask = getResponse.readEntity(Task.class);
    aTask.setTitle("This title is changed");
    client.target(locations.get(1)).request(MediaType.APPLICATION_JSON).put(Entity.json(aTask));
        
    // Delete thirs one
    client.target(locations.get(2)).request().delete();
        
    WebTarget allTarget = client.target("http://localhost:2001").path("api").path("tasks");
        
    GenericType<List<task>> genericType = new GenericType<List<task>>() {};
        
    List<task> all = allTarget.request(MediaType.APPLICATION_JSON).get(genericType);
    for (Task task : all) {
        System.out.println(task);
    }
 }

Enjoy your Task microservice in REST using embedded Jetty with Jersey.

Read more about Jersey [https://jersey.java.net/documentation/latest/index.html]

Friday, May 1, 2015

REST with Jersey and Jetty part 2

Getting Jersey into play

In this part, we will introduce Jetty as serving with rest. We will att a class serving a @GET request.

We will need an extra dependency for Jersey to work, and after getting a strange error under startup I ended up changing the dependency on Jetty from the previous post [http://ironicprogrammer.blogspot.se/2015/04/rest-with-jersey-and-jetty-part-1.html]. I got the following error:

When adding the dependency for Jersey 2.17 after th Jetty dependency. Actually I got it to work by moving the Jetty dependency to after the Jersey dependency. But reading the log you can see that 2.17 if Jersey used Jetty 9.1.1 so, updating Jetty dependency to 9.1.1.v20140108, the order does not matter.
This is the dependencies for this part.

We will also create a new statup-class, It will not be much more code than the one in the previous part, but some extra stuff is needed to get Jersey into play.

package app;

import java.util.logging.Level;
import java.util.logging.Logger;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;

public class JerseyServer {
    public static void main(String[] args) {
        int port = 2001;
        if(args.length == 1) {
            port = Integer.parseInt(args[0]);
        }
        Server server = new Server(port);
        
        ServletHolder servletHolder = new ServletHolder(org.glassfish.jersey.servlet.ServletContainer.class);
        servletHolder.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        servletHolder.setInitParameter("jersey.config.server.provider.packages", "rest");//Set the package where the services reside
        servletHolder.setInitParameter("com.sun.jersey.api.json.POJOMappingFeature", "true");
        ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
        server.setHandler(contextHandler);
        contextHandler.addServlet(servletHolder, "/api/*");
        
        try {
            server.start();
            server.join();
        } catch (Exception ex) {
            Logger.getLogger(JerseyServer.class.getName()).log(Level.SEVERE, null, ex);
            System.exit(1);
        }
    }
}

The difference here is that we use a ServletHolder with some init parameters to set Jersey up. We also set the path to serve to "/api/*" instead of plain root "/".
That brings us to REST, we need something to show that it works. To do this we have a class under "rest" package called HelloResource.

So now the only thing you have to do is to start upp JerseyServer and surf into [http://localhost:2001/api/hello] and you should see the hello message. And there you have your first little Microservice ;)

In future post will explore how to use more than @GET and also how to add JSON support to this.

Thursday, April 30, 2015

REST with Jersey and Jetty part 1

Running Jersy standalone with a Servlet.

A few days ago I started to look into how to run a REST service with an embedded container. Now a friend of Springframework will say, that is easy with Spring, but after looking at a tutorial [http://spring.io/guides/tutorials/bookmarks/] I notice a couple of things. The annotations are not the standard JSR 331/339 ones, and there is a lot of other things from spring framework coming into play. Well, sorry Spring-guys, I don’t want that. I want to go with standard JSR annotations, and no specialities from Spring.

So my ide is to use Jersey which is the reference implementation och JSR 311/339 and run it on a server that can be embedded. What I want to do is to have the following support.

Ability to run with an embedded server (my choise: “jetty”)
Ability to serve REST calls (my choise: “Jersey”)
Ability to communicate wiht JSON.

After some research I noticed that it is not easy to find any good resource on how to run Jersey with an embedded server. the bes I could find was [http://jlunaquiroga.blogspot.se/2014/01/restful-web-services-with-jetty-and.html] , but I don’t like blogs saying “you only need to include the jars necessary or use maven” but leaving out the information of which the necessary jars are or the specific maven dependencies needed.. the documentation over Jersey is scarce in examples.

I will start this “journey” by building it up step by step. In this part, I will do only what is necessary to start an embedded server.

I used the above blog as a starting point. First step I will show is how to run a servlet in an embedded Jetty.

The first thing to do is to have a dependency to Netty.

The server will be started in a class with a main method,

There will also be a simple servlet to run in it.

Next post is about how to create a REST service based on Jersey and run it in Jetty.
(Update: changed the version of Jetty dependency, since I in next post use Jersey 2.17 and there was some issues running with Jetty 9.0.2)

Wednesday, November 13, 2013

Designing a “modular” web application

Background

I would like to separate functionality for a web application into separate jar-modules and include these in a war project.

The purpose for this is to separate development and deployment, that is, to develop functionality separately and include it in the war-packaging and it should automatically be usable with templates, menues etc.
Sorry if the code don't display so well. But putting codes with Generics is not so well handled by Bloggers editor, so until I have time to fix it you will have to live with it ;) and I will use [] instead of <>

Structure

To make it modular it is nescessary to have some common code (placed in “common-web”). The structure for this is basically:

common-web: will contain code common to modules and web-applications.

templates: for reuse in different modules, basic templates is put in a common module.
login: (out of scope, will not implement login in this example) for reuse of login-form etc. i.e. the same files and functionality applies to all web-applications that uses login.
resources: common css and images is placed to be reused.
menu: functionality to assemble n menu(es) from m modules so they will present in web-applications no matter in what module a page is used.
common code: code for hoding and generating menu(es), common utility code for JSF, ManagedBeans etc.

war: web-project with war-packaging that will use modules.
webmoduleA..X: functional parts that implement a function or group af functions that logically belong together.

as an example I will implement at “todo-webmodule” in a PoC to show the functionality.

Solution

Model

Description

I will describe the solution by taking my example project on bitbucket as an example.

The example project (on bitbucket) have the following structure:

In this example the only “working” code for a MenuGroup that I will implement is the TODO-functionality, and of course the supporting code to have it modular. As goes for the concept of menus I will add a couple of MenuGroups undermodule-web itself. (Do not be surprised if the code here differs from the one on bitbucket, because there may be improvements done in the real code.). There is also mockup code to add the menues as described above to get more than one menu.

To have a menu for “Todo”, the following code will give me that as a “MenuGroup”

To have it modular and generate modules, this is done by having the menu.xhtml and supporting classes in common-web. The most important are MenuBean (that assemble the menu for the view), MenuAssembler (that assembles a menu for MenuBean from the groups it is provided)

To get menu groups aswell as config of orderings and placement from other modules, a bit of CDI is used.

@Named
@ApplicationScoped
public class MenuBean extends BaseBean implements Serializable {

List<Menu> menus = Collections.emptyList();

@Inject
    @Any
    private Instance<MenuGroup> mnuGrpInst;

@Inject @Any
    private Instance<WebMenuConfig> menuConfInst;
    
    
    public List<Menu> getMenus() {
        if (menus.isEmpty()) {
            assembleMenus();
        }
        return menus;
    }

private void assembleMenus() {

MenuAssembler ma = new MenuAssembler();
        for (MenuGroup menuGrp : mnuGrpInst) {
            ma.addGroup(menuGrp);
        }

for (Iterator<WebMenuConfig> it = menuConfInst.iterator(); it.hasNext();) {
            WebMenuConfig webMenuConfig = it.next();
            for (Map.Entry<String,String> entry : webMenuConfig.getOrderings().entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                ma.addOrdering(key, value);
            }
            for (Map.Entry<String,String> entry : webMenuConfig.getPlacements().entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                ma.addPlacement(key, value);
            }
        }

menus = ma.assemble();
    }

}

Since we do not know which MenuGroups will exist when developing common code, we inject any type in an Instance. The view will call getMenus() tha if empty will try to assemble the menu. The placement and ordering should be provided from outside aswell, not hardcoded as in this case.

The order we do this is:

add MenuGroups

add rules

placement and/or ordering (defined in a WebMenuConfig implementation)

call assemble()

The last call will assemble the menu and return a list of the top menus. These menus will after returning be rendered in the view.

The implementation of the WebMenuConfig in this case is defined like this:

This will give a menu that looks like:

Code can be found at: https://bitbucket.org/pejomstd/modweb

Friday, March 26, 2010

Tutorials

I have started a Java tutorial for starting up with Java. It can be found at my Google-site. The tutorial is basic Java.

http://sites.google.com/site/ironicprogrammer/tutorials/ironic-programmer-java-tutorial

I will continuosly add more stuff to the site. Even if the first lessons may be a bit text to read. I will try to do programming by examples.

Friday, March 5, 2010

File upload in JSF2 using base class

Surfing the net for JSF2 resources can be a tedious task. Actually for file upload I actually found a couple of blogs describing how to do it the firs I found actually only (FileUpload with JSF 2 and Servlet 3.0) made a taglib based on the second one. And it includes maven which I do not use.

I had to remake the example a bit since I got question to provide a sample application. When extracting the code I noticed it did not work anymore. The reason is probably the one mentioned at this blog: http://mcatr.blogspot.com/2010/01/multipart-requests-and-jsf.html.To make it work again, I did a solution that I am not happy with but it works. It takes the idea from this blog, joined with some from the other blogs mentioned. The former blog states that a multipart request to JSF 2 do not work, because it can not extract parameters from that kind of request.

The problem is that for what I actually wanted it was not right and one was a little bit overkill. So as usual I took another approach. I got some helf from Uploading files with JSF 2.0 and Servlet 3.0 but that solution includes making a custom component and renderer, and is dependant on classes found in Uploading files in Servlet 3.0. I actually copied all the code and tried it...but I got a failure when loading the page. So I wanted something with less code. and simpler to use, and I have a case when I am going to store vCards in a database so a solution to save the file on disk means I have to modify code anyway.

I took the following approach:

Use standard html <input type="file" />
Use @ManagedBean
I first had a base class to handle the file and extended the Managed bean with this one, but since this stopped working I had to add:

A Wrapper to wrap multipart requests
A Filter to catch multipart request and transform them to the Wrapper type.

I also have a FacesUtil class to simplify getting request and parameters

Here is the code:

In the view (vCardForm.xhtml)

Class to represent the uploaded file (UploadFile.java)

I created a class to store some information about the file being upload, I can later choose if I want to store to disk or in a database, for example sending this to an EJB and the EJB descides what to do.

The managed bean (VCardBean.java)

The interesting thing going on here is that i initialize the base class with the request for use of the request. Probably I could have done this in the constructor of the baseclass, but something you have to have to refactor.

package theironicprogrammer.model;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.servlet.ServletOutputStream;
import theironicprogrammer.session.PersonUpdaterLocal;
import theironicprogrammer.http.MultiPart;

/**
 *
 * @author theironicprogrammer@gmail.com
 */
@ManagedBean(name="vcardBean")
@RequestScoped
public class VCardBean implements Serializable{
    @EJB PersonBean personBean;

public String uploadVCard(){
        System.out.println("uploadVCard...");
        HttpServletRequest req = FacesUtil.getRequest();
        if(req instanceof MultipartRequestWrapper){
            MultipartRequestWrapper multi = (MultipartRequestWrapper)req;

UploadFile uf = multi.findFile("vcardFile");
            if(uf != null){
                String fileExt = uf.getFileName().substring(uf.getFileName().lastIndexOf("."));
                System.out.println("Extension" + fileExt);
                // should actually check the extension, but no big deal for example
                personBean.saveVCard(uf, "testuser");

FacesUtil.getFlash().put("messageCode", "vcard.upload.ok");
                FacesUtil.getFlash().put("fileName", uf.getFileName());
            }

}
        return "vCardForm";
    }

public String findVCard(){
        UploadFile uf = personBean.findVCard("testuser");
        if(uf == null) {
            FacesUtil.getFlash().put("messageCode", "vcard.upload.err.load");
            FacesUtil.getFlash().put("messageType", "errors");

} else {
            ServletOutputStream output = null;
            try {
                output = FacesUtil.getResponse().getOutputStream();
                FacesUtil.getResponse().setHeader("Content-disposition", "attachment; filename=" + uf.getFileName());
                FacesUtil.getResponse().setContentType(uf.getContentType());
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                baos.write(uf.getFileData());
                FacesUtil.getResponse().setCharacterEncoding("UTF-8");
                FacesUtil.getResponse().setContentLength(baos.size());
                baos.writeTo(output);
                output.flush();
            } catch (IOException ex) {
                FacesUtil.getFlash().put("messageCode", "vcard.upload.err.load");
                FacesUtil.getFlash().put("messageType", "errors");
                Logger.getLogger(VCardBean.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                try {
                    output.close();
                } catch (IOException ex) {
                    FacesUtil.getFlash().put("messageCode", "vcard.upload.err.load");
                    FacesUtil.getFlash().put("messageType", "errors");
                    Logger.getLogger(VCardBean.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        return "vCardForm";
    }

public String removeVCard(){
        personBean.removeVCard("testuser");
        FacesUtil.getFlash().put("messageCode", "vcard.remove.ok");
        FacesUtil.getFlash().put("messageType", "messages");
        return "vCardForm";
    }

}

MultipartRequestWrapper

package ironicprogrammer.http;

import ironicprogrammer.model.UploadFile;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.Part;

/**
 *
 * @author theironicprogrammer@gmail.com
 */
public class MultipartRequestWrapper extends HttpServletRequestWrapper {
    private static final String CONTENT_DISPOSITION = "content-disposition";
    private static final String CONTENT_DISPOSITION_FILENAME = "filename";

private Hashtable<String, String> params = new Hashtable<String, String>();

public MultipartRequestWrapper(HttpServletRequest request) {
        super(request);
        System.out.println("Created multipart wrapper....");
        try {
            System.out.println("Looping parts");            
            for (Part p : request.getParts()) {
                System.out.println(String.format("Part name: %1$s, contentType : %2$s", p.getName(), p.getContentType()));
                for(String header : p.getHeaderNames()){
                    System.out.println("Header name : " + header + ", value : " + p.getHeader(header));
                }
                byte[] b = new byte[(int) p.getSize()];
                p.getInputStream().read(b);
                params.put(p.getName(), new String[]{new String(b)});
            }
        } catch (IOException ex) {
            Logger.getLogger(MultipartRequestWrapper.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ServletException ex) {
            Logger.getLogger(MultipartRequestWrapper.class.getName()).log(Level.SEVERE, null, ex);
        }

}

public UploadFile findFile(String attrName){
        UploadFile uf = null;
        try {

Part p = findPart(attrName);
            if(p != null){
                String fileName = getFilename(p);
                System.out.println("Filename : " + fileName + ", contentType " + p.getContentType());
                byte[] b = new byte[(int) p.getSize()];
                p.getInputStream().read(b);
                params.put(p.getName(), new String[]{new String(b)});
                uf = new UploadFile(fileName, p.getContentType(), b);
            }

} catch (IOException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        }
        return uf;
    }

private Part findPart(String name){
        HttpServletRequest request = (HttpServletRequest)getRequest();
        Part p = null;
        try {
            for (Part part : request.getParts()) {
                if(part.getName().equals(name)){
                    p = part;
                    break;
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ServletException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        }

return p;
    }

private String getFilename(Part part) {
        for (String cd : part.getHeader(CONTENT_DISPOSITION).split(";")) {
            if (cd.trim().startsWith(CONTENT_DISPOSITION_FILENAME)) {
                return cd.substring(cd.indexOf('=') + 1).trim().replace("\"", "");
            }
        }
        return null;
    }

@Override
    public String getParameter(String name) {
      String [] values = getParameterValues(name);
      if(values == null || values.length == 0) {
        return null;
      }

return values[0];
    }

@Override
    public Map<String, String> getParameterMap() {
      return params;
    }

@Override
    public Enumeration<String> getParameterNames() {
      return params.keys();
    }

@Override
    public String[] getParameterValues(String name) {
      return params.get(name);
    }

}

MultipartRequestFilter

package ironicprogrammer.http;

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

/**
 *
 * @author theironicprogrammer@gmail.com
 */
@WebFilter(urlPatterns="/*")
public class MultipartRequestFilter implements  Filter{
    private static final String REQUEST_METHOD_POST = "POST";
    private static final String CONTENT_TYPE_MULTIPART = "multipart/";

public void init(FilterConfig filterConfig) throws ServletException {
        
    }

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        if(isMultipartRequest(httpRequest)){
            System.out.println("Is multipart request.... wrapping it.");
            request = new MultipartRequestWrapper(httpRequest);
        }
        chain.doFilter(request, response);
    }

public void destroy() {
        
    }

public static final boolean isMultipartRequest(HttpServletRequest request) {
        return REQUEST_METHOD_POST.equalsIgnoreCase(request.getMethod())
            && request.getContentType() != null
            && request.getContentType().toLowerCase().startsWith(CONTENT_TYPE_MULTIPART);
    }

}

Session bean for handling the storage.

For the example this only stores it in the session.

package ironicprogrammer.session;

import ironicprogrammer.model.UploadFile;
import ironicprogrammer.utils.FacesUtil;
import java.util.HashMap;
import java.util.Map;
import javax.ejb.Stateless;

/**
 *
* @author theironicprogrammer@gmail.com
 */
@Stateless
public class PersonBean {

/**
     * Saves a vcard for the person with supplied username
     */
    public void saveVCard(UploadFile file, String username){
        // Make use of session for example. No need to complicate with connection to filesystem or database
        System.out.println("Saving vcard for " + username);
        getVcards().put(username, file);
    }

public UploadFile findVCard(String username){
        System.out.println("Getting vcard for" + username);
        return getVcards().get(username);
    }

public void removeVCard(String username){
        System.out.println("Removing vcard for" + username);
        getVcards().remove(username);
    }

private Map<String, UploadFile> getVcards(){
        Map<String, UploadFile> vcards = (Map<String, UploadFile>)FacesUtil.getRequest().getSession().getAttribute("vcards");
        if(vcards == null){
            vcards = new HashMap<String, UploadFile>();
            FacesUtil.getRequest().getSession().setAttribute("vcards", vcards);
        }
        return vcards;
    }
 
}

Finally the class to inherit to make it all work

This is now obsolete, but I keep it in case JSF will handle the mutlipart form in the future. But even then it may not be needed.

package theironicprogrammer.http;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Part;
import theironicprogrammer.model.UploadFile;

/**
 *
 * @author theironicprogrammer@gmail.com
 */
public class MultiPart {
    private static final String CONTENT_DISPOSITION = "content-disposition";
    private static final String CONTENT_DISPOSITION_FILENAME = "filename";
   
    private HttpServletRequest request;
    
    protected MultiPart(){
        
    }

public UploadFile findFile(String attrName){
        UploadFile uf = null;
        try {
            
            Part p = findPart(attrName);
            if(p != null){
                String fileName = getFilename(p);
                System.out.println("Filename : " + fileName + ", contentType " + p.getContentType());
                byte[] b = new byte[(int) p.getSize()];
                p.getInputStream().read(b);
                uf = new UploadFile(fileName, p.getContentType(), b);
            }
            
        } catch (IOException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        }
        return uf;
    }

public HttpServletRequest getRequest() {
        return request;
    }

public void setRequest(HttpServletRequest request) {
        this.request = request;
    }

private Part findPart(String name){
        Part p = null;
        try {
            for (Part part : request.getParts()) {
                if(part.getName().equals(name)){
                    p = part;
                    break;
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ServletException ex) {
            Logger.getLogger(MultiPart.class.getName()).log(Level.SEVERE, null, ex);
        }

return p;
    }

The only thing needed in the Managed bean is to call findFile("vcardFile") on the multipart request to get the file that is being uploaded and take action on that.

A sample project (for netbeans) can be found here: http://sites.google.com/site/ironicprogrammer/home/jsf-file-upload-example

Sunday, January 10, 2010

Netbeans tutorial "Generating a JavaServer Faces 2.0 CRUD Application from a Database"

I went through this tutorial today. Nice example, but there was something I did not like. As a geek I sit on a sunday and try out a tutorial on my home computer. Lazy as I am I do not want to start my MySql instance, since adding more running components tend to slow down my almost four year old Toshiba laptop.

Since I was going to run Glassfish v3 anyway I was thinking a better idea is to have the database in the form of JavaDB, so I tweaked the script to fit into Derby instead, not much tweaking to do actually and doing it made me happy to not be forced to start MySql (My mysql is by the way a bit old and installed the same time as I installed InstantRails long time ago, and probably needs to be updated). The insert script in the tutorial work more or less as it is in JavaDB just remove the 3 SET-clauses in the top and the COMMIT in the end and it should work.

The script can be found at my google-site http://sites.google.com/site/ironicprogrammer/home/jsf-2-0-tutorial-db-script

Wednesday, October 7, 2009

Making SSL calls with Grails

All of a sudden I realised that I have to call a service I have behind a SSL connection.

Using grails, this is easy to set up. Just create a couple of Groovy-classes and use it from the controller. It may be nescessary though to add the certificat of the SSL site to your JVM.

Adding the certificate

download the certificate you need, name it to something usefull, for example theSite.cer.
use keytool to add it. (needs JAVA_HOME/bin in the path)

keytool -import -keystore /pathToJava/jre/lib/security/cacerts -file theSite.cer  

Class to make the call
this is the class to actually do the work, calling the SSL url you want to reach.

import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.SSLSocket
import java.security.*;

/**
 * @author theironicprogrammer@gmail.com
 */
class SSLConnector {
    String theurl
    String user
    String password
    public SSLConnector(url, user, pwd){
        this.theurl = url
        this.user = user
        this.password = pwd
    }

public String responseString(){
        // Dynamic registration of JSSE provider
        java.security.Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());

// Need to be set
     System.setProperty("java.protocol.handler.pkgs","com.sun.net.ssl.internal.www.protocol");

// Install Authenticator
        Authenticator.setDefault (new SSLAuthenticator(this.user,this.password));

URL url = new URL(this.theurl);
        BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));

String line;

StringBuffer buff = new StringBuffer()
        while ((line = br.readLine()) != null){
            buff.append(line)
        }

br.close();

return buff.toString()
    }

}

Class for password authentication
this class is needed to authenticate you at the remote site.

In the controller you can then use the class to get a responsestring from the remote server.

/Peter

Saturday, October 3, 2009

Grails and EJB

Read Jason Rudolphs article about grails and EJB a while ago. Grails + EJB Domain Models Step-by-Step. It is a nice article but not what I want.

However it seamed a little bit of inventing the wheel again to import the classes into Grails in the same package structure, and I also wanted some other things that EJB3 gave me.

I want the EJB level to handle application rules. In that way, I can reuse the EJBs from other places as well
I have information i two different schemas in Oracle and grails was not supporting more than one.
I like "hit and run" session beans to provide services. which means that I use interface in the sessionbeans to provide CRUD and listing methods.

So I started to elaborate with putting the EJB.jar file in Grails library folder to try it out. It worked out nice, the only thing I have to do is to put some lookup code and start using the session beans. I also get access to all model POJOs.

I like this approach because I can use grails rapid application development with the robustness of EJB3 without doing very much extra.

The downside is that as I am a little bit lazy and avoid writing too much code, is that I have to run it on the same glassfish and I have to copy the jar-file every time I change the interface. I also have to make a war of the grails application and run it on glassfish.

/Peter

Friday, September 4, 2009

GroovyWS or Java WS Client?

We had a project this winter/spring which I designed to use Webservices on a web connected to EJBs, the clients we build in Grails for fast development.

Well we started using GroovyWS because that gave us the opportunity to get up and running pretty quick.

First we had some problems with the time it took to generate the stubs everytime we called a web service, however, this was becaus we stupidly put the creation of the client stubs in the actions so it was done every time. This was easy to sol by making a Groovy singleton class and let it create the service stubs once.

Eventually I decided to move over to making JAX-WS clients in Java using Netbeans. The reasons for this was mostly to try to get better performance and the possibility to put on SSL on the Web Service layer. From information I found and the experience during the first month of the project, I realised some shortcommings with GroovyWS mainly:

there is no support for https calls using GroovyWS
for some reason I had to wrap lists into a class. GroovyWS only regarded the list as one object and took the first one and skipped the rest and making workarounds in the WS-layer to fix this is something I don't want
restarting Glassfish sometimes made problems with the grailsapps and made them crash, this I think is because some of the services tokk some time to start and when GroovyWS tried to make stubs they were not there and after that the wars refused to work.

However making a WSClient in Java from Netbeans is an easy task, even if Java 1.6_07 or later is required for JAX-WS it is not such a big deal to make an jar-file and put it into the grailsapps lib folder, after that it is easy to call the java-classes from the Groovy code.