com.blazebit.reflection.LazySetterMethod Maven / Gradle / Ivy
/*
* Copyright 2011 Blazebit
*/
package com.blazebit.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* This class is a lazy setter that can be invoked later. Basically this class
* just holds the target object on which to invoke the setter, the field name
* via which the setter method is determined and the arguments that should be
* passed as parameters to the setter.
*
* @author Christian Beikov
* @since 0.1.2
*/
public class LazySetterMethod {
private final Object target;
private final Object value;
private final PropertyPathExpression expression;
/**
* Constructs a LazySetterMethod object for the given source object, field
* names as a string separated by '.' (dots) and arguments. Using this
* constructor is equal to #
* {@link LazySetterMethod#LazySetterMethod(java.lang.Object, java.lang.String[], java.lang.Object[]) }
* with the second parameter fieldNames.split("\\.").
*
* @param target The object on which to invoke the getter/setter chain
* @param fieldNames The field names which should be used for the setter
* determination
* @param args The arguments used for the setter method
*/
@SuppressWarnings("unchecked")
public LazySetterMethod(Object target, String fieldNames, Object value) {
if (target == null) {
throw new NullPointerException("target");
}
this.target = target;
this.value = value;
this.expression = (PropertyPathExpression) ExpressionUtils
.getExpression(target.getClass(), fieldNames);
}
/**
* Constructs a LazySetterMethod object for the given source object, field
* names as a string separated by '.' (dots) and arguments.
*
* This constructor is equal to #
* {@link LazySetterMethod#LazySetterMethod(java.lang.Object, java.lang.String, java.lang.Object[])}
* except that this constructor shows that #{@link LazyGetterMethod} also
* can be used as parameter. The LazyGetterMethods will be invoked lazily
*
* @param target The object on which to invoke the getter/setter chain
* @param fieldNames The field names which should be used for the setter
* determination
* @param args The arguments used for the setter method
*/
public LazySetterMethod(Object target, String fieldNames,
LazyGetterMethod value) {
this(target, fieldNames, (Object) value);
}
/**
* Invokes the getter/setter chain based on the source object. First of all
* the actual arguments are determined by invoking LazyGetterMethod objects
* that have been passed during construction. Then the getter chain is
* invoked to determine the actual object on which to invoke the setter.
* Finally the setter is invoked with the actual arguments
*
* Example of how the chaining works:
*
*
* class A{
* private B b;
*
* public A(B b){
* this.b = b;
* }
*
* public B getB(){
* return b;
* }
* }
*
* class B{
* private String s;
*
* public B(String s){
* this.s = s;
* }
*
* public void setS(String s){
* this.s = s;
* }
* }
*
*
*
* new LazySetterMethod(new A(new B("")), "b.s", "value").invoke()
*
*
* is equal to
*
*
* new A(new B("")).getB().setS("test");
*
*
* and
*
*
* new LazySetterMethod(new A(new B("")), "b.s", new LazyGetterMethod(new B("lazyValue"), "s").invoke()
*
*
* is equal to
*
*
* new A(new B("")).getB().setS(new B("lazyValue").getS());
*
*
* @throws InvocationTargetException #{@link Method#invoke(java.lang.Object, java.lang.Object[]) }
* @throws IllegalAccessException #{@link Method#invoke(java.lang.Object, java.lang.Object[]) }
*/
public void invoke() throws InvocationTargetException,
IllegalAccessException {
Object valueToPass = value;
if (valueToPass != null && valueToPass instanceof LazyGetterMethod) {
valueToPass = ((LazyGetterMethod) valueToPass).invoke();
}
expression.setValue(target, valueToPass);
}
}