SpringBoot 集成MongoDB解析

哈哈 阅读:252 2021-03-31 20:57:28 评论:0

1、项目结构

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> 
		<!--依赖mongodb --> 
		<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); 
    } 
 
} 

第二步:功能测试

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 数据插入成功"); 
			}); 
		} 
		 
		 
	} 
 
} 

 

声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

发表评论
搜索
排行榜
KIKK导航

KIKK导航

关注我们