Andy Gibson http://www.andygibson.net/blog Open Source Projects & Technical Writings Fri, 30 Jul 2010 02:42:19 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 The key to being a good programmer http://www.andygibson.net/blog/article/the-key-to-being-a-good-programmer/ http://www.andygibson.net/blog/article/the-key-to-being-a-good-programmer/#comments Thu, 29 Jul 2010 13:47:53 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1216 One blog topic that never seems to get old is what makes a good programmer, or how to be a good programmer, or what you can do to be a better programmer. The same activities are often listed as being the path to successful codesmithing, when really it is just the method by which the true magic happens. With programming, like many things, it isn’t what you do, it’s what you learn from it and the only key ingredient to being a good programmer (besides practice) is exposure to programming. Exposure comes in many forms, whether it is through hands-on practice or looking at someone elses code. Here’s a few of typical examples given and how it exposes us to programming.

Work on projects outside of the office

Working on your own projects outside of work lets you practice programming and exposes yourself to your own code. It also lets you practice problem solving and gives you the opportunity to experiment with alternative solutions. Also, a number of times I’ve gone back and re-read something I wrote and found better ways of doing it. However, it needs to be mixed with exposure to outside code so you don’t just keep yourself in your own rut and writing the same code with the same mistakes.

Works on Open Source projects

Not only does this give you more practice but also the ability to work on other people’s source and see how they code their way around certain problems. It also gives you exposure to the build and testing processes which are tools than that help improve your skills. Usually, in the case of libraries, you don’t even need to work on the project, you can be exposed to some of their ideas just by using the API.

Knows multiple languages

Working with multiple languages does give you exposure to different ideas and ways of doing things, but in itself, doesn’t make a better programmer and can even be detrimental. A native English speaker may improve their vocabulary and be exposed to different phrases by knowing French or German, but it doesn’t make them a much better English speaker or writer. Flip that around and a native French speaker is going to give a better speech than an English speaker who picked up a bit of French. Similarly, a hardcore Java/c#/C++/Delphi guy is going to be better than someone who dabbles in it.

Other Factors

It could be argued that it is obvious that getting more experience leads to being a better programmer, but not so. Solitary practice and accumulation of personal experience may get you so far, even gets some people very far, but for most, external exposure is required to drive new experiences and learning whether it be writing code, drawing pictures or playing the guitar.

Joel Spolsky wrote that good programmers are smart and get things done which also happens to be what makes good lawyers, doctors, accountants and applies to just about every other profession. Obviously being smart is a good thing, but that will only take you to the point where you have to sit down and write some code.

Passion is often stated as a requirement for being a good programmer, but it is just a means to an end. In itself, it doesn’t make a good programmer but can be the fuel that drives the activities that do improve your game. I’ve known a number of capable (not great) programmers who have little passion for it, they enjoy it, but it is purely a 9-5 job for them. The lack of passion shows in that they are content to just use existing skills without spending any time learning new ones or exploring the technical ecosystem available to them.

Summary

Try and expose yourself to as much code as possible, even bad code can be good for you as long as you aren’t copying it. Identify design patterns and more importantly, think about why those patterns were used over other patterns and what possible consequences are there of using that pattern. Learning the thinking behind other architectures will help when the time comes to make your own decisions. After all, when we get stuck as developers the first thing we do is Google it to see what someone else has done. This is just pre-emptive research!

]]> http://www.andygibson.net/blog/article/the-key-to-being-a-good-programmer/feed/ 1 Accessing and Paginating CSV Files with DataValve http://www.andygibson.net/blog/tutorial/accessing-and-paginating-csv-files-with-datavalve/ http://www.andygibson.net/blog/tutorial/accessing-and-paginating-csv-files-with-datavalve/#comments Wed, 28 Jul 2010 17:07:30 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1123

While DataValve is mostly used with database driven back ends, this tutorial shows you how DataValve can turn a comma delimited file into a paginated list of objects that the user can page through. We will then use this data provider in a console application, a Swing application and a JSF web page using the DataValve data client interfaces.

We will start by writing this tutorial as a console application and then demonstrate how the data provider can be used in other applications, even web applications. We’ll start by creating a new Maven application and then include the dependencies for DataValve. We’ll then create our comma delimited data provider, define a row mapper class for it, and hook it up to our demo data. We’ll then attach it to a dataset so we can easily iterate through the data. We will then take our provider and use it in different clients.

  1. Create a new Maven application in your IDE and add datavalve-dataset as a dependency in your pom.xml file. 
    	<dependencies>
		<dependency>
			<groupId>org.fluttercode.datavalve</groupId>
			<artifactId>datavalve-dataset</artifactId>
			<version>0.9.0.CR2</version>
		</dependency>
	</dependencies>
  2. Create a new class called Person in the package of your choice. I used org.fluttercode.tutorials.datavalve.csvreader We will only be using one package in this demonstration.
  3. The Person class will be our model which will be populated from the comma delimited file. 
    public class Person {

	private Integer id;
	private String firstName;
	private String middleName;
	private String lastName;
	private Date dob;
	private String email;
	private String address;
	private String city;
	private String zip;

	public Person() {
	}

	public Person(Integer id, String firstName, String lastName,String middleName,
			Date dob, String email, String address,
			String city, String zip) {
		super();
		this.id = id;
		this.firstName = firstName;
		this.middleName = middleName;
		this.lastName = lastName;
		this.email = email;
		this.dob = dob;
		this.address = address;
		this.city = city;
		this.zip = zip;
	}

	public String getName() {
		return firstName + " " + lastName;
	}

	public String getAddressText() {
		return address+ "," + city+","+zip;
	}

	@Override
	public String toString() {
		return String.format("Person [id=%d, name=%s, dob=%s,address=%s, email=%s",
		    id,getName(),dob,getAddressText(),email);
	}

    .... Getters and Setters Omitted ....
}
  4. In order to convert the csv data to an object, we need to create a ColumnarRowMapper instance. This takes a row of data, already converted to an array of string values, builds the model object from it and returns it back to the caller. Create a new class called PersonRowMapper.
    5. public class PersonRowMapper implements ColumnarRowMapper<Person> {

    private static SimpleDateFormat converter = new SimpleDateFormat(
			"MM/dd/yyyy");

	public Person mapRow(String[] values) {
		Date dob = null;

		try {
			dob = converter.parse(values[5]);
		} catch (ParseException e) {
		}

		return new Person(DataConverter.getInteger(values[0]), values[1],
				values[2], values[3], dob, values[4], values[6], values[7],
				values[8]);
	}
}

    This row mapper implements the ColumnarRowMapper interface and implements the single method to return a built entity object from the array of column values passed in.

  5. The only other element we need is some test data to run it on which you can download from here. Download this file and place it in the package folder with your source code. Depending on your IDE, you may need to refresh the folder in the package explorer so it can pick up the new file in the folder. The example file has 100 rows of data in it.
  6. Create a new class called ProviderFactory which will create our provider and initialize it with the CSV file url. 
    public class ProviderFactory {

	public static CommaDelimitedProvider<Person> createProvider() {
		URL url = ProviderFactory.class.getResource("data.csv");
		CommaDelimitedProvider<Person> provider;
		provider = new CommaDelimitedProvider<Person>(url.getFile());
		provider.setRowMapper(new PersonRowMapper());
		return provider;
	}
}

    We use a URL to reference the csv file stored in the jar from which we get a File instance that we can pass to our CommaDelimitedProvider. This relies on the data.csv file being in the same location as this class. Alternatively, you can put the file elsewhere and just create a regular File object to it rather than use the URL.

  7. For the console part of this demo, create a Main class and add a main method containing the code get an instance of the provider, and perform a simple iteration through the data. 
    public class Main {

	public static void main(String[] args) {
		CommaDelimitedProvider<Person> provider;

		provider= ProviderFactory.createProvider();

		List<Person> results = provider.fetchResults(new DefaultPaginator());
		for (Person p : results) {
			System.out.println(p);
		}
	}
}

    In this example we are reading all the results at once in memory and displaying the whole list.

Paginating the results

We can control which results and how many are displayed by using a paginator to control the flow of data. This can be useful if you have a huge file and it would be impractical to read all the results into memory in one go. Datasets have paginators built in and use a reference to a provider to fetch the actual data.

  1. In the main method, instead of using the provider directly, create a dataset and pass it a reference to our data provider. 
    public static void main(String[] args) {
	CommaDelimitedProvider<Person> provider;

	provider = ProviderFactory.createProvider();

	CommaDelimitedDataset<Person> ds = new CommaDelimitedDataset<Person>(provider);
	ds.setMaxRows(10);
	List<Person> results = ds.getResultList();
	for (Person p : results) {
		System.out.println(p);
	}
}

    We have set the maximum number of rows to 10 so the results returned only contains 10 rows of data at most. We can use this mechanism to control the number of results fetched if they are paginated.

  2. The dataset classes implement the Iterable interface which lets us iterate over the entire set of data. By setting the page size, we can control the batch sizes when the data is fetched in while it is being iterated over. This allows us to control the flow of data, either to reduce the in-memory realization of the source data, or to reduce latency in an otherwise slow data source as the application can process one page of data while the provider is loading the next page of data. 
    public static void main(String[] args)  {
	CommaDelimitedProvider<Person> provider;
	provider = ProviderFactory.createProvider();

	CommaDelimitedDataset<Person> ds = new CommaDelimitedDataset<Person>(provider);
	ds.setMaxRows(5);
	for (Person p : ds) {
		System.out.println(p);
	}
}
  3. You can see this process in action by extending the comma delimited data provider as an anonymous class and adding logging to the post fetch methods. We do this by modifying the ProviderFactory.createProvider() method : 
    public static CommaDelimitedProvider<Person> createProvider() {
	URL url = Main.class.getResource("data.csv");
	CommaDelimitedProvider<Person> provider = new CommaDelimitedProvider<Person>(url.getFile()) {
		@Override
		protected List<Person> doPostFetchResults(List<Person> results,
				Paginator paginator) {
			int end = paginator.getFirstResult()+paginator.getMaxRows();
			System.out.println("Fetching results from "+paginator.getFirstResult()+" to "+end);
			return results;
		}
	};
	provider.setRowMapper(new PersonRowMapper());
	return provider;
}
  4. If you run this now, with the max rows set to 5, in you will see in that log that we iterate through all the records, but we only fetch the results every 5 rows since the max results is set to 5.

    Fetching results from 0 to 5
Person [id=6825, name=JUANITA LAMBERT, address=139 MANNING HWY,CLYO,76604, email=mbeasley@everyma1l.biz
Person [id=5740, name=GREG CABRERA, address=736 GENESSEE BLVD,CORDELE,17433, email=cholder@b1zmail.biz
Person [id=8599, name=ALISSA WISE, address=205 ALICE RD,CAMILLA,14855, email=theyweb@eyec0de.net
Person [id=9282, name=SHARON WINTERS, address=955 COHEN PIKE,TYRONE,811, email=jlogan@hotma1l.com
Person [id=2150, name=KRISTY FRANKS, address=1471 ALEXIS PKWY,BALDWIN,85, email=jgates3@somema1l.com
Fetching results from 5 to 10
Person [id=9927, name=JEFF RICE, address=104 DUNDEE PKWY,HOGANSVILLE,3741, email=diedlots@b1zmail.org
Person [id=7972, name=TAMARA BRYANT, address=1382 WOGAN BLVD,CITY OF CALHOUN,43790, email=hotworn@everyma1l.us
Person [id=5824, name=ALISHA YANG, address=716 HOGANS DR,HARDING,58932, email=foundwrong@hotma1l.net
Person [id=3402, name=JASON NGUYEN, address=527 MICHAEL CRES,FORT STEWART,14664, email=haveothers@ma1l2u.com
Person [id=3620, name=LINDSEY CABRERA, address=1420 LAZELERE HTS,FORT STEWART,21650, email=askeddreams@b1zmail.com
Fetching results from 10 to 15
Person [id=3511, name=ANTHONY MATHEWS, address=1325 OKEY LN,THUNDERBOLT,63656, email=cfarrell@everyma1l.co.uk
Person [id=572, name=JARED FORD, address=722 EUCLID RD,FORSYTH,42014, email=ortrying@b1zmail.co.uk
Person [id=9720, name=AUTUMN WILLIAMS, address=260 HILL PARK,NORCROSS,58355, email=roomwhere@hotma1l.net
Person [id=3447, name=MARION BROWN, address=739 MIDDLE PATH,MACON,9944, email=hwagner@b1zmail.co.uk
Person [id=9356, name=HOPE HAYNES, address=1023 COOPERRIDERS CRES,STATENVILLE,34247, email=sacrificeit@eyec0de.com
Fetching results from 15 to 20
Person [id=2259, name=JEANNIE RANDOLPH, address=672 EDISON PATH,CENTERVILLE,48580, email=wornto@eyec0de.net
Person [id=8264, name=RACHAEL CONLEY, address=1223 STEVENS CT,CARROLLTON,40084, email=smokewhite20@eyec0de.net

Creating a Swing Client

DataValve provides an interface for data access that can be used by different clients. Lets look at using our provider with a Swing JTable.

  1. Start by creating a new class that will be the Swing frame that contains the table and the scroll pane. 
    public class CsvTableFrame extends JFrame {

	private JTable table;
	private JScrollPane pane;

	public CsvTableFrame(CommaDelimitedProvider<Person> provider) {
		initControls();
		initModel(provider);
	}

        //here we will create the table model and attach the provider
	private void initModel(CommaDelimitedProvider<Person> provider) {
	}

        //construct the gui table and scrollable panel
 	private void initControls() {
		setTitle("CSV Data");
		setSize(400, 400);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setVisible(true);

		table = new JTable();
		pane = new JScrollPane(table);
		table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
		getContentPane().add(pane);
	}
}

    This will setup the display for showing a frame with a scrollable table in it.

  2. Now we need to implement the initModel method which will create a ProviderTableModel and attach the provider passed in. The table model class enables us to present our data to the Swing table in a way it understands. The ProviderTableModel implements a method which supplies column values to the model from the data supplied by the provider. The columns are defined in the latter half of the method and determines the order used to supply data to the table for each column. 
            //here we will create the table model and attach the provider
	private void initModel(CommaDelimitedProvider<Person> provider) {
		ProviderTableModel<Person> model = new ProviderTableModel<Person>(
				provider) {

			@Override
			protected Object getColumnValue(Person person, int column) {
				switch (column) {
				case 0:
					return person.getId();
				case 1:
					return person.getName();
				case 2:
					return person.getEmail();
				case 3:
					return person.getAddressText();
				default:
					throw new RuntimeException(
							"Unexpected column for person object " + column);
				}
			}
		};

		//add the columns to the model
		model.addColumn("Id");
		model.addColumn("Name");
		model.addColumn("Email");
		model.addColumn("Address");

		//assign this model to the table
		table.setModel(model);
	}
  3. The last piece we need to change is in the main method where we will create our provider and then pass it into the creation of our Swing frame. 
    public static void main(String[] args) {

	CommaDelimitedProvider<Person> provider;

	provider = ProviderFactory.createProvider();

	new CsvTableFrame(provider);

}

    Creating the CsvTableFrame initializes and shows the Swing window.

  4. If we run this now, we will get a Swing Window which contains a table with our data in it.
    CSV Swing Table DataValve

The model controls the flow of the data and even includes built-in caching and look-ahead loading so no matter how big your CSV dataset is, there is no long delay while the data is loaded and converted to Java objects. In this case, we pass only the provider to the model and the model is responsible for how much data is fetched in each batch.

If you look in the log as you scroll down the list, you will see that it is loading in the data as you scroll. If you go to the end of the list, and start slowly scrolling back up, you won’t see any more loading messages until you get to the top of the list. This is because the values are cached, but if you have a large dataset, the least recently used items (i.e. those at the top of the table) are removed from the cache and therefore need re-loading when you go back to the start of the list.

Creating a JSF Client

The DataValve API allows us to re-use providers with many different clients which we’ll demonstrate with JSF.

  1. Start by creating a new JSF web application, or use the Knappsack Archetypes for Maven to get started quickly. Use the basic archetype so there is no existing application in there or alternative Person objects to clash with.
  2. Add the datavalve-dataset API and the datavalve-faces dependencies to the project, 
    		<dependency>
			<groupId>org.fluttercode.datavalve</groupId>
			<artifactId>datavalve-dataset</artifactId>
			<version>0.9.0.CR2</version>
		</dependency>
		<dependency>
			<groupId>org.fluttercode.datavalve</groupId>
			<artifactId>datavalve-faces</artifactId>
			<version>0.9.0.CR2</version>
		</dependency>
  3. For convenience, copy the ProviderFactory.java,Person.java and PersonRowMapper.java classes over to the new project.
  4. Create a new class called that will be our backing bean that will hold the dataset the JSF page will go against. 
    @Named("csvDataset")
@RequestScoped
public class CsvDatasetBean {

	CommaDelimitedDataset<Person> dataset =
	     new CommaDelimitedDataset<Person>(ProviderFactory.createProvider());

	public CsvDatasetBean() {
		//initialize the dataset settings
		dataset.setMaxRows(10);
	}

	public CommaDelimitedDataset<Person> getDataset() {
		return dataset;
	}
}
  5. Now we have created the backing bean pieces, open home.xhtml to edit it, and replace the hello world text with the following : 
    <?xml version="1.0" encoding="UTF-8"?>
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:dv="http://java.sun.com/jsf/composite/datavalve"
	template="/WEB-INF/templates/template.xhtml">
	<ui:define name="content">
		<h:dataTable value="#{csvDataset.dataset.resultList}" var="v_person">
			<h:column>
				<f:facet name="header">ID</f:facet>
				<h:outputText value="#{v_person.id}" />
			</h:column>

			<h:column>
				<f:facet name="header">Name</f:facet>
				<h:outputText value="#{v_person.name}" />
			</h:column>

			<h:column>
				<f:facet name="header">Email</f:facet>
				<h:outputText value="#{v_person.email}" />
			</h:column>

		</h:dataTable>
		<h:form>
			<dv:simplePaginator paginator="#{csvDataset.dataset}" />
		</h:form>
	</ui:define>
</ui:composition>

    This page contains a table that takes the results from #{csvDataset.dataset.resultList} and displays the id, name and email fields. The last item wrapped in a form is the datavalve-faces default paginator which allows to you scroll across the data. This is provided as part of datavalve-faces and the namespace is added at the top of the page. With JSF 2.0 including support for AJAX, you can have AJAX enabled pagination by setting the attributes on the component.

    CSV JSF Table DataValve

Summary

This tutorial has shown how to consume csv files in a way that is re-usable across different client applications using DataValve. Alternatively, if you change the implementation of ProviderFactory.createProvider to return a different type of provider (i.e. JDBC, ORM, Hibernate) as long is it returns the same kind of Person object, your code will run unchanged in the clients you create. Given the simplicity of the DataValve interfaces, it is not hard to see how easy it is to create providers for other file types whether they be text or binary based.

]]> http://www.andygibson.net/blog/tutorial/accessing-and-paginating-csv-files-with-datavalve/feed/ 0 Implementing User Selectable Themes In JSF http://www.andygibson.net/blog/tutorial/implementing-user-selectable-themes-in-jsf/ http://www.andygibson.net/blog/tutorial/implementing-user-selectable-themes-in-jsf/#comments Wed, 28 Jul 2010 16:44:36 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1116

Many web applications offer users the option to change the appearance of user interface. One of the easiest ways to implement this is by offering different page color schemes by selecting different css style sheets. This article describes how to implement themes in JSF using CDI backing beans that the user can select as their default theme.

Download project source

Each style sheet implements a different color scheme and when they user picks a theme, you simply have to provide the style sheet assigned to that theme. The application will be based on an existing archetype, so we’ll start by creating a new Maven application using the jee6-sandbox-demo-archetype.

As it is, the application has a stylesheet called screen.css which includes color information for the pages. We want to add another style sheet that overrides those color choices for the elements that we want to change per theme.

Of course, we could change much more css than the colors in the theme style sheet, we could change the layout and sizing information also, but the tradeoff is that the more content we put into the theme stylesheet, the more content we have to duplicate in each theme, and the more we have to change each time there is a minor change. We could resolve this problem by giving the user two different theming option, the first would select the layout stylesheet and the other would select the color stylesheet.

  1. In the package explorer locate the bean package and right click on the package folder.
  2. Select New->Class and in the class dialog, enter StyleBean as the name of the class

    This bean will hold the value of the current theme name and return the style sheet name to our view. It will also hold the list of available style sheets.
  3. We’ll start by annotating the bean with the @Named annotation so we can reference it from our JSF view pages and make the bean @SessionScoped so it will remember the settings between each request.
  4. Since our bean is session scoped, it needs to be passivation capable which means adding the Serializable interface to the implements clause.
  5. We add fields for the currently selected theme, and also a theme map which will contain the name of the themes and the stylesheet associated with it. Getters and setters for the theme have been omitted.
    6. import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.context.SessionScoped;
import javax.enterprise.inject.Produces;
import javax.inject.Named;

@Named("styleBean")
@SessionScoped
public class StyleBean implements Serializable {

	private String theme;

	private Map<String, String> themeMap;

	public StyleBean() {
		themeMap = new LinkedHashMap<String, String>();
		// read this list from the db or something
		themeMap.put("Default", "default.css");
		themeMap.put("Blue", "blue.css");
		themeMap.put("Green", "green.css");
	}

}
  6. Because JSF cannot iterate over a Map or Set we need to convert the list of theme names into a List. We do this with another method that we annotate with the @Produces method to indicate that this produces values. We give it the name themes and make it application scoped so this will be produced only once per application. 
    
	@Produces
	@Named("themes")
	@ApplicationScoped
	public List<String> getThemes() {
		return new ArrayList<String>(themeMap.keySet());
	}
  7. We have one more method to implement and that is the method that returns the name of the CSS stylesheet for the selected theme. We do this by using our theme Map as a lookup to get the filename
    8. 
	public String getThemeCss() {
		return themeMap.get(getTheme());
	}

    If you get an error at this point you forgot to put in the getter/setters for the theme field.

Now we have put all our code together in one bean, given that bean a name so it can be referenced from JSF, and implemented the list of themes and converting themes to a CSS file name. It’s time to implement our options page that lists the themes available and lets the user select one.

  1. Create a new JSF page called options.xhtml and paste in the following code : 
    <?xml version="1.0" encoding="UTF-8"?>
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:h="http://java.sun.com/jsf/html"
	xmlns:fc="http://java.sun.com/jsf/composite/fluttercode/component"
	template="/WEB-INF/templates/template.xhtml">
	<ui:define name="content">
		<h:form>
			<fc:panel caption="Visual Options">
				<fc:property caption="Theme">
					<h:selectOneListbox value="#{styleBean.theme}" style="width : 180px;height : 180px">
						<f:selectItems value="#{styleBean.themes}" />
					</h:selectOneListbox>
				</fc:property>
				<h:commandButton value="Update"/>
			</fc:panel>

		</h:form>

	</ui:define>
</ui:composition>

    Most of this code is boilerplate so I’ve highlighted the relevant parts. The list box that is wrapped by the property component, takes the list of themes from our themes producer and is bound to the theme property of our styleBean. When the user selects an item and clicks the Update button the theme property is set to the name of the selected theme.Since this is stateful, the new value holds across page requests so next time the page is rendered we can look at the themeCss property to get the file name of the css file for the selected theme.

  2. To render the css style sheet we need to add it to the style sheets in the header. Open up the template.xhtml file and locate the line with <h:outputStylesheet name="css/screen.css" />. Underneath it, add a new line to include our user selected style sheet. 
    <h:outputStylesheet name="css/#{styleBean.themeCss}" />
  3. Now the only thing left is to create the additional stylesheets for our themes. In the src/main/webapp/resources/css/ folder create a new stylesheet called default.css but leave it blank.
  4. Create a new stylesheet called blue.css with the following content : 
    
body {
	background-color: #E0E0FF;
	color: #102040;
}

#header {
	background: #204080;
	color: #f0f0fF;
}

.panel {
	border: 1px solid #D0D0F0;
	background: #f0f0ff;
}

.panel h1 {
	background: #e0e0f0;
	border-bottom: solid 1px #D0D0F0;
	color: #102040;
}

.odd {
	background: #f0f0fF;
}

.even {
	background: #f7f7ff;
}

.dataTable th {
	background: #204080;
	color: #f0f0ff;
}
  5. Add one more stylesheet called green.css with the following content : 
    body {
	background-color: #E0FFE0;
	color: #104020;
}

#header {
	background: #208040;
	color: #f0fFF0;
}

.panel {
	border: 1px solid #D0F0D0;
	background: #f0fff0;
}

.panel h1 {
	background: #e0f0e0;
	border-bottom: solid 1px #D0F0D0;
	color: #104020;
}

.odd {
	background: #f0fFf0;
}

.even {
	background: #f7fFf7;
}

.dataTable th {
	background: #208040;
	color: #f0fff0;
}

    6. If you deploy the application now and go to the http://localhost:8080/jsfthemes/options.jsf you can pick a different theme,click update and the application will start rendering pages with the new themes.

    Extending the Implementation

    There are a number of ways we can improve this implementation, especially since we are keeping the list of styles and the selection information in a backing bean in the session. Chances are that the session already has some kind of User entity, and it would be a good idea to store the selected theme, or better yet, the name of the css file as part of the user profile. The list of themes is only needed when the user is on the options page and is only used to provide the list of themes and to convert from the theme name to the css file. It would be easy to re-implement these as request scoped elements once the state is moved to the user entity.

    ]]> http://www.andygibson.net/blog/tutorial/implementing-user-selectable-themes-in-jsf/feed/ 0 Installing JBoss Developer Tools http://www.andygibson.net/blog/tutorial/installing-jboss-developer-tools/ http://www.andygibson.net/blog/tutorial/installing-jboss-developer-tools/#comments Wed, 28 Jul 2010 01:55:01 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1126 This article describes how to install the JBoss Developer Tools plug-ins into the Eclipse IDE. You should already have Eclipse installed and configured.

    JBoss Developer Tools is a bundle of Eclipse plug-ins for Eclipse which help when developing applications using a various frameworks, some of which are JBoss specific and some which are standards based, but still JBoss related. In particular this helps developers get to grips with Java EE 6 web development using JSF, CDI, EJB and JPA by integrating the use of these individual frameworks in the IDE.

    64 Bit Windows

    Currently, JBoss Developer Tools does not support 64 bit JVMs on Windows. There is a version for 64 bit Linux, but not for 64 bit windows. Therefore you will need to install a 32-bit JDK to use them, and we will tell Eclipse to use that JDK instead (see [node:3] for more details). This also means you will be unable to use a 64-bit version of Eclipse.

    For example, it provides tooling for the JPA standard and specifically the Hibernate implementation of JPA. Of most interest is the new Java Contexts and Dependency Injection (CDI , JSR 299) tooling which can go hand in hand with their excellent JSF page editing.

    You should start with an Eclipse installation that will support JBoss Tools (see the download page for more details on which Eclipse versions are supported.

    Prerequisite Eclipse Plug-ins

    Before we install JBoss tools, there are a some additional plug-ins that need installing first as prerequisites as described in the JBoss Tools install instructions. These plug-ins, as well as the JBoss Tools plug-ins themselves will be installed using the Eclipse update manager which is opened by opening the menu Help->Install New Software…. This manager has a list of URLs that Eclipse can use to locate and download plug-ins from remote locations called update sites.

    1. Open the install manager by clicking the menu item Help->Install New Software….
    2. In the install manager, click the Add button to add a new update site.
    3. In the dialog that pops up, add BIRT as the Name, and set Location to http://download.eclipse.org/birt/update-site/2.5/. Click OK to close the dialog.
    4. Back in the install manager, in the top drop down box select the BIRT site and you should see a list of available plug-ins appear in the main list area
    5. Click the check box next to each of the plug-ins and click Next.
    6. Once you agree to the licenses and click Finish Eclipse will download and install the plug-ins. Once complete, it will ask if you want to restart Eclipse now or later. Restart Eclipse now before we install additional plug-ins.
    7. Repeat the above steps for the Maven m2Eclipse plug-ins. In the “Add Site” dialog, set the Name to m2Eclipse and the Location to http://m2eclipse.sonatype.org/sites/m2e/.
    8. Once added, select the m2Eclipse site and check all the items in the plug-in list.
    9. Once the m2Eclipse plug-ins are installed, opt to restart eclipse

    Installing JBoss Tools

    Now we will install the plug-ins for Boss Tools, again using update sites as in the previous steps.

    1. Click Help->Install New Software… to open the install manager.
    2. Add a new site called JBoss Tools. The Location for the site is http://download.jboss.org/jbosstools/updates/stable/galileo/. Click OK.
    3. In the install manager, select the JBoss Tools site to download plug-ins from. You should see a long list of available plug-ins. Again, check them all and click Next.
    4. Once it has calculated requirements and dependencies, you should be able to click Next again, and check the license agreement and click Next.
    5. Finally, it will download and install the JBoss Tools plug-ins. This may take a while since the contents are in the region of just under 100 megabytes.
    6. Again, once complete, you should restart Eclipse
    7. You are done, you should now have a working installation of JBoss Developer Tools

    Dependency Issues

    Eclipse can have problems with missing dependencies indicating that there are missing required plug-ins. In such a case, see what plug-ins are missing in the Install Details tab in the Details section. Verify that you have downloaded the correct version of the Eclipse SDK as per the JBoss Tools instructions. Also make sure you downloaded the Eclipse SDK version for Java EE. If you need to access older versions of the Eclipse SDK, you can do so from this download page. Try searching online for the error message to see if it is a common problem.

    ]]>     http://www.andygibson.net/blog/tutorial/installing-jboss-developer-tools/feed/ 0     Installing Servers into Eclipse http://www.andygibson.net/blog/tutorial/installing-servers-into-eclipse/ http://www.andygibson.net/blog/tutorial/installing-servers-into-eclipse/#comments Wed, 28 Jul 2010 01:53:12 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1129

    If you want to do some web development with Eclipse, you will need a web server for it to run on. The process for adding a server to Eclipse is usually the same for different server vendors. Typically though each vendor has different configuration options for setting up the server. For now, we’ll look at adding the server into the Eclipse environment.

    Adding Servers

    Servers are added by letting Eclipse know what type of server you want to install and where it is installed locally. You must have already downloaded and installed a web server before adding it into the Eclipse environment.

    Server Views in Eclipse
    1. Select Window->Show->Other… to bring up the view selector.
    2. Start typing server and you will see the view list is filtered.
    3. We want the Servers view, not the JBoss Server View, that is now deprecated.
    4. Double click on the Servers item and the view selector will close and the Servers tab will open up in the bottom half of the IDE window.
    5. In the Servers window, right click and select New->Server to bring up the New Server dialog
      6. List of runtimes installed in Eclipse
    6. Select the appropriate server runtime for the server you are using from the list. If your server doesn’t appear in the list then click the “Download additional server adapters” link above the list.
        Adding a new server adapater

      1. In the Install New Extension dialog, wait for it to finish downloading the list of available server adapters and try and find the right one for your server.
      2. Once found, select your server and click Next, agree to any license terms and click Finish to install the adapter.
      3. Once installed, you should restart Eclipse when asked. Upon restarting, you will need to go back to step 5 of this process except this time, your server should appear in the initial list.
    7. When you have found your server type in the list of servers, click Next and fill in any required details. This should mostly be about telling Eclipse in which directory the server installation is located and click Next. For most servers it will let you know if you are pointing it to the wrong directory or it cannot find the installed server in that directory.
    8. The Add and Remove tab lets you add existing projects in the workspace to the new server. Unless you have any open projects, you don’t need to worry about this right now.
    9. When you click finish, your new server should appear in the Servers panel. Click on it, expand it and right click on it, and you can see there are options for starting, stopping and restarting the servers. When you add projects to the server, you will be able to select them for republishing.

    With a server installed, you can develop web applications using Eclipse and it will deploy the application for you when needed. This is if you downloaded the version of Eclipse for Java EE developers. If you download and install the m2Eclipse plugins you will be able to develop and deploy Maven web projects in Eclipse with the same benefits.

    ]]>     http://www.andygibson.net/blog/tutorial/installing-servers-into-eclipse/feed/ 0     Installing libraries into Maven from source http://www.andygibson.net/blog/tutorial/installing-libraries-into-maven-from-source/ http://www.andygibson.net/blog/tutorial/installing-libraries-into-maven-from-source/#comments Tue, 27 Jul 2010 14:18:39 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1119 This article describes how to install artifacts into Maven from the source code. To start with you should have installed Maven and downloaded the source code you want to install. This same mechanism can be used for library jar files to archetypes that you want to install.

    1. Open a command prompt and navigate to the directory where the Maven source code is. This is usually indicated by the presence of a pom.xml file in that directory. 
      
> cd dev\projects\myproject
    2. Once in the maven project folder, there are a number of different commands you can use to install the project depending on what you need. The simplest form will compile, test, and install the artifacts into Maven. 
      
>mvn install

    In some cases, you want to install the source and java doc files as well as the main jar file. This can be done by adding it onto the command line.

    
>mvn javadoc:jar source:jar install

    There may be times you want to make sure your build is completely clean before you start. You can do this by adding the clean target onto the command. This deletes any current compiled sources so they will be regenerated from scratch. 

    
>mvn clean javadoc:jar source:jar install

    While we added it at the start of the command, you don’t need to, you can put it at the end and it will still be executed first.

    Skipping Tests

    If you need to skip tests, you can do so by setting a command line parameter on the command line depending on how you want to skip the tests. While skipping tests is not advised, there are many cases where you might need to do so.

    -Dmaven.test.skip=true

    This will skip the compilation and execution of the tests.

    -DskipTests=true

    This will compile the tests, but skip the execution of them.

    See here for more information on controlling test skipping in the pom.xml file.

    ]]>     http://www.andygibson.net/blog/tutorial/installing-libraries-into-maven-from-source/feed/ 0     Install DataValve into Maven http://www.andygibson.net/blog/tutorial/install-datavalve-into-maven/ http://www.andygibson.net/blog/tutorial/install-datavalve-into-maven/#comments Tue, 27 Jul 2010 14:16:56 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1122 This tutorial will show you how to install DataValve into your local Maven repository. You should already have Maven installed locally on your machine into which we will be installing the DataValve libraries.

      Prerequisites

    • Install Maven
    1. First, download the DataValve framework and unzip it into a temporary folder of your choice.
    2. Open a command prompt and change directory to the <install-dir>\modules\ folder
    3. in the modules folder, type the command : 
      mvn clean javadoc:jar source:jar install
    4. This will compile the code, source and javadocs and install them into the local maven repository for use in your local maven applications.

    Once installed, to use DataValve in a Maven project you will need to add the necessary DataValvel modules as dependencies :

    		<dependency>
			<groupId>org.fluttercode.datavalve</groupId>
			<artifactId>datavalve-dataset</artifactId>
			<version>0.9.0.CR2</version>
		</dependency>

    Typically, adding the datavalve-dataset artifact pulls in the core module also. From there, you just need to add modules that your development environment will be dependent on (Wicket, JSF, Swing etc).

    ]]>     http://www.andygibson.net/blog/tutorial/install-datavalve-into-maven/feed/ 0     Updating Weld in Glassfish V3 http://www.andygibson.net/blog/quickbyte/updating-weld-in-glassfish-v3/ http://www.andygibson.net/blog/quickbyte/updating-weld-in-glassfish-v3/#comments Tue, 27 Jul 2010 14:08:40 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1146 (updated : This post refers to Glassfish installations prior to version 3.0.1 which was recently released and includes Weld version 3.0.1. Given the new version, this manual update is not necessary and should not be performed if you have an updated installation of Glassfish 3.0.1+)

    Even some of the recent versions of Glassfish include a version of Weld, the reference implementation for CDI (JSR 299), that has some major issues. Since Glassfish uses OSGI, upgrading isn’t as easy as just replacing the jar with a new one. This tutorial shows you how to upgrade Glassfish to Weld 1.0.1.Final as well as including a pre-built distribution of the two files that need re-deploying.

    One of the ways to get around the faulty version of Weld currently in Glassfish is to moving up to Glassfish 3.0.1 nightly builds (update : 3.0.1 has been released and should be used) . A less bleeding edge solution would be to upgrade the version of Weld that is deployed on your current version of Glassfish by updating the weld-integration and weld-osgi-bundle jar files. However, one must be careful of the integration jar version as one of the major interfaces changed after the initial release of Weld introducing incompatibilities.

    Updating the OSGI bundle is easy since it can be built from the Weld source code. Just download and compile it and locate the osgi-bundle.jar file.

    We also need to grab a new version of the weld-integration.jar file. There are all sorts of versions of this file, but the one I found working for Weld 1.0.1.final was version 3.0.1-b11/.

    I’ve already built the osgi-bundle and grabbed the integration jar and verified that they work so I’ve renamed and zipped them so you can just download and unzip them into the modules directory of your Glassfish v3 installation.

    This is also a necessary step to get the Knappsack Java EE 6 demo project working under Glassfish. You can find more details on the server compatability page

    ]]>     http://www.andygibson.net/blog/quickbyte/updating-weld-in-glassfish-v3/feed/ 0     Introducing DataValve http://www.andygibson.net/blog/article/introducing-datavalve/ http://www.andygibson.net/blog/article/introducing-datavalve/#comments Tue, 27 Jul 2010 14:05:07 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1105 DataValve is a free open source library that facilitates the creation of re-usable view and data access components as well as providing a number of features for pagination, sorting and parameterizing queries. This article defines the problems DataValve aims to solve and how it solves them.

    The need for DataValve

    Most data driven applications have a need for displaying data that is organized into pages. Whether it is search results or sales reports, dumping a complete set of data results into a web page or a Swing grid is sooner or later going to run into problems as the datasets grow larger.

    Visual web frameworks such as Wicket or JSF usually have some components that facilitate pagination and most data access frameworks such as JDBC, Hibernate or JPA have facilities to access results in a paginated manner. Typically however, you need to write your own code to bridge the gap between the view and the data access mechanism. If you write your own glue code you will probably need to re-write it again and again if you want to re-use the back end code with a different view layer or change the data access mechanism.

    Applications With DataValve

    Exotic Data Sources

    There may even be times when you have a sudden request to provide paginated data access to more exotic data sources such as XML, CSV, and binary files, even pulling data from a web service. In such a scenario not only do you have to write most of the pagination yourself, but again, your view layer will need some work to handle the new data access mechanism. This also includes paginated access to in-memory data that is regularly used, but changes rarely and is cached in memory.

    Most of you are probably thinking that this isn’t a big problem because you write layered code with an interface that can have different implementations. You are right, logical organization of code can help with all these problems, however, at the end of the day, you still have to write something that integrates with the new datasource in the same way as the old datasource in the implementation.

    If you are thinking that you will never need to change your view layer or data providers, there are still some problems you might want to consider that DataValve can help with.

    Dynamic Querying

    One common feature in data driven applications is to query a set of data using parameters with the ability to exclude query clauses where the parameter is not set. If you are searching for people, why filter by address if the user didn’t enter an address? The solutions to get around this problem involve either building the query at run time and ignoring restrictions with missing parameter values or accommodating the potentially null parameter in the query itself which makes it look ugly and can harm performance.

    Ordering data safely

    Another problem is the abstraction of the ordering of data, especially with web applications. You don’t want to store the actual SQL columns used for sorting data on the web page in case of SQL injection attacks. The best way is to use a key that maps to how you want the data ordered . You would also have to allow for ascending and descending ordering.

    Parameterizing queries

    Dynamic queries should be parameterized to allow variables in the query to be set in a safe manner as opposed to changing the query text which can again lead to SQL injection attacks. Typically though most parameters have to be set manually and many times we add new parameters and forget to set them. The process of adding and assigning parameters can require lengthy boilerplate code. DataValve offers vastly improved parameter handling for queries.

    How DataValve solves all these problems

    DataValve works by using a well defined interface to access and paginate data that comes from a data provider. There are different data providers for each kind of data source (JDBC,ORM,Hibernate,File based) and you can even write your own using an interface with just 2 methods. Because we have a well defined interface to the data, we can create components for the view to connect to that interface. Since we are coupled to the interface only, we can change the implementation and as long as it returns the same kind of entity objects, our view code remains unchanged. The view doesn’t care whether the list of Person entities comes from a database, an XML file, a web service or an in-memory list. When the dataset is connected up to a different view layer, it is coupled to the same interface and accesses the data in the same defined way.

    Here’s a quick example of how we create a data provider and paginate the results. 

    DataProvider<Person> provider = new SomeDataProvider<Person>();
Paginator paginator = new DefaultPaginator();
paginator.setMaxRows(10);
pagiantor.setFirstResult(15);
List<Person> results = provider.fetchResults(paginator);
for (Person p : results) {
  //do something with the 10 Person objects from 15-25
}

    We can also use a Dataset that is a stateful combination of a Paginator and a data provider reference.

    DataProvider<Person> provider = new SomeDataProvider<Person>();
ObjectDataset<Person> dataset = new DataProviderDataset(provider);
dataset.setMaxRows(10);
dataset.setFirstResult(35);
List<Person> results = dataset.getResults();
for (Person p : results) {
...some code...
}

    Each time we call getResults() on the dataset, it will return the same list of results until we move to another page of results or manually invalidate the result set. Every time you call fetchResults on a data provider the list of results is re-fetched each time. The Dataset also implements the iterator interface so you could iterate over the whole set of data and it would go through each row, but load them in batches as sized by the paginator.

    Queried Results

    Let’s load a result set that uses some filtering and sorting. 

    QueryProvider<Person> provider = new JpaDataProvider<Person>(em);
QueryDataset<Person> dataset = new QueryDataset<Person>(provider);

provider.setSelectStatement("select p from Person p");
provider.setCountStatement("select count(p) from Person p");

//we can also access the provider using
// dataset.getProvider()

//add simple restriction
provider.addRestriction("p.department.id = 4");

List<Person> results = dataset.getResultList();
for (Person p : results) {
    System.out.println(p.getName());
}

    Alternatively, we could specify the parameters using : 

    //:param is a magic value for this method call only
provider.addRestriction("p.firstName = :param",someFirstName);

//alternatively

provider.addRestriction("p.firstName = :aFirstName");
provider.addParameter("aFirstName",someFirstName);

    A few things to note here. The second method of using a parameter requires two method calls, but you can change the parameter value later on prior to execution and if aFirstName is null, then the restriction won’t be included in the executed final query. Typically, restrictions are excluded at the time of query execution, but if you use the first syntax, the restriction is left out immediately if the value is null since you are setting the parameter as a constant and if the value is null, then it will always be null.

    Here are some alternative ways of defining parameters, all of which are subject to the rule that if the parameter is null, then the restriction isn’t added. All these examples can be used with either Hibernate, JPA or JDBC data providers with the only changes being the query specification and the field names in the restrictions. 

      //WRONG - if first name is null, then the param value is 'null%' and will be added
  provider.addRestriction("p.firstName like :param",criteria.firstName+"%");

  //CORRECT - this checks one value, but assigns another to the actual parameter
  provider.addRestriction("p.firstName like :param",criteria.firstName,criteria.firstName+"%");

    This is really useful where we want to use one value for the null check, but assign another value to the actual parameter so we can use ’starts-with’ in searches by adding a wildcard on the end.

      provider.addRestriction("p.department.id = 4");
  provider.addRestriction("or p.managerFlag = 1");

    All restrictions are joined together with “AND”s unless they actually start with a logical operator. Parenthesis can be introduced into the query, but care must be taken that opening or closing parentheses would not be removed in the event of a null parameter.

    If you are using JSF or some other EL enabled environment, you can also use EL expressions directly in the queries as long as you attach an ELParameterResolver to the provider.

      provider.addRestriction("p.firstName = #{criteria.firstName}");
  provider.addRestriction("p.lastName = #{criteria.lastName}");

    Again, if these expressions evaluate to null then the restriction is not used. This makes it really easy to create a search criteria bean that hooks up to the JSF front end and back end without any additional glue code.

    Parameter Resolvers

    DataValve has a concept of parameter resolvers that can be used on any data provider that implements the ParameterizedDataset interface. Parameter resolvers are like plugins that provide parameter resolution through code. The ReflectionParameterResolver uses reflection to find parameter values where the property name is the same as the parameter name.

    provider.addRestriction("p.firstName like :firstName");
provider.addRestriction("p.lastName like :lastName");
provider.addParameterResolver(new ReflectionParameterResolver(criteria));

    Our criteria object has first and last name properties that are used to resolve the parameter values in the restrictions. Again, if the values resolve to null, the restriction is not used when the query is executed.

    Also, multiple parameter resolvers can be attached to a provider so you could use an EL parameter resolver and a reflection parameter resolver. This can be useful for mixing it up if you have multiple sources for parameters. You can also combine different combinations of adding restrictions.

    provider.addRestriction("p.firstName like :firstName");
provider.addRestriction("p.lastName like :lastName");
provider.addRestriction("p.salesRep.id = #{currentUser.id}");
provider.addRestriction("p.dept.id = ",selectedDepartment.getId());
provider.addParameterResolver(new ReflectionParameterResolver(criteria));
provider.addParameterResolver(new ElParameterResolver());

    Ordering Results

    Configuring the order is simple, we add the order key values and associate information with each key to indicates how the ordering is executed which in most cases, it is the list of fields we use to order.

    provider.getOrderKeyMap().put("name","p.lastName,p.firstName");
provider.getOrderKeyMap().put("age","p.dateOfBirth");
provider.getOrderKeyMap().put("id","p.id");

    To order data when we fetch it from the provider, we need to assign a key order value on the paginator used to fetch the data from the provider.

    Paginator paginator = new DefaultPaginator();
paginator.setOrderKey("name"); //order by the persons name
paginator.setOrderAscending(false);
List<Person> orderedList = provider.fetchResults(paginator);

    If you are using a dataset, you can just set the orderKey and orderAscending properties on the dataset instead. These key values can be embedded in your web page and passed back to the server side components without having to worry about SQL injection. If the order key is not recognized as one of the available values in the order key map then no order is used and no SQL is injected.

    State management

    Paginators and data providers are separate instances while object datasets are made up of a paginator with a data provider reference that keeps a hold of the most recent set of results. The reason for this is so you can modify the degree of statelessness used.

    You can make the whole thing stateless with the paginator info being passed between the client and the server. With Wicket, Seam, CDI and Spring Web Flow you might want to keep the paginator state on the server side but keep refreshing the results each time you postback. This can be done by keeping it in a Conversation, a Spring web flow, or a Wicket page. If you want to go fully stateful, you can use the Dataset which includes the paginator and the data provider and caches the recent resultset and put it in a Wicket page, a conversation or a page flow. By default, the JSF Components for paginating a DataValve result set is stateless.

    Client Side

    Briefly, lets look at the options for creating clients for DataValve datasets. There are components for a simple JSF paginator and a sortable column header for JSF 2.0 in the datavalve-faces module, and a SortableDataProvider for Wicket. For Swing, there is a special TableModel that caches and pre-emptively loads data for display in a Swing JTable. This means you can easily navigate thousands of rows of data in a Swing Table without having a long initial load time or taking up a lot of memory for object storage.

    In the DataValve download there are demos for each of these examples in projects that are easy to run using the Jetty plugin for Maven so no server is required. The Wicket demo even demonstrates how different pieces of server side code can be reused with JDBC, CSV and Hibernate driven data providers.

    Get Started

    In addition to the DataValve project page you can see the documentation in HTML, Single HTML, or PDF. The download includes source that can be built and installed with maven as well as pre-built binaries.

    ]]>     http://www.andygibson.net/blog/article/introducing-datavalve/feed/ 0     Installing and Configuring Eclipse http://www.andygibson.net/blog/tutorial/installing-and-configuring-eclipse/ http://www.andygibson.net/blog/tutorial/installing-and-configuring-eclipse/#comments Tue, 27 Jul 2010 02:19:33 +0000 Andy Gibson http://www.andygibson.net/blog/?p=1070 This article shows you how to download and set up Eclipse in preparation for developing Java applications and includes configuring memory settings and if necessary alternate JDK versions. Eclipse is an Integrated Development Environment that provides a set of basic elements for a development environment. This environment is extended by different plug-ins that provide different features for different development tools, environments and frameworks. It is assumed the user is starting from scratch and will be downloading everything fresh. Once downloaded, we will install everything, and set up our environment.

    64 Bit Windows

    Some plug-ins do not support 64 bit JVMs on Windows, JBoss Developer Tools being one example. If you need to use these plug-ins, you will need to install a 32-bit JDK to use them, and we will configure Eclipse to use that JDK instead. This also means you will be unable to use a 64-bit version of Eclipse.

    Installing and setting up Eclipse

    We’ll start by downloading the Eclipse SDK which is the base IDE that we will be installing plug-ins into. At the time of writing, Eclipse SDK 3.5.2 is the most recent version. You need to download the version for Java EE developers since it contains most of the other required plug-ins for things like web development. You can download Eclipse from the Eclipse download site. Once downloaded, unzip it into a folder of your choice. The zip file usually creates a directory called eclipse in the target directory that you unzipped the contents into.

    Memory Settings

    By default, Eclipse uses lousy memory settings, but we can alter the eclipse.ini file in the eclipse install directory to give us a better environment to work in. In the eclipse directory that appeared when you unzipped eclipse, there is an eclipse.ini file. Edit this file and you will see a section that starts with -vmargs. After this sections, you will see a couple of items starting with -xms and -xmx. Edit this section so that it reads something like : 

    -Xms256m
-Xmx512m
-XX:MaxPermSize=256m

    Don’t delete any other items in this section, just replace any that are existing and add others that are not already there.

    The values you use depends on how much memory you have, but this is a decent amount. You can go with less, or more depending on how much free memory you have. See here for more details on Eclipse memory settings.

    Running Eclipse under a different JVM

    You can also tell Eclipse to run using a specific JVM or JDK in the eclipse.ini file by adding a -vm entry. You may need to do this if you have a 64-bit JVM and you need to run Eclipse under a 32-bit JVM. Another reason to add this to the configuration is because the Maven plug-ins we’ll be adding later prefers to run under a JDK instead of a JRE.

    Open up eclipse.ini and add the following 2 lines :

    -vm
C:\Program Files\Java\jdk1.6.xxx\bin\javaw.exe

    Note : This must be on 2 separate lines and they must be placed before the -vm arguments. Otherwise it will not work.

    Now we have Eclipse installed and the environment configured, we’ll take it for a test. Run eclipse.exe and Eclipse should launch. If not, check that you are using a valid path and filename for the -vm option. If you are pointing to a 64-bit JVM and have 32-bit only plugins installed, this can cause silent failures.

    When Eclipse starts up, if you go to Help->About Eclipse and the about dialog pops up. Click on the Installation Details button and in the window that pops up, click on the Configuration tab. In the big configuration listing, near the bottom of the window (you might have to scroll down a little) you should see something like : 

    eclipse.vm=C:\Program Files\Java\jdk1.6.xxxx\bin\javaw.exe
eclipse.vmargs=-Dosgi.requiredJavaVersion=1.5
-Xms256m
-Xmx512m
-XX:MaxPermSize=256m

    This confirms that our memory settings are being picked up, and the JDK we specified is being used.

    Adding Maven Support

    While this article doesn’t intend to cover any other plugins, Maven support in Eclipse is a rather fundamental one for getting started with projects. Here are the steps to install the m2Eclipse Maven plug-ins.

    1. Open the install manager by clicking the menu item Help->Install New Software….
    2. In the install manager, click the Add button to add a new update site.
    3. In the dialog that pops up, add m2Eclipse as the Name, and set Location to http://m2eclipse.sonatype.org/sites/m2e/. Click OK to close the dialog.
    4. Select the m2Eclipse URL in the drop down and click the check box next to the Maven Integration for Eclipse plug-in in the list and click Next.
    5. Once you agree to the licenses and click Finish Eclipse will download and install the plug-ins. Once complete, it will ask if you want to restart Eclipse now or later. It is best to re-start Eclipse before you start a new project or adding more plug-ins.
    ]]>     http://www.andygibson.net/blog/tutorial/installing-and-configuring-eclipse/feed/ 1