Terence hacks

2011 in review

Terence Ponce — Sun, 01 Jan 2012 05:03:52 +0000

The WordPress.com stats helper monkeys prepared a 2011 annual report for this blog.

Here’s an excerpt:

A San Francisco cable car holds 60 people. This blog was viewed about 1,700 times in 2011. If it were a cable car, it would take about 28 trips to carry that many people.

Click here to see the complete report.

Facebook Image Publisher Tracker

Terence Ponce — Thu, 25 Aug 2011 08:57:21 +0000

Hi there! It’s been a while since I made an article. I got pretty busy and kinda lazy over the past few months so I completely forgot that I have a blog going on.

So the last article that I made was about using Google App Engine. I stopped that project because it got pretty complicated the moment I tried using the Datastore. So now, I decided to build something simple, something that doesn’t require a database to run.

Recently, I found out that you can trace a Facebook image back to its publisher based on the image’s URL. Obviously, the image should come from Facebook’s content deliver network or CDN as people usually describe it. It’s no secret, really. I found out how immediately after my first Google search. I’m pretty sure revealing how is kind of unethical and on a moral gray area, but hey, the information is already out there. It’s not like I can make it any worse by posting it here. Besides, I trust that any reader of this blog (if there’s really anyone reading this) would be responsible enough not to use it for evil.

Let’s say, for example, I posted this Facebook picture of me somewhere on the Internet. At the 3rd level of the image link, there’s a set of numbers separated by an underscore (63442_472293192932_636557932_5746749_150701_n.jpg). These numbers are actually time stamps, but among those time stamps is the profile ID of the publisher of the image. What you want to do is to get the 3rd one (636557932), which is the profile ID, and type the link in your browser (http://facebook.com/profile.php?id=/). That wasn’t so hard right? I’m pretty sure anyone persistent enough would be able to figure it out on their own.

After I learned how to do that, I thought it would be fun to make a simple tool to automate the process since I’m too lazy to type it in the address bar every time. Then I realized that it’s pretty easy to make it into a Google App Engine app, so I did.

Since I didn’t really want this article to be lengthy and cause people to get bored, I decided to skip with the code discussion and just get on with showing you the actual software itself. The tool can be found here and the source code for the whole project can be found here.

A noob’s attempt on Google App Engine using Java part 2

Terence Ponce — Sat, 26 Mar 2011 03:11:06 +0000

In my last entry, I modified my Maven project so it can be deployed to Google App Engine. This time, I’m going to work on my actual application so I can finally have something to show to other people.

Right now, my Spring web application works fine on Google App Engine. Let me go over the code that I have so far. I first made a bean called Manufacturer:

package com.jenanderic.domain;

public class Manufacturer {
	private int id;
	private String name;
	private String address;
	
	// Constructors
	
	// Getters and Setters
}

Next, I made an implementation class of a service interface for the bean that I just made:

package com.jenanderic.service;

// Imports

public class ManufacturerServiceImpl implements ManufacturerService {
	
	@Autowired
	private List manufacturers;
	
	// Getters and Setters
}

I made it autowired so Spring will do the injection for me. I then made the controller to handle the requests:

package com.jenanderic.web;

// Imports

@Controller
@RequestMapping("/manufacturer")
public class ManufacturerController {

	private ManufacturerService manufacturerService;
	
	@Autowired
	public void setManufacturerService(ManufacturerService manufacturerService) {
		this.manufacturerService = manufacturerService;
	}
	
	@RequestMapping(method = RequestMethod.GET)
	public String getManufacturerList(Model model) {
		model.addAttribute("manufacturers", manufacturerService.getAllManufacturers());
		return "manufacturer_list";
	}
}

Then, I made the template page since the controller returns a page called manufacturer_list.jsp:

<%@ include file="/WEB-INF/jsp/include.jsp" %>


	
		<spring:message code="manufacturer.title" />
	
	
		
		
			 - 
			 -

Now that everything’s almost done, it’s time to make an actual bean to inject into the controller. I placed it in the Application’s context:

Since I have it autowired, I don’t need to explicitly inject it into the controller. Pretty cool, right?

Anyway, if I build and run the web app in GAE’s development server, it will run smoothly with no problems, so I’m sure that my web app runs 100% fine at this point.

Of course, I need to add persistence in the application since web apps are mostly about persistence. This is where it gets complicated. Even though I have plenty of experience working with database-driven applications, Google App Engine makes it seem otherwise.

Google App Engine works in a manner very different from traditional platforms. The most noticeable is the way it handles persistence; it doesn’t support relational databases. Google App Engine uses a non-relational database called the datastore. At the moment, I don’t have a full grasp of the pros and cons of not being able to use a relational database, but I’m pretty sure it has a great impact with the way you will build your application. Working with a non-relational database means that you have to manually maintain indexes with hand-written code. Aside from that, you have to manually write code for merging the results of multiple queries. Bummer.

A noob’s attempt on Google App Engine using Java

Terence Ponce — Sat, 12 Mar 2011 04:29:53 +0000

Since I solved most of the problems that I encountered with Spring MVC, I decided to take it up a notch by using Google App Engine. If you haven’t heard about GAE, it’s basically a host for web applications that are built in Java or Python. Also, it’s an engine for building web applications (as you can see from the name). One of the benefits that you get from GAE is that your web application gets to be hosted by the same servers that power Google. Best of all, it’s free! Well, not really. It’s free when you avail the basic package, which already has everything a startup company needs anyway. You’ll only need to pay if you need more hosting power or other services like custom domains for your web application.

To be honest, this isn’t my first attempt on GAE. A few months ago, I made a web application using Python and Django-nonrel, a modification of the Django framework for Google App Engine. It was all good but I stopped the development after a few weeks because I lack knowledge, references, and guidance at that time.

With that said, this is my second attempt at using GAE. I decided to use Java and Spring 3.0 this time since I’ve been focusing a lot on Java lately. Hopefully, I’ll be able to do it successfully this time.

Of course, the first thing I did was read through the documentation. Unfortunately, I didn’t really get much from the documentation because it didn’t have enough information about the tools that I’ll use for the project like Maven 2, and Spring 3.0. I didn’t use Ant for my project because I found Maven to be more convenient to use. I already have an existing project built with Maven 2 and Spring 3.0 that I want to migrate to GAE, so I had to find a way to get Maven to do all the build, dependency management, and deployment task for me. Luckily, I found a plugin for Maven that already does what I need.

To start, let me show you the contents of the pom.xml of my existing Maven project:


	4.0.0
	com.jenanderic
	jenanderic
	war
	1.0-SNAPSHOT
	
	Jen&Eric Drugstore
	POS System for Jen&Eric Drugstore
	
	
		
			junit
			junit
			3.8.1
		
		
		
			commons-logging
			commons-logging
			1.1.1
		
		
		
			javax.servlet
			servlet-api
			2.5
		
		
		
			taglibs
			standard
			1.1.2
		
		
		
			jstl
			jstl
			1.1.2
		
		
		
			org.springframework
			spring-aop
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-web
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-context-support
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-context
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-beans
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-core
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-webmvc
			3.0.5.RELEASE
		
		
		
			org.springframework
			spring-web
			3.0.5.RELEASE
		
		
	
	
	
		JenAndEric
		
		

			
				maven-compiler-plugin
				2.1
				
					1.6
					1.6
				
			
			
			
				org.codehaus.mojo
				tomcat-maven-plugin
				
					http://localhost:8080/manager
					tomcat
					s3cret
					/JenAndEric

As you can see from the dependencies, it’s a Spring 3.0 project. Don’t mind the server credentials you see from the bottom of the code. I was too lazy to encrypt it anyway so I don’t care if you see my Tomcat server’s credentials right now. Also, notice the name of the web application that I’m making. I’m trying to make a web application for my family’s drug store so I can finally help with the family business. I’m such a good son. I think I should be awarded for this! Kidding aside, I don’t mind releasing some of the source code here but the project’s repository on BitBucket is marked as private so you won’t really see everything.

Of course, this project won’t be able to run on GAE as is. I need to use the maven-gae-plugin for my project to be able to run on Google App Engine. For starters, I need to add the location of the repositories where Maven will download the plugin and dependencies since it’s not hosted on the global repos of Maven:


	
		maven-gae-plugin-repo
		http://maven-gae-plugin.googlecode.com/svn/repository
		Maven Google App Engine Repository
	



	
		maven-gae-plugin-repo
		http://maven-gae-plugin.googlecode.com/svn/repository/
		Maven Google App Engine Repository

Now that Maven knows where to download the plugins and dependencies that the project needs, it’s time to add the actual plugins themselves:


	
	
		
		
		
			net.kindleit
			maven-gae-plugin
			${gae.pluginVersion}
			
				
					net.kindleit
					gae-runtime
					${gae.version}
					pom
				
			
		
		
		
			maven-release-plugin
			
				gae:deploy

Adding these plugins to your pom.xml allows you to use the gae:run and gae:deploy goals in your Maven project. The first one, gae:run, builds your project and deploys it to the development server that the GAE SDK comes with. The second one, gae:deploy, builds your project and deploys it to the actual server of your application inside Google App Engine.

Next up, we need to add the JAR files that the project needs to run on GAE. Of course, instead of adding them manually to the lib folder of the project, we’ll let Maven handle the dependency management for us:


	
	
	
	
		com.google.appengine.orm
		datanucleus-appengine
		1.0.7.final
	

	
		org.datanucleus
		datanucleus-core
		1.1.5
		
			
				javax.transaction
				transaction-api
			
		
	

	
		com.google.appengine
		datanucleus-jpa
		1.1.5
		runtime
	

	
		com.google.appengine
		geronimo-jpa_3.0_spec
		1.1.1
		runtime
	

	
		com.google.appengine
		appengine-api-1.0-sdk
		${gae.version}
	

	
		com.google.appengine
		appengine-tools-api
		${gae.version}

If you read the code thoroughly, you’ll notice that I used property references for some of the values. I did that so upgrading to a different version won’t be much of a hassle. Finally, I added the actual values for the property references that I made earlier:


	C:\devtools\eclipse\plugins\com.google.appengine.eclipse.sdkbundle.1.4.2_1.4.2.v201102111811\appengine-java-sdk-1.4.2
	
	0.7.1
	1.3.7

As you can see, I haven’t given any name for my application yet. Why is it so hard to come up with names?

Now that we’re finished modifying the pom.xml of the project, it’s time to test if the project will indeed run on Google App Engine:

$ mvn gae:run

As I said earlier, gae:run builds and deploys the project to the development server. Aside from that, it also starts the development server so you can access it from your browser. Anyway, I’m too lazy to post the output, but I assure you that the project will indeed run when you go to http://localhost:8080/

Bad start with Spring part 2 – Resolved

Terence Ponce — Fri, 11 Mar 2011 09:53:05 +0000

Last time, I was kind of frustrated as well as lazy about my problem. As a recap, I had a problem with manually injecting beans in Spring 3.0 because I tried doing it the old fashioned way. After a long time of reading and thinking, I realized that I’m having problems because I didn’t embrace the sudden transition I had with annotations.

Since I’m the kind of person who embraces change, I decided to stop whining and use the auto wiring feature instead. I added the @Autowired annotation to the setter method inside the controller:

package com.jenanderic.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.Model;

import java.util.Date;
import java.util.List;

import com.jenanderic.domain.Manufacturer;
import com.jenanderic.service.ManufacturerService;

@Controller
@RequestMapping("/manufacturer_list")
public class ManufacturerListController {

	private ManufacturerService manufacturerService;

	@RequestMapping(method = RequestMethod.GET)
	public String manufacturerList(Model model) {
		Date today = new Date();
		model.addAttribute("today", today);
		model.addAttribute("manufacturers", manufacturerService.getManufacturers());
		return "manufacturer_list";
	}
	
	@Autowired
	public void setManufacturerService(ManufacturerService manufacturerService) {
		this.manufacturerService = manufacturerService;
	}
}

Actually, now that I’ve thought about it already, I find the use of annotations much better and cleaner than the old method. It takes a while to learn for it to be readable enough though. It took me about half a day of reading to actually realize how cool annotations are. I even used multiple references to learn this.

As of now, I’m learning how Spring works little by little. I even finished a few chapters on the book that I’m reading. As of now, I’m trying out how to make Spring-MVC work with Google App Engine, but I think I’ll cover that on another entry.

Bad start with Spring part 2

Terence Ponce — Mon, 07 Mar 2011 03:15:40 +0000

Recently, I realized that Spring 2.5 was really old already. I was even nitpicked for it:

@Terence why do you start with Spring 2.5 now when Spring 3 is already over a year old? – Sean Patrick Floyd Feb 24 at 10:50

The quote came from a comment in my question on StackOverflow.

Anyway, I decided to try and use Spring 3.0 because of that. One of the new things that I encountered was the way Spring 3.0 maps the request to controllers. The dispatcher servlet doesn’t handle the URL mapping to controllers now. Instead, you use annotations to handle it automatically.

**UPDATE**
Apparently, I was wrong about the annotations. Spring already has annotation support in 2.5. I just didn’t get a chance encounter it back then which is why I thought it was completely new.
**/UPDATE**

So I tried making another simple web application to try it out. First of all, I made a bean class:

Manufacturer.java

package com.jenanderic.domain;

public class Manufacturer {
	
	private int id;
	private String name;
	private String address;
	
	public Manufacturer() {}
	
	public Manufacturer(String name, String address) {
		this.name = name;
		this.address = address;
	}
	
	public Manufacturer(int id, String name, String address) {
		this(name, address);
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getAddress() {
		return address;
	}
	
	public void setAddress(String address) {
		this.address = address;
	}
}

I then made an interface for managing the bean:

package com.jenanderic.service;

import java.io.Serializable;
import java.util.List;

import com.jenanderic.domain.Manufacturer;

public interface ManufacturerService extends Serializable {
	
	public List getManufacturers();
	
	public void setManufacturers(List manufacturers);
}

After that, I made an implementation class for the interface I just created:

ManufacturerServiceImpl.java

package com.jenanderic.service;

import java.util.List;

import com.jenanderic.domain.Manufacturer;

public class ManufacturerServiceImpl implements ManufacturerService {
	
	private List manufacturers;
	
	public List getManufacturers() {
		return manufacturers;
	}
	
	public void setManufacturers(List manufacturers) {
		this.manufacturers = manufacturers;
	}
}

Now that I have the classes that I need, I decided to make a controller class for it:

ManufacturerListController.java

package com.jenanderic.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.Model;

import java.util.Date;
import java.util.List;

import com.jenanderic.domain.Manufacturer;
import com.jenanderic.service.ManufacturerService;

@Controller
@RequestMapping("/manufacturer_list")
public class ManufacturerListController {

	private ManufacturerService manufacturerService;
	
	@RequestMapping(method = RequestMethod.GET)
	public String manufacturerList(Model model) {
		Date today = new Date();
		model.addAttribute("today", today);
		model.addAttribute("manufacturers", manufacturerService.getManufacturers());
		return "manufacturer_list";
	}
	
	public void setManufacturerService(ManufacturerService manufacturerService) {
		this.manufacturerService = manufacturerService;
	}
}

Notice the @Controller and @RequestMapping annotation. Putting the @Controller annotation in your class automatically makes it a controller class in Spring 3.0. Due to this, you don’t need to declare it in your dispatcher servlet anymore. I guess that’s pretty cool.

Oh wait, since I can’t declare the URL mapping of the controller in the dispatcher servlet, how do I inject my beans to the controller manually now? This is what my dispatcher servlet looks like right now:

Notice the part that I commented out. That’s what I would have done if I wasn’t using annotations. Unfortunately, Spring 3.0 frowns upon not using annotations.

Anyway, running the program as is would result in a null pointer exception since this method won’t be getting any bean from the dispatcher servlet:

@RequestMapping(method = RequestMethod.GET)
public String manufacturerList(Model model) {
	Date today = new Date();
	model.addAttribute("today", today);
	model.addAttribute("manufacturers", manufacturerService.getManufacturers());
	return "manufacturer_list";
}

If I use the auto-wiring feature of Spring 3.0, I guess my problem would be resolved by now, but this excerpt from the book that I’m reading is giving me second thoughts of using the auto-wiring feature:

Although the auto-wiring feature is very powerful, the cost is that it will reduce the readability of your bean configurations. Because auto-wiring is performed by Spring at runtime, you cannot derive how your beans are wired from the bean configuration file. In practice, we recommend applying autowiring only in applications whose component dependencies are not complicated.

This was taken from the book, Spring Recipes – A problem-solution approach, 2nd edition by Gary Mak, Josh Long, and Daniel Rubio.

Yes, I know. I can’t really call my application complicated yet. I guess I’m just too lazy or too stupid to fix this problem on my own right now. Either way, I lost the motivation to learn Spring as of the moment. I can’t find a good introductory resource to Spring 3.0 that’s why I’m having a hard time right now. I really hope I get accepted at the code camp that I applied for. They’re going to teach Spring there. That might be my chance to finally have a good start with Spring.

Bad start with Spring – Resolved

Terence Ponce — Sun, 06 Mar 2011 07:22:35 +0000

In my previous entry, I started to learn how to do simple CRUD operations using Spring-MVC’s JDBC feature. Unfortunately, it didn’t turn out to be as simple as I thought.

So my problem was with this unit test that was failing because it returns an empty result set:

public void testGetCompany() {
	Company company = companyDao.getCompany(1);

	assertEquals("Benjo", company.getName());
}

This is getCompany()’s logic:

public Company getCompany(int id) {
	logger.info("Getting company with id = " + id);
	Company company = getSimpleJdbcTemplate().queryForObject(
			"SELECT id, name FROM companies WHERE id = ?",
			new CompanyMapper(), id);
	return company;
}

Of course, I was certain that there was really an entry in the database with the company name, “Benjo” with the id, 1, so I couldn’t figure out where the problem is coming from.

A few days later, I got a chance to talk to my mentor. I described the problem to him as best as I can and I showed him my code as well. After a few minutes of discussion, he finally figured out where the problem was coming from.

Apparently, the problem had something to do with how I created the table in the database:

CREATE TABLE companies (
	id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
	name varchar(100) NOT NULL
);

The problem had something to do with the id field being an auto-incrementing field, but this wasn’t actually the root of the problem. There’s nothing wrong with using auto-incrementing fields. The problem was caused by how I insert values into the database:

INSERT INTO companies (name) VALUES ('Benjo');
INSERT INTO companies (name) VALUES ('Lasam');
INSERT INTO companies (name) VALUES ('Juffy');

The reason why my unit test retrieves an empty result set is because I didn’t hard code the value for id when inserting a value into the database. That’s why it can’t find “Benjo”, which supposedly should have an id of 1. After realizing that, I changed the query into this:

INSERT INTO companies (id, name) VALUES (1, 'Benjo');
INSERT INTO companies (id, name) VALUES (2, 'Lasam');
INSERT INTO companies (id, name) VALUES (3, 'Juffy');

For some reason, the previous query doesn’t assign the value of id as 1 when I let the auto-increment feature do the assigning for me. My mentor says it had something to do with the internal counter of the auto-increment feature. Honestly, I didn’t understand why that was. I don’t know how MySQL works internally. If you ask me, I don’t see anything wrong with the previous queries that I used.

Either way, my problem’s resolved already. As of now, I still can’t understand the reason behind the problem. Hopefully, I’ll be able to know about it in the future. At least I know how to deal with this kind of problem now.

Bad start with Spring

Terence Ponce — Tue, 01 Mar 2011 13:57:02 +0000

Recently, one of my good friends asked me to make a simple web application for them. Since I’ve been wanting to learn Spring for quite some time now, I decided to take on his request because I’m such a good person. Just kidding, I really just wanted to have an excuse to learn Spring.

After a few minutes of Google searching, I came across the official tutorial for Spring MVC. I noticed that the tutorial was a bit outdated and had a few errors, but I still managed to finish the tutorial in spite of that.

Now that I already did all the necessary stuff to make a simple web application in Spring, I decided to add a bit more to get started with the project that my friend asked me to do. The first thing that I tried to do was learn how to do CRUD operations in Spring. I started by making a Java bean called company:

Company.java

package gpspeedometer.domain;

import java.io.Serializable;

public class Company implements Serializable {
	private int id;
	private String name;
	
	public Company() {
	
	}
	
	public Company(String name) {
		setName(name);
	}
	
	public Company(Company company) {
		this(company.getName());
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("Name: " + name);
		return buffer.toString();
	}
	
	@Override
	public boolean equals(Object object) {
		if (object != null && object instanceof Company) {
			Company company = (Company) object;
			if (company.getId() == getId() && company.getName().equals(getName())) {
				return true;
			}
		}
		return false;
	}
	
	@Override
	public int hashCode() {
		return getId() ^ getName().hashCode();
	}
}

I’m not sure if I’ve overridden hashCode() and equals() right, but that’s not really the issue here. Since the tutorial was all about TDD, I decided to make a unit test for the bean that I just created:

CompanyTests.java

package gpspeedometer.domain;

import gpspeedometer.domain.Company;

import junit.framework.TestCase;

public class CompanyTests extends TestCase {
	private Company company;
	
	protected void setUp() throws Exception {
		company = new Company();
	}
	
	public void testGetAndSetName() {
		String testName = "random name";
		assertNull(company.getName());
		company.setName(testName);
		assertEquals(testName, company.getName());
	}
	
	public void testOverrideToString() {
		String testToString = "Name: Random";
		company.setName("Random");
		assertEquals(testToString, company.toString());
	}
	
	public void testOverrideEquals() {
		company.setId(1);
		company.setName("Lasam");
		Company company2 = new Company();
		company2.setId(1);
		company2.setName("Lasam");
		assertEquals(company.equals(company2), true);
	}
	
	public void testOverrideHashCode() {
		company.setId(1);
		company.setName("Lasam");
		Company company2 = new Company();
		company2.setId(1);
		company2.setName("Lasam");
		assertEquals(company.hashCode(), company2.hashCode());
	}
}

Of course, a test as simple as this would most likely pass. Just kidding. To be honest, I’m not really sure about the tests on hashCode and equals, but again, that’s not the issue here. After making the bean, I made an interface to do handle the bean services:

CompanyManager.java

package gpspeedometer.service;

import java.io.Serializable;
import java.util.List;

import gpspeedometer.domain.Company;
import gpspeedometer.repository.CompanyDao;

public interface CompanyManager extends Serializable {
	
	public List getCompanies();
	
	public void setCompanies(List companies);
	
	public void setCompanyDao(CompanyDao companyDao);
}

I then made an implementation class for the interface that I just made:

SimpleCompanyManager.java

package gpspeedometer.service;

import java.util.ArrayList;
import java.util.List;

import gpspeedometer.domain.Company;
import gpspeedometer.repository.CompanyDao;

public class SimpleCompanyManager implements CompanyManager {
	private CompanyDao companyDao;
	private List companies;

	public List getCompanies() {
		return companyDao.getCompanyList();
	}
	
	public void setCompanies(List companies) {
		this.companies = companies;
	}
	
	public void setCompanyDao(CompanyDao companyDao) {
		this.companyDao = companyDao;
	}
}

After that, I made a unit test for the class that I just made:

SimpleCompanyManagerTests.java

package gpspeedometer.service;

import java.util.ArrayList;
import java.util.List;

import gpspeedometer.domain.Company;
import gpspeedometer.repository.CompanyDao;
import gpspeedometer.repository.InMemoryCompanyDao;

import junit.framework.TestCase;

public class SimpleCompanyManagerTests extends TestCase {
	private SimpleCompanyManager companyManager;
	private List companies;
	
	private static int COMPANY_COUNT = 2;
	
	private static String COMPANY_ONE = "Bus Company #1";
	private static String COMPANY_TWO = "Bus Company #2";
	
	protected void setUp() throws Exception {
		companyManager = new SimpleCompanyManager();
		companies = new ArrayList();
		
		Company company = new Company();
		company.setName("Bus Company #1");
		companies.add(company);
		
		company = new Company();
		company.setName("Bus Company #2");
		companies.add(company);
		
		CompanyDao companyDao = new InMemoryCompanyDao(companies);
		companyManager.setCompanyDao(companyDao);
	}
	
	public void testGetCompaniesWithNoCompanies() {
		companyManager = new SimpleCompanyManager();
		companyManager.setCompanyDao(new InMemoryCompanyDao(null));
		assertNull(companyManager.getCompanies());
	}
	
	public void testGetCompanies() {
		List companies = companyManager.getCompanies();
		assertNotNull(companies);
		assertEquals(COMPANY_COUNT, companyManager.getCompanies().size());
		
		Company company = companies.get(0);
		assertEquals(COMPANY_ONE, company.getName());
		
		company = companies.get(1);
		assertEquals(COMPANY_TWO, company.getName());
	}
}

Well, hey, the tests passed again. Lucky me. At this point, I’m pretty sure you’re already bored reading this entry. I wouldn’t be surprised if you skipped over what I said over here. I’m feeling sad about this, so bear with me for a while. Anyway, let’s move on to the database part of the program. Again, I made another interface to handle the DAO of Company:

CompanyDao.java

package gpspeedometer.repository;

import java.util.List;

import gpspeedometer.domain.Company;

public interface CompanyDao {
	public List getCompanyList();
	
	public Company getCompany(int id);
	
	public void addCompany(Company company);
	
	public void editCompany(Company company);
}

I was on a roll until this happened. I made the implementation class for CompanyDao:

JdbcCompanyDao.java

package gpspeedometer.repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.simple.ParameterizedRowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;

import gpspeedometer.domain.Company;

public class JdbcCompanyDao extends SimpleJdbcDaoSupport implements CompanyDao {
	protected final Log logger = LogFactory.getLog(getClass());
	
	public List getCompanyList() {
		logger.info("Getting companies.");
		List companies = getSimpleJdbcTemplate().query(
				"SELECT id, name FROM companies",
				new CompanyMapper());
		return companies;
	}
	
	public Company getCompany(int id) {
		logger.info("Getting company with id = " + id);
		Company company = getSimpleJdbcTemplate().queryForObject(
				"SELECT id, name FROM companies WHERE id = ?",
				new CompanyMapper(), id);
		return company;
	}
	
	public void addCompany(Company company) {
		logger.info("Inserting company: " + company.getName());
		int count = getSimpleJdbcTemplate().update(
				"INSERT INTO companies (name) VALUES (:name)",
				new MapSqlParameterSource()
					.addValue("name", company.getName()));
		logger.info("Rows affected: " + count);
	}
	
	public void editCompany(Company company) {
		logger.info("Editing company: " + company.getName());
		int count = getSimpleJdbcTemplate().update(
				"UPDATE companies SET name = :name WHERE id = :id",
				new MapSqlParameterSource()
					.addValue("name", company.getName())
					.addValue("id", company.getId()));
		logger.info("Rows affected: " + count);
	}
	
	private static class CompanyMapper implements ParameterizedRowMapper {
		public Company mapRow(ResultSet rs, int rowNum) throws SQLException {
			Company company = new Company();
			company.setId(rs.getInt("id"));
			company.setName(rs.getString("name"));
			return company;
		}
	}
}

If you look at the code at first glance, you wouldn’t see anything wrong with it. Unfortunately, that wasn’t the case. I learned that from the unit test that I made for the previous class:

JdbcCompanyDaoTests.java

package gpspeedometer.repository;

import java.util.List;

import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;

import gpspeedometer.domain.Company;

public class JdbcCompanyDaoTests extends AbstractTransactionalDataSourceSpringContextTests {
	private CompanyDao companyDao;
	
	public void setCompanyDao(CompanyDao companyDao) {
		this.companyDao = companyDao;
	}
	
	@Override
	protected String[] getConfigLocations() {
		return new String[] {"classpath:test-context.xml"};
	}
	
	@Override
	protected void onSetUpInTransaction() throws Exception {
		super.deleteFromTables(new String[] {"companies"});
		super.executeSqlScript("file:db/load_data.sql", true);
	}
	
	public void testGetCompanyList() {
		List companies = companyDao.getCompanyList();
		
		assertEquals("Wrong number of companies?", 3, companies.size());
	}
	
	public void testGetCompany() {
		Company company = companyDao.getCompany(1);
		
		assertEquals("Benjo", company.getName());
	}
	
	public void testAddCompany() {
		Company company = new Company();
		company.setName("Ponce Inc.");
		companyDao.addCompany(company);
		
		company = companyDao.getCompany(4);
		assertEquals("Wrong name of company?", "Ponce Inc.", company.getName());
	}
	
	public void testEditCompany() {
		List companies = companyDao.getCompanyList();
		
		for (Company company : companies) {
			company.setName("Lasam Inc.");
			companyDao.editCompany(company);
		}
		
		List updatedCompanies = companyDao.getCompanyList();
		for (Company company : updatedCompanies) {
			assertEquals("Wrong name of company?", "Lasam Inc.", company.getName());
		}
	}
}

The tests failed at lines 33-37 at JdbcCompanyDaoTests.java, specifically, testGetCompany(). Here’s the error that I get from JUnit in Ant:

[junit] Testcase: testAddCompany(gpspeedometer.repository.JdbcCompanyDaoTests): Caused an ERROR
[junit] Incorrect result size: expected 1, actual 0
[junit] org.springframework.dao.EmptyResultDataAccessException: Incorrect result size: expected 1, actual 0
[junit] at org.springframework.dao.support.DataAccessUtils.requiredSingleResult(DataAccessUtils.java:71)
[junit] at org.springframework.jdbc.core.JdbcTemplate.queryForObject(JdbcTemplate.java:722)
[junit] at org.springframework.jdbc.core.simple.SimpleJdbcTemplate.queryForObject(SimpleJdbcTemplate.java:169)
[junit] at gpspeedometer.repository.JdbcCompanyDao.getCompany(JdbcCompanyDao.java:29)
[junit] at gpspeedometer.repository.JdbcCompanyDaoTests.testAddCompany(JdbcCompanyDaoTests.java:44)
[junit] at org.springframework.test.ConditionalTestCase.runBare(ConditionalTestCase.java:76)
[junit]
[junit]
[junit] Test gpspeedometer.repository.JdbcCompanyDaoTests FAILED

For some reason, the query returns nothing, which results in an empty result set. The development came to a screeching halt the moment this error appeared. The reason why this sucked is because I’m still working my way around Spring and how it works. I haven’t got a clue as to how this happened since I don’t really know what’s happening behind the scenes with my code. Let’s take a look at the faulty methods here:

public Company getCompany(int id) {
	logger.info("Getting company with id = " + id);
	Company company = getSimpleJdbcTemplate().queryForObject(
			"SELECT id, name FROM companies WHERE id = ?",
			new CompanyMapper(), id);
	return company;
}

public void testGetCompany() {
	Company company = companyDao.getCompany(1);
	
	assertEquals("Benjo", company.getName());
}

On my database, there’s a table called company that has “Benjo” as its name on the first row, so I checked if the test data really made it into the database:

@Override
protected void onSetUpInTransaction() throws Exception {
	super.deleteFromTables(new String[] {"companies"});
	super.executeSqlScript("file:db/load_data.sql", true);
}

The method loads the sql file called load_data before starting the tests. Here are its contents:

load_data.sql

INSERT INTO companies (name) VALUES ('Benjo');
INSERT INTO companies (name) VALUES ('Lasam');
INSERT INTO companies (name) VALUES ('Juffy');

If this is the case, the method, getCompany(), should be able to retrieve a row from the database, but unfortunately, that didn’t happen. It always returned an empty result set.

Since I couldn’t handle the problem by myself anymore, I turned to StackOverflow for answers. My problem is still vague for me, so I decided to ask a very generic question about my problem. My question didn’t receive any good feedback. All I got was a guy asking me why I was still using Spring 2.5 instead of 3.0, which was out of the question. Honestly, I don’t even know how that is relevant to my problem. I’m pretty sure migrating to 3.0 won’t solve my problem since I’ll most likely be writing the same code if that happens.

Anyway, since I still haven’t received any help from anyone, and I’m still clueless as to how Spring works, I decided to blog about it right now. This really made me sad because I can’t even do simple CRUD operations. What more if I needed to do something more complex? Hopefully, someone will be patient enough to read this and help me with my problem.

Inheritance in Java

Terence Ponce — Sat, 29 Jan 2011 12:16:42 +0000

DISCLAIMER: This article is a bit hard to swallow so I’ll try to explain it to you as simple as I can. I also need to mention that there are other concepts that will also be introduced in this chapter aside from Inheritance.

This is my first post for 2011, so happy new year! Anyway, as a preparation for my upcoming preliminary exam in Java, I decided to write about Inheritance in this article.

Let’s say you’re at work right now. Your boss asked you to make an application that records your company’s employees’ information.

He mentioned the things you need to record:

Name
Salary ($500 being the default salary, unless specified)
Employee Number
Department Handled (For managers only)

Since you’re already familiar with classes, you decided to start immediately by creating classes that models the employees of the company. You started by making a class for the regular employee:

Employee.java

public class Employee {
	private String name;
	private double salary;
	private int empNo;
	
	public Employee(String name, double salary, int empNo) {
		setName(name);
		setSalary(salary);
		setEmpNo(empNo);
	}
	
	public String getName() {
		return this.name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public double getSalary() {
		return this.salary;
	}
	
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	public int getEmpNo() {
		return this.empNo;
	}
	
	public void setEmpNo(int empNo) {
		this.empNo = empNo;
	}
	
	public void getDetails() {
		System.out.println("Name: " + getName());
		System.out.println("Salary: " + getSalary());
		System.out.println("EmpNo: " + getEmpNo());
	}
}

Now that you’re finished creating a class for the regular employee, you decided to make another class for the manager, since your boss specifically told you that there are 2 types of employees at the company:

Manager.java

public class Manager {
	private String name;
	private double salary;
	private int empNo;
	private String department;
	
	public Manager(String name, double salary, int empNo, String department) {
		setName(name);
		setSalary(salary);
		setEmpNo(empNo);
		setDepartment(department);
	}
	
	public String getName() {
		return this.name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public double getSalary() {
		return this.salary;
	}
	
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	public int getEmpNo() {
		return this.empNo;
	}
	
	public void setEmpNo(int empNo) {
		this.empNo = empNo;
	}
	
	public String getDepartment() {
		return this.department;
	}
	
	public void setDepartment(String department) {
		this.department = department;
	}
	
	public void getDetails() {
		System.out.println("Name: " + getName());
		System.out.println("Salary: " + getSalary());
		System.out.println("EmpNo: " + getEmpNo());
		System.out.println("Department: " + getDepartment();
	}
}

Wait, what’s this? Did you notice how similar the 2 classes are? They’re so similar, you can’t even tell how different they are at first glance (Well, aside from the file name of course). This may seem fine at first, but what if your company introduced several new types of employee? It would be pretty ridiculous to have to write almost the same thing everytime a new type of employee is introduced, right? If only there was a way to turn all those redundant code into something we can reuse so we wouldn’t have to write them every single time.

Fortunately, we can! One of the main features of Object-Oriented Programming is Inheritance. Let me quote Wikipedia on this one:

In Object-Oriented Programming (OOP), Inheritance is a way to compartmentalize and reuse code by creating collections of attributes and behaviors called objects which can be based on previously created objects. In classical inheritance where objects are defined by classes, classes can inherit other classes. The new classes, known as subclasses (or derived classes), inherit attributes and behavior of the pre-existing classes, which are referred to as superclasses (or ancestor classes). The inheritance relationships of classes gives rise to a hierarchy.

Basically, what we do with Inheritance is we make a base class (super class) that contains the most common attributes and methods among all the classes, and make other classes (sub classes), which inherits from the base class, to customize and extend the functionality of the base class into their own. We do this to prevent code redundancy and promote code reuse. Lesser code redundancy = faster, and more efficient code.

Now that we’re familiar with Inheritance, let’s try to incorporate it in our code. Based from the boss’ specifications, it’s safe to say that Employee is the super class while Manager is the sub class. Since Employee is the base class, we don’t need to modify it in any way. Manager is the one containing the redundant code so let’s modify that instead:

Manager.java Version 2

public class Manager extends Employee {
	private String department;
	
	public Manager(String name, double salary, int empNo, String department) {
		super(name, salary, empNo);
		setDepartment(department);
	}
	
	public String getDepartment() {
		return this.department;
	}
	
	public void setDepartment(String department) {
		this.department = department;
	}
	
	public void getDetails() {
		super.getDetails();
		System.out.println("Department: " + getDepartment());
	}
}

ZOMG! We just shrunk Manager.java from 52 lines down to 21. Just because this version has less lines than the previous one doesn’t mean it’s simpler. In fact, it’s so complicated, it’s hard to read… at first. Let me demistify the code one by one:

public class Manager extends Employee {

We used the word extends to make the Manager class inherit from the Employee class. This creates a relationship and a hierarchy between the two classes. It’s like saying that Manager is an Employee, but not the other way around. From this point, Manager will inherit everything from Employee, and by everything, I mean the attributes, and methods, but not the constructors.

private String department;

Noticed how we only declared one attribute here? Since Manager inherits from Employee, it already possesses all the attributes and methods from Employee, so there’s no need to declare them anymore.

public Manager(String name, double salary, int empNo, String department) {
	super(name, salary, empNo);
	setDepartment(department);
}

We made a constructor for the manager class, but this time our constructor has an additional argument, department, since managers has to handle a department in the company.

Line 2 calls the super class’ constructor, which returns the created Employee object.

Line 3 sets a value to the Manager’s department attribute using setDepartment().

After all that is done, a Manager object is now created with values for the name, salary, employee number, and department attributes.

public String getDepartment() {
	return this.department;
}

public void setDepartment(String department) {
	this.department = department;
}

As I said earlier, since Manager inherits from Employee, we only need to make a getter and setter method for department.

public void getDetails() {
	super.getDetails();
	System.out.println("Department: " + getDepartment());
}

Since I kept repeating how we don’t need to remake methods that we already made in the super class, shouldn’t this be illegal or something? Of course not! Actually, what we did here is a technique called Method Overriding. Again, let me quote Wikipedia on this one:

Method Overriding, in Object Oriented Programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super classes or parent classes. The implementation in the subclass overrides (replaces) the implementation in the super class by providing a method that has same name, same parameters or signature, and same return type as the method in the parent class. The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, or If an object of the subclass is used to invoke the method, then the version in the child class will be executed.

Since getDetails() from Employee only prints the name, salary, and the employee number, we need to override it inside the Manager class so it prints the department as well.

At line 2, we call the getDetails() method of Employee, which prints the name, salary, and employee number. After that, we print the department at line 3.

Now that we’re done creating our model classes, let’s make another class to demonstrate what we learned in this article:

public class EmployeeDemo {
	public static void main(String args[]) {
		Employee e = new Employee("Your name", 25000.00, 0001);
		Manager m = new Manager("Terence", 100000.00, 0002, "Administration");
		
		e.getDetails();
		m.getDetails();
	}
}

Isn’t it cool how I’m your boss even though you’re employee #1? Kidding aside, this will be the output of the class:

Name: Your name
Salary: 25000.00
EmpNo: 0001

Name: Terence
Salary: 100000.00
EmpNo: 0002
Department: Administration

Isn’t Inheritance neat? I’m pretty sure you still don’t have any solid idea where to use this, but by the time you’re designing a large or complex software, you’ll find that Inheritance makes a lot of things easier in a design point of view.

Code Refactoring

Terence Ponce — Wed, 15 Dec 2010 01:35:58 +0000

In the real world, you’re not a one-man team like you once were during college (because apparently, it’s cheating in your professor’s eyes). You will work with other people when developing software. If that’s the case, it’s inevitable that those other people you’re working with will also be looking at your code. Not only that, they’ll also be working with the code that you will write.

One of the things a developer must strive for is better code. What do I mean by better code? Take a look at the code you’re working on right now. If you show it to other programmers, will they be able to figure out how your code works immediately without having to look at it extensively?

Does your code have too much comments? Do most of the comments just explain the “what” and not the “why” of the code? It’s not that I have anything against using comments. I simply believe that comments should only be used to indicate why you did the following approach in writing the code to which to comment points to instead of what the code does.

Do you find yourself repeating a lot of code in your software?

Take a look at some of the codes that you made in the past. Do you still understand how everything works?

If you answered No to the first and last question and Yes to the rest of the questions, then you, dude, have bad code. It’s time to give your code a makeover a.k.a. code refactoring.

Code Refactoring, by definition of Wikipedia, is the process of changing a program’s source code without affecting its external functional behavior to improve some of the non-functional aspects of the program. You usually change it for the better.

Code Refactoring has the following benefits:

You make your code more readable to yourself and others as well.
Since it makes your code more readable, it makes your software easier to maintain and extend.
More often than not, refactoring results to lesser lines of code, so it actually saves you some bytes of memory when refactoring
It results to lesser comments in your code since the code is pretty much self-explanatory already.
It saves you from being screamed at by your fellow programmers for showing them bad code.

To further my discussion on the concept of code refactoring, let me show you a basic example of how refactoring works.

We’ll use the code that we made in my last entry. Here are both the source files we made:

Car.java

public class Car {
	private String brand;
	private String color;
	private String name;
	private int speed = 0;
	private int gear = 1;

	public String getBrand() {
		return this.brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getColor() {
		return this.color;
	}

	public void setColor(String color) {
		color = color.replaceAll("[0-9]", "");
		this.color = color;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getSpeed() {
		return this.speed;
	}

	public void setSpeed(int speed) {
		this.speed = speed;
	}

	public int getGear() {
		return this.gear;
	}

	public void setGear(int gear) {
		this.gear = gear;
	}
}

CarDemo.java

public class CarDemo {
	public static void main(String[]args) {
		Car myCar = new Car();

		myCar.setBrand("Porsche");
		myCar.setColor("White123");
		myCar.setName("911 GT3");
		myCar.setSpeed(120);
		myCar.setGear(2);

		System.out.println("The car is a " + myCar.getColor() + " " + myCar.getBrand() + " " myCar.getName() + ".");
		System.out.println("The car is runs at " + myCar.getSpeed() + " miles per hour on gear " + myCar.getGear());
	}
}

Let’s focus our attention to CarDemo.java. Look at how we invoked the Car class in this example. You first declare and instantiate an object then you have to set values to them one by one. Isn’t it too much of a hassle to create objects with this approach? I’m pretty lazy to have to write all these so it’s only natural to find a way to do them in shorthanded way.

Speaking of laziness, did I tell it’s one of the virtues of a good programmer? No, not that kind of laziness where you bum around and do nothing. Here’s the definition of laziness according to the book, ProgrammingPerl:

Laziness: The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful, and document what you wrote so you don’t have to answer so many questions about it. Hence, the first great virtue of a programmer. Also hence, this book.

Now that we know how being lazy is a good trait for a programmer, we need to do something about how we create Car objects.

Let’s say one of your co-workers, Bob, who also happens to be your team mate in the program you’re working on, wanted Car objects to have specific default values for their attributes when he creates them so he can mass produce them (Well, mass producing is a bit of an exaggeration but just go with it). He told you that he only wants to specify the brand and name of the car and he wants every car that he makes to have it’s default color set to “White”, its speed set to 0 (obviously) and its gear set to 1. How will you do this?

When we talk about creating objects, we’re talking about the constructor, specifically. Since we didn’t explicitly make a constructor for the Car class in the last entry, let’s make one for Bob:

public Car (String brand, String name) {
	setBrand(brand);
	setColor("White");
	setName(name);
}

What this constructor does is get the values of its brand and name argument and assign them to the object using its setter methods. If you looked at it closely, you’ll notice that we didn’t call the setter for speed and gear. Why? Take a look at Car.java again. We already assigned default values for the attributes, speed and gear.

private int speed = 0;
private int gear = 1;

Every instance of Car will possess these assigned values by default when you create them.

If you still remember Bob’s requirements, you’ll see that it’s exactly what he wanted. If we go to CarDemo.java right now, we can now create objects in this fashion:

Car bobsCar = new Car("Mitsubishi", "Lancer EX");

Isn’t this convenient? We can now create objects and assign values to their attributes in a single line. If we want to change them, we can just invoke the setter methods and be done with it. This will now be our new CarDemo.java:

public class CarDemo {
	public static void main(String[]args) {
		Car bobsCar = new Car("Mitsubishi", "Lancer EX");

		System.out.println("The car is a " + bobsCar.getColor() + " " + bobsCar.getBrand() + " " bobsCar.getName() + ".");
		System.out.println("The car is runs at " + bobsCar.getSpeed() + " miles per hour on gear " + bobsCar.getGear());
	}
}

This will be the output:

The car is a White Mitsubishi Lancer EX.
The car runs at 0 miles per hour on gear 1.

Will you look at that? We shrunk that long 6-liner code into just one line. See how convenient code refactoring is?

We can still shrink the main method of CarDemo.java into just 2 lines. Look at the rest of the code, did you notice how long it is to write the code to print the values of the object to the screen? Well, not really, but what if you made a million objects and you have to print all of their values to the screen? Wouldn’t that be a nightmare?

If you find yourself typing the same code multiple times, you can turn all those repeated code into methods. That way, you only have to type the code once and just call it when you need it.

Let’s cut and paste our printing code to Car.java, put it inside a method, and tweak it a little bit so it would suit our needs:

public void printInformation() {
	System.out.println("The car is a " + getColor() + " " + getBrand() + " " getName() + ".");
	System.out.println("The car is runs at " + getSpeed() + " miles per hour on gear " + getGear());
}

I’m pretty sure you’ll have a good idea of how CarDemo.java would look right now, but I’ll still show it to you:

public class CarDemo {
	public static void main(String[]args) {
		Car bobsCar = new Car("Mitsubishi", "Lancer EX");

		bobsCar.printInformation();
	}
}

We shrunk it into 2 lines (Well, 3, actually, because of the whitespace)! It will still produce the same output as last time, but now it takes less effort to do the same thing. Isn’t code refactoring wonderful? Now you will be saved from getting screamed at by your co-workers.