精华内容
下载资源
问答
  • JPQL

    千次阅读 2019-08-09 08:04:59
    JPA JPQL

    JPQL全称Java Persistence Query Language

    基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言,旨在以面向对象表达式语言的表达式,将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的,可以被编译成所有主流数据库服务器上的SQL。

    其特征与原生SQL语句类似,并且完全面向对象,通过类名和属性访问,而不是表名和表的属性。

    查询全部

    /**
     * 查询全部
     *   jqpl:from cn.nobug.domain.Customer
     *   sql:SELECT * FROM cst_customer
     */
    @Test
    public void testFindAll() {
        //1.获取entityManager对象
        EntityManager em = JpaEnum.getEntityManager();
        //3.查询全部
        String jpql = "from Customer ";
        Query query = em.createQuery(jpql);//创建Query查询对象,query对象才是执行jpql的对象
        //发送查询,并封装结果集
        List list = query.getResultList();
        list.forEach(System.out::println);
        //5.释放资源
        em.close();
    }

    排序查询 

    /**
     * 排序查询: 倒序查询全部客户(根据id倒序)
     *   sql:SELECT * FROM cst_customer ORDER BY cust_id DESC
     *   jpql:from Customer order by custId desc
     *
     * 进行jpql查询
     *   1.创建query查询对象
     *   2.对参数进行赋值
     *   3.查询,并得到返回结果
     */
    @Test
    public void testOrders() {
        //1.获取entityManager对象
        EntityManager em = JpaEnum.getEntityManager();
        //3.查询全部
        String jpql = "from Customer order by custId desc";
        Query query = em.createQuery(jpql);//创建Query查询对象,query对象才是执行jqpl的对象
        //发送查询,并封装结果集
        List list = query.getResultList();
        list.forEach(System.out::println);
        //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 = JpaEnum.getEntityManager();
        //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);
        //5.释放资源
        em.close();
    }

    分页查询

    /**
     * 分页查询
     *   sql:select * from cst_customer limit 0,2
     *   jqpl : from Customer
     */
    @Test
    public void testPaged() {
        //1.获取entityManager对象
        EntityManager em = JpaEnum.getEntityManager();
        //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();
        list.forEach(System.out::println);
        //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 = JpaEnum.getEntityManager();
        //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();
        list.forEach(System.out::println);
        //5.释放资源
        em.close();
    }

     

    展开全文
  • jpql

    2019-09-24 00:21:51
    1 jpql 1.1 jpql和sql有区别 (1)jpql操作对象和对象里面的属性 sql操作 表 和表里面的列 区分大小写 (2)在jpql里面 不能出现 * ,不能出现表名 (3) jpql和sql 他们关键字是相同 ,关键字不区分大小写 1.2 jpql的...

    1 jpql

    1.1 jpql和sql有区别

    (1)jpql操作对象和对象里面的属性 sql操作 表 和表里面的列 区分大小写

    (2)在jpql里面 不能出现 * ,不能出现表名

    (3) jpql和sql 他们关键字是相同 ,关键字不区分大小写

    1.2 jpql的语法

    jpql一般查询
    1
    ​select o.name,o from 类 o where o.属性名

    1.3 jpql里面join

    jpql:
    select o from Employee o join o.department d

    1.4jpql的数据计算

    jpql里面不能使用没有* 所以没有count(*)用的是size(最终换成sql的count查询)

    select o from Department o where o.employees.size>0

    .

    1.5jpql的分页查询

    String jpql = “select o from Employee o”;
    Query query = entityManager.createQuery(jpql);
    // 从那里开始取数据,索引从0开始
    int firstResult = (currentPage - 1) * pageSize;
    // 取多少条
    int maxResults = pageSize;
    query.setFirstResult(firstResult).setMaxResults(maxResults);

    2. 事务4个特性ACID回顾

    原子性(atomic),事务必须是原子工作单元;对于其数据修改,要么全都执行,要么全都不执行
    一致性(consistent),事务在完成时,必须使所有的数据都保持一致状态。
    隔离性(insulation),由事务并发所作的修改必须与任何其它并发事务所作的修改隔离。
    持久性(Duration),事务完成之后,它对于系统的影响是永久性的。

    2.1事务并发

    通常为了获得更好的运行性能,各种数据库都允许多个事务同时运行,这就是事务并发。

    当并发的事务访问或修改数据库中相同的数据(同一行同一列)时,通常需要采取必要的隔离机制。隔离机制的实现必须使用锁

    JPA只能处理第一、二类丢失更新,其他3种必须由数据库自己处理

    如果使用了悲观锁(加了一个行锁),如果事务没有被释放,就会造成其他事务处于等待
    不用

    乐观锁的配置
    @Version
    private Integer version

    3.如何优化JPA

    1.使用双向一对多关联,不使用单向一对多–效率高一点
    2.灵活使用单向多对一关联 --多方来维护效率高一点
    3.不用一对一,用多对一取代(不要使用共享主键一对一,使用唯一外键一对一)
    4.配置对象二级缓存(配置 Cacheable),查询缓存(jpql查询),
    没有查询条件才使用查询缓存(如果有条件命中是很低)
    5.组合关系集合使用list(顺序,重复)–第二个项目 单据模块,多对多集合使用set
    6.表字段要少,表关联不要怕多,有二级缓存撑腰,设计表尽量达到第三范式(外键)

    展开全文
  • JPA JPQL

    2021-07-23 09:45:59
    JPA JPQL 一、JPA简介 JPQL语言,即 Java Persistence Query Language 的简称。JPQL 是一种和 SQL 非常类似的中间性和对象化查询语言,它最终会被编译成针对不同底层数据库的 SQL 查询,从而屏蔽不同数据库的差异。...

    JPA JPQL

    一、JPA简介

    JPQL语言,即 Java Persistence Query Language 的简称。JPQL 是一种和 SQL 非常类似的中间性和对象化查询语言,它最终会被编译成针对不同底层数据库的 SQL 查询,从而屏蔽不同数据库的差异。如果会hibernate的hql查询,那么jpql会上手的很快。
    JPQL语言的语句可以是 select 语句、update 语句或delete语句,它们都通过 Query 接口封装执行。
    Query接口封装了执行数据库查询的相关方法。调用 EntityManager 的 createQuery、create NamedQuery 及 createNativeQuery 方法可以获得查询对象,进而可调用 Query 接口的相关方法来执行查询操作。

    二、实体类

    user类

    package com.kuang.pojo;
    
    import org.hibernate.annotations.Generated;
    
    import javax.persistence.*;
    import java.util.Date;
    
    @NamedQuery(name = "namedUser",query = "from User where id>?")
    @Cacheable(true)
    @Table(name = "User_01")
    @Entity
    public class User {
        private int id;
        private String name;
        private int age;
        private Date Birth;
        private boolean sex;
    
        @GeneratedValue(strategy=GenerationType.AUTO)
        @Id
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Date getBirth() {
            return Birth;
        }
    
        @Temporal(value = TemporalType.DATE )
        public void setBirth(Date birth) {
            Birth = birth;
        }
    
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", Birth=" + Birth +
                    ", sex=" + sex +
                    '}';
        }
    
        public boolean isSex() {
            return sex;
        }
    
        public void setSex(boolean sex) {
            this.sex = sex;
        }
    }
    

    学生类

    package com.kuang.pojo;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name = "JPA_STUDENT")
    public class Student {
        private Integer id;
        private String lastName;
        private Boolean sex;
        private Integer age;
        private Teacher teacher;
    
    
        @JoinColumn(name = "TEACHER_ID")
        @ManyToOne(fetch = FetchType.LAZY)
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        @Id
        @GeneratedValue
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        @Column(name = "LAST_NAME")
        public String getLastName() {
            return lastName;
        }
    
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    
        public Boolean getSex() {
            return sex;
        }
    
        public void setSex(Boolean sex) {
            this.sex = sex;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    

    二、JPQL的三种查询

    1、createNamedQuery

    根据实体类@NamedQuery(name = “namedUser”,query = “from User where id>?”)

    2、createQuery

    创建Query, 可以根据对象查询sql

    3、createNativeQuery

    根据本地sql 查询

    测试

    package com.kuang.test;
    
    import com.kuang.pojo.Student;
    import com.kuang.pojo.User;
    import org.hibernate.ejb.QueryHints;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import javax.persistence.*;
    import java.util.List;
    
    public class TestJPQL {
    
        private EntityManagerFactory entityManagerFactory;
        private EntityManager entityManager;
        private EntityTransaction transaction;
    
        @Before
        public void init(){
            entityManagerFactory= Persistence.createEntityManagerFactory("jpaHello");
            entityManager = entityManagerFactory.createEntityManager();
            transaction= entityManager.getTransaction();
            transaction.begin();
        }
    
        @After
        public void destroy(){
            transaction.commit();
            entityManager.close();
            entityManagerFactory.close();
        }
    
        @Test
        public void testJPQL(){
            // sql语句
            String sql="from User";
            // 创建Query对象
            Query query = entityManager.createQuery(sql);
            // 
            List<User> resultList = query.getResultList();
    
            for (User user : resultList) {
                System.out.println(user.getName());
            }
    
        }
    
        @Test
        public void testJPQL01(){
            String sql="from User where id=?";
            Query query = entityManager.createQuery(sql);
            query.setParameter(1,1);
            User user = (User) query.getSingleResult();
    
            System.out.println(user.getName());
        }
    
        @Test
        public void testJQOLNamed(){
            Query query = entityManager.createNamedQuery("namedUser");
            query.setParameter(1, 0);
            List<User> list = query.getResultList();
    
            for (User user : list) {
                System.out.println(user.getName());
            }
        }
    
        @Test
        public void testJQOlNative(){
            String jpql="select * from user_01";
            Query query = entityManager.createNativeQuery(jpql);
            List list = query.getResultList();
            for (Object o : list) {
                System.out.println(o);
            }
        }
    
        @Test
        public void testCache(){
            Query query = entityManager.createNamedQuery("namedUser").setHint(QueryHints.HINT_CACHEABLE,true);
            query.setParameter(1, 0);
            List<User> list = query.getResultList();
    
            for (User user : list) {
                System.out.println(user.getName());
            }
    
            query = entityManager.createNamedQuery("namedUser").setHint(QueryHints.HINT_CACHEABLE,true);
            query.setParameter(1, 0);
            list = query.getResultList();
            System.out.println(list.size());
        }
    
        @Test
        public void leftTest(){
            String sql="from Student stu left outer join fetch stu.teacher  where stu.id =?";
            Query query = entityManager.createQuery(sql);
            query.setParameter(1,1);
    
            List<Student> list = query.getResultList();
    
            for (Student student : list) {
                System.out.println(student.getLastName());
                System.out.println(student.getTeacher().getName());
            }
        }
    
        @Test
        public void fucntionTest(){
            String sql=" from Student stu left outer join fetch stu.teacher  where stu.id =?";
            Query query = entityManager.createQuery(sql);
            query.setParameter(1,1);
    
            List<Student> list = query.getResultList();
    
            for (Student student : list) {
                System.out.println(student.getLastName());
                System.out.println(student.getTeacher().getName());
            }
        }
    
        @Test
        public void testRemove(){
            String jpql="update Student stu set stu.lastName =? where stu.id =? ";
            Query query = entityManager.createQuery(jpql);
            query.setParameter(1,"HaHA");
            query.setParameter(2,1);
            query.executeUpdate();
        }
    }
    

    四、增删改

    query 对象的增删改可以通过executeUpdate来进行

      @Test
        public void testRemove(){
            String jpql="update Student stu set stu.lastName =? where stu.id =? ";
            Query query = entityManager.createQuery(jpql);
            query.setParameter(1,"HaHA");
            query.setParameter(2,1);
            query.executeUpdate();
        }
    
    展开全文
  • 绩效测试JPQL 真实的睾丸残渣或残渣 2019-09-19 20:40:21.454 INFO 25798 --- [ main] com.bycasseb.jpql.JPQLTests : 43:796000000 : Implícito 2019-09-19 20:40:21.455 INFO 25798 --- [ main] ...
  • JPQL 查询

    2018-12-28 17:29:17
    一、什么是JPQL 在 Java EE 中,JPQL( Java 持久性查询语言)是专门为Java 应用程序访问和导航实体实例设计的。JPQL是EJB2使用的查询语言EJB QL的扩展,它继承了EJB QL并对其做了一些改变。 二、JPQL与SQL ...

    一、什么是JPQL

    在 Java EE 中,JPQL( Java 持久性查询语言)是专门为Java 应用程序访问和导航实体实例设计的。JPQL是EJB2使用的查询语言EJB QL的扩展,它继承了EJB QL并对其做了一些改变。

     

    二、JPQL与SQL

    JPQL 和 SQL 有很多相似之处。归根结底,它们都用于访问和操作数据库数据。而且,二者都使用非过程语句 — 通过特殊解释程序识别的命令。此外,JPQL 在语法上与 SQL 也相似。

    JPQL 和 SQL 的主要区别在于,前者处理 JPA 实体,后者直接在数据库空间内对表、列、行等关系数据进行处理。

     

    三、使用JPQL

    要从 Java 代码内发出 JPQL 查询,您需要利用 EntityManager API 和 Query API 的相应方法,执行以下一般步骤:

    1.   使用注入或通过 EntityManagerFactory 实例获取一个 EntityManager 实例。

    2.   通过调用相应 EntityManager 的方法(如 createQuery),创建一个 Query 实例。

    3.   如果有查询参数,使用相应 Query 的 setParameter 方法进行设置。

    4.   如果需要,使用 setMaxResults 和/或 setFirstResult Query 的方法设置要检索的实例的最大数量和/或指定检索的起始实例位置。

    5.   如果需要,使用 setHint Query 的方法设置供应商特定的提示。

    6.   如果需要,使用 setFlushMode Query 的方法设置查询执行的刷新模式,覆盖实体管理器的刷新模式。

    7.   使用相应 Query 的方法 getSingleResult 或 getResultList 执行查询。如果进行更新或删除操作,您必须使用 executeUpdate 方法,它返回已更新或删除的实体实例的数量。

    JPQL的查询可以分为命名查询和动态查询。

    动态查询

    可以使用EntityManager.createQuery方法创建动态查询,唯一的要求是把合法的JPQL语句传递给此方法。如下:

    Query query = em.createQuery(“select p from Person p where p.id=1033”);

    其中where语句可是可选的。在这里JPQL看上去和SQL语句很像,但应当注意到的是from后边的Person是实体Bean而不是数据表。

    在所写的JPQL语句中你可以像示例中那样的直接将查询条件写在语句中。但是还有更好的方法。在这里你可以使用设置查询参数的方式,其中又有位置参数和命名参数的分别。

    使用位置参数如下所示:

    Query query = em.createQuery(“select p from Person p where p.id=?1”);

    Query.setParameter(1, 1033);//第一个参数是位置,第二个参数查询条件

    使用命名参数如下所示:

    Query query = em.createQuery(“select p from Person p where p.id=:id”);

    Query.setParameter(“id”, 1033);//第一个参数是参数名称,第二个参数查询条件

    需要注意的是位置参数的是位置前加符号”?”,命名参数是名称前是加符号”:”。

    如果你需要传递java.util.Date或java.util.Calendar参数进一个参数查询,你需要使用一个特殊的setParameter()方法。因为一个Date或Calendar对象能够描述一个真实的日期、时间或时间戳.所以我们需要告诉Query对象怎么使用这些参数,我们把javax.persistence.TemporalType作为参数传递进setParameter方法,告诉查询接口在转换java.util.Date或java.util.Calendar参数到本地SQL时使用什么数据库类型。

    查询结果

    使用Query. getSingleResult方法得到查询的单个实例,返回Object。要确保使用此方法时查询只检索到一个实体。

    使用Query. getResultList方法得到查询的实例集合,返回List。

    通常的,我们会如示例中所示的是获取查询返回的是实体,但是在JPQL里我们也可以得到实体的部分属性,就如同使用SQL得到表中的部分列一样。如果是获取部分属性的话,Query.getResultList方法返回的会是Object数组的List每个Object数组项相当于是一条结果,数组的成员是属性值,顺序和所写的JPQL中的SELECT中所写顺序一致。

    查询中使用构造器(Constructor)

    可以在SELECT子句中使用构造器返回一个或多个java实例。如下所示:

    Query query = em.createQuery("select new com.demo.bean.Person(p.id, p.name) from Person p order by p.id desc");

     

    查询分页

    JPA提供了在结果集合中使用分页的功能,使用这个功能我们可以轻松的达到对查询结果分页的目的。如下

    Query.setMaxResults(10);//设置分页大小,在这里为每页10条记录

    Query.setFirstResult(10);//指定第一个结果的位置。这里是指定第11条作为起始结果。

    这里只要在setFirstResult中使用动态参数即可方便的对结果进行分页了。

    使用操作符

    在where子句中我们可以使用一些操作符来进行条件的选择。

    NOT操作符

    select p from Person p where not(p.id = 1036)

    //查询id不是1036的所有人

    BETWEEN操作符

    select p from Person p where p.age between 20 and 26

    //查询年龄在20到26的所有人;上限和下限必须是相同的数据类型

    IS  NULL操作符

    select p from Person p where p.name is not null

    //查询名字不为NULL的所有人

    IS  EMPTY操作符

    IS EMPTY是针对集合属性(Collection)的操作符。可以和NOT 一起使用。注:低版权的Mysql 不支持IS EMPTY

    select p from Person p where p.interest is empty

    //查询兴趣(是集合)是空的所有人

    IN 操作符

    select p from Person p where p.id in (101,102)

    //查询id是101和102的人

    EXISTS 操作符

    [NOT]EXISTS 需要和子查询配合使用。注:低版权的Mysql 不支持EXISTS

    select p from Person p where exists (select b from Book b where b.name like ‘%EJB%’ )

    //如果书籍名字中包含有EJB字样,则得到所有人

    MEMBER OF操作符

    可以使用MEMBER OF操作符检查集合-值路径表达式中是否存在标识符变量、单一值表达式或是输入参数。

    select p from Person p where :interest member of p.interest

    //查询兴趣(是集合)是中包含所输入的兴趣实体实例(:interest)的所有人

    使用字符串函数

    JPQL定义了内置函数方便使用。这些函数的使用方法和SQL中相应的函数方法类似。包括:

    1. CONCAT 字符串拼接

    2. SUBSTRING 字符串截取

    3. TRIM 去掉空格

    4. LOWER 转换成小写

    5. UPPER 装换成大写

    6. LENGTH 字符串长度

    7. LOCATE 字符串定位

    使用算术函数

    JPQL仅仅支持了最低限度的算术函数集合,可以在JPQL的where和having子句中使用算术函数。JPQL定义的算术函数包括:

    ABS 绝对值

    SQRT 平方根

    MOD 取余数

    SIZE 取集合的数量

    使用时间函数

    JPQL像大多数语言一样提供了获得当前日期、时间或是时间标记的函数。这些函数转换为数据库专有的SQL函数,从数据库检索当前日期、时间或时间标记。包含的时间函数如下:

    CURRENT_DATE 返回当前日期

    CURRENT_TIME 返回当前时间

    CURRENT_TIMESTAMP 返回当前时间标记

           联结(连接/关联)

           JPQL仍然支持和SQL中类似的关联语法:

           left out join/left join

           left out join/left join等,都是允许符合条件的右边表达式中的Entities 为空(需要显式使用left join/left outer join 的情况会比较少。)

           inner join

           inner join 要求右边的表达式必须返回Entities。

           left join fetch/inner join fetch

           在默认的查询中,Entity中的集合属性默认不会被关联,集合属性默认是延迟加载( lazy-load )。那么,left fetch/left out fetch/inner join fetch提供了一种灵活的查询加载方式来提高查询的性能(集合属性被关联,同Entity同时加载而不是在需要时再加载,这样就转换为SQL语句时为一条SQL语句,而不是加载Entity时一条语句,加载集合属性时有N(等于Entity数量)条语句,避免了N+1问题,提高了查询性能)。

    使用聚合函数

    JPQL提供的聚合函数有AVG、COUNT、MAX、MIN、SUM。在AVG、MAX、MIN、SUM函数中只能使用持久化字段,而在COUNT中可以使用任何类型的路径表达式或标识符。

    COUNT返回的类型是Long,AVG是Double,SUM可能返回Long或Double。

    分组

    如果聚合函数不是select...from的唯一一个返回列,需要使用"GROUP BY"语句。"GROUP BY"应该包含select 语句中除了聚合函数外的所有属性。如果还需要加上查询条件,需要使用"HAVING"条件语句而不是"WHERE"语句

    select p.grade, count(p) from Person p where p.age > 20 group by p.grade having count(*)>120

    //返回年龄大于20的各年级的总人数(人数大于120)

    排序

    在JPQL中像SQL一样使用order by 来进行排序。"ASC"和"DESC"分别为升序和降序,JPQL中默认为ASC升序。

    批删除和批更新

    JPQL支持批量删除和批量更新的操作。和查询相同的是也是要使用EntityManager.createQuery方法来创建一个Query实例,不同的是在这里要使用Query.executeUpdate方法来直行删除和更新,该方法返回的值是操作的记录数。

     

    命名查询

    可以在实体bean上通过@NamedQuery or @NamedQueries预先定义一个或多个查询语句,减少每次因书写错误而引起的BUG。通常把经常使用的查询语句定义成命名查询。

     

    定义单个命名查询:

    @NamedQuery(name="getPerson", query= "select p from  Person p where p.id=?1")

    @Entity

    public class Person implements Serializable{

     

    如果要定义多个命名查询,应在@javax.persistence.NamedQueries里定义@NamedQuery:

    @NamedQueries({

    @NamedQuery(name="getPerson", query= "select p from  Person p where p.id=?1"),

    @NamedQuery(name="getPersonList", query= "select p from Person as p where p.age>?1")

    })

    @Entity

    public class Person implements Serializable{

     

    当命名查询定义好了之后,我们就可以通过名称执行其查询。代码如下:

    Query query = em.createNamedQuery("getPerson");

    query.setParameter(1, 1);

     

     

    四、注意

     

    1.       JPQL语句的大小写敏感性:除了Java 类和属性名称外,查询都是大小写不敏感的。

    2.       使用参数查询的时候除了基本类型的参数还可以使用实体参数。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,486
精华内容 2,994
关键字:

jpql