2019-10-24Spring Data Jpa @Query查询

package cn.itcast.dao;

import cn.itcast.entity.Customer;
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;

/*
* 符合SpringDataJpa的dao层接口规范
* JpaRepository<操作的实体类泛型，实体类中主键属性的类型>
*       *封装了基本增删改查操作
* JpaSpecificationExecutor<操作的实体类类型>
*       *封装了复杂查询(分页)
* */

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
/*
* 案例，根据客户名称查询客户
*        使用jpql的形式查询
* jpql：from Customer where custName=?
* 配置jpql语句，使用@Query注解
* */
    @Query(value="from Customer where custName=?")
    public Customer findJpql(String custName);

    /*
    * 案例，根据客户名称和客户id查询用户
    *       jpql：from Customer where custName=？ and custId=？
    *  对于多个占位符参数
    *       赋值的时候，默认情况下，占位符的位置需要和方法参数中的位置保持一致
    *可以指定占位符参数的位置
    *       ？索引的方式，指定此占位的取值来源
    *
    * */
    @Query(value = "from Customer where custName=?1 and custId=?2")
    public Customer findCustNameAndId(String name,Long id);
    /*
    * 使用jpql完成更新操作
    *      案例： 根据id更新，客户的名称
    *           更新7号客户的名称，将名称改为“很nb”
    * sql： update cst_customer set cust_name=? where cust_id=?
    * jpql: update Customer set custName=? where custId=?
    *
    * @Query:代表进行查询
    *       *声明此方法是用来更新操作
    * @Modifying
    *   *当前执行的是一个更新的操作
    * */
    @Query(value = "update Customer set custName=?2 where custId=?1")
    @Modifying
    public void updateCustName(long custId,String custName);


    /**
     *使用sql的形式查询
     *      查询全部用户
     *      sql ： select * from cst_customer
     *  @Query:配置sql查询
     *      value:sql语句
     *      nativeQuery：查询方式
     *         true:sql查询
     *         false：jpql查询
     */
//    @Query(value = "select * from cst_customer",nativeQuery = true)
    @Query(value = "select * from cst_customer where cust_name like ?1",nativeQuery = true)
    public ListfindSql(String name);
    /**
     * 方法名的约定
     *      findBy:查询
     *          对象中的属性名(首字母大写)：查询的条件
     *          CustName
     *          *默认情况  使用  等于的方式查询
     *                  特殊的查询方式
     * findByCustName -- 根据客户名称查询
     * 在springdataJpa的运行阶段
     *      会根据方法名称进行解析  findBy  from xxx(实体类)
     *                          属性名     where custName=
     *
     *      1.findBy+属性名称（根据属性名称进行完成匹配的查询=）
     *      2.findBy+属性名称+查询方式（like|isnull）
     *          findByCustNameLike
     *      3.多条件查询
     *          findBy+属性名+“查询方式”+'多条件的连接符（and|or）'+属性名+“查询方式”
     */
    public  Customer findByCustName(String custName);

    public List findByCustNameLike(String custName);
    //使用客户名称模糊匹配和客户所属行业精准匹配的查询
    public  Customer findByCustNameLikeAndCustIndustry(String name,String custIndustry);
}

package cn.itcast.test;

import cn.itcast.dao.CustomerDao;
import cn.itcast.entity.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)//声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
@Autowired
    private CustomerDao customerDao;

@Test
    public void testFindJPQL(){
    Customer jpql = customerDao.findJpql("肇事");
    System.out.println("输出的是："+jpql);
}

@Test
    public void testFindCustNameAndId(){
    Customer customer = customerDao.findCustNameAndId("SS1111", 2l);
    System.out.println(customer);
    }
    /*
    * 测试jpql的更新操作
    *   *springDataJpa中使用jpql完成，更新/删除操作
    *       *需要手动添加事务支持
    *       *默认会执行结束之后，回滚事务
    * */
    @Test
    @Transactional//添加事务的支持
    @Rollback(value = false)//设置自动回滚    false|true
    public void testUpdateCustomer(){
    customerDao.updateCustName(7l,"很nb");
    }
    @Test
    public void testFindSql(){
        List sql = customerDao.findSql("%东%");
        for (Object[] objects:sql){
            System.out.println(Arrays.toString(objects));
        }
    }
    /**
     * 测试方法命名规则的查询
     */

    @Test
    public void testName(){
        Customer customer = customerDao.findByCustName("刘强东");
        System.out.println(customer);
    }

    @Test
    public void testFindByNameLike(){
        List list = customerDao.findByCustNameLike("%强%");
        for (Customer customer : list){
            System.out.println(customer);
        }
    }
    @Test
    public void testFindByCustNameLikeAndCustIndustry(){
        Customer customer1 = customerDao.findByCustNameLikeAndCustIndustry("%强%", "教育");
        System.out.println(customer1);
    }
}