springDataJPQL实现增删改查及分页，原生sql查询，根据方法命名规则实现查询

Posted 2022-08-12 zhangrongfei

一、使用方法

1、在dao中定义开一个方法，使用方法的参数设置jpql，并且使用方法的返回值接受查询结果，在方法上添加@query注解，在注解中写jpql语句进行增删改查，测试

2、使用原生的sql语句：dao中定义一个方法，在方法中添加@query注解，在注解中添加原生sql语句，并且添加一个属性：nativeQuery=true，测试

3、方法命名规则查询：

　　通过以肯定的规则，定义一个方法，框架本身就可以根据方法名生成一块个sql语句进行查询，规则：

　　　　1、必须以findBy开头

　　　　2、查询某个字段，findBy后跟实体类的属性名称

　　　　3、如果有多个条件，就在方法后加And后跟实体类的属性名

　　　　4、方法的参数对应查询的定义

　　　　5、返回值根据返回值的数据类型定义；如果是分页查询，在方法中添加一个参数Pageable即可

二、、编写实现类

package cn.zrf.jpa.entity;

import javax.persistence.*;

@Entity
@Table(name = "cust_customer")
public class Customer 
    // 配置主键自增的策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    @Column(name="cust_id")
    private long custId;
    @Column(name="cust_name")
    private String custName;
    @Column(name="cust_source")
    private String custSource;
    @Column(name="cust_indutry")
    private String custIndutry;
    @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 + ‘\‘‘ +
                ", custIndutry=‘" + custIndutry + ‘\‘‘ +
                ", 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 getCustIndutry() 
        return custIndutry;
    

    public void setCustIndutry(String custIndutry) 
        this.custIndutry = custIndutry;
    

    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;
    

　　

三、编写dao

package cn.zrf.jpa.dao;

import cn.zrf.jpa.entity.Customer;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;

import java.util.List;

public interface CustomerDao extends JpaRepository<Customer,Long>,JpaSpecificationExecutor<Customer> 
    //查询全部
    @Query("from Customer")
    List<Customer> getAllCustomer();
    //查询全部并分页
    @Query("from Customer ")
    List<Customer> getAllCustomerByPage(Pageable pageable);
    //条件查询(根据ID查询)
    @Query("from Customer where cust_id = ?")
    Customer getCustomerById(Long id);
    //根据地址，姓名模糊查询
    @Query("from Customer where custAddress like ? and custName like ?")
    List<Customer> getCustList(String address,String custName);
    //根据ID进行局部更新操作
    @Query("update Customer set cust_name=? where custId=?")
    @Modifying
    void getUpdateById(String name,Long id);
    //原生sql语句模糊查询操作
    @Query(value = "select * from cust_customer where cust_name like ?",nativeQuery = true)
    List<Customer> getCustomerListByNative(String name);
    //方法命名规则查询
    /**1 应该使用findBy开头
     * 2 查询某个字段  findBy后跟实体类的属性的名称
     * 3 如果有多个条件   就在方法后加And+实体类的属性名
     * 4  方法的参数 对应查询的定义
     * 5 返回值根据返回的数据类型定义
     * 6 如果需要分页查询   在方法中添加一个参数Pageable 即可
     */
    //根据ID查询
    Customer findByCustId(Long id);
    //根据姓名，地址进行模糊查询
    List<Customer> findByCustNameLikeAndCustAddressLike(String name,String address);
    //分页查询
    List<Customer> findByCustAddressLike(String address, Pageable pageable);

　　

四、测试类

package cn.jpa.test;

import cn.zrf.jpa.dao.CustomerDao;
import cn.zrf.jpa.entity.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.test.annotation.Commit;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.awt.print.Pageable;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJpql 
    @Autowired
    CustomerDao customerDao;
    //查询全部
    @Test
    public void getAllCustomerTest()
        List<Customer> list = customerDao.getAllCustomer();
        for (Customer customer:list)
            System.out.println(customer);
        
    
    //查询全部并分页
    @Test
    public void getAllCustomerByPageTest()
        List<Customer> list = customerDao.getAllCustomerByPage(new PageRequest(0, 3));
        for (Customer customer:list)
            System.out.println(customer);
        
    
    //根据ID查询
    @Test
    public void getCustomerByIdTest()
        Customer customer = customerDao.getCustomerById(1l);
        System.out.println(customer);
    
    //根据地址，姓名进行模糊查询
    @Test
    public void getCuseListTest()
        List<Customer> custList = customerDao.getCustList("%京%", "%长%");
        for (Customer customer:custList)
            System.out.println(customer);
        
    
    //根据ID进行局部更新操作
    @Test
    @Transactional
    @Commit
    public void getUpdateByIdTest()
        customerDao.getUpdateById("张无忌",3l);
    
    //原生sql语句模糊查询
    @Test
    public void getCustomerByNativeTest()
        List<Customer> list = customerDao.getCustomerListByNative("%长%");
        for (Customer customer:list)
            System.out.println(customer);
        
    
    //方法命名规则查询测试
    //根据ID查询
    @Test
    public void findByIdTest()
        Customer customer = customerDao.findByCustId(1L);
        System.out.println(customer);
    
    //根据地址，姓名进行模糊查询
    @Test
    public void findByCustNameLikeAndAddressLike()
        List<Customer> list = customerDao.findByCustNameLikeAndCustAddressLike("%张%","%京%");
        for (Customer customer:list)
            System.out.println(customer);
        
    
    //根据地址进行分页查询
    @Test
    public void findByCustAddressLike()
        List<Customer> list = customerDao.findByCustAddressLike("%京%", new PageRequest(0, 3));
        for (Customer customer:list)
            System.out.println(customer);