[ https://issues.jboss.org/browse/CDI-552?page=com.atlassian.jira.plugin.sy... ] Frigo Coder edited comment on CDI-552 at 10/11/18 9:12 AM: ----------------------------------------------------------- This is a very desired feature that would be useful in several scenarios: - Migrating legacy code - Weld SE applications - Rich domain objects - OOP applications with advanced features A proxy based solution would be preferable to maintain consistency with CDI, however this would interfere with direct field access. Runtime weaving solutions are also possible with AspectJ, JavaAgent, or ClassLoader hacks. The new keyword would be optimal, but helper functions or classes are also acceptable. I have a toy implementation that only approximates the real thing with severe limitations obviously: {code:java} public class Manual<T> implements AutoCloseable { /** * Does not support constructor interceptors */ public static <T> Manual<T> from(T instance) { return new Manual<>(instance); } /** * Does not support constructor parameters */ public static <T> Manual<T> create(Class<T> clazz) { return new Manual<>(clazz); } private BeanManager bm; private CreationalContext<T> ctx; private InjectionTargetFactory<T> itf; private InjectionTarget<T> it; private InterceptionFactory<T> ifm; private T instance; private T proxy; @SuppressWarnings("unchecked") private Manual(T instance) { prepare((Class<T>) instance.getClass()); process(instance); } private Manual(Class<T> clazz) { prepare(clazz); process(it.produce(ctx)); } private void prepare(Class<T> clazz) { bm = CDI.current().getBeanManager(); ctx = bm.createCreationalContext(null); itf = bm.getInjectionTargetFactory(bm.createAnnotatedType(clazz)); // itf.configure(); // this fucks up things it = itf.createInjectionTarget(null); ifm = bm.createInterceptionFactory(ctx, clazz); ifm.configure(); } private void process(T object) { this.instance = object; it.inject(instance, ctx); it.postConstruct(instance); proxy = ifm.createInterceptedInstance(instance); } @Override public void close() { it.preDestroy(instance); it.dispose(instance); ctx.release(); } @Override protected void finalize() throws Throwable { it.preDestroy(instance); it.dispose(instance); ctx.release(); super.finalize(); } /** * Neither of them supports direct field access due to proxy */ public T get() { return proxy; } } {code} was (Author: frigocoder): This is a very desired feature that would be useful in several scenarios: - Migrating legacy code - Weld SE applications - Rich domain objects - OOP applications with advanced features A proxy based solution would be preferable to maintain consistency with CDI, however this would interfere with direct field access. Runtime weaving solutions are also possible with AspectJ, JavaAgent, or ClassLoader hacks. The new keyword would be optimal, but helper functions or classes are also acceptable. I have a toy implementation that only approximates the real thing with severe limitations obviously: {{public class Manual<T> implements AutoCloseable { /** * Does not support constructor interceptors */ public static <T> Manual<T> from(T instance) { return new Manual<>(instance); } /** * Does not support constructor parameters */ public static <T> Manual<T> create(Class<T> clazz) { return new Manual<>(clazz); } private BeanManager bm; private CreationalContext<T> ctx; private InjectionTargetFactory<T> itf; private InjectionTarget<T> it; private InterceptionFactory<T> ifm; private T instance; private T proxy; @SuppressWarnings("unchecked") private Manual(T instance) { prepare((Class<T>) instance.getClass()); process(instance); } private Manual(Class<T> clazz) { prepare(clazz); process(it.produce(ctx)); } private void prepare(Class<T> clazz) { bm = CDI.current().getBeanManager(); ctx = bm.createCreationalContext(null); itf = bm.getInjectionTargetFactory(bm.createAnnotatedType(clazz)); // itf.configure(); // this fucks up things it = itf.createInjectionTarget(null); ifm = bm.createInterceptionFactory(ctx, clazz); ifm.configure(); } private void process(T object) { this.instance = object; it.inject(instance, ctx); it.postConstruct(instance); proxy = ifm.createInterceptedInstance(instance); } @Override public void close() { it.preDestroy(instance); it.dispose(instance); ctx.release(); } @Override protected void finalize() throws Throwable { it.preDestroy(instance); it.dispose(instance); ctx.release(); super.finalize(); } /** * Neither of them supports direct field access due to proxy */ public T get() { return proxy; } } }} -- This message was sent by Atlassian Jira (v7.12.1#712002)