跟着Hibernate 学习 23 种设计模式

于 2025-06-20 21:33:56 发布
阅读量574 收藏 8
点赞数 15
CC 4.0 BY-SA版权
分类专栏： # 设计模式23+1条 文章标签： hibernate 学习 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148799792

以下是 Hibernate 框架中涉及的 23 种设计模式的分类、技术原理及代码示例：

一、创建型模式

1. 工厂方法模式 (Factory Method)

作用：定义创建对象的接口，由子类决定实例化哪个类。

Hibernate 实现：

  • SessionFactory：通过 Configuration 构建 SessionFactory 实例。
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory(); // 构建工厂
2. 抽象工厂模式 (Abstract Factory)

作用：创建一组相关或依赖的对象，而无需指定具体类。

Hibernate 实现：

  • RegionFactory：根据配置创建不同的缓存区域工厂（如 Ehcache、Infinispan）。
public interface RegionFactory {
    Cache createCache(String regionName, Properties properties, CacheDataDescription metadata);
}

// 具体实现（EhcacheRegionFactory）
public class EhcacheRegionFactory implements RegionFactory {
    @Override
    public Cache createCache(String regionName, Properties properties, CacheDataDescription metadata) {
        return new EhcacheCache(regionName, properties); // 返回具体缓存实现
    }
}
3. 单例模式 (Singleton)

作用：确保一个类只有一个实例，并提供全局访问点。

Hibernate 实现：

  • ServiceRegistry：通过 StandardServiceRegistryBuilder 构建全局服务注册表。
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
4. 建造者模式 (Builder)

作用：逐步构建复杂对象，允许用户通过链式调用设置属性。

Hibernate 实现：

  • CriteriaBuilder：构建类型安全的查询条件。
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<User> query = builder.createQuery(User.class);
Root<User> root = query.from(User.class);
query.select(root).where(builder.equal(root.get("name"), "Alice"));
5. 原型模式 (Prototype)

作用：通过克隆现有对象创建新实例。

Hibernate 实现：

  • Cloneable 接口：实体类实现 Cloneable 以支持深拷贝。
public class User implements Cloneable {
    @Override
    public User clone() {
        try {
            return (User) super.clone(); // 浅拷贝
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

二、结构型模式

6. 适配器模式 (Adapter)

作用：将接口转换为客户端期望的另一个接口。

Hibernate 实现：

  • JDBCAdapter：适配不同数据库的 JDBC 驱动。
public class JDBCAdapter {
    private Connection connection;

    public JDBCAdapter(DataSource dataSource) {
        try {
            this.connection = dataSource.getConnection(); // 适配不同数据源
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
7. 装饰器模式 (Decorator)

作用：动态为对象添加附加功能。

Hibernate 实现：

  • CacheConcurrencyStrategy：为缓存添加并发控制策略（如读写锁）。
public class ReadWriteCacheDecorator implements Cache {
    private final Cache delegate;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    @Override
    public Object get(Object key) {
        lock.readLock().lock();
        try {
            return delegate.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
}
8. 代理模式 (Proxy)

作用：通过代理对象控制对原对象的访问。

Hibernate 实现：

  • 懒加载代理：通过 CGLIB 或 Javassist 生成实体类的代理对象。
// 生成代理类（示例）
public class UserProxy$$_jvst9b0_0 implements User {
    private User target;
    private Session session;

    @Override
    public String getName() {
        if (target == null) {
            target = session.load(User.class, id); // 懒加载
        }
        return target.getName();
    }
}
9. 外观模式 (Facade)

作用：为复杂子系统提供简化的接口。

Hibernate 实现：

  • Session 接口：封装数据库操作，提供统一的访问接口。
public interface Session {
    void save(Object entity);
    void update(Object entity);
    void delete(Object entity);
    Query createQuery(String queryString);
}
10. 桥接模式 (Bridge)

作用：将抽象与实现解耦，使两者可以独立变化。

Hibernate 实现：

  • ConnectionProvider：桥接不同连接池实现（如 HikariCP、C3P0）。
public interface ConnectionProvider {
    Connection getConnection() throws SQLException;
    void closeConnection(Connection conn) throws SQLException;
}

// 具体实现（HikariCPConnectionProvider）
public class HikariCPConnectionProvider implements ConnectionProvider {
    private final HikariDataSource dataSource;

    @Override
    public Connection getConnection() {
        return dataSource.getConnection(); // 返回 HikariCP 连接
    }
}
11. 组合模式 (Composite)

作用：将对象组合成树形结构，以表示“部分-整体”的层次结构。

Hibernate 实现：

  • Criteria 查询组合：通过组合模式构建复杂查询条件。
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.eq("name", "Alice"));
criteria.add(Restrictions.or(
    Restrictions.eq("age", 30),
    Restrictions.eq("age", 35)
));
12. 享元模式 (Flyweight)

作用：共享对象以减少内存占用。

Hibernate 实现：

  • SessionFactory 复用：全局共享一个 SessionFactory 实例。
// 全局共享 SessionFactory
public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

三、行为型模式

13. 模板方法模式 (Template Method)

作用：定义算法骨架，将某些步骤延迟到子类实现。

Hibernate 实现：

  • AbstractSaveEventListener：定义保存实体的流程，子类实现具体步骤。
public abstract class AbstractSaveEventListener extends AbstractEntityPersister {
    @Override
    public Serializable save(Object entity, Serializable id, Object[] state) {
        // 公共逻辑（如版本控制、事件触发）
        return doSave(entity, id, state); // 调用子类实现
    }

    protected abstract Serializable doSave(Object entity, Serializable id, Object[] state);
}
14. 观察者模式 (Observer)

作用：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者收到通知。

Hibernate 实现：

  • 事件监听机制：通过 @EntityListeners 监听实体生命周期事件。
@Entity
@EntityListeners(AuditListener.class)
public class User {
    // 实体字段
}

// 监听器
public class AuditListener {
    @PostPersist
    public void postPersist(Object entity) {
        System.out.println("Entity persisted: " + entity);
    }
}
15. 策略模式 (Strategy)

作用：定义一系列算法，并将每个算法封装起来，使它们可以互换。

Hibernate 实现：

  • IdentifierGenerator 策略：根据配置选择不同的主键生成策略（如自增、UUID）。
public interface IdentifierGenerator {
    Serializable generate(SessionImplementor session, Object entity);
}

// 具体策略（UUIDGenerator）
public class UUIDGenerator implements IdentifierGenerator {
    @Override
    public Serializable generate(SessionImplementor session, Object entity) {
        return UUID.randomUUID().toString(); // 返回 UUID
    }
}
16. 命令模式 (Command)

作用：将请求封装为对象，以便用不同的请求、队列或日志参数化其他对象。

Hibernate 实现：

  • FlushCommand：封装刷新操作命令。
public class FlushCommand implements Command {
    private final SessionImplementor session;

    public FlushCommand(SessionImplementor session) {
        this.session = session;
    }

    @Override
    public void execute() {
        session.flush(); // 执行刷新命令
    }
}
17. 责任链模式 (Chain of Responsibility)

作用：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

Hibernate 实现：

  • 拦截器链：通过 Interceptor 处理持久化操作。
public class AuditInterceptor implements EmptyInterceptor {
    @Override
    public boolean onSave(Object entity, Serializable id, Object[] state) {
        if (entity instanceof Auditable) {
            ((Auditable) entity).setLastModified(new Date()); // 审计拦截
            return true;
        }
        return false;
    }
}
18. 备忘录模式 (Memento)

作用：捕获并保存对象的内部状态，以便后续恢复。

Hibernate 实现：

  • EntityEntry 状态保存：通过 EntityEntry 保存实体状态快照。
public class EntityEntry {
    private Object[] loadedState;
    private Object[] previousState;

    public void takeSnapshot(Object[] state) {
        this.previousState = Arrays.copyOf(state, state.length); // 保存快照
    }
}
19. 状态模式 (State)

作用：允许对象在内部状态改变时改变行为。

Hibernate 实现：

  • 事务状态管理：通过 TransactionState 管理事务的不同状态。
public enum TransactionState {
    ACTIVE,
    COMMITTED,
    ROLLED_BACK
}

// 事务状态管理
public class JdbcTransaction implements Transaction {
    private TransactionState state = TransactionState.ACTIVE;

    @Override
    public void commit() {
        state = TransactionState.COMMITTED; // 修改状态
    }
}
20. 访问者模式 (Visitor)

作用：在对象结构中定义新操作，而无需修改结构本身。

Hibernate 实现：

  • ClassVisitor：通过访问者模式遍历实体类元数据。
public interface ClassVisitor {
    void visit(ClassMetadata metadata);
}

// 具体访问者
public class AuditClassVisitor implements ClassVisitor {
    @Override
    public void visit(ClassMetadata metadata) {
        if (metadata.hasIdentifierProperty()) {
            System.out.println("Entity has ID: " + metadata.getIdentifierPropertyName());
        }
    }
}
21. 解释器模式 (Interpreter)

作用：给定一种语言，定义其文法表示，并构建解释器来解释语言中的句子。

Hibernate 实现：

  • HQL 解析：通过 ANTLR 解析 HQL 查询语句。
// 示例：使用 ANTLR 解析 HQL
ANTLRInputStream input = new ANTLRInputStream(hqlQuery);
HqlLexer lexer = new HqlLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
HqlParser parser = new HqlParser(tokens);
ParseTree tree = parser.query(); // 解析查询
22. 迭代器模式 (Iterator)

作用：提供一种顺序访问集合元素的方法，而无需暴露其内部表示。

Hibernate 实现：

  • 结果集遍历：通过 ScrollableResults 遍历查询结果。
Query query = session.createQuery("FROM User");
ScrollableResults results = query.scroll(ScrollMode.FORWARD_ONLY);
while (results.next()) {
    User user = (User) results.get(0);
    System.out.println(user.getName());
}
23. 中介者模式 (Mediator)

作用：定义一个中介对象来封装一系列对象之间的交互。

Hibernate 实现：

  • Session 作为中介者：协调 EventSource、Cache、Connection 等组件之间的交互。
public class SessionImpl implements Session {
    private final EventSource eventSource;
    private final Cache cache;
    private final Connection connection;

    @Override
    public void save(Object entity) {
        eventSource.fireEvent(new PreInsertEvent(entity)); // 触发事件
        cache.put(entity); // 更新缓存
        connection.commit(); // 提交事务
    }
}

总结

Hibernate 框架通过灵活运用 23 种设计模式，实现了高扩展性、低耦合性和灵活性。这些模式覆盖了对象创建、结构组织、行为交互等各个方面，是学习 Java 框架设计的经典案例。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值