initial commit

Author: benblack86

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="lib" path="libs/commons-codec-1.7.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -0,0 +1,2 @@
+bin/
+.settings/

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>JavaSnippets</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

README.txt

@@ -0,0 +1,10 @@
+JavaSnippets: Snippets of useful/interesting Java code
+- Java: 1.6
+
+VERSION HISTORY
+
+v1.0
+- Serializing and encoding
+- Example of printing the date
+- Using reflection to make a dynamic object
+

libs/commons-codec-1.7.jar

@@ -0,0 +1,15 @@
+package benblack86.date;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+public class FormatDate {
+
+	public static void main(String args[]) {
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd-HH:mm:ss.SSS");
+		sdf.setCalendar(Calendar.getInstance(TimeZone.getTimeZone("GMT")));
+		
+		System.out.println("NOW: "+sdf.format(System.currentTimeMillis()));
+	}
+}

src/benblack86/date/FormatDate.java

@@ -0,0 +1,12 @@
+package benblack86.dynamic;
+
+public class ObjA extends RequestObject {
+	public String name;
+	public String location;
+	
+	@Override
+	public void execute() {
+		System.out.printf("%s\n", this.toString());
+	}
+
+}

src/benblack86/dynamic/ObjA.java

@@ -0,0 +1,13 @@
+package benblack86.dynamic;
+
+public class ObjB extends RequestObject {
+	public String name;
+	public double height;
+	public double width;
+
+	@Override
+	public void execute() {
+		System.out.printf("%s|area:%s\n", this.toString(), height*width);
+	}
+
+}

src/benblack86/dynamic/ObjB.java

@@ -0,0 +1,75 @@
+package benblack86.dynamic;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RequestHandler {
+	public static void main(String[] args) {
+		RequestHandler requestHandler = new RequestHandler();
+		
+		requestHandler.processRequest("ObjA|name:Ben|location:NYC").execute();
+		requestHandler.processRequest("ObjB|name:Chen|width:40|height:182").execute();
+		requestHandler.processRequest("ObjB|name:Izo|height:100").execute();
+	}
+	
+	public RequestObject processRequest(String input) {
+		try {
+			String[] components = input.split("\\|");
+			
+			// create the object requested and get its fields
+			Class<?> requestClass = Class.forName("benblack86.dynamic." + components[0]);
+			RequestObject object = (RequestObject) requestClass.newInstance();
+			Field[] fields = requestClass.getFields();
+			
+			// create a map for quick access (should cache in real system)
+			Map<String, Field> nameToField = new HashMap<String, Field>();
+			for(int i = 0; i< fields.length; i++) {
+				nameToField.put(fields[i].getName(), fields[i]);
+			}
+			
+			// loop over components and set value on to object
+			for(int i = 1; i < components.length; i++) {
+				int split = components[i].indexOf(":");
+				String variable = components[i].substring(0, split);
+				String value = components[i].substring(split+1);
+				
+				Field field = nameToField.get(variable);
+				
+				if(field != null) {
+					field.set(object, stringToObject(field.getType(), value));
+				}
+				
+			}
+			
+			
+			return object;
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+		
+		return null;
+	}
+	
+	private Object stringToObject(Class<?> parameter, String value) {
+		if(parameter == String.class) {
+			return value;
+		} else if(parameter == boolean.class || parameter == Boolean.class) {
+			return Boolean.valueOf(value);
+		} else if(parameter == int.class || parameter == Integer.class) {
+			return Integer.valueOf(value);
+		} else if(parameter == double.class || parameter == Double.class) {
+			return Double.valueOf(value);
+		} else if(parameter == long.class || parameter == Long.class) {
+			return Long.valueOf(value);
+		} else if(parameter == short.class || parameter == Short.class) {
+			return Short.valueOf(value);
+		} else if(parameter == float.class || parameter == Float.class) {
+			return Float.valueOf(value);
+		} else if(parameter == byte.class || parameter == Byte.class) {
+			return Byte.valueOf(value);
+		}
+
+		return null;
+	}
+}

src/benblack86/dynamic/RequestHandler.java

@@ -0,0 +1,24 @@
+package benblack86.dynamic;
+
+import java.lang.reflect.Field;
+
+public abstract class RequestObject {
+	public String toString() {
+		StringBuffer prop = new StringBuffer(this.getClass().getSimpleName());
+		try {
+			Class<?> requestClass = this.getClass();
+			Field[] fields = requestClass.getFields();
+
+			for(int i = 0; i < fields.length; i++ ) {
+				prop.append("|").append(fields[i].getName()).append(":").append(fields[i].get(this));
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+
+		return prop.toString();
+	}
+
+	public abstract void execute();
+}

src/benblack86/dynamic/RequestObject.java

@@ -0,0 +1,99 @@
+package benblack86.properties;
+
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum PropertiesManager {
+	INSTANCE;
+
+	public static void main(String[] args) {
+		System.out.printf("Prop1:%s\n", PropertiesManager.INSTANCE.isProp1());
+		System.out.printf("Prop2:%s\n", PropertiesManager.INSTANCE.getProp2());
+		System.out.printf("Prop3:%s\n", PropertiesManager.INSTANCE.getProp3());
+	}
+	
+	
+	private boolean prop1;
+	private String prop2;
+	private int prop3;
+
+	private PropertiesManager() {
+		try {
+			Map<String, Method> methods = new HashMap<String, Method>();
+
+			for(PropertyDescriptor propertyDescriptor : Introspector.getBeanInfo(this.getClass()).getPropertyDescriptors()){
+			   if(propertyDescriptor.getWriteMethod() != null) {
+				   String name = propertyDescriptor.getWriteMethod().getName();
+
+				   // cut off "set" from method name
+				   if(name.startsWith("set")) {
+				   	   methods.put(name.substring(3), propertyDescriptor.getWriteMethod());
+				   }
+			   }
+			}
+			
+			// normally this data would be loaded from somewhere
+			Map<String, String> properties = new HashMap<String, String>();
+			properties.put("Prop1", "true");
+			properties.put("Prop2", "hello");
+			properties.put("Prop3", "34");
+
+			for(String property : properties.keySet()) {
+				if(methods.containsKey(property)) {
+					Method method = methods.get(property);
+
+					Class<?> parameter = method.getParameterTypes()[0];
+
+					if(parameter == String.class) {
+						method.invoke(this, properties.get(property));
+					} else if(parameter == boolean.class || parameter == Boolean.class) {
+						method.invoke(this, Boolean.valueOf(properties.get(property)));
+					} else if(parameter == int.class || parameter == Integer.class) {
+						method.invoke(this, Integer.valueOf(properties.get(property)));
+					} else if(parameter == double.class || parameter == Double.class) {
+						method.invoke(this, Double.valueOf(properties.get(property)));
+					} else if(parameter == long.class || parameter == Long.class) {
+						method.invoke(this, Long.valueOf(properties.get(property)));
+					} else if(parameter == short.class || parameter == Short.class) {
+						method.invoke(this, Short.valueOf(properties.get(property)));
+					} else if(parameter == float.class || parameter == Float.class) {
+						method.invoke(this, Float.valueOf(properties.get(property)));
+					} else if(parameter == byte.class || parameter == Byte.class) {
+						method.invoke(this, Byte.valueOf(properties.get(property)));
+					}
+				} else {
+					throw new Exception("property "+property+" not definned in PropertiesManager");
+				}
+			}
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public boolean isProp1() {
+		return prop1;
+	}
+
+	public void setProp1(boolean prop1) {
+		this.prop1 = prop1;
+	}
+
+	public String getProp2() {
+		return prop2;
+	}
+
+	public void setProp2(String prop2) {
+		this.prop2 = prop2;
+	}
+
+	public int getProp3() {
+		return prop3;
+	}
+
+	public void setProp3(int prop3) {
+		this.prop3 = prop3;
+	}
+}

src/benblack86/properties/PropertiesManager.java

@@ -0,0 +1,48 @@
+package benblack86.serialize;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import org.apache.commons.codec.binary.Base64;
+
+/**
+ * Requires commons-codec for the encoding/decoding
+ *
+ */
+public class SerializeEncoder {
+
+	public static void main(String[] args) {
+		try {
+			String example = "Hello world";
+			
+			String encode = SerializeEncoder.seralizeAndEncode(example);
+			String decode = SerializeEncoder.decodeAndDesealize(encode);
+			
+			System.out.printf("Encode: %s\n", encode);
+			System.out.printf("Decode: %s\n", decode);
+			
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	
+	public static String seralizeAndEncode(String value) throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		ObjectOutputStream oos = new ObjectOutputStream(baos);
+		oos.writeObject(value);
+		oos.close();
+		return new String(Base64.encodeBase64(baos.toByteArray()));
+	}
+
+	public static String decodeAndDesealize(String value) throws IOException, ClassNotFoundException {
+		byte data[] = Base64.decodeBase64(value);
+		ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));
+		Object o = ois.readObject();
+		ois.close();
+		return (String)o;
+	}
+}