Spring集成JPA和MyBatis例子

最新推荐文章于 2024-04-24 17:33:50 发布
最新推荐文章于 2024-04-24 17:33:50 发布
阅读量2.2w 收藏 16
点赞数 1
分类专栏： Spring 文章标签： Spring JPA MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_boy/article/details/72353608
版权

现在Spring流行基于Java的配置（JavaConfig），总体来说是充分利用隐式的bean发现机制和自动装配，结合Java显式配置，完成整个项目的配置。《Spring实战(第4版)》第2章和第3章详细介绍了这些技术。
本文根据第11章第11.3节借助Spring Data实现自动化的JPA Repository，整理了一个简单例子，记录下来。

本例子源代码下载地址为：
Spring集成JPA和MyBatis简单例子-20170622

一、用idea创建Maven项目
结构如下图所示
这里写图片描述
pom.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wu.demo.spring</groupId>
    <artifactId>jpamybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>4.12</junit.version>
        <springframework.version>4.3.8.RELEASE</springframework.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.29</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.11.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.8.Final</version>
        </dependency>
    </dependencies>
</project>

数据源配置文件如下

jdbc.driver = org.postgresql.Driver
db.url = jdbc:postgresql://localhost:5432/test
db.username = postgres
db.password = postgres

initdb.sql不是项目必须的，只是用于建表测试，内容如下：

drop table if exists user_test;
create table user_test (
  id varchar(32) primary key,
  username varchar(32) not null,
  password varchar(32) not null
);

准备工作做完了。
二、创建User类

package com.wu.demo.spring.jpamybatis.bean;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

@Entity
@Table(name="user_test")
public class User {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    private String id;

    @Column
    private String username;

    @Column
    private String password;

    //此处节省篇幅，省略了get/set。
}

三、Dao包中，UserRepository继承JpaRepository。

package com.wu.demo.spring.jpamybatis.dao;

import com.wu.demo.spring.jpamybatis.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, String>{
}

UserMapper接口如下：

package com.wu.demo.spring.jpamybatis.dao;

import com.wu.demo.spring.jpamybatis.bean.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;

public interface UserMapper {

    @Select(value="select * from user_test where username = #{username}")
    User getByUsername(@Param("username") String username);

    @SelectProvider(type = UserSqlProvider.class, method = "get")
    User get(@Param("username") String username, @Param("password") String password);

    @UpdateProvider(type = UserSqlProvider.class, method = "update")
    void update(User user);
}

UserSqlProvider如下：

package com.wu.demo.spring.jpamybatis.dao;

import com.alibaba.druid.util.StringUtils;
import com.wu.demo.spring.jpamybatis.bean.User;
import org.apache.ibatis.jdbc.SQL;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * MyBatis动态SQL语句构建器，链式SQL构建始于version 3.4.2
 */
@Component
public class UserSqlProvider {

    /**
     * 根据用户名和密码查询
     * @param params
     * @return
     */
    public String get(Map<String, String> params){
        String username = params.get("username");
        String password = params.get("password");
        SQL sql = new SQL().SELECT("*").FROM("user_test");
        if(!StringUtils.isEmpty(username)){
            sql.WHERE("username=#{username}");
        }
        if(!StringUtils.isEmpty(password)){
            sql.WHERE("password=#{password}");
        }
        return sql.toString();
    }

    /**
     * 修改用户名和密码
     * @param user
     * @return
     */
    public String update(User user){
        SQL sql = new SQL().UPDATE("user_test").SET("username = #{username}, password = #{password}")
                .WHERE("id=#{id}");
        return sql.toString();
    }
}

四、Service如下

package com.wu.demo.spring.jpamybatis.service;

import com.wu.demo.spring.jpamybatis.bean.User;
import com.wu.demo.spring.jpamybatis.dao.UserMapper;
import com.wu.demo.spring.jpamybatis.dao.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private UserMapper userMapper;

    public void save(User user) {
        userRepository.save(user);
    }

    public User getByUsername(String username){
        return userMapper.getByUsername(username);
    }

    public User get(String username, String password){
        return userMapper.get(username, password);
    }

    public void update(User user){
        userMapper.update(user);
    }

    public void insertAndUpdate(){
        User o = new User();
        o.setUsername("guest");
        o.setPassword("guest123");
        save(o);//JPA保存用户

        User user = getByUsername("admin");
        user.setPassword("admin123456");
        update(user);//MyBatis修改用户

//        throw new RuntimeException(); //事务测试，抛出异常则全部回滚
    }
}

JpaTransactionManager可以同时管理JPA和MyBatis事务。

五、工程主配置文件AppConfig.java如下：

package com.wu.demo.spring.jpamybatis.conf;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

@Configuration
@PropertySource(value={"classpath:jdbc.properties"})
@ComponentScan(basePackages = {"com.wu.demo.spring.jpamybatis.service"})
public class AppConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigInDev() {
        return new PropertySourcesPlaceholderConfigurer();
    }

}

数据源DataSourceConfig.java配置如下：

package com.wu.demo.spring.jpamybatis.conf;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Value("${jdbc.driver}")
    private String jdbcDriver;

    @Value("${db.url}")
    private String dbUrl;

    @Value("${db.username}")
    private String username;

    @Value("${db.password}")
    private String password;

    @Bean(destroyMethod = "close")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(jdbcDriver);
        dataSource.setUrl(dbUrl);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

JPA和MyBatis配置DaoConfig.java如下：

package com.wu.demo.spring.jpamybatis.conf;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@Import({ DataSourceConfig.class })
@EnableJpaRepositories(entityManagerFactoryRef="entityManagerFactory", transactionManagerRef="jpaTransactionManager",
        basePackages = "com.wu.demo.spring.jpamybatis.dao")
@MapperScan("com.wu.demo.spring.jpamybatis.dao")//Mapper扫描
public class DaoConfig {

    @Bean
    public JpaVendorAdapter jpaVendorAdapter(){
        HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
        adapter.setDatabase(Database.POSTGRESQL);
        adapter.setShowSql(true);
        adapter.setGenerateDdl(false);
        adapter.setDatabasePlatform("org.hibernate.dialect.HSQLDialect");
        return adapter;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource){
        LocalContainerEntityManagerFactoryBean emfb = new LocalContainerEntityManagerFactoryBean();
        emfb.setDataSource(dataSource);
        emfb.setJpaVendorAdapter(jpaVendorAdapter());
        emfb.setPackagesToScan("com.wu.demo.spring.jpamybatis.bean");
        return emfb;
    }

    @Bean
    public JpaTransactionManager jpaTransactionManager(DataSource dataSource) {
        JpaTransactionManager jtm = new JpaTransactionManager();
        jtm.setEntityManagerFactory(entityManagerFactory(dataSource).getObject());
        return jtm;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        return sessionFactory.getObject();
    }

}

六、测试类如下：

package com.wu.demo.spring.jpamybatis.test;
import com.wu.demo.spring.jpamybatis.bean.User;
import com.wu.demo.spring.jpamybatis.conf.AppConfig;
import com.wu.demo.spring.jpamybatis.conf.DataSourceConfig;
import com.wu.demo.spring.jpamybatis.conf.DaoConfig;
import com.wu.demo.spring.jpamybatis.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={AppConfig.class, DataSourceConfig.class, DaoConfig.class})
@Rollback(value = false)//关闭自动事务自动回滚
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void save(){
        User o = new User();
        o.setUsername("admin");
        o.setPassword("admin123");
        userService.save(o);
    }

    @Test
    public void getByUsername(){
        User o = userService.getByUsername("admin");
        System.out.println(o);
    }

    @Test
    public void get(){
        User o = userService.get("admin", "admin123");
        System.out.println(o);
    }

    @Test
    public void update(){
        User o = userService.getByUsername("admin");
        o.setUsername("admin2");
        o.setPassword("admin222");
        userService.update(o);
    }

    @Test
    public void insertAndUpdate(){
        userService.insertAndUpdate();
    }

}

本例子源代码下载地址为：
Spring集成JPA和MyBatis简单例子-20170622

参考资料如下：
1、Spring4.X + spring MVC + Mybatis3 零配置应用开发框架搭建详解
2、Spring Data JPA @EnableJpaRepositories配置详解
3、Spring事物管理器TransactionManager解析
4、《Spring实战（第4版）》
5、《Spring 3.x企业应用开发实战》

八卦程序
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
玩转 Spring Boot 集成篇（MyBatis、JPA、事务支持）
一猿小讲
01-26 2461
在使用 Spring 进行实际项目研发中，Spring 整合 ORM 组件（MyBatis、JPA）是必不可少一个环节，而在整合过程中，往往要进行大量的配置。借助 SpringBoot 可...
Spring集成JPA和MyBatis简单例子
05-16
Spring集成JPA和MyBatis简单例子
鱼和熊掌兼得：同时使用 JPA 和 Mybatis
weixin_49794051的博客
12-29 9512
前言 JPA 和 Mybatis 的争论由来已久，还记得在 2 年前我就在 spring4all 社区就两者孰优孰劣的话题发表了观点，我当时是力挺 JPA 的，这当然跟自己对 JPA 熟悉程度有关，但也有深层次的原因，便是 JPA 的设计理念契合了领域驱动设计的思想，可以很好地指导我们设计数据库交互接口。这两年工作中，逐渐接触了一些使用 Mybatis 的项目，也对其有了一定新的认知。都说认知是一个螺旋上升的过程，随着经验的累积，人们会轻易推翻过去，到了两年后的今天，我也有了新的观点。本文不是为了告诉你 J
SpringBoot集成JPA及基本使用
最新发布
JingAi_jia917的博客
04-24 1253
本篇从JDBC、ORM、JPA、Spring Data JPA说起，分享了SpringBoot集成JPA的实现、Repository的命名规则以及InvalidDefinitionException异常的处理
java mybatis jpa_Spring Boot集成JPA和MyBatis例子
weixin_30539081的博客
02-16 164
先说说背景，项目之前使用的spring JPA做为数据持久化的工具，本人接手后想使用MyBatis，但是之前的又不想改变，所以有了这个需求，同一个数据源，使用spring JPA和MyBatis来做持久化。刚开始集成出了好多问题，以下就列出正确的集成方式，参照这种方式，一定能集成成功在之前的mybatis版本中，dao和mapper文件的文件名要特殊定义，就是末尾必须是Dao或者Mapper,但是...
springboot同时整合JPA和mybatis的demo
08-12
这个demo同时整合了springboot+JPA+mybatis这个两个orm框架。
Spring4集成JPA和MyBatis3简单例子
05-18
Spring4集成JPA和MyBatis3简单例子
Spring集成JPA和MyBatis简单例子-20170622
06-22
Spring集成JPA和MyBatis简单例子
springboot框架与其它结合如jpa、mybatis、websocket、security、shiro、cache.zip
10-14
该项目是Springboot 和 dubbo 结合的例子，是provider 的示例，提供服务。简单的写了一些用户和权限的接口没有写的很完整，主要是为了提现dubbo 服务 Springboot-shiro2 也是和dubbo 的结合例子是 消费者的示例。
liuge1988-spring-boot-demo-master.zip
08-20
十几个springboot的例子，包括集成Druid数据源，mybatis，rabbit MQ，redis，spring data JPA，spring Securiy 整车swagger文档等
JPA和Mybatis混用事务管理器出现事务问题原理剖析
JavaMyDream的博客
04-02 754
【代码】JPA和Mybatis混用事务管理器出现事务问题原理剖析。
Spring 集成Hibernate & 集成JPA & 集成MyBatis
chenshifu888的博客
12-03 1039
通过以上步骤，你可以在Spring中集成Hibernate，并使用JPA来管理数据库访问和持久性。在Spring中，可以使用JPA（Java Persistence API）作为对象关系映射（ORM）框架，与数据库进行交互和管理持久化数据。在Spring中，可以使用Hibernate作为对象关系映射(ORM)框架来管理数据库访问和持久性。通过以上步骤，你可以在Spring中成功集成JPA，并使用Repository进行数据库访问操作。注意，在以上步骤中可以根据实际需求进行配置和扩展。
mybatis事务和spring整合mybatis事务
cheyun0833的博客
09-27 1123
下面是spring整合mybatis 事务管理 介绍事务 企业级开发中，事务管理是必不可少的，保证数据的完整性和一致性。 事务的四个特性ACID: atomic:原子性 事务操作具有原子特性，要么一起完成， 要么一起不起作用 consistency:一致性 一旦事务完成（提交或...
springBoot数据库jpa+对接mybatis
weixin_30435261的博客
06-26 373
1 spring Data jpa hibernate引领数据访问技术，使用orm对象关系映射来进行数据库访问，通过模型和数据库进行映射，通过操作对象实现对数据库操作，把数据库相关操作从代码中独立出来。随着hibernate盛行，hibernate主导了JPA规范，即 java persistence api。jps是一个基于orm映射的标准，主要实现有hibernate，ec...
spring mvc jpa mysql mybatis_Spring同时集成JPA与Mybatis
weixin_39941732的博客
02-03 140
@ORMORM的出现，使得关系型数据库映射成了对象；简单来说，有了ORM之后，JAVA程序员从面向JDBC编程转化成面向JAVA对象编程。Spring ORMSpring对ORM的解决方案主要体现在以下方面：统一的资源管理方式与异常管理：Spring使用各种ORM框架，资源管理及使用方式都是统一的；同时Spring会将各个ORM框架的异常转译到Spring异常体系下。统一的事务管理：Spring通...
SpringBoot+JPA+Mybatis+多数据源(MySQL/PostgreSQL)
俱往矣
03-13 1060
开始公司主要使用的是Springboot+JPA后来要对接一个其他系统，然后加了一个数据库，就成了Springboot+JPA+多数据源，但是后面随着业务发现JPA有时候用着太难受，就想着加个Mybatis，然后去网上搜如何整合JPA+Mybatis，但是网上的教程都是单数据源整合的，没有发现多数据源整合的案例。想着之前整合过Mybatis+多数据源，然后就把配置文件复制一份，开始踩坑之路。 一...
spring集成jpa和mybatis,及spring事务处理,jpa的生命周期
风的专栏
09-13 2475
1、spring集成jpa      getDataSource--&gt;entityManagerFactory--&gt;transactionManager      映射为      数据源--&gt;实体管理工厂--&gt;事务管理器      实体是有生命周期状态的 2、spring集成mybatis     getDataSource--&gt;sqlSessionFact...
数据持久层框架调研(jpa vs mybatis)
天然卷的博客
10-22 1135
背景 1.Mybatis generator为mybatis生成了大量并没有实际使用的代码，实际发现只有 selectByExample，insertSelective 两个方法使用较多，而且为每个实体类生成一个 *Example 类。 *Example 这个类是大量相似的代码，完全可以抽象统一起来 2.还有生成不同风格的 DynamicSql 风格的mapper 层代码，混乱可读性差。 框架选型 jpa jpa只需要简单生成entity，mapper 层继承 org.springframework.dat
springboot使用SpringDataJPA与mybits并存，多数据源配置与使用
b308175181的博客
03-22 1001
项目中使用多个数据源在以往工作中比较常见，可以使用SpringDataJPA构建简单的查询，mybits做一些复杂的操作。 1.多数据源yml配置： 2.config配置 1.基础的配置，这个实际上可以写到对应后续各个源里面，看个人喜好。（注意：作为第一数据源有@Primary） package import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.co.
Spring Data JPA 和 mybatis 的关系
06-11
Spring Data JPA 和 MyBatis 都是 Java 开发中常用的持久层框架，它们的主要区别在于实现方式不同。 Spring Data JPA 是 Spring Data 家族中的一个成员，它是基于 JPA 规范实现的 ORM 框架，通过注解和接口声明的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值