JPA---Spring-data-JPA---Hibernate

package com.ytfs.entity;


import javax.persistence.*;
import java.io.Serializable;

/**
 * @Classname Customer
 * @Description TODO(客户实体类)
 * @Date 2020/4/29 21:34
 * @Created by ytfs
 */


@Entity
@Table(name = "cst_customer")
public class Customer implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;
    /**
     * cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT ‘客户编号(主键)‘,
     * `cust_name` varchar(32) NOT NULL COMMENT ‘客户名称(公司名称)‘,
     * `cust_source` varchar(32) DEFAULT NULL COMMENT ‘客户信息来源‘,
     * `cust_industry` varchar(32) DEFAULT NULL COMMENT ‘客户所属行业‘,
     * `cust_level` varchar(32) DEFAULT NULL COMMENT ‘客户级别‘,
     * `cust_address` varchar(128) DEFAULT NULL COMMENT ‘客户联系地址‘,
     * `cust_phone` v
     */
    @Column(name = "cust_name")
    private String custName;

    @Column(name = "cust_source")
    private String custSource;

    @Column(name = "cust_industry")
    private String custIndustry;

    @Column(name = "cust_level")
    private String custLevel;

    @Column(name = "cust_address")
    private String custAddress;

    @Column(name = "cust_phone")
    private String 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 getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    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;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName=‘" + custName + ‘\‘‘ +
                ", custSource=‘" + custSource + ‘\‘‘ +
                ", custIndustry=‘" + custIndustry + ‘\‘‘ +
                ", custLevel=‘" + custLevel + ‘\‘‘ +
                ", custAddress=‘" + custAddress + ‘\‘‘ +
                ", custPhone=‘" + custPhone + ‘\‘‘ +
                ‘}‘;
    }
}

package com.ytfs.dao;

import com.alibaba.druid.sql.visitor.functions.If;
import com.ytfs.entity.Customer;
import org.hibernate.mapping.Value;
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.lang.invoke.VarHandle;
import java.security.spec.NamedParameterSpec;
import java.util.List;


/**
 * @Classname CustomerDao
 * @Description TODO(客户的数据库访问层)
 * @Date 2020/4/29 21:46
 * @Created by ytfs
 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
 */


public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {

    /**
     * JPQL的方式查询全部客户
     *
     * @return
     */
    @Query(value = "from Customer")
    List<Customer> findAllByJPQL();

    /**
     * 根据客户名称和客户id查询客户
     * jpql： from Customer where custName = ? and custId = ?
     * <p>
     * 对于多个占位符参数
     * 赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
     * <p>
     * 可以指定占位符参数的位置
     * ? 索引的方式，指定此占位的取值来源
     */
    @Query("from Customer where custName = ?2 and custId = ?1")
    Customer findCustomerById(Long custId, String custName);



    /**
     * 使用jpql完成更新操作
     *      案例 ： 根据id更新，客户的名称
     *          更新4号客户的名称，将名称改为“黑马程序员”
     *
     *  sql  ：update cst_customer set cust_name = ? where cust_id = ?
     *  jpql : update Customer set custName = ? where custId = ?
     *
     *  @Query : 代表的是进行查询
     *      * 声明此方法是用来进行更新操作
     *  @Modifying
     *      * 当前执行的是一个更新操作
     *
     */
    @Query("update Customer  set custName = ?1 where custId = ?2")
    @Modifying
    void updateCustomerById(String custName,Long Id);


    /**
     * 使用sql的形式查询：
     *     查询全部的客户
     *  sql ： select * from cst_customer;
     *  Query : 配置sql查询
     *      value ： sql语句
     *      nativeQuery ： 查询方式
     *          true ： sql查询
     *          false：jpql查询 默认值
     *
     */
    @Query(value = "select  * from cst_customer", nativeQuery = true)
    List<Customer> findAllBySql();


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


    /**
     * 根据名称精准查询客户
     * @param CustName
     * @return
     */
    Customer findByCustName(String CustName);


    /**
     * 根据客户名称进行模糊查询
     * @param CustName
     * @return
     */
    List<Customer> findByCustNameLike(String CustName);


    /**
     * 根据客户名称模糊查询,并且通过id精确查询
     * @param name
     * @param Id
     * @return
     */
    List<Customer> findByCustNameLikeAndCustId(String name, Long Id);

}

package com.ytfs.test;

import com.ytfs.dao.CustomerDao;
import com.ytfs.entity.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * @Classname SpringDataJpaTest
 * @Description TODO(springDataJpa的测试案例)
 * @Date 2020/4/29 21:58
 * @Created by ytfs
 */


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJpaTest {

    @Autowired
    private CustomerDao customerDao;

    /**
     * @description 查询全部
     * @author 雨听风说
     * @updateTime 2020/4/29 22:44
     */
    @Test
    public void testFindALl() {

        List<Customer> list = this.customerDao.findAll();

        list.forEach(System.out::println);

    }

    /**
     * @description 根据id查询客户
     * @author 雨听风说
     * @updateTime 2020/4/29 22:49
     */
    @Test
    public void testFindById() {
        System.out.println(this.customerDao.findById(1L));
    }

    /**
     * @description 根据Id删除
     * @author 雨听风说
     * @updateTime 2020/4/29 22:53
     */
    @Test
    public void testDelete() {
        this.customerDao.deleteById(4l);
    }

    /**
     * @description 保存客户, save, 保存并且返回保存的对象
     * @author 雨听风说
     * @updateTime 2020/4/29 23:03
     */
    @Test
    public void testSave() {
        Customer customer = new Customer();
        customer.setCustName("雨听风说");
        this.customerDao.save(customer);
    }

    /**
     * @description 当保存方法执行的时候, 如果需要保存的对象有id, 那么将自动更新这个id的对象
     *              并且将该对象为设置的参数置为null
     * @author 雨听风说
     * @updateTime 2020/4/29 23:07
     */

    @Test
    public void testUpdate() {

        Customer customer = new Customer();

        customer.setCustId(5l);

        customer.setCustName("雨听风说修改");
        this.customerDao.save(customer);
    }
}

package com.ytfs.test;

import com.ytfs.dao.CustomerDao;
import com.ytfs.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 javax.transaction.Transactional;
import java.util.List;

/**
 * @Classname SpringDataJPAJpqlTest
 * @Description TODO(SpringDataJpaJpql测试)
 * @Date 2020/4/30 21:15
 * @Created by ytfs
 */

/**
 * jpql的查询方式
 * jpql ： jpa query language  （jpq查询语言）
 * 特点：语法或关键字和sql语句类似
 *     查询的是类和类中的属性
 *     需要将JPQL语句配置到接口方法上
 * 1.特有的查询：需要在dao接口上配置方法
 * 2.在新添加的方法上，使用注解的形式配置jpql查询语句
 * 3.注解 ： @Query
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataJPAJpqlTest {

    @Autowired
    private CustomerDao customerDao;

    /**
     * @description 通过JPQL的方式查询所有的客户
     * @author 雨听风说
     * @updateTime 2020/4/30 21:48
     */
    @Test
    public void testFindAll() {

        List<Customer> list = this.customerDao.findAllByJPQL();

        list.forEach(System.out::println);
    }

    /**
     * @description 通过客户姓名和客户的Id查询一个客户
     * @author 雨听风说
     * @updateTime 2020/4/30 21:48
     */

    @Test
    public void testFindCustomerByIdAndName() {
        Customer customer = this.customerDao.findCustomerById(5L, "雨听风说");

        System.out.println("customer = " + customer);
    }

    /**
     * @description 通过Id修改客户的姓名
     * @author 雨听风说
     * @updateTime 2020/4/30 21:59
     * <p>
     * 测试jpql的更新操作
     * springDataJpa中使用jpql完成 更新/删除操作
     * 需要手动添加事务的支持
     * 默认会执行结束之后，回滚事务
     * @Rollback :设置是否自动回滚
     * false|true
     */

    @Test
    @Transactional
    @Rollback(value = false)
    public void testUpdateCustomerById() {
        this.customerDao.updateCustomerById("雨听风说", 5L);
    }

    /**
     * @description 通过sql语句的形式查询全部的客户
     * @author 雨听风说
     * @updateTime 2020/4/30 22:08
     */

    @Test
    public void testFindAllBySql() {
        List<Customer> customers = this.customerDao.findAllBySql();

        customers.forEach(System.out::println);
    }

    /**
     * @description 通过sql语句的形式模糊条件查询
     * @author 雨听风说
     * @updateTime 2020/4/30 22:08
     */
    @Test
    public void testFindCustomerByLikeCustName() {
        Customer customer = this.customerDao.FindCustomerByLikeCustName("雨听风说");

        System.out.println(customer);
    }

    /**
     * @description 根据名称精准查客户
     * @author 雨听风说
     * @updateTime 2020/4/30 23:47
     */
    @Test
    public void testByName() {
        Customer customer = this.customerDao.findByCustName("雨听风说");

        System.out.println("customer = " + customer);
    }

    /**
     * @description 根据客户的名称模糊查询
     * @author 雨听风说
     * @updateTime 2020/4/30 23:51
     */
    @Test
    public void testFindByNameLike() {
        List<Customer> byCustNameLike = this.customerDao.findByCustNameLike("%风说%");

        byCustNameLike.forEach(System.out::println);
    }

    /**
     * @description 根据客户名称模糊查询,并且根据id精准查询
     * @author 雨听风说
     * @updateTime 2020/4/30 23:56
     */

    @Test
    public void testFindCustomerByNameLikeAndId() {


        List<Customer> byCustNameLikeAndCustId = this.customerDao.findByCustNameLikeAndCustId("%风说%", 5L);

        byCustNameLikeAndCustId.forEach(System.out::println);
    }
}