PermGen error » maven

Obfuscating Javascript with Maven and Google Closure

admin — Mon, 18 Apr 2011 11:45:41 +0000

GitHub Repository – with Maven project example

At the time of writing I couldn’t find an easy way to automate Javascript obfuscation when building a Maven project. Using the Googles Closure compiler I decided to work on my own concept. This guide shows how you can incorporate the same process into your maven projects.

EDIT: wro4j is a plugin that makes use of the Closure compiler however it only allows for SIMPLE_CUSTOMIZATIONS level obfuscation.

EDIT: As per Alex’s comment below it seems you can customise the wro4j plugin

Firstly, you need to include the Exec-Maven. This plugin allows you to execute Java applications during your build process. Include this plugin in your maven pom.xml like so:

>
	>org.codehaus.mojo>
	>exec-maven-plugin>
	>1.1>
	>
  		>
    			>
      				>java>
    			>
  		>
	>
	>
		>uk.co.eggsylife.JavascriptObfuscator>
		>
			>${basedir}/src/main/webapp/scripts/raw.js> 
			>${basedir}/src/main/webapp/scripts/raw.min.js> 
		>
	>
>

Notice the configuration of the plugin. Firstly we are targeting the goal ‘java’. I shall discuss this later. Secondly, we define a main class. This is the Java application the plugin will run. Finally we have the arguments, these are the arguments that will be passed to the ‘public static void main(String[] args)’ method. In the example above we pass the input file and the location/name of the output file.

Now for the ‘JavascriptObfuscator’ class. This class communicates with the Closure Compiler API passing in the raw Javascript from the input file – asking for the obfuscated version from the API and then saving the output to the specified output file.

package uk.co.eggsylife;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
 
 
public class JavascriptObfuscator {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
 
		System.out.println("Obfuscating Javascript");
 
		if( args.length >= 2 ) {
 
			int argumentCount = args.length;
			String jsFile = args[0];
 
			String outputFile = args[1];
 
			String compilationLevel = "ADVANCED_OPTIMIZATIONS";
			if(argumentCount == 3 ) {
				compilationLevel  = args[2];
			}
 
 
			String outputFormat = "text";
			if(argumentCount == 4 ) {
				outputFormat  = args[3];
			}
 
			System.out.println("Processing ( " + jsFile + " )" );
			System.out.println("Compilation Level ( " + compilationLevel + " )");
			System.out.println("Output Format ( " + outputFormat + " )");
			System.out.println("Saving to ( " + outputFile + " )");
 
			StringBuffer contents = new StringBuffer();
			BufferedReader reader = null;
 
			try {
				File file = new File(jsFile);
	            		reader = new BufferedReader(new FileReader(file));
			    	String text = null;
 
			    	// Read the Javascript
			    	while ((text = reader.readLine()) != null) {
			        	contents.append(text).append(System.getProperty("line.separator"));
			    	}
 
				// Javascript Pre-Obfuscation
			    	String jsCode = contents.toString();
 
			    	ClosureCompiler compiler = new ClosureCompiler(outputFile, jsCode, compilationLevel, outputFormat);
			    	compiler.processCompilation();
 
			    	System.out.println("Obfuscation Finished");
 
			} 
			catch (Exception e) {
	            		e.printStackTrace();
	        	}
			finally {
				try {
	                		if (reader != null) {
	                			reader.close();
	                		}
	            		} 
				catch (IOException e) {
	                		e.printStackTrace();
	            		}
	        	}
 
		}
		else {
			System.err.println("No (not enough) arguments passed to Obfuscation - requires JS file and Output directory");
		}
	}
}

The class *must* have at least two arguments – the input and output file – however you can pass further arguments which allow you to customise the Closure compiler obfuscation.

args[0] = Input file (required)
args[1] = Output file (required)
args[2] = Compilation level (default ADVANCED_OPTIMIZATIONS)
args[3] = Output format (default test)

You can of course customise this class to make it perform as you like

Next notice the use of the ‘ClosureCompiler’ class, this class communicates with the Closure API

package uk.co.eggsylife;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
 
public class ClosureCompiler {
 
	private String outputFile = null;
	private String jsCode = null;
	private String compilationLevel = null;
	private String outputFormat = null;
 
	public ClosureCompiler(String outputFile, String jsCode, String compilationlevel, String outputFormat) {
		this.outputFile = outputFile;
		this.jsCode = jsCode;
		this.compilationLevel = compilationlevel;
		this.outputFormat = outputFormat;
	}
 
	public void processCompilation() {
		try {
			String obfuscatedCode = sendForCompilation();
			saveObfuscatedCodeToFile(outputFile, obfuscatedCode);
		} 
		catch (Exception e) {
			System.err.println("Exception when obfuscating code: " + e.getMessage());
		}
	}
 
	private String sendForCompilation() throws Exception {
		URL url = new URL("http://closure-compiler.appspot.com/compile");
 
		String data = URLEncoder.encode("js_code", "UTF-8") + "=" + URLEncoder.encode(jsCode, "UTF-8");
		data += "&" + URLEncoder.encode("compilation_level", "UTF-8") + "=" + URLEncoder.encode(compilationLevel, "UTF-8");
		data += "&" + URLEncoder.encode("output_format", "UTF-8") + "=" + URLEncoder.encode(outputFormat, "UTF-8");
		data += "&" + URLEncoder.encode("output_info", "UTF-8") + "=" + URLEncoder.encode("compiled_code", "UTF-8");
 
		URLConnection conn = url.openConnection();
		conn.setDoOutput(true);
		OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
		wr.write(data);
		wr.flush();
 
		// Get the response
		BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
		String codeLine;
 
		StringBuffer obfuscatedCodeLine = new StringBuffer();
		while ((codeLine = rd.readLine()) != null) {
			obfuscatedCodeLine.append(codeLine).append(System.getProperty("line.separator"));
		}
		wr.close();
		rd.close();
 
		return obfuscatedCodeLine.toString();
	}
 
	private void saveObfuscatedCodeToFile(String outputdirectory, String javascriptCode) throws Exception{
		FileWriter fstream = new FileWriter(outputdirectory);
		BufferedWriter out = new BufferedWriter(fstream);
		out.write(javascriptCode);
		//Close the output stream
		out.close();
	}
 
}

It fetches the obfuscated result and saves it to the specified output file

That just about completes the blog, the last thing is to show how your would invoke this. Thats a simple as:

mvn exec:java

You can of course customise the goal of the plugin so that it obfuscates as and when you need it to.

I would also welcome any comments or further customisations on this

Spring 3 RESTful Web Services

admin — Sun, 03 Jan 2010 10:00:31 +0000

Step One – Project Creation with Maven

This tutorial is slightly different to my previous examples. In recent development I have begun to use Maven to manage my project dependencies.

If you are comfortable with creating a Web application project and Maven please skip down to the example code.

First of all you will need to install the Maven 2 plugin for Eclipse.

After you have installed the plugin create a new ‘Dynamic Web Project’ in Eclipse. Call it ‘SpringRestfulExample’.

Click Next. On the next screen we need to edit the src folder and the output folder. First of all remove the current src folder and then click ‘Add Folder…’

On the Add folder dialog enter the value /src/main/java and click OK.

Then make sure the default output folder reads target/classes. Click next

On the change the Context directory to read /src/main/webapp. Continue on to create the project.

Next we need to introduce Maven. Assuming you have installed the Maven plugin correctly Right click the Project and you should see a Maven menu item.

Highlight Maven and click ‘Enable Dependency Management’.

The next screen will ask you a few Maven options leave everything as it is apart from Packaging – change this to war. Click Finish.

Now we need to ensure the project uses any Maven dependencies we setup. Right click the Project and choose Properties.

From the Properties menu click ‘Java EE Module Dependencies’. On the right hand pane you will see ‘Maven Dependencies’ simply add a tick in that box and click Apply

Step Two – Making the Web application work

Next we’re going to make sure the web application works OK before we introduce Spring and other requirements.

In your src/main/webapp folder create a file called index.jsp and add some sample content like below:

Spring RESTful Example

Your WebApplication is up and running....

(If you open your web.xml file you’ll see a list of welcome files we’re creating the index.jsp of that welcome file list)

I’ll assume you’re comfortable with setting up local servers in Eclipse. If you open up your Servers view in Eclipse and add your project to your server, then start you server. You should be able to visit http://localhost:8080/SpringRestfulExample/ and view the page you created.

Step Three – Introducing Spring

In the root of your project you’ll notice that there is a file called pom.xml – this manages all your Maven dependencies.

Open the file (choose the tab pom.xml in the editor if the file opens up in the Maven editor) and add the following content:

 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">
	>4.0.0>
	>SpringRestfulExample>
	>SpringRestfulExample>
	>war>
	>0.0.1-SNAPSHOT>
 
 	>
    	>3.0.0.RELEASE>
	>
 	>
 		>compile>
 		>target>
 		>src/main/java>
 		>target/classes>
 	>
 
	>
		>
			>org.springframework>
		  	>spring-core>
		  	>${org.springframework.version}>
		>
		>
	  		>org.springframework>
	  		>spring-expression>
	  		>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-beans>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-aop>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-context>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-context-support>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-web>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-webmvc>
  			>${org.springframework.version}>
		>
		>
  			>org.springframework>
  			>spring-oxm>
  			>${org.springframework.version}>
		>
		>
			>org.slf4j>
			>slf4j-log4j12>
			>1.4.2>
		>
		>
			>org.apache.tiles>
			>tiles-api>
			>2.1.2>
		>
		>
			>org.apache.tiles>
			>tiles-core>
			>2.1.2>
		>
		>
			>org.apache.tiles>
			>tiles-jsp>
			>2.1.2>
		>
		>
			>javax.servlet>
			>jstl>
			>1.1.2>
		>
		>
			>taglibs>
			>standard>
			>1.1.2>
		>
 
	>
 
>

This Maven configuration includes all the required elements for the Spring example we’re going to be working with. If you need to read up more on Maven and Spring please see the SpringSource recent blog post.

Step Four – Configuring Spring MVC

Although we’re going to make an application that serves up RESTful XML we need to integrate Spring Web MVC. First of all we’ll create some basic Pojo objects that we shall represent.

Right click the src/main/java folder and create a new package called ‘com.spring.datasource’

Within that package create a new class called ‘Student’. Add the following content:

package com.spring.datasource;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
public class Student {
	private int id = -1;
	private String name = null;
 
	public Student() {
 
	}
 
	public Student(int id, String name) {
		this.id = id;
		this.name = name;
	}
 
	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
}

In the same package create a class called ‘Classroom’ and add the following:

package com.spring.datasource;
 
import java.util.ArrayList;
 
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
@XmlRootElement(name = "class")
public class Classroom {
 
	private String classId = null;
	private ArrayList<Student> students = null;
 
	public Classroom() {
 
	}
 
	public Classroom(String id) {
		this.classId = id;
		students = new ArrayList<Student>();
		Student studentOne = new Student(1, "Student One");
		Student studentTwo = new Student(2, "Student Two");
		students.add(studentOne);
		students.add(studentTwo);
	}
 
	/**
	 * @return the classId
	 */
	public String getClassId() {
		return classId;
	}
 
	/**
	 * @param classId the classId to set
	 */
	public void setClassId(String classId) {
		this.classId = classId;
	}
 
	/**
	 * @return the students
	 */
	@XmlElement(name="student")
	public ArrayList<Student> getStudents() {
		return students;
	}
 
	/**
	 * @param students the students to set
	 */
	public void setStudents(ArrayList<Student> students) {
		this.students = students;
	}
}

A classroom is just a collection of students – in this example I have hard coded two students but you can imagine that this may be a datasource. Also note the further use of the @XmlElement annotations.

Now create a new package called ‘com.spring.controller’.

This will contain our Spring MVC controller. Within that package create a new class called ‘StudentsController’ and add the following:

package com.spring.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
 
import com.spring.datasource.Classroom;
 
/**
 * @author Eggsy - eggsy_at_eggsylife.co.uk
 *
 */
@Controller
public class StudentsController {
 
	public static final String STUDENTS_VIEW_KEY = "studentsView";
 
	@RequestMapping(method=RequestMethod.GET,value="/students")
	public ModelAndView showStudentsPage() {
		Classroom classOfStudents = new Classroom("Class One");
		ModelAndView mav = new ModelAndView(STUDENTS_VIEW_KEY);
		mav.addObject("classRoom", classOfStudents);
		return mav;
	}
}

I’ll assume you are comfortable with the Spring controller annotations. If not you can have a quick lookover my previous Spring blog posts. We use the same controlller for REST requests as well as normal HTML requests. Also as you can see we always return the same view. In essence the controller doesn’t do anything special or anything different from previous controllers you may have written.

It is within the servlet.xml file configuration that takes over handling the REST requests.

 id="studentsView" class="org.springframework.web.servlet.view.xml.MarshallingView">
	 ref="jaxbMarshaller" />
>
 

 id="jaxbMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
	 name="classesToBeBound">
		>
			>com.spring.datasource.Classroom>
			>com.spring.datasource.Student>
		>
	>
>

Notice name a bean studentsView which is a Spring Mashalling view. This matches the view our controller returns. We then make use of another great Spring feature called the ContentNegotiatingViewResolver this bean allows us to handle XML requests and HTML requests and it basically makes decision on which view resolver to use. The bean is declared like so:

 class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
	 name="mediaTypes">
	    >
	         key="xml" value="application/xml"/>
	         key="html" value="text/html"/>
	    >
	>
	 name="viewResolvers">
	    >
	         class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
	         class="org.springframework.web.servlet.view.UrlBasedViewResolver">
			 name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
		>
	    >
	>
>

The content resolver declares two media types that we can handle (You can add more such as JSON) and then for the two media types we declare two View resolvers. For XML requests we use the BeanNameViewResolver so in practice we use the studentsView bean discussed earlier. Then for normal HTML requests we use the standard UrlBasedViewResolver configured with Tiles2 defintions.

The complete file is as shown below:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">
 
 
	 base-package="com.spring.controller" />
	 class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
	 class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
 
	 id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
		 name="definitions">
			>
      				>/WEB-INF/tiles-defs/templates.xml>
    			>
		>
	>
 
	 id="studentsView" class="org.springframework.web.servlet.view.xml.MarshallingView">
		 ref="jaxbMarshaller" />
	>
 
	
	 id="jaxbMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
		 name="classesToBeBound">
			>
				>com.spring.datasource.Classroom>
				>com.spring.datasource.Student>
			>
		>
	>
 
	 class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        	 name="mediaTypes">
            		>
                		 key="xml" value="application/xml"/>
				 key="html" value="text/html"/>
            		>
		>
        	 name="viewResolvers">
            		>
		                 class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
                		 class="org.springframework.web.servlet.view.UrlBasedViewResolver">
					 name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
				>
            		>
       		>
    	>
>

To complete the application we should create the required JSP’s and Tiles configuration. Under the /src/main/webapp create a new folder called ‘pages’ and create a file named ‘students.jsp’ within it. Add the following content:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
Classroom of students
 

	${student.id} - ${student.name}

Finally we need to create the tiles defintion file the view. Create a new folder called ’tiles-defs’ in the WEB-INF folder and create a file called ‘templates.xml’ within it. (Notice this matches the location in our servlet.xml file

Add the following content to the templates.xml file:

 version="1.0" encoding="ISO-8859-1" ?>

       "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
 
>
 
	 name="studentsView" template="/pages/students.jsp">
	>
 
>

Step Five – Updating the web.xml

Finally we need to configure the web.xml to work with Spring Web MVC. Open your web.xml file (located in the webapp folder) and make sure it matches the following:

 version="1.0" encoding="UTF-8"?>
 id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" 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">
	>SpringRestfulExample>
 
 
	>
		>SpringRestfulExample>
		>org.springframework.web.servlet.DispatcherServlet>
		>1>
	>
 
	>
    		>SpringRestfulExample>
    		>/app/*>
	>
 
	>
		>index.jsp>
	>
>

That should just about be it. If you start your webserver and visit the page http://localhost:8080/SpringRestfulExample/app/students you should see the JSP page you created with the two students listed.

However if you perform a curl request (mocking an XML request) you should see the XML representation of the classroom:

curl -H 'Accept: application/xml' http://localhost:8080/SpringRestfulExample/app/students

Project download

I have made the project available for download on Google’s Project hosting. You can get hold of it at http://code.google.com/p/eggsy-spring3-restful-example/ or via SVN on the URL http://eggsy-spring3-restful-example.googlecode.com/svn/trunk/

Resources

Spring forum post and help from user Toxic: http://forum.springsource.org/showthread.php?t=82146

REST in Spring 3 – Spring source blog : http://blog.springsource.com/2009/03/08/rest-in-spring-3-mvc/

Eyal Lupu’s Java Blog : http://www.jroller.com/eyallupu/entry/content_negotiation_using_spring_mvc

SpringSource.org – RESTful Services : http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18s02.html