JDBC、JPA、Spring Data JPA、Hibernate、Mybatis

1.概念:

Hibernate :Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。着力点对象与对象之间关系

2.简介:

Mybatis:MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。Mybatis:着力于POJO与SQL之间的映射关系

Spring Data:Spring Data:是一个用于简化数据库访问,并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷,并支持map-reduce框架和云计算数据服务。

3.开发的难度:

Hibernate的开发难度要大于Mybatis、Spring Data。主要是由于Hibernate封装了完整的对象关系映射机制,以至于内部的实现比较复杂、庞大,学习周期较长。
Mybatis 主要依赖于SQL的编写与ResultMap的映射。
Spring Data易上手,通过命名规范、注解查询简化查询操作。

4.查询区别:

简单查询:Hibernate 提供了基础的查询方法,也可以根据具体的业务编写相应的SQL;

Mybatis需要手动编写SQL语句,Spring Data 继承基础接口,可使用内置的增删改查方法。

高级查询:Hibernate通过对象映射机制,开发者无需关心SQL的生成与结果映射,专注业务流程;Mybatis需要通过手动在XML文件中编写SQL语句以及ResultMap或者注解,Spring Data 提供了命名规范查询和注解查询更简便的编写想要的SQL。

5.数据库的扩展性:

Hibernate与数据库具体的关联都在XML中,所以HQL对具体是用什么数据库并不是很关心。

Mybatis由于所有SQL都是依赖数据库书写的,所以扩展性,迁移性比较差。

Spring Data 与数据具体的关联可以通过命名规范查询、注解查询,无需关心数据库的差异,但是通过本地化SQL查询的话,就不易扩展。

6.缓存机制:

相同点:Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外,都可以通过实现你自己的缓存或为其他第三方缓存方案,创建适配器来完全覆盖缓存行为。

不同点:Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置,然后再在具体的表-对象映射中配置是那种缓存。

MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置,这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例,通过Cache-ref来实现。

Spring Data 可以通过自己的缓存或者第三方缓存方案,配置满足自己业务需要的缓存行为。

6.查询方式:

Hibernate查询:
1.HQL —>from Admin as admin where admin.name =:name 使用命名参数,仅使用与Hiberante框架

2.Criteria—->对象化查询 Criteria c = getSession().Criteria(Admin.class)

c.add(Restrictions.eq(“aname”,name));//eq是等于,gt是大于,lt是小于,or是或
c.add(Restrictions.eq(“apassword”, password));

3.DetachedCriteria—–>动态分离查询

4.例子查询-Example.create(user).list()

5.sql查询

Query q = s.createSQLQuery(“select * from user”).addEntity(User.class);

6.命名查询:Query q = getSession().getNamedQuery(“getUserByID”);

Mybatis查询:

l 定义xml例如;userMapper.xml

l 定义接口userMapper 定义相关的方法 不必编写接口的实现类

l 通过mybatis内部处理机制解析xml文件中的sql

l 调用存储过程 {call 存储过程名}

Spring Data查询:

1.命名查询,需要遵循Spring Data规范,例如findByUser、deleteById 等从右向左解析生成sql

2.注解查询:@Query(“ql语句”)

7.总结:

Hibernate 对数据库提供了较为完整的封装,封装了基本的DAO层操作,有较好的数据库移植性

Mybatis 可以进行更细致的SQL优化,查询必要的字段,但是需要维护SQL和查询结果集的映射,而且数据库的移植性较差,针对不同的数据库编写不同的SQL,

Spring Data JPA 极大的简化了数据库访问,可以通过命名规范、注解的方式较快的编写SQL。

ORM框架的使用需要根据具体的项目业务选择更适合的技术方案,而不能一味地为了技术而技术。


概述

jdbc是java连接数据库操作的原生接口

jpa是java持久化规范,是orm框架的标准,主流orm框架都实现了这个标准

spring data jpa是对jpa规范的再次抽象,底层还是用的实现jpa的hibernate技术

hibernate是一个标准的orm框架,实现了jpa

mybatis也是一个持久化框架,但不完全是一个orm框架,不是依照的jpa规范。

什么是orm?

orm(Object Relation Mapping) 对象关系映射,是对象持久化的核心,是对jdbc的封装。

hibernate VS mybatis VS jdbc

jdbc是比较底层的数据库操作方式,hibernate和mybatis都是在jdbc的基础上进行了封装。

hibernate是将数据库中的数据表映射为持久层的java对象,实现对数据表的完整性控制。hibernate的主要思想是面向对象,标准的orm。不建议自己写sql语句,如果确实有必要推荐hql代替。hibernate是全表映射,只需提供java bean和数据库表映射关系,

mybatis是将sql语句中的输入参数parameterMap和输出结果resultMap映射为java对象,放弃了对数据表的完整性控制,获得了更大的灵活性。mybatis拥抱sql,在sql语句方面有更大的灵活性,mybatis不是面向对象,不是标准的orm,更像是sql mapping框架。mybatis是半自动的,需要提供java bean,sql语句和数据库表的映射关系。

开发难度:

Hibernate因为是封装了完整的对象关系映射,内部实现比较复杂,学习周期大。

mybatis主要是配置文件中sql语句的编写

spring data上手快,通过命名规范,注解查询可简化操作

总结

如果是进行底层编程,需要对性能要求高,应采用jdbc方式。

如果直接操作数据库表,没有过多的定制,建议使用hibernate方式。

如果要灵活使用sql语句,建议采用mybatis方式。

### 如何在项目中同时使用 Spring Data JPAMyBatis 实现多数据源管理 #### 1. 多数据源的概念 在一个应用程序中,如果需要连接多个数据库实例来完成业务逻辑,则称为多数据源配置。这种场景下,可以通过 Spring Boot 提供的灵活性,分别针对不同数据源配置对应的持久化技术(如 JPAMyBatis)。这种方式能够满足复杂项目的多样化需求[^2]。 --- #### 2. 技术选型与特点比较 JPA 是一种基于 ORM 的解决方案,允许开发人员以面向对象的方式操作数据库,简化了 Java 对象和关系型数据库之间的映射过程。而 MyBatis 则提供了更高的 SQL 控制能力,适用于复杂的查询场景。两者的差异在于对象映射方式、移植性和批量处理效率等方面[^4]。 --- #### 3. 配置步骤详解 ##### (1)引入依赖 为了支持多数据源管理和两种持久化框架,在 `pom.xml` 文件中需添加以下依赖: ```xml <dependencies> <!-- Spring Boot Starter Data JPA --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!-- MyBatis-Spring-Boot-Starter --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.3.0</version> </dependency> <!-- 数据库驱动 (MySQL为例) --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> ``` 上述代码片段展示了如何引入必要的 Maven 依赖项。 --- ##### (2)数据源分离配置 假设存在两个数据源:`dataSourceA` 使用 JPA 进行操作,`dataSourceB` 使用 MyBatis 进行操作。可以在 `application.yml` 中定义如下配置: ```yaml spring: datasource: a: url: jdbc:mysql://localhost:3306/db_a?useSSL=false&serverTimezone=UTC username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver b: url: jdbc:mysql://localhost:3306/db_b?useSSL=false&serverTimezone=UTC username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver mybatis: mapper-locations: classpath:mapper/*.xml ``` 此部分描述了如何通过 YAML 文件区分不同的数据源及其属性。 --- ##### (3)自定义配置类 为每个数据源单独创建 Bean 容器并绑定至对应的技术栈。 ###### A. 针对 JPA 的数据源配置 (`DataSourceAConfig`) ```java @Configuration @EnableTransactionManagement @PropertySource({"classpath:datasource-a.properties"}) public class DataSourceAConfig { @Bean(name = "dataSourceA") @ConfigurationProperties(prefix = "spring.datasource.a") public DataSource dataSource() { return DataSourceBuilder.create().build(); } @Primary @Bean(name = "entityManagerFactoryA") public LocalContainerEntityManagerFactoryBean entityManagerFactory( EntityManagerFactoryBuilder builder, @Qualifier("dataSourceA") DataSource dataSource) { Map<String, Object> properties = new HashMap<>(); properties.put("hibernate.hbm2ddl.auto", "update"); properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect"); return builder.dataSource(dataSource).properties(properties) .packages("com.example.jpa.entity").persistenceUnit("unitA").build(); } @Primary @Bean(name = "transactionManagerA") public PlatformTransactionManager transactionManager(@Qualifier("entityManagerFactoryA") EntityManagerFactory emf) { return new JpaTransactionManager(emf); } } ``` 这段代码实现了第一个数据源的具体初始化逻辑,并将其关联到 JPA 持久层[^5]。 --- ###### B. 针对 MyBatis 的数据源配置 (`DataSourceBConfig`) ```java @Configuration @MapperScan(basePackages = "com.example.mybats.mapper", sqlSessionFactoryRef = "sqlSessionFactoryB") public class DataSourceBConfig { @Bean(name = "dataSourceB") @ConfigurationProperties(prefix = "spring.datasource.b") public DataSource dataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "sqlSessionFactoryB") public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSourceB") DataSource dataSource) throws Exception { SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean(); factoryBean.setDataSource(dataSource); PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); factoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml")); return factoryBean.getObject(); } @Bean(name = "sqlSessionTemplateB") public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactoryB") SqlSessionFactory sessionFactory) { return new SqlSessionTemplate(sessionFactory); } } ``` 该段代码完成了第二个数据源的构建工作,并指定它服务于 MyBatis 映射文件。 --- ##### (4)事务管理 由于涉及多个数据源的操作,因此需要特别关注分布式事务的支持情况。可以利用 Spring 的声明式事务机制配合动态代理功能实现跨数据源的一致性控制[^3]。 示例代码展示了一个简单的事务边界设定: ```java @Service @Transactional(transactionManager = "transactionManagerA", rollbackFor = Exception.class) public class CandidateService { private final CandidateRepository repository; public CandidateService(CandidateRepository repository) { this.repository = repository; } public void processCandidate(long id) { try { // 调用 Repository 方法执行保存或其他操作 repository.findById(id).orElseThrow(() -> new RuntimeException("Not found")); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } } ``` 此处强调了如何显式指明所使用的事务管理器名称。 --- ### 总结 以上内容介绍了如何在同一 Spring Boot 应用程序中整合 JPAMyBatis 并实施多数据源策略的方法。这种方法充分利用了两者的优势,既保留了 JPA 的简洁易用特性,又兼顾了 MyBatis 在复杂查询方面的强大表现力。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值