Home » Java » Core Java » Loan pattern in Java (a.k.a lender lendee pattern)

About Prasanna Kumar

Loan pattern in Java (a.k.a lender lendee pattern)

This post is about implementing loan pattern in Java.

Use Case

Implement separation between the code that holds resource from that of accessing it such that the accessing code doesn’t need to manage the resources. The use case mentioned holds true when we write code to read/write to a file or querying SQL / NOSQL dbs. There are certainly API’s handled this with the help of AOP. But I thought if a pattern based approach could help us to deal with these kind of use case, that’s where I came to know about Loan Pattern (a.k.a lender lendee pattern).
 

What it does

Loan pattern takes a “lending approach” i.e the code which keep hold of the resources “lends” if to the calling code. The lender (a.k.a code which holds resources) manages the resources once the lendee (code accessing the resource) has used it (with no interest ). Lets get in to lender code:

/**
 * This class is an illustration of using loan pattern(a.k.a lender-lendee pattern) 
 * @author prassee
 */
public class IOResourceLender {

	/**
	 * Interface to write data to the buffer. Clients using this
	 * class should provide impl of this interface 
	 * @author sysadmin
	 *
	 */
	public interface WriteBlock {
		void call(BufferedWriter writer) throws IOException;
	}

	/**
	 * Interface to read data from the buffer. Clients using this
	 * class should provide impl of this interface
	 * @author sysadmin
	 *
	 */
	public interface ReadBlock {
		void call(BufferedReader reader) throws IOException;
	}

	/**
	 * method which loans / lends the resource. Here {@link FileWriter} is the 
	 * resource lent. The resource is managed for the given impl of {@link WriteBlock}
	 *  
	 * @param fileName
	 * @param block
	 * @throws IOException
	 */
	public static void writeUsing(String fileName, WriteBlock block)
			throws IOException {
		File csvFile = new File(fileName);
		if (!csvFile.exists()) {
			csvFile.createNewFile();
		}
		FileWriter fw = new FileWriter(csvFile.getAbsoluteFile(), true);
		BufferedWriter bufferedWriter = new BufferedWriter(fw);
		block.call(bufferedWriter);
		bufferedWriter.close();
	}

	/**
	 * method which loans / lends the resource. Here {@link FileReader} is the 
	 * resource lent. The resource is managed for 
	 * the given impl of {@link ReadBlock}
	 *  
	 * @param fileName
	 * @param block
	 * @throws IOException
	 */
	public static void readUsing(String fileName, ReadBlock block)
			throws IOException {
		File inputFile = new File(fileName);
		FileReader fileReader = new FileReader(inputFile.getAbsoluteFile());
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		block.call(bufferedReader);
		bufferedReader.close();
	}
}

The lender code holds a FileWriter, the resource and we also expect an implementation of WriteBlock so that writeUsing method just calls the method on the WriteBlock interface which is enclosed within the managing the resource. One the client(lendee) side we provide an anonymous implementation of WriteBlock. Here is the lendee code, Iam just giving an method its up to the you to use it in the class which you may like.

public void writeColumnNameToMetaFile(final String attrName,
			String fileName, final String[] colNames) throws IOException {
		IOResourceLender.writeUsing(fileName,
				new IOResourceLender.WriteBlock() {
					public void call(BufferedWriter out) throws IOException {
						StringBuilder buffer = new StringBuilder();
						for (String string : colNames) {
							buffer.append(string);
							buffer.append(',');
						}
						out.append(attrName + ' = ' + buffer.toString());
						out.newLine();
					}
				});
	}

The example uses the loan pattern for a simple file IO operation. However this code could be further improved by providing abstract lenders and lendee.The code for this post is shared in the following gist https://gist.github.com/4481190 I welcome your comments and suggestions !!
 

Reference: Loan pattern in Java (a.k.a lender lendee pattern) from our JCG partner Prasanna Kumar at the Prassee on Scala blog.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

 

2 comments

  1. Christian Schlichtherle

    Note that you must close the streams in a finally-block, otherwise a file descriptor remains open if the Block.call() fails. In a long running server app, this may exhaust the OS resources and trigger a grinding halt.

  2. I usually use this pattern,but I never call “Loan pattern” and I don’t even call it what!

Leave a Reply

Your email address will not be published. Required fields are marked *

*


eight × 3 =

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Want to take your Java Skills to the next level?
Grab our programming books for FREE!
  • Save time by leveraging our field-tested solutions to common problems.
  • The books cover a wide range of topics, from JPA and JUnit, to JMeter and Android.
  • Each book comes as a standalone guide (with source code provided), so that you use it as reference.
Last Step ...

Where should we send the free eBooks?

Good Work!
To download the books, please verify your email address by following the instructions found on the email we just sent you.