Archive

Posts Tagged ‘Java’

Struts2 Dynamic Method Invocation

April 14, 2017 Leave a comment

Dynamic invocation in Struts2 is used to avoid configuration separate action mapping for each method in action class by using wildcard method.

Look at Struts configuration below.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN" "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
	<constant name="struts.enable.DynamicMethodInvocation" value="true" />
	<constant name="struts.devMode" value="false" />
	<constant name="struts.custom.i18n.resources" value="app-resources" />
	<constant name="struts.action.extension" value="html" />
        <constant name="struts.mapper.action.prefix.enabled" value="true"/>
 
	<package name="default" namespace="/" strict-method-invocation="false" extends="struts-default">

		<action name="*Book" method="{1}" class="strutshelloworld.net.ren.struts2.actions.BookAction">
		      <result name="success">/WEB-INF/jsp/Book.jsp</result>
		</action>
	</package>
</struts>

Action code.

import com.opensymphony.xwork2.ActionSupport;

/**
 * The Class BookAction.
 */
public class BookAction extends ActionSupport {

    /** The message. */
    private String message;

    /* (non-Javadoc)
     * @see com.opensymphony.xwork2.ActionSupport#execute()
     */
    public String execute() {
        message = "Inside execute method";
        return SUCCESS;
    }

    /**
     * Adds the.
     *
     * @return the string
     */
    public String add() {
        message = "Inside add method";
        return SUCCESS;
    }

    /**
     * Update.
     *
     * @return the string
     */
    public String update() {
        message = "Inside update method";
        return SUCCESS;
    }

    /**
     * Delete.
     *
     * @return the string
     */
    public String delete() {
        message = "Inside delete method";
        return SUCCESS;
    }

    /**
     * Gets the message.
     *
     * @return the message
     */
    public String getMessage() {
        return message;
    }

    /**
     * Sets the message.
     *
     * @param message the new message
     */
    public void setMessage(String message) {
        this.message = message;
    }
}

Please consider this as view code

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>In here</title>
</head>
<body>


<h1>Hello Here</h1>


<s:form action="Book">
<s:submit action="addBook" key="label.submit" align="center" />
<s:submit action="updateBook" key="label.update" align="center" />
<s:submit action="deleteBook" key="label.delete" align="center" />
</s:form>
</body>
</html>

As you can see, instead writing different name for each action name, action is provided with name=”*Book” method=”{1}” means if the input is “addBook” or “updateBook” then the add() / update() method will be executed in Action class accordingly.

Please note it, strict-method-invocation (SMI) property in package tag has default value true. For futher reading about Strict Method Invocation (SMI)  you can see in here and here.

Thank you. 🙂

Advertisements

java.lang.ClassNotFoundException: org.Springframework.Web.Context.ContextLoaderListener

March 16, 2017 Leave a comment

How to solve java.lang.ClassNotFoundException: org.Springframework.Web.Context.ContextLoaderListener.

Firstly we must know root cause :
This error because using Spring MVC framework in Java Web application and configured org.springframework.web.context.ContextLoaderListener as a listener in your deployment descriptor also known as web.xml, but the JAR which contains this class is not available in web application’s classpath. This jar appears in spring-web.jar, if you use maven as build tool so make sure that spring-web dependency exist in pom file.


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>

Second, right click web project -> Select “Deployment Assembly” -> Click the “Add..” button on the right -> Select “Java Build Path Entries” from the menu of Directive Type and click “Next” -> Select “Maven Dependencies” from the Java Build Path Entries menu -> Click finish.

Please see picture below.

Build path

Thank you.

Categories: Java, Java and Web Tags: , ,

How To Remove Duplicate Value In Array Without Collection Help

October 27, 2016 Leave a comment

Below how to remove duplicate value in array without collection help


public class RemoveDuplicateManual {

public int[] removeDuplicateNumber(int[] inputArray) {
Arrays.sort(inputArray);
int[] outputArray = new int[inputArray.length];
int previous = inputArray[0];
int observed = 0;
for (int i = 1; i < inputArray.length; i++) {
observed = inputArray[i];
if (previous != observed) {
outputArray[i] = observed;
}
previous = observed;
}

return outputArray;
}
}

🙂

Iterator Pattern

March 22, 2016 Leave a comment

Iterator pattern is used to provide a way to access the elements of an aggregate object sequentially without exposing its internal structure.

Iterator Pattern

Iterator Pattern

Here is example.

SubjectType.java

public enum SubjectType {
     MANDATORY, OPTIONAL, ALL
}

Subject.java

 public class Subject {

    private String name;
    private String lecturer;
    private SubjectType type;
    
    public Subject(){
        
    }
    public Subject(String name, String lecturer, SubjectType type) {
        super();
        this.name = name;
        this.lecturer = lecturer;
        this.type = type;
    }
    public String getName() {
        return name;
    }
    public String getLecturer() {
        return lecturer;
    }
    public SubjectType getType() {
        return type;
    }
    @Override
    public String toString() {
        return "Subject [name=" + name + ", lecturer=" + lecturer + ", type=" + type + "]";
    }

}
 

SubjectCollection.java

public interface SubjectCollection {
    public void addSubject(Subject subject);
    public void removeSubject(Subject subjet);
    public SubjectIterator iterator(SubjectType type);
}

SubjectIterator.java

 public interface SubjectIterator {
   public Boolean hasNext();
   public Subject next();
   public void remove();
} 

SubjectCollectionImpl.java

public class SubjectCollectionImpl implements SubjectCollection {

    private List<Subject> subjects;

    public SubjectCollectionImpl() {
        subjects = new ArrayList<Subject>();
    }

    public void addSubject(Subject subject) {
        subjects.add(subject);
    }

    public void removeSubject(Subject subject) {
        subjects.remove(subject);
    }

    public SubjectIterator iterator(SubjectType type) {
        return new Iterator(type, subjects);
    }

    private class Iterator implements SubjectIterator {

        private SubjectType type;
        private int index;
        private List<Subject> subjects;

        private Iterator(SubjectType type, List<Subject> subjects) {
            this.type = type;
            this.subjects = subjects;
        }

        public Boolean hasNext() {
            while (index < subjects.size()) {
                Subject s = subjects.get(index);
                if (s.getType().equals(type)) {
                    return true;
                } else {
                    index++;
                }
            }
            return false;
        }

        public Subject next() {
            Subject s = subjects.get(index);
            index++;
            return s;
        }

        public void remove() {
            subjects.remove(index);
            index++;
        }

    }
}

App.java

public class App 
{
    public static void main( String[] args )
    {
    	SubjectCollection subjectCollection = populateSubject();
    	SubjectIterator iterator = subjectCollection.iterator(SubjectType.ALL);
    	while(iterator.hasNext()){
    		Subject s = iterator.next();
    		System.out.println(s.toString());
    	}
    	System.out.println("-----------------------");
    	iterator = subjectCollection.iterator(SubjectType.MANDATORY);
    	while(iterator.hasNext()){
    		Subject s = iterator.next();
    		System.out.println(s.toString());
    	}
    	System.out.println("-----------------------");
    	iterator = subjectCollection.iterator(SubjectType.OPTIONAL);
    	while(iterator.hasNext()){
    		Subject s = iterator.next();
    		iterator.remove();
    		System.out.println(s.toString());
    	}
    }
    
    public static SubjectCollection populateSubject(){
    	SubjectCollection subjectCollection = new SubjectCollectionImpl();
    	
    	subjectCollection.addSubject((new Subject("Accounting", "John", SubjectType.OPTIONAL)));
    	subjectCollection.addSubject((new Subject("Art", "Smith", SubjectType.OPTIONAL)));
    	subjectCollection.addSubject((new Subject("Chemistry", "Lennon", SubjectType.ALL)));
    	subjectCollection.addSubject((new Subject("Civil", "Alan", SubjectType.ALL)));
    	subjectCollection.addSubject((new Subject("Economics", "Mike", SubjectType.MANDATORY)));
    	subjectCollection.addSubject((new Subject("Education", "Joe", SubjectType.MANDATORY)));
    	
    	return subjectCollection;
    }
}

Result.

Iterator Result

Iterator Result

Categories: Java Tags: , ,

Observer Pattern

February 20, 2016 Leave a comment

Observer pattern is one to many dependency between object so when object changes state  so all of it dependents are notified. In observer pattern the object that watch on the state of another object are called Observer and the object that is being watched is called Subject / Observable.

Observer Pattern

Observer Pattern

Here is example.

Observer.java

public interface Observer {
 public void update();
}

Dress.java

public class Dress implements Observable {

 private List<Observer> observers;
 private int stock;

 public Dress() {
 observers = new ArrayList<Observer>();
 }

 public void addObserver(Observer observer) {
 observers.add(observer);
 }

 public void notifyObserver() {
 if (getStock() < 1) {
 for (Observer observer : observers) {
 observer.update();
 }
 }
 }

 public int getStock() {
 return stock;
 }

 public void setStock(int stock) {
 this.stock = stock;
 notifyObserver();
 }
}

Observable.java

public interface Observable {
 public void addObserver(Observer observer);
 public void notifyObserver();
}

Buyer.java

public class Buyer implements Observer {

 private String name;
 private String job;

 public String getName() {
 return name;
 }

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

 public String getJob() {
 return job;
 }

 public void setJob(String job) {
 this.job = job;
 }

 public void update() {
 System.out.println("Name " + name + " Job " + job + " get notifcation");
 }

}

Supplier.java

 public class Supplier implements Observer {
 private String name;
 private String address;

 public String getName() {
 return name;
 }

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

 public String getAddress() {
 return address;
 }

 public void setAddress(String address) {
 this.address = address;
 }

 public void update() {
 System.out.println("Supplier " + name + " Address " + address + " get notifcation");
 }
} 
Categories: Java Tags: , ,

Bridge Pattern

January 18, 2016 Leave a comment

Bridge pattern is used to decouple an abstraction from its implementation so that two independent each other. In other words, by moving the set of abstract operations to an interface, so that an abstraction will depend on an implementation of the interface.

Here is example.

Bridge Pattern

Bridge Pattern

 

  • AbstractPrinter as Abstraction to define abstraction to interface and hold reference object of type implementor.
  • ConcretePrinter as RefinedAbstraction to extend interface defined by abstraction.
  • IPrinterDocument as Implementator to define the interface for implementation classes.
  • WordPrinterDocument and PdfPrinterDocument as implementation classes.

 

AbstractPrinter.java

public abstract class AbstractPrinter {

protected IPrinterDocument printerDocument;

public AbstractPrinter(IPrintDocument printerDocument){
this.printerDocument = printerDocument;
}

public abstract void printDocument();
}

ConcretePrinter.java

public class ConcretePrinter extends AbstractPrinter {

public ConcretePrinter(IPrinterDocument printerDocument) {
super(printerDocument);
}

@Override
public void printDocument() {
printerDocument.printDocument();
}
}

IPrinterDocument.java

public interface IPrintDocument {
 public void printDocument();
}

PdfPrinterDocument.java

public class PdfPrinterDocument implements IPrinterDocument {
 
 public void printDocument() {
 System.out.println("Pdf Document is being printed");
 }
}

WorderPrintDocument.java

public class WordPrinterDocument implements IPrinterDocument {
 
 public void printDocument() {
 System.out.println("Word Document is being printed");
 }
}
Categories: Java Tags: , ,

Singleton Pattern

November 15, 2015 Leave a comment

Singleton pattern restrict that only one instance of the class exists in the java virtual machine.  There are several approach to implement singleton pattern but all of them have same common step.

  • Private constructor to restrict instantiation of the class from outside
  • Private static variable of the same class
  • Public method that returns the instance of the class
singleton design pattern

Singleton Pattern

  • Eager Init

In eager init, instance of class is created at the time of class loading even is not needed yet.

public class EagerInit {
	private static volatile EagerInit instance = new EagerInit();

	private EagerInit() {
	}

	public static EagerInit getInstance() {
		return instance;
	}
}
  • Static Block Init

Static block init is similar with eager init.

public class StaticBlockInit {
	private static StaticBlockInit instance;

	private StaticBlockInit() {
	}

	static {
		try {
			instance = new StaticBlockInit();
		} catch (Exception ex) {
			throw new RuntimeException("Exception occured in creating singleton instance");
		}
	}

	public StaticBlockInit getInstance() {
		return instance;
	}
}
  • Lazy Init

In lazy init, instance is created in global access method.

public class LazyInit {
	private static LazyInit instance;

	private LazyInit() {
	}

	public static LazyInit getInstance() {
		if (instance == null) {
			synchronized(LazyInit.class){
				if(instance == null){
					instance = new LazyInit();
				}
			}
		}
		return instance;
	}
}