Exposing Methods of Value Object

Question

I have the need for a value (transfer) object that contains only getters and setters, as well as a full "business object" that has the same getters and setters as well as business logic (like insert()).
I hate the idea of maintaining two separate objects, and making sure that when I add a new attribute to the BO I remember to add it to the VO.
I would love to have the BO hold a private instance of the VO inside it, and automatically "expose" all the VO's methods to the outside world as if they were its own. I could do this with inheritence, but then I have the problem of creating a VO from a BO (lots of error-prone repetitive code).
Any ideas on how I could expose these methods, together with the BO's logic?
Thanks, Gary

Answer 1

If I've understood your question, you may use a Proxy
object to achieve the desired behaviour.
What you'll need to do is create a "super" interface
that contains the methods from your business object
and value object. You will then create a Proxy that
implements the "super" interface. When you invoke a
method on the proxy, the invocation handler will try
to first invoke the method on the business object. If
the business object does not implement the requested
method (i.e. one of the value methods), the handler
tries to invoke the method on the value object member
of the business object.
The only maintainence overhead implied by this
solution is that methods must be added to the "super"
interface to correspond to each method added to the
business or value objects.
Have a look at this example to see what I mean
public class Test {
public static void main(String[] args) {
try {
ProxyHandler d = new ProxyHandler(new
Handler(new BusinessObject());
Object o =
Object o =
Proxy.newProxyInstance(Thread.currentThread().getConte
tClassLoader(),
new Class[]
new Class[] {BusinessValueInterface.class},
class}, d);
BusinessValueInterface bvi =
rface bvi = (BusinessValueInterface)o;
bvi.businessMethod();
System.out.println(bvi.getVal());
catch (Exception ex) {
ex.printStackTrace();
static class ProxyHandler implements
nts InvocationHandler {
BusinessObject b;
public ProxyHandler(BusinessObject bo) {
b = bo;
public Object invoke(Object proxy, Method m,
thod m, Object[] params)
throws Throwable
Class[] paramClasses = null;
if (params != null) {
paramClasses = new
amClasses = new Class[params.length];
for (int x = 0; x < params.length;
params.length; x++)
paramClasses[x] =
paramClasses[x] = params[x].getClass();
Method m1 = null;
try {
m1 =
m1 = b.getClass().getMethod(m.getName(),
getName(), paramClasses);
catch (Exception ex) {
if (m1 != null) {
return m1.invoke(b, params);
else {
Method m2 =
Method m2 =
2 = b.val.getClass().getMethod(m.getName(),
paramClasses);
if (m2 != null) {
return m2.invoke(b.val, params);
else {
return null;
interface BusinessValueInterface {
public String getVal();
public void businessMethod();
static class BusinessObject {
ValueObject val = new ValueObject();
public void businessMethod() {
System.out.println("businessMethod
inessMethod invoked");
static class ValueObject {
public String getVal() {
return "value";
Good luck,
MikeI would definetly like to know more about what performance characteristics is needed in the system before recommending a dynamic proxy. Value objects accessors and mutators tend to be the most called methods in a system, and there is a fairly large overhead for dynamic proxies (about 5*(normal method call) on a windows 2000 box running IBM jre 1.3.1). Dynamix proxies are great and I use them for a lot of things, but NOT for value object setter and getters...
I�d recommend either wrapping the VO in the BO and exposing it as:
MyBO myBo = getBO();
myBo.getValue().setName( ... ); or make the BO stateless and pass the value in the method calls:
myBO.performSomeNiceBusinessLogic( valueObject, someOtherArgument );The latter is probably the way I would go for most cases, but the former has its advantages to.
Br - johan