JPA和Spring整合

最新推荐文章于 2023-06-13 19:49:01 发布
最新推荐文章于 2023-06-13 19:49:01 发布
阅读量177 收藏
点赞数
文章标签： spring与Jpa整合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44118941/article/details/85221297
版权

创建maven工程
1 pom坐标

<properties>
        <spring.version>5.0.2.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring对orm框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring end -->

        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->

        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->

        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- spring data jpa 的坐标-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- el beg 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- el end -->
    </dependencies>

2实体类(set get略)

@Entity
@Table(name = "cst_customer")
public class Customer {

    /**
     * @Id：声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY ：自增，mysql
     *                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *          GenerationType.SEQUENCE : 序列，oracle
     *                  * 底层数据库必须支持序列
     *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
     *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
     * @Column:配置属性和字段的映射关系
     *      name：数据库表中字段的名称
     */
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址

3实体类对应表的接口

public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor {


    //以下是jpql方法
    //根据客户名称查询客户
    @Query(value = "from Customer where custName=?")
    public Customer findJpql(String name);

    //根据客户名称和客户id查询客户
    @Query(value = "from Customer where custName=? and custId=?")
    public Customer findCustNameAndId(String name, Long id);

    //@Modifying当前执行的是一个更新操作
    @Query(value = " update Customer set custName = ?2 where custId = ?1 ")
    @Modifying
    public void updateCustomer(long custId, String custName);

    //nativeQuery ： 查询方式 true ： sql查询    false：jpql查询
    @Query(value = "select * from cst_customer where cust_name like ?1", nativeQuery = true)
    public List<Object[]> findSql(String name);


    // findBy : 查询 接属性名称 首字母大写(条件)
    public Customer findByCustName(String custName);


    public List<Customer> findByCustNameLike(String custName);

    //使用客户名称模糊匹配和客户所属行业精准匹配的查询
    public Customer findByCustNameLikeAndCustIndustry(String custName, String custIndustry);
}

4spring.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--spring 和 spring data jpa的配置-->

    <!-- 1.创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--配置的扫描的包（实体类所在的包） -->
        <property name="packagesToScan" value="cn.itcast.domain" />
        <!-- jpa的实现厂家 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>

        <!--jpa的供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--配置是否自动创建数据库表 -->
                <property name="generateDdl" value="false" />
                <!--指定数据库类型 -->
                <property name="database" value="MYSQL" />
                <!--数据库方言：支持的特有语法 -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <!--是否显示sql -->
                <property name="showSql" value="true" />
            </bean>
        </property>

        <!--jpa的方言 ：高级的特性 -->
        <property name="jpaDialect" >
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>


    </bean>

    <!--2.创建数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="12345"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa" ></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!--3.整合spring dataJpa-->
    <jpa:repositories base-package="cn.itcast.dao"
                      transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>

    <!--4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
    </bean>

    <!-- 4.txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5.aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>


    <!--5.声明式事务 -->

    <!-- 6. 配置包扫描-->
    <context:component-scan base-package="cn.itcast" ></context:component-scan>
</beans>

5测试1

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpaTest {
    @Autowired
    private CustomerDao customerDao;
    //查询所有
    @Test
    public void testFindAll(){
        List<Customer> all = customerDao.findAll();
        for (Customer customer : all) {
            System.out.println(customer);
        }

    }
    //根据id查询
    @Test
    public void testFindOne(){
        Customer one = customerDao.findOne(2l);
        System.out.println(one);
    }
    //保存方法
    @Test
    public void testSave1(){
        Customer customer = new Customer();
        customer.setCustName("嘻嘻嘻");
        customer.setCustAddress("武汉");
        Customer save = customerDao.save(customer);

    }
    //更新方法(根据传递的对象是否存在主键id，
    //     *      如果没有id主键属性：保存
    //     *      存在id主键属性，根据id查询数据，更新数据)
    @Test
    public void testSave2(){
        Customer customer = new Customer();
        customer.setCustName("嘻嘻嘻");
        customer.setCustAddress("武汉");
        customer.setCustId(2l);
        Customer save = customerDao.save(customer);

    }
    @Test
    public void testUpdate(){
        Customer customer  = new Customer();
        customer.setCustId(7l);
        customer.setCustName("黑马程序员很厉害");
        customerDao.save(customer);
    }
    @Test
    public void testDelete () {
        customerDao.delete(3l);
    }
    @Test
    public void testCount(){
        long count = customerDao.count();
        System.out.println(count);

    }
    //判断id为4的客户是否存在
    @Test
    public void testExisit(){
        boolean exists = customerDao.exists(4l);
        System.out.println(exists);

    }
    //根据id从数据库查询
    //     *      @Transactional : 保证getOne正常运行
    //     *
    //     *  findOne：
    //     *      em.find()           :立即加载
    //     *  getOne：
    //     *      em.getReference     :延迟加载
    //     *      * 返回的是一个客户的动态代理对象
    //     *      * 什么时候用，什么时候查询
    @Test
    @Transactional
    public void testGetO(){
        Customer one = customerDao.getOne(5l);
        System.out.println(one);
    }
}

测试2(Jpql)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpqlTest {
    @Autowired
    private CustomerDao customerDao;

    //根据客户名称查询客户
    @Test
    public void testFindJpql() {
        Customer jpql = customerDao.findJpql("黑马程序员很厉害");
        System.out.println(jpql);
    }

    //根据客户名称和客户id查询客户
    @Test
    public void testFindCustNameAndId() {
        Customer customer = customerDao.findCustNameAndId("试试播客", 5l);
        System.out.println(customer);
    }

    //更新操作 加上事务和设置不回滚注解
    @Test
    @Transactional
    @Rollback(value = false)
    public void updateCustomer() {
        customerDao.updateCustomer(2l, "哈哈哈");
    }

    @Test
    public void findSql() {
        List<Object[]> sql = customerDao.findSql("嘻嘻嘻%");
        for (Object[] objects : sql) {
            System.out.println(Arrays.toString(objects));
        }
    }

    @Test
    public void findByCustName() {
        Customer customer = customerDao.findByCustName("哈哈哈");
        System.out.println(customer);
    }

    @Test
    public void findByCustNameLike() {
        List<Customer> nameLike = customerDao.findByCustNameLike("试试%");
        for (Customer customer : nameLike) {
            System.out.println(customer);
        }

    }
    @Test
    public void findByCustNameLikeAndCustIndustry() {
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("试试%", "教育1");
        System.out.println(customer);

    }
}
猴子不和你计较
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
四 Spring整合SpringDataJpa
fangguozi的专栏
05-11 174
本Spring Data系列的内容均是根据 百战程序员关于Sping Data视频 编写而成。 Spring Data JPA：是Spring Data项目下的一个模块。提供了一套基于JPA标准操作数据库的简化方案。底层默认的是依赖Hibernate JPA来实现的。 Spring Data JPA的技术特点：我们只需要定义接口并集成Spring Data JPA中所提供的接口就可以了，不需要...
整合Spring Data JPA1
08-03
- **集成事务管理**：与 Spring 的事务管理无缝集成，无需手动处理事务开始和结束。 - **多数据源支持**：可以方便地配置和管理多个数据源，实现数据隔离和读写分离。 **2. Spring Boot 整合 Spring Data JPA** - ...
Spring Boot整合JPA
最新发布
梁辰兴的博客
06-13 3861
创建文章仓库接口ArticleRepository/*** 功能：文章仓库接口* 日期：2023年06月13日* 作者：梁辰兴/*** 根据文章ID进行分页查询评论* nativeQuery = true, 表示使用原生SQL语句，否则使用HQL语句* @param aId 查询条件字段（文章编号）* @param pageable 可分页对象，分页查询需要该参数* @return 返回page对象，包含page的相关信息及查询结果集/*** 根据文章ID进行分页查询评论。
SpringBoot 一文搞懂Spring JPA
matafeiyanll的博客
05-06 1万+
一文搞懂Spring JPA 什么是 JPA spirng data jpa是spring提供的一套简化JPA开发的框架，按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。 Spring Data JPA 可以理解为 JPA 规范的再次封装抽象，底层还是使用了 Hibernate 的 JPA 技术实现。 Springboot整合SpringData JPA SpringData简介 整合Sp
JPA和Spring-Data-JPA简介
benjaminlee1的博客
11-08 2万+
什么是JPAJPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术 ORM：通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。本质就是将数据从一种形式转换到另外一种形式。 结束现在Hiberna
spring整合Jpa三种整合方式
一点一滴得积累
02-03 1453
1.Spring整合Jpa三种整合方式 - LocalEntityManagerFactoryBean：适用于那些仅使用 JPA 进行数据访问的项目，该 FactoryBean 将根据JPA PersistenceProvider 自动检测配置文件进行工作，一般从“META-INF/persistence.xml”读取配置信息，这种方式最简单，但不能设置 Spring 中定义的DataSourc
Spring和openJPA集成
08-06
Spring 和 OpenJPA 集成是企业级Java开发中常见的技术组合，主要用于构建数据持久化层。Spring 是一个强大的轻量级应用框架，而 OpenJPA 是一个开源的 Java Persistence API (JPA) 实现，它允许开发者将对象关系映射...
Spring Data JPA的优点和难点.pdf
12-05
Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发效率极高**： - Spring Data JPA通过提供自动化的 Repository 实现，减少了大量手动编写SQL和DAO层代码的...
详解spring boot jpa整合QueryDSL来简化复杂操作
08-27
详解Spring Boot JPA整合QueryDSL来简化复杂操作 在Spring Boot项目中，使用JPA（Java Persistence API）来进行数据库操作时，经常会遇到复杂的SQL查询问题，而QueryDSL正是用来简化JPA操作的。QueryDSL定义了一种...
SpringData和Spring和JPA的整合
07-28
**SpringData、Spring和JPA整合详解** 在Java企业级开发中，Spring框架因其强大的功能和灵活的架构设计，已经成为主流的开发选择。SpringData和JPA（Java Persistence API）则是Spring框架的重要扩展，用于简化数据...
Spring2.5整合JPA
03-17
Spring2.5整合JPA实例 博文链接：https://zmx.iteye.com/blog/556452
SpringBoot整合SpringDataJPA
热门推荐
青衫
05-23 15万+
一、SpringBootData JPA介绍   SpringData：其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。   SpringData JPA：基于JPA的标准数据进行操作。简化操作持久层的代码。只需要编写接口就可以。     二、SpringBoot整...
Spring整合JPA
浅瞳夜未的博客
01-06 2042
      如果我的博客能够帮到大家能够点个赞，关注一下，以后还会更新更过JavaWeb的高级技术，大家的支持就是我继续更新的动力。谢谢。           今天，来写一遍Spring整合JPA的Demo，Spring框架呢 是我们学习JavaWeb必学的一个框架，非常好用，而且支持对第三方框架的集成，所以在JavaWeb项目中用的比较多。JPA呢是Java Persistence AP...
spring JPA使用
核桃的专栏
06-30 465
如果项目中多数都是单表操作，那么jpa很适合你的项目。 jpa方便之处就是只声明接口，不需要实现接口（spring帮你来实现接口），实现开发者专注于业务开发。 举个栗子：public interface FirstDatasRepository extends JpaRepository<TDdtRptFirstDatas, Long> { List<TDdtRptFirstDatas>
JPA与Spring Data JPA
Ascend2015的博客
05-30 608
前言 这是在对慕课网的SpringBoot博客站实战课程学习中遇到JpaRepository接口时就想要写的，但是一直没动手，毕竟懒癌，最近延毕了，所以有点空闲时间就来开篇了。仅仅是匆忙地做个记录，还不清楚到底主旨是要表达什么，所以先用“JPA与Spring-data-Jpa”这个标题好了，后面可能再做修改。 1. JPA JPA是Java Persistence API的缩写，它的本质...
Spring Data JPA使用必备(一)：Spring Data JPA整合Spring以及简单的使用
IT-CRUD
03-16 923
最近公司部分新开的项目需要使用Spring data JPA技术，作为一个从来没有用过JPA的小白来说，需要重新的学习。N年前简单的看过JPA，这么多年没用过，完全忘记了有木有。接下来的系列文章就一起来整理一下。 本次的spring data jpa系列文章都是以spring boot整合为基础的。 Spring data JPA和Spring boot整合 Spring data JPA的介绍不说了，网上的说明很多，建议可以看一下程序员DD关于JPA的文章：Spring Boot中使用Spring-d
在构建maven项目中 <version>${spring.version}</version>含义
yinbucheng的博客
05-06 2万+
Maven的pom文件里，类似于这种版本号${spring.version} 是什么意思？ maven  pom   esolve 2016年12月17日提问 · 2016年12月17日更新 关注 3 关注 收藏 0 收藏，1.9k 浏览 问题对人有帮助，内容完整，我也想知道答案 0 问题没有实际价值，缺少关键内
SpringBoot系列(6)---SpringBoot-JPA
搞事情的博客
07-12 5万+
JPA 应该都熟悉了，我就不多说了什么是JPA了。目前JPA主要实现由hibernate和openJPA等。 Spring Data JPA 是Spring Data 的一个子项目，它通过提供基于JPA的Repository极大了减少了操作JPA的代码。笔者觉得这个由SpringBoot 提供的JPARepository真的是非常爽。基本上大部分的业务都可以满足了。 在Spring环境中需要配

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值