SpringData Hibernate JPA 使用案例 案例 （一）

已于 2024-05-06 14:42:45 修改
阅读量693 收藏 1
点赞数
分类专栏： SpringData springboot 文章标签： hibernate java spring 后端
于 2022-09-20 16:29:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50909707/article/details/126951253
版权

目录

一、Hibernate的基本操作

1、添加依赖

2、添加建表实体类

3、添加hibernate配置依赖

4、测试类

 二、SpringData实现JPA的功能

1、添加persistence.xml配置文件

 2、JPA测试

3、切换持久化单元的演示

 4、*HibernateJPI常见操作，测试案例*

一、Hibernate的基本操作

1、添加依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.2.RELEASE</version>
        <artifactId>spring-boot-starter-parent</artifactId>
        <relativePath/>
    </parent>

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <junit.version>4.13</junit.version>
        <hibernate.version>5.4.32.Final</hibernate.version>
        <mysql.version>5.1.22</mysql.version>
    </properties>

<dependencies>
        <!--hibernate对jpa的依赖包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--Mysql and MariaDB-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
<!--junit4-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2、添加建表实体类

hibernate可以通过实体类自动生成对应的表

package com.dragonwu.entity;


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author DragonWu
 * @date 2022-09-20 11:17
 **/
@Entity //作为hibernate的实体类
@Table(name="tb_customer")//映射的表名
public class Customer {

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

    @Column(name="cus_name",columnDefinition = "varchar(32) default null comment '客户名'")
    private String name;//客户名

    @Column(name="cus_address",length = 200)
    private String address;//客户地址

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

3、添加hibernate配置依赖

这里建议命名为hibernate.cfg.xml，我存放的目录在resource/hibernate/hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--配置数据库连接信息-->
        <property name="connection.url">jdbc:mysql://my-server:3306/test</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.username">root</property>
        <!-- 数据库的登陆密码 -->
        <property name="hibernate.connection.password">XXX</property>
        <!-- 指定连接数据库的编码 -->
        <property name="connection.characterEncoding">utf8</property>
        <!-- 指定数据库方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</property>
        <!-- 显示Hibernate持久化操作所生成的SQL -->
        <property name="show_sql">true</property>
        <!-- 将SQL脚本进行格式化后再输出 -->
        <property name="format_sql">true</property>
        <!-- 指定自动生成数据表的策略
        默认是none 不自动生成
        update 如果没有表会创建，有会检查更新
        create 每次运行都会创建新表-->
        <property name="hbm2ddl.auto">update</property>
        <!-- DB schema will be updated if needed -->
        <!-- 指定哪些实体类需要进行ORM映射 -->
        <mapping class="com.dragonwu.entity.Customer"/>

        <!--        &lt;!&ndash;使用xml来进行映射时书写如下&ndash;&gt;-->
        <!--        <mapping resource="hibernate.xml.Customer.xml"/>-->
    </session-factory>

</hibernate-configuration>

4、测试类

package com.dragonwu.test;

import com.dragonwu.entity.Customer;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

/**
 * @author DragonWu
 * @date 2022-09-20 12:52
 **/
public class HibernateTest {

    //Session工厂 Session:数据库会话 代码持久化操作数据库的一个桥梁
    private SessionFactory sf;

    @Before
    public void init() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate/hibernate.cfg.xml").build();

        //2、根据服务注册类持久一个元数据资源集，同时构建元数据并生成应用一般唯一的session工厂

        sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();
    }

    @Test
    public void testC() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            Customer customer = new Customer();
            customer.setName("DragonWu");

            session.save(customer);

            tx.commit();
        }
    }

    @Test
    public void testR() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            Customer customer = session.find(Customer.class, 1L);
            System.out.println("===================");
            System.out.println(customer);

            tx.commit();
        }
    }

    @Test
    public void testR_lazy() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            Customer customer = session.load(Customer.class, 1L);
            System.out.println("===================");
            System.out.println(customer);

            tx.commit();
        }
    }

    @Test
    public void testU() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            Customer customer = new Customer();
            customer.setId(1L);
            customer.setAddress("杭州");

            //session.save()插入
            //session.update()更新
            session.saveOrUpdate(customer);//存在id时更新，不存在id时创建

            tx.commit();
        }
    }

    @Test
    public void testD() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            Customer customer = new Customer();
            customer.setId(1L);

            session.remove(customer);

            tx.commit();
        }
    }

    @Test
    public void testR_HQL() {
        //session进行持久化操作
        try (Session session = sf.openSession()) {
            Transaction tx = session.beginTransaction();

            String hql = " FROM Customer where id=:id";

            List<Customer> resultList = session
                    .createQuery(hql, Customer.class)
                    .setParameter("id",2L)
                    .getResultList();
            System.out.println(resultList);

            tx.commit();
        }
    }
}

在对应连接里创建对应数据库，运行单元测试类testC

表已自动生成。 

单元测试testR

 单元测试testR_lazy懒加载，load懒加载当执行到对应查询时系统才会执行查询，而find会先执行查询。

 二、SpringData实现JPA的功能

用之前的hibernate，如果我们需要修改持久化层，需要修改很多配置以及代码，由此SpringData推出了JPA的功能。JPA同样是钟规范，需要依赖于他的实现。

1、添加persistence.xml配置文件

目录结构如图：

<?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="hibernateJPA" transaction-type="RESOURCE_LOCAL">

        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--需要进行ORM的实体类-->
        <class>com.dragonwu.entity.Customer</class>
        <!--可选配置：配置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="XXX"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>

            <!--配置jpa实现方（hibernate）的配置信息
                显示sql : false|true
                自动创建数据库表 ： hibernate.hbm2ddl.auto
                    create : 程序运行是创建数据库表（如果有表，先删除再创建）
                    update: 程序运行是创建表（如果有表，不会创建表）
                    none: 不会创建表-->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

 2、JPA测试

package com.dragonwu.test;

import com.dragonwu.entity.Customer;
import org.junit.Before;
import org.junit.Test;

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

/**
 * @author DragonWu
 * @date 2022-09-20 15:13
 **/
public class JPATest {

    EntityManagerFactory factory;

    @Before
    public void before(){
        factory= Persistence
                .createEntityManagerFactory("hibernateJPA");

    }

    @Test
    public void testC(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer = new Customer();
        customer.setName("龘龘");

        em.persist(customer);

        tx.commit();
    }
}

3、切换持久化单元的演示

添加另一种jpa的依赖

<!--openjpa-->
        <dependency>
            <groupId>org.apache.openjpa</groupId>
            <artifactId>openjpa-all</artifactId>
            <version>3.2.0</version>
        </dependency>

添加openjpa单元项后的persistence.xml文件

<?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="hibernateJPA" transaction-type="RESOURCE_LOCAL">

        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--需要进行ORM的实体类-->
        <class>com.dragonwu.entity.Customer</class>
        <!--可选配置：配置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="XXX"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>

            <!--配置jpa实现方（hibernate）的配置信息
                显示sql : false|true
                自动创建数据库表 ： hibernate.hbm2ddl.auto
                    create : 程序运行是创建数据库表（如果有表，先删除再创建）
                    update: 程序运行是创建表（如果有表，不会创建表）
                    none: 不会创建表-->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>

        </properties>
    </persistence-unit>

    <persistence-unit name="openJPA" transaction-type="RESOURCE_LOCAL">

        <!--jpa的实现方式-->
        <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>

        <!--需要进行ORM的实体类-->
        <class>com.dragonwu.entity.Customer</class>
        <!--可选配置：配置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="XXX"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>

            <!--配置jpa实现方（openjpa）的配置信息-->
            <!--可以自动生成数据库表-->
            <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
        </properties>
    </persistence-unit>
</persistence>

使用openJPA我们只需要改变单元项即可，代码耦合性很低，非常适合装配使用。

package com.dragonwu.test;

import com.dragonwu.entity.Customer;
import org.junit.Before;
import org.junit.Test;

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

/**
 * @author DragonWu
 * @date 2022-09-20 15:13
 **/
public class JPATest {

    EntityManagerFactory factory;

    @Before
    public void before(){
        factory= Persistence
                .createEntityManagerFactory("openJPA");

    }

    @Test
    public void testC(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer = new Customer();
        customer.setName("DragonWu Master");

        em.persist(customer);

        tx.commit();
    }
}

查看效果：可以看到两种不同的单元项都可以对数据库进行操作，而底层都是基于hibernate来实现的。

 4、*HibernateJPI常见操作，测试案例*

package com.dragonwu.test;

import com.dragonwu.entity.Customer;
import org.junit.Before;
import org.junit.Test;

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

/**
 * @author DragonWu
 * @date 2022-09-20 15:13
 **/
public class JPATest {

    EntityManagerFactory factory;

    @Before
    public void before(){
        factory= Persistence
                .createEntityManagerFactory("hibernateJPA");

    }

    @Test
    public void testC(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer = new Customer();
        customer.setName("DragonWu Master");

        em.persist(customer);

        tx.commit();
    }

    @Test
    public void testR(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer = em.find(Customer.class,4L);
        //find立即查询
        System.out.println("==============================");
        System.out.println(customer);

        tx.commit();
    }

    @Test
    public void testR_lazy(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer = em.getReference(Customer.class,4L);
        //load延时查询
        System.out.println("==============================");
        System.out.println(customer);

        tx.commit();
    }

    @Test
    public void testU(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer=new Customer();
        customer.setId(5L);
        customer.setName("Jack");

        //如果该id对应的数据存在则更新，否则添加；更新时会先查询是否有变化，若有变化才会更新
        em.merge(customer);

        tx.commit();
    }

    @Test
    public void testU_JPQL(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        //注意这里是类名
        String jpql="UPDATE Customer set name=:name where id=:id";
        em.createQuery(jpql)
                .setParameter("name","好人")
                .setParameter("id",5L)
                .executeUpdate();

        tx.commit();
    }

    @Test
    public void testU_SQL(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        //注意这里是表名
        String sql="UPDATE tb_customer set cus_name=:name where id=:id";
        em.createNativeQuery(sql)
                .setParameter("name","坏人")
                .setParameter("id",5L)
                .executeUpdate();

        tx.commit();
    }

    @Test
    public void testD(){
        EntityManager em=factory.createEntityManager();
        EntityTransaction tx=em.getTransaction();
        tx.begin();

        Customer customer=em.find(Customer.class,5L);
        //这里不支持删除游离态的对象
        em.remove(customer);

        tx.commit();
    }
}
Dragon Wu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Data JPA/Hibernate 运行期动态模型、动态实体建表、动态字段查询的方式
12-14
最近公司的低代码开发平台数据中心需要重构，需要在页面上创建表模型添加修改字段。涉及到动态生成表结构，动态生成模型实体类动态查询表字段等等，经过调研发现hibernate在这方面是很方便的，调用内置API就能完成系列操作，下面贴出核心代码： /** * @author cjbi */ public class DynamicDdlTest { @Autowired private EntityManager entityManager; /** * 运行期的持久化实体没有必要一定表示为像POJO类或JavaBean对象那样的形式。 * Hibernate也支持动态模
spring data jpa 案例
03-06
这个案例涵盖了如何使用Spring Data JPA来操作数据库，通过一些常见的API实现数据的CRUD（创建、读取、更新、删除）操作。下面将详细阐述Spring Data JPA的核心概念、功能以及案例中可能涉及的知识点。 1. **Spring...
Spring Data JPA + Hibernate + Mysql
hhujjj2005的博客
05-10 560
是一个开源的对象关系映射(ORM)框架，国外使用比较多，国内主要使用的mybatis。JPA只是一个ORM框架的规范, 对该规范的实现比较完整就是Spring Data JPA（底层基于Hibernate实现），是基于Spring的数据持久层框架，也就是说它只能用在Spring环境内。
SpringData JPA 快速入门案例详解
zp8126的专栏
03-19 1440
JPA（Java Persistence API）是 Java 持久层规范，定义了一些列 ORM 接口，它本身是不能直接使用的，因为接口需要实现才能使用，Hibernate 框架就是实现 JPA 规范的框架。
SpringData JPA的使用案例 基本操作1 （二）
qq_50909707的博客
09-21 380
这里我添加了一些自定义的jpql和sql查询的案例，当然在继承CrudRepository接口以后已经可以使用大量同样方法，在继续继承RagingAndSortingRepository后便可调用分页查询的接口。之前讲过JPA支持通过类来操作表，hibernate底层会自动生成对应的表。更多方法可以直接看继承接口源码。
springboot 整合 spring-data-jpa 案例-入门
段子手168的博客
03-17 275
springboot学习，spring学习,springboot 整合spring-data-jpa
Spring Data JPA 应用案例实现
丿涛哥哥的博客
07-15 246
Spring Data JPA 应用案例实现 需求：使用 Spring Data JPA 完成对 tb_resume 表（简历表）的Dao 层操作（增删改查，排序，分页等） 数据表设计 初始化Sql语句 SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for tb_resume -- ---------------------------- DROP TAB
Spring Data Jpa 介绍和详细入门案例搭建
不会骑摩托的程序员不是好的摄影师
09-25 504
Spring Data Jpa是 dao层的一个框架，简化数据库开发。 本文从jpa、orm的由来，和各种orm框架对比详细介绍spring data jpa。 并且从零到一，新建了一个完整的spring项目完成了常用的spring data jpa的使用按理。老铁们 入门足够了！
SpringDataJpa系列一之初识及入门案例搭建
程序员大航子
12-06 2732
本文章参考文档为《SpringDataJpa从入门到精通》 首先， 我觉得入门SpringDataJpa的话， 我们首先要理清楚。 JPA、Hibernate和SpringDataJpa的关系。 什么是JPA？ 全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。 但是它只是提供了一种规范， 而Hibernate...
Spring Data JPA 原理与实战第一天 JPA初识
fegus的博客
05-20 1038
开篇词 勇敢走出舒适区，突破自己的技术瓶颈 你好，我是张振华，在 Java 领域从业已有十几年，也算是一个“Java 老兵”，我曾先后在驴妈妈、携程等互联公司分别担任 Java 架构师、开发主管等职务。在电商公司工作期间，我负责过后端服务的平台架构、实现过微服务的升级，同时写过公司的很多核心框架，经历了很多人都会遇到的一些常见问题，积累并总结了一些可以复用和迁移的经验。 我是如何学习 Spring Data JPA 的？ 大概 4、5 年前，公司入职了一些架构师，引入了 Spring Data JPA 框
spring data jpa简单案例
08-12
Spring Data JPA 是 Spring 框架的一个模块，它为使用 JPA（Java Persistence API）提供了强大的支持，简化了数据访问层的开发。通过使用 Spring Data JPA，我们可以避免编写大量重复的 CRUD（创建、读取、更新、...
SpringDataJPADemo：JPA 框架知识案例
03-06
在本案例中，我们将探讨如何设置和使用 Spring Data JPA。 ### 1. 引入依赖 首先，我们需要在项目中引入 Spring Data JPA 的依赖。通常，这会在 Maven 或 Gradle 的构建文件中完成。例如，在 Maven 的 `pom.xml` ...
Spring-Boot-Hibernate-JPA:员工管理工具
05-11
本项目"Spring-Boot-Hibernate-JPA:员工管理工具"正是基于这些技术实现的一个实用案例，它通过REST API实现了对员工数据的创建、读取、更新和删除（CRUD）操作，为开发者提供了一个直观的实践平台。 首先，Spring ...
spring Spring MVC Hibernate 4.x 整合案例
01-16
分页查询的封装通常涉及到对查询结果的分组和分页处理，你可以使用Pageable接口或者Spring Data JPA的Page对象来实现这一功能。 最后，确保所有的配置文件（如applicationContext.xml、web.xml、pom.xml等）都已...
Spring Boot的数据访问之Spring Data JPA以及Hibernate的实战(超详细 附源码）
showswoller的博客
10-24 770
Spring Boot的数据访问之Spring Data JPA以及Hibernate的实战(超详细 附源码）包括一个简单的网页条件查询实例
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 675
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
java springboot 集成 阿里通义千问
最新发布
qq_25987725的博客
07-25 202
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
"高薪训练营1：Spring Data JPA详解与实战
学员将了解到Spring Data JPA是如何将接口方法转换成JPA查询语言的，以及Spring Data JPA是如何使用Hibernate来实现对数据库的操作的。通过了解这些原理和机制，学员可以更好地理解Spring Data JPA的使用方法，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值