Spring Data JPA 4.方法定义规范

忘是亡心i 2022-05-21 09:58 158阅读 0赞

# 方法定义规范 #

## 简单条件查询 ##

*  简单条件查询: 查询某一个实体类或者集合
 *  按照 Spring Data 的规范，查询方法以 find | read | get 开头， 涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。
 *  例如：定义一个 Entity 实体类 :

class User｛ 
            private String firstName; 
            private String lastName;
             ｝

使用And条件连接时，应这样写： f`indByLastNameAndFirstName(String lastName,String firstName);` 条件的属性名称与个数要与参数的位置与个数一一对应

## 支持的关键字 ##

直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，目前支持的关键字写法如下：

![支持的关键字1][1]

![支持的关键字2][2]

## 查询方法解析流程 ##

*  假如创建如下的查询：findByUserDepUuid()，框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析，假设查询实体为Doc
    
     *  先判断 userDepUuid （根据 POJO 规范，首字母变为小写）是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，继续第二步；
     *  从右往左截取第一个大写字母开头的字符串(此处为Uuid)，然后检查剩下的字符串是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，则重复第二步，继续从右往左截取；最后假设 user 为查询实体的一个属性；
     *  接着处理剩下部分（DepUuid），先判断 user 所对应的类型是否有depUuid属性，如果有，则表示该方法最终是根据 “ Doc.user.depUuid” 的取值进行查询；否则继续按照步骤 2 的规则从右往左截取，最终表示根据 “`Doc.user.dep.uuid`” 的值进行查询。
     *  可能会存在一种特殊情况，比如 Doc包含一个 user 的属性，也有一个 userDep 属性，此时会存在混淆。可以明确在属性之间加上 “\_” 以显式表达意图，比如 “findByUser\_DepUuid()” 或者 “findByUserDep\_uuid()”
 *  特殊的参数： 还可以直接在方法的参数上加入分页或排序的参数，比如：
    
     *  `Page<UserModel> findByName(String name, Pageable pageable)`;
     *  `List<UserModel> findByName(String name, Sort sort)`;

## 代码示例: ##

*  entity类: Person.java

package com.ifox.hgx.springdata.entities;
    
    import org.springframework.format.annotation.DateTimeFormat;
    import javax.persistence.*;
    import java.util.Date;
    
    
    @Table(name = "JPA_PERSONS")
    @Entity
    public class Person { 
        private Integer id ;
        private String lastName ;
        private String email ;
        private Date birth ;
        private Integer age ;
    
        private Address address;
    
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Id
        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 String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        @DateTimeFormat
        public Date getBirth() {
            return birth;
        }
    
        public void setBirth(Date birth) {
            this.birth = birth;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @JoinColumn(name = "ADDRESS_ID")
        @ManyToOne
        public Address getAddress() {
            return address;
        }
    
        public void setAddress(Address address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id=" + id +
                    ", lastName='" + lastName + '\'' +
                    ", email='" + email + '\'' +
                    ", birth=" + birth +
                    ", age=" + age +
                    ", address=" + address +
                    '}';
        }
    }

*  entity类:Address.java

package com.ifox.hgx.springdata.entities;
    
    import javax.persistence.*;
    
    /** * @Author hanguixian * @Date Created in 21:12 2018/7/4 */
    @Table(name="JPA_ADDRESSES")
    @Entity
    public class Address { 
    
        private Integer id;
        private String province;
        private String city;
    
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Id
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getProvince() {
            return province;
        }
    
        public void setProvince(String province) {
            this.province = province;
        }
    
        public String getCity() {
            return city;
        }
    
        public void setCity(String city) {
            this.city = city;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "id=" + id +
                    ", province='" + province + '\'' +
                    ", city='" + city + '\'' +
                    '}';
        }
    }

*  dao层:

package com.ifox.hgx.springdata.dao;
    
    import com.ifox.hgx.springdata.entities.Person;
    import org.springframework.data.repository.Repository;
    import java.util.Date;
    import java.util.List;
    
    /** * 在 Repository 子接口中声明方法 * 1. 不是随便声明的. 而需要符合一定的规范 * 2. 查询方法以 find | read | get 开头 * 3. 涉及条件查询时，条件的属性用条件关键字连接 * 4. 要注意的是：条件属性以首字母大写。 * 5. 支持属性的级联查询. 若当前类有符合条件的属性, 则优先使用, 而不使用级联属性. * 若需要使用级联属性, 则属性之间使用 _ 进行连接. */
    public interface PersonRepository extends Repository<Person,Integer> { 
    
    
        //根据 lastName 来获取对应的 Person
        Person getByLastName(String lastName);
    
        //WHERE lastName LIKE ?% AND id < ?
        List<Person> getByLastNameStartingWithAndIdLessThan(String lastName, Integer id);
    
        //WHERE lastName LIKE %? AND id < ?
        List<Person> getByLastNameEndingWithAndIdLessThan(String lastName, Integer id);
    
        //WHERE email IN (?, ?, ?) OR birth < ?
        List<Person> getByEmailInAndBirthLessThan(List<String> emails, Date birth);
    
        //WHERE a.id > ?
        List<Person> getByAddress_IdGreaterThan(Integer id);
    
    }

*  测试类:SpringDataTest.java

package com.ifox.hgx.jap.spring;
    
    import com.ifox.hgx.springdata.dao.PersonRepository;
    import com.ifox.hgx.springdata.entities.Person;
    import com.ifox.hgx.springdata.service.PersonService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.List;
    
    
    public class SpringDataTest { 
    
        private ApplicationContext applicationContext = null;
        private PersonService personService = null;
        private PersonRepository personRepository = null;
    
        {
            applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            personService = applicationContext.getBean(PersonService.class);
            personRepository = applicationContext.getBean(PersonRepository.class) ;
        }
    
        @Test
        public void testDataSource() throws Exception {
            DataSource dataSource = applicationContext.getBean(DataSource.class);
            Connection connection = dataSource.getConnection();
            System.out.println(connection);
    
        }
    
        @Test
        public void testPersonFindByLastName() {
            Person person = personService.getByLastName("sjsja");
            System.out.println(person);
    
        }
    //关注此处测试
        @Test
        public void testKeyWords() {
            List<Person> persons = personRepository.getByLastNameStartingWithAndIdLessThan("A", 5);
            System.out.println(persons);
    
            List<Person>  persons2 = personRepository.getByLastNameEndingWithAndIdLessThan("C",40) ;
            System.out.println(persons2);
    
            List<Person> people  = personRepository.getByEmailInAndBirthLessThan(Arrays.asList("aa@qq.com","bb@qq.com","cc@qq.com"),new Date()) ;
            System.out.println(people);
    
            List<Person> people1 = personRepository.getByAddress_IdGreaterThan(2) ;
            System.out.println(people1);
        }
    }

*  数据测试数据:

![数据库数据][70]

[1]: /images/20220521/830a69392a0d48b3b9b1535501938e31.png
[2]: /images/20220521/f6005ebbaec24efd87010f9494220ba1.png
[70]: /images/20220521/99be06365d644a35b77c2b6fbb421873.png