Dev @ Work » Java

Securing your Liferay Service using PermissionChecker

Bert Willems — Mon, 03 May 2010 06:42:08 +0000

Welcome to 3rd article in this series of articles showing you how you can develop custom Liferay services. In the previous article I showed you how you can implement a custom Liferay service and expose it as a web service. In this article I will show you how you can secure your service using Liferay’s build-in permission model.

The permission system in Liferay is pretty powerful: you configure permissions on roles or teams. Next you apply roles to either groups (communities, organizations) or individual users. In this article we will define a new permission: the permission to access our “very exiting business logic” sayHello. After all, we have invested countless hours in developing it; we don’t want everybody to use it without us knowing .

I hope this article is useful to you. Please let me know if you have any questions or comments; just drop me a message and I will get back to you as soon as I can.

0. Project Setup

I have made some modifications to the code since my last article, so please download and unzip the starting point of our application. Please familiarize yourself with the project structure. I have refactored the view of the SayHelloPortlet to render using a JSP called sayHello.jsp, this will help us further along in this article.

Please note that I have modified the service contract specified in HelloWorldService.java. I have added the groupId parameter which we will use later in this article. Here is the new service contract:

String sayHello(long groupId, String name);

I have updated all the service implementation files as well to reflect changes in the contract.

1. Implement the permission check on the service

The first step is to implement the actual check on permission in our service implementation. Replace the sayHello method in HelloWorldServiceImpl.java with the following code (note the marked lines are new lines):

public String sayHello(long groupId, String name) {
    try {
        if (!getPermissionChecker().hasPermission(groupId, "nl.devatwork.hello.world.service", groupId, "SAY_HELLO"))
            return "Hah, I don't think you can use my service. You don't have permission";
    } catch (PrincipalException ex) {
        return "security blew up";
    }

    return "Hello, " + name;
}

Lets dissect this code: The first thing we do is to get the instance of the PermissionChecker from our base class PrincipalBean. The PermissionChecker will do the heavy lifting for us, that is convenient isn’t it?

The second step is the call to the method hasPermission. This method performs the actual check for us. The method has the following signature:

public boolean hasPermission(long groupId, String name, long primKey, String actionId);

The first argument, groupId, determines the scope of the check. Remember I told you that you can apply roles to communities and organizations? Those things are groups with and ID. In the next step I will show you how we will get the value for groupId.

The second argument, name, is the name of our permission. The convention is we pass a String representation of our package in which the service lives.

The third argument, primKey, is the primary key of the resource we are protecting. Our service is a so-called top level resource which do not have a primary key that is why we will use the value of groupId. If we would have a model stored in the database we would specify the ID of the model here.

The final argument, actionId, is the identifier of the action. We will use a capitalized version of the method name here.

I think that is enough info about these few lines of code.

2. Getting the scope

Now that our service checks for permission we need to modify our portlet to provide the correct groupId in order for Liferay to scope the authorization properly. Please add the highlighted lines to SayHelloPortlet.java:

public void doView(RenderRequest request, RenderResponse response) throws PortletException, java.io.IOException {
    ThemeDisplay themeDisplay = (ThemeDisplay) request.getAttribute(WebKeys.THEME_DISPLAY);
    long groupId = themeDisplay.getScopeGroupId();

    String msg = HelloWorldServiceUtil.sayHello(groupId, "Liferay Dev");
    request.setAttribute("msg", msg);
    request.setAttribute("groupId", groupId);

    getPortletContext().getRequestDispatcher("/WEB-INF/jsp/sayHello.jsp").include(request, response);
}

As you can see Liferay provides a nice utility called ThemeDisplay from which we can get the scope groupId.

3. Telling Liferay about our new permission

So far we have implemented the necessary code to check for permission. Now we have to inform Liferay that there is a new permission, otherwise you won’t be able to configure it and that would be a waste of effort, wouldn’t it? Create a new file called portlet.properties in the resource folder of the portlet application and paste the following content into it:

resource.actions.configs=resource-actions/default.xml

This properties file tells Liferay to look for resource actions (permissions) in default.xml in the folder resource-actions. Lets create that file now and paste the following content into it:



    
        nl.devatwork.hello.world.service
        
            SayHelloPortlet
        

        
            SAY_HELLO

I have highlighted the important lines. Please take a look at the first highlighted line. Does it look familiar to you? Yes, it is the same as the value of the name argument of the hasPermission method.

The second highlighted line tells Liferay that the SayHelloPortlet can configure this permission, I will show you how in the next step.

The final highlighted line should also look familiar to you. It is the same as the value of the actionId argument of the hasPermission method.

4. Create configure permissions link

This is the final step, we implemented the check, we told Liferay about our new permission. Now we need a place to configure it. Modify sayHello.jsp:

<%@ page contentType="text/html" isELIgnored="false" %>
<%@ include file="/WEB-INF/jsp/include.jsp" %>


the msg was: ${msg}


    lets configure the permission for our service

We have added a link to configure permission to our service. Notice that modelResource is again the same as the value of the name argument of the hasPermission method.

Now that we have implemented all the necessary changes we can compile and deploy the new JAR’s and WAR’s and start our application. Go ahead and add permissions, remove them, login and logout under different accounts. Our permission is working like a charm. If you haven’t followed all the steps above you can download the finished project.

That is it for now,I hope you have learned something. Let me know if you have any questions or comments. Bye.

Tags: Java, Liferay, Security

Expose a Liferay Service as a Web Service

Bert Willems — Mon, 26 Apr 2010 06:39:50 +0000

In my previous article I showed you how you can implement a reusable Liferay Service without using Ext or the Service Builder utility. In this article we will take it one step further and expose the service we have created as web service again without using Ext or the Service Builder.

Liferay exposes the services based on Axis using a separate web application called tunnel-web. We will hook into tunnel-web so our service will be exposed in exactly the same way Liferay services are externalized. Let’s get started.

0. Project Setup

We will pick up from where we ended in the previous article. I have you haven’t followed the previous article you can download the initial project setup here. Please take a minute to familiarize yourself with the project structure.

We need to add a new dependencies to the pom of the service contract library:


    com.liferay.portal
    portal-service
    ${liferay.version}
    provided


    com.liferay.portal
    portal-kernel
    ${liferay.version}
    provided


    com.liferay.portal
    portal-impl
    ${liferay.version}
    provided

1. Prepare the portal

Make sure tunnel-web is installed in your application server. See the Liferay administration guide for details. The access to the web-service is restricted based on IP address. Open your portal-ext.properties and add the following lines to allow specified IP addresses to access to the web-services.

axis.servlet.hosts.allowed=127.0.0.1,SERVER_IP
axis.servlet.https.required=false

2. Add the Service Classes

Ok lets get down to business. The first step is to create the web service class in the service contract library. Create a new class called HelloWorldServiceSoap in the package nl.devatwork.hello.world.service.http and copy the following code into it:

package nl.devatwork.hello.world.service.http;

import com.liferay.portal.kernel.log.Log;
import com.liferay.portal.kernel.log.LogFactoryUtil;
import nl.devatwork.hello.world.service.HelloWorldServiceUtil;

import java.rmi.RemoteException;

public class HelloWorldServiceSoap {
    private static Log _log = LogFactoryUtil.getLog(HelloWorldServiceSoap.class);

    public static String sayHello(String name)
            throws RemoteException {
        String result;
        try {
            result = HelloWorldServiceUtil.sayHello(name);
        } catch (Exception e) {
            _log.error(e, e);

            throw new RemoteException(e.getMessage());
        }

        return result;
    }
}

This class wraps SOAP calls and maps them to the appropriate service call.

You can now build the service contract library by executing the following command in the /hello-world-service/ folder:

mvn clean package

Copy the resulting JAR file (/hello-world-service/target/hello-world-service-1.0.0-SNAPSHOT.jar) to the /lib/ext folder of your application server.

3. Apply Glue

The final step is a bit of handwork. We need to manually register the new service to the tunnel-web application. Open the server-config.wsdd located in the deploy directory/tunnel-web/WEB-INF folder of your application server. Add the following code just above the end of the XML:

This will register our service within tunnel-web.

Start your application server and navigate to http://127.0.0.1:8080/tunnel-web/axis. Here you will find a list of all the services currently exposed by Liferay. In the list you will find our service (Portlet_DevAtWork_HelloWorldService). You can view the WSDL by clicking on the link behind the service.

That wasn’t to bad now was it? If you are to lazy to copy the code you can download the complete project here.

I hope you learned how you can expose services as web services in Liferay. In the upcoming article I will show you how you can add security to the web service.

That is it for now. Let me know if you have any comments or questions.

Tags: Java, Liferay, Spring, Web Services

Implementing a reusable Liferay Service Without Ext or Service Builder

Bert Willems — Mon, 19 Apr 2010 10:38:01 +0000

In Liferay you can split your application logic vertically exposing each component as a separate independent service. This service can be consumed by your portlet applications and any other applications. Liferay itself exposes several services to you: GroupService (for managing communities) and UserService (for managing users) for example. In this article I will show you how you can create a reusable service yourself and host it in Liferay.

In this article we will build a simple hello world service, nothing to fancy (I want to leave something for you to do yourself ). We will code the service from scratch without using tools like service builder.

The project will contain 3 modules:

A library containing the service contract
A web application implementing the service contract
A web application consuming the service

I hope you like this article, please let me know if you have any questions or comments. Lets get started. I assume you have read my previous article about using Maven to build Liferay applications. If not please read it first.

0. Project Setup

Please download and unzip the empty project and load it into an IDE of choice or use the command shell if you want. The project contains empty files. Please familiarizes yourself with the project structure and notice the dependencies in the different pom.xml files. Nothing special going on though.

1. Service Contract

This library contains the code contract of our HelloWorld service and a utility class which will provide easy access for non Spring portlets. Lets first set up our service contract, copy he following code into HelloWorldService.java:

package nl.devatwork.hello.world.service;

public interface HelloWorldService {
    String sayHello(String name);
}

That wasn’t so bad now was it? I think you have written more complex service contracts .

Lets implement the access utility class. Copy the following code into HelloWorldServiceUtil.java:

package nl.devatwork.hello.world.service;

public class HelloWorldServiceUtil {
    private static HelloWorldService _service;

    public static HelloWorldService getService() {
        if (_service == null) {
            throw new RuntimeException("HelloWorldService is not set");
        }

        return _service;
    }

    public void setService(HelloWorldService service) {
        _service = service;
    }

    public static String sayHello(String name) {
        return getService().sayHello(name);
    }
}

Again a really simple class. It has a getter and a setter which will be used to inject our service instance into this utility class. The static sayHello method is a proxies the service method.

You can build the service contract library by executing the following command in the /hello-world-service/ folder:

mvn clean package

Copy the resulting JAR file (/hello-world-service/target/hello-world-service-1.0.0-SNAPSHOT.jar) to the /lib/ext folder of your application server. You have to do this in order to avoid class loader issues. We will use this library later.

2. Service Implementation

Now we will implement the service in a self contained web application. This application can be deployed using the auto deploy mechanism of your application server.

Lets implement the base class for our service implementation which implements the required plumbing. Copy the following code into HelloWorldServiceBaseImpl.java:

package nl.devatwork.hello.world.service.base;

import com.liferay.portal.SystemException;
import com.liferay.portal.kernel.annotation.BeanReference;
import com.liferay.portal.service.base.PrincipalBean;
import com.liferay.portal.util.PortalUtil;
import nl.devatwork.hello.world.service.HelloWorldService;

public abstract class HelloWorldServiceBaseImpl extends PrincipalBean implements HelloWorldService {
    @BeanReference(name = "nl.devatwork.hello.world.service.HelloWorldService.impl")
    protected HelloWorldService helloWorldService;

    public HelloWorldService getHelloWorldService() {
        return helloWorldService;
    }

    public void setHelloWorldService(HelloWorldService helloWorldService) {
        this.helloWorldService = helloWorldService;
    }

    protected void runSQL(String sql) throws SystemException {
        try {
            PortalUtil.runSQL(sql);
        } catch (Exception e) {
            throw new SystemException(e);
        }
    }
}

Now that we have the plumbing in place lets concentrate on our state of the art business logic. Copy the following code into HelloWorldServiceImpl.java:

package nl.devatwork.hello.world.service.impl;

import nl.devatwork.hello.world.service.base.HelloWorldServiceBaseImpl;

public class HelloWorldServiceImpl extends HelloWorldServiceBaseImpl {
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

Very exiting business logic isn’t it? .

Ok, now that we have our code in place lets apply some glue to make it all work. Copy the following content to service.properties:

##
## Properties Override
##

    #
    # Specify where to get the overridden properties. Updates should not be made
    # on this file but on the overridden version of this file.
    #
    include-and-override=service-ext.properties

##
## Build
##

    build.namespace=DevAtWork
    build.number=1
    build.date=1269952033689
    build.auto.upgrade=true

##
## Spring
##

    #
    # Input a list of comma delimited Spring configurations. These will be
    # loaded after the bean definitions specified in the
	# portalContextConfigLocation parameter in web.xml.
    #
    spring.configs=\
        WEB-INF/classes/META-INF/portlet-spring.xml

Notice the last two lines. This tells Liferay to load our Spring configuration.

Lets create our Spring configuration now. Copy the following code to portlet-spring.xml:

We register two beans into the Spring container. One for our service implementation instance and one for our service util.

Lets add the following code to web.xml:




    
        com.liferay.portal.kernel.spring.context.PortletContextLoaderListener

This will load the Spring configuration for us.

Add the following code to liferay-plugin-package.properties:

name=Hello World Service Implementation
module-group-id=nl.devatwork.service.impl
module-incremental-version=1
short-description=
change-log=
page-url=http://www.devatwork.nl
author=Dev @ Work
licenses=Free

portal-dependency-jars=hello-world-service-1.0.0-SNAPSHOT.jar

Notice that we declare a dependency on the library we deployed earlier. Liferay will load the library on our class path.

We are ready with the service implementation now. You can build the service implementation by executing the following command in the /hello-world-service-impl/ folder:

mvn clean package

Copy the resulting WAR file (/hello-world-service-impl/target/hello-world-service-impl-1.0.0-SNAPSHOT.war to the auto deploy folder of your application server. The service implementation will be installed now.

3. Consumer Implementation

Now that we have the service contract and implementation in place lets create a portlet which consumes the service.

Copy the following code into SayHelloPortlet.java:

package nl.devatwork.hello.world.portlets;

import nl.devatwork.hello.world.service.HelloWorldServiceUtil;

import javax.portlet.GenericPortlet;
import javax.portlet.PortletException;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;

public class SayHelloPortlet extends GenericPortlet {
    public void doView(RenderRequest request, RenderResponse response) throws PortletException, java.io.IOException {
        String msg = HelloWorldServiceUtil.sayHello("Liferay Dev");
        response.setContentType("text/html");
        response.getWriter().print(msg);
    }
}

Copy the following code to portlet.xml:




    
        SayHelloPortlet
        Say Hello Portlet
        nl.devatwork.hello.world.portlets.SayHelloPortlet
        0
        
            text/html
            view
        
        
            Say Hello Portlet
            Say Hello Portlet
            DevAtWork

Copy the following code to liferay-plugin-package.properties:

name=Hello World Portlets
module-group-id=nl.devatwork.portlets
module-incremental-version=1
short-description=
change-log=
page-url=http://www.devatwork.nl
author=Dev @ Work
licenses=Free

portal-dependency-jars=hello-world-service-1.0.0-SNAPSHOT.jar

Copy the following code to web.xml:

We are ready with the consumer implementation now. You can build the portlet by executing the following command in the /hello-world-portlets/ folder:

mvn clean package

Copy the resulting WAR file (/hello-world-portlets/target/hello-world-portlets-1.0.0-SNAPSHOT.war to the auto deploy folder of your application server. The portlet will be installed now. Add the new portlet to a page and if everything works well then it should display the message: ‘Hello, Liferay Dev’.

You can download the complete project here.

That is it for this article, I hope you enjoyed reading it and that you learned something. If you have any questions or comments please post a comment and I will get back to you as soon as I can. In the next article I will show you how you can expose the HelloWorld service as a web service so it can be consumed by external applications.

Tags: Java, Liferay, Spring

Setting up Maven for Liferay Development

Bert Willems — Sat, 17 Apr 2010 13:08:03 +0000

Welcome to the third article in these series about Liferay usage, maintenance and development. In this post I will show you how to set up your Liferay development enviroment using Apaches Maven2 build tool. We will develop a really simple JSR-168 portlet which can be deployed into Liferay. I assume you have read my previous articles and that you are using Liferay 5.2.3 on JBoss 5.1. I hope you like this post as much as the previous ones, if you have any feedback feel free to contact me or post a response.

The next version of Liferay, release date end Q1 begin Q2, will have complete support for maven including custom archetypes. Some of the steps described in this article will be obsolete then, but lets get started.

Installing Maven

The first step is to actually install Maven. You can find the download and installation instructions on the Maven website http://maven.apache.org/. Confirm that Maven is installed properly by executing the following command:

mvn --version

You should see the Maven version number.

Installing the Liferay dependencies into your local Maven repository

The next step is to install the Liferay portal-kernel and portal-service into your local repository. This manual step is required in order for Maven to resolve the Liferay portal dependencies. Navigate the ‘%JBOSS_HOME%/server/default/lib/ext’ folder where the JARs are located. Execute the following commands:

mvn install:install-file -Dfile="portal-kernel.jar" -DgroupId="com.liferay.portal" -DartifactId="portal-kernel" -Dversion="5.2.3-RELEASE" -Dpackaging=jar
mvn install:install-file -Dfile="portal-service.jar" -DgroupId="com.liferay.portal" -DartifactId="portal-service" -Dversion="5.2.3-RELEASE" -Dpackaging=jar

Now that you have installed the required dependencies let set up a quick Hello World portlet using Maven.

Setting up the Hello World Portlet

Now that we have all the required dependencies installed in our local Maven repository we can start building an application. Download the complete source here. Create the following folder structure:

/pom.xml
/src/main/java/nl/devatwork/HelloWorldPortlet.java
/src/main/webapp/WEB-INF/portlet.xml
/src/main/webapp/WEB-INF/web.xml

First let set up the POM so our dependencies can be loaded. Notice that I have set the Liferay dependencies as being provided. Add the following code to the pom.xml file you have just created:



    4.0.0
    devatwork
    1.0.0-SNAPSHOT
    maven-hello-world
    war
    Maven Hello World Portlet
    
        
        
            javax.portlet
            portlet-api
            2.0
            provided
        
        
        
            com.liferay.portal
            portal-service
            5.2.3-RELEASE
            provided
        
        
            com.liferay.portal
            portal-kernel
            5.2.3-RELEASE
            provided

The portlet will be a very simple portlet. It will print a string and the name of the current theme. Add the following code to the HelloWorldPortlet.java file:

package nl.devatwork;

import com.liferay.portal.kernel.util.WebKeys;
import com.liferay.portal.theme.ThemeDisplay;

import javax.portlet.GenericPortlet;
import javax.portlet.PortletException;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;

public class HelloWorldPortlet extends GenericPortlet {
    protected void doView(RenderRequest request, RenderResponse response) throws PortletException, java.io.IOException {
        ThemeDisplay themeDisplay = (ThemeDisplay) request.getAttribute(WebKeys.THEME_DISPLAY);
        response.setContentType("text/html");
        response.getWriter().print("Hello World, " + themeDisplay.getTheme().getName());
    }
}

The next step is to set up the web.xml file, just copy the following code into it:

The final step of this sample portlet is the portlet.xml, again really straight forward. Just copy in the following code:



    
        HelloWorldPortlet
        Maven Hello World Portlet
        nl.devatwork.HelloWorldPortlet
        0
        
            text/html
            view

Now that the application is finished you can package it by executing the following command in the root of your application:

mvn clean package

Deploy the WAR to your application server and test it. Download the complete source here.

Now you are able to build Liferay plug-ins using Maven. I hope you liked this article. Please let me know if you have any questions or comments. Bye for now!

Tags: Java, Liferay, Maven

Setting up Liferay with MySQL

Bert Willems — Sun, 24 Jan 2010 19:59:37 +0000

Welcome to the second article in a series of articles on Liferay. In this series I will show you various aspects of Liferay, Liferay installation, Liferay maintenance and Liferay development so lets get started. These articles assume that you have basic Java development skills.

In this post I will show you how to configure Liferay to use MySQL instead of Hypersonic. I assume you have followed all the steps in the previous post or that you are using a JNDI datasource. I also assume that you have installed MySQL on your system already. If not, please install it first. If the portal is still running stop it first before continuing with the next steps.

Installing the MySQL Connector

The first step is to install the MySQL Java connector so that JBoss and Liferay know how to connect to the database. You can download the connector from the official MySQL website.Copy the JAR file of the connector to the ‘%JBOSS_HOME%\server\default\lib\’ folder.

Create the Database

Use the MySQL command line to create a new database. In this post we will use ‘lportal’ as the name of the database. Use the following command to create the database:

create database lportal default character set utf8

Modify the configuration

Modify the ‘%JBOSS_HOME%\server\default\deploy\liferay-ds.xml’ file and set its content to:



	
		jdbc/LiferayPool
		jdbc:mysql://localhost/lportal?useUnicode=true&characterEncoding=UTF-8
		com.mysql.jdbc.Driver
		username
		password
		0

Make sure you set the proper username and password.

Now fire up the portal and it will create the database schema for you. It fills the database with minimal data. You can use test@liferay.com and test to log in. That is it!

Tags: Java, Liferay, MySQL

Setting up Liferay in JBoss 5.1

Bert Willems — Sun, 24 Jan 2010 11:18:46 +0000

Welcome to the first article in a series of articles on Liferay. In this series I will show you various aspects of Liferay, Liferay installation, Liferay maintenance and Liferay development so lets get started. These articles assume that you have basic Java development skills.

In this post I will show you how to install Liferay 5.2.3, the latest communitie edition, on your local machine in the JBoss 5.1 application server, I assume you have a Windows machine. If you are running a different OS you can take the same steps but some paths will change depending on your OS. There are quite a few steps that need to be taken in order to set up Liferay, I will go through each and every step in detail.

Install the Java Development Kit 1.5

If you have installed the JDK already you can skip this section. In order to develop you need the Java SDK. The SDK contains things like the compiler and the base libraries. You can download the latest vesion from the Sun Java website. You need to download and install the JDK 5.0 Update 22 version. Once you have installed the SDK verify that the JAVA_HOME enviroment variable is set. Go to the enviroment variables settings of your computer and check if an entry JAVA_HOME exists in the system variables group, if not add it the value should point to the root directory of th SDK installation folder, for example: ‘C:\java\jdk1.5.0_21′. Next ensure that the PATH system variable includes the value ‘%JAVA_HOME%\bin’, if not add it. Save the settings if you made a modification.

You can verify if the SDK is installed and configured properly by executing the following command in a command window:

java -version

Is should print something like:

java version "1.6.0_17"
Java(TM) SE Runtime Environment (build 1.6.0_17-b04)
Java HotSpot(TM) Client VM (build 14.3-b01, mixed mode, sharing)

Java is now properly installed.

Installing JBoss 5.1

Although Liferay can run in a host of application servers I chose the JBoss application server for these series. First step is to download JBoss application server 5.1GA from the JBoss website. Unzip the JBoss application server in a location of choice. I use ‘C:\java\jboss’, I call this path JBOSS_HOME directory. That is basically it.

You can start JBoss by double clicking on ‘%JBOSS_HOME%\bin\run.bat’. The JBoss console windows will popup and JBoss starts, it might take a few minutes before it is ready. When JBoss is completely started (look for this line [ServerImpl] JBoss (Microcontainer) [5.1.0.GA (build: SVNTag=JBoss_5_1_0_GA date=200905221053)] Started in 1m:12s:239ms) go to http://localhost:8080/, you will see the default website here.

Shutdown the JBoss server by pressing CTRL+C in the JBoss console window.

Configuring the Java Authentication and Authorization Service

Open the file ‘%JBOSS_HOME%\server\default\conf\login-config.xml’ in a text editor of choice. Comment out the policy named other (defined in lines 110 and 129). After that it should look like this:

This allows Liferay to add it’s own implementation.

Setting up a Datasource

In this post we will set up Liferay to work with Hypersonic, in a later post I will show you how to set up MySQL. Create a new file ‘%JBOSS_HOME%\server\default\deploy\liferay-ds.xml’ and set its content to:



   

      jdbc/LiferayPool
      jdbc:hsqldb:${jboss.server.data.dir}${/}hypersonic${/}localDB
      org.hsqldb.jdbcDriver
      sa
      
      0

Setting up a Mailsource

I assume you have a mail server running on your local machine, if not configure the proper URLs forPOP and SMTP. Create a new file ‘%JBOSS_HOME%\server\default\deploy\mail-service.xml’ and set its content to:



   
      mail/MailSession
      nobody
      password

Installing Liferay Dependencies

This is the last preperation before we can install Liferay. Liferay needs several dependencies in order to run correctly. You can download the dependencies from the Liferay website. Download them and unzip them in the ‘%JBOSS_HOME%\server\default\lib’.

Installing Liferay

Finally we can start installing Liferay. First delete all the files and folders of the JBoss root application, you can find them at ‘%JBOSS_HOME%\server\default\deploy\ROOT.war’. The directory must be left empty.

Download the Liferay portal WAR from the Liferay website. Unzip it in the ‘%JBOSS_HOME%\server\default\deploy\ROOT.war’ folder.

Delete jaxen.jar, jaxrpc.jar, stax.jar, xercesImpl.jar, xml-apis.jar from the ‘%JBOSS_HOME%\server\default\deploy\ROOT.war\WEB-INF\lib’ folder.

Create a new file ‘%JBOSS_HOME%\server\default\deploy\ROOT.war\WEB-INF\classes\portal-ext.properties’ and set its content to:

jdbc.default.jndi.name=jdbc/LiferayPool
mail.session.jndi.name=mail/MailSession

That is it, fire up JBoss and Liferay will be installed. Once JBoss and Liferay are started(look for this line: [ServerImpl] JBoss (Microcontainer) [5.1.0.GA (build: SVNTag=JBoss_5_1_0_GA date=200905221053)] Started in 2m:31s:673ms) go to http://localhost:8080/. You will see the Liferay portal now.

You can login using username ‘test@liferay.com’ and password ‘test’ (without the quotes ofcourse).

You have learned to setup Liferay with JBoss and Hypersonic. Take a moment to familiarize yourself with the Liferay portal: add some portlets, change layouts and themes. That is it for now! In the following posts I will show you how to change from Hypersonic to a different database engine and how to develop a Liferay portlet, layout and theme.

I hope you liked my article, if you have any question or feedback feel free to post a comment or contact me.

Tags: Hypersonic, Java, JBoss, Liferay

Liferay: Good, Bad or Ugly?

Bert Willems — Mon, 02 Nov 2009 21:08:53 +0000

Hello, I have been developing application for Liferay for about one month now and I thought it would be a nice idea to share my experience. This is no thorough review of the product, just my personal experience with Liferay.

For those who don’t know what Liferay is: it is a portal server based on Java technology. It allows you to create portal and community websites easily. It provides more than 60 out-of-the-box and ready-to-use application called ‘portlets’. Those ‘portlets’ range from simple editorial blocks to blog engine and a chat portlet. It contains a full blown content management system and some powerful collaboration tools. See http://www.liferay.com/web/guest/products/portal/features for a comprehensive list of features.

Anyway, I have been working with Liferay for about one month now, specifically for one project. I won’t elaborate on the project in details but it is a career portal with jobs, resumes and company presentations. I have developed a considerable part of the code myself and it has been an interesting experience because I never wrote one line of Java before: I have a c++/.NET background. Fortunately, I have a good, experienced Java team to back me up.

Okay, lets get back to the subject now. I will separate my experiences into three categories:

The good

In my opinion Liferay is a complete product, the out of the box portlets are useful and you can actually create a full portal just with those portlets: that is impressive.

I also like the fact that Liferay provides pre-packaged version of their portal software which you can download and run without any special configuration. You can get a Liferay portal up and running in 5 minutes.

The Liferay community is active. You can find a lot of information in the WIKI and on the forum. I also like the fact that Liferay provides seminars around the world, to me that is a sign of professionalism.

I also like the fact that Liferay offers custom JS and CSS includes per portlet, this allows me add style and JavaScript without having to code it into the portlet itself or in a Liferay theme.

The API is pretty powerful and usable, although it is hard to find out how it works (seen second point of The Bad).

The bad

What I think is really bad on Liferay is that there are still some major bugs open in version 5.2.3. Those bugs should have been fixed a long time ago IMHO. I am not sure if those bugs are fixed in the enterprise version of Liferay, so I am judging on that. For example LPS-114.

One other thing I think is bad on Liferay is the lack of API documentation. It is really hard to find how certain things are achieved or what methods do exactly. For example I have spend some hours finding out how I can retrieve a list of pages of the current community. I have searched the Liferay Wiki, the Liferay forums and used Google without success: I ended up reverse engineering Liferay itself. It is working beautifully now but it wasn’t a good experience figuring it out.

The Ugly

Even though Liferay is supposed to be fully compliant with JSR-168 and JSR-286, I can’t get the custom portlet mode to work properly. Although this seems to be an optional part of the JSR-286 I assume that a enterprise product like Liferay would support this feature. I had to apply a work around which resulted in ugly code.

Considering all above points, I can say I am fairly impressed by the Liferay portal. I would choose it again for portal project.

Please let me know if you agree or disagree with me, lets get into a debate regardin Liferay! It deserves it!

Tags: Java, Liferay

Building a JSF Portlet for Liferay

Trilobyte — Sun, 30 Aug 2009 18:23:48 +0000

In this article I will show you how to build a portlet for the Liferay Portal using JavaServer Faces (JSF). I am not going to explain in detail how to setup Liferay, there are a lot of articles on that subject. I assume you have Java, Tomcat, Liferay, Ant and the Portal plugin SDK up and running.

Setting up the build

The first step is to create the directory and file structure. I will use the pluginsdk to do it for us. Execute the following command in the command line in the directory ‘{pluginsdk}/portlets’:

create.bat sample-Jsf-Portlet "Sample Jsf Portlet"

The first parameter is the name of the portlet, also the name of the directory that will be created for this portlet. The second parameter is the title or display name for the portlet: you will be see the portlet in Liferay with this display name.

After executing the above statement the portlet is created as a plain JSP portlet in a new sub directory. Navigate to the created sub directory and build the portlet using the following command:

ant all

After the build and deploy have been completed fire up your application server and verify if the portlet is up and running.

Setting up JavaServer Faces

The next step is to configure the portlet to run using JSF instead of JSP.

Delete all the files in the ‘docroot/WEB-INF/src’ directory.

Next set up the appropiate libraries, copy the following JARs to ‘docroot/WEB-INF/lib’:

jsf-api.jar
jsf-impl.jar
jsf-portlet.jar

Next modify the ‘docroot/WEB-INF/web.xml’ to look exactly like this:

< ?xml version="1.0" encoding="UTF-8"?>


javax.faces.STATE_SAVING_METHOD
client


javax.faces.application.CONFIG_FILES
/WEB-INF/faces-config.xml


com.sun.faces.validateXml
false


com.liferay.util.bridges.jsf.sun.LiferayConfigureListener


FacesServlet
javax.faces.webapp.FacesServlet


FacesServlet
/faces/*



Page Sources
*.jsp
*.jspx
*.xhtml


nobody



nobody

Next modify the ‘docroot/WEB-INF/portlet.xml’, change the following lines:

com.sun.faces.portlet.FacesPortlet

com.sun.faces.portlet.INIT_VIEW
/view.jsp

Create a new file ‘docroot/WEB-INF/faces-config.xml’ and add the following content:

< ?xml version="1.0" encoding="UTF-8"?>
< !DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">

Add the following line to the build properties file ‘docroot/WEB-INF/liferay-plugin-package.properties’:

portal-dependency-jars=commons-beanutils.jar,commons-collections.jar,commons-digester.jar,jstl.jar,jstl-impl.jar

This will setup the portlet to run in the JSF context.

Modify the view

Open the ‘docroot\view.jsp’ and replace the content with:

< %@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
< %@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>


Hello World, from a JSF portlet

Compile, Deploy and Run

Compile and deploy the code using the above Ant command. The portlet is being deployed to the application server. Add the portlet to a page and view the result.

I hope this helped you to get build JSF based portlets. Download the source. Take care!

Tags: Java, Liferay

My First Java Steps

Bert Willems — Tue, 25 Aug 2009 19:06:20 +0000

Hello all, sorry for the radio silence lately, you might wonder what I have been doing lately. Well I have committed a terrible sin against the .NET framework (my previous home ): I started learning Java.

Why Java? Because several clients of Liones demand that their applications must be build on the Java platform and I am deeply involved in the process. I am not going to bother you with the organizational side of the process, I will focus on sharing my experience.

Learning Java isn’t really the objective for me, it is just another programming language and C# is similar enough to not cause any problems for me to program in Java. The real objective is to be able to develop applications (called portlets) for the Liferay portal framework. The hidden challenge, for me, turned out to be setting up the environment.

I got everything up and running today: Java, Ant, Tomcat, Liferay and I developed my first custom portlet (an application for Liferay) using above technologies and Java Server Faces. I will post an article on how I did it soon!

Tags: Java, Liferay, Liones