कस्टम भंडार कार्यान्वयन के लिए MongoTemplate पासिंग

Question

परियोजना में इस्तेमाल किया कई करने के लिए कॉन्फ़िगर किया गया है MongoTemplate रों

मोंगो रेफरी पैकेज में खजाने के लिए

@EnableMongoRepositories(basePackages={"com.mypackage.one"}, mongoTemplateRef="mongoTemplateOne") 

के रूप में पारित हो जाता है com.mypackage.one

और

@EnableMongoRepositories(basePackages={"com.mypackage.two"}, mongoTemplateRef="mongoTemplateTwo") 

पैकेज com.mypackage.two

मानक खजाने के लिए में खजाने के लिए यह ठीक काम करता है। लेकिन परिदृश्यों के लिए, जहां मुझे कस्टम व्यवहार की आवश्यकता है, मैं अपने कस्टम व्यवहार आवश्यकताओं के साथ myRepoCustomImpl कहता हूं।

समस्या: मैं MongoTemplate जो अनुरूप मानक भंडार का उपयोग करने की जरूरत है।

उदा। तो MyRepo रूप

@Repository 
interface MyRepo extends MongoRepository<MyEntity, String>, MyRepoCustom{} 

MyRepoCustom इंटरफेस प्रदान कर रहा है MyRepoCustomImpl

@Service 
    public class MyRepoCustomImpl implements MyRepoCustom{ 
     @Autowired 
     @Qualifier("mongoTemplateOne") 
     MongoTemplate mongoTmpl; 

     @Override 
     MyEntity myCustomNeedFunc(String arg){ 
      // MyImplemenation goes here 
     } 

} 

तो MyRepo पैकेज com.mypackage.one में है, mongoTemplateOne myRepo द्वारा उपयोग किया जाएगा, इसलिए करने के लिए एक किसी तरह होना चाहिए MyRepoCustomImpl को पता चलेगा कि इसे mongoTemplateOne का भी उपयोग करना चाहिए, जब भी मैं 0 में परिवर्तन करूंगा MyRepo के लिए, के रूप में

@EnableMongoRepositories(basePackages={"com.mypackage.one"}, mongoTemplateRef="mongoTemplateThree") 

अब मैं MyRepoCustomImpl में @Qualifier में परिवर्तन करने की जरूरत है कहते हैं! कस्टम व्यवहार के साथ बहुत से प्रतिनिधि हैं, इसलिए यह कठिन कार्य बन रहा है।

प्रश्न: इसके बजाय ऐसा कोई तरीका नहीं है कि मोंगो टेम्पलेट का उपयोग किया जाना चाहिए रेपो के अनुसार स्वचालित रूप से इंजेक्शन या हल किया जाना चाहिए?

Answer 1

आप सीधे अपने सेवा कक्षाओं में MongoTemplate और MongoOperations इंजेक्षन कर सकते हैं।

उन्हें ऑटो-वायर करने का प्रयास करें और फिर आपको अच्छा होना चाहिए।

अद्यतन:

उचित क्वालीफायर के साथ autowiring (जब से तुम दो खजाने है) यह संभव नहीं है के बिना। कस्टम वर्ग के रूप में सभी एक साथ भंडार से अलग हैं। यदि आपके पास केवल एक भंडार था तो मोंगोटेम्प्लेट का ऑटोवायर पर्याप्त होगा, अन्यथा आपको मल्टीटोम्प्लेट के दो बीन्स के रूप में प्रत्यारोपण में क्वालीफायर प्रदान करना होगा।

Answer 2

MongoTemplateMongoRepository इंटरफ़ेस द्वारा उजागर नहीं किया गया है।वे संभावित रूप से MongoTemplate@Bean के नाम का पर्दाफाश कर सकते हैं और यह आपके प्रश्न का समाधान प्रदान कर सकता है। हालांकि, तथ्य यह है कि वे नहीं करते हैं, मैं नीचे एक उदाहरण प्रदान करूंगा जो आपकी आवश्यकताओं के अनुरूप हो सकता है।

सबसे पहले mongoTemplateRefनाम @Bean उपयोग करने के लिए की को संदर्भित करता है, यह MongoTemplate का नाम निर्दिष्ट नहीं है।

आपको प्रत्येक MongoTemplate@Bean प्रदान करने की आवश्यकता होगी और फिर इसे अपने @EnableMongoRepositories एनोटेशन के भीतर देखें।

चूंकि आप वसंत-बूट का उपयोग कर रहे हैं, तो आप MongoDataAutoConfiguration कक्षा का लाभ उठा सकते हैं। कृपया यहां देखें कि यह https://github.com/spring-projects/spring-boot/blob/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/mongo/MongoDataAutoConfiguration.java पर क्या करता है।

सबसे सरल उदाहरण यह है।

पैकेज: com.abc.repo

@Configuration 
@EnableMongoRepositories(basePackages={"com.abc.repo"}, mongoTemplateRef=AbcRepConfiguration.TEMPLATE_NAME) 
public class AbcRepoConfiguration { 
    public static final String TEMPLATE_NAME = "mongoTemplateTwo"; 

    @Bean(name="mongoPropertiesTwo") 
    @ConfigurationProperties(prefix="spring.data.mongodb2") 
    public MongoProperties mongoProperties() { 
     return new MongoProperties(); 
    } 

    @Bean(name="mongoDbFactoryTwo") 
    public SimpleMongoDbFactory mongoDbFactory(MongoClient mongo, @Qualifier("mongoPropertiesTwo") MongoProperties mongoProperties) throws Exception { 
     String database = this.mongoProperties.getMongoClientDatabase(); 
     return new SimpleMongoDbFactory(mongo, database); 
    } 

    @Bean(name=AbcRepoConfiguration.TEMPLATE_NAME) 
    public MongoTemplate mongoTemplate(@Qualifier("mongoDbFactoryTwo") MongoDbFactory mongoDbFactory, MongoConverter converter) throws UnknownHostException { 
     return new MongoTemplate(mongoDbFactory, converter); 
    } 
} 

public abstract class BaseRepo { 
    @Autowired 
    @Qualifier(AbcRepoConfiguration.TEMPLATE_NAME) 
    MongoTemplate mongoTemplate; 
} 

@Service 
public class MyRepoCustomImpl extends BaseRepo implements MyRepoCustom {  
    @Override 
    MyEntity myCustomNeedFunc(String arg){ 
     // access to this.mongoTemplate is present 
    } 
} 

कॉम: com.xyz.repo

@Configuration 
@EnableMongoRepositories(basePackages={"com.xyz.repo"}) //mongoTemplateRef defaults to mongoTemplate 
public class XyzRepoConfiguration { 

} 

public abstract class BaseRepo { 
    @Autowired 
    MongoTemplate mongoTemplate; 
} 

@Service 
public class MyRepoCustomImpl extends BaseRepo implements MyRepoCustom {  
    @Override 
    MyEntity myCustomNeedFunc(String arg){ 
     // access to this.mongoTemplate is present 
    } 
} 

पैकेज (इस कार्यान्वयन MongoDataAutoConfiguration द्वारा प्रदान विन्यास पर निर्भर करता है)। xyz.repospring.data.mongodb पर application.propertiesके भीतर संपत्तियों पर भरोसा करेगाcom.abc.repo भीतर application.properties

मैंने पहले AbcRepoConfiguration.TEMPLATE_NAME दृष्टिकोण इस्तेमाल नहीं किया है spring.data.mongodb2 गुणों पर निर्भर करेगा, लेकिन यह मेरी आईडीई के भीतर संकलन था।

अगर आपको किसी स्पष्टीकरण की आवश्यकता है तो कृपया मुझे बताएं।

Answer 3

MongoTemplate आपके भंडार वर्ग पर इंजेक्शन नहीं है लेकिन spring-data-mongodb में गहरा है, इसलिए आप इसे अपने भंडार से नहीं प्राप्त कर सकते हैं। कोड को देखो, आप बहुत सी चीजें सीखेंगे।

तो यदि आप वसंत-बूट ऑटो-कॉन्फ़िगरेशन और घटक खोज को अक्षम करते हैं और इसे स्वयं से कॉन्फ़िगर करते हैं, तो आप रेपो विस्तार के अनुसार एक बीन इंजेक्ट नहीं कर सकते हैं, लेकिन यह @Qualifier नाम बदलने से काफी लंबा होगा। आपका आईडीई कॉल आपको आसानी से मदद करता है और आपको अक्षम ऑटो-कॉन्फ़िगरेशन पर पछतावा हो सकता है।

निराशा के लिए खेद है।

Answer 4

आप निम्न उदाहरण का उपयोग कर सकते हैं।

1)

package com.johnathanmarksmith.mongodb.example; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.annotation.AnnotationConfigApplicationContext; 

/** 
* Date: 6/28/13/10:40 AM 
* Author: Johnathan Mark Smith 
* Email: john@johnathanmarksmith.com 
* <p/> 
* Comments: 
* This main really does not have to be here but I just wanted to add something for the demo.. 
* 
*/ 


public class MongoDBApp { 

    static final Logger logger = LoggerFactory.getLogger(MongoDBApp.class); 

    public static void main(String[] args) { 
     logger.info("Fongo Demo application"); 

     ApplicationContext context = new AnnotationConfigApplicationContext(MongoConfiguration.class); 




     logger.info("Fongo Demo application"); 
    } 
} 

2)

package com.johnathanmarksmith.mongodb.example; 

import com.mongodb.Mongo; 
import com.mongodb.ServerAddress; 
import org.springframework.context.annotation.ComponentScan; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.PropertySource; 
import org.springframework.data.mongodb.config.AbstractMongoConfiguration; 
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories; 

import java.util.ArrayList; 


/** 
* Date: 5/24/13/8:05 AM 
* Author: Johnathan Mark Smith 
* Email: john@johnathanmarksmith.com 
* <p/> 
* Comments: 
* <p/> 
* This is a example on how to setup a database with Spring's Java Configuration (JavaConfig) style. 
* <p/> 
* As you can see from the code below this is easy and a lot better then using the old style of XML files. 
* <p/> 
* T 
*/ 

@Configuration 
@EnableMongoRepositories 
@ComponentScan(basePackageClasses = {MongoDBApp.class}) 
@PropertySource("classpath:application.properties") 
public class MongoConfiguration extends AbstractMongoConfiguration { 


    @Override 
    protected String getDatabaseName() { 
     return "demo"; 
    } 



    @Override 
    public Mongo mongo() throws Exception { 
     /** 
     * 
     * this is for a single db 
     */ 

     // return new Mongo(); 


     /** 
     * 
     * This is for a relset of db's 
     */ 

     return new Mongo(new ArrayList<ServerAddress>() {{ add(new ServerAddress("127.0.0.1", 27017)); add(new ServerAddress("127.0.0.1", 27027)); add(new ServerAddress("127.0.0.1", 27037)); }}); 

    } 

    @Override 
    protected String getMappingBasePackage() { 
     return "com.johnathanmarksmith.mongodb.example.domain"; 
    } 

} 

3)

package com.johnathanmarksmith.mongodb.example.repository; 


import java.util.List; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.data.mongodb.core.MongoTemplate; 
import org.springframework.data.mongodb.core.query.Criteria; 
import org.springframework.data.mongodb.core.query.Query; 
import org.springframework.stereotype.Repository; 

import com.johnathanmarksmith.mongodb.example.domain.Person; 


/** 
* Date: 6/26/13/1:22 PM 
* Author: Johnathan Mark Smith 
* Email: john@johnathanmarksmith.com 
* <p/> 
* Comments: 
* <p/> 
* This is my Person Repository 
*/ 


@Repository 
public class PersonRepository { 

    static final Logger logger = LoggerFactory.getLogger(PersonRepository.class); 

    @Autowired 
    MongoTemplate mongoTemplate; 

    public long countUnderAge() { 
     List<Person> results = null; 

     Query query = new Query(); 
     Criteria criteria = new Criteria(); 
     criteria = criteria.and("age").lte(21); 

     query.addCriteria(criteria); 
     //results = mongoTemplate.find(query, Person.class); 
     long count = this.mongoTemplate.count(query, Person.class); 

     logger.info("Total number of under age in database: {}", count); 
     return count; 
    } 

    /** 
    * This will count how many Person Objects I have 
    */ 
    public long countAllPersons() { 
     // findAll().size() approach is very inefficient, since it returns the whole documents 
     // List<Person> results = mongoTemplate.findAll(Person.class); 

     long total = this.mongoTemplate.count(null, Person.class); 
     logger.info("Total number in database: {}", total); 

     return total; 
    } 

    /** 
    * This will install a new Person object with my 
    * name and random age 
    */ 
    public void insertPersonWithNameJohnathan(double age) { 
     Person p = new Person("Johnathan", (int) age); 

     mongoTemplate.insert(p); 
    } 

    /** 
    * this will create a {@link Person} collection if the collection does not already exists 
    */ 
    public void createPersonCollection() { 
     if (!mongoTemplate.collectionExists(Person.class)) { 
      mongoTemplate.createCollection(Person.class); 
     } 
    } 

    /** 
    * this will drop the {@link Person} collection if the collection does already exists 
    */ 
    public void dropPersonCollection() { 
     if (mongoTemplate.collectionExists(Person.class)) { 
      mongoTemplate.dropCollection(Person.class); 
     } 
    } 
} 

4)

package com.johnathanmarksmith.mongodb.example.domain; 

import org.springframework.data.annotation.Id; 
import org.springframework.data.mongodb.core.mapping.Document; 

/** 
* Date: 6/26/13/1:21 PM 
* Author: Johnathan Mark Smith 
* Email: john@johnathanmarksmith.com 
* <p/> 
* Comments: 
* <p/> 
* This is a Person object that I am going to be using for my demo 
*/ 


@Document 
public class Person { 

    @Id 
    private String personId; 

    private String name; 
    private int age; 

    public Person(String name, int age) { 
     this.name = name; 
     this.age = age; 
    } 

    public String getPersonId() { 
     return personId; 
    } 

    public void setPersonId(final String personId) { 
     this.personId = personId; 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(final String name) { 
     this.name = name; 
    } 

    public int getAge() { 
     return age; 
    } 

    public void setAge(final int age) { 
     this.age = age; 
    } 

    @Override 
    public String toString() { 
     return "Person [id=" + personId + ", name=" + name 
       + ", age=" + age + "]"; 
    } 

} 

https://github.com/JohnathanMarkSmith/spring-fongo-demo