5:16 p.m.
Hey Guys,
I'm working on an extension that @Observes ProcessAnnotatedType in order to
modify the typing information for fields annotated with a specific
Annotation.
When I use BeanManager to later construct an instance of AnnotatedType for
that modified class, however, I am not supplied with the modified
AnnotatedType instance, I am given a brand new instance that does not
include my extension's prior modifications.
If this is right, then there needs to be some way to retrieve the previously
modified data from the BeanManager, otherwise, the information is
effectively lost unless the BeanManager is creating a full contextual
instance of the class, not merely providing injection.
So this doesn't seem right to me. Thoughts?
Example code below.
Thanks,
Lincoln
--------------------------------------------------------------------------------------------------------
public <T> void processAnnotatedType(@Observes final
ProcessAnnotatedType<T> event)
{
AnnotatedTypeBuilder<T> builder =
AnnotatedTypeBuilder.newInstance(event.getAnnotatedType());
builder.readAnnotationsFromUnderlyingType();
boolean modifiedType = false;
for (AnnotatedField<?> f : event.getAnnotatedType().getFields())
{
if (f.isAnnotationPresent(InputField.class))
{
builder.overrideFieldType(f.getJavaMember(), Object.class);
modifiedType = true;
}
}
if (modifiedType)
{
AnnotatedType<T> replacement = builder.create();
event.setAnnotatedType(replacement);
}
}
Then later... the AnnotatedType created in the method below not reflect
changes made to the type in the extension above.
public void injectNonContextualInstance(final Object instance)
{
if (instance != null)
{
CreationalContext<Object> creationalContext =
manager.createCreationalContext(null);
InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>)
manager.createInjectionTarget(beanManager.createAnnotatedType(instance.getClass()));
injectionTarget.inject(instance, creationalContext);
}
}
--
Lincoln Baxter, III
http://ocpsoft.com
http://scrumshark.com
"Keep it Simple"
1:48 a.m.
Hello
In OpenWebBeans, if InjectionTarget is set for non-contextual types, whenever we inject
into non-contextual instances, we use this setting injection target instance. Otherwise,
we use normal InjectionTarget that created by BeanManager
--Gurkan
________________________________
From: "Lincoln Baxter, III" <lincolnbaxter(a)gmail.com>
To: Weld Dev List <weld-dev(a)lists.jboss.org>
Sent: Thu, May 6, 2010 12:16:06 AM
Subject: [weld-dev] Potentially un-spec'd behavior for
BeanManager.createAnnotatedType(...)
Hey Guys,
I'm working on an extension that @Observes ProcessAnnotatedType in order to modify the
typing information for fields annotated with a specific Annotation.
When I use BeanManager to later construct an instance of AnnotatedType for that modified
class, however, I am not supplied with the modified AnnotatedType instance, I am given a
brand new instance that does not include my extension's prior modifications.
If this is right, then there needs to be some way to retrieve the previously modified data
from the BeanManager, otherwise, the information is effectively lost unless the
BeanManager is creating a full contextual instance of the class, not merely providing
injection.
So this doesn't seem right to me. Thoughts?
Example code below.
Thanks,
Lincoln
--------------------------------------------------------------------------------------------------------
public <T> void processAnnotatedType(@Observes final
ProcessAnnotatedType<T> event)
{
AnnotatedTypeBuilder<T> builder =
AnnotatedTypeBuilder.newInstance(event.getAnnotatedType());
builder.readAnnotationsFromUnderlyingType();
boolean modifiedType = false;
for (AnnotatedField<?> f : event.getAnnotatedType().getFields())
{
if (f.isAnnotationPresent(InputField.class))
{
builder.overrideFieldType(f.getJavaMember(), Object.class);
modifiedType = true;
}
}
if (modifiedType)
{
AnnotatedType<T> replacement = builder.create();
event.setAnnotatedType(replacement);
}
}
Then later... the AnnotatedType created in the method below not reflect changes
made to the type in the extension above.
public void injectNonContextualInstance(final Object instance)
{
if (instance != null)
{
CreationalContext<Object> creationalContext =
manager.createCreationalContext(null);
InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>)
manager.createInjectionTarget(beanManager.createAnnotatedType(instance.getClass()));
injectionTarget.inject(instance, creationalContext);
}
}
--
Lincoln Baxter, III
http://ocpsoft.com
http://scrumshark.com
"Keep it Simple"
9:06 a.m.
Gurkan, I don't understand what you are saying.
On 6 May 2010, at 06:48, Gurkan Erdogdu wrote:
Hello
In OpenWebBeans, if InjectionTarget is set for non-contextual types, whenever we inject
into non-contextual instances, we use this setting injection target instance. Otherwise,
we use normal InjectionTarget that created by BeanManager
--Gurkan
From: "Lincoln Baxter, III" <lincolnbaxter(a)gmail.com>
To: Weld Dev List <weld-dev(a)lists.jboss.org>
Sent: Thu, May 6, 2010 12:16:06 AM
Subject: [weld-dev] Potentially un-spec'd behavior for
BeanManager.createAnnotatedType(...)
Hey Guys,
I'm working on an extension that @Observes ProcessAnnotatedType in order to modify
the typing information for fields annotated with a specific Annotation.
When I use BeanManager to later construct an instance of AnnotatedType for that modified
class, however, I am not supplied with the modified AnnotatedType instance, I am given a
brand new instance that does not include my extension's prior modifications.
If this is right, then there needs to be some way to retrieve the previously modified
data from the BeanManager, otherwise, the information is effectively lost unless the
BeanManager is creating a full contextual instance of the class, not merely providing
injection.
So this doesn't seem right to me. Thoughts?
Example code below.
Thanks,
Lincoln
--------------------------------------------------------------------------------------------------------
public <T> void processAnnotatedType(@Observes final
ProcessAnnotatedType<T> event)
{
AnnotatedTypeBuilder<T> builder =
AnnotatedTypeBuilder.newInstance(event.getAnnotatedType());
builder.readAnnotationsFromUnderlyingType();
boolean modifiedType = false;
for (AnnotatedField<?> f : event.getAnnotatedType().getFields())
{
if (f.isAnnotationPresent(InputField.class))
{
builder.overrideFieldType(f.getJavaMember(), Object.class);
modifiedType = true;
}
}
if (modifiedType)
{
AnnotatedType<T> replacement = builder.create();
event.setAnnotatedType(replacement);
}
}
Then later... the AnnotatedType created in the method below not reflect changes made to
the type in the extension above.
public void injectNonContextualInstance(final Object instance)
{
if (instance != null)
{
CreationalContext<Object> creationalContext =
manager.createCreationalContext(null);
InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>)
manager.createInjectionTarget(beanManager.createAnnotatedType(instance.getClass()));
injectionTarget.inject(instance, creationalContext);
}
}
--
Lincoln Baxter, III
http://ocpsoft.com
http://scrumshark.com
"Keep it Simple"
_______________________________________________
weld-dev mailing list
weld-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/weld-dev
9:07 a.m.
I think this needs clarification in the spec *create*AnnotatedType suggests that the
AnnotatedType should be created from the class passed, not fetched from the modified one
if the class is the same as the passed.
But I think the behavior should be that it uses the modified one.
On 5 May 2010, at 22:16, Lincoln Baxter, III wrote:
Hey Guys,
I'm working on an extension that @Observes ProcessAnnotatedType in order to modify
the typing information for fields annotated with a specific Annotation.
When I use BeanManager to later construct an instance of AnnotatedType for that modified
class, however, I am not supplied with the modified AnnotatedType instance, I am given a
brand new instance that does not include my extension's prior modifications.
If this is right, then there needs to be some way to retrieve the previously modified
data from the BeanManager, otherwise, the information is effectively lost unless the
BeanManager is creating a full contextual instance of the class, not merely providing
injection.
So this doesn't seem right to me. Thoughts?
Example code below.
Thanks,
Lincoln
--------------------------------------------------------------------------------------------------------
public <T> void processAnnotatedType(@Observes final
ProcessAnnotatedType<T> event)
{
AnnotatedTypeBuilder<T> builder =
AnnotatedTypeBuilder.newInstance(event.getAnnotatedType());
builder.readAnnotationsFromUnderlyingType();
boolean modifiedType = false;
for (AnnotatedField<?> f : event.getAnnotatedType().getFields())
{
if (f.isAnnotationPresent(InputField.class))
{
builder.overrideFieldType(f.getJavaMember(), Object.class);
modifiedType = true;
}
}
if (modifiedType)
{
AnnotatedType<T> replacement = builder.create();
event.setAnnotatedType(replacement);
}
}
Then later... the AnnotatedType created in the method below not reflect changes made to
the type in the extension above.
public void injectNonContextualInstance(final Object instance)
{
if (instance != null)
{
CreationalContext<Object> creationalContext =
manager.createCreationalContext(null);
InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>)
manager.createInjectionTarget(beanManager.createAnnotatedType(instance.getClass()));
injectionTarget.inject(instance, creationalContext);
}
}
--
Lincoln Baxter, III
http://ocpsoft.com
http://scrumshark.com
"Keep it Simple"
_______________________________________________
weld-dev mailing list
weld-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/weld-dev
5102
days inactive
5103
days old
3 comments
3 participants
participants (3)
-
Gurkan Erdogdu -
Lincoln Baxter, III -
Pete Muir