jpa02

1     /**
2      * 使用jpql查询
3      *      from Customer where custName = ?
4      *      @Query注解
5      *          value: sql语句 | jpql语句
6      *          nativeQuery = true,使用sql ,false(默认)，使用jpql
7      */
8     @Query(value = " from Customer where custName = ?")
9     public Customer findJpql(String custName);

 1 /**
 2      *      jpql: from Customer where custName = ? and custId = ?
 3      *                                                  参数与条件不存在关系
 4      *      对于多个占位符参数，赋值的时候默认的情况
 5      *      占位符的位置需要和方法参数保持一致
 6      *      如果不一致，可以指定占位符参数的位置
 7      *      ？ 索引的方式 ,指定此占位的取值来源
 8      *
 9      */
10     @Query(value = "from Customer where custName = ? and custId = ?")
11     public Customer findCustNameAndId(String name ,Long id);

1    /**u/d
2      * sql: update cst_customer set cust_name = ? where cust_id = ?
3      * @Moditying
4      *          表示当前执行的是更新操作
5      * 需要手动添加事务，默认执行后会回滚 @Transaction
6      */
7     @Query(value = "update Customer set custName = ?2 where custId = ?1")
8     @Modifying
9     public void updateCustomer(long custId,String custName);

 public Customer findByCustName(String custName);

 public Customer findByCustNameLike(String custName);

 public Customer findByCustNameAndCustIndustry(String custName,String custIndustry);

1 public interface Specification<T> {
2     Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);
3 }

 1 /**
 2      * 自定义查询条件
 3      *  1.实现Specification 接口（提供泛型，查询对象类型）
 4      *  2.实现toPredicate方法（构造查询条件）
 5      *  3.需要借助方法参数中的两个参数
 6      *      root 需要查询的对象属性
 7      *      CriteriaBuilder 构造查询条件，内部封住了查询条件（模糊匹配，精确匹配）
 8      */
 9     @Test
10     public void testSpec(){
11 
12         Specification<Customer> spec = new Specification<Customer>() {
13             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
14 
15                 Path<Object> custName = root.get("custName");
16                 Predicate predicate = cb.equal(custName, "zhangsan");//equal 进行精准匹配 (属性，取值)
17                 return predicate;
18             }
19         };
20 
21         Customer customer = customerDao.findOne(spec);
22         System.out.println(customer);
23     }

 1     /**
 2      * 多条件查询
 3      * 根据客户名和行业查询
 4          * root用来获取属性
 5          * cb构造查询
 6      *      1.构造客户名的精准匹配查询
 7      *      2.构造所属行业的精准匹配查询
 8      *      3.将连个查询联合起来
 9      */
10     @Test
11     public void testSpec1(){
12         Specification<Customer> spec = new Specification<Customer>() {
13             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
14                 Path<Object> custName = root.get("custName");
15                 Path<Object> custIndustry = root.get("custIndustry");
16 
17                 //构造查询
18                 Predicate p1 = cb.equal(custName, "zhangsan");
19                 Predicate p2 = cb.equal(custIndustry, "it");
20                 //将查询条件组合起来
21                 Predicate and = cb.and(p1, p2);
22                 return and;
23             }
24         };
25 
26         Customer customer = customerDao.findOne(spec);
27         System.out.println(customer);
28     }

 1  /**
 2      * 模糊匹配
 3      * equal 直接得到path对象
 4      * gt,lt,le ,like 得到path对象,根据path指定的参数类型，进行比较
 5      * 指定参数类型 ： path.as(类型的字节码对象)
 6      */
 7     @Test
 8     public void testSpec2(){
 9         Specification<Customer> spec = new Specification<Customer>() {
10             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
11                 //查询属性客户名
12                 Path<Object> custName = root.get("custName");
13                 //查询方式模糊匹配
14                 Predicate like = cb.like(custName.as(String.class), "华%");
15 
16                 return like;
17             }
18         };
19 
20 //        List<Customer> list = customerDao.findAll(spec);
21 //        for (Customer customer : list){
22 //            System.out.println(customer);
23 //        }
24 
25     //添加排序
26     //创建排序对象，需要调用构造方法实例化sort对象
27     //第一个参数：排序的顺序
28         //Sort.Direction.Desc：倒序
29         //Sort.Direction.ASC:升序
30     //第二个参数：排序的属性名称
31         Sort sort  = new Sort(Sort.Direction.DESC,"custId");
32         List<Customer> list = customerDao.findAll(spec,sort);
33         for (Customer customer : list) {
34             System.out.println(customer);
35         }
36 
37 
38     }

 1     /**
 2      * 分页查询
 3      *  findAll(Specification,Pageable)
 4      *  Specficaation 查询条件
 5      *  Pageable 分页参数
 6      *
 7      */
 8     @Test
 9     public void testSpec4(){
10 
11         Specification spec = null;
12         Pageable pageable = new PageRequest(0, 2); //当前查询页数，每页查询条数
13         Page<Customer> page = customerDao.findAll(null, pageable);
14         System.out.println(page.getTotalPages());
15         System.out.println(page.getTotalElements());
16 
17     }

 1     /**
 2      * 客户与联系人，一对多
 3      * 使用注解的形式配置多表关系
 4      * 1.声明关系 @OnetwoMany targetEntity: 对方对象的字节码对象
 5      * 2.配置外键（中间表） name 外键字段名称
 6      *                  referencedColumnName 参照主表的主键字段名称
 7      *
 8      *  ! 在客户实体类添加了外键设置，对客户而言，具备了维护主键的作用
 9      */
10     @OneToMany(targetEntity = LinkMan.class)
11     @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
12     private Set<LinkMan> linkMans = new HashSet();

 1     /**
 2      * 配置联系人到客户的多对一关系
 3      *      使用注解的方式配置多对一关系
 4      *      1.配置表关系  @ManytoOne targetTarget 对方实体类的字节码
 5      *      2.配置外键（中间表）
 6      *
 7      *  配置外键的过程，配置到了多了一方，就会在多的一方维护外键
 8      */
 9     @ManyToOne(targetEntity = Customer.class)
10     @JoinColumn(name ="lkm_cust_id",referencedColumnName = "cust_id")
11     private Customer customer;

 1         <!--注入jpa的配置信息
 2             加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
 3             hibernate.hbm2ddl.auto : 自动创建数据库表
 4                 create ： 每次都会重新创建数据库表
 5                 update：有表不会重新创建，没有表会重新创建表
 6         -->
 7         <property name="jpaProperties" >
 8             <props>
 9                 <prop key="hibernate.hbm2ddl.auto">update</prop>
10             </props>
11         </property>

 1     @Test
 2     @Transactional
 3     @Rollback(false)
 4     public void  add(){
 5         Customer customer = new Customer();
 6         customer.setCustName("zhangsan");
 7         LinkMan linkMan = new LinkMan();
 8         linkMan.setLkmName("lisi");
 9 
10         customer.getLinkMans().add(linkMan);
11 
12         customerDao.save(customer);
13         linkManDao.save(linkMan);
14     }

 1  /**
 2      * 放弃外键维护权
 3      *      mappedBy：对方配置关系的属性名称 4      * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
 5      *      CascadeType.all         : 所有
 6      *                  MERGE       ：更新
 7      *                  PERSIST     ：保存
 8      *                  REMOVE      ：删除
 9      *
10      * fetch : 配置关联对象的加载方式
11      *          EAGER   ：立即加载
12      *          LAZY    ：延迟加载
13 
14      */
15     @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
16     private Set<LinkMan> linkMans = new HashSet<>();

 1     /**
 2      * 级联添加：保存一个客户的同时，保存客户的所有联系人
 3      *      需要在操作主体的实体类上，配置casacde属性
 4      */
 5     @Test
 6     @Transactional //配置事务
 7     @Rollback(false) //不自动回滚
 8     public void testCascadeAdd() {
 9         Customer customer = new Customer();
10         customer.setCustName("百度1");
11 
12         LinkMan linkMan = new LinkMan();
13         linkMan.setLkmName("小李1");
14 
15         linkMan.setCustomer(customer);
16         customer.getLinkMans().add(linkMan);
17 
18         customerDao.save(customer);
19     }

 1     /**
 2      * 级联删除：
 3      *      删除1号客户的同时，删除1号客户的所有联系人
 4      */
 5     @Test
 6     @Transactional //配置事务
 7     @Rollback(false) //不自动回滚
 8     public void testCascadeRemove() {
 9         //1.查询1号客户
10         Customer customer = customerDao.findOne(1l);
11         //2.删除1号客户
12         customerDao.delete(customer);
13     }

 1   /**
 2      * 配置用户到角色的多对多关系
 3      *      配置多对多的映射关系
 4      *          1.声明表关系的配置
 5      *              @ManyToMany(targetEntity = Role.class)  //多对多
 6      *                  targetEntity：代表对方的实体类字节码
 7      *          2.配置中间表（包含两个外键）
 8      *                @JoinTable
 9      *                  name : 中间表的名称
10      *                  joinColumns：配置当前对象在中间表的外键
11      *                      @JoinColumn的数组
12      *                          name：外键名
13      *                          referencedColumnName：参照的主表的主键名
14      *                  inverseJoinColumns：配置对方对象在中间表的外键
15      */
16     @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
17     @JoinTable(name = "sys_user_role",
18             //joinColumns,当前对象在中间表中的外键
19             joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
20             //inverseJoinColumns，对方对象在中间表的外键
21             inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
22     )
23     private Set<Role> roles = new HashSet<>();

1     //配置多对多
2     @ManyToMany(mappedBy = "roles")  //配置多表关系
3     private Set<User> users = new HashSet<>();

 1     /**
 2      * 保存一个用户，保存一个角色
 3      *
 4      *  多对多放弃维护权：被动的一方放弃
 5      */
 6     @Test
 7     @Transactional
 8     @Rollback(false)
 9     public void  testAdd() {
10         User user = new User();
11         user.setUserName("小李");
12 
13         Role role = new Role();
14         role.setRoleName("java程序员");
15 
16         //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
17         user.getRoles().add(role);
18 
19         //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
20         role.getUsers().add(user);
21 
22         userDao.save(user);
23         roleDao.save(role);
24     }

    @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)

    //测试级联添加（保存一个用户的同时保存用户的关联角色）
    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeAdd() {
        User user = new User();
        user.setUserName("zhangsan");

        Role role = new Role();
        role.setRoleName("lisi");

        //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
        role.getUsers().add(user);
        userDao.save(user);
    }

 1     /**
 2      * 案例：删除id为1的用户，同时删除他的关联对象
 3      */
 4     @Test
 5     @Transactional
 6     @Rollback(false)
 7     public void  testCasCadeRemove() {
 8         //查询1号用户
 9         User user = userDao.findOne(1l);
10         //删除1号用户
11         userDao.delete(user);
12 
13     }

 1         //测试对象导航查询（查询一个对象的时候，通过此对象查询所有的关联对象）
 2         @Test
 3         @Transactional // 解决在java代码中的no session问题
 4         public void  testQuery1() {
 5             //查询id为1的客户
 6             Customer customer = customerDao.getOne(9l);
 7             //对象导航查询，此客户下的所有联系人
 8             Set<LinkMan> linkMans = customer.getLinkMans();
 9 
10             for (LinkMan linkMan : linkMans) {
11                 System.out.println(linkMan);
12             }
13         }

 1 /**
 2          *  默认 ： 立即加载
 3          *  延迟加载：
 4          *
 5          */
 6         @Test
 7         @Transactional // 解决在java代码中的no session问题
 8         public void  testQuery3() {
 9             LinkMan linkMan = linkManDao.findOne(2l);
10             //对象导航查询所属的客户
11             Customer customer = linkMan.getCustomer();
12             System.out.println(customer);
13         }