Springdata-JPAの研究ノート

リポジトリー・インタフェース

リポジトリーは、2つのクエリ方法を提供Springdata JPAトップレベルのインタフェースです。

1）の命名規則メソッド名に基づいて、

2）クエリ@Qeuryコメントに基づいて

1.メソッド名の命名クエリ

ルール：findBy（キーワード）+属性名（最初の文字がプロパティ名を大文字）+クエリ（最初の文字は大文字）

ファジィクエリ：

@Test
public void test(){
    
    List<StudentEntity> res = this.stu.findByXmLike("刘%");
    for(StudentEntity tmp : res){
        System.out.println(tmp);
    }
}

命名規則方法：

• そして--- SQLおよびキーワードに相当し、このようfindByUsernameAndPassword（文字列のユーザー、StriangのPWD）など;
• あるいは---そのようなfindByUsernameOrAddress（文字列のユーザは、文字列ADDR）のような、SQLのと同等またはキーワード。
• BETWEEN --- SQLのキーワードの間に相当なfindBySalaryBetween（int型の最大値、整数分）。
• LessThan --- "<"、などfindBySalaryLessThan（int型の最大）のSQLに相当;
• 演算子：GreaterThan ---のSQL同等物 ">"、例えばfindBySalaryGreaterThan（INT分）。
• GreaterThanEqual
• IsNull --- SQLに相当する "nullである" は、findByUsernameIsNull（）。
• IsNotNull --- SQL当量）（例えばfindByUsernameIsNotNull、 "nullでありません"。
• NOTNULL ---とIsNotNull相当。
• 「のような」のような--- SQL相当、などfindByUsernameLike（文字列のユーザー）。
• NotLike ---におけるSQLに相当するようなfindByUsernameNotLike（文字列のユーザ）として、「好きではありません」。
• [並べ替え---そのようなfindByUsernameOrderBySalaryAsc（Stringユーザー）として「順」にSQLに相当。
• 「！=」などfindByUsernameNot（文字列のユーザー）として、SQLへ---同じではありません。
• 「中」、などfindByUsernameIn（コレクションに相当---ではSQL UserListパラメータ）、コレクションタイプの方法であってもよい、または配列可変長パラメータであってもよいです。
• このようfindByUsernameNotIn（コレクションとして「ないで」でSQLに相当--- NotIn UserListパラメータ）、コレクションタイプの方法であってもよい、または配列可変長パラメータであってもよいです。

短所：クエリが複雑すぎる場合には、メソッド名が非常に長くなります

@queryに基づき2.クエリを指摘します

JPQL文のクエリによって2.1

JPQL：進化のHibernateのHQLて。そして、HQLの構文は非常に似ています。

実装は必要ありません。

クラス名とクラスメンバを使用して文の中JPQL変数。

//使用@Query注解查询, 抽象方法, 参数列表的顺序就是sql语句中的顺序
    @Query(value="from StudentEntity where xm like ?1")
    List<StudentEntity> queryByXm(String name);

//多值查询
    @Query(value="from StudentEntity where xm is ?1 and yxh is ?2")
    List<StduentEntity> queryByXmAndYxh(String name, Integer yxh);

//或是这样的Like查询写法
@Query(value="from StudentEntity where xm like %:name%")
    List<StudentEntity> queryByXm(@Param("name") String name);

JPQLのパラメータ代入文に@param（「名前」）

クエリにSQL文を使用して2.2

データベース内のテーブル名とデータテーブルを使用して@query声明

nativeQuery =真の使用SQL文

//可标可不标参数顺序, 多值查询时不标明顺序按次序填充
@Query(value = "select * from S where xm = ?1", nativeQuery = true)
    List<StudentEntity> queryBySQL(String name);

3.ページング

PagingAndSortingRepository

3.1。ページング処理

@Test
    public void testPaging(){
        int page, size;
        //page 为当前页的索引，起始为0
        //size 为页面大小
        page = 1;
        size = 5;
        Pageable p = new PageRequest(page,size);
        Page<StudentEntity> res =  this.stu.findAll(p);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

3.2注文プロセス

/*
    对单列做排序
     */
    @Test
    public void testSort(){
        // Sort: 该对象封装了排序规则以及指定的排序字段（对象的属性来表示）
        // direction: 排序规则
        // properties: 指定做排序的属性, 给表对应类的属性
        Sort sort = new Sort(Sort.Direction.DESC, "xh");
        List<StudentEntity> res = this.stu.findAll(sort);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

/*
多列排序
*/
@Test
    public void testSort2(){
        //Sort sort = new Sort();
        Sort.Order o1 = new Sort.Order(Sort.Direction.DESC, "yxh");
        Sort.Order o2 = new Sort.Order(Sort.Direction.ASC, "csrq");
        Sort sort = new Sort(o1,o2);
        List<StudentEntity>  res = this.stu.findAll(sort);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

4. JpaSpecificationExecutorインタフェース

単独で使用することはできません、継承しなければならないとJpaRepositoryは、そうでなければ、プロキシオブジェクトを生成することはできません。

完了、複雑な多基準クエリ、およびページングやソートのサポート

//1.创建接口
public interface StudentRepository extends JpaRepository<StudentEntity,Integer>, JpaSpecificationExecutor<StudentEntity>

5.1つの条件のクエリ

などコールcriteriaBuilderクエリ方法を決定する方法であって、決意は、ファジィクエリ等しいです

root.get（）メソッドは、値の.as（String.class）は文字列クラス（または他の指定されたタイプ）に変わりに使用することができる返します

/*
    JpaSpecificationExecutor
    单条件查询
     */
    @Test
    public void testSpecification(){
        Specification<StudentEntity> spec= new Specification<StudentEntity>() {
            /*
            @return Predicate:定义了查询条件
            @param Root<StduentEntity> root:根对象，封装了查询条件的对象
            @param criteriaQuery :定义了基本的查询，一般不常用
            @param criteriaBuilder : 创建一个查询条件
             */
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("xm"), "刘%");
                return pre;
            }
        };

        List<StudentEntity> res = this.stu.findAll(spec);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

以上5.2基準クエリ

マルチ基準は、さまざまな方法を問い合わせます

/*
    JpaSpecificationExecutor
    需求：使用姓名和学院查询数据
    多条件查询方式一
     */
    @Test
    public void testSpecification2(){
        Specification<StudentEntity> spec= new Specification<StudentEntity>() {
            /*
            @return Predicate:定义了查询条件
            @param Root<StduentEntity> root:根对象，封装了查询条件的对象
            @param criteriaQuery :定义了基本的查询，一般不常用
            @param criteriaBuilder : 创建一个查询条件
             */
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> plist = new ArrayList<>();
                plist.add(criteriaBuilder.like(root.get("xm"), "刘%"));
                plist.add(criteriaBuilder.equal(root.get("yxh"),2));
                //此时条件之间没有关联
                Predicate [] arr = new Predicate[plist.size()];
                return criteriaBuilder.or(plist.toArray(arr));     //规定关系之间的关系并返回查询规则
                //如果再想或关系，就将cb返回的Predicate对象再放入cb.or方法中
            }
        };

        List<StudentEntity> res = this.stu.findAll(spec);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

/*
    JpaSpecificationExecutor
    需求：使用姓名和学院查询数据
    多条件查询方式二
     */
    @Test
    public void testSpecification2(){
        Specification<StudentEntity> spec= new Specification<StudentEntity>() {
            /*
            @return Predicate:定义了查询条件
            @param Root<StduentEntity> root:根对象，封装了查询条件的对象
            @param criteriaQuery :定义了基本的查询，一般不常用
            @param criteriaBuilder : 创建一个查询条件
             */
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
                return cb.or(cb.like(root.get("xm"),"刘%"), cb.equal(root.get("yxh"),2));
            }
        };

        List<StudentEntity> res = this.stu.findAll(spec);
        for(StudentEntity s: res){
            System.out.println(s);
        }
    }

以上5.3基準クエリページング+

    /*
    查询院系号为1或性别为女的同学 结果分页
     */
    @Test
    public void test4(){
        Specification<StudentEntity> spec = new Specification<StudentEntity>() {
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
                return cb.and(cb.equal(root.get("yxh"),1),cb.equal(root.get("xb"),0));
            }
        };

        Pageable pg = new PageRequest(0,2);
        Page<StudentEntity> res = this.stu.findAll(spec, pg);
        System.out.println(res.getTotalElements());
        System.out.println(res.getTotalPages());
        for(StudentEntity s :res){
            System.out.println(s);
        }
    }

5.4 +ソート基準クエリ

/*
    查询院系号为1或性别为女的同学，结果按学号做倒序排序
     */
    @Test
    public void test5(){
        Specification<StudentEntity> spec = new Specification<StudentEntity>() {
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
                return cb.and(cb.equal(root.get("yxh"),1),cb.equal(root.get("xb"),0));
            }
        };

        Sort sort = new Sort(Sort.Direction.DESC,"xh");
        List<StudentEntity> res = this.stu.findAll(sort);
        for(StudentEntity s :res){
            System.out.println(s);
        }
    }

ページング+ 5.5 +ソート基準クエリ

ソートページオブジェクトに統合

new PageRequest(0,3,sort);

/*
    查询院系号为1或性别为女的同学，做分页处理，结果按学号做倒序排序
     */
    @Test
    public void test6(){
        //排序定义
        Sort sort = new Sort(Sort.Direction.DESC,"xh");
        //分页定义,Pageable对象中存在
        Pageable pg = new PageRequest(0,3,sort);

        Specification<StudentEntity> spec = new Specification<StudentEntity>() {
            @Override
            public Predicate toPredicate(Root<StudentEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
                return cb.and(cb.equal(root.get("yxh"),1),cb.equal(root.get("xb"),0));
            }
        };
        Page<StudentEntity> res = this.stu.findAll(pg);
        System.out.println("总条目数: "+res.getTotalElements());
        System.out.println("页数: "+res.getTotalPages());
        for(StudentEntity s : res){
            System.out.println(s);
        }
    }

エンティティクラス

5.1主キーが定義され

//自增方式创建主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    @Column(name="xh")
    private int xh;

@Temporal方法

//JPA将时间映射到日期
    @Temporal(TemporalType.DATE)
    @Column(name = "csrq")
    private Date csrq;

6.関係

6.1 1の関係

例：ロールとユーザ-1

//测试一对一关系 学生类
    @OneToOne(cascade = CascadeType.PERSIST)        //表示级联关系，增加学生时，对应用户也会加入数据库
    @JoinColumn(name="id")              //表示外键，使用对应表的主键(数据库内的名称)
    private Account account;

    //用户类
    @OneToOne(mappedBy = "account")         //看谁引用了这个account
    private StudentEntity student;

1人の関係を操作します

//增添数据
@Test
    public void test7(){
        //创建用户对象
        Account acc = new Account();
        acc.setUsername("玩家");

        //创建学生对象
        StudentEntity student = new StudentEntity();
        student.setXm("李修文");
        student.setYxh(3);
        student.setSjhm("13120716616");
        student.setPassword("0");
        //student.setCsrq(new Date("1998-7-24"));
        student.setJg("上海");
        student.setXb(1);

        //关联
        student.setAccount(acc);
        acc.setStudent(student);

        //保存学生，相应地acc中也会出现“玩家”条目
        this.stu.save(student);
    }

    /*
    根据学号查询学生，并查询其账户
     */
    @Test
    public void test8(){
        StudentEntity student = this.stu.findByXh(1112);
        System.out.println("学生信息："+student);
        Account acc = student.getAccount();
        System.out.println(acc);
    }

6.2対多の関係

//用户类
@Id
    @Column(name="user_id")
    private int userId;

    @Column(name="user_name")
    private String name;

    @OneToMany
    @JoinColumn(name="role_id")
    private Role role;

//角色类
    @Id
    @Column(name="role_id")
    private Integer roleId;

    @Column(name="role_name")
    private String roleName;

    @OneToMany(mappedBy = "role")
    private Set<User> users = new HashSet<User>();

6.3対多の関係

これは、中間テーブルを生成します。

//学生类

/*
@JoinTable: 配置中间表信息
joinColumns: 建立当前表在中间表的外键字段
*/
@ManyToMany(cascade = CasadeType.PERSIST, fetch = FetchType.EAGER)      //级联操作，添加不存在的数据时同时导入课程类,  放弃延迟加载改为立即加载
@JoinTable(name="t_stu_class",joinColumns=@JoinColumn(name="stu_xh"), inverseJoinColumns = @JoinColumn(name="class_id"))
private Set<Class> classes = new HashSet<Class>();

//课程类
@ManyToMany(mappedBy = "classes")       //映射引用课程类的对象
private Set<Student> students = new HashSet<Student>();

* かどうかの特定の使用のオープンクラスで動作し、多対多、カスケードノート

ない場合は、すぐに（遅延読み込みのため、セッションは学生を取得した後に閉じているため）問合せ時に、出力に対応し、すべてのコースを搭載した学生が文句を言うでしょう