05. ORM 框架：JPA/Hibernate 与 MyBatis

// 瞬时态 (Transient) — 未与 Session 关联
Book book = new Book("Java", 100);

// 持久态 (Persistent) — Session 管理
session.persist(book);        // 变为持久态，插入数据库
book.setPrice(200);           // 脏检查 → 自动 UPDATE

// 游离态 (Detached) — 曾持久化但 Session 关闭
session.detach(book);         // / session.close()
book.setPrice(300);           // 无自动操作

// 删除态 (Removed)
session.remove(book);         // 标记删除，flush 时 DELETE

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

Book book = session.find(Book.class, 1L);  // 加载到持久化上下文
book.setPrice(book.getPrice() * 1.1);       // 修改

// tx.commit() 时自动执行：
// 1. flush — 脏检查发现 priceChanged → 生成 UPDATE SQL
// 2. commit — 提交事务
// 无需手动 save()

session.setHibernateFlushMode(FlushMode.MANUAL);

@Entity
public class Author {
    @OneToMany(mappedBy = "author", 
               cascade = CascadeType.ALL,      // 级联操作
               fetch = FetchType.LAZY,         // 默认延迟加载
               orphanRemoval = true)           // 孤儿删除
    private List<Book> books = new ArrayList<>();
}

// N+1 触发场景
List<Author> authors = em.createQuery("FROM Author", Author.class).getResultList();
for (Author a : authors) {
    a.getBooks().size();  // 每条触发 SELECT books WHERE author_id=?
}

// 方案 1：JOIN FETCH
FROM Author a JOIN FETCH a.books  // 单条 JOIN SQL

// 方案 2：@BatchSize
@BatchSize(size = 50)  // 每 50 个 Author 批量加载 Books，变 N/50+1 条

// 方案 3：Entity Graph
EntityGraph<Author> graph = em.createEntityGraph(Author.class);
graph.addSubgraph("books");
Map<String, Object> hints = Map.of("javax.persistence.fetchgraph", graph);
Author a = em.find(Author.class, 1L, hints);

// 方案 4：二级缓存 + @Cache
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "books")

<!-- ehcache.xml -->
<cache alias="org.example.Book">
    <expiry>
        <ttl unit="minutes">10</ttl>
    </expiry>
    <heap unit="entries">1000</heap>
</cache>

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Book { }

public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    @Results({
        @Result(property = "createTime", column = "create_time"),
        @Result(property = "role", column = "role_id", 
                one = @One(select = "com.example.RoleMapper.selectById"))
    })
    User findById(Long id);
    
    @SelectProvider(type = UserSqlProvider.class, method = "findByCondition")
    List<User> findByCondition(UserQuery query);
}

<select id="findByCondition" resultType="User">
    SELECT * FROM users
    <where>
        <if test="name != null">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="status != null">
            AND status = #{status}
        </if>
        <choose>
            <when test="sortField != null">
                ORDER BY ${sortField} ${sortOrder}
            </when>
            <otherwise>
                ORDER BY id DESC
            </otherwise>
        </choose>
    </where>
</select>

<resultMap id="orderResultMap" type="Order">
    <id property="id" column="order_id"/>
    <result property="amount" column="amount"/>
    <!-- 一对一 -->
    <association property="user" javaType="User">
        <id property="id" column="user_id"/>
        <result property="name" column="user_name"/>
    </association>
    <!-- 一对多 -->
    <collection property="items" ofType="OrderItem">
        <id property="id" column="item_id"/>
        <result property="productName" column="product_name"/>
    </collection>
</resultMap>

<insert id="batchInsert">
    INSERT INTO users (name, email) VALUES
    <foreach collection="list" item="user" separator=",">
        (#{user.name}, #{user.email})
    </foreach>
</insert>

SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);
try {
    UserMapper mapper = session.getMapper(UserMapper.class);
    for (User user : users) {
        mapper.insert(user);  // 缓存 SQL，满 batch 才发送
    }
    session.commit();
} finally {
    session.close();
}

jdbc.url=jdbc:mysql://localhost/db?rewriteBatchedStatements=true
# 将多条语句合并为 multi-value 插入，提升 3-5 倍性能

public interface UserRepository extends JpaRepository<User, Long>, 
                                        JpaSpecificationExecutor<User> {
    // 方法名派生查询
    List<User> findByNameContainingAndStatusOrderByCreateTimeDesc(String name, Integer status);
    
    // JPQL
    @Query("SELECT u FROM User u WHERE u.status = :status AND u.createTime > :since")
    List<User> findActiveUsersSince(@Param("status") Integer status, 
                                     @Param("since") LocalDateTime since);
    
    // 原生 SQL
    @Query(value = "SELECT * FROM users u WHERE JSON_CONTAINS(u.roles, ?1)", nativeQuery = true)
    List<User> findByRoleJson(String role);
    
    // 投影/聚合
    @Query("SELECT u.status, COUNT(u) FROM User u GROUP BY u.status")
    List<StatusCount> countByStatus();
}

public static Specification<User> withFilter(String name, Integer status) {
    return (root, query, cb) -> {
        List<Predicate> predicates = new ArrayList<>();
        if (name != null) {
            predicates.add(cb.like(root.get("name"), "%" + name + "%"));
        }
        if (status != null) {
            predicates.add(cb.equal(root.get("status"), status));
        }
        return cb.and(predicates.toArray(new Predicate[0]));
    };
}

// 使用
userRepo.findAll(withFilter("test", 1), PageRequest.of(0, 20));

spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.pool-name=PrimaryHikariPool

# 核心参数
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.leak-detection-threshold=60000

@Entity
@EntityListeners(AuditingEntityListener.class)
public class BaseEntity {
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    @CreatedBy
    @Column(updatable = false)
    private String createdBy;
    
    @LastModifiedBy
    private String updatedBy;
    
    @Column(name = "is_deleted")
    private Boolean deleted = false;  // 软删除标记
}

// Hibernate 过滤器自动过滤已删除数据
@FilterDef(name = "softDelete", parameters = @ParamDef(name = "deleted", type = Boolean.class))
@Filter(name = "softDelete", condition = "is_deleted = :deleted")
@Entity
public class Order extends BaseEntity { }

@Intercepts({
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class ReadWriteSplitInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        
        // SQL 类型判断
        if (ms.getSqlCommandType() == SqlCommandType.SELECT) {
            DynamicDataSourceContextHolder.setDataSourceKey("slave");
        } else {
            DynamicDataSourceContextHolder.setDataSourceKey("master");
        }
        
        try {
            return invocation.proceed();
        } finally {
            DynamicDataSourceContextHolder.clear();
        }
    }
}

// JPA 接口投影
public interface UserSummary {
    String getName();
    String getEmail();
}

@Query("SELECT u.name AS name, u.email AS email FROM User u WHERE u.status = :status")
List<UserSummary> findSummariesByStatus(@Param("status") Integer status);

// 构造函数投影（类型安全）
@Query("SELECT new com.example.UserDTO(u.id, u.name, u.email) FROM User u WHERE u.id = :id")
UserDTO findDTOById(@Param("id") Long id);

// MyBatis 直接映射到 DTO
@Select("SELECT id, name, email FROM users WHERE id = #{id}")
UserDTO findDTOById(Long id);