Interface Filters

Occasionally, you may want to limit bean properties to only those defined on a parent class or interface.
This is accomplished through interface filters.

Interface filters are defined through the following:

- {@link oaj.BeanContext#BEAN_beanFilters}
- {@link oaj.annotation.Bean#interfaceClass() @Bean(interfaceClass)}
- {@link oaj.transform.BeanFilterBuilder#interfaceClass(Class)}

For example, let's define the following interface and implementation:

// Interface public class MyInterface { public String getFoo(); } // Implementation public class MyInterfaceImpl implements MyInterface { public String getFoo() {...} public String getBar() {...} }

Suppose we only want to render the properties defined on our interface, not the implementation.
To do so, we can define the following bean filter:

// Define transform that limits properties to only those defined on MyClass public class MyInterfaceFilter extends BeanFilter<MyInterface> { public MyInterfaceFilter() { interfaceClass(MyInterface. class); } }

When serialized, the serialized bean will only include properties defined on the interface.

WriterSerializer s = JsonSerializer .create() .simple() .beanFilters(MyInterfaceFilter. class) .build(); MyInterface o = new MyInterfaceImpl(); // Prints "{foo:'foo'}" // bar is ignored because it's not on the interface String json = s.serialize(o);

The {@link oaj.BeanContextBuilder#beanFilters(Object...)} method will automatically interpret any non-`BeanFilter` classes passed in as meaning interface classes.
So in the previous example, the `BeanFilter` class could have been avoided altogether by just passing in `MyInterface.class` to the serializer, like so:

WriterSerializer s = JsonSerializer .create() .beanFilters(MyInterface. class) Shortcut! .build();

The annotation equivalent is {@link oaj.annotation.Bean#interfaceClass() Bean#interfaceClass()}.

@Bean(interfaceClass=MyInterface. class) public class MyInterfaceImpl implements MyInterface { public String getFoo() {...} public String getBar() {...} }

The annotation can be used in a couple of ways.

Using the annotation on an interface will be inherited by all children.

@Bean(interfaceClass=MyInterface. class) public class MyInterface { public String getFoo(); }

The annotation can be used on parent classes as well.
Child beans will only serialize properties defined on the parent class.

@Bean(interfaceClass=MyAbstractClass. class) public abstract class MyAbstractClass { public String getFoo() {...}; }