https://www.digitalocean.com/community/articles/how-to-install-apache-tomcat-on-ubuntu-12-04

https://www.digitalocean.com/community/articles/how-to-install-apache-tomcat-on-ubuntu-12-04

https://www.digitalocean.com/community/articles/how-to-install-apache-tomcat-on-ubuntu-12-04

https://www.digitalocean.com/community/articles/how-to-install-apache-tomcat-on-ubuntu-12-04

configuring pache tomcat and eclipse in ubuntu

Download Eclipse;

use the Eclipse Update Manager to install all packages from the category Web, XML, Java EE Development and OSGi Enterprise Development, except “PHP Development” and the “RAP” Tooling;

while you wait for the installation of the packages you can install tomcat7 by running from terminal:

sudo apt-get install tomcat7 tomcat7-docs tomcat7-examples tomcat7-admin -y

configure WTP to use Tomcat:

1. select Windows -> Preferences -> Server -> Runtime Environments;
2. press Add…;
3. select “Apache Tomcat v7.0″;
4. enter “/usr/share/tomcat7″ into the “Tomcat installation directory” field;
5. press Ok;

create a new “Dynamic Web Project”

• as Target Runtime select “Apache Tomcat v7.0″;
• press twice Next;
• select the “Generate the web.xml deployment descriptor” option at the final dialog;
• press Finish;

close Eclipse;

to fix the error “Cannot create a server using the selected type” run the following:

cd ~/workspace/.metadata/.plugins/org.eclipse.core.runtime/.settings/
rm org.eclipse.jst.server.tomcat.core.prefs
rm org.eclipse.wst.server.core.prefs

to fix the error “Could not load the Tomcat server configuration at /usr/share/tomcat7/conf. The configuration may be corrupt or incomplete. /usr/share/tomcat7/conf/catalina.policy (No such file or directory)” run the following commands:

cd /usr/share/tomcat7
sudo ln -s /var/lib/tomcat7/conf conf
sudo ln -s /etc/tomcat7/policy.d/03catalina.policy conf/catalina.policy
sudo ln -s /var/log/tomcat7 log
sudo chmod -R 777 /usr/share/tomcat7/conf

to fix the error “Could not load the Tomcat server configuration at /Servers/Tomcat v7.0 Server at localhost-config. The configuration may be corrupt or incomplete” run the following commands:

cp /etc/tomcat7/* workspace/Servers/Tomcat\ v7.0\ Server\ at\ localhost-config/

log out and log back in;

open Eclipse;

open the server view:

• go to Window->Show View->Other…;
• choose the Servers under the Server category;

click on “new server wizard”;

• choose Apache / Tomcat v7.0 Server and press Next;
• enter “/usr/share/tomcat7″ into the “Tomcat installation directory” field;
• press Next;
• select your project on the left pane under “Available” and press Add> to move it to the right pane under “Configured”;
• press Finish”;

to be able to start the Tomcat server from Eclipse you need first to stop the one running in background:

sudo service tomcat7 stop

and to disable Tomcat to automatically start at boot run:

sudo update-rc.d tomcat7 disable

download the zip of Jersey;

put the the jersey jars into the folder “WEB-INF/lib” and add them to the project build path;

create your first RESTful Webservice by following this tutorial by Lars Vogel.

Your web services will be automatically deployed in the following folder:

~/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/

Your web service will be accessible through the following URI:

http://localhost:8080/EclipseProjectName/x/y/z

Where:

1. x = the root of your service set inside the tag url-pattern in web.xml;
2. y = the path set for your class
3. z = the path set for your method

Java Sorting: Comparator vs Comparable Tutorial

Article By Kamal Mettananda on July 10, 2008
Java Comparators and Comparables? What are they? How do we use them? This is a question we received from one of our readers. This article will discuss the java.util.Comparator and java.lang.Comparable in details with a set of sample codes for further clarifications.
Prerequisites

Basic Java knowledge

System Requirements

JDK installed

What are Java Comparators and Comparables?
As both names suggest (and you may have guessed), these are used for comparing objects in Java. Using these concepts; Java objects can be
sorted according to a predefined order.

Two of these concepts can be explained as follows.
Comparable
A comparable object is capable of comparing itself with another object. The class itself must implements the java.lang.Comparable interface in order to be able to compare its instances.

Comparator
A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances. This comparator class must implement the java.util.Comparator interface.

Do we need to compare objects?
The simplest answer is yes. When there is a list of objects, ordering these objects into different orders becomes a must in some situations. For example; think of displaying a list of employee objects in a web page. Generally employees may be displayed by sorting them using the employee id. Also there will be requirements to sort them according to the name or age as well. In these situations both these (above defined) concepts will become handy.

How to use these?
There are two interfaces in Java to support these concepts, and each of these has one method to be implemented by user.
Those are;

java.lang.Comparable: int compareTo(Object o1)
This method compares this object with o1 object. Returned int value has the following meanings.

positive – this object is greater than o1
zero – this object equals to o1
negative – this object is less than o1


java.util.Comparator: int compare(Object o1, Objecto2)
This method compares o1 and o2 objects. Returned int value has the following meanings.

positive – o1 is greater than o2
zero – o1 equals to o2
negative – o1 is less than o2


java.util.Collections.sort(List) and java.util.Arrays.sort(Object[]) methods can be used to sort using natural ordering of objects.
java.util.Collections.sort(List, Comparator) and java.util.Arrays.sort(Object[], Comparator) methods can be used if a Comparator is available for comparison.

The above explained Employee example is a good candidate for explaining these two concepts. First we’ll write a simple Java bean to represent the Employee.

public class Employee {
private int empId;
private String name;
private int age;

public Employee(int empId, String name, int age) {
// set values on attributes
}
// getters & setters
}


Next we’ll create a list of Employees for using in different sorting requirements. Employees are added to a List without any specific order in the following class.

import java.util.*;

public class Util {

public static List getEmployees() {

List col = new ArrayList();

col.add(new Employee(5, "Frank", 28));
col.add(new Employee(1, "Jorge", 19));
col.add(new Employee(6, "Bill", 34));
col.add(new Employee(3, "Michel", 10));
col.add(new Employee(7, "Simpson", 8));
col.add(new Employee(4, "Clerk",16 ));
col.add(new Employee(8, "Lee", 40));
col.add(new Employee(2, "Mark", 30));

return col;
}
}


Sorting in natural ordering
Employee’s natural ordering would be done according to the employee id. For that, above Employee class must be altered to add the comparing ability as follows.

public class Employee implements Comparable {
private int empId;
private String name;
private int age;

/**
* Compare a given Employee with this object.
* If employee id of this object is
* greater than the received object,
* then this object is greater than the other.
*/
public int compareTo(Employee o) {
return this.empId - o.empId ;
}
….
}


The new compareTo() method does the trick of implementing the natural ordering of the instances. So if a collection of Employee objects is sorted using Collections.sort(List) method; sorting happens according to the ordering done inside this method.

We’ll write a class to test this natural ordering mechanism. Following class use the Collections.sort(List) method to sort the given list in natural order.

import java.util.*;

public class TestEmployeeSort {

public static void main(String[] args) {
List coll = Util.getEmployees();
Collections.sort(coll); // sort method
printList(coll);
}

private static void printList(List list) {
System.out.println("EmpId\tName\tAge");
for (Employee e: list) {
System.out.println(e.getEmpId() + "\t" + e.getName() + "\t" + e.getAge());
}
}
}


Run the above class and examine the output. It will be as follows. As you can see, the list is sorted correctly using the employee id. As empId is an int value, the employee instances are ordered so that the int values ordered from 1 to 8.

EmpId Name Age
1 Jorge 19
2 Mark 30
3 Michel 10
4 Clerk 16
5 Frank 28
6 Bill 34
7 Simp 8
8 Lee 40


Sorting by other fields
If we need to sort using other fields of the employee, we’ll have to change the Employee class’s compareTo() method to use those fields. But then we’ll loose this empId based sorting mechanism. This is not a good alternative if we need to sort using different fields at different occasions. But no need to worry; Comparator is there to save us.

By writing a class that implements the java.util.Comparator interface, you can sort Employees using any field as you wish even without touching the Employee class itself; Employee class does not need to implement java.lang.Comparable or java.util.Comparator interface.
Sorting by name field
Following EmpSortByName class is used to sort Employee instances according to the name field. In this class, inside the compare() method sorting mechanism is implemented. In compare() method we get two Employee instances and we have to return which object is greater.

public class EmpSortByName implements Comparator{

public int compare(Employee o1, Employee o2) {
return o1.getName().compareTo(o2.getName());
}
}


Watch out: Here, String class’s compareTo() method is used in comparing the name fields (which are Strings).

Now to test this sorting mechanism, you must use the Collections.sort(List, Comparator) method instead of Collections.sort(List) method. Now change the TestEmployeeSort class as follows. See how the EmpSortByName comparator is used inside sort method.

import java.util.*;

public class TestEmployeeSort {

public static void main(String[] args) {

List coll = Util.getEmployees();
//Collections.sort(coll);
//use Comparator implementation
Collections.sort(coll, new EmpSortByName());
printList(coll);
}

private static void printList(List list) {
System.out.println("EmpId\tName\tAge");
for (Employee e: list) {
System.out.println(e.getEmpId() + "\t" + e.getName() + "\t" + e.getAge());
}
}
}


Now the result would be as follows. Check whether the employees are sorted correctly by the name String field. You’ll see that these are sorted alphabetically.

EmpId Name Age
6 Bill 34
4 Clerk 16
5 Frank 28
1 Jorge 19
8 Lee 40
2 Mark 30
3 Michel 10
7 Simp 8

Sorting by empId field
Even the ordering by empId (previously done using Comparable) can be implemented using Comparator; following class
does that.

public class EmpSortByEmpId implements Comparator{

public int compare(Employee o1, Employee o2) {
return o1.getEmpId() - o2.getEmpId();
}
}


Explore further
Do not stop here. Work on the followings by yourselves and sharpen knowledge on these concepts.

Sort employees using name, age, empId in this order (ie: when names are equal, try age and then next empId)
Explore how & why equals() method and compare()/compareTo() methods must be consistence.


If you have any issues on these concepts; please add those in the comments section and we’ll get back to you.

Labels: Java, Tech, Tutorial
Visitors Who Read This Article Also Read