एक जेपीए EntityListener

Question

मैं एक जेपीए EntityListener में एक स्प्रिंग निर्भरता सुई कोशिश कर रहा हूँ में एक स्प्रिंग निर्भरता इंजेक्शन।

@RooJavaBean 
@RooToString 
@RooJpaActiveRecord 
@EntityListeners(PliListener.class) 
public class Pli implements Serializable{ 
... 

लेकिन, मेरा निर्भरता (अर्थात evenementPliRepository) हमेशा अशक्त है:

@Configurable(autowire = Autowire.BY_TYPE, dependencyCheck = true) 
public class PliListener { 

    @Autowired 
    private EvenementPliRepository evenementPliRepository; 

    @PostPersist 
    void onPostPersist(Pli pli) { 
     EvenementPli ev = new EvenementPli(); 
     ev.setPli(pli); 
     ev.setDateCreation(new Date()); 
     ev.setType(TypeEvenement.creation); 
     ev.setMessage("Création d'un pli"); 
     System.out.println("evenementPliRepository: " + evenementPliRepository); 
     evenementPliRepository.save(ev); 
    } 


} 

यहाँ मेरी इकाई वर्ग है: यहाँ मेरी श्रोता वर्ग है।

किसी को भी कृपया मदद कर सकते हैं?

Answer 1

मेरा मानना ​​है कि ऐसा इसलिए है क्योंकि यह श्रोता बीन वसंत के नियंत्रण में नहीं है। वसंत इसे तुरंत नहीं कर रहा है, वसंत कैसे जान सकता है कि उस बीन को कैसे ढूंढें और इंजेक्शन कैसे करें?

मैंने उस पर कोशिश नहीं की है, लेकिन ऐसा लगता है कि आप वसंत नियंत्रण गैर-वसंत-तत्काल बीन्स के लिए स्प्रिंग कॉन्फ़िगर करने योग्य एनोटेशन के साथ एस्पेक्टजे वीवर का उपयोग कर सकते हैं।

http://static.springsource.org/spring/docs/3.1.2.RELEASE/spring-framework-reference/html/aop.html#aop-using-aspectj

Answer 2

राज्यविहीन फलियों पर निर्भरता इंजेक्षन करने के लिए एक हैक,, इसे "स्थिर" निर्भरता को परिभाषित एक सेटर विधि ताकि वसंत निर्भरता (स्थिर निर्भरता को यह बताए) इंजेक्षन कर सकते हैं बनाने के लिए है।

निर्भरता को स्थिर के रूप में घोषित करें।

static private EvenementPliRepository evenementPliRepository; 

एक विधि बनाएं ताकि वसंत इसे इंजेक्ट कर सके।

@Autowired 
public void init(EvenementPliRepository evenementPliRepository) 
{ 
    MyListenerClass.evenementPliRepository = evenementPliRepository; 
    logger.info("Initializing with dependency ["+ evenementPliRepository +"]"); 
} 

अधिक जानकारी पर: http://blog-en.lineofsightnet.com/2012/08/dependency-injection-on-stateless-beans.html

Answer 3

मैं नीचे एक इकाई श्रोता में एक वसंत सेम सुई AOP का उपयोग कर के रास्ते जाने के लिए शुरू कर दिया।

यह एक जेपीए EntityListener वर्ग में वसंत में कामयाब सेम इंजेक्षन करना संभव नहीं है: एक दिन और अनुसंधान और अलग अलग बातें की कोशिश कर के एक आधे के बाद मैं इस link जिसमें कहा गया बारे में जाना। ऐसा इसलिए है क्योंकि जेपीए श्रोता तंत्र एक स्टेटलेस वर्ग पर आधारित होना चाहिए, इसलिए विधियां प्रभावी रूप से स्थिर हैं, और गैर-संदर्भ जागरूक हैं। ... एओपी की कोई राशि आपको बचाएगी, श्रोता का प्रतिनिधित्व करने वाले 'ऑब्जेक्ट' को कुछ भी इंजेक्शन नहीं दिया जाता है, क्योंकि कार्यान्वयन वास्तव में उदाहरण नहीं बनाते हैं, लेकिन क्लास विधि का उपयोग करते हैं।

इस बिंदु पर मैं EclipseLink DescriptorEventAdapter भर में फिर से इकट्ठा हुआ और ठोकर खाई। इस जानकारी का उपयोग करके मैंने एक श्रोता वर्ग बनाया जो वर्णनकर्ता एडाप्टर को बढ़ाता है।

public class EntityListener extends DescriptorEventAdapter { 
    private String injectedValue; 

    public void setInjectedValue(String value){ 
     this.injectedValue = value; 
    } 

    @Override 
    public void aboutToInsert(DescriptorEvent event) { 
     // Do what you need here 
    } 
} 

आदेश वर्ग का उपयोग करने के मैं अपने इकाई वर्ग पर @EntityListeners एनोटेशन का इस्तेमाल किया जा सकता था। दुर्भाग्यवश, यह विधि स्प्रिंग को मेरे श्रोता के निर्माण को नियंत्रित करने की अनुमति नहीं देगी और नतीजतन निर्भरता इंजेक्शन की अनुमति नहीं होगी।इसके बजाय मैं अपने वर्ग के लिए निम्न 'init' समारोह कहा:

public void init() { 
    JpaEntityManager entityManager = null; 

    try { 
     // Create an entity manager for use in this function 
     entityManager = (JpaEntityManager) entityManagerFactory.createEntityManager(); 
     // Use the entity manager to get a ClassDescriptor for the Entity class 
     ClassDescriptor desc = 
      entityManager.getSession().getClassDescriptor(<EntityClass>.class); 
     // Add this class as a listener to the class descriptor 
     desc.getEventManager().addListener(this); 
    } finally { 
     if (entityManager != null) { 
      // Cleanup the entity manager 
      entityManager.close(); 
     } 
    } 
} 

एक छोटे से वसंत एक्सएमएल विन्यास

<!-- Define listener object --> 
<bean id="entityListener" class="EntityListener " init-method="init"> 
    <property name="injectedValue" value="Hello World"/> 
    <property name="entityManagerFactory" ref="emf"/> 
</bean> 

अब हम एक स्थिति है जहाँ वसंत एक इकाई श्रोता बनाता है जोड़े, जो कुछ भी निर्भरता के साथ यह इंजेक्शन की आवश्यकता है, और श्रोता ऑब्जेक्ट स्वयं को इकाई वर्ग के साथ पंजीकृत करता है जिस पर वह सुनना चाहता है।

मुझे आशा है कि इस मदद करता है।

Answer 4

और क्या इस समाधान के बारे में?

@MappedSuperclass 
@EntityListeners(AbstractEntityListener.class) 
public abstract class AbstractEntity { 

    @Id 
    @GeneratedValue(strategy = GenerationType.AUTO) 
    @Column(name = "id") 
    private Long id; 

    @Column(name = "creation_date") 
    private Date creationDate; 

    @Column(name = "modification_date") 
    private Date modificationDate; 

} 

तो श्रोता ...

@Component 
public class AbstractEntityListener { 

    @Autowired 
    private DateTimeService dateTimeService; 

    @PreUpdate 
    public void preUpdate(AbstractEntity abstractEntity) { 
     AutowireHelper.autowire(this, this.dateTimeService); 
      abstractEntity.setModificationDate(this.dateTimeService.getCurrentDate()); 
    } 

    @PrePersist 
    public void prePersist(AbstractEntity abstractEntity) { 
     AutowireHelper.autowire(this, this.dateTimeService); 
     Date currentDate = this.dateTimeService.getCurrentDate(); 
     abstractEntity.setCreationDate(currentDate); 
     abstractEntity.setModificationDate(currentDate); 
    } 
} 

और सहायक ... मेरे लिए

/** 
    * Helper class which is able to autowire a specified class. It holds a static reference to the {@link org 
    * .springframework.context.ApplicationContext}. 
    */ 
    public final class AutowireHelper implements ApplicationContextAware { 

     private static final AutowireHelper INSTANCE = new AutowireHelper(); 
     private static ApplicationContext applicationContext; 

     private AutowireHelper() { 
     } 

     /** 
     * Tries to autowire the specified instance of the class if one of the specified beans which need to be autowired 
     * are null. 
     * 
     * @param classToAutowire the instance of the class which holds @Autowire annotations 
     * @param beansToAutowireInClass the beans which have the @Autowire annotation in the specified {#classToAutowire} 
     */ 
     public static void autowire(Object classToAutowire, Object... beansToAutowireInClass) { 
      for (Object bean : beansToAutowireInClass) { 
       if (bean == null) { 
        applicationContext.getAutowireCapableBeanFactory().autowireBean(classToAutowire); 
       } 
      } 
     } 

     @Override 
     public void setApplicationContext(final ApplicationContext applicationContext) { 
      AutowireHelper.applicationContext = applicationContext; 
     } 

     /** 
     * @return the singleton instance. 
     */ 
     public static AutowireHelper getInstance() { 
      return INSTANCE; 
     } 

    } 

काम करता है।

स्रोत: http://guylabs.ch/2014/02/22/autowiring-pring-beans-in-hibernate-jpa-entity-listeners/

Answer 5

यह वास्तव में एक पुराने सवाल है, लेकिन मैं वैकल्पिक समाधान:

public class MyEntityListener { 
    @Autowired 
    private ApplicationEventPublisher publisher; 

    @PostPersist 
    public void postPersist(MyEntity target) { 
     SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); 

     publisher.publishEvent(new OnCreatedEvent<>(this, target)); 
    } 

    @PostUpdate 
    public void postUpdate(MyEntity target) { 
     SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); 

     publisher.publishEvent(new OnUpdatedEvent<>(this, target)); 
    } 

    @PostRemove 
    public void postDelete(MyEntity target) { 
     SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); 

     publisher.publishEvent(new OnDeletedEvent<>(this, target)); 
    } 
} 

शायद नहीं सबसे अच्छा एक लेकिन स्थैतिक चर की तुलना में बेहतर w/ओ AOP + बुनाई।

Answer 6

मैं बाहर का परीक्षण दृष्टिकोण https://guylabs.ch/2014/02/22/autowiring-pring-beans-in-hibernate-jpa-entity-listeners/ में सुझाव दिया और काम किया। बहुत साफ नहीं है लेकिन नौकरी करता है। मेरे लिए थोड़ा संशोधित AutowireHelper वर्ग इस तरह देखा:

import org.springframework.context.ApplicationContext; 
import org.springframework.context.ApplicationContextAware; 
import org.springframework.stereotype.Component; 

@Component 
public class AutowireHelper implements ApplicationContextAware { 

    private static ApplicationContext applicationContext; 

    private AutowireHelper() { 
    } 

    public static void autowire(Object classToAutowire) { 
     AutowireHelper.applicationContext.getAutowireCapableBeanFactory().autowireBean(classToAutowire); 
    } 

    @Override 
    public void setApplicationContext(final ApplicationContext applicationContext) { 
     AutowireHelper.applicationContext = applicationContext; 
    } 
} 

तो इस तरह इकाई श्रोता से कहा जाता है:

public class MyEntityAccessListener { 

    @Autowired 
    private MyService myService; 


    @PostLoad 
    public void postLoad(Object target) { 

     AutowireHelper.autowire(this); 

     myService.doThings(); 
     ... 
    } 

    public void setMyService(MyService myService) { 
     this.myService = myService; 
    } 
}