SpringBoot整合mongoDB

1 搭建mongoDB

自行搜索安装。

2 整合

2.1 创建SpringBoot项目

直接通过idea创建一个springboot项目：mongodb-demo，导入MongoDB的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

我这里用的springboot的版本是 2.1.9.RELEASE

2.2 MongoDB的连接

在application.yml假如mongoDB的配置

server:
  port: 9999
spring:
  data:
    mongodb:
      uri: mongodb://172.23.109.238:40001
      database: user

2.3 创建实体类

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

@Data
@Document("user")
public class User {

    @Id
    private String id;
    private String userName;
    private Integer sex;
    private Integer age;
}

2.4 创建Repository

创建一个UserRepository接口，继承MongoRepository<User,String>，其中泛型User为实体类，String为字段id的类型。

import com.cloud.mongodb.demo.entity.User;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User,String> {

}

2.5 创建Controller

创建一个UserController，注入UserRepository.添加测试方法。

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @PostMapping("/save")
    public void save(@RequestBody  User user) {
        userRepository.save(user);
    }

    @GetMapping("/list")
    public List<User> list() {
        return userRepository.findAll();
    }
}

2.6 启动项目，进行调试

请求保存接口 http://localhost:9999/user/save

{
    "userName":"小明",
    "age":18,
    "sex":1
}

请求list接口，查看是否保存成功,http://localhost:9999/user/list

1586749040747.png

可以看到基本操作已经完成。

3 MongoDB事务

MongoDB在4.0之前只支持单文档事务，想要使用(Multi-Document Transaction)多文档事务，需要升级到4.0。
MongoDB的StandAlone模式不支持事务，只有ReplicaSet(复制集)才支持事务
MongoDB使用事务之后，数据库和集合必须提前创建。

3.1 配置MongoDB复制集

可以参考这个文档来配置。

https://docs.mongodb.com/manual/tutorial/deploy-replica-set-with-keyfile-access-control/

具体操作后面有空再补充。

3.2 配置springboot开启事务。

这里我重新创建一个SpringBoot工程：mongodb-plus，将一些公用的配置放到一起。

3.2.1 创建一个自动配置类

/**
 * 自动配置
 */
@Configuration
public class MongoAutoConfigure {
    @Bean
    MongoTransactionManager transactionManager(MongoDbFactory factory){
        return new MongoTransactionManager(factory);
    }
}

3.2.2 添加配置文件

在resources文件夹下增加一个spring.factories，添加自动配置类

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.cloud.mongodb.plus.configure.MongoAutoConfigure

3.2.3 引用mongodb-plus

可以通过maven将mongodb-plus打成jar包，或者将mongodb-plus导入到mongodb-demo中，然后mongodb-demo工程pom.xml引入mongo-plus包。

<dependency>
    <groupId>com.cloud.mongodb</groupId>
    <artifactId>mongodb-plus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

3.2.4 添加service层

添加userService,并在save方法添加事务。

public interface IUserService {

    void save(User user);

    List<User> list();
}

@Service
public class UserServiceImpl implements IUserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save(User user) {
        userRepository.save(user);
    }

    @Override
    public List<User> list() {
        return userRepository.findAll();
    }

}

3.2.5 改造UserController

去掉UserRepository注入，改为UserService.

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private IUserService userService;

    @PostMapping("/save")
    public void save(@RequestBody  User user) {
        userService.save(user);
    }

    @GetMapping("/list")
    public List<User> list() {
        return userService.list();
    }
}

3.2.6 测试

重启工程，按照上面的《2 创建SpringBoot》自行测试..

测试完可以发现save方法可以正常保存。

3.2.7 制造一个异常

添加一个算术异常，测试保存功能是否可以正常调用。

@Override
@Transactional(rollbackFor = Exception.class)
public void save(User user) {
    userRepository.save(user);
    int i = 1/0;
}

重启demo工程，调用保存方法，事务是否会回滚。

{
    "userName":"小明3",
    "age":18,
    "sex":1
}

可以看到，控制台报了异常，同时，mongoDB没有保存上述数据，事务开启成功。

1586760109815.png

4 抽取公用方法

常见保存，删掉，根据id获取对象数据等方法，可以抽取成一个公用的代码，不用重复造轮子。

4.1 改造mongodb-plus工程

4.1.1 创建BaseEntity

在mongodb-plus工程中，创建entity的基类，主要是扩展用，这里暂时只对分页属性扩展。

@Data
public class PageVo {
    @Transient
    private transient Integer page = 1;
    @Transient
    private transient Integer pageSize = 10;
}

public abstract class BaseEntity<T, ID extends Serializable> extends PageVo {
}

4.1.2 创建BaseService

在mongodb-plus工程中，创建baseService.

public interface IBaseService<T extends BaseEntity,ID extends Serializable> {
     void save(T t);
     T selectById(ID id);
     void deleteById(ID id);
}

public class BaseServiceImpl<T extends BaseEntity, ID extends Serializable> implements IBaseService<T, ID> {

    @Autowired
    protected MongoRepository<T, ID> baseRepository;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save(T t) {
        ID id = FieldCacheUtil.getId(t);
        if (id == null) {
            baseRepository.save(t);
        } else {
            T dbObj = this.selectById(id);
            CopyOptions copyOptions = CopyOptions.create().ignoreNullValue();
            BeanUtil.copyProperties(t,dbObj,copyOptions);
            baseRepository.save(dbObj);
        }
    }
    
    @Override
    public T selectById(ID id) {
        Optional<T> dbObj = baseRepository.findById(id);
        return dbObj.orElse(null);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteById(ID id) {
        baseRepository.deleteById(id);
    }
}

4.2 改造 mongodb-demo工程

4.2.1 实体类

继承BaseEntity

@EqualsAndHashCode(callSuper = true)
@Data
@Document("user")
public class User extends BaseEntity<User,String> {

    @Id
    private String id;
    private String userName;
    private Integer sex;
    private Integer age;
}

4.2.2 业务层

删除baseService已有的方法，当然这里的list也可以抽取到BaseService中。

public interface IUserService extends IBaseService<User,String> {
    List<User> list();
}

@Service
public class UserServiceImpl extends BaseServiceImpl<User,String> implements IUserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public List<User> list() {
        return userRepository.findAll();
    }

}

4.2.3 启动是否报错，并测试.

{
    "userName":"小明4",
    "age":18,
    "sex":1
}

可以看到mongoDB中，保存成功。

1586761623312.png

4.2.4 注意

FieldCacheUtil通过反射获取id值。

public class FieldCacheUtil {
    public static final Map<Class<?>, Field> idFieldMap = new ConcurrentHashMap<>();

    public FieldCacheUtil() {
    }

    @SneakyThrows
    public static <T,ID> ID getId(T t) {
        Class cla = t.getClass();
        try {
            Field primaryKeyField = getPrimaryKeyField(cla);
            return (ID) primaryKeyField.get(t);
        } catch (IllegalAccessException var3) {
            throw new Exception("获取id失败");
        }
    }

    @SneakyThrows
    public static Field getPrimaryKeyField(Class<?> tc) {
        Field idField = idFieldMap.getOrDefault(tc, null);
        if (Objects.nonNull(idField)) {
            return idField;
        } else {
            Field[] allFields = tc.getDeclaredFields();
            Field[] var3 = allFields;
            int var4 = allFields.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Field field = var3[var5];
                Id tableId = field.getDeclaredAnnotation(Id.class);
                if (Objects.nonNull(tableId)) {
                    field.setAccessible(true);
                    idFieldMap.putIfAbsent(tc, field);
                    return field;
                }
            }

            throw new Exception("当前实体没有主键");
        }
    }

}

5 扩展公用Repository接口

上文只是针对service进行公用方法抽取，有时候需要对Repository进行自定义操作，而这些操作基本也是公用方法，所以需要对Repository进行扩展。

5.1 修改mongodb-plus工程

5.1.1 创建公用的Repository

在dao层中添加BaseRepository，该接口为自定义Repository，需要添加@NoRepositoryBean注解来说明此接口不是一个声明的Repository，否则Spring默认当做普通的Repository来处理

@NoRepositoryBean
public interface BaseRepository<T extends BaseEntity, ID extends Serializable> extends MongoRepository<T, ID>,BaseRepositoryEnhance<T, ID>  {

}

添加一个扩展的接口BaseRepositoryEnhance，所有的扩展方法定义都在此接口上(可以合并到BaseRepository中)

public interface BaseRepositoryEnhance <T extends BaseEntity, ID extends Serializable> {

    /**
     * 分页获取
     * @param t
     * @return
     */
    List<T> findPage(T t);

    /**
     * 获取当前泛型的实体信息
     * @return
     */
    MongoEntityInformation<T, ID> getCurEntityInformation();
}

添加一个实现类，主要实现我们自定义的方法。

public class BaseRepositoryImpl<T extends BaseEntity, ID extends Serializable> extends SimpleMongoRepository<T,ID> implements BaseRepository<T, ID> {

    private MongoOperations mongoOperations;
    private  MongoEntityInformation<T, ID> entityInformation;

    public BaseRepositoryImpl(MongoEntityInformation<T, ID> metadata, MongoOperations mongoOperations) {
        super(metadata, mongoOperations);
        this.mongoOperations = mongoOperations;
        entityInformation = metadata;
    }


    @Override
    public List<T> findPage(T t) {

        Query query = new Query();
        // 查询pagge
        // 从那条记录开始
        query.skip((t.getPage() - 1) * t.getPage());
        // 取多少条记录
        query.limit(t.getPageSize());
        List<T> ts = mongoOperations.find(query, entityInformation.getJavaType(), entityInformation.getCollectionName());
        return ts;
    }

    @Override
    public MongoEntityInformation<T, ID> getCurEntityInformation() {
        return entityInformation;
    }
}

5.1.2 配置自定义的MongoRepositoryFactoryBean

创建CustomMongoRepositoryFactoryBean，主要是实现加载自定义工厂bean

public class CustomMongoRepositoryFactoryBean <T extends Repository<S, ID>, S, ID extends Serializable> extends MongoRepositoryFactoryBean<T,S,ID> {


    /**
     * 默认构造方法
     * @param repositoryInterface
     */
    public CustomMongoRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
        super(repositoryInterface);
    }

    /**
     * 设置为自定义工厂
     * @param operations
     * @return
     */
    @Override
    protected RepositoryFactorySupport getFactoryInstance(MongoOperations operations) {
        return new CustomMongoRepositoryFactory(operations);
    }

    /**
     * 自定义工厂类
     */
    public class CustomMongoRepositoryFactory extends MongoRepositoryFactory {


        private final MongoOperations operations;

        /**
         * 默认的构造方法
         * @param mongoOperations
         */
        public CustomMongoRepositoryFactory(MongoOperations mongoOperations) {
            super(mongoOperations);
            operations = mongoOperations;
        }


        /**
         * Create a repository instance as backing for the query proxy
         * @param information
         * @return
         */
        @Override
        protected Object getTargetRepository(RepositoryInformation information) {
            //如果为自定义的类型，返回BaseRepositoryImpl
            if(isBaseRepository(information.getRepositoryInterface())) {
                MongoEntityInformation<?, Object> entityInformation = getEntityInformation(information.getDomainType());
                return getTargetRepositoryViaReflection(BaseRepositoryImpl.class,entityInformation, operations);
            }
            return super.getTargetRepository(information);
        }

        /**
         * Returns the base class backing the actual repository instance
         * @param metadata
         * @return
         */
        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            //如果为自定义的类型，返回BaseRepositoryImpl
            if(isBaseRepository(metadata.getRepositoryInterface())) {
                return BaseRepositoryImpl.class;
            }
            return super.getRepositoryBaseClass(metadata);
        }

        /**
         * 判断Repository的接口是否为BaseRepository
         * @param repositoryInterface
         * @return
         */
        private boolean isBaseRepository(Class<?> repositoryInterface) {
            return ClassUtils.isAssignable(BaseRepository.class, repositoryInterface);
        }
    }
}

同时需要在MongoAutoConfigure添加指定的FactoryBean。

/**
 * 自动配置
 */
@Configuration
@EnableMongoRepositories(basePackages = {"com.cloud"},repositoryFactoryBeanClass = CustomMongoRepositoryFactoryBean.class)
public class MongoAutoConfigure {
    @Bean
    MongoTransactionManager transactionManager(MongoDbFactory factory){
        return new MongoTransactionManager(factory);
    }
}

5.1.3 修改BaseService注入类

1.前面我们注入的是MongoRepository类型，现在需要改为自定义的类型BaseRepository；

2.不再需要FieldCacheUtil获取id了，baseRepository.getCurEntityInformation()即可获取id。

public class BaseServiceImpl<T extends BaseEntity, ID extends Serializable> implements IBaseService<T, ID> {

    @Autowired
    protected BaseRepository<T, ID> baseRepository;
    
    public void save(T t) {
        ID id = baseRepository.getCurEntityInformation().getId(t);
        if (id == null) {
            baseRepository.save(t);
        } else {
            T dbObj = this.selectById(id);
            CopyOptions copyOptions = CopyOptions.create().ignoreNullValue();
            BeanUtil.copyProperties(t,dbObj,copyOptions);
            baseRepository.save(dbObj);
        }
    }
    
    @Override
    public T selectById(ID id) {
        Optional<T> dbObj = baseRepository.findById(id);
        return dbObj.orElse(null);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteById(ID id) {
        baseRepository.deleteById(id);
    }
}

5.1.4 打包

5.2 修改mongodb-demo工程

5.2.1 修改UserRepository

前面我们继承的是MongoRepository类型，现在需要改为自定义的类型BaseRepository

public interface UserRepository extends BaseRepository<User,String> {
}

5.2.2 修改UserService

添加一个page方法

public interface IUserService extends IBaseService<User,String> {

    List<User> list();

    List<User> page(User user);
}

@Service
public class UserServiceImpl extends BaseServiceImpl<User,String> implements IUserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public List<User> list() {
        return userRepository.findAll();
    }

    @Override
    public List<User> page(User user) {
        return userRepository.findPage(user);
    }
}

5.2.3 修改UserController

添加page方法

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private IUserService userService;

    @PostMapping("/save")
    public void save(@RequestBody  User user) {
        userService.save(user);
    }

    @GetMapping("/list")
    public List<User> list() {
        return userService.list();
    }

    @PostMapping("/page")
    public List<User> page(@RequestBody User user) {
        return userService.page(user);
    }
}

5.2.4 测试

访问 POST http://localhost:9999/user/page

{
    "pageSize":2,
    "page":1
}

1586766653846.png

可以看到成功访问。

6.扩展特定Repository接口

上面已经对公用的Repository做了扩展，但有时候需要对特定的Repository进行扩展，这里以UserRepository为例。

6.1 创建UserRepositoryEnhance接口

UserRepositoryEnhance为中间接口，所有扩展方法都写在这里。

public interface UserRepositoryEnhance {
    /**
     * 根据性别类型获取列表
     * @param sexType
     * @return
     */
    List<User> findListBySexType(String sexType);
}

6.2 修改 UserRepository

继承UserRepositoryEnhance。

public interface UserRepository extends BaseRepository<User,String>,UserRepositoryEnhance{

}

6.3 创建UserRepositoryImpl

实现UserRepositoryEnhance

public class UserRepositoryImpl implements UserRepositoryEnhance {

    @Autowired
    private MongoOperations mongoOperations;
    @Override
    public List<User> findListBySexType(String sexType) {
        Integer sex = "M".equals(sexType) ? 1 : 2;
        Criteria where = Criteria.where("sex").is(sex);
        Query query = Query.query(where);
        return mongoOperations.find(query, User.class);
    }
}

6.4 修改UserService

增加findListBySexType方法

public interface IUserService extends IBaseService<User,String> {

    List<User> list();

    List<User> page(User user);

    List<User> findListBySexType(String sexType);
}

@Service
public class UserServiceImpl extends BaseServiceImpl<User,String> implements IUserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public List<User> list() {
        return userRepository.findAll();
    }

    @Override
    public List<User> page(User user) {
        return userRepository.findPage(user);
    }

    @Override
    public List<User> findListBySexType(String sexType) {
        return userRepository.findListBySexType(sexType);
    }
}

6.5 修改UserController