On preferring the use of getters over direct field access

You often find advice that says you should prefer getters over directly using a field. Fowler terms this SelfEncapsulation. I've sometimes thought this is a bit abstract and a case of over-engineering...but today I found a good reason why it's necessary. Consider the following code:

	import java.io.BufferedReader;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.nio.charset.StandardCharsets;
	import java.nio.file.Path;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import java.util.stream.Collectors;
	import java.util.zip.GZIPInputStream;
	import java.util.zip.GZIPOutputStream;
	/**
	* Appends the entry to the file as GZipped.
	*/
	final class AppendEntryAsGZip<P> extends WriteToFileTask<P> {
	/**
	* A log.
	*/
	private static final Logger LOG = Logger.getLogger(AppendEntryAsGZip.class.getName());
	/**
	* constructs the task.
	*
	* @param entry should not be null
	* @param toFile should not be null
	*/
	AppendEntryAsGZip(final P entry, final Path toFile) {
	super(entry, toFile);
	}
	@Override
	protected void writeEntryToFile(final Path toFile, final P entry) throws IOException {
	final StringBuilder sb = new StringBuilder();
	sb.append(slurpGZippedFile(toFile));
	sb.append(entry.toString());
	writeOutGZippedFile(toFile, sb.toString());
	}
	/**
	* reads in a GZipped file.
	* @param toFile the file to be read
	* @return the lines of the file
	* @throws IOException if something goes wrong
	*/
	private String slurpGZippedFile(final Path toFile) throws IOException {
	if (toFile.toFile().length() == 0) {
	return "";
	}
	try (final FileInputStream fis = new FileInputStream(toFile.toFile());
	final GZIPInputStream gis = new GZIPInputStream(fis);
	final BufferedReader br = new BufferedReader(new InputStreamReader(gis, "UTF-8"))) {
	return br.lines().collect(Collectors.joining());
	} catch (final IOException e) {
	LOG.log(Level.SEVERE, "Could not open file " + toFile.toString(), e);
	throw e;
	}
	}
	/**
	* writes out a string to a file, gzipped.
	* @param toFile the file to be written
	* @param log the string to write, as gzipped
	*/
	private void writeOutGZippedFile(final Path toFile, final String log) {
	try (final FileOutputStream fos = new FileOutputStream(toFile.toFile());
	final GZIPOutputStream gos = new GZIPOutputStream(fos)) {
	gos.write(log.getBytes(StandardCharsets.UTF_8));
	} catch (final IOException e) {
	LOG.log(Level.SEVERE, "Could not write file " + toFile.toString(), e);
	}
	}
	}

view raw AppendAsGZip.java hosted with ❤ by GitHub

	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import java.io.File;
	import java.io.IOException;
	import java.nio.file.Path;
	import static org.mockito.BDDMockito.*;
	public class AppendEntryAsGZipTest {
	@Mock Path toFile;
	ServiceQueryLogEntry entry;
	AppendEntryAsGZip toTest;
	@Before
	public void setup() {
	MockitoAnnotations.initMocks(this);
	entry = new ServiceQueryLogEntry.Builder()
	.build();
	toTest = new AppendEntryAsGZip(entry, toFile);
	}
	@Test(expected = NullPointerException.class)
	public void rejectsNullEntry() {
	new AppendEntryAsGZip(null, toFile);
	}
	@Test(expected = NullPointerException.class)
	public void rejectsNullPath() {
	new AppendEntryAsGZip(entry, null);
	}
	@Test
	public void canWriteAnEntryToFile() throws IOException {
	final File f = mock(File.class);
	given(f.getPath()).willReturn("./service_log.2018-04-19");
	given(toFile.toFile()).willReturn(f);
	// surprising NullPointerException:
	// at java.io.File.isInvalid(File.java:187)
	// at java.io.FileOutputStream.<init>(FileOutputStream.java:205)
	// at java.io.FileOutputStream.<init>(FileOutputStream.java:162)
	// at AppendEntryAsGZip.writeOutGZippedFile(AppendEntryAsGZip.java:70)
	// at AppendEntryAsGZip.writeEntryToFile(AppendEntryAsGZip.java:40)
	// at AppendEntryAsGZipTest.canWriteAnEntryToFile(AppendEntryAsGZipTest.java:42)
	toTest.writeEntryToFile(toFile, entry);
	}
	}

view raw AppendAsGZipTest.java hosted with ❤ by GitHub

It turns out this NPE happens because of the implementation of java.io.File#isInvalid. Because this uses this.path instead of getPath(), even providing a canned answer for an external mock doesn't work well. Since #isInvalid is final (but according to the JavaDoc has rudimentary logic that they probably intend to evolve). Encapsulating even your use of private fields behind getters provides unexpected hooks for testability and maintainability.

Using ECMAScript 6 modules

This may be obvious to everyone else, but today I found myself constructing a toy HTML/JS example and wanting to use the new hotness of ECMAScript 6 Modules.

I constructed the following page.

	export default function crossPlatformSpanTextUpdate(span, text) {
	if ('textContent' in span) {
	span.textContent = text;
	} else {
	span.innerText = text;
	}
	}

view raw cross_platform_span_update.js hosted with ❤ by GitHub

	<html>
	<head>
	<title>An E-commerce retailer</title>
	</head>
	<body>
	<h1>
	Hello <span id="greeting">Placeholder</span>!</h1>
	<h2>
	Please <a href="https://www.blogger.com/buy/12345">buy</a> this product</h2>
	</body>
	<script src="greeting.js" type="module"></script>
	<script type="text/javascript">
	document.onready = greetCustomer(document.querySelector("#greeting"));
	</script>
	</html>

view raw demo.html hosted with ❤ by GitHub

	import {getUserPreferredLanguage} from './language.js'
	import {crossPlatformSpanTextUpdate} from './cross_platform_span_update.js'
	export default function greetCustomer(location) {
	loadGreeting(location, getUserPreferredLanguage());
	}
	function loadGreeting(span, lang) {
	var text = greeting(lang);
	crossPlatformSpanTextUpdate(span, text);
	}
	function greeting(lang) {
	if (lang === "es") {
	return "Dear dear Customer";
	}
	return "Valued Shopper";
	}

view raw greeting.js hosted with ❤ by GitHub

	/*
	used for language detection from
	https://stackoverflow.com/questions/1043339/javascript-for-detecting-browser-language-preference
	*/
	export default function getUserPreferredLanguage() {
	return window.navigator.languages[0] ||
	[window.navigator.language || window.navigator.userLanguage];
	}

view raw language.js hosted with ❤ by GitHub

This refused to work. I kept getting

 ReferenceError: greetCustomer is not defined 

Reading the docs a little more, I decided to change it. I changed my script tag to type module and removed the onready function bit. No joy.

	<html>
	<head>
	<title>An E-commerce retailer</title>
	</head>
	<body>
	<h1>
	Hello <span id="greeting">Placeholder</span>!</h1>
	<h2>
	Please <a href="https://www.blogger.com/buy/12345">buy</a> this product</h2>
	</body>
	<script src="greeting.js" type="module"></script>
	<script type="module">
	greetCustomer(document.querySelector("#greeting"));
	</script>
	</html>

view raw demo.html hosted with ❤ by GitHub

I tried importing directly, using an example I'd seen. Now I got:

SyntaxError: import not found: getUserPreferredLanguage

I finally got things working with the following

	<html>
	<head>
	<title>An E-commerce retailer</title>
	</head>
	<body>
	<h1> Hello <span id="greeting">Placeholder</span>!</h1>
	<h2> Please <a href="buy/12345">buy</a> this product</h2>
	</body>
	<script src="greeting.js" type="module"></script>
	<script type="module">
	import greetCustomer from './greeting.js'
	greetCustomer(document.querySelector("#greeting"));
	</script>
	</html>

view raw demo.html hosted with ❤ by GitHub

	import getUserPreferredLanguage from './language.js'
	import crossPlatformSpanTextUpdate from './cross_platform_span_update.js'
	export default function greetCustomer(location) {
	loadGreeting(location, getUserPreferredLanguage());
	}
	function loadGreeting(span, lang) {
	var text = greeting(lang);
	crossPlatformSpanTextUpdate(span, text);
	}
	function greeting(lang) {
	if (lang === "es") {
	return "Dear dear Customer";
	}
	return "Valued Shopper";
	}

view raw greeting.js hosted with ❤ by GitHub

It seems like importing modules via the destructuring syntax by default is not the way to go.