랄라라

Using Java Reflection you can inspect the methods of classes and invoke them at runtime. This is done via the Java class java.lang.reflect.Method. This text will get into more detail about the Java Method object.

Obtaining Method Objects

The Method class is obtained from the Class object. Here is an example:

Class aClass = ...//obtain class object
Method[] methods = aClass.getMethods();

The Method[] array will have one Method instance for each public method declared in the class.

If you know the precise parameter types of the method you want to access, you can do so rather than obtain the array all methods. This example returns the public method named "doSomething", in the given class which takes a Stringas parameter:

Class  aClass = ...//obtain class object
Method method =
    aClass.getMethod("doSomething", new Class[]{String.class});

If no method matches the given method name and arguments, in this case String.class, aNoSuchMethodException is thrown.

If the method you are trying to access takes no parameters, pass null as the parameter type array, like this:

Class  aClass = ...//obtain class object
Method method =
    aClass.getMethod("doSomething", null);

Method Parameters and Return Types

You can read what parameters a given method takes like this:

Method method = ... // obtain method - see above
Class[] parameterTypes = method.getParameterTypes();

You can access the return type of a method like this:

Method method = ... // obtain method - see above
Class returnType = method.getReturnType();

Invoking Methods using Method Object

You can invoke a method like this:

//get method that takes a String as argument
Method method = MyObject.class.getMethod("doSomething", String.class);

Object returnValue = method.invoke(null, "parameter-value1");

The null parameter is the object you want to invoke the method on. If the method is static you supply null instead of an object instance. In this example, if doSomething(String.class) is not static, you need to supply a validMyObject instance instead of null;

The Method.invoke(Object target, Object ... parameters) method takes an optional amount of parameters, but you must supply exactly one parameter per argument in the method you are invoking. In this case it was a method taking a String, so one String must be supplied.

Using Java Reflection you can inspect the fields (member variables) of classes and get / set them at runtime. This is done via the Java class java.lang.reflect.Field. This text will get into more detail about the Java Field object. Remember to check the JavaDoc from Sun out too.

Obtaining Field Objects

The Field class is obtained from the Class object. Here is an example:

Class aClass = ...//obtain class object
Field[] methods = aClass.getFields();

The Field[] array will have one Field instance for each public field declared in the class.

If you know the name of the field you want to access, you can access it like this:

Class  aClass = MyObject.class
Field field = aClass.getField("someField");

The example above will return the Field instance corresponding to the field someField as declared in the MyObjectbelow:

public class MyObject{
  public String someField = null;

}

If no field exists with the name given as parameter to the getField() method, a NoSuchFieldException is thrown.

Field Name

Once you have obtained a Field instance, you can get its field name using the Field.getName() method, like this:

Field field = ... //obtain field object
String fieldName = field.getName();

Field Type

You can determine the field type (String, int etc.) of a field using the Field.getType() method:

Field field = aClass.getField("someField");
Object fieldType = field.getType();

Getting and Setting Field Values

Once you have obtained a Field reference you can get and set its values using the Field.get() andField.set()methods, like this:

Class  aClass = MyObject.class
Field field = aClass.getField("someField");

MyObject objectInstance = new MyObject();

Object value = field.get(objectInstance);

field.set(objetInstance, value);

The objectInstance parameter passed to the get and set method should be an instance of the class that owns the field. In the above example an instance of MyObject is used, because the someField is an instance member of the MyObject class.

It the field is a static field (public static ...) pass null as parameter to the get and set methods, instead of theobjectInstance parameter passed above.

Using Java Reflection you can inspect the constructors of classes and instantiate objects at runtime. This is done via the Java class java.lang.reflect.Constructor. This text will get into more detail about the Java Constructorobject.

Obtaining Constructor Objects

The Constructor class is obtained from the Class object. Here is an example:

Class aClass = ...//obtain class object
Constructor[] constructors = aClass.getConstructors();

The Constructor[] array will have one Constructor instance for each public constructor declared in the class.

If you know the precise parameter types of the constructor you want to access, you can do so rather than obtain the array all constructors. This example returns the public constructor of the given class which takes a String as parameter:

Class aClass = ...//obtain class object
Constructor constructor =
        aClass.getConstructor(new Class[]{String.class});

If no constructor matches the given constructor arguments, in this case String.class, aNoSuchMethodException is thrown.

Constructor Parameters

You can read what parameters a given constructor takes like this:

Constructor constructor = ... // obtain constructor - see above
Class[] parameterTypes = constructor.getParameterTypes();

Instantiating Objects using Constructor Object

You can instantiate an object like this:

//get constructor that takes a String as argument
Constructor constructor = MyObject.class.getConstructor(String.class);

MyObject myObject = (MyObject)
        constructor.newInstance("constructor-arg1");

The Constructor.newInstance() method takes an optional amount of parameters, but you must supply exactly one parameter per argument in the constructor you are invoking. In this case it was a constructor taking a String, so one String must be supplied.

Using Java Reflection you can inspect Java classes at runtime. Inspecting classes is often the first thing you do when using Reflection. From the classes you can obtain information about

• Class Name
• Class Modifies (public, private, synchronized etc.)
• Package Info
• Superclass
• Implemented Interfaces
• Constructors
• Methods
• Fields
• Annotations

plus a lot more information related to Java classes. For a full list you should consult the JavaDoc for java.lang.Class. This text will briefly touch upon all accessing of the above mentioned information. Some of the topics will also be examined in greater detail in separate texts. For instance, this text will show you how to obtain all methods or a specific method, but a separate text will show you how to invoke that method, how to find the method matching a given set of arguments if more than one method exists with the same name, what exceptions are thrown from method invocation via reflection, how to spot a getter/setter etc. The purpose of this text is primarily to introduce the Class object and the information you can obtain from it.

The Class Object

Before you can do any inspection on a class you need to obtain its java.lang.Class object. All types in Java including the primitive types (int, long, float etc.) including arrays have an associated Class object. If you know the name of the class at compile time you can obtain a Class object like this:

    Class myObjectClass = MyObject.class

If you don't know the name at compile time, but have the class name as a string at runtime, you can do like this:

String className = ... //obtain class name as string at runtime Class class = Class.forName(className);

When using the Class.forName() method you must supply the fully qualified class name. That is the class name including all package names. For instance, if MyObject is located in package com.jenkov.myapp then the fully qualified class name is com.jenkov.myapp.MyObject

The Class.forName() method may throw a ClassNotFoundException if the class cannot be found on the classpath at runtime.

Class Name

From a Class object you can obtain its name in two versions. The fully qualified class name (including package name) is obtained using the getName() method like this:

    Class aClass = ... //obtain Class object. See prev. section
    String className = aClass.getName();

If you want the class name without the pacakge name you can obtain it using the getSimpleName() method, like this:

    Class  aClass          = ... //obtain Class object. See prev. section
    String simpleClassName = aClass.getSimpleName();

Modifiers

You can access the modifiers of a class via the Class object. The class modifiers are the keywords "public", "private", "static" etc. You obtain the class modifiers like this:

  Class  aClass = ... //obtain Class object. See prev. section
  int modifiers = aClass.getModifiers();

The modifiers are packed into an int where each modifier is a flag bit that is either set or cleared. You can check the modifiers using these methods in the class java.lang.reflect.Modifier:

    Modifier.isAbstract(int modifiers)
    Modifier.isFinal(int modifiers)
    Modifier.isInterface(int modifiers)
    Modifier.isNative(int modifiers)
    Modifier.isPrivate(int modifiers)
    Modifier.isProtected(int modifiers)
    Modifier.isPublic(int modifiers)
    Modifier.isStatic(int modifiers)
    Modifier.isStrict(int modifiers)
    Modifier.isSynchronized(int modifiers)
    Modifier.isTransient(int modifiers)
    Modifier.isVolatile(int modifiers)

Package Info

You can obtain information about the package from a Class object like this:

Class  aClass = ... //obtain Class object. See prev. section
Package package = aClass.getPackage();

From the Package object you have access to information about the package like its name. You can also access information specified for this package in the Manifest file of the JAR file this package is located in on the classpath. For instance, you can specify package version numbers in the Manifest file. You can read more about the Packageclass here: java.lang.Package

Superclass

From the Class object you can access the superclass of the class. Here is how:

Class superclass = aClass.getSuperclass();

The superclass class object is a Class object like any other, so you can continue doing class reflection on that too.

Implemented Interfaces

It is possible to get a list of the interfaces implemented by a given class. Here is how:

Class  aClass = ... //obtain Class object. See prev. section
Class[] interfaces = aClass.getInterfaces();

A class can implement many interfaces. Therefore an array of Class is returned. Interfaces are also represented byClass objects in Java Reflection.

NOTE: Only the interfaces specifically declared implemented by a given class is returned. If a superclass of the class implements an interface, but the class doesn't specifically state that it also implements that interface, that interface will not be returned in the array. Even if the class in practice implements that interface, because the superclass does.

To get a complete list of the interfaces implemented by a given class you will have to consult both the class and its superclasses recursively.

Constructors

You can access the constructors of a class like this:

 Constructor[] constructors = aClass.getConstructors();

Constructors are covered in more detail in the text on Constructors.

Methods

You can access the methods of a class like this:

 Method[] method = aClass.getMethods();

Methods are covered in more detail in the text on Methods.

Fields

You can access the fields (member variables) of a class like this:

 Field[] method = aClass.getFields();

Fields are covered in more detail in the text on Fields.

Annotations

You can access the class annotations of a class like this:

 Annotation[] annotations = aClass.getAnnotations();

Annotations are covered in more detail in the text on Annotations.

Java Reflection makes it possible to inspect classes, interfaces, fields and methods at runtime, without knowing the names of the classes, methods etc. at compile time. It is also possible to instantiate new objects, invoke methods and get/set field values using reflection.

Java Reflection is quite powerful and can be very useful. For instance, when mapping objects to tables in a database at runtime, like Butterfly Persistence does. Or, when mapping the statements in a script language to method calls on real objects at runtime, like Butterfly Container does when parsing its configuration scripts.

There are already numerous Java Reflection Tutorials on the internet. However, most of them, including Sun's own Java Reflection tutorial, only scratch the surface of Java Reflection and its possibilities.

This tutorial will get into Java reflection in more depth than most of the tutorials I have seen. It will explain the basics of Java Reflection including how to work with arrays, annotations, generics and dynamic proxies, and do dynamic class loading and reloading. It will also show you how to do more specific tasks, like reading all getter methods of a class, or accessing private fields and methods of a class. This tutorial will also clear up some of the confusion out there about what Generics information is available at runtime. Some people claim that all Generics information is lost at runtime. This is not true.

This tutorial describes the version of Java Reflection found in Java 6.

Java Reflection Example

Here is a quick Java Reflection example to show you what using reflection looks like:

Method[] methods = MyObject.class.getMethods();

for(Method method : methods){
    System.out.println("method = " + method.getName());
}

This example obtains the Class object from the class called MyObject. Using the class object the example gets a list of the methods in that class, iterates the methods and print out their names.

Exactly how all this works is explained in further detail throughout the rest of this tutorial (in other texts).

Table of Contents

You can find a list of all the topics covered in this tutorial at the top left of the page. This list is repeated on all pages in this tutorial.

출처 - http://tutorials.jenkov.com/java-reflection/index.html

참조 :  
1. http://jackson.codehaus.org/
2. http://wiki.fasterxml.com/JacksonInFiveMinutes

라이브러리 다운로드
http://wiki.fasterxml.com/JacksonDownload
jackson-core, jackson-databind, jackson-annotations 를 다운 받음.

Jackson 에서 JSON 처리에 제공하는 방법
1. Streaming API
     성능이 빠름.
2. Tree Model
     일반적인 XML처럼 노드형태로 Json 데이터를 다룸. 유연성이 가장 좋음. 입맛대로 구성할 수 있음.
3. Data Binding
     POJO 기반의 가자 객체들을 JSON으로 변환함.
   -Simple data Binding : 자바클래스 내의 Map, List, String, 숫자형, Boolean, null 형의 데이터들을 JSON으로 변환함.
   -Full data binding : Simple data Binding에서 제공하는것들을 포함하고 자바 빈타입에서 제공하는 데이터들도 JSON으로 변환함.


소스
* 공식사이트에 있는 import 패키지 이름이 버전업되면서 변경됐음.(2013-05-22)

출처 - http://arisu1000.tistory.com/27710

serialversionutil-civan.zip

1. Serialization 이란?

  모든 데이터의 흐름은 바이트 전송으로 이루어 집니다. 이것은 객체도 마찬가진데, 이때 사용되는 개념이 Serialization 이라는 것이고 자바에서는 java.io.Serializable 이라는 interface입니다.

이것을 사용하는 방법은 implements Serializable 이라고 class명 옆에다 추가만 해주면 됩니다. 그런데, 클래서를 선언하면 static final long 타입의 serialVersionUID 상수를 선언하라는 경고문구를 
이클립스의 노란 warning 아이콘과 더불어 확인 할 수 있습니다.

2. serialVersionUID 용도는?

만일 serialVersionUID를 지정하지 않으면 실행시점에서 JVM이 디폴트 값을 산정하게 되며, 
그 알고리즘은 Java(TM) Object Serialization Specification 정의된 것을 따른다고 합니다. 
한마디로 굳이 신경 쓸필요는 없다는 뜻이고 이클립스내에서 이 경고아이콘을 제외하도록 설정할 수도 있습니다.

그러나 모든 serialization이 필요한 클래스에는 명시적으로 serialVersionUID를 선언해줄것을 강력하게 권유하고 있는데 그 이유는 디폴트 serialVersionUID 계산은 클래스의 세부 사항을 매우 민감하게 반영하기 때문에 컴파일러 구현체에 따라서 달라질 수 있어 deserialization(serialization 했던 객체를 복구하는 과정)과정에서 예상하지 못한 InvalidClassExceptions을 유발할 수 있다 라는 것이 그 이유입니다.

즉 서로 다른 자바 컴파일러 구현체 사이에서도 동일한 serialVersionUID값을 얻기 위해서는 명시적으로 serialVersionUID값을 선언해야 하며 가능한 serialVersionUID을 private으로 선언하라는 것입니다.

3. 쉽게하는 방법은?

그러나, 이것을 간단히 할 수 있는 방법은 serialver.exe를 사용하는 것입니다.

첨부파일을 압축을 풀고 이클립스 플러그인 디렉토리에 넣어두면 자동생성 플러그인 설치는 끝
3.3에서도 이상없이 작동한다. 사용방법은 다음과 같다.
파일을 선택 마우스 오른클릭하면
Add serialVersionUID 라는 메뉴가 추가 되어 있는것을 확인할 수 있다. 

import java.io.Serializable;

public class APIJson implements Serializable {

 /**
  *   아래 참조....
  */   
 private static final long serialVersionUID = 5005432000206295213L;

}

출처 - http://softlife.tistory.com/category/%EA%B0%9C%EB%B0%9C%EB%8F%84%EA%B5%AC/Eclipse

Maven standard directory layout guide us to place any non-Java files for testing undersrc/test/resources/ folder. They are automatically copied over to target/test-classes/ folder during test phase.

Image you have the following folder layout:

src/
   main/
      java/
         SomeClass.java
   test/
      java/
         SomeClassTest.java
      resources/
         sample.txt

The question is how to reach test file resource from JUnit test method.

Test file existence 

The basically you should test whether required test file resource does exists:

@Test
public void testStreamToString() {
   assertNotNull("Test file missing", 
               getClass().getResource("/sample.txt"));
   ...
}

Test file to stream 

Please note how getResource() argument value looks. Test class getResource() will resolve/sample.txt properly to /target/test-classes/sample.txt.

You might need to get InputStream from file resource which is easy to done with help of sister methodgetResourceAsStream():

// JDK7 try-with-resources ensures to close stream automatically
try (InputStream is = getClass().getResourceAsStream("/sample.txt")) {
        int Byte;       // Byte because byte is keyword!
        while ((Byte = is.read()) != -1 ) {
                System.out.print((char) Byte);
        }
}

Test file to File or Path 

Common is also to convert resource to java.io.File or its JDK7 successor java.nio.file.Path (from so-called NIO.2). I present Path example to print last modification time of test resource filesrc/test/resources/sample.txt:

URL resourceUrl = getClass().
getResource("/sample.txt");
Path resourcePath = Paths.get(resourceUrl.toURI());
FileTime lmt = Files.getLastModifiedTime(resourcePath);
// prints e.g. "Tue Jul 09 16:35:51 CEST 2013"
System.out.println(new Date(lmt.toMillis()));

출처 - http://devblog.virtage.com/2013/07/how-to-get-file-resource-from-maven-srctestresources-folder-in-junit-test/

Java API Documentation에서 보면 

public URL getResource(String name)

Class.getResource() 메소드는 해당 클래스의 소스 파일 위치를 상대 루트로 설정한다.

반면, ClassLoader.getResource()/getResources() 메소드는 클래스패스의 루트를 상대 루트로 설정한다.

다음은 이와 같은 차이를 보여주는 예제이다.

package test;

import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;

public class GetResourceExample {

 public static void main(String[] args) {
  Class<GetResourceExample> clazz = GetResourceExample.class;
  URL resource = clazz.getResource(".");
  System.out.println("resource: " + resource);

  ClassLoader classLoader = clazz.getClassLoader();
  try {
   Enumeration<URL> resources = classLoader.getResources(".");
   System.out.println("resources:");
   while (resources.hasMoreElements()) {
    URL nextElement = resources.nextElement();
    System.out.println(nextElement);
   }
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }

}

결과는 다음과 같다.

resource: file:/D:/%ec%9e%91%ec%97%85%ec%8b%a4/Java/JavaExample/bin/test/
resources:
file:/D:/%ec%9e%91%ec%97%85%ec%8b%a4/Java/JavaExample/bin/

Class.getResource() 메소드의 경우

해당 클래스가 포함된 패키지에 따른 디렉토리를 현재 디렉토리로 함을 알 수 있다.

반면, ClassLoader.getResources() 메소드의 경우

클래스패스의 루트를 현재 디렉토리로 함을 확인할 수 있다.

출처 - http://devday.tistory.com/entry/ClassgetResource-vs-ClassLoadergetResourcegetResources

http://commons.apache.org/configuration/

연구실에서 프로젝트를 할 때, DB 계정 정보 등의 설정 정보 등을 XML파일로 적어놓고 참조하려고 마음을 먹었습니다. 그래서  XML파일 읽는 코드를 한 20줄 짜고, 이 설정 정보를 java.util.Properties 에 저장하여 메모리에 유지하도록 static 하게 변수를 선언하는 등의 작업을 하였으나, 검색해보니 Apache Commons 프로젝트에 Configuration 이라는 컴포넌트가 있습니다.

구글에서 검색하니 http://twit88.com/blog/2007/09/18/xml-configuration-for-java-program/  에도 간단한 예가 나와있습니다. 어쨌든, http://commons.apache.org/configuration/userguide/user_guide.html 를 보시면 이 컴포넌트의 사용방법이 자세하게 기술되어 있습니다. 그리고 User guide의 Hierarchical Properties 항목을 보면, XML파일을 이용하는 방법이 기술되어 있습니다. 

출처 - http://thebasis.tistory.com/94