The error you are facing is based on objectmapper convertvalue-vs-readvalue.

Basically, what objectMapper.convertValue(addressDetail, Address.class) tries, is to create an Address from the single string value you pass in. It does not read the string contents and set field values. If you need to use convertValue, then you have to create a constructor like public Address(String json){/*do mapping manually here*/}.

The better approach however would be to use objectMapper.readValue(addressDetail, Address.class), as this method actually traverses the JSON string and creates an instance with the fields you have present in the string. readValue only requires getter/setter and an no-args constructor to function

You have two attributes called "linkLabel" in each of the JSON objects. Attribute names in a JSON object have to be unique if you want them to be extracted correctly by a standard JSON parser.

What is going to happen is that one of the attributes is going to be ignored (silently) by the JSON parser. For example:

    "listLinkLabel": [{
            "linkLabel": 1,
            "linkLabel": "after"
    }]

Assuming that the first attribute is the one that is ignored, your code will then try to convert "after" to an integer ... which will fail.

Basically, your JSON is (semantically) malformed, and you need to correct whatever is generating it.

UPDATE - I think I have figured out why Jackson is generating malformed JSON. You have:

@JsonIdentityInfo(
    generator = ObjectIdGenerators.IntSequenceGenerator.class,
    property = "linkLabel")

and also

@Column(name = "LinkLabel")
@GeneratedValue(strategy = GenerationType.AUTO)
private String linkLabel;

In other words, you have told Jackson that 1) there is a id attribute with type int and name linkLabel, 2) there is a property named linkLabel whose type is String.

Jackson has gotten a bit confused by this contradictory information, and assumed that you have specified there are two distinct attributes called linkLabel ... which doesn't work¹.

You also >>appear<< to be trying to use linkLabel as a data field (with non-integer content) and that is also problematic².

Solution: either get rid of the @JsonIdentityInfo annotation, or change it to use a distinct property name, and declare the corresponding Java field with the correct Java type.

^{1 - It doesn't work with the Jackson parser ... but you could make it work with a custom parser. Hence, there is a (tenuous) justification for Jackson to do this rather than treating this as an error.}

^{2 - There is no way that Jackson could figure this one out ...}

You need to tokenize the String. (if it always starts with f( and ends with ) you can make your life easier, be removing these parts).

A(4) -> Find the Classname -> A -> find the Parameter -> 4

This is done like this (pseudo java code):

public static Object createClass(String className, Double value){
    Class a = Class.forName(className);
    Class[] params = new Class[]{Integer.class};
    Constructor c = a.getConstructor(params);
    Object[] values = new Object[]{value};
    return c.newInstance();
}

Maybe, this lik is helpful: http://docs.oracle.com/javase/tutorial/reflect/member/ctorInstance.html

update This is like writing a compiler. You can get further information, if you read something about, how to write a compiler: http://en.wikipedia.org/wiki/Compiler

update 2 put all generated instances into an array. Now you can get the correct method f with the reflections-API. The Code will be something like

http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html#getDeclaredMethod(java.lang.String, java.lang.Class...)

Object[] values ...
Class[] classes ...
for(Object o: values){
    add o.getClass() to classes
}

Method f = Functions.getClass().getDeclaredMethods("f", classes);
f.invoke(values);

If you remove your constructor declaration from the Student class, then the implicit empty constructor will exist. But if you declared explicitly a constructor like your public Student(String firstname, String surname, String total) then the empty constructor won't be available, unless you add it explicitly to your class.

public Student() { };

Then you call unexistant methods :

newStudent.firstName("my name");

The method you want to call, as declared in your Student object is setFirstName(String firstName)

Finally in your println calls, you are trying to access the attribut of the object directly instead of using the getters methods.

java cannot magically cast one object to any another object unless they have parent child relationship.

casts won't work in that way.

All String's are Object's. But not all Object's are String's.

Edit to comment(u mean down casting is not possible in java):

No. I didn't mean that. Down casting is possible in the cases like

Object obj = getThat();
String s = (String) obj; 

Possible, if you see. The above code executes fine if getThat() method returns a String. Otherwise a Exception. Same rule applies to getResponse() method too.

You are definitely reinventing the wheel

• Java Object Serialization already does this, albeit that the serialization format is binary (and opaque).

• Various JSON (or XML) <-> POJO binding mechanisms already do this, albeit that the serialization format can be verbose.

(Now there are limits to what these schemes can do. For example, they cannot serialize a Thread or a Socket. But neither can your proposal ... for the same reasons. These classes have state that simply cannot be captured in a serialization.)

But if you really want to invent the wheel, you can do it.

• As noted, you can use reflection to access and call a public or private constructor on a non-abstract type.

• There is also an "under the hood" Unsafe mechanism that JOS uses to create objects without invoking any constructor. Combine this with Unsafe methods for assigning values to fields.

However, your approach implicitly assumes that the toString method returns a string that can be used later to reconstruct the object. This is not true, in general.

• The default implementation returns a string consisting of the object's class name and its identity hashcode. (An example of the types affected by this is any array type.) You can't reconstruct an object from that.
• And even for cases where the toString result does include the information needed for deserialization, the string format is rarely standardized. (The Collection APIs are the exception ...)

In short, toString is not the answer.