第七章 Jimmer与外部系统的集成¶

@Test
@DisplayName("Spring Boot自动配置测试")
public void testAutoConfiguration() {
    // 验证JSqlClient已被自动配置并注入
    assertNotNull(sqlClient, "sqlClient未被成功注入");

    // 验证应用上下文
    assertNotNull(applicationContext, "applicationContext未被成功注入");
    assertTrue(applicationContext.containsBean("sqlClient"), "未找到sqlClient Bean");

    // 验证Jimmer相关配置是否被加载
    JSqlClient injectedSqlClient = applicationContext.getBean(JSqlClient.class);
    assertNotNull(injectedSqlClient, "无法从应用上下文获取JSqlClient");
    assertSame(sqlClient, injectedSqlClient, "注入的sqlClient与应用上下文中的实例不一致");
}

@Repository
public interface ProductRepository extends JRepository<Product, String> {

    // 命名方法查询 - 根据名称查找
    List<Product> findByName(String name);

    // 命名方法查询 - 根据名称模糊查询
    List<Product> findByNameContaining(String namePart);

    // 命名方法查询 - 组合条件 
    List<Product> findByActiveAndStockGreaterThan(boolean active, int stockThreshold);

    // 命名方法查询 - 价格范围查询
    List<Product> findByPriceBetween(BigDecimal minPrice, BigDecimal maxPrice);

    // 命名方法查询 - 分页查询
    Page<Product> findByCategoryId(String categoryId, Pageable pageable);

    // 关键字搜索（同一参数用于多个字段）
    List<Product> findByNameContainingOrDescriptionContaining(String keyword, String sameKeyword);

    // 复合条件查询
    List<Product> findByActiveAndPriceGreaterThanAndCategoryId(
        boolean active, BigDecimal minPrice, String categoryId);
}

List<Product> findByActiveAndPriceGreaterThanAndCategoryId(
    boolean active, BigDecimal minPrice, String categoryId);

@Test
@DisplayName("Spring Data基本CRUD测试")
public void testBasicCrud() {
    // 创建测试数据
    String categoryId = createTestCategory();
    String productId = createTestProduct(categoryId);

    try {
        // 测试查询
        Optional<Product> productOpt = productRepository.findById(productId);
        assertTrue(productOpt.isPresent(), "产品应该存在");

        Product product = productOpt.get();
        assertEquals(TEST_PREFIX + "Product", product.name());
        assertEquals(0, new BigDecimal("99.99").compareTo(product.price()));
        assertEquals(categoryId, product.categoryId());

        // 测试更新
        Product updatedProduct = productRepository.save(
            ProductDraft.$.produce(product, draft -> {
                draft.setPrice(new BigDecimal("199.99"));
                draft.setStock(50);
                draft.setModifiedTime(LocalDateTime.now());
            })
        );

        assertEquals(0, new BigDecimal("199.99").compareTo(updatedProduct.price()));
        assertEquals(50, updatedProduct.stock());

        // 测试删除
        productRepository.deleteById(productId);
        assertFalse(productRepository.existsById(productId));

    } finally {
        // 清理测试数据...
    }
}

@Test
@DisplayName("Spring Data分页和排序测试")
public void testPagingAndSorting() {
    // 创建测试数据
    String categoryId = createTestCategory();
    String[] productIds = new String[3];

    try {
        // 创建测试产品
        productIds[0] = createTestProduct(categoryId, "测试A", new BigDecimal("100.00"), 100);
        productIds[1] = createTestProduct(categoryId, "测试B", new BigDecimal("200.00"), 50);
        productIds[2] = createTestProduct(categoryId, "测试C", new BigDecimal("300.00"), 25);

        // 测试分页查询 - 每页2条记录
        Page<Product> productPage = productRepository.findAll(
            PageRequest.of(0, 2)
        );

        // 验证基本分页功能
        assertTrue(productPage.hasContent());

        // 验证排序功能
        Page<Product> priceSortedPage = productRepository.findAll(
            PageRequest.of(0, 10, Sort.by(Sort.Direction.DESC, "price"))
        );

        List<Product> products = priceSortedPage.getContent();
        assertTrue(products.size() >= 2);

        // 价格应该是降序排列
        for (int i = 0; i < products.size() - 1; i++) {
            assertTrue(
                products.get(i).price().compareTo(products.get(i + 1).price()) >= 0,
                "产品应按价格降序排列"
            );
        }

    } finally {
        // 清理测试数据...
    }
}

@Test
@DisplayName("Spring Data命名方法查询测试")
public void testNamedMethodQueries() {
    // 创建测试数据
    String categoryId = createTestCategory();
    String[] productIds = new String[3];

    try {
        // 创建测试产品
        productIds[0] = createTestProduct(categoryId, "测试手表A", new BigDecimal("199.99"), 50, true);
        productIds[1] = createTestProduct(categoryId, "测试手表B", new BigDecimal("299.99"), 30, true);
        productIds[2] = createTestProduct(categoryId, "测试手机C", new BigDecimal("599.99"), 20, false);

        // 测试 findByNameContaining 查询
        List<Product> watchProducts = productRepository.findByNameContaining("手表");
        assertFalse(watchProducts.isEmpty(), "应该找到包含'手表'的产品");

        // 测试 findByActiveAndStockGreaterThan 查询
        List<Product> activeProducts = productRepository.findByActiveAndStockGreaterThan(true, 20);
        assertFalse(activeProducts.isEmpty(), "应该找到活跃且库存>20的产品");

        // 测试 findByPriceBetween 查询
        List<Product> priceRangeProducts = productRepository.findByPriceBetween(
            new BigDecimal("100.00"), new BigDecimal("300.00")
        );
        assertFalse(priceRangeProducts.isEmpty(), "应该找到价格在指定范围内的产品");

    } finally {
        // 清理测试数据...
    }
}

Product updatedProduct = productRepository.save(
    ProductDraft.$.produce(product, draft -> {
        draft.setPrice(new BigDecimal("199.99"));
        draft.setStock(50);
        draft.setModifiedTime(LocalDateTime.now());
    })
);

// 使用Fetcher控制数据图加载
Optional<Product> findById(String id, Fetcher<Product> fetcher);

@Test
@DisplayName("数据图加载测试")
public void testDataGraphLoading() {
    // 创建测试数据
    String categoryId = createTestCategory();
    String productId = createTestProduct(categoryId);

    try {
        // 创建Fetcher，指定要获取的数据图
        ProductFetcher fetcher = ProductFetcher.$.allScalarFields()
            .category(CategoryFetcher.$.allScalarFields());

        // 使用Fetcher查询产品及其关联的类别
        Optional<Product> productOpt = productRepository.findById(productId, fetcher);
        assertTrue(productOpt.isPresent(), "产品应该存在");

        Product product = productOpt.get();
        // 验证产品信息
        assertEquals(TEST_PREFIX + "Product", product.name());

        // 验证关联的类别信息已加载
        Category category = product.category();
        assertNotNull(category, "类别应该被加载");
        assertEquals(TEST_PREFIX + "Category", category.name());
    } finally {
        // 清理测试数据
        if (productRepository.existsById(productId)) {
            productRepository.deleteById(productId);
        }
        sqlClient.getEntities().delete(Category.class, categoryId);
    }
}

// 单个API调用，但Jimmer内部使用批处理
List<Product> products = productRepository.findAllById(Arrays.asList(id1, id2, id3));

@Test
@DisplayName("自动批处理测试")
public void testAutoBatching() {
    // 创建测试数据 - 同一类别下的多个产品
    String categoryId = createTestCategory();
    String productId1 = createTestProduct(categoryId, "批处理测试产品1", new BigDecimal("101.00"), 100);
    String productId2 = createTestProduct(categoryId, "批处理测试产品2", new BigDecimal("102.00"), 200);
    String productId3 = createTestProduct(categoryId, "批处理测试产品3", new BigDecimal("103.00"), 300);

    try {
        // 使用单个API调用批量获取多个产品
        List<Product> products = productRepository.findAllById(Arrays.asList(productId1, productId2, productId3));

        // 验证结果
        assertEquals(3, products.size(), "应该找到3个产品");

        // 验证每个产品的属性
        boolean foundProduct1 = false;
        boolean foundProduct2 = false;
        boolean foundProduct3 = false;

        for (Product product : products) {
            if (product.id().equals(productId1)) {
                assertEquals("批处理测试产品1", product.name());
                assertEquals(0, new BigDecimal("101.00").compareTo(product.price()));
                assertEquals(100, product.stock());
                foundProduct1 = true;
            } else if (product.id().equals(productId2)) {
                assertEquals("批处理测试产品2", product.name());
                assertEquals(0, new BigDecimal("102.00").compareTo(product.price()));
                assertEquals(200, product.stock());
                foundProduct2 = true;
            } else if (product.id().equals(productId3)) {
                assertEquals("批处理测试产品3", product.name());
                assertEquals(0, new BigDecimal("103.00").compareTo(product.price()));
                assertEquals(300, product.stock());
                foundProduct3 = true;
            }
        }

        assertTrue(foundProduct1, "应该找到产品1");
        assertTrue(foundProduct2, "应该找到产品2");
        assertTrue(foundProduct3, "应该找到产品3");

        // 测试批量保存
        List<Product> updatedProducts = products.stream()
            .map(product -> ProductDraft.$.produce(product, draft -> {
                draft.setStock(draft.stock() + 50); // 增加库存
            }))
            .toList();

        // 一次性保存所有修改过的产品
        productRepository.saveAll(updatedProducts);

        // 重新加载产品验证更新
        List<Product> reloadedProducts = productRepository.findAllById(Arrays.asList(productId1, productId2, productId3));
        assertEquals(3, reloadedProducts.size(), "应该重新加载3个产品");

        for (Product product : reloadedProducts) {
            if (product.id().equals(productId1)) {
                assertEquals(150, product.stock(), "产品1的库存应该增加50");
            } else if (product.id().equals(productId2)) {
                assertEquals(250, product.stock(), "产品2的库存应该增加50");
            } else if (product.id().equals(productId3)) {
                assertEquals(350, product.stock(), "产品3的库存应该增加50");
            }
        }

    } finally {
        // 清理测试数据
        productRepository.deleteAllById(Arrays.asList(productId1, productId2, productId3));
        sqlClient.getEntities().delete(Category.class, categoryId);
    }
}

// 基本分页查询
Page<Product> findByCategoryId(String categoryId, Pageable pageable);

// 复合条件 + 分页
Page<Product> findByCategoryIdAndPriceBetweenAndActiveTrue(
    String categoryId, 
    BigDecimal minPrice, 
    BigDecimal maxPrice,
    Pageable pageable
);

@Configuration
public class JimmerSecurityConfig {

    /**
     * 检查当前用户是否为管理员
     */
    public static boolean isAdmin() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        if (authentication == null || !authentication.isAuthenticated()) {
            return false;
        }

        return authentication.getAuthorities().stream()
            .anyMatch(auth -> "ROLE_ADMIN".equals(auth.getAuthority()));
    }

    /**
     * 定义产品激活状态过滤器
     * 非管理员只能看到激活的产品
     */
    @Bean
    public Filter<ExtendedProductProps> activeOnlyFilter() {
        return new Filter<ExtendedProductProps>() {
            @Override
            public void filter(FilterArgs<ExtendedProductProps> args) {
                if (!isAdmin()) {
                    args.where(args.getTable().active().eq(true));
                }
            }
        };
    }
}

@Bean
public Filter<TenantAwareProps> tenantFilter() {
    return new Filter<TenantAwareProps>() {
        @Override
        public void filter(FilterArgs<TenantAwareProps> args) {
            String currentTenantId = getCurrentTenantId();
            if (currentTenantId != null) {
                args.where(args.getTable().tenantId().eq(currentTenantId));
            }
        }
    };

    private String getCurrentTenantId() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth != null && auth.isAuthenticated() && auth.getPrincipal() instanceof UserDetails) {
            return ((TenantAwareUser)auth.getPrincipal()).getTenantId();
        }
        return null;
    }
}

@Test
@DisplayName("测试用户权限控制")
public void testRoleBasedAccess() {
    // 步骤1：以普通用户身份查询产品
    setNormalUserAuthentication();

    ExtendedProductTable table = ExtendedProductTable.$;
    List<ExtendedProduct> productsForUser = sqlClient.createQuery(table)
        .where(table.id().in(Arrays.asList(activeProductId, inactiveProductId)))
        .select(table)
        .execute();

    // 断言：普通用户只能看到激活产品
    assertEquals(1, productsForUser.size(), "普通用户应该只能看到1个激活产品");
    assertEquals(activeProductId, productsForUser.get(0).id(), "普通用户应该能看到激活产品");

    // 步骤2：以管理员身份查询产品
    setAdminAuthentication();

    List<ExtendedProduct> productsForAdmin = sqlClient.createQuery(table)
        .where(table.id().in(Arrays.asList(activeProductId, inactiveProductId)))
        .select(table)
        .execute();

    // 断言：管理员可以看到所有产品
    assertEquals(2, productsForAdmin.size(), "管理员应该能看到所有产品");
    assertTrue(
        productsForAdmin.stream().anyMatch(p -> p.id().equals(activeProductId)) &&
        productsForAdmin.stream().anyMatch(p -> p.id().equals(inactiveProductId)),
        "管理员应该能同时看到激活和非激活产品"
    );
}

private void setNormalUserAuthentication() {
    Authentication auth = new UsernamePasswordAuthenticationToken(
        "user", 
        "password", 
        Collections.singletonList(new SimpleGrantedAuthority("ROLE_USER"))
    );
    SecurityContextHolder.getContext().setAuthentication(auth);
}

private void setAdminAuthentication() {
    Authentication auth = new UsernamePasswordAuthenticationToken(
        "admin", 
        "password", 
        Collections.singletonList(new SimpleGrantedAuthority("ROLE_ADMIN"))
    );
    SecurityContextHolder.getContext().setAuthentication(auth);
}

@Test
@DisplayName("测试字段级别权限控制")
public void testFieldLevelSecurity() {
    // 步骤1：以普通用户身份查询产品详情
    setNormalUserAuthentication();

    ExtendedProduct productForUser = sqlClient.getEntities().findById(ExtendedProduct.class, activeProductId);

    // 断言：普通用户查看时应手动过滤敏感字段
    assertNotNull(productForUser, "普通用户应该能查看产品基本信息");
    assertEquals(new BigDecimal("100.00"), productForUser.price(), "普通用户可以看到销售价格");

    // 如果是普通用户，不应展示成本价格
    if (!isAdmin()) {
        System.out.println("普通用户不应看到成本价格");
    }

    // 步骤2：以管理员身份查询产品详情
    setAdminAuthentication();

    ExtendedProduct productForAdmin = sqlClient.getEntities().findById(ExtendedProduct.class, activeProductId);

    // 断言：管理员可以查看产品，包括成本价格信息
    assertNotNull(productForAdmin, "管理员应该能查看产品所有信息");
    assertEquals(new BigDecimal("100.00"), productForAdmin.price(), "管理员可以看到销售价格");
    assertEquals(new BigDecimal("80.00"), productForAdmin.costPrice(), "管理员可以看到成本价格");
}

@GetMapping("/api/products/{id}")
public ProductVO getProduct(@PathVariable String id) {
    Product product = productRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("Product not found"));

    // 根据当前用户角色选择不同的视图
    if (SecurityUtils.isAdmin()) {
        return ProductVO.fromProductForAdmin(product);
    } else {
        return ProductVO.fromProductForUser(product);
    }
}

package org.ljma.jimmer.samples;

import org.babyfish.jimmer.client.EnableImplicitApi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableImplicitApi  // 自动启用所有REST控制器的API文档
public class JimmerApplication {

    public static void main(String[] args) {
        SpringApplication.run(JimmerApplication.class, args);
    }
}

import org.babyfish.jimmer.client.Api;

@RestController
@RequestMapping("/api/products")
@Api
public class ProductController {
    // ...
}

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductRepository productRepository;

    @GetMapping
    public List<Product> getAllProducts() {
        return productRepository.findAll(ProductFetcher.$.allScalarFields());
    }

    @GetMapping("/{id}")
    public Product getProduct(@PathVariable String id) {
        return productRepository.findById(id, ProductFetcher.$.allScalarFields())
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    // 更多方法...
}

@Controller
public class ProductGraphQLController {

    @Autowired
    private ProductRepository productRepository;

    @Autowired
    private JSqlClient sqlClient;

    /**
     * 查询单个产品
     */
    @QueryMapping
    public Product product(@Argument String id, DataFetchingEnvironment env) {
        // 从GraphQL环境自动创建Fetcher，避免不必要的字段查询
        Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
                Product.class, 
                env
        );

        // 使用动态生成的Fetcher查询数据
        return productRepository.findById(id, fetcher).orElse(null);
    }

    /**
     * 查询产品列表，支持分页
     */
    @QueryMapping
    public List<Product> products(
            @Argument Integer page, 
            @Argument Integer size, 
            DataFetchingEnvironment env
    ) {
        // 从GraphQL环境自动创建Fetcher，避免不必要的字段查询
        Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
                Product.class, 
                env
        );

        // 使用动态生成的Fetcher查询数据
        return productRepository.findAll(
                PageRequest.of(page, size),
                fetcher
        ).getContent();
    }

    /**
     * 搜索产品，支持多条件
     */
    @QueryMapping
    public List<Product> searchProducts(
            @Argument String keyword,
            @Argument String categoryId,
            @Argument BigDecimal minPrice,
            @Argument BigDecimal maxPrice,
            @Argument Boolean active,
            DataFetchingEnvironment env
    ) {
        // 从GraphQL环境自动创建Fetcher
        Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
                Product.class, 
                env
        );

        // 构建动态查询
        return sqlClient.createQuery(ProductTable.class, (q, product) -> {
            // 动态添加查询条件
            List<Predicate> predicates = new ArrayList<>();

            if (keyword != null && !keyword.isEmpty()) {
                predicates.add(
                    Predicate.or(
                        product.name().ilike("%" + keyword + "%"),
                        product.description().ilike("%" + keyword + "%")
                    )
                );
            }

            if (categoryId != null) {
                predicates.add(product.categoryId().eq(categoryId));
            }

            if (minPrice != null) {
                predicates.add(product.price().ge(minPrice));
            }

            if (maxPrice != null) {
                predicates.add(product.price().le(maxPrice));
            }

            if (active != null) {
                predicates.add(product.active().eq(active));
            }

            return q.where(Predicate.and(predicates))
                .select(product.fetch(fetcher));
        })
        .execute();
    }

    /**
     * 根据类别查询产品
     */
    @QueryMapping
    public List<Product> productsByCategory(
            @Argument String categoryId,
            DataFetchingEnvironment env
    ) {
        // 从GraphQL环境自动创建Fetcher
        Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
                Product.class, 
                env
        );

        // 使用动态生成的Fetcher查询数据
        return productRepository.findByCategoryId(categoryId, fetcher);
    }
}

ProductFetcher fetcher = ProductFetcher.$
    .id()
    .name()
    .price()
    .category(CategoryFetcher.$
        .id()
        .name()
    )
    .tags(TagFetcher.$
        .id()
        .name()
    );

// GraphQL查询
query {
  products {
    id
    name
    category {
      id
      name
    }
  }
}

// 自动生成的Fetcher
ProductFetcher fetcher = ProductFetcher.$
    .id()
    .name()
    .category(CategoryFetcher.$
        .id()
        .name()
    );

// Jimmer生成的SQL(伪代码)
SELECT 
    p.ID as p_id, 
    p.NAME as p_name,
    c.ID as c_id,
    c.NAME as c_name
FROM t_product p
LEFT JOIN t_category c ON p.category_id = c.id

// 限制关联深度的Fetcher
Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
    Product.class,
    env,
    FetcherOption.builder()
        .maxDepth(3)  // 最多加载3层关联
        .build()
);

// 或使用显式策略
Fetcher<Product> fetcher = DataFetchingEnvironments.createFetcher(
    Product.class,
    env,
    FetcherOptionArgs.of(args -> args
        .ignoreAssociation(ProductProps.REVIEWS) // 忽略评论关联
        .loadAssociation(ProductProps.CATEGORY)  // 强制加载类别
    )
);

@SpringBootTest
@AutoConfigureMockMvc
public class GraphQLIntegrationTest extends AbstractTest {

    private static final String TEST_PREFIX = "test-graphql-";

    @Autowired
    private MockMvc mockMvc;

    private HttpGraphQlTester graphQlTester;

    private String categoryId;
    private String productId;

    @BeforeEach
    public void setup() {
        // 创建GraphQL测试客户端
        WebTestClient webTestClient = MockMvcWebTestClient.bindTo(mockMvc)
                .baseUrl("/graphql")  // 指定GraphQL端点URL
                .build();
        graphQlTester = HttpGraphQlTester.create(webTestClient);

        // 准备测试数据
        categoryId = createTestCategory();
        productId = createTestProduct(categoryId);
    }

    @Test
    @DisplayName("测试根据ID查询产品")
    public void testGetProduct() {
        // 执行GraphQL查询
        String query = """
            query {
              product(id: "%s") {
                id
                name
                price
                active
                category {
                  id
                  name
                }
              }
            }
            """.formatted(productId);

        // 验证结果
        graphQlTester.document(query)
                .execute()
                .path("product").hasValue()
                .path("product.id").hasValue()
                .path("product.name").hasValue()
                .path("product.category.id").hasValue()
                .path("product.category.name").hasValue();
    }

    @Test
    @DisplayName("测试查询产品列表")
    public void testGetProducts() {
        // 执行GraphQL查询
        String query = """
            query {
              products(page: 0, size: 10) {
                id
                name
                price
              }
            }
            """;

        // 验证结果
        graphQlTester.document(query)
                .execute()
                .path("products").entityList(Map.class).hasSizeGreaterThan(0);
    }

    @Test
    @DisplayName("测试搜索产品功能")
    public void testSearchProducts() {
        // 执行GraphQL查询
        String query = """
            query {
              searchProducts(
                keyword: "测试",
                minPrice: 50.0,
                active: true
              ) {
                id
                name
                price
                active
              }
            }
            """;

        // 验证结果
        graphQlTester.document(query)
                .execute()
                .path("searchProducts").entityList(Map.class);
    }

    // 辅助方法：创建测试类别
    private String createTestCategory() {
        String id = TEST_PREFIX + UUID.randomUUID();
        Category category = CategoryDraft.$.produce(draft -> {
            draft.setId(id);
            draft.setName("测试类别");
            draft.setDescription("用于GraphQL测试");
            draft.setCreatedTime(LocalDateTime.now());
        });
        sqlClient.getEntities().save(category);
        return id;
    }

    // 辅助方法：创建测试产品
    private String createTestProduct(String categoryId) {
        String id = TEST_PREFIX + UUID.randomUUID();
        Product product = ProductDraft.$.produce(draft -> {
            draft.setId(id);
            draft.setName("测试产品");
            draft.setPrice(new BigDecimal("99.99"));
            draft.setStock(100);
            draft.setActive(true);
            draft.setDescription("用于GraphQL测试");
            draft.setCategoryId(categoryId);
            draft.setCreatedTime(LocalDateTime.now());
        });
        sqlClient.getEntities().save(product);
        return id;
    }
}