SpringBoot 集成MongoDB
哈哈
阅读：608
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=20package 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.作者投稿可能会经我们编辑修改或补充。
