SpringData-JPA入门

最新推荐文章于 2023-04-18 22:29:38 发布
最新推荐文章于 2023-04-18 22:29:38 发布
阅读量279 收藏
点赞数
分类专栏： Java 文章标签： JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_nowu/article/details/84667221
版权

1.导入JAR包

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>

    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>

2.配置JPA核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name：持久化单元名称
            transaction-type：事务管理的方式
                    JTA：分布式事务管理
                    RESOURCE_LOCAL：本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!-- 数据库信息
                用户名，javax.persistence.jdbc.user
                密码，  javax.persistence.jdbc.password
                驱动，  javax.persistence.jdbc.driver
                数据库地址   javax.persistence.jdbc.url
            -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

            <!--配置jpa实现方(hibernate)的配置信息
                显示sql           ：   false|true
                自动创建数据库表    ：  hibernate.hbm2ddl.auto
                        create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
                        update      ：程序运行时创建表（如果有表，不会创建表）
                        none        ：不会创建表

            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>
</persistence>

3.创建实体类 并加注解

package com.itheima.domain;

import javax.persistence.*;

/**
 * 客户的实体类
 *      配置映射关系
 *
 *
 *   1.实体类和表的映射关系
 *      @Entity:声明实体类
 *      @Table : 配置实体类和表的映射关系
 *          name : 配置数据库表的名称
 *   2.实体类中属性和表中字段的映射关系
 *
 *
 */
@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;//客户地址

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custPhone='" + custPhone + '\'' +
                ", custAddress='" + custAddress + '\'' +
                '}';
    }
}

4.编写工具类 ,方便后面测试

package com.itheima.utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 * 工具类得到
 */
public class JpaUtil {

    private static  EntityManagerFactory factory;
    static {
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取实体管理器
     * @return
     */
    public static  EntityManager getEntityManager(){
       return  factory.createEntityManager();
    }
}

5.测试(增删改)

package com.itheima.test;

import com.itheima.domain.Customer;
import com.itheima.utils.JpaUtil;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;


public class JpaTest {
    /**
     * 测试jpa的保存
     *      案例：保存一个客户到数据库中
     *  Jpa的操作步骤
     *     1.加载配置文件创建工厂（实体管理器工厂）对象
     *     2.通过实体管理器工厂获取实体管理器
     *     3.获取事务对象，开启事务
     *     4.完成增删改查操作
     *     5.提交事务（回滚事务）
     *     6.释放资源
     */

     //增加
    @Test
    public void JpaSava(){
        //1.加载配置文件创建工厂（实体管理器工厂）对象
       // EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        //EntityManager em = factory.createEntityManager();
        EntityManager em = JpaUtil.getEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();
        // 4.完成增删改查操作
        Customer ct=new Customer();

        ct.setCustName("哈登");
        ct.setCustAddress("美国休斯敦-火箭队");
        //保存操作
        em.persist(ct);
        //5.提交事务（回滚事务）
        transaction.commit();
        // 6.释放资源  从后到前
        em.close();

    }

    /**
     * 根据id查找
     */
    @Test
   public  void Jpafind(){
       //得到实体管理器
       EntityManager entityManager = JpaUtil.getEntityManager();
       //获取事务对象  开启事务
       EntityTransaction transaction = entityManager.getTransaction();
       transaction.begin();
       //查找
       Customer customer = entityManager.find(Customer.class, 2L);
       System.out.println(customer);
       entityManager.close();
   }

    /**
     * 修改 先查再修改
     */
    @Test
    public  void JpaUpdate(){
        //得到实体管理器
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象  开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //查找
        Customer customer = entityManager.find(Customer.class, 2L);
        customer.setCustName("保罗");
        entityManager.merge(customer);
        System.out.println(customer);
        entityManager.close();
    }

    /**
     * 删除
     */
    @Test
    public void JpaDel(){
        //得到实体管理器
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象  开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //查找
        Customer customer = entityManager.find(Customer.class, 2L);

        entityManager.remove(customer);
        transaction.commit();
        entityManager.close();

    }
}

5.2  查询

package com.itheima.test;

import com.itheima.utils.JpaUtil;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;

public class JPQLTest {
    /**
     * 查询全部
     */
    @Test
     public void findAllTest(){
         EntityManager entityManager = JpaUtil.getEntityManager();
      //获取事务对象 ,开启事务
         EntityTransaction transaction = entityManager.getTransaction();
         transaction.begin();
         String pql="from Customer";
         Query query = entityManager.createQuery(pql);
         List resultList = query.getResultList();
         for (Object o : resultList) {
             System.out.println(o);
         }
          transaction.commit();

          entityManager.close();
     }

     //分页查询
    @Test
    public void findPage(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象 ,开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        String pql="from Customer ";
        Query query = entityManager.createQuery(pql);
        query.setFirstResult(1);
        query.setMaxResults(2);
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }
        transaction.commit();

        entityManager.close();
    }

    //条件查询
    @Test
    public void  findByTj(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象 ,开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        String pql="from Customer where custName like  ? ";
        Query query = entityManager.createQuery(pql);
        query.setParameter(1,"%哈登%");
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);

        }
     transaction.commit();
        entityManager.close();
    }

    //统计查询
    @Test
    public void CountTest(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象 ,开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        String pql="select count (custName) from Customer where custName like ? ";
        Query query = entityManager.createQuery(pql);
        query.setParameter(1,"%哈登%");
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);

        }
        transaction.commit();
        entityManager.close();

    }

    //排序查询
   // SELECT * FROM cst_customer WHERE cust_name LIKE "%哈登%" ORDER BY cust_id DESC;
    @Test
    public void ordesTest(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //获取事务对象 ,开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        String pql=" from Customer where custName like ? order by custId DESC";
        Query query = entityManager.createQuery(pql);
        query.setParameter(1,"%哈登%");
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }
         transaction.commit();
        entityManager.close();

    }
}

 

Sun_nowU
关注
专栏目录
jpa获取数据库当前时间_java – 根据当前日期时间查询JPA实体实例...
weixin_39616379的博客
12-19 1006
我有一个实体类型有两个日期,startDate和endDate：import org.joda.time.DateTime;@Entitypublic class Thing {@Type(type = "org.jadira.usertype.dateandtime.joda.PersistentDateTime")private DateTime startDate;@Type(type = ...
最详细的Spring-data-jpa入门（一）
热门推荐
此成非彼诚博客
08-13 10万+
刚进公司，人生地不熟，偷偷藏着本《mybatis入土为安》，以为可以靠mybatis混的轻松点，谁知天有不测风云，大家用的是JPA。我这个小白没有听说过，全英文名叫，就是java持久化api，是SUN公司推出的一套基于的规范。持久化想必如雷贯耳，都0202年了，谁还不用个持久化框架啊，举起mybatis。ORM呢？全英文名为：对象关系映射，简单来说为了不用JDBC那一套原始方法来操作数据库，ORM框架横空出世（mybatis、hibernate等等）。...
JPA当中实现时间设置默认值(取当前时间)
qq_35272054的博客
05-30 8839
package com.example.springbootdemo; import lombok.Data; import org.hibernate.annotations.CreationTimestamp; import org.hibernate.annotations.UpdateTimestamp; import javax.persistence.*; import java...
SpringDataJpa
云别
11-18 581
SpringDataJpa概述 Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。 它提供了包括增删改查等在内的常用功能，且易于扩展 Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案 Sp...
springData-JPA知识点总结
perry1230的博客
05-04 416
前几天总结springboot，挺大牛说集成JPA比较不错，于是就拿过来试试！底层数据库操作笼统讲就是增删改查，例如JDBC模板，Hibernate,Mybaties,JPA。接下来尝试springBootJPA旅程1. @Column(nullable = false) 内容扩展unique=true是指这个字段的值在这张表里不能重复，所有记录值都要唯一，就像主键那样。nullable=fa...
SpringDataJpa入门
qq_40826752的博客
06-18 182
大家好，我是IT修真院上海分院第6期学员，一枚正直善良的JAVA程序员。今天给大家分享一下，SpringDataJpa的基本知识。一、背景介绍    JPA(Java Persistence API)是Sun官方提出的Java持久化规范。JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。它为Java开发人员提供了一种对象/关联映射工具来管理Jav...
Spring-data-jpa常用教程.pdf
12-18
### Spring-data-jpa 的核心知识点解析 #### 一、Spring-data-jpa 基本介绍 Spring-data-jpa 是 Spring 家族中的一个重要成员，它主要用于简化基于 Java Persistence API (JPA) 的数据访问层（DAO）的开发工作。...
spring-data-jpa-guide:spring-data-jpa-guide，Spring Data JPA实现，SpringDataJpa解决方案
04-29
SpringDataJpa之Hibernate5.0的Entity判断Dirty的过程 SpringDataJPA之Hibernate加载过程 高级用法学习资料： https://github.com/eugenp/tutorials/tree/master/spring-rest-query-language 源码说明： 源码太分散...
纯甘货，Spring-data-jpa详解，全方位介绍
m0_68850571的博客
06-01 3367
篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第三方插件整合，缓存，插件，最后会持续到mybatis的架构，源码解释，重点会介绍几个重要的设计模式，这样一个体系。
Spring-Data-Jpa关联查询
m0_68399617的博客
03-20 1649
依照SpringData的命名规则，对于两个有关联关系的对象的查询，可以通过方法名中“_”下划线类标识，也可以通过Spring-Data-Jpa命名规范查询，同时SpringDataJpa还支持用@Query注解定义在数据访问层接口的方法上实现查询，下面来看一个示例进行理解。 上一篇讲了Spring-Data-Jpa入门，这一篇来看一下Spring-Data-Jpa条件查询（基于上一篇Spring-Data-Jpa入门的项目中写的，配置文件没有任何改动，详情可以参考Spring-Data-Jpa入门）。 .
09_JPA详解_使用JPQL语句进行查询.zip
05-06
09_JPA详解_使用JPQL语句进行查询.zip 09_JPA详解_使用JPQL语句进行查询.zip
JPA动态sql的使用姿势
Y_hahaha的博客
04-18 5455
JPA动态sql的使用姿势
Spring Data Jpa 时间戳比较
lida1001的博客
12-29 9695
1.【背景】JAVA Instant介绍 Instant now = Instant.now(); 注意：通过这种方式获取的时间戳与北京时间相差8个时区（比北京时间小8个小时） 。Instant.now()使用的是UTC时间Clock.systemUTC().instant()。LocalDate、LocalDateTime 的now()方法使用的是系统默认时区 不存在Instant.now...
Spring Data JPA 介绍和使用
weixin_33860722的博客
03-11 553
本文参考了Spring Data JPA官方文档，引用了部分文档的代码。 Spring Data JPA是Spring基于Hibernate开发的一个JPA框架。如果用过Hibernate或者MyBatis的话，就会知道对象关系映射（ORM）框架有多么方便。但是Spring Data JPA框架功能更进一步，...
jpa获取数据库当前时间_基于当前日期+时间为实例查询JPA实体的最佳方式是什么？...
weixin_39672296的博客
12-19 665
我有了两个日期，的startDate和结束日期的实体类型：基于当前日期+时间为实例查询JPA实体的最佳方式是什么？import org.joda.time.DateTime;@Entitypublic class Thing {@Type(type = "org.jadira.usertype.dateandtime.joda.PersistentDateTime")private DateTim...
JPA查询时间(localdatetime)间隔数据问题
chentao866的博客
04-11 6367
1.需求mysql查询近7天数据 String strat = LocalDate.now()+" 24:00:00";//获取今天日期 LocalDateTime rightNow = LocalDateTime.parse(strat, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));//获取今天日期 LocalDateTime s
SpringData学习总结笔记
马哥私房菜
07-05 777
spring data jpa的hello world 1.配置数据源 &lt;!-- 配置数据源,数据库账户密码存放这个db.prop文件中 --&gt; &lt;context:property-placeholder location="classpath:db.prop"/&gt; &lt;context:component-scan base-pack...
Spring Data JPA 的基本使用
.
06-29 560
1JPA 是什么 JPA（Java Persistence API）是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象 / 关联映射工具来管理 Java 应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在 Hibernate、TopLink、JDO 等 ORM 框架各自为营的局面。 值得注意的是，JPA 是在充分吸收了现有的...
JPA当天时间范围查询
qq_34287953的博客
04-08 2304
LocalDateTime localDateTime = LocalDateTime.now(); //当日最小时间 LocalDateTime minTime = localDateTime.with(LocalTime.MIN); //当天最大时间 LocalDateTime maxTime = localDateTime.with(LocalTime.MAX);
spring-boot-starter-data-jpa 入门
最新发布
04-30
spring-boot-starter-data-jpa 是 Spring Boot 提供的一个快速开发 JPA 应用的起步依赖。它提供了一系列默认的配置和依赖，方便我们快速地使用 JPA 进行开发。 以下是入门步骤： 1. 添加依赖：在 pom.xml 文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 配置数据源：在 application.properties 或 application.yml 文件中配置数据库连接信息，例如： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 3. 创建实体类：创建一个用于映射数据库表的实体类，例如： ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Integer age; // 省略 getter 和 setter 方法 } ``` 4. 创建 Repository 接口：创建一个继承 JpaRepository 接口的 Repository 接口，例如： ```java public interface UserRepository extends JpaRepository<User, Long> { } ``` 5. 使用 Repository：在业务逻辑中使用 UserRepository 进行增删改查操作，例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public User save(User user) { return userRepository.save(user); } public User findById(Long id) { return userRepository.findById(id).orElse(null); } public List<User> findAll() { return userRepository.findAll(); } public void deleteById(Long id) { userRepository.deleteById(id); } } ``` 以上就是使用 spring-boot-starter-data-jpa 开发 JPA 应用的基本步骤。需要注意的是，该起步依赖默认使用 Hibernate 作为 JPA 的实现，因此需要添加 Hibernate 的相关依赖。同时，也可以根据需要进行自定义配置，例如配置 JPA 的缓存、事务管理等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值