Spring Data Jpa(2019_idea版),Hibernate增删改查操作

最新推荐文章于 2021-12-07 15:31:07 发布
最新推荐文章于 2021-12-07 15:31:07 发布
阅读量654 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq847196660/article/details/97815061
版权

1.创建项目工程，Maven导入相关坐标
在这里插入图片描述

<!-- 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>

2.写实体类，以及映射关系，属性相关的注解
在这里插入图片描述

/***
 * 客户的实体类
 *      配置映射关系
 *              1.实体类和表的映射关系
 * @Entity 声明实体类
 * @Table  配置实体类和表的映射关联
 *      name:配置数据库的名称
 *
 */
@Entity
@Table(name = "cst_customer")
public class Customer implements Serializable {
    /***
     * 2.实体类中属性和表中字段的映射关系
     * @Id 主键映射配置
     * @GeneratedValue:配置主键的生成策略
     *   strategy
     *    GenerationType.IDENTITY ：自增，mysql
     *    底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *    enerationType.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_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_address")
    private String custAddress;
    @Column(name = "cust_phone")
    private String custPhone;

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

    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 getCustIndustry() {
        return custIndustry;
    }
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustAddress() {
        return custAddress;
    }
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
}

3.配置Hibernate工厂，的配置文件，文件名称是固定的：persistence.xml ,配置文件路径也需要在 META-INF 文件夹下
在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit,
        自己理解：也就是配置文件搭建工厂对象，其中包括：
            1.Hibernate实现类  2.数据源   3.Hibernate 的可选配置信息
        持久化单元：
            name:持久化单元名称
            transaction-type：事务管理的方式
                JTA：分布是事务管理，相当于，不同的数据，在不同的服务器上
                RESOURCE_LOCAL：本地事务管理。所有数据都在一个服务器上
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式,配置Hibernate的数据库封装实现类-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--可选配置：配置jpa实现方式的配置信息-->
        <properties>
            <!--数据库信息,数据库4个字符串-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="123"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test"/>
            <!--配置jpa实现类Hibernate 的配置信息
                显示sql       ：false/true
                自动创建数据表： hibernate.hbm2ddl.auto
                    create: 程序运行时创建数据库表（如果有表，先删除表再创建）
                    update: 程序运行时创建表(如果有表，不会创建表)
                    none:   不会创建表
            -->
            <!--显示sql-->
            <property name="hibernate.show_sql" value="true"/>
            <!--程序运行时创建数据库表-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>

    </persistence-unit>

</persistence>

4.生成工厂工具类
在这里插入图片描述

public class JpaUtils {
    /***
     * 解决实体管理器工厂的浪费资源和耗时问题
     *      通过静态代码块的形式，当程序第一次访问工具类是，创建一个公共的实体管理器工厂对象
     *第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
     *第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
     */
    private static EntityManagerFactory factory;
    static {
//        1.加载配置工具类的时候，创建EntityManagerFactory 工厂对象
        factory = Persistence.createEntityManagerFactory("myJpa");
    }
//    调用管理器方法 获取EntityManager管理器对象
    public static EntityManager getEntityManager(){

        return factory.createEntityManager();
    }
}

5.通过单元测试，写增删改查的Jpa 测试类（不需要写sql）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class JpaTest {
    /**
     * 测试jpa的保存
     *      案例：保存一个客户到数据库中
     *      jpa的操作步骤
     *          1.加载配置文件创建实体工厂对象
     *          2.通过实体类获取管理器
     *          3.获取事务对象，开启事务
     *          4.完成增删改查操作
     *          5.提交事务
     *          6.释放资源
     */
    @Test
    public void testsave(){
        1.加载配置文件创建实体工厂对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        2.通过实体类获取管理器
//        EntityManager em= factory.createEntityManager();

            //注意通过工具类，得到管理器对象
        EntityManager em= JpaUtils.getEntityManager();
//        3.获取事务对象，开启事务
        EntityTransaction tx =  em.getTransaction();
        tx.begin();//开启对象
//        4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("穿天猴");
        customer.setCustIndustry("教育1");
        //保存
        em.persist(customer);//保存操作
        //5.提交事务
        tx.commit();
        //释放资源
        em.close();
//        factory.close(); 使用工具类后，得到管理器后，工厂对象就关闭了
    }

//    单查立即加载方法
    @Test
    public void fingbyid(){
        //注意通过工具类，得到管理器对象
        EntityManager em= JpaUtils.getEntityManager();
//        3.获取事务对象，开启事务
        EntityTransaction tx =  em.getTransaction();
        tx.begin();//开启对象
        //3.增删改查 -- 根据id查询客户
        /**
         * find : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = em.find(Customer.class, 1L);
        System.err.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();

    }
    //    单查延迟加载（懒加载）方法
    @Test
    public void fingbyidgetReference(){
        //注意通过工具类，得到管理器对象
        EntityManager em= JpaUtils.getEntityManager();
//        3.获取事务对象，开启事务
        EntityTransaction tx =  em.getTransaction();
        tx.begin();//开启对象
        //3.增删改查 -- 根据id查询客户
        /**
         * getReference : 延迟加载根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = em.getReference(Customer.class, 1L);
        System.err.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    //    删除方法
    @Test
    public void remove(){
        //注意通过工具类，得到管理器对象
        EntityManager em= JpaUtils.getEntityManager();
//        3.获取事务对象，开启事务
        EntityTransaction tx =  em.getTransaction();
        tx.begin();//开启对象
        //3.增删改查 -- 根据id查询客户
        /**
         * remove : 根据对象id 删除数据
         *      传实体类进去。
         */
        Customer customer = em.find(Customer.class, 2L);
        System.out.println(customer);
        em.remove(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();

    }

    //    更新数据方法
    @Test
    public void update(){
        //注意通过工具类，得到管理器对象
        EntityManager em= JpaUtils.getEntityManager();
//        3.获取事务对象，开启事务
        EntityTransaction tx =  em.getTransaction();
        tx.begin();//开启对象
        //3.增删改查 -- 根据id查询客户
        /**
         * merge : 根据对象，修改数据
         *      传实体类进去。
         */
        Customer customer = em.find(Customer.class, 3L);
        customer.setCustAddress("南来风");
        System.out.println(customer);
        em.merge(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();

    }
}

6.Jpql 语法方式做操作，跟sql有一些区别
在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述在这里插入图片描述

/**
 * 测试jqpl，语句查询
 */
public class JpqlTest {

    /**
     * 查询全部，from 类路径
     * jqpl：from cn.itcast.domain.Customer
     * sql：SELECT * FROM cst_customer
     */
    @Test
    public void testFindAll() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        String jpql = " from Customer";
        Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //发送查询，并封装结果集
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.print(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }


    /**
     * 排序查询： 倒序查询全部客户（根据id倒序）
     * sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
     * jpql：from Customer order by custId desc
     * <p>
     * 进行jpql查询
     * 1.创建query查询对象
     * 2.对参数进行赋值
     * 3.查询，并得到返回结果
     */
    @Test
    public void testOrders() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        String jpql = "from Customer order by custId desc";
        Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

        //发送查询，并封装结果集
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }


    /**
     * 使用jpql查询，统计客户的总数
     * sql：SELECT COUNT(cust_id) FROM cst_customer
     * jpql：select count(custId) from Customer
     */
    @Test
    public void testCount() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "select count(custId) from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值
        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        Object result = query.getSingleResult();

        System.out.println(result);

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }


    /**
     * 分页查询
     * sql：select * from cst_customer limit 0,2
     * jqpl : from Customer
     */
    @Test
    public void testPaged() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 分页参数
        //起始索引
        query.setFirstResult(0);
        //每页查询的条数
        query.setMaxResults(2);

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }


    /**
     * 条件查询
     * 案例：查询客户名称以‘传智播客’开头的客户
     * sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
     * jpql : from Customer where custName like ?
     */
    @Test
    public void testCondition() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer where custName like ? ";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 占位符参数
        //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
        query.setParameter(1, "传智播客%");

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for (Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }
}
U盘data
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用IDEA搭建的hibernate+Spring+SpringMVC架构实现增删改查等功能
05-15
原本是在eclipse下搭的，后来学习IDEA，又转到IDEA搭建的hibernate+Spring+SpringMVC架构实现增删改查等功能,和大家一起学习进步，不喜勿喷哦
2017 spring data jpa+spring4.2+springmvc+hibernate4.3 maven环境intellij idea增删改查实例
07-22
综上所述，这个实例提供了一个完整的Java Web开发环境，展示了如何使用Spring Data JPA、Spring 4.2、Spring MVC和Hibernate 4.3进行数据操作，以及如何利用Maven进行项目管理，同时借助IntelliJ IDEA提升开发效率。...
使用Idea开发工具Maven仓库构建Hibernate项目实现增删改查功能
weixin_46683845的博客
12-07 323
一、新建maven项目 二、导入hibernate跟连接mysql所需的依赖 三、创建实体类 四、创建与实体类互相映射的文件 五、创建hibernate配置文件 六、增删改查测试
Hibernate中JPA的简单使用，实现简单的对表的增删改查操作
BluewineY的博客
09-26 7082
Hibernate中可以通过.hbm.xml配置来完成表的创建，啰嗦麻烦。但是之后出现JPA注解。使用JPA注解，开发人员可以不用编写.hbm.xml文件，只需在持久化类中加JPA注解。相关的JPA注解如下：        1、@Entity //标识这个pojo是一个jpa实体         2、@Table(name = "users") //设置表名，指定表名为users     
一步步实现：JPA的基本增删改查CRUD（jpa基于hibernate）
山鹰的专栏
01-12 387
创建实体类 有关实体类中相关注解的说明  * @Table  标注类对应的表  * 若表名和类型相同时，省略@Table,比如类Users 和表 users;  * 若不相同时，必须有@Table，并设置name,为该类对应的表名。@Table(name="users")  *   * @Entity 标注实体  *   * @Id 标注id  *   * @Transient 标注该属性不做与...
SpringBoot +Jpa+ Hibernate+Mysql工程
weixin_34232363的博客
08-08 346
1 使用工具workspace-sts 3.9.5.RELEASE (1)新建一个SpringBoot 项目，选择加载项目需要的的组件。DevTools,JPA，Web,Mysql. Finish. 工程命名，项目创建成功。 （2）src/mian/java文件下放java文件，创建包，规范化命名。 config:程序入口 @SpringBootApplication@EntitySca...
filesystem-master_java_springdatajpa_springboot_hibernate_文件服务器_
10-03
标题 "filesystem-master_java_springdatajpa_springboot_hibernate_文件服务器_" 暗示了一个项目，它涉及使用Java技术栈，特别是Spring Data JPA、Spring Boot和Hibernate，来构建一个文件服务器。这个项目可能重点...
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
**Spring Data JPA** 是一个基于 **Java** 的开源框架，它是 **Spring Framework** 的一个模块，主要用于简化 **Java Persistence API (JPA)** 的使用。JPA 是 Java 平台上的一个标准，用于管理和持久化应用程序的...
Spring Boot中使用Spring-data-jpa实现数据库增删查改
08-31
总的来说，Spring Boot结合Spring Data JPA提供了一种高效、简洁的方式来处理数据库的增删查改操作。它减少了重复的代码，让开发者能更专注于业务逻辑，而不是数据库操作。这对于提升开发效率和代码质量有着显著的...
idea+maven+hibernate+springmvc+mysql 实现的增删改查小demo，适合新手
09-01
idea创建的maven项目，hibernate实现数据持久化，springmvc实现数据控制，适合新手学习，也可以用作初学idea的同学的参考。另附数据库。 idea创建的maven项目，hibernate实现数据持久化，springmvc实现数据控制，适合新手学习。另附数据库。
hibernate+jpa注解实现最简单的增删改查
05-13
hibernate+jpa注解实现最简单的增删改查，采用mysql数据库。解压后直接将/sql/jpa.sql导入数据库，再在myEclipse中导入即可。运行方式，如压缩包内图片所示
Hibernate的四种典型例子(增删改查)
06-14
简单明了,狠适合初学者看看
Hibernate基础：快速入门(6)：修改数据
知行合一 止于至善
12-12 5012
数据库的操作增删改查，或者CRUD是最常见的操作。这篇文章中介绍修改数据的方法
hibernate框架实例演示（增删改查）:
浮生若梦--JJ
10-02 5642
一:hibernate框架后台: 1、导入hibernate框架常用包 2、在src下创建配置文件(hibernate.cfg.xml) <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate
springboot jpa hibernate 实现动态查询
weixin_33873846的博客
05-17 407
2019独角兽企业重金招聘Python工程师标准>>> ...
Idea搭建Spring Boot框架，结合jpa实现增删改查
weixin_30851409的博客
03-25 246
　　Spring Boot出来很久了，也用了很久了，虽然用的时候也用的挺方便的，但毕竟那个框架不是自己搭的，再怎么运用也不如自己搭建个，在搭的过程中，还是踩了些小坑，下面则是搭建的过程： 　　打开idea，File--> New--> Project -->Maven -->Next --> Next -->Finish ...
Spring+Hibernate两种方法实现增删改查
nai598455803的专栏
03-20 933
首先，定义一个Customer的bean类，设置好Customer.hbm.xml文件。再定义好一个Dao接口。准备好一个jdbc.properties文件。     第一种方法： 在dao类中定义一个HibernateTemplate类的对象，用该对象调用HibernateTemplate模板封装好的方法，如下：   Java代码   /***   * hib
Jpa设置默认值约束
段占彪的博客
07-06 1122
使用SpringDataJpa设置字段的默认值约束的2种方式 1、修改建表时的列定义属性 @Column(columnDefinition="INT DEFAULT '1' COMMENT '状态，1：正常，0：冻结状态，2：删除'") private Integer status; 2、通过Hibernate(org.hibernate.annotations.ColumnDefault)下提供的注解进行设置默认值 @ColumnDefault("1") private Integer status;
IDEA下的Hibernate入门demo
的博客
05-11 715
Hibernate简介 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servl...
SpringMVC入门：实战增删改查操作详解
在Spring MVC框架中，'增删改查'通常指的是数据库操作中的四个基本操作：新增（Insert）、删除（Delete）、更新（Update）和查询（Read）。这些操作是Web应用程序开发中最常见的业务逻辑处理，特别是在使用Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值