[refactor] Remove unnecessary declarations in service-locator pattern.

service-locator/src/main/java/com/iluwatar/App.java

@@ -1,20 +1,20 @@
 package com.iluwatar;
+
 /**
- * Service locator pattern, used to lookup jndi services 
+ * Service locator pattern, used to lookup jndi services
- * and cache them for subsequent requests. 
+ * and cache them for subsequent requests.
- * @author saifasif
  *
+ * @author saifasif
  */
 public class App {
-	public static void main(String[] args) {
+    public static void main(String[] args) {
-		Service service = ServiceLocator.getService("jndi/serviceA");
+        Service service = ServiceLocator.getService("jndi/serviceA");
-		service.execute();
+        service.execute();
-		service = ServiceLocator.getService("jndi/serviceB");
+        service = ServiceLocator.getService("jndi/serviceB");
-		service.execute();
+        service.execute();
-		service = ServiceLocator.getService("jndi/serviceA");
+        service = ServiceLocator.getService("jndi/serviceA");
-		service.execute();
+        service.execute();
-		service = ServiceLocator.getService("jndi/serviceA");
+        service = ServiceLocator.getService("jndi/serviceA");
-		service.execute();		
+        service.execute();
-	}	
+    }
-
 }

service-locator/src/main/java/com/iluwatar/InitContext.java

@@ -3,27 +3,27 @@ package com.iluwatar;
 /**
  * For JNDI lookup of services from the web.xml. Will match name of the service name that
  * is being requested and return a newly created service object with the name
- * @author saifasif
  *
+ * @author saifasif
  */
 public class InitContext {
 
-	/**
+    /**
-	 * Perform the lookup based on the service name. The returned object will need to be
+     * Perform the lookup based on the service name. The returned object will need to be
-	 * casted into a {@link Service}
+     * casted into a {@link Service}
-	 * @param serviceName
+     *
-	 * @return 
+     * @param serviceName a string
-	 */
+     * @return an {@link Object}
-	public Object lookup(String serviceName){
+     */
-		if( serviceName.equals("jndi/serviceA") ){
+    public Object lookup(String serviceName) {
-			System.out.println("Looking up service A and creating new service for A");
+        if (serviceName.equals("jndi/serviceA")) {
-			return new ServiceImpl("jndi/serviceA");
+            System.out.println("Looking up service A and creating new service for A");
-		} else if( serviceName.equals("jndi/serviceB") ){
+            return new ServiceImpl("jndi/serviceA");
-			System.out.println("Looking up service B and creating new service for B");
+        } else if (serviceName.equals("jndi/serviceB")) {
-			return new ServiceImpl("jndi/serviceB");
+            System.out.println("Looking up service B and creating new service for B");
-		} else {
+            return new ServiceImpl("jndi/serviceB");
-			return null;
+        } else {
-		}
+            return null;
-	}
+        }
-
+    }
 }

service-locator/src/main/java/com/iluwatar/Service.java

@@ -14,16 +14,15 @@ public interface Service {
 	/*
 	 * The human readable name of the service
 	 */
-	public String getName();
+	String getName();
 	
 	/*
 	 * Unique ID of the particular service
 	 */
-	public int getId();
+	int getId();
 	
 	/*
 	 * The workflow method that defines what this service does
 	 */
-	public void execute();
+	void execute();
-
 }

service-locator/src/main/java/com/iluwatar/ServiceCache.java

@@ -5,42 +5,43 @@ import java.util.Map;
 
 /**
  * The service cache implementation which will cache services that are being created.
- * On first hit, the cache will be empty and thus any service that is being requested, will be 
+ * On first hit, the cache will be empty and thus any service that is being requested, will be
  * created fresh and then placed into the cache map. On next hit, if same service name will
- * be requested, it will be returned from the cache 
+ * be requested, it will be returned from the cache
- * @author saifasif
  *
+ * @author saifasif
  */
 public class ServiceCache {
-	
-	private Map<String, Service> serviceCache;
 
-	public ServiceCache() {
+    private final Map<String, Service> serviceCache;
-		serviceCache = new HashMap<String, Service>();
-	}
 
-	/**
+    public ServiceCache() {
-	 * Get the service from the cache. null if no service is found matching the 
+        serviceCache = new HashMap<String, Service>();
-	 * name
+    }
-	 * @param serviceName
-	 * @return {@link Service}
-	 */
-	public Service getService(String serviceName){
-		Service cachedService = null;
-		for (String serviceJndiName : serviceCache.keySet()){
-			if( serviceJndiName.equals( serviceName ) ){
-				cachedService = serviceCache.get(serviceJndiName);
-				System.out.println("(cache call) Fetched service " + cachedService.getName() + "("+cachedService.getId()+") from cache... !");
-			}
-		}
-		return cachedService;
-	}
 
-	/**
+    /**
-	 * Adds the service into the cache map
+     * Get the service from the cache. null if no service is found matching the name
-	 * @param newService
+     *
-	 */
+     * @param serviceName a string
-	public void addService(Service newService){
+     * @return {@link Service}
-		serviceCache.put(newService.getName(), newService);
+     */
-	}
+    public Service getService(String serviceName) {
+        Service cachedService = null;
+        for (String serviceJndiName : serviceCache.keySet()) {
+            if (serviceJndiName.equals(serviceName)) {
+                cachedService = serviceCache.get(serviceJndiName);
+                System.out.println("(cache call) Fetched service " + cachedService.getName() + "(" + cachedService.getId() + ") from cache... !");
+            }
+        }
+        return cachedService;
+    }
+
+    /**
+     * Adds the service into the cache map
+     *
+     * @param newService a {@link Service}
+     */
+    public void addService(Service newService) {
+        serviceCache.put(newService.getName(), newService);
+    }
 }

service-locator/src/main/java/com/iluwatar/ServiceImpl.java

@@ -1,37 +1,37 @@
 package com.iluwatar;
 
 /**
- * This is a single service implementation of a sample service. This is the actual 
+ * This is a single service implementation of a sample service. This is the actual
- * service that will process the request. The reference for this service is to 
+ * service that will process the request. The reference for this service is to
  * be looked upon in the JNDI server that can be set in the web.xml deployment descriptor
- * @author saifasif
  *
+ * @author saifasif
  */
 public class ServiceImpl implements Service {
-	
-	private String serviceName;
-	private int id;
-	
-	public ServiceImpl(String serviceName) {
-		// set the service name
-		this.serviceName = serviceName;
-		
-		// Generate a random id to this service object
-		this.id = (int)Math.floor(Math.random()*1000)+1;
-	}
 
-	@Override
+    private final String serviceName;
-	public String getName() {
+    private final int id;
-		return serviceName;
-	}
 
-	@Override
+    public ServiceImpl(String serviceName) {
-	public int getId() {
+        // set the service name
-		return id;
+        this.serviceName = serviceName;
-	}
 
-	@Override
+        // Generate a random id to this service object
-	public void execute() {
+        this.id = (int) Math.floor(Math.random() * 1000) + 1;
-		System.out.println("Service " + getName() + " is now executing with id " + getId());
+    }
-	}
+
+    @Override
+    public String getName() {
+        return serviceName;
+    }
+
+    @Override
+    public int getId() {
+        return id;
+    }
+
+    @Override
+    public void execute() {
+        System.out.println("Service " + getName() + " is now executing with id " + getId());
+    }
 }

service-locator/src/main/java/com/iluwatar/ServiceLocator.java

@@ -3,35 +3,34 @@ package com.iluwatar;
 /**
  * The service locator module.
  * Will fetch service from cache, otherwise creates a fresh service and update cache
- * 
- * @author saifasif
  *
+ * @author saifasif
  */
 public class ServiceLocator {
-	
+
-	private static ServiceCache serviceCache = new ServiceCache();
+    private static ServiceCache serviceCache = new ServiceCache();
-	
+
-	/**
+    /**
-	 * Fetch the service with the name param from the cache first, 
+     * Fetch the service with the name param from the cache first,
-	 * if no service is found, lookup the service from the {@link InitContext} and 
+     * if no service is found, lookup the service from the {@link InitContext} and
-	 * then add the newly created service into the cache map for future requests.
+     * then add the newly created service into the cache map for future requests.
-	 * @param serviceJndiName
+     *
-	 * @return {@link Service}
+     * @param serviceJndiName a string
-	 */
+     * @return {@link Service}
-	public static Service getService(String serviceJndiName){
+     */
-		Service serviceObj = serviceCache.getService(serviceJndiName);
+    public static Service getService(String serviceJndiName) {
-		if ( serviceObj != null ){
+        Service serviceObj = serviceCache.getService(serviceJndiName);
-			return serviceObj;
+        if (serviceObj != null) {
-		} else {
+            return serviceObj;
-			/*
+        } else {
-			 * If we are unable to retrive anything from cache, then 
+            /*
+             * If we are unable to retrive anything from cache, then
 			 * lookup the service and add it in the cache map
 			 */
-			InitContext ctx = new InitContext();
+            InitContext ctx = new InitContext();
-			serviceObj = (Service) ctx.lookup(serviceJndiName);
+            serviceObj = (Service) ctx.lookup(serviceJndiName);
-			serviceCache.addService(serviceObj);
+            serviceCache.addService(serviceObj);
-			return serviceObj;
+            return serviceObj;
-		}
+        }
-	}
+    }
-
 }