Liferay: Custom 404 Page for plugins

Liferay portal runs and is configured as ROOT application with in tomcat sever.
By default, if tried to request a plugin in Liferay (say we have a theme plugin named as "error-theme"), a 404 Error is raised and the user is served Tomcat's default 404 error page as below:

To make your 404 page a bit more presentable, provide the user with a link back into your site, as well as hide the Tomcat version in use, you can easily add a custom 404 error page.

Step 1:

Create a jsp name it 404.jsp, with below content:

The requested resource is not available. Please provide the correct URL or try again later.
<br/>
<a href="#" onclick="javascript:history.go(-1);">Go back to main site.</a>

Step 2:

Now create a new directory as error-theme/docroot/errors in Lifeay IDE and copy the above created 404.jsp to it.

Step 3:

Last step is to add the below code to the web deployment descriptor (web.xml) of the plugin:

         <error-page>
  <error-code>404</error-code>
  <location>/errors/404.jsp</location>
 </error-page>

Now, when someone goes to the plugin link that does not exist, they get the custom 404 page we created.

JQuery : Declare a function

Method 1: The Javascript way

The simple way to declare a  function in javascript:

function callMe (count) {
     return (count+5);
}

console.log(callMe(13));
//output: 18

Disadvantage: If you wanted a quick function to test something then maybe that’s the only occasion you would use this. It’s not good coding and doesn’t promote code reuse.

Method 2: Creating your JQuery function

The simple way to declare a  function in javascript:

<div id="mydiv">i am here</div>

jQuery.fn.extend({
    mytext: function () {
        var text = $(this).text();
        var mytexts = '';
        var toggle = true; //lower/uppper toggle
            $.each(text, function(i, nome) {
                mytexts += (toggle) ? nome.toUpperCase() : nome.toLowerCase();
                toggle = (toggle) ? false : true;
            });
    return mytexts;
    }
});

console.log($('#mydiv').zigzag());
//output: #1 i aM HeRe

//chained example
console.log($('#mydiv').zigzag().toLowerCase());
//output: #1 i am here

Method 1: Functions in custom namespaces

If your writing functions in a custom namespace you must declare them in this way. Extra functions can be added to the namespace you just need to add a comma after each one (except the last one!).

JQUERY4U = {
    callme: function(count) {
        return (count + 5);
    }
}
//function call
JQUERY4U.callme(13);

Reference post: Full credit goes to the original post, which made the topic so easy to understand (visit for more details).

Liferay 6: Monitoring tomcat.

The Liferay tomcat bundle is available for download on http://www.liferay.com/downloads/liferay-portal/available-releases and instant use. It ships pre-configured with hypersonic database and you can switch to mysql, oracle, etc for permanent solutions.

When moving your site or solution to production server there is always uncertainty on how much the load will be coming at peak time, how many request the tomcat will be able to server with Liferay. Although the Apache tomcat comes with tomcat-manager application that allows you to monitor all the resources via JMX beans. but since this have been removed in Liferay-tomcat bundle thus it is hard to monitor the resources and threads the tomcat server is consuming. Thus to over come this shortcoming, below are the steps to enable the monitoring in the tomcat:

Server Details
Liferay: 6.1.2 GA2 Enterprise
Tomcat Bundle: 7.0.27
Java 6

Step 1:
Stop the running Liferay tomcat server and clean the temp and work folder.

Step 2:
Download the vanilla apache tomcat server of the same version and unzip it at some temporary location.

Step 3:
Copy host-manager and manager application <tomcat>/webapps directory to liferay installation at <liferay-tomcat-bundle>/tomcat-7.0.27/webapps

Step 4:
Create a manager.xml file at location <liferay-tomcat-bundle>/tomcat-7.0.27/conf/Catalina/localhost.
And the following content to it and save it

<Context antiResourceLocking="false" privileged="true" useHttpOnly="true">
 
 </Context>

Step 5:
Now open file <liferay-tomcat-bundle>/tomcat-7.0.27/conf/tomcat-users.xml in edit mode. And the below content inside the tag <tomcat-users>.

<tomcat-users>
...

  <role rolename="tomcat"/>
  <role rolename="manager-gui"/>
  <role rolename="standard"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="manager,admin,standard,manager-gui,tomcat"/>

...
</tomcat-users>

Step 6:

Now restart the tomcat server and go to the URL: http://localhost:8080/manager/html and you will be prompted for username and password which should be the same as defined above.

And now you can monitor the tomcat resources and can tune them accordingly.

Java Reflection API: Calling methods

Moving forward from my previous article: Java Reflection API: Constructing Objects

Using Java Reflection you can inspect the methods of classes and invoke them at runtime. This is done via the Java class java.lang.reflect.Method. Below are the details to achieve the same:

Obtaining Methods
You can obtain the methods from the Class object:

Method[] methods = mClass.getMethods();

The Method[] array will have one Method instance for each public method declared in the class.

If you know the precise parameter types of the method you want to access, you can do so rather than obtain the array of all methods. This example returns the public method named "mMethod", in the given class which takes a String as parameter:

Method method = mClass.getMethod("mMethod", new Class[]{String.class});

If the method trying to access takes no parameters, pass null as the parameter type array:

Method method = mClass.getMethod("mMethod", null);

Parameters and Return types
To access details about method parameters and return types, do the below:

Class[] parameterTypes = method.getParameterTypes();

Class returnType = method.getReturnType();

Calling methods

The null parameter is the object you want to invoke the method on. If the method is static you supply null instead of an object instance. In this example, if mMethod(String.class) is not static, you need to supply a valid mObject instance instead of null;

The Method.invoke(Object target, Object ... parameters) method takes an optional amount of parameters, but you must supply exactly one parameter per argument in the method you are invoking. In this case it was a method taking a String, so one String must be supplied.

Method method = mClass.getMethod("mMethod", String.class);
Object returnValue = method.invoke(null, "value-1");

Java Reflection API: Constructing Objects

Moving forward from my previous article: Java Reflection API: Introduction

Using Java Reflection API, you can instantiate objects at runtime and invoke class constructors.

Getting Constructor

To get the list of all public constructors declared use the below code:

Constructor[]
constructors = mClass.getConstructors();

Here Constructor[] is an array of type java.lang.reflect.Constructor. However If you have the precise parameter types of the constructor you want to access, you can do so rather than obtain the array all constructors. Below example returns the public constructor of the given class which takes String as parameter:

Constructor constructor
= mClass.getConstructor(new Class[]{String.class});

Further to read all the input parameters of a constructor, do like this:

Class[] parameterTypes =
constructor.getParameterTypes();

Do the below to create an object using Java Reflection:

Constructor constructor = mClass.getConstructor(String.class);
Object mObject = constructor.newInstance("argument-1");

Next post in the series is Java Reflection API: Calling Methods