1.pom依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5. <modelVersion>4.0.0</modelVersion>
  6.  
  7. <groupId>org.maple</groupId>
  8. <artifactId>spring-data-jpa</artifactId>
  9. <packaging>pom</packaging>
  10. <version>1.0-SNAPSHOT</version>
  11. <modules>
  12. <module>jpa-01</module>
  13. </modules>
  14.  
  15. <properties>
  16. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  17. <project.hibernate.version>5.0.7.Final</project.hibernate.version>
  18. </properties>
  19.  
  20. <dependencies>
  21. <!-- junit -->
  22. <dependency>
  23. <groupId>junit</groupId>
  24. <artifactId>junit</artifactId>
  25. <version>4.12</version>
  26. <scope>test</scope>
  27. </dependency>
  28.  
  29. <!-- hibernate对jpa的支持包 -->
  30. <dependency>
  31. <groupId>org.hibernate</groupId>
  32. <artifactId>hibernate-entitymanager</artifactId>
  33. <version>${project.hibernate.version}</version>
  34. </dependency>
  35.  
  36. <!-- c3p0 -->
  37. <dependency>
  38. <groupId>org.hibernate</groupId>
  39. <artifactId>hibernate-c3p0</artifactId>
  40. <version>${project.hibernate.version}</version>
  41. </dependency>
  42.  
  43. <!-- log日志 -->
  44. <dependency>
  45. <groupId>log4j</groupId>
  46. <artifactId>log4j</artifactId>
  47. <version>1.2.17</version>
  48. </dependency>
  49.  
  50. <!-- Mysql and MariaDB -->
  51. <dependency>
  52. <groupId>mysql</groupId>
  53. <artifactId>mysql-connector-java</artifactId>
  54. <version>5.1.6</version>
  55. </dependency>
  56.  
  57. <dependency>
  58. <groupId>org.projectlombok</groupId>
  59. <artifactId>lombok</artifactId>
  60. <version>1.18.4</version>
  61. </dependency>
  62. </dependencies>
  63.  
  64. <build>
  65. <plugins>
  66. <plugin>
  67. <groupId>org.apache.maven.plugins</groupId>
  68. <artifactId>maven-compiler-plugin</artifactId>
  69. <version>3.8.0</version>
  70. <configuration>
  71. <source>1.8</source>
  72. <target>1.8</target>
  73. </configuration>
  74. </plugin>
  75. </plugins>
  76. </build>
  77.  
  78. </project>

2.写配置文件 默认路径 resources/META-INF/persistence.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
  3. <!--需要配置persistence-unit节点
  4. 持久化单元:
  5. name:持久化单元名称
  6. transaction-type:事务管理的方式
  7. JTA:分布式事务管理
  8. RESOURCE_LOCAL:本地事务管理
  9. -->
  10. <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
  11. <!--jpa的实现方式 -->
  12. <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
  13.  
  14. <!--可选配置:配置jpa实现方的配置信息-->
  15. <properties>
  16. <!-- 数据库信息
  17. 用户名,javax.persistence.jdbc.user
  18. 密码, javax.persistence.jdbc.password
  19. 驱动, javax.persistence.jdbc.driver
  20. 数据库地址 javax.persistence.jdbc.url
  21. -->
  22. <property name="javax.persistence.jdbc.user" value="root"/>
  23. <property name="javax.persistence.jdbc.password" value="root"/>
  24. <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
  25. <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
  26.  
  27. <!--配置jpa实现方(hibernate)的配置信息
  28. 显示sql : false|true
  29. 自动创建数据库表 : hibernate.hbm2ddl.auto
  30. create : 程序运行时创建数据库表(如果有表,先删除表再创建)
  31. update :程序运行时创建表(如果有表,不会创建表)
  32. none :不会创建表
  33.  
  34. -->
  35. <property name="hibernate.show_sql" value="true" />
  36. <property name="hibernate.hbm2ddl.auto" value="update" />
  37. </properties>
  38. </persistence-unit>
  39.  
  40. </persistence>

3.写实体类,与表建立关联

  1. package org.maple.domain;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.ToString;
  7. import lombok.experimental.Accessors;
  8.  
  9. import javax.persistence.*;
  10.  
  11. /**
  12. * @author mapleins
  13. * @Date 2019-01-10 20:31
  14. * @Desc
  15. **/
  16. @Data
  17. @NoArgsConstructor
  18. @AllArgsConstructor
  19. @ToString
  20. @Accessors(chain = true)
  21. @Entity
  22. @Table(name = "cst_customer")
  23. public class Customer {
  24.  
  25. /**
  26. * @Id:声明主键的配置
  27. * @GeneratedValue:配置主键的生成策略
  28. * strategy
  29. * GenerationType.IDENTITY :自增,mysql
  30. * * 底层数据库必须支持自动增长(底层数据库支持的自动增长方式,对id自增)
  31. * GenerationType.SEQUENCE : 序列,oracle
  32. * * 底层数据库必须支持序列
  33. * GenerationType.TABLE : jpa提供的一种机制,通过一张数据库表的形式帮助我们完成主键自增
  34. * GenerationType.AUTO : 由程序自动的帮助我们选择主键生成策略
  35. * @Column:配置属性和字段的映射关系
  36. * name:数据库表中字段的名称
  37. */
  38. @Id
  39. @GeneratedValue(strategy = GenerationType.IDENTITY)
  40. @Column(name = "cust_id")
  41. private Long custId; //客户的主键
  42.  
  43. @Column(name = "cust_name")
  44. private String custName;//客户名称
  45.  
  46. @Column(name="cust_source")
  47. private String custSource;//客户来源
  48.  
  49. @Column(name="cust_level")
  50. private String custLevel;//客户级别
  51.  
  52. @Column(name="cust_industry")
  53. private String custIndustry;//客户所属行业
  54.  
  55. @Column(name="cust_phone")
  56. private String custPhone;//客户的联系方式
  57.  
  58. @Column(name="cust_address")
  59. private String custAddress;//客户地址
  60. }

4.创建工厂工具类

  1. package org.maple.util;
  2.  
  3. import javax.persistence.EntityManager;
  4. import javax.persistence.EntityManagerFactory;
  5. import javax.persistence.Persistence;
  6.  
  7. /**
  8. * 解决实体管理器工厂的浪费资源和耗时问题
  9. * 通过静态代码块的形式,当程序第一次访问此工具类时,创建一个公共的实体管理器工厂对象
  10. *
  11. * 第一次访问getEntityManager方法:经过静态代码块创建一个factory对象,再调用方法创建一个EntityManager对象
  12. * 第二次方法getEntityManager方法:直接通过一个已经创建好的factory对象,创建EntityManager对象
  13. */
  14. public class JpaUtils {
  15.  
  16. private static EntityManagerFactory factory;
  17.  
  18. static {
  19. //1.加载配置文件,创建entityManagerFactory
  20. factory = Persistence.createEntityManagerFactory("myJpa");
  21. }
  22.  
  23. /**
  24. * 获取EntityManager对象
  25. */
  26. public static EntityManager getEntityManager() {
  27. return factory.createEntityManager();
  28. }
  29. }

5.测试(CRUD)

  1. package org.maple.test;
  2.  
  3. import org.junit.Test;
  4. import org.maple.domain.Customer;
  5. import org.maple.util.JpaUtils;
  6.  
  7. import javax.persistence.EntityManager;
  8. import javax.persistence.EntityTransaction;
  9.  
  10. /**
  11. * @author mapleins
  12. * @Date 2019-01-10 20:34
  13. * @Desc
  14. **/
  15. public class JPATest {
  16.  
  17. /**
  18. * 测试保存 persist
  19. */
  20. @Test
  21. public void testSave(){
  22. EntityManager manager = JpaUtils.getEntityManager();
  23. EntityTransaction transaction = manager.getTransaction();
  24. transaction.begin();
  25. Customer customer = new Customer().setCustName("tom").setCustIndustry("抓猫公司");
  26. manager.persist(customer);
  27. transaction.commit();
  28. manager.close();
  29. }
  30.  
  31. /**
  32. * 根据id查询 find
  33. */
  34. @Test
  35. public void testFind(){
  36. EntityManager manager = JpaUtils.getEntityManager();
  37. Customer customer = manager.find(Customer.class, 1l);
  38. System.out.println(customer);
  39. }
  40.  
  41. /**
  42. * 根据id查询 getReference
  43. * 调用查询结果的属性才会发送,所以延迟查询
  44. */
  45. @Test
  46. public void testReference(){
  47. EntityManager manager = JpaUtils.getEntityManager();
  48. Customer customer = manager.getReference(Customer.class, 1l);
  49. System.out.println(customer);
  50. }
  51.  
  52. /**
  53. * 删除 remove
  54. * 需要先查出来再删
  55. */
  56. @Test
  57. public void testRemove(){
  58. EntityManager manager = JpaUtils.getEntityManager();
  59. EntityTransaction transaction = manager.getTransaction();
  60. transaction.begin();
  61. //先查后删
  62. Customer customer = manager.find(Customer.class, 1l);
  63. manager.remove(customer);
  64. transaction.commit();
  65. manager.close();
  66. }
  67.  
  68. /**
  69. * 更新 merge
  70. */
  71. @Test
  72. public void testMerge(){
  73. EntityManager manager = JpaUtils.getEntityManager();
  74. EntityTransaction transaction = manager.getTransaction();
  75. transaction.begin();
  76. //先查后更新
  77. Customer customer = manager.find(Customer.class, 2l);
  78. customer.setCustIndustry("抓老鼠公司");
  79. manager.merge(customer);
  80. transaction.commit();
  81. manager.close();
  82. }
  83.  
  84. }

6.jpa操作的操作步骤

1.加载配置文件创建实体管理器工厂
  Persisitence:静态方法(根据持久化单元名称创建实体管理器工厂)
  createEntityMnagerFactory(持久化单元名称)
  作用:创建实体管理器工厂

2.根据实体管理器工厂,创建实体管理器
  EntityManagerFactory :获取EntityManager对象
  方法:createEntityManager
  * 内部维护的很多的内容
  内部维护了数据库信息,
  维护了缓存信息
  维护了所有的实体管理器对象
  再创建EntityManagerFactory的过程中会根据配置创建数据库表
  * EntityManagerFactory的创建过程比较浪费资源
  特点:线程安全的对象
  多个线程访问同一个EntityManagerFactory不会有线程安全问题
  * 如何解决EntityManagerFactory的创建过程浪费资源(耗时)的问题?
  思路:创建一个公共的EntityManagerFactory的对象
  * 静态代码块的形式创建EntityManagerFactory

3.创建事务对象,开启事务
  EntityManager对象:实体类管理器
  beginTransaction : 创建事务对象
  presist : 保存
  merge : 更新
  remove : 删除
  find/getRefrence : 根据id查询

  Transaction 对象 : 事务
  begin:开启事务
  commit:提交事务
  rollback:回滚

4.增删改查操作
5.提交事务
6.释放资源

7.查询全部、分页查询、统计查询、条件查询、排序

  1. package org.maple.test;
  2.  
  3. import org.junit.Test;
  4. import org.maple.util.JpaUtils;
  5.  
  6. import javax.persistence.EntityManager;
  7. import javax.persistence.EntityTransaction;
  8. import javax.persistence.Query;
  9. import java.util.List;
  10.  
  11. /**
  12. * @author mapleins
  13. * @Date 2019-01-10 20:59
  14. * @Desc 查询全部、分页查询、统计查询、条件查询、排序
  15. **/
  16. public class JPATest2 {
  17.  
  18. /**
  19. * 查询全部
  20. */
  21. @Test
  22. public void findAll(){
  23. EntityManager manager = JpaUtils.getEntityManager();
  24. EntityTransaction transaction = manager.getTransaction();
  25. transaction.begin();
  26. //jpql
  27. String jpql = "from Customer";
  28. Query query = manager.createQuery(jpql);
  29. List resultList = query.getResultList();
  30. System.out.println(resultList);
  31.  
  32. transaction.commit();
  33. manager.close();
  34. }
  35.  
  36. /**
  37. * 查询全部 根据id 倒序
  38. */
  39. @Test
  40. public void findAllOrderById(){
  41. EntityManager manager = JpaUtils.getEntityManager();
  42. EntityTransaction transaction = manager.getTransaction();
  43. transaction.begin();
  44. //jpql
  45. String jpql = "from Customer order by custId desc ";
  46. Query query = manager.createQuery(jpql);
  47. List resultList = query.getResultList();
  48. System.out.println(resultList);
  49.  
  50. transaction.commit();
  51. manager.close();
  52. }
  53.  
  54. /**
  55. * 统计查询
  56. */
  57. @Test
  58. public void count(){
  59. EntityManager manager = JpaUtils.getEntityManager();
  60. EntityTransaction transaction = manager.getTransaction();
  61. transaction.begin();
  62. //jpql
  63. String jpql = "select count(*) from Customer";
  64. Query query = manager.createQuery(jpql);
  65. Object singleResult = query.getSingleResult();
  66. System.out.println(singleResult);
  67.  
  68. transaction.commit();
  69. manager.close();
  70. }
  71.  
  72. /**
  73. * 分页查询
  74. */
  75. @Test
  76. public void limit(){
  77. EntityManager manager = JpaUtils.getEntityManager();
  78. EntityTransaction transaction = manager.getTransaction();
  79. transaction.begin();
  80. //jpql
  81. String jpql = "from Customer";
  82. Query query = manager.createQuery(jpql);
  83. //分页
  84. query.setFirstResult(0); //从0开始查,包括0
  85. query.setMaxResults(2); //查询2条
  86. List resultList = query.getResultList();
  87. System.out.println(resultList);
  88.  
  89. transaction.commit();
  90. manager.close();
  91. }
  92.  
  93. /**
  94. * 条件查询
  95. * 查询名字带o的
  96. */
  97. @Test
  98. public void testCondition(){
  99. EntityManager manager = JpaUtils.getEntityManager();
  100. EntityTransaction transaction = manager.getTransaction();
  101. transaction.begin();
  102. //jpql
  103. String jpql = "from Customer where custName like ?";
  104. Query query = manager.createQuery(jpql);
  105. query.setParameter(1,"%o%");
  106. List resultList = query.getResultList();
  107. System.out.println(resultList);
  108.  
  109. transaction.commit();
  110. manager.close();
  111. }
  112. }

<Spring Data JPA>一 JPA原生的更多相关文章

  1. 一步步学习 Spring Data 系列之JPA(一)

    引入: Spring Data是SpringSource基金会下的一个用于简化数据库访问,并支持云服务的开源框架.其主要目标是使得数据库的访问变得方便快捷,并支持map-reduce框架和云计算数据服 ...

  2. 一步步学习 Spring Data 系列之JPA(二)

    继上一篇文章对Spring Data JPA更深( )一步剖析. 上一篇只是简单的介绍了Spring Data JPA的简单使用,而往往在项目中这一点功能并不能满足我们的需求.这是当然的,在业务中查询 ...

  3. Spring Data系列之Jpa(一)

    1.Spring Data的由来 Spring Data是SpringSource基金会创下的一个简化数据库访问.支持云服务的开源框架.其主要目的是让数据库访问变的方便快捷,可以用Spring Dat ...

  4. Spring Data Jpa+SpringMVC+Jquery.pagination.js实现分页

    本博客介绍基于Spring Data这款orm框架加上Jquery.pagination插件实现的分页功能. 介绍一下Spring Data框架 spring Data : Spring 的一个子项目 ...

  5. Spring Boot:整合Spring Data JPA

    综合概述 JPA是Java Persistence API的简称,是一套Sun官方提出的Java持久化规范.其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术,它为Java开发人员提供了一种 ...

  6. MongoDB分组汇总操作,及Spring data mongo的实现

    转载请在页首注明作者与出处 一:分组汇总 1.1:SQL样例 分组汇总的应用场景非常多,比如查询每个班级的总分是多少,如果用关系形数据库,那么sql是这样子的 ),class from score g ...

  7. spring data jpa使用原生sql查询

    spring data jpa使用原生sql查询 @Repository public interface AjDao extends JpaRepository<Aj,String> { ...

  8. Spring Data JPA进阶——Specifications和Querydsl

    Spring Data JPA进阶--Specifications和Querydsl 本篇介绍一下spring Data JPA中能为数据访问程序的开发带来更多便利的特性,我们知道,Spring Da ...

  9. Spring Data JPA初使用(转载)

    我们都知道Spring是一个非常优秀的JavaEE整合框架,它尽可能的减少我们开发的工作量和难度. 在持久层的业务逻辑方面,Spring开源组织又给我们带来了同样优秀的Spring Data JPA. ...

随机推荐

  1. poj2421【MST-prim+Kruskal】

    水过~~~~打好基础/~~ ------prim #include <iostream> #include <stdio.h> #include <string.h> ...

  2. unity ShaderLab 编辑器——sublime text 2

    sublime text 2,支持unity shader关键字高亮显示,智能提示功能.这个脚本编辑器的售价是70美元,不过作者很厚道地给了我们永久的免费试用期. 1)下载sublime text 2 ...

  3. 洛谷 P2578 [ZJOI2005]九数码游戏【bfs+康托展开】

    只有9!=362880个状态,用康托展开hash一下直接bfs即可 #include<iostream> #include<cstdio> #include<cstrin ...

  4. python 合集set,交集,并集,差集,对称差集别搞混

    有集合 x与y x = {1,2,3,4,5}y = {4,5,6,7,8} x和y的交集为 {4,5} x和y的对称差集{1, 2, 3, 6, 7, 8} x和y的并集{1, 2, 3, 4, 5 ...

  5. CIFAR10自定义网络实战

    目录 CIFAR10 MyDenseLayer CIFAR10 MyDenseLayer import os import tensorflow as tf from tensorflow.keras ...

  6. ssm框架下实现文件上传

      1.由于ssm框架是使用Maven进行管理的,文件上传所需要的jar包利用pom.xml进行添加,如下所示: <properties> <commons-fileupload.v ...

  7. 题解报告:hdu 2141 Can you find it?(二分)

    Problem Description Give you three sequences of numbers A, B, C, then we give you a number X. Now yo ...

  8. 利用VS自带的dotfuscator混淆代码的学习

    对于一些原创的敏感代码,我们可以通过简单的重命名混淆使得别人难以真正理解执行原理.这一点,使用VS自带的dotfuscator即可实现. 如上图所示,你可以自定义选择哪些类被排除重命名,内置的规则中, ...

  9. 新建cordova应用

    使用命令行(本例命令行均使用as或webstrom的命令行),在任意目录输入以下命令新建cordova应用 cordova create capp1 com.cesc.ewater.capp1 其中c ...

  10. 找不到draw9patch.bat?已经不用找了

    Google 已经因为 draw9patch 热门的原因,把它集成在 Android Studio 里面了, 你现在可以直接在 Android Studio 里直接打开编辑了.