Refine search
public static void refreshPartialBeanClass(ClassLoader classLoader, Object partialBean) { ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader(); ProxyClassLoadingDelegate.beginProxyRegeneration(); try { Thread.currentThread().setContextClassLoader(classLoader); Object lifecycle = (Object) ReflectionHelper.get(partialBean, "lifecycle"); if (lifecycle != null) { Class<?> targetClass = (Class) ReflectionHelper.get(lifecycle, "targetClass"); PartialBeanProxyFactory proxyFactory = PartialBeanProxyFactory.getInstance(); try { // Deltaspike 1.5 Method m3 = PartialBeanProxyFactory.class.getMethod("getProxyClass", new Class[] { BeanManager.class, Class.class, Class.class} ); Class<? extends InvocationHandler> delegateInvocationHandlerClass = (Class) ReflectionHelper.get(lifecycle, "delegateInvocationHandlerClass"); m3.invoke(proxyFactory, new Object[] {BeanManagerProvider.getInstance().getBeanManager(), targetClass, delegateInvocationHandlerClass} ); } catch (NoSuchMethodException e) { // Deltaspike 1.7 Method m2 = PartialBeanProxyFactory.class.getMethod("getProxyClass", new Class[] { BeanManager.class, Class.class } ); m2.invoke(proxyFactory, new Object[] {BeanManagerProvider.getInstance().getBeanManager(), targetClass} ); } } } catch (Exception e) { LOGGER.error("Deltaspike proxy redefinition failed", e); } finally { Thread.currentThread().setContextClassLoader(oldContextClassLoader); ProxyClassLoadingDelegate.endProxyRegeneration(); } } }
@PrePersist public void persist(Object entity) { BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager(); Set<Bean<?>> beans = beanManager.getBeans(PrePersistAuditListener.class); for (Bean<?> bean : beans) { PrePersistAuditListener result = (PrePersistAuditListener) beanManager.getReference( bean, PrePersistAuditListener.class, beanManager.createCreationalContext(bean)); result.prePersist(entity); } }
@Override public <T> T createDependendInstance(Class<T> cls) { Assert.requireNonNull(cls, "cls"); BeanManager bm = BeanManagerProvider.getInstance().getBeanManager(); AnnotatedType annotatedType = bm.createAnnotatedType(cls); final InjectionTarget<T> injectionTarget = bm.createInjectionTarget(annotatedType); final Bean<T> bean = new BeanBuilder<T>(bm) .beanClass(cls) .name(UUID.randomUUID().toString()) .scope(Dependent.class) .beanLifecycle(new DelegatingContextualLifecycle<T>(injectionTarget)) .create(); Class<?> beanClass = bean.getBeanClass(); CreationalContext<T> creationalContext = bm.createCreationalContext(bean); T instance = (T) bm.getReference(bean, beanClass, creationalContext); contextMap.put(instance, creationalContext); beanMap.put(instance, bean); return instance; }
/** * {@inheritDoc} */ @Override public Object redefineParameterValue(ParameterValue value) { CreationalContext<?> ctx = BeanManagerProvider.getInstance().getBeanManager() .createCreationalContext(declaringBean); try { if (value.getPosition() == handlerMethod.getHandlerParameter().getPosition()) { return event; } return value.getDefaultValue(ctx); } finally { if (ctx != null) { ctx.release(); } } } }
@Override public void processEvent(SystemEvent e) throws AbortProcessingException { if (!this.isActivated) { return; } BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager(); beanManager.fireEvent(e); } }
/** * This method will properly destroy the @Dependent scoped instance. * It will have no effect if the bean is NormalScoped as those have their * own lifecycle which we must not disrupt. */ public void destroy() { if (!BeanManagerProvider.getInstance().getBeanManager().isNormalScope(bean.getScope())) { bean.destroy(instance, creationalContext); } }
@Override public void sessionDestroyed(ClientSession dolphinSession) { Assert.requireNonNull(dolphinSession, "dolphinSession"); BeanManager bm = BeanManagerProvider.getInstance().getBeanManager(); ClientScopeContext clientContext = (ClientScopeContext) bm.getContext(ClientScoped.class); clientContext.destroy(); } }
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { long oldSerialId = in.readLong(); if (oldSerialId != serialVersionUID) { throw new NotSerializableException(getClass().getName() + " serialVersion does not match"); } String passivationId = (String) in.readObject(); bean = (Bean<T>) BeanManagerProvider.getInstance().getBeanManager().getPassivationCapableBean(passivationId); instance = (T) in.readObject(); creationalContext = (CreationalContext<T>) in.readObject(); }
private List<Interceptor<?>> resolveInterceptors(Object instance, Method method) { BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager(); Annotation[] interceptorBindings = extractInterceptorBindings(beanManager, instance, method); if (interceptorBindings.length > 0) { return beanManager.resolveInterceptors(InterceptionType.AROUND_INVOKE, interceptorBindings); } return new ArrayList<>(); }
public static BeanManager getBeanManager() { BeanManagerProvider provider = BeanManagerProvider.getInstance(); if (BeanManagerProvider.isActive()) { return provider.getBeanManager(); } throw new RuntimeException("Unable to locate the BeanManager"); }
BeanManagerInfo bmi = getBeanManagerInfo(ClassUtils.getClassLoader(null)); BeanManagerInfo parentBmi = getParentBeanManagerInfo(ClassUtils.getClassLoader(null)); if (parentBmi != null) result = resolveBeanManagerViaJndi(); result = resolveBeanManagerViaStaticHelper();
/** * It doesn't really matter which of the system events is used to obtain the BeanManager, but * {@link AfterBeanDiscovery} has been chosen since it allows all events which occur after the * {@link AfterBeanDiscovery} to use the {@link BeanManagerProvider}. * * @param afterBeanDiscovery event which we don't actually use ;) * @param beanManager the BeanManager we store and make available. */ public void setBeanManager(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) { setBeanManagerProvider(this); BeanManagerInfo bmi = getBeanManagerInfo(ClassUtils.getClassLoader(null)); bmi.loadTimeBm = beanManager; }
/** * This method recurses into the parent ClassLoaders and checks whether a BeanManagerInfo for it exists. * * @return the BeanManagerInfo of the parent ClassLoader hierarchy if any exists, or <code>null</code> if there is * no {@link BeanManagerInfo} for the ClassLoaders in the hierarchy. */ private BeanManagerInfo getParentBeanManagerInfo(ClassLoader classLoader) { ClassLoader parentClassLoader = classLoader.getParent(); if (parentClassLoader == null) { return null; } BeanManagerInfo bmi = getBeanManagerInfo(parentClassLoader); if (bmi == null) { // recursive call up to the root ClassLoader bmi = getParentBeanManagerInfo(parentClassLoader); } return bmi; }
BeanManagerInfo bmi = getBeanManagerInfo(ClassUtils.getClassLoader(null)); if (!isParentBeanManagerBooted()) result = resolveBeanManagerViaJndi();
public static boolean isRequestContextActive() { return BeanManagerProvider.isActive() && ContextUtils.isContextActive(RequestScoped.class); }
/** * @return whether a BeanManagerInfo for a parent classloader is available and has the booted flag set. */ private boolean isParentBeanManagerBooted() { ClassLoader classLoader = ClassUtils.getClassLoader(null); BeanManagerInfo parentBmi = getParentBeanManagerInfo(classLoader); return parentBmi != null && parentBmi.booted; }
@PreUpdate public void update(Object entity) { BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager(); Set<Bean<?>> beans = beanManager.getBeans(PreUpdateAuditListener.class); for (Bean<?> bean : beans) { PreUpdateAuditListener result = (PreUpdateAuditListener) beanManager.getReference( bean, PreUpdateAuditListener.class, beanManager.createCreationalContext(bean)); result.preUpdate(entity); } }
@Override public <T> T createDependentInstance(Class<T> cls) { Assert.requireNonNull(cls, "cls"); BeanManager bm = BeanManagerProvider.getInstance().getBeanManager(); AnnotatedType annotatedType = bm.createAnnotatedType(cls); final InjectionTarget<T> injectionTarget = bm.createInjectionTarget(annotatedType); final Bean<T> bean = new BeanBuilder<T>(bm) .beanClass(cls) .name(UUID.randomUUID().toString()) .scope(Dependent.class) .beanLifecycle(new DelegatingContextualLifecycle<T>(injectionTarget)) .create(); Class<?> beanClass = bean.getBeanClass(); CreationalContext<T> creationalContext = bm.createCreationalContext(bean); T instance = (T) bm.getReference(bean, beanClass, creationalContext); contextMap.put(instance, creationalContext); beanMap.put(instance, bean); return instance; }
/** * {@inheritDoc} */ @Override public Object redefineParameterValue(ParameterValue value) { CreationalContext<?> ctx = BeanManagerProvider.getInstance().getBeanManager() .createCreationalContext(declaringBean); try { if (value.getPosition() == handlerMethod.getHandlerParameter().getPosition()) { return event; } return value.getDefaultValue(ctx); } finally { if (ctx != null) { ctx.release(); } } } }
@Override public void processEvent(SystemEvent e) throws AbortProcessingException { if (!this.isActivated) { return; } BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager(); beanManager.fireEvent(e); } }