SpringBoot 集成MongoDB

一时失言乱红尘 2023-10-18 16:50 90阅读 0赞

1、项目结构

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70][]

pom.xml 文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>com.zzg</groupId>
    		<artifactId>mysql-boot</artifactId>
    		<version>0.0.1-SNAPSHOT</version>
    	</parent>
    	<artifactId>mysql-boot-mongodb</artifactId>
    	<dependencies>
    		
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-mongodb</artifactId>
    			<version>2.1.2.RELEASE</version>
    		</dependency>
    	</dependencies>
    </project>

mongodb封装 核心代码：

package com.zzg.mongodb.config.entity;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @Component
    @Configuration
    @ConfigurationProperties(prefix = "com.zzg.mongodb") 
    @PropertySource("classpath:mongodb.properties")
    public class MongODBConfigEntity {
    	private String host;
    	private String port;
    	private String database;
    	private String username;
    	private String password;
    	private String socketTimeout;
    	private String connectTimeout;
    	private String connectionsPerHost;
    	
    	// set 和 get 方法
    	public String getHost() {
    		return host;
    	}
    	public void setHost(String host) {
    		this.host = host;
    	}
    	public String getPort() {
    		return port;
    	}
    	public void setPort(String port) {
    		this.port = port;
    	}
    	public String getDatabase() {
    		return database;
    	}
    	public void setDatabase(String database) {
    		this.database = database;
    	}
    	public String getSocketTimeout() {
    		return socketTimeout;
    	}
    	public void setSocketTimeout(String socketTimeout) {
    		this.socketTimeout = socketTimeout;
    	}
    	public String getConnectTimeout() {
    		return connectTimeout;
    	}
    	public void setConnectTimeout(String connectTimeout) {
    		this.connectTimeout = connectTimeout;
    	}
    	public String getConnectionsPerHost() {
    		return connectionsPerHost;
    	}
    	public void setConnectionsPerHost(String connectionsPerHost) {
    		this.connectionsPerHost = connectionsPerHost;
    	}
    	public String getUsername() {
    		return username;
    	}
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	
    	// 自定义方法
    	public String getURI(){
    		// 标准个数 =  mongodb://userName:passWord@127.0.0.1:27017/DBname
    		StringBuilder builder = new StringBuilder();
    		builder.append("mongodb://").append(this.username).append(":").append(this.password).append("@")
    			.append(this.host).append(":").append(this.port).append("/").append(this.database);
    		return builder.toString().trim();
    	}
    	
    	
    	
    
    
    }

package com.zzg.mongodb.config;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.mongodb.MongoDbFactory;
    import org.springframework.data.mongodb.core.MongoTemplate;
    import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
    
    import com.mongodb.MongoClientOptions;
    import com.mongodb.MongoClientURI;
    import com.zzg.mongodb.config.entity.MongODBConfigEntity;
    
    @Configuration
    public class MongODBConfig {
    	@Autowired
    	private MongODBConfigEntity entity;
    
    	// 获取MongoDbFactory 对象
    	@Bean
    	public MongoDbFactory getMongDbFactory() {
    		MongoClientOptions.Builder builder = MongoClientOptions.builder()
    				.socketTimeout(Integer.valueOf(entity.getSocketTimeout().trim()))
    				.connectTimeout(Integer.valueOf(entity.getConnectTimeout().trim()))
    				.connectionsPerHost(Integer.valueOf(entity.getConnectionsPerHost().trim()));
    		MongoClientURI mongoClientURI = new MongoClientURI(entity.getURI(), builder);
    		return new SimpleMongoDbFactory(mongoClientURI);
    	}
    	
    	// 获取MongoTemplate 对象
    	@Bean
    	public MongoTemplate getMongoTemplate(){
    		return new MongoTemplate(getMongDbFactory());
    	}
    
    }

package com.zzg.mongodb.common.inter;
    
    import java.util.List;
    
    import org.springframework.data.mongodb.core.query.Query;
    import org.springframework.data.mongodb.core.query.Update;
    
    /**
     * 
     * @ClassName:  BaseMongoDao   
     * @Description: 基础公共接口定义  
     * @author: ** -zzg
     * @date:   2019年4月9日 下午4:45:38   
     *   
     * @param <T>  
     * @Copyright: 2019 www.digipower.cn 
     * 注意：本内容仅限于****技开发有限公司内部使用，禁止用于其他的商业目的
     */
    public interface BaseMongoDao<T> {
    	
    	 public List<T> find(Query query);
    	 
    	 public T findOne(Query query);
    	 
    	 public void update(Query query, Update update);
    	 
    	 public T save(T entity);
    	 
    	 public T findById(String id);
    	 
    	 public T findById(String id, String collectionName);
    	 
    	 public long count(Query query);
    	 
    	 public void remove(Query query);
    	 
    	 
    
    }

package com.zzg.mongodb.common;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.mongodb.core.MongoTemplate;
    import org.springframework.data.mongodb.core.query.Query;
    import org.springframework.data.mongodb.core.query.Update;
    import org.springframework.stereotype.Component;
    import com.zzg.mongodb.common.inter.BaseMongoDao;
    import com.zzg.mongodb.reflect.ReflectionUtils;
    
    /**
     * 
     * @ClassName:  BaseMongoDaoImpl   
     * @Description: mongodb 抽象类组件  
     * @author: *** -zzg
     * @date:   2019年4月9日 下午4:51:59   
     *   
     * @param <T>  
     * @Copyright: 2019 www.digipower.cn 
     * 注意：本内容仅限于****科技开发有限公司内部使用，禁止用于其他的商业目的
     */
    
    @Component
    public abstract class BaseMongoDaoImpl<T> implements BaseMongoDao<T> {
    //	@Autowired
    //	private MongoTemplate template;
    	
    	/**
         * spring mongodb　集成操作类
         */
        protected MongoTemplate template;
        
        /**
         * 注入mongodbTemplate
         *
         * @param mongoTemplate
         */
        protected abstract void setMongoTemplate(MongoTemplate template);
        
    
    	@Override
    	public List<T> find(Query query) {
    		// TODO Auto-generated method stub
    		return template.find(query, this.getEntityClass());
    	}
    
    	@Override
    	public T findOne(Query query) {
    		// TODO Auto-generated method stub
    		return template.findOne(query, this.getEntityClass());
    	}
    
    	@Override
    	public void update(Query query, Update update) {
    		// TODO Auto-generated method stub
    		template.findAndModify(query, update, this.getEntityClass());
    	}
    
    	@Override
    	public T save(T entity) {
    		// TODO Auto-generated method stub
    		template.insert(entity);
    		return entity;
    	}
    
    	@Override
    	public T findById(String id) {
    		// TODO Auto-generated method stub
    		return template.findById(id, this.getEntityClass());
    	}
    
    	@Override
    	public T findById(String id, String collectionName) {
    		// TODO Auto-generated method stub
    		return template.findById(id, this.getEntityClass(), collectionName);
    	}
    
    	@Override
    	public long count(Query query) {
    		// TODO Auto-generated method stub
    		return template.count(query, this.getEntityClass());
    	}
    
    	@Override
    	public void remove(Query query) {
    		// TODO Auto-generated method stub
    		template.remove(query, this.getEntityClass());
    	}
    	
    	/**
         * 获取需要操作的实体类class
         *
         * @return
         */
        private Class<T> getEntityClass() {
            return ReflectionUtils.getSuperClassGenricType(getClass());
        }
    }

package com.zzg.mongodb.reflect;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import org.apache.commons.lang.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.util.Assert;
    /**
     * 
     * @ClassName:  ReflectionUtils   
     * @Description: 反射工具类
     * @author: 世纪伟图 -zzg
     * @date:   2019年4月9日 下午4:55:34   
     *     
     * @Copyright: 2019 www.digipower.cn 
     * 注意：本内容仅限于深圳市世纪伟图科技开发有限公司内部使用，禁止用于其他的商业目的
     */
    
    
    public class ReflectionUtils {
    	// 错误日志记录
    	private final static Logger logger = LoggerFactory.getLogger(ReflectionUtils.class);
    	
    	/**
         * 调用Getter方法.
         */
        public static Object invokeGetterMethod(Object obj, String propertyName) {
            String getterMethodName = "get" + StringUtils.capitalize(propertyName);
            return invokeMethod(obj, getterMethodName, new Class[] {}, new Object[] {});
        }
    
        /**
         * 调用Setter方法.使用value的Class来查找Setter方法.
         */
        public static void invokeSetterMethod(Object obj, String propertyName, Object value) {
            invokeSetterMethod(obj, propertyName, value, null);
        }
    
        /**
         * 调用Setter方法.
         *
         * @param propertyType 用于查找Setter方法,为空时使用value的Class替代.
         */
        public static void invokeSetterMethod(Object obj, String propertyName, Object value,
            Class<?> propertyType) {
            Class<?> type = propertyType != null ? propertyType : value.getClass();
            String setterMethodName = "set" + StringUtils.capitalize(propertyName);
            invokeMethod(obj, setterMethodName, new Class[] {type}, new Object[] {value});
        }
    
        /**
         * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
         */
        public static Object getFieldValue(final Object obj, final String fieldName) {
            Field field = getAccessibleField(obj, fieldName);
    
            if (field == null) {
                throw new IllegalArgumentException(
                    "Could not find field [" + fieldName + "] on target [" + obj + "]");
            }
    
            Object result = null;
            try {
                result = field.get(obj);
            } catch (IllegalAccessException e) {
                logger.error("不可能抛出的异常" + e.getMessage());
            }
            return result;
        }
    
        /**
         * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
         */
        public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
            Field field = getAccessibleField(obj, fieldName);
    
            if (field == null) {
                throw new IllegalArgumentException(
                    "Could not find field [" + fieldName + "] on target [" + obj + "]");
            }
    
            try {
                field.set(obj, value);
            } catch (IllegalAccessException e) {
                logger.error("不可能抛出的异常" + e.getMessage());
            }
        }
    
        /**
         * 循环向上转型, 获取对象的DeclaredField,   并强制设置为可访问.
         * <p>
         * 如向上转型到Object仍无法找到, 返回null.
         */
        public static Field getAccessibleField(final Object obj, final String fieldName) {
            Assert.notNull(obj, "object不能为空");
            Assert.hasText(fieldName, "fieldName");
            for (Class<?> superClass = obj.getClass();
                 superClass != Object.class; superClass = superClass.getSuperclass()) {
                try {
                    Field field = superClass.getDeclaredField(fieldName);
                    field.setAccessible(true);
                    return field;
                } catch (NoSuchFieldException e) {//NOSONAR
                    // Field不在当前类定义,继续向上转型
                }
            }
            return null;
        }
    
        /**
         * 直接调用对象方法, 无视private/protected修饰符.
         * 用于一次性调用的情况.
         */
        public static Object invokeMethod(final Object obj, final String methodName,
            final Class<?>[] parameterTypes, final Object[] args) {
            Method method = getAccessibleMethod(obj, methodName, parameterTypes);
            if (method == null) {
                throw new IllegalArgumentException(
                    "Could not find method [" + methodName + "] on target [" + obj + "]");
            }
    
            try {
                return method.invoke(obj, args);
            } catch (Exception e) {
                throw convertReflectionExceptionToUnchecked(e);
            }
        }
    
        /**
         * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问.
         * 如向上转型到Object仍无法找到, 返回null.
         * <p>
         * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)
         */
        public static Method getAccessibleMethod(final Object obj, final String methodName,
            final Class<?>... parameterTypes) {
            Assert.notNull(obj, "object不能为空");
    
            for (Class<?> superClass = obj.getClass();
                 superClass != Object.class; superClass = superClass.getSuperclass()) {
                try {
                    Method method = superClass.getDeclaredMethod(methodName, parameterTypes);
    
                    method.setAccessible(true);
    
                    return method;
    
                } catch (NoSuchMethodException e) {//NOSONAR
                    // Method不在当前类定义,继续向上转型
                }
            }
            return null;
        }
    
        /**
         * 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
         * 如无法找到, 返回Object.class.
         * eg.
         * public UserDao extends HibernateDao<User>
         *
         * @param clazz The class to introspect
         * @return the first generic declaration, or Object.class if cannot be determined
         */
        @SuppressWarnings({"unchecked", "rawtypes"})
        public static <T> Class<T> getSuperClassGenricType(final Class clazz) {
            return getSuperClassGenricType(clazz, 0);
        }
    
        /**
         * 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
         * 如无法找到, 返回Object.class.
         * <p>
         * 如public UserDao extends HibernateDao<User,Long>
         *
         * @param clazz clazz The class to introspect
         * @param index the Index of the generic ddeclaration,start from 0.
         * @return the index generic declaration, or Object.class if cannot be determined
         */
        @SuppressWarnings("rawtypes")
        public static Class getSuperClassGenricType(final Class clazz, final int index) {
    
            Type genType = clazz.getGenericSuperclass();
    
            if (!(genType instanceof ParameterizedType)) {
                logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
                return Object.class;
            }
    
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    
            if (index >= params.length || index < 0) {
                logger.warn(
                    "Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                        + params.length);
                return Object.class;
            }
            if (!(params[index] instanceof Class)) {
                logger.warn(clazz.getSimpleName()
                    + " not set the actual class on superclass generic parameter");
                return Object.class;
            }
    
            return (Class) params[index];
        }
    
        /**
         * 将反射时的checked exception转换为unchecked exception.
         */
        public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
            if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
                || e instanceof NoSuchMethodException) {
                return new IllegalArgumentException("Reflection Exception.", e);
            } else if (e instanceof InvocationTargetException) {
                return new RuntimeException("Reflection Exception.",
                    ((InvocationTargetException) e).getTargetException());
            } else if (e instanceof RuntimeException) {
                return (RuntimeException) e;
            }
            return new RuntimeException("Unexpected Checked Exception.", e);
        }
    
    }

第二步：功能测试

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1][]

mongodb.properties

com.zzg.mongodb.host=127.0.0.1
    com.zzg.mongodb.port=27017
    com.zzg.mongodb.database=admin
    com.zzg.mongodb.username=root
    com.zzg.mongodb.password=123456
    com.zzg.mongodb.socketTimeout=3000
    com.zzg.mongodb.connectTimeout=3000
    com.zzg.mongodb.connectionsPerHost=20

package com.zzg.mongodb.repository;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.mongodb.core.MongoTemplate;
    import org.springframework.stereotype.Repository;
    import com.zzg.entity.Book;
    import com.zzg.mongodb.common.BaseMongoDaoImpl;
    
    @Repository
    public class BookRepository extends BaseMongoDaoImpl<Book>{
    	@Autowired
    	@Override
    	protected void setMongoTemplate(MongoTemplate template) {
    		// TODO Auto-generated method stub
    		this.template = template;
    	}
    }

package com.zzg.controller;
    
    import java.util.List;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.ResponseBody;
    import com.zzg.api.BookService;
    import com.zzg.entity.Book;
    import com.zzg.mongodb.repository.BookRepository;
    
    @Controller
    @RequestMapping("/mongodb")
    public class MongodbControlller {
    	
    	// 引入日志
    	private final static Logger logger = LoggerFactory.getLogger(MongodbControlller.class);
    	
    	@Autowired
    	private BookService service;
    	@Autowired
    	private BookRepository repository;
    
    	
    	@RequestMapping(value = "/inser", method = { RequestMethod.GET })
    	@ResponseBody
    	public void getBooks() {
    		List<Book> list = service.getBooks();
    		if(list != null && list.size() > 0){
    			list.stream().forEach(item ->{
    				repository.save(item);
    				logger.error("mongodb 数据插入成功");
    			});
    		}
    		
    		
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190410084826796.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190410085406787.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70