Builder Design Pattern (simple way)

August 25, 2015 admin Leave a comment

This design pattern allows us to create an object with the advantage that the same construction process can create different representations of that object. Here is the simplest implementation of this design pattern.

In a next tutorial we will explain the other way of doing the same thing, with more flexibility but with a more complex implementation.

So, let’s start creating a car!

package pt.joaobrito.builder;

/**
 * This is the class that we will create object of
 */
class Car {

	private String brand, model, version;

	/**
	 * This private constructor avoids the user to create the object in the complex way
	 * using the new keyword.
	 */
	private Car() {}

	/**
	 * This method allows us to get the builder of the car without instantiating the car
	 * 
	 * @return the builder instance
	 */
	public static Builder getBuilder() { return new Builder(); }

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

	public String getModel() { return this.model; }

	public String getVersion() { return this.version; }

	/**
	 * This is the printable version of the car
	 * @return a printable car
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder("Your new car -> ");
		if (brand != null) { sb.append("brand: " + brand); }
		if (model != null) { sb.append(", model: " + model); }
		if (version != null) { sb.append(", version: " + version); }
		return sb.toString();
	}

	/**
	 * This class is the builder itself.
	 * Notice that in every builder method we always return the builder instance. 
	 * This allows us to continue building more parts of the car in one single line.
	 */
	static final class Builder {

		/**
		 * Here we keep an instance of the car we are building. When finished we return it.
		 */
		private final Car car = new Car();

		/**
		 * This is the method that return the car we previously built (or not)
		 * @return
		 */
		public Car getInstance() { return car.getBrand() == null ? null : car; }

		public Builder buildBrand(String brand) {
			this.car.brand = brand;
			return this;
		}

		public Builder buildModel(String model) {
			this.car.model = model;
			return this;
		}

		public Builder buildVersion(String version) {
			this.car.version = version;
			return this;
		}
	}

}

public class Builder {

	public static void main(String[] args) {
		Car c1 = Car.getBuilder().buildBrand("BMW").buildModel("Serie 5").buildVersion("535d Touring").getInstance();
		Car c2 = Car.getBuilder().buildBrand("VW").buildModel("Passat").getInstance();
		Car c3 = Car.getBuilder().buildModel("Class E").getInstance();
		
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3 == null ? "You don't have a car! Please create a car with a brand defined." : c3);
	}
}

package pt.joaobrito.builder;

/**

* This is the class that we will create object of

class Car {

private String brand, model, version;

/**

* This private constructor avoids the user to create the object in the complex way

* using the new keyword.

private Car() {}

/**

* This method allows us to get the builder of the car without instantiating the car

* @return the builder instance

public static Builder getBuilder() { return new Builder(); }

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

public String getModel() { return this.model; }

public String getVersion() { return this.version; }

/**

* This is the printable version of the car

* @return a printable car

@Override

public String toString() {

StringBuilder sb = new StringBuilder("Your new car -> ");

if (brand != null) { sb.append("brand: " + brand); }

if (model != null) { sb.append(", model: " + model); }

if (version != null) { sb.append(", version: " + version); }

return sb.toString();

}

/**

* This class is the builder itself.

* Notice that in every builder method we always return the builder instance.

* This allows us to continue building more parts of the car in one single line.

static final class Builder {

/**

* Here we keep an instance of the car we are building. When finished we return it.

private final Car car = new Car();

/**

* This is the method that return the car we previously built (or not)

* @return

public Car getInstance() { return car.getBrand() == null ? null : car; }

public Builder buildBrand(String brand) {

this.car.brand = brand;

return this;

}

public Builder buildModel(String model) {

this.car.model = model;

return this;

}

public Builder buildVersion(String version) {

this.car.version = version;

return this;

}

public class Builder {

public static void main(String[] args) {

Car c1 = Car.getBuilder().buildBrand("BMW").buildModel("Serie 5").buildVersion("535d Touring").getInstance();

Car c2 = Car.getBuilder().buildBrand("VW").buildModel("Passat").getInstance();

Car c3 = Car.getBuilder().buildModel("Class E").getInstance();

System.out.println(c1);

System.out.println(c2);

System.out.println(c3 == null ? "You don't have a car! Please create a car with a brand defined." : c3);

}

The final result:

Development, tutorial

Singleton Design Pattern

August 24, 2015 admin Leave a comment

With his design patttern we allways get the same instance, as you can see next.

The Singleton class:

package pt.joaobrito.singleton;

public final class Singleton {

	/**
	 * A private constructor. This is necessary in order to not allow create a new Singleton object
	 * from the outside with the keyword new
	 */
	private Singleton() {}

	private static final class SingletonHolder {
		public static final Singleton INSTANCE = new Singleton();
	}

	public static final Singleton getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

package pt.joaobrito.singleton;

public final class Singleton {

/**

* A private constructor. This is necessary in order to not allow create a new Singleton object

* from the outside with the keyword new

private Singleton() {}

private static final class SingletonHolder {

public static final Singleton INSTANCE = new Singleton();

}

public static final Singleton getInstance() {

return SingletonHolder.INSTANCE;

}

2. The main class:

package pt.joaobrito.singleton;

public class Main {

	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();

		// test if the reference are the same
		System.out.println(s1 == s2);
	}

}

package pt.joaobrito.singleton;

public class Main {

public static void main(String[] args) {

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

// test if the reference are the same

System.out.println(s1 == s2);

}

3. The result:

UML

Development, tutorial

Reverse String/array recursively

July 24, 2015 admin Leave a comment

Here is an example how to recursively invert the order of a string or an array in Java.

package pt.joaobrito;

public class Recursive {

	/**
	 * The main method
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("Inverted string: " + reverseString("123456789"));

		System.out.print("Inverted array:  ");
		int[] ra = reverseArray(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
		for (int s : ra) {
			System.out.print(s);
		}
		System.out.println("");
	}

	/**
	 * This method inverts the order of the string
	 *
	 * @param s
	 * @return the reverse string
	 */
	public static String reverseString(String s) {
		if (s.length() == 0) {
			return s;
		}
		// recursive call
		return s.substring(s.length() - 1) + reverseString(s.substring(0, s.length() - 1));
	}

	/**
	 * This method inverts the order of the array
	 *
	 * @param array
	 * @return the inverted array
	 */
	public static int[] reverseArray(int[] array) {
		if (array.length <= 1) { // stop condition
			return new int[]{};
		}

		int[] aux = new int[array.length - 2];
		for (int i = 0; i < aux.length; i++) {
			aux[i] = array[i + 1];
		}

		int[] g = reverseArray(aux); // recursive call

		System.arraycopy(g, 0, array, 1, g.length);
		int firstPosition = array[0];
		array[0] = array[array.length - 1];
		array[array.length - 1] = firstPosition;
		return array;
	}

}

package pt.joaobrito;

public class Recursive {

/**

* The main method

* @param args

public static void main(String[] args) {

System.out.println("Inverted string: " + reverseString("123456789"));

System.out.print("Inverted array: ");

int[] ra = reverseArray(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});

for (int s : ra) {

System.out.print(s);

}

System.out.println("");

}

/**

* This method inverts the order of the string

* @param s

* @return the reverse string

public static String reverseString(String s) {

if (s.length() == 0) {

return s;

}

// recursive call

return s.substring(s.length() - 1) + reverseString(s.substring(0, s.length() - 1));

}

/**

* This method inverts the order of the array

* @param array

* @return the inverted array

public static int[] reverseArray(int[] array) {

if (array.length <= 1) { // stop condition

return new int[]{};

}

int[] aux = new int[array.length - 2];

for (int i = 0; i < aux.length; i++) {

aux[i] = array[i + 1];

}

int[] g = reverseArray(aux); // recursive call

System.arraycopy(g, 0, array, 1, g.length);

int firstPosition = array[0];

array[0] = array[array.length - 1];

array[array.length - 1] = firstPosition;

return array;

}

The output is:

Notice that in the string method we have twice the iterations that we have in the array method, because we go through all positions in the string.

If you know other ways of doing it, please feel free to comment it out.

Thanks.

Pocket

Hibernate / JPA 2 Persistence Annotations Tutorial

April 4, 2015 admin Leave a comment

from Pocket http://ift.tt/1FvqQ7Z

This Hibernate (or JPA 2) Persistence Annotations Tutorial contains overview of all important annotations which you may need while annotating your java POJOs to make them act as persistent JPA entities.

web

Java Collections Guide

February 23, 2015 admin Leave a comment

A simple guide to java collections. With this guide you will always know what structure to use regarding your needs.

Thanks.

Posted from WordPress for Android

Pocket

You think you know everything about CDI events… Think again!

February 9, 2015 admin Leave a comment

from Pocket http://ift.tt/1poOQBY

CDI events are one of the shiniest feature in the CDI specification. They are a easy to understand and use and are a straight forward implementation of the Observer Design Pattern.

Pocket

EJB 3.1 @LocalBean vs no annotation

December 23, 2014 admin Leave a comment

from Pocket http://ift.tt/1sRGAJO

The rules are (from memory): Bean has a @LocalBean annotation -> bean has a no-interface view Bean has a @Local annotation -> bean has a local view Bean has a @Remote annotation -> bean has a remote view Bean has no view annotations, but directly implements an interface which has a @Local annotatio

Development, tutorial, web, web development

Decoupling event producers and event consumers in Java EE 6 using CDI and JMS

December 12, 2014 admin Leave a comment

In this post I will show you how to decouple event producer from the event consumers (aka async events).

you must configure your application server (here the glassfish settings):

call the EJB method sendEvent() to send the event (from a servlet or from a web page):

@LocalBean
@Stateless
public class MyEJB {

	@Inject
	@InForeground
	private Event<BaseEvent> event;

	/**
	 * fires the @InForeground event
	 *
	 * @throws InterruptedException
	 */
	public void sendEvent() throws InterruptedException {
		event.fire(new MyEvent("Hello world event", new Date()));
		Thread.sleep(5000);
	}
}

@LocalBean

@Stateless

public class MyEJB {

@Inject

@InForeground

private Event<BaseEvent> event;

/**

* fires the @InForeground event

* @throws InterruptedException

public void sendEvent() throws InterruptedException {

event.fire(new MyEvent("Hello world event", new Date()));

Thread.sleep(5000);

}

the EJB fires the event anotaded with @InForeground qualifier.

An observer method handle the event and send it to the JMS Queue with the help of a message producer:

@Stateless
public class BackgroundEventSender implements BackgroundEventSenderItf {

	@Resource(mappedName = "myConnectionFactory") // the JNDI name for this connection factory
	private ConnectionFactory connectionFactory;

	@Resource(mappedName = "myQueue") // JNDI name for this queue
	private Queue backgroundEventQueue;

	private Connection connection;
	private Session session;
	private MessageProducer producer;

	@PostConstruct
	public void init() {
		try {
			connection = connectionFactory.createConnection();
			session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
			producer = session.createProducer(backgroundEventQueue);
		} catch (JMSException ex) {
			throw new RuntimeException(ex.getMessage(), ex);
		}
	}

	@PreDestroy
	public void destroy() {
		try {
			if (connection != null) {
				connection.close();
			}
		} catch (Exception ex) {
			// todo: handle the exception
		}

	}

	/**
	 * sends the foreground event to the queue with the help of the producer object
	 *
	 * @param event
	 */
	@Override
	public void event(@Observes @InForeground BaseEvent event) {
		try {
			ObjectMessage msg = session.createObjectMessage();
			msg.setObject(event);
			producer.send(msg);
		} catch (JMSException ex) {
			throw new RuntimeException(ex.getMessage(), ex);
		}

	}

}

@Stateless

public class BackgroundEventSender implements BackgroundEventSenderItf {

@Resource(mappedName = "myConnectionFactory") // the JNDI name for this connection factory

private ConnectionFactory connectionFactory;

@Resource(mappedName = "myQueue") // JNDI name for this queue

private Queue backgroundEventQueue;

private Connection connection;

private Session session;

private MessageProducer producer;

@PostConstruct

public void init() {

try {

connection = connectionFactory.createConnection();

session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);

producer = session.createProducer(backgroundEventQueue);

} catch (JMSException ex) {

throw new RuntimeException(ex.getMessage(), ex);

}

@PreDestroy

public void destroy() {

try {

if (connection != null) {

connection.close();

}

} catch (Exception ex) {

// todo: handle the exception

}

/**

* sends the foreground event to the queue with the help of the producer object

* @param event

@Override

public void event(@Observes @InForeground BaseEvent event) {

try {

ObjectMessage msg = session.createObjectMessage();

msg.setObject(event);

producer.send(msg);

} catch (JMSException ex) {

throw new RuntimeException(ex.getMessage(), ex);

}

Now, in another (background) thread, the onMessage method handle the message and fires a new event (which wraps the received event) now annotated with @InBackground qualifier:

@MessageDriven(mappedName = "myQueue", activationConfig = {
	@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
	@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
})
public class BackgroundEventDispatcher implements MessageListener {

	public BackgroundEventDispatcher() {
	}

	@Inject
	@InBackground
	private Event<BaseEvent> event;

	/**
	 * dispatches the message received from the queue and fires a new event (now with the @InBackground qualifier)
	 *
	 * @param message
	 */
	public void onMessage(Message message) {
		if (!(message instanceof ObjectMessage)) {
			throw new RuntimeException("Invalid message type received");
		}
		ObjectMessage msg = (ObjectMessage) message;
		try {
			Serializable eventObject = msg.getObject();
			if (!(eventObject instanceof BaseEvent)) {
				throw new RuntimeException("Unknown event type received");
			}
			BaseEvent evt = (BaseEvent) eventObject;
			this.event.fire(evt);

		} catch (JMSException ex) {
			throw new RuntimeException(ex.getMessage(), ex);
		}
	}
}

@MessageDriven(mappedName = "myQueue", activationConfig = {

@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),

@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")

})

public class BackgroundEventDispatcher implements MessageListener {

public BackgroundEventDispatcher() {

}

@Inject

@InBackground

private Event<BaseEvent> event;

/**

* dispatches the message received from the queue and fires a new event (now with the @InBackground qualifier)

* @param message

public void onMessage(Message message) {

if (!(message instanceof ObjectMessage)) {

throw new RuntimeException("Invalid message type received");

}

ObjectMessage msg = (ObjectMessage) message;

try {

Serializable eventObject = msg.getObject();

if (!(eventObject instanceof BaseEvent)) {

throw new RuntimeException("Unknown event type received");

}

BaseEvent evt = (BaseEvent) eventObject;

this.event.fire(evt);

} catch (JMSException ex) {

throw new RuntimeException(ex.getMessage(), ex);

}

And finally, if you have a method that consumes events annotated with @InBackground qualifier, then you receive the event and process it accordingly to your business needs.

@Stateless
public class EventConsumer implements EventConsumerItf {

	/**
	 * consumes the event sent by the JMS queue
	 *
	 * @param event
	 */
	@Override
	public void afterMyEvent(@Observes @InBackground MyEvent event) {
		System.out.println("Event message: " + event.getData());
		System.out.println("Event time: " + new SimpleDateFormat("yyyy.MM.dd @ HH:mm:ss").format(event.getEventTime()));
	}

}

@Stateless

public class EventConsumer implements EventConsumerItf {

/**

* consumes the event sent by the JMS queue

* @param event

@Override

public void afterMyEvent(@Observes @InBackground MyEvent event) {

System.out.println("Event message: " + event.getData());

System.out.println("Event time: " + new SimpleDateFormat("yyyy.MM.dd @ HH:mm:ss").format(event.getEventTime()));

}

The event object it’s just a POJO like this one:

public class MyEvent extends BaseEvent {

	private String data;

	private Date eventTime;

	public String getData() {
		return data;
	}

	public MyEvent(String data, Date eventTime) {
		this.data = data;
		this.eventTime = eventTime;
	}

	public void setData(String data) {
		this.data = data;
	}

	public Date getEventTime() {
		return eventTime;
	}

	public void setEventTime(Date eventTime) {
		this.eventTime = eventTime;
	}
}

public class MyEvent extends BaseEvent {

private String data;

private Date eventTime;

public String getData() {

return data;

}

public MyEvent(String data, Date eventTime) {

this.data = data;

this.eventTime = eventTime;

}

public void setData(String data) {

this.data = data;

}

public Date getEventTime() {

return eventTime;

}

public void setEventTime(Date eventTime) {

this.eventTime = eventTime;

}

You can get the full code from github. Thank you!

Feel free to comment.

Curiosity, Development

JAVA Dynamic Binding – Another Example

November 29, 2014 admin Leave a comment

In this post I will show you another interesting example of Java Dynamic Binding…

Did you expect such behavior? Feel free to comment. Thanks.

Pocket

Cómo crear una API REST usando Node.JS

November 15, 2014 admin Leave a comment

from Pocket http://ift.tt/1i8gtba

En esta entrada explicaremos como crear un Web Server que sirva una API RESTful usando para ello la tecnología de Node.js y todo el JavaScript que podamos, incluyendo la base de datos (MongoDB) y el plugin para conectarnos a ella y mapear los modelos (Mongoose).

M	T	W	T	F	S	S
					1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

João David Brito

Builder Design Pattern (simple way)

Singleton Design Pattern

Reverse String/array recursively

Hibernate / JPA 2 Persistence Annotations Tutorial

Java Collections Guide

You think you know everything about CDI events… Think again!

EJB 3.1 @LocalBean vs no annotation

Decoupling event producers and event consumers in Java EE 6 using CDI and JMS

JAVA Dynamic Binding – Another Example

Cómo crear una API REST usando Node.JS

software architect

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

software architect