// 你以為的JPA
public interface UserRepository extends JpaRepository<User, Long> {
    // 自動生成SQL：SELECT * FROM users WHERE name = ?
    List<User> findByName(String name);
}
// 實(shí)際JPA做的事情：
// 1. 解析方法名
// 2. 構(gòu)建查詢
// 3. 處理分頁/排序
// 4. 管理事務(wù)
// 5. 一級緩存
// 6. 懶加載代理
// 7. 臟數(shù)據(jù)檢查
// 8. 自動刷新

// 1. 最基礎(chǔ)的倉庫標(biāo)記接口
public interface Repository<T, ID> {
    // 標(biāo)記接口，沒有方法
}
// 2. CrudRepository - 基礎(chǔ)CRUD操作
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S entity);
    Optional<T> findById(ID id);
    Iterable<T> findAll();
    long count();
    void delete(T entity);
    boolean existsById(ID id);
    // ... 其他方法
}
// 3. PagingAndSortingRepository - 分頁排序
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort sort);
    Page<T> findAll(Pageable pageable);
}
// 4. JpaRepository - JPA特定功能
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID> {
    List<T> findAll();
    List<T> findAll(Sort sort);
    List<T> findAllById(Iterable<ID> ids);
    <S extends T> List<S> saveAll(Iterable<S> entities);
    void flush();
    <S extends T> S saveAndFlush(S entity);
    void deleteInBatch(Iterable<T> entities);
    void deleteAllInBatch();
    // ... 其他JPA特定方法
}

// 查詢查找策略
public interface QueryLookupStrategy {
    // 解析Repository方法
    RepositoryQuery resolveQuery(
        Method method, 
        RepositoryMetadata metadata, 
        ProjectionFactory factory, 
        NamedQueries namedQueries);
}
// 具體實(shí)現(xiàn)：PartTreeJpaQuery
public class PartTreeJpaQuery implements RepositoryQuery {
    private final PartTree tree;
    private final JpaParameters parameters;
    private final EntityManager em;
    public PartTreeJpaQuery(Method method, RepositoryMetadata metadata, 
                           EntityManager em) {
        // 1. 解析方法名
        this.tree = new PartTree(method.getName(), 
            metadata.getDomainType());
        // 2. 解析參數(shù)
        this.parameters = new JpaParameters(method);
        this.em = em;
    }
    protected TypedQuery<?> createQuery(CriteriaQuery<?> query, 
                                       Pageable pageable) {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<?> criteria = createCriteriaQuery(builder);
        // 3. 構(gòu)建查詢條件
        Predicate predicate = tree.toPredicate(
            getRoot(), criteria, builder);
        if (predicate != null) {
            criteria.where(predicate);
        }
        // 4. 應(yīng)用排序
        if (tree.isOrderBy()) {
            criteria.orderBy(toOrders(tree.getSort(), root, builder));
        }
        TypedQuery<?> typedQuery = em.createQuery(criteria);
        // 5. 應(yīng)用分頁
        if (pageable != null) {
            typedQuery.setFirstResult((int) pageable.getOffset());
            typedQuery.setMaxResults(pageable.getPageSize());
        }
        return typedQuery;
    }
}

@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
public class JpaConfig {
    // 配置
}
// 啟用JPA倉庫的注解
@Import(JpaRepositoriesRegistrar.class)
public @interface EnableJpaRepositories {
    String[] basePackages() default {};
}
// 注冊器
class JpaRepositoriesRegistrar extends RepositoryBeanDefinitionRegistrarSupport {
    @Override
    protected void registerBeanDefinitions(...) {
        // 1. 掃描Repository接口
        RepositoryConfigurationSource configurationSource = 
            new RepositoryConfigurationExtensionSupport() {
                // ...
            };
        // 2. 注冊RepositoryFactoryBean
        for (BeanComponentDefinition definition : 
             getRepositoryConfigurations(configurationSource, loader, true)) {
            registry.registerBeanDefinition(definition.getBeanName(), 
                definition.getBeanDefinition());
        }
    }
}
// Repository工廠Bean
public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
    extends RepositoryFactoryBeanSupport<T, S, ID> {
    @Override
    protected RepositoryFactorySupport createRepositoryFactory(
        EntityManager entityManager) {
        return new JpaRepositoryFactory(entityManager);
    }
    // 創(chuàng)建Repository實(shí)例
    @Override
    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        // 創(chuàng)建代理
        this.repository = getRepository();
    }
}

public class JpaRepositoryFactory extends RepositoryFactorySupport {
    @Override
    public <T, ID> JpaRepository<?, ?> getRepository(
        Class<T> domainClass, 
        Object customImplementation) {
        // 1. 獲取Repository元數(shù)據(jù)
        RepositoryMetadata metadata = getRepositoryMetadata(domainClass);
        // 2. 獲取Repository基本信息
        Class<?> repositoryInterface = metadata.getRepositoryInterface();
        Class<?> customImplementationClass = metadata.getCustomImplementationClass();
        // 3. 創(chuàng)建Repository碎片
        SimpleJpaRepository<?, ?> target = 
            getTargetRepository(metadata, entityManager);
        // 4. 創(chuàng)建Query執(zhí)行器
        JpaRepositoryQuery query = createRepositoryQuery(metadata, target);
        // 5. 創(chuàng)建代理
        return createRepositoryProxy(customImplementationClass, target, query);
    }
    protected <T> T createRepositoryProxy(
        Class<?> customImplementationClass,
        Object target,
        RepositoryQuery queryExecutor) {
        // 創(chuàng)建InvocationHandler
        RepositoryInvocationHandler handler = new RepositoryInvocationHandler(
            target, queryExecutor, customImplementationClass);
        // 創(chuàng)建動態(tài)代理
        return (T) Proxy.newProxyInstance(
            getProxyClassLoader(),
            new Class[] { repositoryInterface, Repository.class },
            handler);
    }
}
// InvocationHandler實(shí)現(xiàn)
private static class RepositoryInvocationHandler implements InvocationHandler {
    private final Object target;
    private final RepositoryQuery queryExecutor;
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
        throws Throwable {
        // 1. 如果是Object的方法，直接調(diào)用
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
        }
        // 2. 如果是默認(rèn)方法（Java 8+）
        if (method.isDefault()) {
            return invokeDefaultMethod(proxy, method, args);
        }
        // 3. 檢查是否有自定義實(shí)現(xiàn)
        if (customImplementation != null && 
            method.getDeclaringClass().isInstance(customImplementation)) {
            return method.invoke(customImplementation, args);
        }
        // 4. 執(zhí)行查詢
        return queryExecutor.execute(method, args);
    }
}

public enum QueryLookupStrategy {
    // 1. 使用@Query注解
    @Query("SELECT u FROM User u WHERE u.name = ?1")
    List<User> findByName(String name);
    // 2. 使用命名查詢
    @NamedQuery(name = "User.findByEmail", 
               query = "SELECT u FROM User u WHERE u.email = ?1")
    // 實(shí)體類上的注解
    // 3. 解析方法名
    List<User> findByFirstNameAndLastName(String firstName, String lastName);
    // 4. 自定義實(shí)現(xiàn)
    public interface UserRepositoryCustom {
        List<User> findActiveUsers();
    }
    public class UserRepositoryImpl implements UserRepositoryCustom {
        public List<User> findActiveUsers() {
            // 自定義實(shí)現(xiàn)
        }
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@QueryAnnotation
public @interface Query {
    String value() default "";  // JPQL查詢
    String countQuery() default "";  // 計(jì)數(shù)查詢
    String countProjection() default "";  // 計(jì)數(shù)投影
    boolean nativeQuery() default false;  // 是否原生SQL
    String name() default "";  // 命名查詢
}
// 查詢注解處理器
public class JpaQueryMethod extends RepositoryQuery {
    private final Method method;
    private final JpaQueryAnnotation annotation;
    public JpaQueryMethod(Method method, RepositoryMetadata metadata, 
                         ProjectionFactory factory) {
        this.method = method;
        this.annotation = method.getAnnotation(Query.class);
    }
    protected String getQueryString() {
        if (annotation != null) {
            return annotation.value();  // 獲取注解值
        }
        // 嘗試獲取命名查詢
        String namedQueryName = getNamedQueryName();
        NamedQueries namedQueries = getNamedQueries();
        if (namedQueries.hasQuery(namedQueryName)) {
            return namedQueries.getQuery(namedQueryName);
        }
        return null;
    }
    protected Query createQuery(EntityManager em, Object[] parameters) {
        String queryString = getQueryString();
        if (annotation.nativeQuery()) {
            // 原生SQL查詢
            Query query = em.createNativeQuery(queryString);
            applyQueryHints(query);
            return query;
        } else {
            // JPQL查詢
            TypedQuery<?> query = em.createQuery(queryString, getDomainClass());
            applyQueryHints(query);
            return query;
        }
    }
}

// 實(shí)體定義
@Entity
public class Order {
    @Id
    private Long id;
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)  // 默認(rèn)LAZY
    private List<OrderItem> items;
}
// 問題代碼
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByUserId(Long userId);
}
// 使用
List<Order> orders = orderRepository.findByUserId(1L);
for (Order order : orders) {
    // 這里每個order.items都會觸發(fā)一次查詢！
    List<OrderItem> items = order.getItems();
}

// 方案1：使用JOIN FETCH
@Query("SELECT o FROM Order o JOIN FETCH o.items WHERE o.user.id = :userId")
List<Order> findByUserIdWithItems(@Param("userId") Long userId);
// 方案2：使用@EntityGraph
@EntityGraph(attributePaths = {"items"})
@Query("SELECT o FROM Order o WHERE o.user.id = :userId")
List<Order> findByUserIdWithItems(@Param("userId") Long userId);
// 方案3：使用Projection
public interface OrderSummary {
    Long getId();
    BigDecimal getTotal();
    // 不包含items
}
@Query("SELECT o.id as id, o.total as total FROM Order o WHERE o.user.id = :userId")
List<OrderSummary> findSummariesByUserId(@Param("userId") Long userId);

// 錯誤：先查詢?nèi)吭賰?nèi)存分頁
Pageable pageable = PageRequest.of(0, 10);
List<User> allUsers = userRepository.findAll();  // 查出100萬條
List<User> pageUsers = allUsers.stream()
    .skip(pageable.getOffset())
    .limit(pageable.getPageSize())
    .collect(Collectors.toList());  // 內(nèi)存爆炸！
// 正確：使用Page
Pageable pageable = PageRequest.of(0, 10, Sort.by("id").descending());
Page<User> page = userRepository.findAll(pageable);
// 復(fù)雜查詢分頁
@Query(value = "SELECT u FROM User u WHERE u.age > :age",
       countQuery = "SELECT COUNT(u) FROM User u WHERE u.age > :age")
Page<User> findByAgeGreaterThan(@Param("age") int age, Pageable pageable);

public class SimpleJpaRepository<T, ID> implements JpaRepository<T, ID> {
    @Override
    public Page<T> findAll(Pageable pageable) {
        if (pageable == null) {
            return new PageImpl<>(findAll());
        }
        // 1. 查詢數(shù)據(jù)
        TypedQuery<T> query = getQuery(null, pageable.getSort());
        query.setFirstResult((int) pageable.getOffset());
        query.setMaxResults(pageable.getPageSize());
        List<T> content = query.getResultList();
        // 2. 查詢總數(shù)
        TypedQuery<Long> countQuery = getCountQuery();
        Long total = countQuery.getSingleResult();
        return new PageImpl<>(content, pageable, total);
    }
    protected TypedQuery<Long> getCountQuery() {
        // 構(gòu)建計(jì)數(shù)查詢
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Long> query = builder.createQuery(Long.class);
        Root<T> root = query.from(getDomainClass());
        if (this.queryMethod.hasPredicate()) {
            query.where(this.queryMethod.getPredicate(root, query, builder));
        }
        // 使用COUNT而不是SELECT *
        query.select(builder.count(root));
        return entityManager.createQuery(query);
    }
}

@Repository
@Transactional(readOnly = true)  // 類級別事務(wù)
public interface UserRepository extends JpaRepository<User, Long> {
    // 繼承readOnly = true
    List<User> findByName(String name);
    @Transactional  // 方法級別覆蓋
    <S extends User> S save(S entity);
    @Transactional(readOnly = false)
    @Modifying
    @Query("UPDATE User u SET u.status = :status WHERE u.id = :id")
    int updateStatus(@Param("id") Long id, @Param("status") String status);
}

@Service
public class UserService {
    @Transactional
    public void updateUser(UserDTO dto) {
        // 1. 查詢用戶
        User user = userRepository.findById(dto.getId()).orElseThrow();
        // 2. 更新用戶
        user.setName(dto.getName());
        userRepository.save(user);  // 同一個事務(wù)
        // 3. 記錄日志
        logRepository.save(new Log("用戶更新"));  // 同一個事務(wù)
        // 如果這里拋出異常，所有操作回滾
    }
}

// 1. 事務(wù)要短小
@Transactional(timeout = 5)  // 5秒超時
public void quickOperation() {
    // 快速操作
}
// 2. 只讀事務(wù)優(yōu)化
@Transactional(readOnly = true)
public List<User> getUsers() {
    return userRepository.findAll();  // 只讀，可能有優(yōu)化
}
// 3. 避免事務(wù)中調(diào)用RPC
@Transactional
public void processOrder(Order order) {
    // 數(shù)據(jù)庫操作
    orderRepository.save(order);
    // 不要在事務(wù)中調(diào)用RPC！
    // paymentService.pay(order);  // 錯誤！
    // 應(yīng)該：事務(wù)提交后異步調(diào)用
}
// 正確做法
@Transactional
public void processOrder(Order order) {
    orderRepository.save(order);
    // 事務(wù)提交
}
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleAfterCommit(OrderEvent event) {
    // 事務(wù)提交后執(zhí)行
    paymentService.pay(event.getOrder());
}

// 1. 實(shí)體設(shè)計(jì)
@Entity
@Table(name = "orders", indexes = {
    @Index(name = "idx_user_status", columnList = "userId,status"),
    @Index(name = "idx_create_time", columnList = "createTime")
})
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long userId;
    private BigDecimal amount;
    private String status;
    @CreationTimestamp
    private LocalDateTime createTime;
    @UpdateTimestamp
    private LocalDateTime updateTime;
    // 使用延遲加載
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY, 
               cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
}
// 2. Repository設(shè)計(jì)
@Repository
public interface OrderRepository extends JpaRepository<Order, Long>,
                                        JpaSpecificationExecutor<Order> {
    // 簡單查詢：方法名派生
    List<Order> findByUserIdAndStatus(Long userId, String status);
    // 分頁查詢
    Page<Order> findByUserId(Long userId, Pageable pageable);
    // 復(fù)雜查詢：@Query
    @Query("SELECT o FROM Order o " +
           "JOIN FETCH o.items " +
           "WHERE o.userId = :userId AND o.createTime BETWEEN :start AND :end")
    List<Order> findUserOrdersWithItems(
        @Param("userId") Long userId,
        @Param("start") LocalDateTime start,
        @Param("end") LocalDateTime end);
    // 統(tǒng)計(jì)查詢
    @Query("SELECT new com.example.dto.OrderStatsDTO(" +
           "COUNT(o), SUM(o.amount), AVG(o.amount)) " +
           "FROM Order o WHERE o.userId = :userId")
    OrderStatsDTO getUserOrderStats(@Param("userId") Long userId);
    // 原生SQL查詢
    @Query(value = "SELECT DATE(create_time) as date, COUNT(*) as count " +
                   "FROM orders WHERE create_time >= :start " +
                   "GROUP BY DATE(create_time) " +
                   "ORDER BY date DESC",
           nativeQuery = true)
    List<Object[]> getDailyOrderCount(@Param("start") LocalDateTime start);
}
// 3. Specification動態(tài)查詢
public class OrderSpecifications {
    public static Specification<Order> hasStatus(String status) {
        return (root, query, cb) -> 
            status == null ? null : cb.equal(root.get("status"), status);
    }
    public static Specification<Order> amountBetween(BigDecimal min, BigDecimal max) {
        return (root, query, cb) -> {
            if (min == null && max == null) return null;
            if (min == null) return cb.lessThanOrEqualTo(root.get("amount"), max);
            if (max == null) return cb.greaterThanOrEqualTo(root.get("amount"), min);
            return cb.between(root.get("amount"), min, max);
        };
    }
    public static Specification<Order> createdAfter(LocalDateTime date) {
        return (root, query, cb) -> 
            date == null ? null : cb.greaterThanOrEqualTo(root.get("createTime"), date);
    }
}
// 4. 使用示例
@Service
@Transactional(readOnly = true)
public class OrderQueryService {
    public Page<Order> searchOrders(OrderSearchCriteria criteria, Pageable pageable) {
        Specification<Order> spec = Specification
            .where(OrderSpecifications.hasStatus(criteria.getStatus()))
            .and(OrderSpecifications.amountBetween(
                criteria.getMinAmount(), criteria.getMaxAmount()))
            .and(OrderSpecifications.createdAfter(criteria.getStartDate()));
        return orderRepository.findAll(spec, pageable);
    }
}

// 問題：在事務(wù)外訪問懶加載屬性
@Service
public class OrderService {
    @Transactional
    public Order getOrder(Long id) {
        return orderRepository.findById(id).orElse(null);
    }
}
// 調(diào)用
Order order = orderService.getOrder(1L);
// 事務(wù)已關(guān)閉！
List<OrderItem> items = order.getItems();  // LazyInitializationException
// 解決方案1：使用JOIN FETCH
@Query("SELECT o FROM Order o JOIN FETCH o.items WHERE o.id = :id")
Optional<Order> findByIdWithItems(@Param("id") Long id);
// 解決方案2：使用@Transactional
@Transactional(readOnly = true)
public Order getOrderWithItems(Long id) {
    Order order = orderRepository.findById(id).orElse(null);
    if (order != null) {
        order.getItems().size();  // 在事務(wù)內(nèi)觸發(fā)加載
    }
    return order;
}
// 解決方案3：使用DTO/Projection
public interface OrderDTO {
    Long getId();
    String getOrderNo();
    // 不包含items
}

// 錯誤：循環(huán)插入
@Transactional
public void createUsers(List<User> users) {
    for (User user : users) {
        userRepository.save(user);  // 每次save都flush
    }
}
// 正確：批量插入
@Transactional
public void createUsers(List<User> users) {
    for (int i = 0; i < users.size(); i++) {
        userRepository.save(users.get(i));
        // 每50條flush一次
        if (i % 50 == 0 && i > 0) {
            entityManager.flush();
            entityManager.clear();  // 清理一級緩存
        }
    }
}
// 最佳：使用saveAll
@Transactional
public void createUsers(List<User> users) {
    userRepository.saveAll(users);
}
// 使用原生SQL批量插入
@Modifying
@Query(value = "INSERT INTO users (name, email) VALUES (:names, :emails)", 
       nativeQuery = true)
void batchInsert(@Param("names") List<String> names, 
                 @Param("emails") List<String> emails);

// 使用@Version樂觀鎖
@Entity
public class Product {
    @Id
    private Long id;
    private String name;
    private Integer stock;
    @Version
    private Integer version;  // 版本號
    public void reduceStock(int quantity) {
        if (this.stock < quantity) {
            throw new InsufficientStockException();
        }
        this.stock -= quantity;
    }
}
// 使用悲觀鎖
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdForUpdate(@Param("id") Long id);
}
// 使用場景
@Service
public class OrderService {
    @Transactional
    public void placeOrder(Long productId, int quantity) {
        // 悲觀鎖
        Product product = productRepository.findByIdForUpdate(productId)
            .orElseThrow(() -> new ProductNotFoundException());
        product.reduceStock(quantity);
        productRepository.save(product);
        // 如果發(fā)生并發(fā)修改，會拋ObjectOptimisticLockingFailureException
    }
}

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        generate_statistics: true
        session.events.log.LOG_QUERIES_SLOWER_THAN_MS: 1000
    show-sql: true
    open-in-view: false  # 重要！防止懶加載異常
# 日志配置
logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
    org.springframework.orm.jpa: DEBUG

@Component
public class JpaPerformanceMonitor {
    @PersistenceUnit
    private EntityManagerFactory emf;
    @Scheduled(fixedDelay = 60000)
    public void monitorPerformance() {
        Statistics stats = emf.unwrap(SessionFactory.class)
            .getStatistics();
        Map<String, Object> metrics = new HashMap<>();
        metrics.put("queryExecutionCount", stats.getQueryExecutionCount());
        metrics.put("queryExecutionMaxTime", stats.getQueryExecutionMaxTime());
        metrics.put("queryCacheHitCount", stats.getQueryCacheHitCount());
        metrics.put("queryCacheMissCount", stats.getQueryCacheMissCount());
        metrics.put("secondLevelCacheHitCount", stats.getSecondLevelCacheHitCount());
        metrics.put("secondLevelCacheMissCount", stats.getSecondLevelCacheMissCount());
        // 發(fā)送到監(jiān)控系統(tǒng)
        sendToMonitoringSystem(metrics);
        // 慢查詢告警
        if (stats.getQueryExecutionMaxTime() > 1000) {
            log.warn("發(fā)現(xiàn)慢查詢，最大執(zhí)行時間: {}ms", 
                stats.getQueryExecutionMaxTime());
        }
    }
}

# application-prod.yml
spring:
  jpa:
    open-in-view: false
    show-sql: false
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        jdbc.batch_size: 50
        order_inserts: true
        order_updates: true
        generate_statistics: true
        cache.use_second_level_cache: true
        cache.use_query_cache: true
        cache.region.factory_class: org.hibernate.cache.jcache.JCacheRegionFactory
        javax.cache.provider: org.ehcache.jsr107.EhcacheCachingProvider
    hibernate:
      ddl-auto: validate
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-test-query: SELECT 1