java练习生

一、添加依赖

<!--添加mongodb功能-->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>2.1.8.RELEASE</version>
</dependency>
<!--使用ConfigurationProperties注解为自定义的配置类赋值时需要添加该依赖，否则提示：spring boot configuration annotation processor not found in classpath-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

二、创建配置类

2.1 添加连接配置信息（application.yml）

mongodb: 
  database: mongodb://ttt:hzq@xxx1:27017,xxx2:27017,xxx3:27017/vts?authSource=admin
  uri: test

2.2 创建配置参数类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "mongodb")
@Data
public class MongoDbProperties {
    private String database;
    private String uri;
}

2.3 创建配置类

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import hzq.maven.demo.config.properties.MongoDbProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

import javax.annotation.Resource;

@Configuration
@EnableConfigurationProperties(MongoDbProperties.class)
public class MongoDbConfig extends AbstractMongoConfiguration {

    @Resource
    private MongoDbProperties mongoProperties;

    @Override
    @Bean
    public MongoTemplate mongoTemplate() throws Exception {

        return new MongoTemplate(mongoDbFactory());
    }

    @Override
    @Bean
    public MongoDbFactory mongoDbFactory() {
        MongoDbFactory dbFactory = new SimpleMongoDbFactory(mongoClient(), getDatabaseName());
        return dbFactory;
    }

    @Override
    public MongoClient mongoClient() {
        MongoClientURI uri = new MongoClientURI(this.mongoProperties.getUri());
        return new MongoClient(uri);
    }

    @Override
    protected String getDatabaseName() {
        return this.mongoProperties.getDatabase();
    }
}

三、创建操作类

3.1 接口

import java.util.List;
import java.util.Map;

/**
 * mongo操作接口
 */
public interface MongoService{

    /**
     * 保存到mongo
     * @param objectToSave 数据对象类型
     * @param aggregateName 集合名称
     */
    void save(Object objectToSave,String aggregateName);

    /**
     * 根据条件查询记录
     * @param condition 条件名称
     * @param value    条件值
     * @param     entityClass 对应实体类
     * @param aggregateName 集合名称
     * @return mongo记录
     */
    Object find(String condition, Object value ,Class<?> entityClass , String aggregateName);

    /**
     * 根据条件查询记录
     * @param conditionMap 条件集合
     * @param     entityClass 对应实体类
     * @param aggregateName 集合名称
     * @return mongo记录
     */
    Object findByMap(Map<String ,Object> conditionMap, Class<?> entityClass , String aggregateName);

    /**
     * 根据条件查询批量记录
     * @param condition 条件名称
     * @param value    条件值
     * @param     entityClass 对应实体类
     * @param aggregateName 集合名称
     * @return mongo记录
     */
    List<Object> findBatch(String condition, Object value ,Class<?> entityClass , String aggregateName);

    /**
     * 根据条件查询记录
     * @param conditionMap 条件集合
     * @param     entityClass 对应实体类
     * @param aggregateName 集合名称
     * @return mongo记录
     */
    List<Object> findBatchByMap(Map<String ,Object> conditionMap, Class<?> entityClass , String aggregateName);


    /**
     * 根据条件修改单条记录
     * @param condition 修改记录的查询条件
     *  @param    queryValue 查询条件过滤值
     * @param key        要修改的列名称
     * @param updateValue      修改的值
     * @param     entityClass 对应实体类
     * @param aggregateName 集合名称
     */
    void update(String condition,Object queryValue ,String key, Object updateValue,Class<?> entityClass, String aggregateName);

    /**
     *根据条件集合批量修改记录
     * @param conditionMap 条件集合
     * @param key  要修改的列
     * @param updateValue 修改的值
     * @param entityClass 对应实体类
     * @param aggregateName 集合名称
     */
    void updateByMap(Map<String ,Object> conditionMap,String key, Object updateValue,Class<?> entityClass, String aggregateName);
}

3.2 实现

import hzq.maven.demo.service.mongo.MongoService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
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.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * mongo操作实现
 */
@ConditionalOnExpression("${mongodb.button:true}")
@Service
public class MongoServiceImpl implements MongoService {
    @Resource
    private MongoTemplate mongoTemplate;

    @Override
    public void save(Object objectToSave, String aggregateName) {
        mongoTemplate.save(objectToSave, aggregateName);
    }

    @Override
    public Object find(String condition, Object value, Class entityClass, String aggregateName) {
        Query query = new Query(Criteria.where(condition).is(value));
        return mongoTemplate.findOne(query, entityClass, aggregateName);
    }

    @Override
    public Object findByMap(Map conditionMap, Class entityClass, String aggregateName) {
        Query query = new Query();
        conditionMap.forEach(( k, v) -> query.addCriteria(Criteria.where(k.toString()).is(v)));
        return mongoTemplate.findOne(query, entityClass, aggregateName);
    }

    @Override
    public List findBatch(String condition, Object value, Class entityClass, String aggregateName) {
        Query query = new Query(Criteria.where(condition).is(value));
        return mongoTemplate.find(query, entityClass, aggregateName);
    }

    @Override
    public List findBatchByMap(Map conditionMap, Class entityClass, String aggregateName) {
        Query query = new Query();
        conditionMap.forEach(( k, v) -> query.addCriteria(Criteria.where(k.toString()).is(v)));
        return mongoTemplate.find(query, entityClass, aggregateName);
    }

    @Override
    public void update(String condition, Object queryValue, String key, Object updateValue, Class entityClass, String aggregateName) {
        Query query = new Query(Criteria.where(condition).is(queryValue));
        Update update = Update.update(key, updateValue);
        mongoTemplate.updateFirst(query, update, entityClass,aggregateName);
    }

    @Override
    public void updateByMap(Map conditionMap, String key, Object updateValue, Class entityClass, String aggregateName) {
        Query query = new Query();
        conditionMap.forEach(( k, v) -> query.addCriteria(Criteria.where(k.toString()).is(v)));
        Update update = Update.update(key, updateValue);
        mongoTemplate.updateMulti(query, update, entityClass,aggregateName);
    }
}

四、使用

@Resource
private MongoTemplate mongoTemplate;

public void mongoSet(TestDataDTO testDataDTO){
    mongoTemplate.save(testDataDTO,"TestData");
}