# Docker 方式
docker run -d --name mongo7 -p 27017:27017 mongo:7.0

# 验证
docker exec -it mongo7 mongosh --eval "db.version()"
# 预期输出：7.0.x

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/myapp   # database = myapp

db.users.insertOne({
  name: "张三",
  email: "zhangsan@example.com",
  age: 28
})

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

@Data
@Document(collection = "users")            // 映射到 users Collection
public class User {

    @Id
    private String id;                      // MongoDB 的 _id 字段

    @Field("name")                          // 显式指定字段名（驼峰转 snake 等场景用）
    private String name;

    private String email;                   // 不写 @Field 则字段名 = 属性名

    private Integer age;

    private List<String> tags;

    private Address address;                // 嵌套文档

    @Field("create_time")
    private LocalDateTime createTime;       // 映射到 create_time 字段
}

@Data
public class Address {                      // 嵌套文档不需要 @Document
    private String city;
    private String street;
}

@Autowired
private MongoTemplate mongoTemplate;

// === 新增 ===
User user = new User();
user.setName("张三");
user.setEmail("zhangsan@example.com");
user.setAge(28);
user.setTags(List.of("Java", "MongoDB"));
user.setAddress(new Address("北京", "中关村大街"));
user.setCreateTime(LocalDateTime.now());

User saved = mongoTemplate.insert(user);
System.out.println(saved.getId());  // ObjectId 的 hex 字符串

// 批量新增
List<User> users = generateUsers(100);
mongoTemplate.insert(users, User.class);    // 一批全写入

// === 查询：按 ID ===
User found = mongoTemplate.findById("507f1f77bcf86cd799439011", User.class);

// === 查询：全部 ===
List<User> all = mongoTemplate.findAll(User.class);

// === 更新 ===
// updateFirst：更新匹配到的第一条
Query query = new Query(Criteria.where("name").is("张三"));
Update update = new Update().set("age", 29).set("email", "newemail@example.com");
mongoTemplate.updateFirst(query, update, User.class);

// updateMulti：更新所有匹配的
mongoTemplate.updateMulti(
    new Query(Criteria.where("age").lt(20)),
    new Update().set("level", "junior"),
    User.class
);

// upsert：有则更新，没有则新增
mongoTemplate.upsert(
    new Query(Criteria.where("email").is("zhangsan@example.com")),
    new Update().set("name", "张三").set("age", 29),
    User.class
);

// === 删除 ===
mongoTemplate.remove(new Query(Criteria.where("age").lt(18)), User.class);

// === findAndModify：原子读-改-写 ===
User updated = mongoTemplate.findAndModify(
    new Query(Criteria.where("name").is("张三")),
    new Update().inc("age", 1),              // age 原子 +1
    User.class
);

// === 精确匹配 ===
Query query = new Query(Criteria.where("name").is("张三"));

// === 比较操作 ===
Query query = new Query(Criteria.where("age").gt(25));            // >
Query query = new Query(Criteria.where("age").gte(25));           // >=
Query query = new Query(Criteria.where("age").lt(30));            // <
Query query = new Query(Criteria.where("age").ne(28));            // !=
Query query = new Query(Criteria.where("age").in(25, 28, 32));   // IN

// === 逻辑组合：AND（链式 .and） ===
Query query = new Query(
    Criteria.where("age").gt(25)
        .and("address.city").is("北京")
);

// === 逻辑组合：OR ===
Query query = new Query(
    new Criteria().orOperator(
        Criteria.where("age").lt(25),
        Criteria.where("tags").is("Java")
    )
);

// === 数组查询 ===
Query query = new Query(Criteria.where("tags").is("Java"));       // 数组包含
Query query = new Query(Criteria.where("tags").all("Java", "MongoDB"));  // 包含所有
Query query = new Query(Criteria.where("tags").size(2));          // 数组长度

// === 元素存在性 ===
Query query = new Query(Criteria.where("age").exists(true));
Query query = new Query(Criteria.where("gender").exists(false));

// === 正则匹配 ===
Query query = new Query(Criteria.where("name").regex("^张"));

// === 嵌套文档字段 ===
Query query = new Query(Criteria.where("address.city").is("北京"));

Query query = new Query(Criteria.where("age").gt(20))
    .with(Sort.by(Sort.Direction.DESC, "age"))  // 按 age 降序
    .skip(0)                                     // 跳过前 N 条
    .limit(10);                                  // 返回 N 条

List<User> users = mongoTemplate.find(query, User.class);

// 配合 Pageable
Pageable pageable = PageRequest.of(0, 10, Sort.by("age").descending());
Query query = new Query(Criteria.where("age").gt(20)).with(pageable);
long total = mongoTemplate.count(query, User.class);   // 总数

Query query = new Query(Criteria.where("age").gt(25));
query.fields()
    .include("name", "email")    // 只返回这些字段
    .exclude("_id");              // 排除 _id

List<User> users = mongoTemplate.find(query, User.class);

@Repository
public interface UserRepository extends MongoRepository<User, String> {

    // === 精确匹配 ===
    List<User> findByName(String name);
    User findByEmail(String email);

    // === 比较 ===
    List<User> findByAgeGreaterThan(int age);           // age > ?
    List<User> findByAgeBetween(int from, int to);      // age between ? and ?

    // === 多条件 ===
    List<User> findByNameAndAge(String name, int age);
    List<User> findByNameOrEmail(String name, String email);

    // === 排序 ===
    List<User> findByAgeGreaterThanOrderByAgeDesc(int age);

    // === 分页 ===
    Page<User> findByAgeGreaterThan(int age, Pageable pageable);

    // === 数组 ===
    List<User> findByTagsIn(List<String> tags);

    // === 存在性 ===
    List<User> findByGenderExists(boolean exists);

    // === regex ===
    List<User> findByNameRegex(String regex);
}

@Repository
public interface UserRepository extends MongoRepository<User, String> {

    // ?0 = 第一个参数，?1 = 第二个参数
    @Query("{ 'age': { $gt: ?0 }, 'address.city': ?1 }")
    List<User> findByAgeAndCity(int age, String city);

    // 只返回部分字段
    @Query(value = "{ 'age': { $gt: ?0 } }",
           fields = "{ 'name': 1, 'email': 1 }")
    List<User> findNamesByAge(int age);
}

import org.springframework.data.mongodb.core.aggregation.*;

// 需求：按城市分组，统计每个城市的用户数、平均年龄
Aggregation agg = Aggregation.newAggregation(
    Aggregation.match(Criteria.where("age").gt(20)),              // $match：过滤
    Aggregation.group("address.city")                              // $group：按城市分组
        .count().as("userCount")                                   //   统计数量
        .avg("age").as("avgAge")                                   //   平均年龄
        .max("age").as("maxAge"),                                  //   最大年龄
    Aggregation.sort(Sort.by(Sort.Direction.DESC, "userCount")),   // $sort：按用户数降序
    Aggregation.limit(5)                                           // $limit：取前 5
);

AggregationResults<CityStat> results = mongoTemplate.aggregate(
    agg, "users", CityStat.class);
List<CityStat> stats = results.getMappedResults();

db.users.aggregate([
  { $match: { age: { $gt: 20 } } },
  { $group: { _id: "$address.city", userCount: { $count: {} }, avgAge: { $avg: "$age" }, maxAge: { $max: "$age" } } },
  { $sort: { userCount: -1 } },
  { $limit: 5 }
])

package com.mall.common.entity;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BaseEntity implements Serializable {
    private Long id;              // 雪花算法主键（不是 ObjectId）
    private Long createUserId;
    private String createUserName;
    private Date createTime;
    private Long updateUserId;
    private String updateUserName;
    private Date updateTime;
    private Integer isDel;        // 软删除标记（0:正常 1:删除）
}

package com.mall.domain.mongo.entity;

@Document(collection = "ProductDetailEntity")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ProductDetailEntity extends BaseEntity {

    @Indexed                             // 按 productId 查询，必须建索引
    private Long productId;

    private String detail;               // 富文本 HTML，几 KB ~ 几十 KB
}

package com.mall.common.util;

public abstract class FillUserUtil {

    private static final Long DEFAULT_USER_ID = 1L;
    private static final String DEFAULT_USER_NAME = "系统管理员";

    /**
     * 填充创建用户信息——从 SecurityContext 拿当前登录用户
     */
    public static void fillCreateUserInfo(BaseEntity baseEntity) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication.getPrincipal() instanceof String) {
            // 未登录用户（如定时任务）→ 使用默认值
            baseEntity.setCreateUserId(DEFAULT_USER_ID);
            baseEntity.setCreateUserName(DEFAULT_USER_NAME);
        } else {
            JwtUserEntity jwtUserEntity = (JwtUserEntity) authentication.getPrincipal();
            baseEntity.setCreateUserId(jwtUserEntity.getId());
            baseEntity.setCreateUserName(jwtUserEntity.getUsername());
        }
        baseEntity.setCreateTime(new Date());
    }

    /**
     * 填充修改用户信息
     */
    public static void fillUpdateUserInfo(BaseEntity baseEntity) {
        JwtUserEntity jwtUserEntity = (JwtUserEntity)
            SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        baseEntity.setUpdateUserId(jwtUserEntity.getId());
        baseEntity.setUpdateUserName(jwtUserEntity.getUsername());
        baseEntity.setUpdateTime(new Date());
    }
}

ProductDetailEntity entity = new ProductDetailEntity();
entity.setProductId(productId);
entity.setDetail(htmlContent);
entity.setId(idGenerateHelper.nextId());          // 雪花算法生成 Long 型 _id
FillUserUtil.fillCreateUserInfo(entity);           // 自动填充创建人 + 创建时间
mongoTemplate.insert(entity, ProductDetailEntity.class);

// ProductCommandService.doGenerate() —— 简化版
transactionTemplate.execute((status -> {
    productHelper.batchInsert(productEntityList);         // ① MySQL：商品基本表
    if (CollectionUtils.isNotEmpty(realAddList)) {
        saveProductDetail(realAddList);                   // ② MongoDB：商品详情
        saveProductAttribute(realAddList);                // ③ MySQL：商品属性
        productPhotoService.savePhoto(realAddList);       // ④ MySQL：商品照片
    }
    return Boolean.TRUE;
}));

private void saveProductDetail(List<ProductEntity> addList) {
    // 只有填了"商品详情"的商品才写 MongoDB（空详情没必要存）
    List<ProductEntity> detailList = addList.stream()
        .filter(x -> StringUtils.hasLength(x.getDetail()))
        .collect(Collectors.toList());
    if (CollectionUtils.isEmpty(detailList)) {
        return;
    }

    List<ProductDetailEntity> addDetailList = detailList.stream().map(x -> {
        ProductDetailEntity entity = new ProductDetailEntity();
        entity.setProductId(x.getId());
        entity.setDetail(x.getDetail());
        entity.setId(idGenerateHelper.nextId());       // 雪花算法手动生成主键
        FillUserUtil.fillCreateUserInfo(entity);        // 自动填充审计字段
        return entity;
    }).collect(Collectors.toList());
    mongoTemplate.insert(addDetailList, ProductDetailEntity.class);
}

// ProductSearchService.fillDetail()
public void fillDetail(ProductEntity productEntity) {
    Query query = new Query(Criteria.where("productId").is(productEntity.getId()));
    List<ProductDetailEntity> entities = mongoTemplate.find(query, ProductDetailEntity.class);
    if (CollectionUtils.isEmpty(entities)) {
        return;  // 不是所有商品都有详情
    }
    productEntity.setDetail(entities.get(0).getDetail());
}

// ProductCommandService.deleteProductDetail()
private void deleteProductDetail(ProductEntity productEntity) {
    ProductDetailQuery query = new ProductDetailQuery();
    query.setProductId(productEntity.getId());
    List<ProductDetailEntity> entities = productDetailMapper.searchByCondition(query);
    if (CollectionUtils.isNotEmpty(entities)) {
        List<Long> idList = entities.stream()
            .map(ProductDetailEntity::getId).collect(Collectors.toList());
        productDetailMapper.deleteByIds(idList, deleteEntity);
        // ⚠️ 只从 MySQL 删了，MongoDB 里的文档还在！
    }
}

@Data
@Document(collection = "dynamic_forms")
public class DynamicForm {
    @Id
    private String id;

    private String formId;        // 表单模板 ID（区分不同客户的表单）
    private Map<String, Object> fields;  // 所有自定义字段都在这
    // {
    //   "姓名": "张三",
    //   "手机号": "13800000000",
    //   "是否过敏": true,
    //   "兴趣爱好": ["篮球", "足球"],
    //   "紧急联系人": { "姓名": "张父", "电话": "13900000000" }
    // }

    @Field("submit_time")
    private LocalDateTime submitTime;
}

@Service
public class DynamicFormService {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 提交表单数据——任何字段都能存，不需要改表结构
     */
    public DynamicForm submit(String formId, Map<String, Object> fields) {
        DynamicForm form = new DynamicForm();
        form.setFormId(formId);
        form.setFields(fields);
        form.setSubmitTime(LocalDateTime.now());
        return mongoTemplate.insert(form);
    }

    /**
     * 跨字段搜索——查找所有表单中"姓名"字段 = 张三的记录
     * 对比 MySQL：需要 JOIN 所有 EAV 表，或者用 JSON_CONTAINS 走全表扫描
     */
    public List<DynamicForm> searchByField(String fieldName, Object value) {
        Query query = new Query(
            Criteria.where("fields." + fieldName).is(value)
        );
        return mongoTemplate.find(query, DynamicForm.class);
    }

    /**
     * 统计某个表单中各选项的频率——如"兴趣爱好"有哪些选项，各选了多少次
     */
    public List<FieldStat> fieldStats(String formId, String fieldName) {
        Aggregation agg = Aggregation.newAggregation(
            Aggregation.match(Criteria.where("formId").is(formId)),
            Aggregation.unwind("fields." + fieldName),    // 拆开数组
            Aggregation.group("fields." + fieldName)
                .count().as("count"),
            Aggregation.sort(Sort.by(Sort.Direction.DESC, "count"))
        );
        return mongoTemplate.aggregate(
            agg, "dynamic_forms", FieldStat.class).getMappedResults();
    }
}