Tutorial

In this tutorial we will walk through examples of the most common features of Mockito. My sample project can be downloaded here.

Interfaces and Implementation

Some mocking frameworks only supported mocking interfaces. As a result our projects became bloated with useless interfaces that were only used for testing.  Mockito creates mock objects with interfaces or classes.


interface Person{
List getChildren();
Boolean isCitizen();
Integer getAge();
Map getSchedule();
void haveChild();
}


class PersonImpl implements Person{
public List getChildren() { return null; }
public Boolean isCitizen() { return null; }
public Integer getAge() { return null; }
public Map getSchedule() { return null; }
public void haveChild() { }
}



assertNotNull(Mockito.mock(Person.class));
assertNotNull(Mockito.mock(PersonImpl.class));


Default Values

Mockito provides stub implementations for all of the methods on the interface/class. It also provides several common sense defaults out of the box.


Person mockPerson = Mockito.mock(PersonImpl.class);
assertNotNull(mockPerson.getChildren());
assertEquals(0, mockPerson.getChildren().size());
assertFalse(mockPerson.isCitizen());
assertEquals(new Integer(0), mockPerson.getAge());
assertNotNull(mockPerson.getSchedule());

Mockito returns empty Lists and Maps to prevent NPE’s in your test code. It defaults to false for Boolean return values. By default Zero is returned for Integer, Long and Double. Notice that even though PersonImpl returns null for all of its methods the Mockito version returns reasonable default values.

Changing Behavior


Person mockPerson = mock(PersonImpl.class);
Mockito.when(mockPerson.getAge()).thenReturn(35);
assertEquals(new Integer(35), mockPerson.getAge());


Mockito.when() takes a mock and a method call that returns a value. Mockito’s thenReturn() method takes the return value that Mockito will provide to all matching calls. By default the method getAge() returns Zero, within Mockito, but now it returns 35. This ability to control behavior is the key to testing functionality in isolation.

Verifying Method Calls


Person mockPerson = Mockito.mock(PersonImpl.class);
mockPerson.getAge();
Mockito.verify(mockPerson).getAge();


Mockito.verify() takes a mock object and verifies that the following method is called.


Person mockPerson = Mockito.mock(PersonImpl.class);
mockPerson.getAge();
mockPerson.getAge();
Mockito.verify(mockPerson, Mockito.times(2)).getAge();


This is the same verify as before except a second parameter is passed to the verify() method telling it how many times the trailing method should be called.


Person mockPerson = Mockito.mock(PersonImpl.class);
mockPerson.getAge();
mockPerson.getAge();
Mockito.verify(mockPerson, Mockito.atLeastOnce()).getAge();


Sometimes it is not important how many times a method is called as long as it is called at least once. Mockito.atLeastOnce() method provides this flexibility.

No More Interactions


Person mockPerson = Mockito.mock(PersonImpl.class);
mockPerson.getAge();
Mockito.verify(mockPerson).getAge();
Mockito.verifyNoMoreInteractions(mockPerson);


Mockito.verifyNoMoreInteractions() ensures that no other methods have been called on the PersonImpl class. Since Mockito is very helpful in stubbing out all of the methods for a class or interface there is no control over which methods have been called. Only methods that have been explicitly verified are checked for specific calls.

Throw Exception


@Test(expected = RuntimeException.class)
public void testThenThrow(){
Person mockPerson = Mockito.mock(PersonImpl.class);
Mockito.when(mockPerson.getAge()).thenThrow(new RuntimeException("test exception"));
mockPerson.getAge();
}


The thenThrow() method prepares the method defined in when() to throw an Exception. While I am not attempting to provide a tutorial on JUnit4 features, I feel it necessary to point out the Annotation verifies that a RuntimeException is thrown in the test.


@Test(expected = RuntimeException.class)
public void testDoThrow(){
Person mockPerson = Mockito.mock(PersonImpl.class);
Mockito.doThrow(new RuntimeException("test exception")).when(mockPerson).haveChild();
mockPerson.haveChild();
}


The doThrow() syntax is necessary to throw an Exception for a void method. The previous example threw an exception for Person.getAge() which is not a void method. In this example Person.haveChild() is void and requires this alternate syntax in order to compile.

TDD with Mockito

Let’s drive a small class that we will call Bouncer.  This class will check if a Person is old enough to drink.  First let’s write a test.


@Test
public void testCheckAgeOf_UnderAge(){
Person mockPerson = Mockito.mock(PersonImpl.class);
Mockito.when(mockPerson.getAge()).thenReturn(20);
Bouncer bouncer = new Bouncer();
assertFalse(bouncer.checkAgeOf(mockPerson));
}


Of coarse this does not even compile. We need to create a Bouncer class with the checkAgeOf() method. And here is the amazing class


class Bouncer{
public boolean checkAgeOf(Person customer){
return false;
}
}


So why did I return false. Well the test does not require anything more than this to pass. TDD is about doing the simplest thing that works and then refactor the code. This is the simplest thing that works. Now let’s write another test.


@Test
public void testCheckAgeOf_OfAge(){
Person mockPerson = Mockito.mock(PersonImpl.class);
Mockito.when(mockPerson.getAge()).thenReturn(21);
Bouncer bouncer = new Bouncer();
assertTrue(bouncer.checkAgeOf(mockPerson));
}


Now we need real business logic in our method.


return customer.getAge() >= 21;


Green again. Now it is time to refactor. In this simple case I am not sure how to simplify the code. There are a few more tests that should be written. A test if getAge() returns null and if Person is null and other boundary cases. Since the focus of this article is on Mockito I will stop here.

Mockito is a powerful mocking framework that simplifies the creation and usage of mock objects. I encourage you to download my sample code and continue to explore the Mockito framework.

Time and time again, I have uncovered issues that have been ignored and/or hidden by exploring “over reactions”.  They are indicators that there is more to the story.  For example, one of teams that I was leading was very frustrated with how much time we were spending estimating stories.  Their frustration eventually culminated in some of the team members refusing to participate in team estimation meetings.  As you can imagine this created significant tension between the developers and the business team.

While some teams do take too long to estimate, this team generally spent less than 1 percent of their month estimating cards.  With this unequal and opposite reaction focusing my attention I began to interview team members one-on-one.  These conversations confirmed that there was a problem, but failed to adequately explain why.

At this point I approached the Project Lead and requested that we all sit down and discuss the estimation process.  At the conclusion of this meeting two things were clear.  First, the development team did not trust the business team’s motivations for gathering estimates.  Second, they did not feel like decision makers were adjusting their expectations based on the estimates that they received.

This conversation helped both sides understand each other.  While this was not a magical cure, it did realign the action of estimating and the team’s reactions.  This may still seem like it was not worth addressing.

On the contrary, exaggerated emotional investment can be a significant source of waste.  This type of waste is often expressed through frustrations, confusion, fear, and/or apathy.  Individual opinions spread throughout teams and become a significant source of waste.  The only way to reduce this waste is to understand the root causes.  I do not have a perfect approach to efficiently identify these sources.  In my experience it takes patience and persistence to uncover the truth.

These principles also apply to under reactions.  Some teams that have lost hope will withdraw.  The under reactions that will follow are just as important to address as over reactions.  Remember to pay attention to wheels that are abnormally quiet while you are oiling squeaky wheels.

As technical people we often shy away from feelings, however like it or not our teams are made up of people.  People that have feelings that are formed by their experiences and perceptions.  Ultimately people want to be heard and understood.  Once this occurs, teams tend to realign their reactions.

Most Windows 7 computers come with PowerShell and all the necessary dependencies already installed, so I never actually had to install it, but from what I’ve read the setup is fairly simple – you just sort of install it.  You also get a little IDE called Powershell ISE which is basically just your standard, 3-pane scripting IDE (with a command-line interpreter in one pane, the output in another, and a third pane for writing and saving scripts.)

I tried my standard approach of consulting forums and the MSDN library for a little while but it seemed most of the documentation I could find was either circular and self-referencing or written by some rabid Microsoft fanatic who was so hopelessly drunk on the M$ Kool-Aid that every other word they wrote was some special Microsoft technology or practice. After about a half hour of reading online documentation, all that I really learned was that commands in PowerShell are called “cmdlets.” It’s not clear what the distinction is between a cmdlet and your standard Bash command in Linux, but I guess I’ve seen more pathetic cries for attention in the Windows world than this.

Slightly dismayed at my lack of progress in learning much from my usual way, I considered the much suggested get-help cmdlet…

UGH Ok, I’m just going to stop right here, I can’t make it any further calling these things “cmdlets.” Call me stubborn, or close-minded, but this is just ridiculous. I’m calling them “commands.”

…Anyways, silly nomenclature aside, this get-help command is kind of like a “man” page to a Linux user, it displays the syntax, description, and examples for any command in PowerShell. The get-help command is in some ways even a little more clever than man pages. For instance, I needed to know how to create a new directory so first thing I tried was get-help mkdir. While mkdir is not a command in PowerShell, nor does it even have a directly analogous single-command counterpart in PowerShell, it recognized what I was asking for and brought me to the page for the New-Item command which has a -type directory flag you can use to make a new directory. With this command, I was able to learn anything I needed to learn to make my script happen.

There were, of course, a few more bumps in the road, but nothing too serious; string manipulation is distinctly different from most other languages, and there was some difficulty in getting the permissions (or execution-policy) just right so that I could actually run the script. All-in-all, it took me about four hours to get the environment set up, learn enough of the language to be productive, and finally write and test the script I needed. Despite the handicap that it is a Microsoft-specific product, Powershell sincerely surprised me by being a fairly easy-to-learn and useful scripting language. I really only got to use a very small part of the language, but nonetheless, I would recommend Powershell to anyone who needs to write a script in Windows but cannot use Cygwin.

Space efficiency is given as amount of storage space available in an array of n disks, in multiples of the capacity of a single drive. For example if an array holds n=5 drives of 250GB and efficiency is n-1 then available space is 4 times 250GB or roughly 1TB.

The space efficiency of RAID5 is n-1 and the fault tolerance allows for one disk to go down at a time.  What this means is that if you have a RAID5 array set up, you lose one of your disk’s worth of space in the array, yet if any one of the disks in the array goes down, you do not lose any data.  Compared to something like RAID1 which simply mirrors all data so that what is stored on one disk is also stored on another, RAID5 has a much better space efficiency.

Now if you’re like me, you probably wondered, “How the hell is RAID5 possible? Where do they fit the data? If you back up data, shouldn’t it all be duplicated somewhere? How is it possible to have space efficiency less than 1/2 n?  Isn’t there some conservation of mass law that prevents such a preposterously awesome thing from happening?”   To understand the answer to the question, we have to look at the bitwise level of RAID5, or how the data is really stored in 1’s and 0’s. And this, my friend, is where the mysterious and beautiful Exclusive Or (XOR) operator comes in.

Many of you are familiar with AND and OR operators, AND only evaluates to true when both inputs are true, while OR only evaluates to false when both inputs are false.  The mathematical miscreant we know as “XOR” only evaluates to true when both of its inputs are opposite.  So, to quickly summarize the XOR function, take a look at the following truth table:

An Exclusive Or Truth Table

Got it? Good.

XOR has a few other interesting properties as well, the most important of which is that it is reversible.  That is, if you XOR A and B to get result C, then you can get A back by doing B XOR C, or get B back by doing A XOR C.  This can be extended so that if you do (A XOR B) XOR C = D, then you can do the same thing to get back any of the data stored in A, B, or C, by applying the exclusive or operator to D and the other two inputs.  Don’t believe me? Let’s do an example:

Let’s say A = 0010, B = 0101, and C = 1100.  So D would be equal to the XOR of all three:

  (A XOR B XOR C)
= (0010 XOR 0101) XOR C
= 0111 XOR C
= 0111 XOR 1100
= 1101
= D

So now if for some reason we lost one of the inputs, (A, B, or C), we can use D and two of the other inputs to get that one back.   So let’s say we lose B, we can get the data it contained back by XOR-ing the other three parts together:

  A XOR C XOR D
= 0010 XOR 1100 XOR D
= 1110 XOR 1011
= 0101
= B

Did I just blow your mind?  Some people call it “math.”  Others call it “logic.”  I call it like I see it and that XOR is straight up witchcraft.

Well all fantasy aside, the above example has some very practical applications for data storage. RAID5 uses this unique property of XOR to sort of stack data on top of each other into a storage unit called the “parity block” or “parity drive” (datum D in the example above would be considered the parity datum.) But the concept of RAID5 is a little more complicated than just abstracting the A, B, C, and D example from above to apply to whole drives instead of just 4-bit numbers.  RAID5 uses something called “striping” to store data. Each drive in a RAID5 array is “striped” into parts so that when you store data, you store it across all the drives in the array.  The concept of “striping” is probably best described the aid of the following picture:

4 - Disk Array in RAID5 format

Each of the four drives in the picture above is divided into four blocks, each belonging to a stripe on the same level across each drive.  Each drive and each stripe have a parity block which is the XOR of the other three blocks. In the picture this is denoted by the subscript “p.” The fault tolerance for this set up with striping works just like the example above but repeated for every stripe.  So say you lost drive 3, you would XOR A₁ with A₂ and A_p to get the remaining A₃ for the A stripe, B₁ with B₂ and B₃ to get your parity block, and then the same with C and D to get those bits of data back.

And that, in short, is how RAID5 works.

Sources:

http://en.wikipedia.org/wiki/RAID

http://www.scottklarr.com/topic/23/how-raid-5-really-works/

The Download
When I bought this machine it had a fresh install of Windows XP and came with the recovery disk which was excellent because I had to use it multiple times before I got things just the way I wanted them. Since this computer didn’t have any files I didn’t have to worry about backing anything up but it would be a must if considering putting Ubuntu on an everyday machine. To install Ubuntu you need the install CD. Ubuntu community can mail you one if you so request online, but why not be a DIYer and burn it yourself? I downloaded the Ubuntu 9.10 Desktop version for a graphical install and then went straight to burning it onto a CD. This was a mistake. I didn’t figure that the piece of the installation instructions regarding running the checksum was all that important, but it absolutely is. If the download is the least bit wrong the installation will not work. I burned several CDs of a bad image. Eventually I followed the installation documentation more closely and actually downloaded winMd5Sum. With this free tool I was able to compare the checksum of the downloaded image with the correct checksum from the Ubuntu site. It took several attempts and switching to a Canadian mirror before getting a successful download. Finally I could burn it to a disc.

Burning the Disc
The download comes as an image with an “.iso” extension. I had never burned an image before so I followed the Ubuntu advice to download the free Infra Recorder. The actual burning of the image to the disc couldn’t have been easier. Following the Ubuntu instructions I quickly had an Ubuntu install disc. I inserted it into my computer and restarted it so it could boot from the disc and headed straight to the install options. Here is where I went wrong for the second time by skipping a small part of the install instructions. Instead of using the “Install” option on the disc I should have first chose, “Check the disc for defects.” After a few failed installs and a bunch of wasted time, choosing the “Check for defects” option finally revealed that while my download was successful, my burn did not translate to the disc just right. Burning another disc or two finally yielded some successful results.

Installing
There are many ways to install Ubuntu. It can be installed as the sole operating system on the computer, as a virtual OS inside of Windows, or even as a side-by-side dual boot with Windows. I was attempting the latter. When trying to achieve a dual boot installation the hard drive must be partitioned so that each OS can reside in its own territory. With Windows on the machine I first dabbled in the computer management menu to try to clear space for Ubuntu, but then while installing it was difficult to interpret the partitioning. My solution was to reformat the hard drive so that Windows again occupied the whole hard drive and then use the installer disc to set up the partitions. I think this is the best option because you get a very good visual of how your hard drive is split up and you’ll have to go through the setup menu anyway so it saves you time from toiling in a Windows configuration. Other items in the installation process are very easy such as choosing language, naming the computer and setting up a user account. With the install completed, the next time the computer starts there will be a choice to start Ubuntu or Windows which is the whole idea of a dual-booting system.

In Conclusion
Installing Ubuntu, especially in a dual-boot situation, can be a daunting task. Although my experience exemplified Murphy’s Law it is a very do-able process. Looking back, I could have saved a ton of time had I followed the online instructions more carefully and verified the download and burn of the image. Bottom line though is that the instructions and documentation are great resources and there are plenty of forums and YouTube videos also documenting the process. With the volume of help out there I wouldn’t worry about lacking experience like myself, just jump in, read up and take your time.

ALTER sequence MY_SEQ increment BY 500;
SELECT MY_SEQ.NEXTVAL FROM dual;
ALTER sequence MY_SEQ increment BY 1;

What do you do if you don’t have the correct permissions to do this? You can always call up the dba and ask him. If you’re impatient, you can also do a little pl/sql programming to accomplish the same thing. All you want to do is just repeatedly select the next value until the sequence value is higher that the current key value.

DECLARE
  current_value NUMBER;
  seq_val NUMBER;
BEGIN
  SELECT MAX(MY_TABLE.id) INTO current_val FROM MY_TABLE;
  WHILE current_val >= seq_val
  LOOP
    SELECT MY_SEQ.NEXTVAL INTO seq_val FROM dual;
  END LOOP;
END;

Of course, if you encounter this situation once, chances are that you will encounter it many times. Next, you can create a function that takes the table name, key column name, and sequence name and then executes dynamically created sql to fix the problem.

CREATE OR REPLACE PROCEDURE INCREMENT_SEQ(IN TABLE_NAME, IN ID_COLUMN_NAME, IN SEQUENCE_NAME) IS
DECLARE
  current_value NUMBER;
  seq_val NUMBER := -1;
BEGIN
  EXECUTE IMMEDIATE 'select max(' || TABLE_NAME || '.' || ID_COLUMN_NAME || ') into current value from ' || TABLE_NAME;
  WHILE current_val >= seq_val
  LOOP
    EXECUTE IMMEDIATE 'select ' || SEQUENCE_NAME || ".nextval into seq_val from dual';
  end loop;
END INCREMENT_SEQ;

Now, you should be able to fix any sequence/key mismatches simply by calling the procedure.

INCREMENT_SEQ('MY_TABLE', 'ID', 'MY_SEQ');

How does it work?
The Data Export API provides read-only access to all available analytics data. Any data that is displayed in the analytics web interface can be accessed through this API. Nice isn’t it? You can get all your analytics data, for all your monitored websites and use it as you please.

Getting started
To get started basically you need very little — a valid Google Analytics account and a client that would do all the low level work(sending HTTP requests with corresponding headers) or you could write your own small client that fits your needs. For example you could write shell scripts that use cURL under the hood. Anyway, it doesn’t matter, the important thing here is to find a good way to communicate with the Google Analytics servers.

At this point, Google offers 2 solutions: a Java and a JavaScript client. Both are easy to use, but may not fit your needs. That’s why there are also other similar clients in different languages like PHP, Perl, and Ruby.

The entire process of getting Google Analytics data and doing something useful with it can be split into 3 steps:

• Authorization
• Data feed
• Parse XML feed and perform your computations.

In Part 2 I’ll describe several ways of authorizations and when you would use each. But before that I’d like to mention some limitations. Basically Google has several quota policies, which currently are:

• 10,000 requests per 24 hours (this limit applies to a single web resource)
• 10 requests in any given 1-second period (this limit applies across all queries an application makes to the API)
• 4 pending requests at any given time. Be advised that this limit is new and is subject to change
• A query is also limited to pagination limits of 10,000 entries per feed, with a default response of 1,000 entries

Stay tuned!

The goal: scalable reads with MySQL in master-slave configuration, writing to the master, and reading from N slaves, load balanced in round-robin fashion (or something).

The problem: using JPA (Java Persistence API) instead of direct JDBC calls. Turns out the MySQL ReplicationDriver (used to load balance reads to slaves and send writes to the master) relies on the readOnly state of the Connection in order to decide whether it’s a read or a write. With direct JDBC calls, I could get the Connection and toggle the readOnly state as needed.

However, buried under JPA and EntityManager and so on, there’s no way to do that. So I looked into other solutions (LBPool, for instance), but nothing out there seems to be intended for JPA environment.

So I had to do it myself… in digging around in the MySQL Connector/J source, I discovered the loadbalance option, intended for use w/ MySQL Cluster, because in that environment, you don’t need to distinguish between master and slave, they’re all just nodes.

The loadbalance option wouldn’t work directly for me, of course, because I don’t want to load balance writes, just reads.

Soulution to the problem is to use two data sources, one for reads, and the other for writes, I can stick the read data source behind all my “fetch stuff” APIs, and use the write data source for everything else. Then I can use the loadbalance option for the read data source, because I know for certain I’m never sending it any writes.

I am currently using Jboss 4.2.1 GA here my mysql-ds.xml

<datasources>
  <no-tx-datasource>
    <jndi-name>MasterA</jndi-name>
    <connection-url>jdbc:mysql://masterDB/databasename</connection-url>
    <driver-class>com.mysql.jdbc.ReplicationDriver</driver-class>
    <user-name>username</user-name>
    <password>password</password>
    <min-pool-size>10</min-pool-size>
    <!-- Don't set this any higher than max_connections on your
         MySQL server, usually this should be a 10 or a few 10's
         of connections, not hundreds or thousands -->
    <max-pool-size>50</max-pool-size>
    <idle-timeout-minutes>10</idle-timeout-minutes>
    <exception-sorter-class-name>com.mysql.jdbc.integration.jboss.ExtendedMysqlExceptionSorter</exception-sorter-class-name>
    <valid-connection-checker-class-name>com.mysql.jdbc.integration.jboss.MysqlValidConnectionChecker</valid-connection-checker-class-name>
    <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml -->
    <metadata>
      <type-mapping>mySQL</type-mapping>
    </metadata>
  </no-tx-datasource>
  <no-tx-datasource>
    <jndi-name>SlaveA</jndi-name>
    <connection-url>jdbc:mysql://slaveA,slaveB/databasename</connection-url>
    <driver-class>com.mysql.jdbc.ReplicationDriver</driver-class>
    <user-name>username</user-name>
    <password>password</password>
    <min-pool-size>10</min-pool-size>
    <!-- Don't set this any higher than max_connections on your
         MySQL server, usually this should be a 10 or a few 10's
         of connections, not hundreds or thousands -->
    <max-pool-size>50</max-pool-size>
    <idle-timeout-minutes>10</idle-timeout-minutes>
    <exception-sorter-class-name>com.mysql.jdbc.integration.jboss.ExtendedMysqlExceptionSorter</exception-sorter-class-name>
    <valid-connection-checker-class-name>com.mysql.jdbc.integration.jboss.MysqlValidConnectionChecker</valid-connection-checker-class-name>
    <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml -->
    <metadata>
      <type-mapping>mySQL</type-mapping>
    </metadata>
  </no-tx-datasource>
</datasources>

Persistence.xml for the JTA datasources.

<?xml version="1.0" encoding="UTF-8"?>
			<persistence version="1.0"
	xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd">
<persistence-unit name="Master">
	<provider>org.hibernate.ejb.HibernatePersistence</provider>
	<jta-data-source>
		java:/MasterA
	</jta-data-source>
	<properties>
		<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />			
		<property name="hibernate.connection.readOnly" value="true" /> 	</properties>
</persistence-unit>
<persistence-unit name="Slave">
	<provider>org.hibernate.ejb.HibernatePersistence</provider>
	<jta-data-source>
		java:/SlaveA
	</jta-data-source>
	<properties>
		<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />			
		<property name="hibernate.connection.readOnly" value="true" /> 	
</properties>
</persistence-unit>
</persistence>

For normal JDBC connections read only state can changed like the following code.

public static void main(String[] args) throws Exception {
    ReplicationDriver driver = new ReplicationDriver();
 
    Properties props = new Properties();
 
    // We want this for failover on the slaves
    props.put("autoReconnect", "true");
 
    // We want to load balance between the slaves
    props.put("roundRobinLoadBalance", "true");
 
    props.put("user", "user");
    props.put("password", "password");
 
    //
    // Looks like a normal MySQL JDBC url, with a
    // comma-separated list of hosts, the first
    // being the 'master', the rest being any number
    // of slaves that the driver will load balance against
    //
 
    Connection conn =
        driver.connect("jdbc:mysql:replication://master,slave1,slave2,slave3/databasename",
            props);
 
    //
    // Perform read/write work on the master
    // by setting the read-only flag to "false"
    //
 
    conn.setReadOnly(false);
    conn.setAutoCommit(false);
    conn.createStatement().executeUpdate("UPDATE some_table ....");
    conn.commit();
 
    //
    // Now, do a query from a slave, the driver automatically picks one
    // from the list
    //
 
    conn.setReadOnly(true);
 
    ResultSet rs =
      conn.createStatement().executeQuery("SELECT a,b FROM alt_table");
 
     .......
  }

Conculsion:
Thus with the help of two data sources I am able to replicate the functionality of Master/Slave Read scalability. If you are using the normal JDBC connection then changing the read-only is as simple as the above code. Hope this will be helpful for someone who needs to setup Replication in the code level.

How to accomplish load balancing?
Load balancing can be accomplished through software but is usually achieved with the help of a dedicated hardware appliance due to the speed requirements. A load balancer can use many different algorithms. The most basic method is round-robin, which sends a request to each server in the cluster successively. More sophisticated techniques make decisions based on CPU usage, number of requests queued, average response time or even number of lost packets. One problem with load balancing is that a user’s session is likely not replicated across the the whole server cluster so typically a single user’s requests will be “sticky” and always be routed to the same backend server.

Another, more global, method of load balancing is Anycast. Anycast is an addressing strategy often used in DNS where hosts in multiple geographical locations represent the same IP address. This balances workload because any request is routed to the closest host (as determined by the routing protocol). In the event of one of the hosts going offline the request is then routed to the next closest available host. Routing requests to the nearest host has the added benefits of increasing response time and reliability.

Why load balance?
Simply put, work gets done more efficiently when resources are not used to their capacity and as a result user response times are generally better. The best reason, however, is often times failover. Failover refers to the ability of a system to remain operational while one or more components have failed or gone down. Say your clumsy friend trips over a power cord, eliminating one of three nodes in a cluster hosting a website. People opening a new connection to your website will not notice because the load balancer will realize that the one node is not responding and will route all requests to the other two nodes until the first one is responsive again. The only users who might notice would have been sticky to that one node. Failover is also useful for maintenance. If something has to be upgraded across all nodes, then one node can be taken down at a time to be upgraded without any downtime for whatever service the cluster may be hosting.

Load balancing and failover are powerful concepts which allow network administrators to have some peace of mind and users to keep on working.

1. Musings of a SpringOne 2009 Attendee Day 1
2. Musings of a SpringOne 2009 Attendee Day 2
3. Musings of a SpringOne 2009 Attendee Day 3

Read on for day 4.

OSGi and Groovy Jump Start

The presentation started with a 5 minute youtube video preview which I thought was pretty innovative.

The first half was around what is OSGi, some of which I’ve had experience with. I did pick up on a few key concepts that I didn’t know i wasn’t communicating earlier in my own presentations on OSGi.

We covered how a groovy POGO has groovy types in the public API. So if your groovy bundle has the groovylib in it’s classpath then it has to export the groovy package. Also when using Groovy in OSGi, if possible use POJOs for your applications type system since POGOs force you to expose couple groovy types in the bundle’s API.

The examples were done using gradle and this was my first live example of using gradle. This is a key benefit of conferences — being exposed to technologies you may otherwise not have the time to take a peek at.

I liked how the presenter took the path of not making things look complex but rather simplifying the concepts. He did this with concepts such as the OSGi bundle lifecycle.

Some of the tools covered in this session were:

• bnd to create a groovy manifest
• osgi bundle for gradle uses bnd
• junit4osgi

Expand your business with Groovy – Case Study

This session was a case study on how a monolithic application was extended to provide customizations using groovy. A major customer had approached HypericQ wanting a custom dashboard.

HypericQ developed a architecture around attach point’s which are places within the UI where plugins can connect to.

Custom UI was provided by gsp templates for customer specific dashboards.

Groovy templates was used as the templating framework that allowed clients to build their own using GSP pages.

A Web Services API was provided as part of the core platform that enabled several benefits:
- hqapi command line interaction
- allows integration testing of the application
- embedding a groovy console inside the application
- console gives you a HQL way to query the domain and not worry about the end customers database environment

The talk was an interesting exercise in how a dynamic plugin architecture could be implemented. Groovy categories was heavily used to enable this.

Re-factoring a Spring Application for SOA using Spring technologies in 40 min

The current focus of SOA is really software architecture. SOA is neither static nor predictable. The architectural pattern of any application must be reflective of the business. SOA is preparing the stuff that is critical to your business to stand the test of time.

Architecture involves the courage to be wrong while minimizing the impact of being wrong. It is about making educated decisions between speed and perfection. The longer it takes to deliver the software the higher the client’s expectations of that software is.

The foundation of SOA is highly cohesive, loosely coupled modules. One must practice

1. strategy first programming
2. process life-cycle dynamics
3. process collaboration
4. loose coupling promotes a network based architecture over a hierarchical one – composition over inheritance

SOA and OSGi enable embracing change by making versioning a runtime concept.

There is an argument to be made for deploying a process as a whole in BPEL. But what about flexible orchestration via simple messaging. We were given the American football analogy. Each play is scripted, but between plays we need to adjust strategy to meet the overall goal.

Modern event driven architecture was mentioned as a composite process linked together in a linear fashion through the use of rule based pathing.

The second half of this talk was the Spring booking demo from Spring Web Flow project. There are 3 OSGi bundles:

1. war bundle
2. service bundle
3. datasource bundle

The demo was using STS and it’s DM Server tooling. The entire development workflow was very seamless with SpringSource having done an awesome job of the tooling.

We saw an example of a transparent failover. So there is a need to take down the primary database for maintenance work without taking the application down. A backup datasource bundle is started and the primary datasource bundle is stopped. The datasource bundle is a simple datasource definition and an osgi service with ranking. Because of a higher rank the backup datasource bundle takes precendence and the primary datasource bundle can be safely stopped. Bundles can also take advantage of filtering besides ranking.

Spring Integration builds on pipes and filters. You can expose OSGi services as pipes. It provides the ability to change the behavior of a modularized application by changing how the modules are hooked up in the XML as opposed to modifying source code or in cases where the source code is not available.

Conference Wrap Up

Here are my key take aways:

• It is time for Grails
• Need to investigate Spring Faces
• Webgoat
• Spring Web Flow
• Spring Integration
• Spring DM Server

Overall it was a very productive conference and I would recommend it for anyone looking to attend it next year.