kymr tech blog

Compound Pattern

Sun, 22 Jan 2017 22:00:00 +0000

State Pattern

Definition

The compound pattern is that combines at least two patterns into a solution that solves a recurring or general problem. For example, Model–view–controller (MVC) pattern for implementing user interfaces on computers. It divides a given software application into three interconnected parts, so as to separate internal representations of information from the ways that information is presented to or accepted from the user.

Components

A typical collaboration of the MVC components.

The model is the central component of the pattern. It expresses the application’s behavior in terms of the problem domain, independent of the user interface. It directly manages the data, logic and rules of the application.
A view can be any output representation of information, such as a chart or a diagram. Multiple views of the same information are possible, such as a bar chart for management and a tabular view for accountants.
The controller, accepts input and converts it to commands for the model or view.

Interactions

A model stores data that is retrieved according to commands from the controller and displayed in the view.
A view generates new output to the user based on changes in the model.
A controller can send commands to the model to update the model’s state. It can also send commands to its associated view to change the view’s presentation of the model.

State & Proxy Pattern

Sun, 15 Jan 2017 23:50:00 +0000

State Pattern

Definition

The state pattern is a behavioral software design pattern that implements a state machine in an object-oriented way. With the state pattern, a state machine is implemented by implementing each individual state as a derived class of the state pattern interface, and implementing state transitions by invoking methods defined by the pattern’s superclass.

Implementation

State Interface & Concrete class

public interface State {
	void insertQuarter();
	void ejectQuarter();
	void turnCrank();
	void dispense();
}

public class HasQuarterState implements State {
	Random random = new Random(System.currentTimeMillis());
	GumballMachine gumballMachine;

	public HasQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("cannot insert");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("quarter is ejected");
		gumballMachine.setState(gumballMachine.getNoQuarterState());
	}

	@Override
	public void turnCrank() {
		System.out.println("turned crank");
		int winner = random.nextInt(10);
		if ((winner == 0) && (gumballMachine.getCount() > 1)) {
			gumballMachine.setState(gumballMachine.getWinnerState());
		} else {
			gumballMachine.setState(gumballMachine.getSoldState());
		}
	}

	@Override
	public void dispense() {
		System.out.println("cannot dispense");
	}
}

public class NoQuarterState implements State {
	GumballMachine gumballMachine;

	public NoQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("quarter is inserted");
		gumballMachine.setState(gumballMachine.getHasQuarterState());
	}

	@Override
	public void ejectQuarter() {
		System.out.println("insert qaurter");
	}

	@Override
	public void turnCrank() {
		System.out.println("insert qaurter");
	}

	@Override
	public void dispense() {
		System.out.println("insert qaurter");
	}
}

public class SoldOutState implements State {
	GumballMachine gumballMachine;

	public SoldOutState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("cannot insert");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("cannot eject");
	}

	@Override
	public void turnCrank() {
		System.out.println("cannot turn crank");
	}

	@Override
	public void dispense() {
		System.out.println("cannot dispense");
	}
}

public class SoldState implements State {
	GumballMachine gumballMachine;

	public SoldState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("cannot insert");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("cannot eject");
	}

	@Override
	public void turnCrank() {
		System.out.println("cannot turn");
	}

	@Override
	public void dispense() {
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() > 0) {
			gumballMachine.setState(gumballMachine.getNoQuarterState());
		} else {
			System.out.println("out of gumballs");
			gumballMachine.setState(gumballMachine.getSoldOutState());
		}
	}
}

public class WinnerState implements State {
	GumballMachine gumballMachine;

	public WinnerState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("cannot insert");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("cannot eject");
	}

	@Override
	public void turnCrank() {
		System.out.println("cannot turn crank");
	}

	@Override
	public void dispense() {
		System.out.println("Congratulations, you can get one more gumball");
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() == 0) {
			System.out.println("out of gumballs");
			gumballMachine.setState(gumballMachine.getSoldOutState());
		} else {
			gumballMachine.releaseBall();
			if  (gumballMachine.getCount() > 0) {
				gumballMachine.setState(gumballMachine.getNoQuarterState());
			} else {
				System.out.println("out of gumballs");
				gumballMachine.setState(gumballMachine.getSoldOutState());
			}
		}
	}
}

Context

public class GumballMachine {
	State soldOutState;
	State noQuarterState;
	State hasQuarterState;
	State soldState;
	State winnerState;

	State state = soldOutState;
	int count = 0;

	public GumballMachine(int numberGumballs) {
		soldOutState = new SoldOutState(this);
		noQuarterState = new NoQuarterState(this);
		hasQuarterState = new HasQuarterState(this);
		soldState = new SoldState(this);
		winnerState = new WinnerState(this);
		this.count = numberGumballs;

		if (numberGumballs > 0) {
			state = noQuarterState;
		}
	}

	public void insertQuarter() {
		state.insertQuarter();
	}

	public void ejectQuarter() {
		state.ejectQuarter();
	}

	public void turnCrank() {
		state.turnCrank();
		state.dispense();
	}

	void setState(State state) {
		this.state = state;
	}

	void releaseBall() {
		System.out.println("A gumball comes rolling out the slot..");
		if (count != 0) {
			count = count -1;
		}
	}

	public State getWinnerState() {
		return winnerState;
	}

	public void setWinnerState(State winnerState) {
		this.winnerState = winnerState;
	}

	public State getSoldOutState() {
		return soldOutState;
	}

	public State getNoQuarterState() {
		return noQuarterState;
	}

	public State getHasQuarterState() {
		return hasQuarterState;
	}

	public State getSoldState() {
		return soldState;
	}

	public int getCount() {
		return count;
	}

	@Override
	public String toString() {
		return "Gumball Machine!! Current Gumball : " + count;
	}
}

Demo

public class Demo {
	public static void main(String[] args) {
		GumballMachine gumballMachine = new GumballMachine(5);

		System.out.println(gumballMachine);
		gumballMachine.insertQuarter();
		gumballMachine.turnCrank();

		System.out.println(gumballMachine);

		gumballMachine.insertQuarter();
		gumballMachine.turnCrank();
		gumballMachine.insertQuarter();
		gumballMachine.turnCrank();

		System.out.println(gumballMachine);
	}
}

Proxy Pattern

Definition

A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. In the proxy extra functionality can be provided, for example caching when operations on the real object are resource intensive, or checking preconditions before operations on the real object are invoked. For the client, usage of a proxy object is similar to using the real object, because both implement the same interface.

Remote Proxy

In distributed object communication, a local object represents a remote object (one that belongs to a different address space). The local object is a proxy for the remote object, and method invocation on the local object results in remote method invocation on the remote object. An example would be an ATM implementation, where the ATM might hold proxy objects for bank information that exists in the remote server.

Virtual Proxy

In place of a complex or heavy object, a skeleton representation may be advantageous in some cases. When an underlying image is huge in size, it may be represented using a virtual proxy object, loading the real object on demand.

Protection Proxy

A protection proxy might be used to control access to a resource based on access rights.

Implementation

This is protection proxy example that controls access to a resource

Proxy Target

public interface PersonBean {
	String getName();
	String getGender();
	String getInterests();
	int getHotOrNotRating();

	void setName(String name);
	void setGender(String gender);
	void setInterests(String interests);
	void setHotOrNotRating(int rating);
}

public class PersonBeanImpl implements PersonBean {
	String name;
	String gender;
	String interests;
	int rating;
	int ratingCount = 0;

	@Override
	public String getName() {
		return name;
	}

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

	@Override
	public String getGender() {
		return gender;
	}

	@Override
	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public String getInterests() {
		return interests;
	}

	@Override
	public void setInterests(String interests) {
		this.interests = interests;
	}

	@Override
	public int getHotOrNotRating() {
		return (ratingCount == 0) ? 0 : rating / ratingCount;
	}

	@Override
	public void setHotOrNotRating(int rating) {
		this.rating += rating;
		ratingCount++;
	}

}

Invocation Handler

public class OwnerInvocationHandler implements InvocationHandler {
	PersonBean personBean;

	public OwnerInvocationHandler(PersonBean personBean) {
		this.personBean = personBean;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		try {
			if (method.getName().startsWith("get")) {
				return method.invoke(personBean, args);
			} else if (method.getName().equals("setHotOrNotRating")) {
				throw new IllegalAccessException();
			} else if (method.getName().startsWith("set")) {
				return method.invoke(personBean, args);
			}
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}

		return null;
	}
}

public class NonOwnerInvocationHandler implements InvocationHandler {
	PersonBean personBean;

	public NonOwnerInvocationHandler(PersonBean personBean) {
		this.personBean = personBean;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		try {
			if (method.getName().startsWith("get")) {
				return method.invoke(personBean, args);
			} else if (method.getName().equals("setHotOrNotRating")) {
				return method.invoke(personBean, args);
			} else if (method.getName().startsWith("set")) {
				throw new IllegalAccessException();
			}
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}

		return null;
	}
}

Demo

public class Demo {
	public static void main(String[] args) {
		PersonBean joe = search("joe");
		PersonBean ownerProxy = getOwnerProxy(joe);
		System.out.println("Name is " + ownerProxy.getName());
		ownerProxy.setInterests("skiing");
		System.out.println("Interest set from owner proxy");
		try {
			ownerProxy.setHotOrNotRating(10);
		} catch (Exception e) {
			System.out.println("Cannot set rating from owner proxy");
		}
		System.out.println("Rating is " + ownerProxy.getHotOrNotRating());

		PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
		System.out.println("Name is " + nonOwnerProxy.getName());
		try {
			nonOwnerProxy.setInterests("skiing");
		} catch (Exception e) {
			System.out.println("Cannot set interests from non owner proxy");
		}
		nonOwnerProxy.setHotOrNotRating(3);
		System.out.println("Rating set from non owner proxy");
		System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());

	}

	private static PersonBean getOwnerProxy(PersonBean personBean) {
		return (PersonBean) Proxy.newProxyInstance(
				personBean.getClass().getClassLoader(),
				personBean.getClass().getInterfaces(),
				new OwnerInvocationHandler(personBean)
		);
	}

	private static PersonBean getNonOwnerProxy(PersonBean personBean) {
		return (PersonBean) Proxy.newProxyInstance(
				personBean.getClass().getClassLoader(),
				personBean.getClass().getInterfaces(),
				new NonOwnerInvocationHandler(personBean)
		);
	}

	private static PersonBean search(String name) {
		PersonBeanImpl personBean = new PersonBeanImpl();
		personBean.setName(name);
		personBean.setGender("male");
		personBean.setInterests("programming");
		personBean.setHotOrNotRating(10);

		return personBean;
	}



}

RetryUtils with Java 8. How to retry block of codes when exception occurs with functional way?

Mon, 09 Jan 2017 02:00:00 +0000

Basic

There are already many ways exist to retry logics when exception occurs. For example, you can use framework like @retry with Spring. I just want to make a simple util to retry logic with java 8 like below.

RetryUtils

@Slf4j
public class RetryUtils {
	private static final int RETRY = 3;
	private static final long DELAY = 1000l;

	@FunctionalInterface
	public interface RunnableWithException {
		void run() throws Exception;
	}

	public static <V> V retry(Callable<V> callable, Throwable throwable, String message) {
		return retryLogics(callable, throwable, message);
	}

	public static void retry(RunnableWithException runnable, Throwable throwable, String message) {
		retryLogics(() -> {
			runnable.run();
			return null;
		}, throwable, message);
	}

	private static <T> T retryLogics(Callable<T> callable, Throwable throwable, String message) {
		int counter = 0;

		while (counter < RETRY) {
			try {
				return callable.call();
			} catch (Exception e) {
				counter++;
				log.error("retry {} / {}, {}", counter, RETRY, message, e);

				try {
					Thread.sleep(DELAY);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}
			}
		}

		throw new RuntimeException(throwable);
	}
}

The logic can have a return value or not. When the logic has a return value, callable interface is good for it. But when the logic doesn’t have a return value, then runnable can be used. Because retry will be executed when exception occurs, so i declared new interface that throws exception. I want to print the error message at every retry, so i added it to paramter. Also i want to throw the specific exception if all retries also are failed. If you want to control retry count and delay time, then customize it :D

Below is the use case.

Test Case

public class RetryUtilsTest {

	@Test
	public void testRunnable() throws Exception {
		RetryUtils.retry(() -> System.out.println("hi"), new IOException(), "error occurs");
	}

	@Test(expectedExceptions = Exception.class)
	public void testRunnableWithException() throws Exception {
		RetryUtils.retry(() -> {
			throw new Exception();
		}, new IOException(), "error occurs");
	}

	@Test
	public void testCallable() throws Exception {
		String result = RetryUtils.retry(() -> "hi", new IOException(), "error occurs");
		System.out.println(result);

		List<String> results = RetryUtils.retry(() -> Arrays.asList("hi1", "hi2", "hi3"), new IOException(), "error occurs");
		results.forEach(str -> System.out.println("List : " + str));
	}

	@Test(expectedExceptions = Exception.class)
	public void testCallableException() throws Exception {
		String result = RetryUtils.retry(() -> {
			throw new Exception();
		}, new IOException(), "error occurs");
	}
}

Iterator & Composite Pattern

Mon, 09 Jan 2017 02:00:00 +0000

Iterator Pattern

Definition

The iterator pattern is a design pattern in which an iterator is used to traverse a container and access the container’s elements. The iterator pattern decouples algorithms from containers; in some cases, algorithms are necessarily container-specific and thus cannot be decoupled.

Implementation

Base object

public interface Menu {
	public Iterator<MenuItem> createIterator();
}

public class MenuItem {
	String name;
	String description;
	boolean vegetarian;
	double price;

	public MenuItem(String name, String description, boolean vegetarian, double price) {
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}

	public boolean isVegetarian() {
		return vegetarian;
	}

	public double getPrice() {
		return price;
	}

	@Override
	public String toString() {
		return "MenuItem{" +
				"name='" + name + '\'' +
				", description='" + description + '\'' +
				", vegetarian=" + vegetarian +
				", price=" + price +
				'}';
	}
}

Concrete Class

public class PancakeHouseMenu implements Menu {
	ArrayList<MenuItem> menuItems;

	public PancakeHouseMenu() {
		menuItems = new ArrayList<>();

		addItem("K&B Pancake set",
				"scrambled egg & toast pancake", true, 2.99);
		addItem("Blueberry Pancake",
				"Blueberry Pancake", true, 3.49);
	}

	public void addItem(String name, String description, boolean vegetarian, double price) {
		menuItems.add(
				new MenuItem(name, description, vegetarian, price)
		);
	}

	public Iterator<MenuItem> createIterator() {
		return menuItems.iterator();
	}
}

public class DinerMenu implements Menu {
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	public DinerMenu() {
		menuItems = new MenuItem[MAX_ITEMS];

		addItem("Vegetarian BLT",
				"Vegetarian BLT", true, 2.99);
		addItem("BLT",
				"BLT", false, 2.99);
		addItem("Today's soup",
				"Soup with potato salad", false, 3.29);
		addItem("Hotdog",
				"Hotdog with cheese", false, 3.29);
	}

	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menuItem = new MenuItem(name, description, vegetarian, price);

		if (MAX_ITEMS <= numberOfItems) {
			System.out.println("Sorry, menu is full. It cannot add new item");
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems += 1;
		}
	}

	public Iterator<MenuItem> createIterator() {
		return new DinerMenuIterator(menuItems);
	}
}

public class CafeMenu implements Menu {
	Hashtable<String, MenuItem> menuItems = new Hashtable<>();

	public CafeMenu() {
		addItem("Burger & Fries",
				"Burger & potato fries", true, 3.99);
		addItem("Today's soup",
				"Soup with salad", false, 3.69);
	}

	public void addItem(String name, String description, boolean vegetarian, double price) {
		MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
		menuItems.put(menuItem.getName(), menuItem);
	}

	@Override
	public Iterator<MenuItem> createIterator() {
		return menuItems.values().iterator();
	}
}

Concrete Iterator

public class DinerMenuIterator implements Iterator<MenuItem> {
	MenuItem[] items;
	int position = 0;

	public DinerMenuIterator(MenuItem[] items) {
		this.items = items;
	}

	@Override
	public boolean hasNext() {
		if (items.length <= position || items[position] == null) {
			return false;
		} else {
			return true;
		}
	}

	@Override
	public MenuItem next() {
		MenuItem menuItem = items[position];
		position += 1;
		return menuItem;
	}
}

Client

public class Waitress {
	List<Menu> menus;

	public Waitress(List<Menu> menus) {
		this.menus = menus;
	}

	public void printMenu() {
		System.out.println("Menus : ");

		menus.forEach(menu -> {
			System.out.println("===");
			printMenu(menu.createIterator());
		});
	}

	private void printMenu(Iterator<MenuItem> iterator) {
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

Test

public class MenuTest {
	public static void main(String[] args) {
		List<Menu> menus = Arrays.asList(new PancakeHouseMenu(), new DinerMenu(), new CafeMenu());
		Waitress waitress = new Waitress(menus);

		waitress.printMenu();
	}
}

Composite Pattern

Definition

The composite pattern is a partitioning design pattern. The composite pattern describes that a group of objects is to be treated in the same way as a single instance of an object. The intent of a composite is to “compose” objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.[

Implementation

Component

public abstract class MenuComponent {
	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}

	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}

	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}

	public String getName() {
		throw new UnsupportedOperationException();
	}

	public String getDescription() {
		throw new UnsupportedOperationException();
	}

	public boolean isVegetarian() {
		throw new UnsupportedOperationException();
	}

	public double getPrice() {
		throw new UnsupportedOperationException();
	}

	public void print() {
		throw new UnsupportedOperationException();
	}

	public Iterator<MenuComponent> createIterator() {
		throw new UnsupportedOperationException();
	}
}

Composite

public class Menu extends MenuComponent {
	List<MenuComponent> menuComponents = new ArrayList<>();
	String name;
	String description;

	public Menu(String name, String description) {
		this.name = name;
		this.description = description;
	}

	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}

	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}

	public MenuComponent getChild(int i) {
		return menuComponents.get(i);
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}

	public void print() {
		System.out.print("\n" + getName());
		System.out.println(", " + getDescription());
		System.out.println("--------------------");

		menuComponents.forEach(MenuComponent::print);
	}

	public Iterator<MenuComponent> createIterator() {
		return new CompositeIterator(menuComponents.iterator());
	}
}

Leaf

public class MenuItem extends MenuComponent {
	String name;
	String description;
	boolean vegetarian;
	double price;

	public MenuItem(String name, String description, boolean vegetarian, double price) {
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}

	public boolean isVegetarian() {
		return vegetarian;
	}

	public double getPrice() {
		return price;
	}

	public void print() {
		System.out.print(" " + getName());
		if (isVegetarian()) {
			System.out.print("(v)");
		}
		System.out.println(", " + getPrice());
		System.out.println("    -- " + getDescription());
	}

	public Iterator<MenuComponent> createIterator() {
		return new NullIterator();
	}
}

Composite with Iterator

public class CompositeIterator implements Iterator<MenuComponent> {
	Stack<Iterator> stack = new Stack();

	public CompositeIterator(Iterator<MenuComponent> iterator) {
		stack.push(iterator);
	}

	@Override
	public boolean hasNext() {
		if (stack.empty()) {
			return false;
		} else {
			Iterator iterator = stack.peek();
			if (!iterator.hasNext()) {
				stack.pop();
				return hasNext();
			} else {
				return true;
			}
		}
	}

	@Override
	public MenuComponent next() {
		if (hasNext()) {
			Iterator<MenuComponent> iterator = stack.peek();
			MenuComponent component = iterator.next();

			if (component instanceof Menu) {
				stack.push(((Menu) component).createIterator());
			}
			return component;
		} else {
			return null;
		}
	}
}

public class NullIterator implements Iterator<MenuComponent> {
	@Override
	public boolean hasNext() {
		return false;
	}

	@Override
	public MenuComponent next() {
		return null;
	}
}

Client

public class Waitress {
	MenuComponent allMenus;

	public Waitress(MenuComponent allMenus) {
		this.allMenus = allMenus;
	}

	public void print() {
		allMenus.print();
	}

	public void printVegetarianMenu() {
		Iterator iterator = allMenus.createIterator();
		System.out.println("\nVegetarian Menu");

		while (iterator.hasNext()) {
			MenuComponent menuComponent = (MenuComponent) iterator.next();

			try {
				if (menuComponent.isVegetarian()) {
					menuComponent.print();
				}
			} catch (UnsupportedOperationException e) {}
		}
	}
}

Test

public class MenuTest {
	public static void main(String[] args) {
		MenuComponent pancakeHouseMenu = new Menu("Pancake house menu", "breakfast menu");
		MenuComponent dinerMenu = new Menu("ObjectTown menu", "lunch menu");
		MenuComponent cafeMenu = new Menu("cafe menu", "dinner menu");
		MenuComponent dessertMenu = new Menu("dessert menu", "enjoy dessert!!");

		MenuComponent allMenus = new Menu("all menus", "all menus");

		allMenus.add(pancakeHouseMenu);
		allMenus.add(dinerMenu);
		allMenus.add(cafeMenu);

		dinerMenu.add(new MenuItem("pasta", "pasta with bread", true, 3.89));
		dinerMenu.add(dessertMenu);

		dessertMenu.add(new MenuItem("apple pie", "apple pie with vanilla icecream", true, 1.59));

		Waitress waitress = new Waitress(allMenus);
		waitress.print();
		waitress.printVegetarianMenu();
	}
}

Template Method Pattern

Sun, 01 Jan 2017 23:00:00 +0000

Template Method Pattern

Definition

The template method pattern is a behavioral design pattern that defines the program skeleton of an algorithm in an operation, deferring some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm’s structure.

Template method’s abstract class may also define hook methods that may be overridden by subclasses.

Implementation

Template Method Abstract Class

public abstract class CaffeineBeverage {

	final void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		addCondiments();
	}

	abstract void brew();
	abstract void addCondiments();

	void boilWater() {
		System.out.println("boiling water..");
	}

	void pourInCup() {
		System.out.println("pouring in cup");
	}
}

Concrete Class Coffee & Tea

public class Coffee extends CaffeineBeverage {
	@Override
	void brew() {
		System.out.println("brewing coffee with filter");
	}

	@Override
	void addCondiments() {
		System.out.println("adding sugar");
	}
}

public class Tea extends CaffeineBeverage {

	@Override
	void brew() {
		System.out.println("brewing tea");
	}

	@Override
	void addCondiments() {
		System.out.println("adding lemon");
	}
}

Demo

public class Demo {
	public static void main(String[] args) {
		Arrays.asList(new Tea(), new Coffee())
				.forEach((CaffeineBeverage beverage) -> {
					System.out.println("This is " + beverage.getClass().getSimpleName());
					beverage.prepareRecipe();
				});
	}
}

Arrays Sort Example

public class Duck {
	String name;
	int weight;

	public Duck(String name, int weight) {
		this.name = name;
		this.weight = weight;
	}

	@Override
	public String toString() {
		return "Duck{" +
				"name='" + name + '\'' +
				", weight=" + weight +
				'}';
	}
}

public class Demo {
	public static void main(String[] args) {
		System.out.println("\n\nDuck Sort Example");

		Duck[] ducks = {
			new Duck("Daffy", 8),
			new Duck("Dewey", 2),
			new Duck("Howard", 7),
			new Duck("Louie", 2),
			new Duck("Donald", 10),
			new Duck("Huey", 2)
		};

		System.out.println("Before:");
		Stream.of(ducks).forEach(System.out::println);

		System.out.println("After");
		Arrays.sort(ducks, (Duck o1, Duck o2) -> o1.weight - o2.weight);
		Stream.of(ducks).forEach(System.out::println);
	}
}

Sorting Arrays uses Comparator Interface at sort method internally. It just need to be declared how to compare that object, not how we rearrange the array.

Adapter & Facade Pattern

Mon, 26 Dec 2016 02:00:00 +0000

Adapter Pattern

Definition

The adapter pattern is a software design pattern (also known as Wrapper, an alternative naming shared with the Decorator pattern) that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.

Both Adapter pattern and Decorator pattern is usually called as Wrapper. But the purpose is basically different. At decorator pattern, we usually add additional function to original interface. At Adapter pattern, It is convert the interface to existing one.

Implementation

Duck

public interface Duck {
	public void quack();
	public void fly();
}

Turkey

public interface Turkey {
	public void gobble();
	public void fly();
}

Wild Turkey

public class WildTurkey implements Turkey {
	@Override
	public void gobble() {
		System.out.println("Gobble gobble");
	}

	@Override
	public void fly() {
		System.out.println("I'm flying a short distance");
	}
}

TurkeyAdapter

public class TurkeyAdapter implements Duck {
	Turkey turkey;

	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}

	@Override
	public void quack() {
		turkey.gobble();
	}

	@Override
	public void fly() {
		for (int i = 0; i < 5; i++) {
			turkey.fly();
		}
	}
}

Demo

public class Test {
	public static void main(String[] args) {
		WildTurkey wildTurkey = new WildTurkey();
		Duck tuckeyAdapter = new TurkeyAdapter(wildTurkey);

		tuckeyAdapter.quack();
		tuckeyAdapter.fly();
	}
}

Facade Pattern

Definition

The Facade design pattern is often used when a system is very complex or difficult to understand because the system has a large number of interdependent classes or its source code is unavailable. This pattern hides the complexities of the larger system and provides a simpler interface to the client. It typically involves a single wrapper class which contains a set of members required by client. These members access the system on behalf of the facade client and hide the implementation details

A Facade can

make a software library easier to use, understand and test, since the facade has convenient methods for common tasks
make the library more readable, for the same reason
reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system
wrap a poorly designed collection of APIs with a single well-designed API

Implementation

public class EncodingOptionParser {
	public EncodingOption parse(String option) {
		System.out.println("parse option.. " + option);
		return new EncodingOption();
	}
}

public class TranscodeEngineConnector {
	public class Engine {
		// this is sample
	}

	Engine engine;

	public TranscodeEngineConnector() {
		this.engine = new Engine();
	}

	public void connect() {
		System.out.println("Connect to Transcoder Engine..");
	}

	public void validate(String path) {
		System.out.println("Validating Source " + path + " ..");
	}

	public void optimizeOption(EncodingOption encodingOption) {
		System.out.println("Optimizing Option..");
	}

	public String encode() {
		System.out.println("Encoding..");
		return "localOutputPath";
	}
}

public class FileTransfer {
	public void copy(String source, String dest) {
		System.out.println("copying result..");
	}
}

public class EncodeTask {
	private String id;
	private String sourcePath;
	private String destPath;
	private String option;
	
	...
}

public class TranscodeFacade {
	EncodingOptionParser encodingOptionParser;
	TranscodeEngineConnector transcodeEngineConnector;
	FileTransfer fileTransfer;

	public TranscodeFacade(EncodingOptionParser encodingOptionParser, TranscodeEngineConnector transcodeEngineConnector, FileTransfer fileTransfer) {
		this.encodingOptionParser = encodingOptionParser;
		this.transcodeEngineConnector = transcodeEngineConnector;
		this.fileTransfer = fileTransfer;
	}

	public void encode(EncodeTask task) {
		EncodingOption encodingOption = encodingOptionParser.parse(task.getOption());
		transcodeEngineConnector.connect();
		transcodeEngineConnector.validate(task.getSourcePath());
		transcodeEngineConnector.optimizeOption(encodingOption);
		String outputPath = transcodeEngineConnector.encode();
		fileTransfer.copy(outputPath, task.getDestPath());
	}
}

public class Test {
	public static void main(String[] args) {
		EncodeTask encodeTask = new EncodeTask();
		encodeTask.setId("id1");
		encodeTask.setSourcePath("source");
		encodeTask.setDestPath("dest");
		encodeTask.setOption("option json string");

		TranscodeEngineConnector transcodeEngineConnector = new TranscodeEngineConnector();
		EncodingOptionParser encodingOptionParser = new EncodingOptionParser();
		FileTransfer fileTransfer = new FileTransfer();
		TranscodeFacade transcodeFacade = new TranscodeFacade(encodingOptionParser, transcodeEngineConnector, fileTransfer);

		transcodeFacade.encode(encodeTask);
	}
}

Command Pattern

Sun, 18 Dec 2016 23:50:00 +0000

Definition

Command Pattern

The command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method and values for the method parameters.

Command A command object knows about receiver and invokes a method of the receiver. Values for parameters of the receiver method are stored in the command.
Invoker An invoker object knows how to execute a command, and optionally does bookkeeping about the command execution. The invoker does not know anything about a concrete command, it knows only about command interface. Both an invoker object and several command objects are held by a client object
Receiver The receiver then does the work
client The client decides which commands to execute at which points. To execute a command, it passes the command object to the invoker object.

Implementation

RemoteContol

First, Command interface.

public interface Command {
	public void execute();
}

And, concrete commands need to be implemented.

public class LightOnCommand implements Command {
	Light light;

	public LightOnCommand(Light light) {
		this.light = light;
	}

	@Override
	public void execute() {
		light.on();
	}
}

public class LightOffCommand implements Command {
	Light light;

	public LightOffCommand(Light light) {
		this.light = light;
	}

	@Override
	public void execute() {
		light.off();
	}
}

This is Receiver that work

public class Light {
	public void on() {
		System.out.println("light on");
	}

	public void off() {
		System.out.println("light off");
	}
}

RemoteControl is an invoker. And main method is an implementation of client.

public class SimpleRemoteControl {
	Command slot;

	public SimpleRemoteControl() {

	}

	public void setCommand(Command command) {
		slot = command;
	}

	public void buttonWasPressed() {
		slot.execute();
	}

	public static void main(String[] args) {
		SimpleRemoteControl simpleRemoteControl = new SimpleRemoteControl();
		Light light = new Light();
		simpleRemoteControl.setCommand(new LightOnCommand(light));
		simpleRemoteControl.buttonWasPressed();
	}
}

If you want to execute multi-comamnds, then you can easily implement MacroCommand that has multi commands as a variable.

public class MacroCommand implements Command {
	Command[] commands;

	public MacroCommand(Command[] coomands) {
		this.commands = coomands;
	}

	@Override
	public void execute() {
		Arrays.stream(commands).forEach(Command::execute);
	}

	public static void main(String[] args) {
		Light light = new Light();

		LightOnCommand lightOnCommand = new LightOnCommand(light);
		LightOffCommand lightOffCommand = new LightOffCommand(light);

		Command[] commands = {lightOnCommand, lightOffCommand};
		MacroCommand macroCommand = new MacroCommand(commands);

		SimpleRemoteControl simpleRemoteControl = new SimpleRemoteControl();
		simpleRemoteControl.setCommand(macroCommand);

		simpleRemoteControl.buttonWasPressed();
	}
}

Java 8 Lambda

Command interface is same. But this Command interface has single abstract method. So this is FunctionalInterface.

public interface Command {
	public void execute();
}

Now, you can easily implement RemoteControl like below with lambda expression.

public class RemoteControl {
	private HashMap<Integer, Command> commands = new HashMap<>();

	public void register(int slot, Command command) {
		commands.put(slot, command);
	}

	public void buttonPressed(int slot) {
		if (commands.containsKey(slot) == false) {
			System.out.println("This button is not registed yet.");
		}

		commands.get(slot).execute();
	}

	public static void main(String[] args) {
		Light light = new Light();

		RemoteControl remoteControl = new RemoteControl();
		remoteControl.register(1, () -> light.on());
		remoteControl.register(2, () -> light.off());
		remoteControl.register(3, () -> {
			light.on();
			light.off();
		});

		remoteControl.buttonPressed(1);
		remoteControl.buttonPressed(2);
		remoteControl.buttonPressed(3);
	}
}

Singleton Pattern

Mon, 12 Dec 2016 02:14:00 +0000

Definition

Singleton Pattern

The singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. The concept is sometimes generalized to systems that operate more efficiently when only one object exists, or that restrict the instantiation to a certain number of objects. The term comes from the mathematical concept of a singleton.

Implementation

Classical Example

This use-case is really bad. Because getInstance method will be called many times. And when the method is called, it is going to be synchronized. Usually, method execution with synchronization is slower 100 times than normal execution.

public class ClassicalSingleton {
	private static ClassicalSingleton classicalSingleton;

	private ClassicalSingleton() {
	}

	public static synchronized ClassicalSingleton getInstance() {
		if (classicalSingleton == null) {
			classicalSingleton = new ClassicalSingleton();
		}
		return classicalSingleton;
	}
}

Initialize instance during class-loading.

I prefer below code normally. The instance is going to be initialized while class-loading. It looks like a waste of memory. But i think it will be used often. If this singleton is used often, then i think below way is not bad.

public class InitializedSingleton {
	private static InitializedSingleton initializedSingleton = new InitializedSingleton();

	private InitializedSingleton() {
	}

	public static synchronized InitializedSingleton getInstance() {
		return initializedSingleton;
	}
}

Double Checking Locking

I think this way is most widely used. This singleton instance is going to be initialized when it needed, and it is safe, and it is also faster than synchronization on all over the method.

public class DoubleCheckingLockingSingleton {
	private volatile static DoubleCheckingLockingSingleton doubleCheckingLockingSingleton;

	private DoubleCheckingLockingSingleton() {
	}

	public static DoubleCheckingLockingSingleton getInstance() {
		if (doubleCheckingLockingSingleton == null) {
			synchronized (DoubleCheckingLockingSingleton.class) {
				if (doubleCheckingLockingSingleton == null) {
					doubleCheckingLockingSingleton = new DoubleCheckingLockingSingleton();
				}
			}
		}

		return doubleCheckingLockingSingleton;
	}
}

Java Volatile keyword

The Java volatile keyword is used to mark a Java variable as “being stored in main memory”. More precisely that means, that every read of a volatile variable will be read from the computer’s main memory, and not from the CPU cache, and that every write to a volatile variable will be written to main memory, and not just to the CPU cache. Actually, since Java 5 the volatile keyword guarantees more than just that volatile variables are written to and read from main memory. Since Java 5 the volatile keyword guarantees also

If Thread A writes to a volatile variable and Thread B subsequently reads the same volatile variable, then all variables visible to Thread A before writing the volatile variable, will also be visible to Thread B after it has read the volatile variable.
The reading and writing instructions of volatile variables cannot be reordered by the JVM (the JVM may reorder instructions for performance reasons as long as the JVM detects no change in program behaviour from the reordering). Instructions before and after can be reordered, but the volatile read or write cannot be mixed with these instructions. Whatever instructions follow a read or write of a volatile variable are guaranteed to happen after the read or write.

Example

Source Code Repository

Factory Pattern

Sun, 04 Dec 2016 23:55:00 +0000

Definition

Factory Method Pattern

The factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method—either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.

Abstract Factory Pattern

The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes.

Dependency Inversion Principle

he dependency inversion principle refers to a specific form of decoupling software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details.

High-level modules should not depend on low-level modules. Both should depend on abstractions.
Abstractions should not depend on details. Details should depend on abstractions.

Example

Source Code Repository

This example is based on Head-First example which uses Pizza & PizzaStore

There are a lot of kinds of Pizza. So you can use factory to create pizza object.

Each location has its own style to create pizza. Because of that PizzaStore declares as a abstract class, and each chain stores inherent it. The important thing is create-method is declared as a abstract which is need to be implemented by each concrete classes. The result of which, it can encapsulate the instance creation logic. And instance creation is executed by each concrete classes, it can be easily changed. This pattern is called as ‘Factory-Method-Pattern’

But, There are a lot of objects. And PizzaStore has dependency with all the concrete Pizza objects. Decoupling is important. So in this case we need to focus how to decouple between PizzaStore and Pizza. The biggest problem is PizzaStore depends on each style concrete pizza. Even though each branch store has its own style, we don’t need to create all the pizza objects for each store’s style if we abstract the pizza style. The difference among each chain stores is ingredients. So if we apply Abstract Factory to create pizza ingredient objects for each chain’s style all over the pizza, then we don’t need to declare each concrete styles of pizza object.

Decorator Pattern

Sun, 27 Nov 2016 23:55:00 +0000

Definition

The Decorator pattern (also known as Wrapper, an alternative naming shared with the Adapter pattern) is a design pattern that allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern.

OCP (Open-Closed Principle)

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification. That is, such an entity can allow its behaviour to be extended without modifying its source code.

Decorator’s super class is Component that is same with the decorated object’s super class.
Component can be wrapped by multiple decorators.
Decorator has same super class with Component. So it can has Decorator as a Component.
Decorator can add new behavior to Component, and it also can execute additional task.
At runtime, Decorator can be applied at any time when it needs.

Cons

A lot of ConcreteDecorator classes.
Initializing object will be complex. Because sometimes it needs to be wrapped by lots of decorators.

Example

Java I/O is one of the most famous example in Decorator pattern.

InputStream class is Component.

public abstract class InputStream implements Closeable {
	private static final int MAX_SKIP_BUFFER_SIZE = 2048;

	public abstract int read() throws IOException;

	public int read(byte b[]) throws IOException {
		return read(b, 0, b.length);
	}

	public int read(byte b[], int off, int len) throws IOException {
		if (b == null) {
			throw new NullPointerException();
		} else if (off < 0 || len < 0 || len > b.length - off) {
			throw new IndexOutOfBoundsException();
		} else if (len == 0) {
			return 0;
		}

		int c = read();
		if (c == -1) {
			return -1;
		}
		b[off] = (byte)c;

		int i = 1;
		try {
			for (; i < len ; i++) {
				c = read();
				if (c == -1) {
					break;
				}
				b[off + i] = (byte)c;
			}
		} catch (IOException ee) {
		}
		return i;
	}

	public long skip(long n) throws IOException {

		long remaining = n;
		int nr;

		if (n <= 0) {
			return 0;
		}

		int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
		byte[] skipBuffer = new byte[size];
		while (remaining > 0) {
			nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
			if (nr < 0) {
				break;
			}
			remaining -= nr;
		}

		return n - remaining;
	}

	public int available() throws IOException {
		return 0;
	}

	public void close() throws IOException {}

	public synchronized void mark(int readlimit) {}

	public synchronized void reset() throws IOException {
		throw new IOException("mark/reset not supported");
	}

	public boolean markSupported() {
		return false;
	}

}

FileInputStream is Concrete Component Class

public class FileInputStream extends java.io.InputStream {
	private final FileDescriptor fd;

	private final String path;

	private FileChannel channel = null;

	private final Object closeLock = new Object();
	private volatile boolean closed = false;

	public FileInputStream(String name) throws FileNotFoundException {
		this(name != null ? new File(name) : null);
	}

	public FileInputStream(File file) throws FileNotFoundException {
		String name = (file != null ? file.getPath() : null);
		SecurityManager security = System.getSecurityManager();
		if (security != null) {
			security.checkRead(name);
		}
		if (name == null) {
			throw new NullPointerException();
		}
		if (file.isInvalid()) {
			throw new FileNotFoundException("Invalid file path");
		}
		fd = new FileDescriptor();
		fd.attach(this);
		path = name;
		open(name);
	}

	public FileInputStream(FileDescriptor fdObj) {
		SecurityManager security = System.getSecurityManager();
		if (fdObj == null) {
			throw new NullPointerException();
		}
		if (security != null) {
			security.checkRead(fdObj);
		}
		fd = fdObj;
		path = null;

        /*
         * FileDescriptor is being shared by streams.
         * Register this stream with FileDescriptor tracker.
         */
		fd.attach(this);
	}

	private native void open0(String name) throws FileNotFoundException;

	private void open(String name) throws FileNotFoundException {
		open0(name);
	}

	public int read() throws IOException {
		return read0();
	}

	private native int read0() throws IOException;

	private native int readBytes(byte b[], int off, int len) throws IOException;

	public int read(byte b[]) throws IOException {
		return readBytes(b, 0, b.length);
	}

	public int read(byte b[], int off, int len) throws IOException {
		return readBytes(b, off, len);
	}

	public native long skip(long n) throws IOException;

	public native int available() throws IOException;

	public void close() throws IOException {
		synchronized (closeLock) {
			if (closed) {
				return;
			}
			closed = true;
		}
		if (channel != null) {
			channel.close();
		}

		fd.closeAll(new Closeable() {
			public void close() throws IOException {
				close0();
			}
		});
	}

	public final FileDescriptor getFD() throws IOException {
		if (fd != null) {
			return fd;
		}
		throw new IOException();
	}

	public FileChannel getChannel() {
		synchronized (this) {
			if (channel == null) {
				channel = FileChannelImpl.open(fd, path, true, false, this);
			}
			return channel;
		}
	}

	private static native void initIDs();

	private native void close0() throws IOException;

	static {
		initIDs();
	}

	protected void finalize() throws IOException {
		if ((fd != null) &&  (fd != FileDescriptor.in)) {
            /* if fd is shared, the references in FileDescriptor
             * will ensure that finalizer is only called when
             * safe to do so. All references using the fd have
             * become unreachable. We can call close()
             */
			close();
		}
	}
}

FilterInputStream is decorator class.

public class FilterInputStream extends java.io.InputStream {
	protected volatile java.io.InputStream in;

	protected FilterInputStream(java.io.InputStream in) {
		this.in = in;
	}

	public int read() throws IOException {
		return in.read();
	}

	public int read(byte b[]) throws IOException {
		return read(b, 0, b.length);
	}

	public int read(byte b[], int off, int len) throws IOException {
		return in.read(b, off, len);
	}

	public long skip(long n) throws IOException {
		return in.skip(n);
	}

	public int available() throws IOException {
		return in.available();
	}

	public void close() throws IOException {
		in.close();
	}

	public synchronized void mark(int readlimit) {
		in.mark(readlimit);
	}

	public synchronized void reset() throws IOException {
		in.reset();
	}

	public boolean markSupported() {
		return in.markSupported();
	}
}

BufferedInputStream is Concrete Decorator class.

public class BufferedInputStream extends java.io.FilterInputStream {

	private static int DEFAULT_BUFFER_SIZE = 8192;
	private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;

	protected volatile byte buf[];

	private static final
	AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
			AtomicReferenceFieldUpdater.newUpdater
					(BufferedInputStream.class,  byte[].class, "buf");

	protected int count;

	protected int pos;

	protected int markpos = -1;

	protected int marklimit;


	private java.io.InputStream getInIfOpen() throws IOException {
		java.io.InputStream input = in;
		if (input == null)
			throw new IOException("Stream closed");
		return input;
	}

	private byte[] getBufIfOpen() throws IOException {
		byte[] buffer = buf;
		if (buffer == null)
			throw new IOException("Stream closed");
		return buffer;
	}

	public BufferedInputStream(java.io.InputStream in) {
		this(in, DEFAULT_BUFFER_SIZE);
	}

	public BufferedInputStream(java.io.InputStream in, int size) {
		super(in);
		if (size <= 0) {
			throw new IllegalArgumentException("Buffer size <= 0");
		}
		buf = new byte[size];
	}

	private void fill() throws IOException {
		byte[] buffer = getBufIfOpen();
		if (markpos < 0)
			pos = 0;            /* no mark: throw away the buffer */
		else if (pos >= buffer.length)  /* no room left in buffer */
			if (markpos > 0) {  /* can throw away early part of the buffer */
				int sz = pos - markpos;
				System.arraycopy(buffer, markpos, buffer, 0, sz);
				pos = sz;
				markpos = 0;
			} else if (buffer.length >= marklimit) {
				markpos = -1;   /* buffer got too big, invalidate mark */
				pos = 0;        /* drop buffer contents */
			} else if (buffer.length >= MAX_BUFFER_SIZE) {
				throw new OutOfMemoryError("Required array size too large");
			} else {            /* grow buffer */
				int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
						pos * 2 : MAX_BUFFER_SIZE;
				if (nsz > marklimit)
					nsz = marklimit;
				byte nbuf[] = new byte[nsz];
				System.arraycopy(buffer, 0, nbuf, 0, pos);
				if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
					// Can't replace buf if there was an async close.
					// Note: This would need to be changed if fill()
					// is ever made accessible to multiple threads.
					// But for now, the only way CAS can fail is via close.
					// assert buf == null;
					throw new IOException("Stream closed");
				}
				buffer = nbuf;
			}
		count = pos;
		int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
		if (n > 0)
			count = n + pos;
	}

	public synchronized int read() throws IOException {
		if (pos >= count) {
			fill();
			if (pos >= count)
				return -1;
		}
		return getBufIfOpen()[pos++] & 0xff;
	}

	private int read1(byte[] b, int off, int len) throws IOException {
		int avail = count - pos;
		if (avail <= 0) {
            /* If the requested length is at least as large as the buffer, and
               if there is no mark/reset activity, do not bother to copy the
               bytes into the local buffer.  In this way buffered streams will
               cascade harmlessly. */
			if (len >= getBufIfOpen().length && markpos < 0) {
				return getInIfOpen().read(b, off, len);
			}
			fill();
			avail = count - pos;
			if (avail <= 0) return -1;
		}
		int cnt = (avail < len) ? avail : len;
		System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
		pos += cnt;
		return cnt;
	}

	public synchronized int read(byte b[], int off, int len)
			throws IOException
	{
		getBufIfOpen(); // Check for closed stream
		if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
			throw new IndexOutOfBoundsException();
		} else if (len == 0) {
			return 0;
		}

		int n = 0;
		for (;;) {
			int nread = read1(b, off + n, len - n);
			if (nread <= 0)
				return (n == 0) ? nread : n;
			n += nread;
			if (n >= len)
				return n;
			// if not closed but no bytes available, return
			java.io.InputStream input = in;
			if (input != null && input.available() <= 0)
				return n;
		}
	}

	public synchronized long skip(long n) throws IOException {
		getBufIfOpen(); // Check for closed stream
		if (n <= 0) {
			return 0;
		}
		long avail = count - pos;

		if (avail <= 0) {
			// If no mark position set then don't keep in buffer
			if (markpos <0)
				return getInIfOpen().skip(n);

			// Fill in buffer to save bytes for reset
			fill();
			avail = count - pos;
			if (avail <= 0)
				return 0;
		}

		long skipped = (avail < n) ? avail : n;
		pos += skipped;
		return skipped;
	}

	public synchronized int available() throws IOException {
		int n = count - pos;
		int avail = getInIfOpen().available();
		return n > (Integer.MAX_VALUE - avail)
				? Integer.MAX_VALUE
				: n + avail;
	}

	public synchronized void mark(int readlimit) {
		marklimit = readlimit;
		markpos = pos;
	}

	public synchronized void reset() throws IOException {
		getBufIfOpen(); // Cause exception if closed
		if (markpos < 0)
			throw new IOException("Resetting to invalid mark");
		pos = markpos;
	}

	public boolean markSupported() {
		return true;
	}

	public void close() throws IOException {
		byte[] buffer;
		while ( (buffer = buf) != null) {
			if (bufUpdater.compareAndSet(this, buffer, null)) {
				InputStream input = in;
				in = null;
				if (input != null)
					input.close();
				return;
			}
			// Else retry in case a new buf was CASed in fill()
		}
	}
}


FileInputStream fis = new FileInputStream("path");
BufferedInputStream bis = new BufferedInputStream(fis);

bis.read()

FileInputStream is InputStream that can read data from file. And BufferedInputStream is a decorator of InputStream that has a buffer to optimize performance. It reads many bytes at a time from the stream to buffer. When you execute above code, then file will be read through the buffer like below.

functional style

If the Component has single abstract method, then we can easily implements decorator pattern with chaining of lambda expressions. Below example is closer to Builder pattern that is usually used with Decorator pattern.

Component

public interface Beverage {
	public abstract String getDescription();
	public abstract double cost();
}

Concrete Component

public class Espresso implements Beverage {
	@Override
	public String getDescription() {
		return "espresso";
	}

	@Override
	public double cost() {
		return 1.99;
	}
}

Decorator

public abstract class CondimentDecorator implements Beverage {
	Beverage beverage;

	protected CondimentDecorator(Beverage beverage) {
		this.beverage = beverage;
	}
}

Concrete Decorator

public class Mocha extends CondimentDecorator {
	protected Mocha(Beverage beverage) {
		super(beverage);
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", mocha";
	}

	@Override
	public double cost() {
		return 0.2 + beverage.cost();
	}
}

public class Whip extends CondimentDecorator {
	protected Whip(Beverage beverage) {
		super(beverage);
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", whip";
	}

	@Override
	public double cost() {
		return 0.3 + beverage.cost();
	}
}

functional style helper

public interface DecoratingBeverage extends Beverage {
	static DecoratingBeverage from(Beverage beverage) {
		return new DecoratingBeverage() {
			@Override
			public String getDescription() {
				return beverage.getDescription();
			}

			@Override
			public double cost() {
				return beverage.cost();
			}
		};
	}

	default DecoratingBeverage decorate(Function<? super DecoratingBeverage, ? extends Beverage> decorator) {
		Beverage beverage = decorator.apply(this);
		return from(beverage);
	}
}

use case

public class Order {
	static void print(Beverage beverage) {
		System.out.println(beverage.getDescription() + " $" + beverage.cost());
	}

	public static void main(String[] args) {
		Beverage newOrderedBeverage = DecoratingBeverage.from(new Espresso())
				.decorate(beverage -> new Mocha(beverage))
				.decorate(beverage -> new Whip(beverage));

		print(newOrderedBeverage);
	}
}