springboot 分页mongodb查询（二）

BaseService

public interface BaseService<T> {

    void save(T entity);

    void update(T entity);

    Long countByCondition(T condition);

    List<T> listByCondition(T condition, Integer page, Integer pageSize);

    T getById(String id);

    void delete(String id);

    void deleteInBulk(List<String> idList);
}

public interface IStorageService extends BaseService<Storage> {

    Storage getByName(String name, String id);

    List<Storage> listByAppId(String appId, Integer page, Integer pageSize);

    List<Storage> listAll();
}

@Service
public class StorageServiceImpl implements IStorageService {

    @Autowired
    private StorageDao storageDao;

    /**
     * 
     * 根据条件查询<br/>
     * 
     * @param condition 查询条件
     * @param page 分页-页码
     * @param pageSize 分页-页大小
     * @return
     */
    @Override
    public List<Storage> listByCondition(Storage condition, Integer page, Integer pageSize) {
        return storageDao.listByCondition(condition, page, pageSize);
    }

    /**
     * 
     * 根据主键查询<br/>
     * 
     * @param id
     * @return
     */
    @Override
    public Storage getById(String id) {
        return storageDao.getById(id);
    }

    /**
     * 
     * 根据名称查询，用于新增或更新时判断名称是否重复<br/>
     * 
     * @param name 名称
     * @param id 主键Id，为空时表示新增，不为空时表示更新
     * @return
     */
    @Override
    public Storage getByName(String name, String id) {
        return storageDao.getByName(name, id);
    }

    /**
     * 
     * 查询所有记录<br/>
     * 
     * @return
     */
    @Override
    public List<Storage> listAll() {
        return storageDao.listAll();
    }

    /**
     * 
     * 根据应用Id查询<br/>
     * 
     * @param appId
     * @param page
     * @param pageSize
     * @return
     */
    @Override
    public List<Storage> listByAppId(String appId, Integer page, Integer pageSize) {
        return storageDao.listByAppId(appId, page, pageSize);
    }

    /**
     * 
     * 新增记录<br/>
     * 
     * @param storage
     * @return
     */
    @Override
    public void save(Storage storage) {
        Date now = new Date();
        if (storage.getCreateTime() == null) {
            storage.setCreateTime(now);
        }
        if (storage.getUpdateTime() == null) {
            storage.setUpdateTime(now);
        }
        if(StringUtils.isBlank(storage.getName())) {
            storage.setName(UUID.randomUUID().toString().replaceAll("_", ""));
        }
        storage.setIsDel(false);
        storageDao.save(storage);
    }

    /**
     * 
     * 更新记录<br/>
     * 
     * @param storage
     */
    @Override
    public void update(Storage storage) {
        storageDao.update(storage);
    }

    /**
     * 
     * 删除记录<br/>
     * 
     * @param id
     */
    @Override
    public void delete(String id) {
        storageDao.delete(id);
    }

    /**
     * 
     * 批量删除记录<br/>
     * 
     * @param idList
     */
    @Override
    public void deleteInBulk(List<String> idList) {
        storageDao.deleteInBulk(idList);
    }

    /**
     * 
     * 根据条件统计<br/>
     * 
     * @param condition
     * @return
     */
    @Override
    public Long countByCondition(Storage condition) {
        return storageDao.countByCondition(condition);
    }
}

BaseDao

public interface BaseDao<T> {

    /**
     * 
     * 根据条件查询<br/>
     * 
     * @param condition
     *            查询条件
     * @param page
     *            分页-页码，为null则不分页
     * @param pageSize
     *            分页-页大小，为null则不分页
     * @return
     */
    List<T> listByCondition(T condition, Integer page, Integer pageSize);

    /**
     * 
     * 根据条件查询<br/>
     * 
     * @param query
     * @param page
     * @param pageSize
     * @return
     */
    List<T> listByCondition(Query query, Integer page, Integer pageSize);

    /**
     * 根据主键Id查询<br/>
     * 
     * @param id
     *            主键Id
     * @return
     */
    T getById(String id);

    /**
     * 查询所有记录<br/>
     * 
     * @return
     */
    List<T> listAll();

    /**
     * 
     * 新增记录<br/>
     * 
     * @param entity
     * @return
     */
    void save(T entity);

    /**
     * 
     * 更新记录<br/>
     * 
     * @param entity
     * @return
     */
    void update(T entity);

    /**
     * 
     * 更新记录<br/>
     * 
     * @param query
     * @param update
     */
    void update(Query query, Update update);

    /**
     * 
     * 删除记录<br/>
     * 
     * @param entity
     * @return
     */
    void delete(String id);

    /**
     * 
     * 批量删除记录<br/>
     * 
     * @param idList
     */
    void deleteInBulk(List<String> idList);

    /**
     * 
     * 根据条件统计<br/>
     * 
     * @param condition
     * @return
     */
    Long countByCondition(T condition);

    /**
     * 
     * 根据条件统计<br/>
     * 
     * @param condition
     * @return
     */
    Long countByCondition(Query query);

    /**
     * 模糊查询<br/>
     * 
     * @param value
     * @return
     */
    Pattern createLike(String value);

}

BaseDaoImpl

public class BaseDaoImpl<T> implements BaseDao<T> {

	@Autowired
	private MongoTemplate mongoTemplate;

	@SuppressWarnings("unchecked")
	private Class<T> getEntryClass() {
		return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
	}

	@Override
	public List<T> listByCondition(T condition, Integer page, Integer pageSize) {
		return Collections.emptyList();
	}

	@Override
	public List<T> listByCondition(Query query, Integer page, Integer pageSize) {
		if (page != null && pageSize != null) {
			page = page < 1 ? 1 : page;
			query.skip((page - 1) * pageSize);
			query.limit(pageSize);
		}
		return mongoTemplate.find(query, getEntryClass());
	}

	@Override
	public T getById(String id) {
		Criteria criteria = Criteria.where("id").is(id);
		criteria.and("isDel").is(false);
		Query query = new Query(criteria);
		return mongoTemplate.findOne(query, getEntryClass());
	}

	@Override
	public List<T> listAll() {
		Criteria criteria = Criteria.where("isDel").is(false);
		Query query = new Query(criteria);
		return mongoTemplate.find(query, getEntryClass());
	}

	@Override
	public void save(T entity) {
		mongoTemplate.save(entity);
	}

	@Override
	public void update(T entity) {
	}

	@Override
	public void update(Query query, Update update) {
		mongoTemplate.updateFirst(query, update, getEntryClass());
	}

	@Override
	public void delete(String id) {
		Criteria criteria = Criteria.where("id").is(id);
		Query query = new Query(criteria);
		Update update = new Update();
		update.set("isDel", true);
		mongoTemplate.updateFirst(query, update, getEntryClass());
	}

	@Override
	public void deleteInBulk(List<String> idList) {
		Criteria criteria = Criteria.where("id").in(idList);
		Query query = new Query(criteria);
		Update update = new Update();
		update.set("isDel", true);
		mongoTemplate.updateMulti(query, update, getEntryClass());
	}

	@Override
	public Pattern createLike(String value) {
		// 完全匹配
		// Pattern pattern = Pattern.compile("^王$", Pattern.CASE_INSENSITIVE);
		// 右匹配
		// Pattern pattern = Pattern.compile("^.*王$", Pattern.CASE_INSENSITIVE);
		// 左匹配
		// Pattern pattern = Pattern.compile("^王.*$", Pattern.CASE_INSENSITIVE);
		// 模糊匹配
		// Pattern pattern = Pattern.compile("^.*王.*$",
		// Pattern.CASE_INSENSITIVE);
		return Pattern.compile("^.*" + value + ".*$", Pattern.CASE_INSENSITIVE);
	}

	@Override
	public Long countByCondition(T condition) {
		return null;
	}

	@Override
	public Long countByCondition(Query query) {
		return mongoTemplate.count(query, getEntryClass());
	}

}

public interface StorageDao extends BaseDao<Storage> {

	/**
	 * 
	 * 根据应用Id查询<br/>
	 * 
	 * @param appId
	 *            appId
	 * @return
	 */
	List<Storage> listByAppId(String appId, Integer page, Integer pageSize);

	/**
	 * 
	 * 新增和更新时判断名称是否重复<br/>
	 * 
	 * @param name
	 *            名称
	 * @param id
	 *            主键Id，为空时表示新增，不为空时表示更新
	 * @return
	 */
	Storage getByName(String name, String id);
}

@Component
public class StorageDaoImpl extends BaseDaoImpl<Storage> implements StorageDao {

    @Override
    public List<Storage> listByCondition(Storage condition, Integer page, Integer pageSize) {
        Criteria criteria = Criteria.where("isDel").is(false);
        if (condition != null) {
            if (StringUtils.isNotBlank(condition.getId())) {
                criteria.and("id").is(condition.getId());
            }
            if (StringUtils.isNotBlank(condition.getAppId())) {
                criteria.and("appId").is(condition.getAppId());
            }
        }
        Query query = new Query(criteria);
        query.with(new Sort(Direction.DESC, "createTime"));
        return super.listByCondition(query, page, pageSize);
    }

    @Override
    public void update(Storage storage) {
        Criteria criteria = Criteria.where("id").is(storage.getId());
        Query query = new Query(criteria);
        Update update = new Update();
        update.set("name", storage.getName());
        update.set("appId", storage.getAppId());
        update.set("updateTime", new Date());
        update.set("isDel", storage.getIsDel());
        super.update(query, update);
    }

    @Override
    public List<Storage> listByAppId(String appId, Integer page, Integer pageSize) {
        Criteria criteria = Criteria.where("appId").is(appId);
        Query query = new Query(criteria);
        return super.listByCondition(query, page, pageSize);
    }

    @Override
    public Storage getByName(String name, String id) {
        Criteria criteria = Criteria.where("name").is(name).and("isDel").is(false);
        if (StringUtils.isNotBlank(id)) {
            criteria.and("id").nin(id);
        }
        Query query = new Query(criteria);
        List<Storage> storageList = super.listByCondition(query, 0, 1);
        if (storageList != null && !storageList.isEmpty()) {
            return storageList.get(0);
        }
        return null;
    }

    @Override
    public Long countByCondition(Storage condition) {
        Criteria criteria = Criteria.where("isDel").is(false);
        if (condition != null) {
            if (StringUtils.isNotBlank(condition.getId())) {
                criteria.and("id").is(condition.getId());
            }
            if (StringUtils.isNotBlank(condition.getAppId())) {
                criteria.and("appId").is(condition.getAppId());
            }
        }
        Query query = new Query(criteria);
        return super.countByCondition(query);
    }

}