easyfk-db-mongo MongoDB

<dependency>
    <groupId>com.mcst</groupId>
    <artifactId>db-mongo</artifactId>
</dependency>

dependencies {
    implementation 'com.mcst:db-mongo'
}

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/easyfk

spring:
  data:
    mongodb:
      host: localhost
      port: 27017
      database: easyfk
      username: your_username
      password: your_password

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/easyfk?maxPoolSize=50&minPoolSize=10&maxIdleTimeMS=60000

┌────────────────────────────────────────────────┐
│                  Service 层                     │
│          注入 Repository，调用业务方法            │
└──────────────────────┬─────────────────────────┘
                       │
┌──────────────────────▼─────────────────────────┐
│         Repository 层 (BaseMongoRepositoryImpl) │
│     DTO ↔ Entity 自动转换 · 实现 IBaseRepository │
└──────────────────────┬─────────────────────────┘
                       │
┌──────────────────────▼─────────────────────────┐
│           DAO 层 (BaseSpringMongoDAO)           │
│         CRUD 操作 · MongoTemplate 封装          │
└──────────────────────┬─────────────────────────┘
                       │
┌──────────────────────▼─────────────────────────┐
│          Entity 层 (BaseMongoEntity)            │
│       智能 ID · 自动审计 · 序列化支持             │
└────────────────────────────────────────────────┘

@Data
@EqualsAndHashCode(callSuper = true)
@Document(collection = "products")
public class Product extends BaseMongoEntity {

    @Indexed(unique = true)
    private String productCode;

    private String name;
    private String description;
    private BigDecimal price;
    private Integer stock;
    private String category;
    private String status;
}

@Repository
public class ProductDAO extends BaseSpringMongoDAO<Product> {

    // 可在此添加自定义查询方法
}

@Repository
public class ProductRepository
        extends BaseMongoRepositoryImpl<ProductDAO, ProductDTO, Product, String> {

    // 可在此添加自定义业务查询方法
}

SearchCondition condition = SCBuilder.builder()
    .equalsConditions("category", "electronics")
    .likeConditions("name", ".*iPhone.*")
    .rangeConditions(new RangeCondition("price", 500.0, null, RangeConditionType.GreaterThan))
    .descFields("createdAt")
    .pageSearch(new PageSearch(1, 20))
    .build();

@Data
public class ProductDTO implements Serializable {
    private String id;
    private String productCode;
    private String name;
    private String description;
    private BigDecimal price;
    private Integer stock;
    private String category;
    private String status;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

ProductDTO dto = new ProductDTO();
dto.setProductCode("PROD-001");
dto.setName("iPhone 15");
dto.setPrice(new BigDecimal("7999.00"));
dto.setStock(100);

String id = productRepository.insertAndReturnId(dto);

List<ProductDTO> products = new ArrayList<>();
for (int i = 0; i < 5000; i++) {
    ProductDTO dto = new ProductDTO();
    dto.setName("Product " + i);
    dto.setPrice(BigDecimal.valueOf(100 + i));
    products.add(dto);
}
// 自动分批，每批 1000 条
productRepository.insertBatch(products);

SearchCondition condition = SCBuilder.builder()
    .equalsConditions("category", "electronics")
    .equalsConditions("status", "ACTIVE")
    .rangeConditions(new RangeCondition("price", 100.0, 1000.0, RangeConditionType.Between))
    .descFields("createdAt")
    .build();

List<ProductDTO> products = productRepository.queryByCondition(condition);

SearchCondition condition = SCBuilder.builder()
    .equalsConditions("category", "electronics")
    .descFields("createdAt")
    .pageSearch(new PageSearch(1, 20))
    .build();

PageResult<ProductDTO> page = productRepository.queryByPage(condition);
// page.getRows()  — 当前页数据
// page.getTotal() — 总记录数

SearchCondition condition = SCBuilder.builder()
    .likeConditions("name", ".*iPhone.*")
    .build();

List<ProductDTO> products = productRepository.queryByCondition(condition);

// 方式一：Repository 层直接指定
ProductDTO product = productRepository.queryById(id, "name", "price", "stock");

// 方式二：通过 SearchCondition 指定
SearchCondition condition = SCBuilder.builder()
    .equalsConditions("category", "electronics")
    .selectFields("name", "price", "stock")
    .build();
List<ProductDTO> products = productRepository.queryByCondition(condition);

ProductDTO update = new ProductDTO();
update.setId(productId);
update.setPrice(new BigDecimal("6999.00"));
update.setStock(50);

// 仅更新 price 和 stock 字段
productRepository.updateBySelective(update);

// 更新 price 和 stock，同时清空 description 和 remark 字段
productRepository.updateBySelective(update, "description", "remark");

ProductDTO template = new ProductDTO();
template.setStatus("INACTIVE");

SearchCondition condition = SCBuilder.builder()
    .rangeConditions(new RangeCondition("stock", null, 0, RangeConditionType.LessThanOrEqual))
    .build();

productRepository.updateEntityByCondition(template, condition);

ProductDTO dto = new ProductDTO();
dto.setId(existingId);       // 有 ID → 更新
dto.setName("Updated Name");
productRepository.saveOrUpdateBySelective(dto);

ProductDTO newDto = new ProductDTO();  // 无 ID → 插入
newDto.setName("New Product");
productRepository.saveOrUpdateBySelective(newDto);

SearchCondition condition = SCBuilder.builder()
    .equalsConditions("productCode", "PROD-001")
    .build();

// stock 字段原子减 1，返回更新后的实体
Product updated = productDAO.atomicIncrement(condition, "stock", -1);

Product example = new Product();
example.setCategory("electronics");
example.setStatus("ACTIVE");

// 查询所有 category=electronics 且 status=ACTIVE 的记录
List<Product> products = productDAO.findByEntity(example);

// 检查是否存在
boolean exists = productDAO.exists(example);

// 按 ID 删除
productRepository.deleteById(productId);

// 按条件删除
SearchCondition condition = SCBuilder.builder()
    .equalsConditions("status", "DISCONTINUED")
    .build();
productRepository.deleteByCondition(condition);

@Service
public class ProductService {

    @Resource
    private ProductRepository productRepository;

    public BaseResult<?> createProduct(ProductDTO dto) {
        return productRepository.insert(dto);
    }

    public PageResult<ProductDTO> searchProducts(String keyword, String category,
                                                  BigDecimal minPrice, BigDecimal maxPrice,
                                                  int page, int size) {
        SCBuilder builder = SCBuilder.builder();
        if (EmptyUtil.isNotEmpty(keyword)) {
            builder.likeConditions("name", ".*" + keyword + ".*");
        }
        if (EmptyUtil.isNotEmpty(category)) {
            builder.equalsConditions("category", category);
        }
        if (minPrice != null || maxPrice != null) {
            builder.rangeConditions(
                new RangeCondition("price", minPrice, maxPrice, RangeConditionType.Between));
        }
        SearchCondition condition = builder
            .equalsConditions("status", "ACTIVE")
            .descFields("createdAt")
            .pageSearch(new PageSearch(page, size))
            .build();

        return productRepository.queryByPage(condition);
    }
}

com.mcst.easyfk.db.mongo
├── config
│   └── MongoAutoConfig.java              # Spring Boot 自动配置类
├── dao
│   └── BaseSpringMongoDAO.java           # 通用 DAO 基类
├── entities
│   └── BaseMongoEntity.java              # 实体基类（ID 管理 + 审计字段）
├── repository
│   └── BaseMongoRepositoryImpl.java      # 通用 Repository 实现（DTO/Entity 转换）
└── util
    └── MongoConditionBuilder.java        # 查询条件构建器（SearchCondition → Query）