精华内容
下载资源
问答
  • 创建DataAdapter的几种方法
    千次阅读
    2018-07-30 11:49:45

    DataApter充当数据库和ADO.Net模型中非链接数据对象之间的桥梁,使用该对象的Fill方法来实现数据库记录和导入到DataSet对象中,使用Update方法将存储在dataset对象中的数据更新到数据库中去。
    通常来说,创建DataAdapter有几种方法
    下面做下简单的概括;

     private static string connString = @"Data Source=DESKTOP-GVLLFG5\SQLEXPRESS;Initial Catalog=db_Mytime;Integrated Security=True";
            public static SqlConnection connection = new SqlConnection(connString);//初始化sqlConnnection的新实例
    
            private static SqlDataAdapter sqlda = null;
            private static SqlCommand cmd = new SqlCommand("select * from db_time", connection);
            //使用一个查询命令SqlCommamd对象作为参数
            SqlDataAdapter da1 = new SqlDataAdapter(cmd);
           //使用查询命令字符串和SqlConnction对象作为参数
            SqlDataAdapter da2 = new SqlDataAdapter("select * from db_time", connString);
             //使用查询命令串的和数据库链接字符串作为参数
    
            SqlDataAdapter da3 = new SqlDataAdapter("select * from db_time", connection);
    

    其中使用查询命令串和和SqlConection对象作为参数创建sqladapter比较常见,

    更多相关内容
  • 今天,一名读者出去面试,面试官问他:说说Java8中创建Stream流有哪几种方式?他竟然没回答上来!! Stream概述 Java8中两大最为重要的改变。第一个是 Lambda 表达式;另外一个则是 Stream API(java.util.stream....

    写在前面

    先说点题外话:不少读者工作几年后,仍然在使用Java7之前版本的方法,对于Java8版本的新特性,甚至是Java7的新特性几乎没有接触过。真心想对这些读者说:你真的需要了解下Java8甚至以后版本的新特性了。

    今天,一名读者出去面试,面试官问他:说说Java8中创建Stream流有哪几种方式?他竟然没回答上来!!

    Stream概述

    Java8中有两大最为重要的改变。第一个是 Lambda 表达式;另外一个则是 Stream API(java.util.stream.*)。

    Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式。

    何为Stream?

    流(Stream) 到底是什么呢?

    可以这么理解流:流就是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。

    “集合讲的是数据,流讲的是计算! ”

    注意:

    ①Stream 自己不会存储元素。

    ②Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。

    ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

    Stream操作步骤

    1.创建 Stream

    一个数据源(如: 集合、数组), 获取一个流。

    2.中间操作

    一个中间操作链,对数据源的数据进行处理。

    3.终止操作(终端操作)

    一个终止操作,执行中间操作链,并产生结果 。

    在这里插入图片描述

    如何创建Stream流?

    这里,创建测试类TestStreamAPI1,所有的操作都是在TestStreamAPI1类中完成的。

    (1)通过Collection系列集合提供的stream()方法或者parallelStream()方法来创建Stream。

    在Java8中,Collection 接口被扩展,提供了两个获取流的默认方法,如下所示。

    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
    

    其中,stream()方法返回一个顺序流,parallelStream()方法返回一个并行流。

    我们可以使用如下代码方式来创建顺序流和并行流。

    List<String> list = new ArrayList<>();
    list.stream();
    list.parallelStream();
    

    (2)通过Arrays中的静态方法stream()获取数组流。

    Java8 中的 Arrays类的静态方法 stream() 可以获取数组流 ,如下所示。

    public static <T> Stream<T> stream(T[] array) {
        return stream(array, 0, array.length);
    }
    

    上述代码的的作用为:传入一个泛型数组,返回这个泛型的Stream流。

    除此之外,在Arrays类中还提供了stream()方法的如下重载形式。

    public static <T> Stream<T> stream(T[] array) {
        return stream(array, 0, array.length);
    }
    
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
    }
    
    public static IntStream stream(int[] array) {
        return stream(array, 0, array.length);
    }
    
    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
        return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
    }
    
    public static LongStream stream(long[] array) {
        return stream(array, 0, array.length);
    }
    
    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
        return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
    }
    
    public static DoubleStream stream(double[] array) {
        return stream(array, 0, array.length);
    }
    
    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
        return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
    }
    

    基本上能够满足基本将基本类型的数组转化为Stream流的操作。

    我们可以通过下面的代码示例来使用Arrays类的stream()方法来创建Stream流。

    Integer[] nums = new Integer[]{1,2,3,4,5,6,7,8,9};
    Stream<Integer> numStream = Arrays.stream(nums);
    

    (3)通过Stream类的静态方法of()获取数组流。

    可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。

    我们先来看看Stream的of()方法,如下所示。

    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }
    @SafeVarargs
    @SuppressWarnings("varargs") 
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
    

    可以看到,在Stream类中,提供了两个of()方法,一个只需要传入一个泛型参数,一个需要传入一个可变泛型参数。

    我们可以使用下面的代码示例来使用of方法创建一个Stream流。

    Stream<String> strStream = Stream.of("a", "b", "c");
    

    (4)创建无限流

    可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。

    先来看看Stream类中iterate()方法和generate()方法的源码,如下所示。

    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        Objects.requireNonNull(f);
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;
    
            @Override
            public boolean hasNext() {
                return true;
            }
    
            @Override
            public T next() {
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
    }
    
    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
            new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }
    

    通过源码可以看出,iterate()方法主要是使用“迭代”的方式生成无限流,而generate()方法主要是使用“生成”的方式生成无限流。我们可以使用下面的代码示例来使用这两个方法生成Stream流。

    • 迭代
    Stream<Integer> intStream = Stream.iterate(0, (x) -> x + 2);
    intStream.forEach(System.out::println);
    

    运行上述代码,会在终端一直输出偶数,这种操作会一直持续下去。如果我们只需要输出10个偶数,该如何操作呢?其实也很简单,使用Stream对象的limit方法进行限制就可以了,如下所示。

    Stream<Integer> intStream = Stream.iterate(0, (x) -> x + 2);
    intStream.limit(10).forEach(System.out::println);
    
    • 生成
    Stream.generate(() -> Math.random()).forEach(System.out::println);
    

    上述代码同样会一直输出随机数,如果我们只需要输出5个随机数,则只需要使用limit()方法进行限制即可。

    Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);
    

    (5)创建空流

    在Stream类中提供了一个empty()方法,如下所示。

    public static<T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
    }
    

    我们可以使用Stream类的empty()方法来创建一个空Stream流,如下所示。

    Stream<String> empty = Stream.empty();
    

    写在最后

    如果觉得文章对你有点帮助,请微信搜索并关注「 冰河技术 」微信公众号,跟冰河学习Java8新特性。

    最后,附上Java8新特性核心知识图,祝大家在学习Java8新特性时少走弯路。

    展开全文
  • 查询方法

    千次阅读 2019-04-07 21:51:40
    一共三方法都是用来查询数据,初始方法,linq,Lambda,第一种方法比后两种方法都复杂。 代码很多,后面两代码少方法简便,都可以查询数据的效果,期间会说的到特别一些关键字和方法。 第一初始方法 先声明...

    (作者:饶家俊,撰写时间:2019年4月2号)

    一共三种的方法都是用来查询数据,初始方法,linq,Lambda,第一种方法比后两种方法都复杂。

    代码很多,后面两种代码少方法简便,都可以查询数据的效果,期间会说的到特别一些关键字和方法。

    第一种初始方法

    在这里插入图片描述
    先声明变量,在把数据放入列表里面,设置获取范围变量,和调用数据的来源来查询数据。
    在添加类,封装几个字段。不封装字段,或者使用封装的字段会显示未包含定义。要使用固定的字段。
    然后直接实例化的myModel,在查询后面要有new关键字.
    在给它赋值,获取要获取的ID和需要的数据。
    在把查询语句用小括号放进去通过ToList来转换。
    最后返回数据。

    第二种方法linq
    在这里插入图片描述

    匿名类型var关键字。
    匿名类型提供了一种方便的方法,可用来将一组只读属性封装到单个对象中,
    先声明变量,var关键字是定义数据类型的间接方式。
    这被称为隐式类型声明或间接类型声明,不用显示定义,不会显示未包含定义要使用固定的字段。
    把数据放入列表里面,设置获取范围变量,和调用数据的来源来查询数据。
    通过new 运算符和对象创建匿名类型.
    在给它赋值,获取要获取的ID和需要的数据。
    不用添加类和封装字段,使用固定的字段,可以少打很多的代码。
    是不是比初始的方法要便利一些,第三种方法的代码比第二更少去看看把。
    最后返回数据。

    第三种方法Lambda
    在这里插入图片描述
    先声明变量,然后直接实例化的myModel。
    在调用获取里面的表,
    左边是a为参数可自己命名,右边是固定的表达式。
    用参数和表达式的方法体,会自动识别类型,不会显示未包含定义。
    在给它赋值,获取要获取的ID和需要的数据。
    不用添加类和封装字段,使用固定的字段,便利可以少打很多的代码。
    最后返回数据。

    展开全文
  • Spring Data JPA多表查询几种方法

    千次阅读 2019-11-29 16:51:04
    Spring Data JPA多表查询几种方法 前言 公司目前在ORM框架上选型只有两个选择 MyBatis-Plus Spring Data JPA 相信很多人会选择MyBatis-Plus(MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的...

    Spring Data JPA多表查询的几种方法

    前言

    公司目前在ORM框架上选型只有两个选择

    MyBatis-Plus

    Spring Data JPA

    相信很多人会选择MyBatis-Plus(MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生),主要因为JPA对多表复杂查询很不友好,特别是现在建表很多不用外键,所以很多人使用JPA查询就很不方便,但如果有人说:不行,我一定要用JPA,怎么办呢?所以本文就简单说明一下自己所知道的几种JPA的多表复杂查询方法。

    讲解前先创建两张表一张student(学生)表和一张teacher(教师)表,对应两个实体类:

    @Entity
    @Data
    @Accessors(chain = true)
    public class Student {
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        @ApiModelProperty("学生ID")
        @Column(insertable = false, updatable = false, columnDefinition = "INT UNSIGNED  COMMENT '学生ID'")
        private Integer studentId;
    
        @ApiModelProperty("学生名")
        @Column(length = 50, columnDefinition = "VARCHAR(255) NOT NULL COMMENT '学生名'")
        private String studentName;
    
    }
    
    @Entity
    @Data
    @Accessors(chain = true)
    public class Teacher {
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        @ApiModelProperty("教师ID")
        @Column(insertable = false, updatable = false, columnDefinition = "INT UNSIGNED COMMENT '教师ID'")
        private Integer teacherId;
    
        @ApiModelProperty("教师名")
        @Column(length = 50, columnDefinition = "VARCHAR(255) NOT NULL COMMENT '教师名'")
        private String teacherName;
    
    }
    

    两张表目前是没有什么关联的

    一、单纯使用注解

    相信大家去百度或者谷歌第一种推荐的就是使用自带的注解:

    • @OneToOne
    单向一对一

    如果一个学生对应一个老师,那么就需要在教师表或者学生表添加对应关联的ID,而使用注解就只需在学生表添加

    @OneToOne
    @JoinColumn(name = "teacher_id", referencedColumnName = "teacherId")
    //设置生成的外键名称为teacher_id,对应Teacher类中的teacherId
    private Teacher teacher;
    

    自动创建表你会发现student表中会增加teacher_id的外键,如果不想自动创建外键可以在@JoinColumn中加入 foreignKey = @ForeignKey(name = “none”, value = ConstraintMode.NO_CONSTRAINT),表示不创建外键。这时查询单独查Student也会查询到Teacher。

    双向一对一

    有时我想根据Teacher查询到对应的Student,那么需要在Teacher类中添加

    @OneToOne(mappedBy = "teacher")//对应Student中的Teacher对象的名字
    private Student student;
    

    这样就可以两边都查询到对应的信息。

    • @OneToMany
    • @ManyToOne

    一对多和多对一和一对一其实基本一样,只不过把对象换成List,查询时就能获取对应的集合,这里不多描述。

    • @ManyToMany

    多对多其实和上面的也基本一样,只不过这是不能使用单个字段,需要创建一张中间表进行映射,需要加入把Student类中的teacher修改:

    @ManyToMany
    @JoinTable(name = "student_teacher_inner",  //创建中间表student_teacher_inner
    joinColumns = {@JoinColumn(name = "student_id", referencedColumnName = "studentId")},
    inverseJoinColumns = {@JoinColumn(name =  "teacher_id",referencedColumnName = "teacherId")})
    private List<Teacher> teacher;
    

    @JoinTable

    joinColumns元素描述关系所有方在中间表的连接列,inverseJoinColumns元素指定了反方在中间表的连接列。

    对于这种注解相信大家都很熟悉了,我这边就不仔细讲解了,主要注意的点有:

    • 自动建立外键

    如果用这种方法查询就避免不了建外键,而外键主要是保证数据库数据的完整性和一致性,对于使用外键有好处也有坏处,主要坏处是操作数据方面有了很多的限制,增加了维护成本,需要看你怎么取舍,但很多项目都是业务进行控制数据库的完整性和一致性,不需要建立外键。

    • 不能分页查询

    如果是一对多,多对多,那么只能一次查询全部对应的集合,不能使用分页。

    • 双向关联会出现死循环

    例如你查询Student对象,哪里Student里有Teacher,而Teacher里又有Student,所以会一直循环下去,如果用toString方法或转成JSON那么是必然会造成死循环的,所以利用sping boot等框架将后台数据返回给前台也是同理,需要Student对象的teacher变量上加上注解:

    @JsonIgnoreProperties(value = {"student"})
    

    表明忽略字段名称student,同理Teacher对象也需要加上对应的注解

    • 运行时报错

    No serializer found for class org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer
    and no properties discovered to create BeanSerializer

    需要在对象上加上

    @JsonIgnoreProperties(value = {"handler", "hibernateLazyInitializer", "fieldHandler"})
    
    • 复杂查询需要额外使用Specification

    如果两张表都是双向多对多关系,那么我想根据教师查出学生名字等于“学生3”的Student集合,这时就需要

    Specification<Teacher> specification = Specification.where((root, query, cb) -> {
        Join<Teacher, student> join = root.join("student", JoinType.LEFT);
        return cb.equal(join.get("studentName"), "学生3");
    });
    List<Teacher> all = teacherDao.findAll(specification);
    

    这里只写了实现代码,具体解析就不详细说明

    二、使用@Query注解

    如果觉得上面的方法很难用,而且没有分页查询,那么可以使用@Query注解查询,需要说明一下@Query默认使用hsql语言进行查询,如果不知道hsql是什么可以百度一下,两者最大的区别就是sql是使用表的字段名,而hsql是使用表的字段名,其他语法略有不同。

    • 现在学生教师一对一,在学生表手动创建一个teacher_id字段用来对应教师表,通过学生获取对应的教师
    • 创建一个StudentVO展示获取到的数据
    @Data
    @Accessors(chain = true)
    public class StudentVO {
    
        @ApiModelProperty("学生ID")
        private Integer studentId;
    
        @ApiModelProperty("学生名")
        private String studentName;
    
        @ApiModelProperty("教师ID")
        private Integer teacherId;
    
        @ApiModelProperty("教师名称")
        private String teacherName;
    
        public StudentVO(Integer studentId, String studentName, Integer teacherId, 	   String teacherName) {
            this.studentId = studentId;
            this.studentName = studentName;
            this.teacherId = teacherId;
            this.teacherName = teacherName;
        }
        
        public StudentVO() {
        }
    
    }
    
    
    • 通过在Dao编写方法获取到对应的值
    //没有构造函数会报Unable to locate appropriate constructor on class
    @Query(value = "select new com.luwei.model.student.StudentVO(s.studentId,s.studentName ,t.teacherId ,t.teacherName) " +
    "from Student s left join Teacher t  on s.teacherId=t.teacherId")
    Page<StudentVO> findCustom(Pageable pageable);
    
    

    这样很简单就能进行联合查询,如果里想用传统的sql语句可以把nativeQuery 改为true表示使用传统sql语句,需要注意的是分页sql语句需要自己实现

    //不用驼峰,不然会报找不到列名
    @Query(value = "select s.student_id ,s.student_name,t.teacher_id " +
    "from tb_student s left join tb_teacher t  on s.teacher_id = t.teacher_id ",
    countQuery = "SELECT COUNT(*) FROM tb_student", nativeQuery = true)
    Page<Student> findCustom(Pageable pageable);
    
    

    运用@Query也很容易根据自己的sql语句查询到对应的字段,但有唯一的缺点,不能动态查询,也是致命的缺点,不能像mybatis哪有可以根据你的参数是否为空来进行动态添加,对于参数不确定时需要编写不同的方法,所以如果需要动态查询的不适用使用该注解。那么有没有一种可以动态查询的方法了?答案是有的。

    三、使用EntityManager

    EntityManager是JPA中用于增删改查的接口,它的作用相当于一座桥梁,连接内存中的java对象和数据库的数据存储。那么如何获得EntityManager对象呢?这取决于你的EntityManger对象的托管方式,主要有以下两种方式:

    • 容器托管的EntityManager对象

    容器托管的EntityManager对象最为简单,编程人员不需要考虑EntityManger的连接,释放以及复杂的事务问题等等,所有这些都交给容器来完成。

    • 应用托管的EntityManager对象

    应用托管的EntityManager对象,编程人员需要手动地控制它的释放和连接、手动地控制事务等。

    我这边使用容器托管,获取EntityManager对象如下:

    @PersistenceContext
    private EntityManager entityManager;
    
    

    现在我获取学生名字带有小明的StudentVO的信息就需要这样编写代码:

    //需要无参构造方法,编写sql语句
    StringBuilder sql = new StringBuilder("select s.student_id StudentId,s.student_name StudentName,t.teacher_id teacherId,t.teacher_name teacherName " +
    "from tb_student s left join tb_teacher t  on s.teacher_id = t.teacher_id where 1=1 ");
    //查询参数
    String studentName = "小明";
    if (!TextUtils.isEmpty(studentName)) {
    	sql.append(" and s.student_name = ? ");
    }
    
    //添加普通sql查询
    NativeQueryImpl sqlQuery = entityManager.createNativeQuery(sql).unwrap(NativeQueryImpl.class);
    
    //映射返回类
    Query query = sqlQuery.setResultTransformer(Transformers.aliasToBean(StudentVO.class));
    //添加查询参数
    query.setParameter(1, studentName);
    
    //执行
    List<StudentVO> list = query.getResultList();
    
    

    这样就可以实现查询,如果有动态条件只需拼接好sql就可以了,但这个方法还有一个缺点,就是不能自动帮我们分页,需要我们自己拼接分页条件。有的人就可能会说了,这样每次都需要拼接是不是很麻烦啊,但如果你把所有逻辑抽成一个方法,就会发现其实感觉还可以。

    示例

    下面示范下分页查询如果学生名字带有小明的学生和教师的信息,返回依然时StudentVO。准备一下抽出来的方法:

    • 把基本查询sql语句转为查询总数的sql语句的方法

    其实我们用page,看日志就会发现,每次分页查询都是执行两条sql语句,一条是查询总数的sql,一条原来的sql,是因为框架帮我们把原来的sql语句转成可以查询总数的sql语句,我们也写一个类似的方法

    /**
     * 转为查询总数的sql语句
     *
     * @param sql 原来的sql语句
    */
    private static String getCountSql(String sql) {
        String substring = null, replace = null;
        if (sql.toLowerCase().startsWith("select")) {
            int from = sql.lastIndexOf("FROM");
            if (from != -1) {
                substring = sql.substring(6, from);
    
            } else if ((from = sql.lastIndexOf("from")) != -1) {
                substring = sql.substring(6, from);
            }
        }
        if (substring != null) {
            replace = sql.replace(substring, " count(*) ");
        }
        return replace;
    }
    
    

    这方法只是简单的转换,找到select后把后面的参数都换为count(*),这其实并不严谨,仅供参考

    • 拼接分页条件方法

    原来的sql语句也需要拼接limt 关键字,

    /**
     * 拼接分页字符串
     *
     * @param stringBuilder
     * @param page 多少页
     * @param size 每页多少个
     */
    public static StringBuilder createLimit(StringBuilder stringBuilder, Integer page, Integer size) {
        return stringBuilder.append(" LIMIT ").append(page * size).append(" , ").append(size);
    }
    
    
    • 获取总页数的方法
    /**
     * @param total 总数
     * @param size  每页多少个
     * @return 一共有多少页
     */
    public static int getTotalPages(int total, int size) {
        return (total + size) / size;
    }
    
    
    • 查询方法

    最后还需把上面这些方法抽成一个查询方法中

     /***
         *
         * @param sql 查询的原sql语句
         * @param page 分页
         * @param clazz 返回的对象
         * @param conditionList where条件集合
         * @param <T>
         * @return 返回page
         */
        private <T> Page<T> findPage(StringBuilder sql, Pageable page, T clazz, List<String> conditionList) {
            //原sql转换查询总数sql语句
            String countSql = getCountSql(sql.toString());
            Query countQuery = entityManager.createNativeQuery(countSql);
            //原sql语句添加limit
            StringBuilder limit = createLimit(sql, page.getPageNumber(), page.getPageSize());
            NativeQueryImpl sqlQuery = entityManager.createNativeQuery(limit.toString()).unwrap(NativeQueryImpl.class);
            Query nativeQuery = sqlQuery.setResultTransformer(Transformers.aliasToBean(clazz.getClass()));
    
            //添加where条件
            for (int i = 1; i <= conditionList.size(); i++) {
                countQuery.setParameter(i, conditionList.get(i - 1));
                nativeQuery.setParameter(i, conditionList.get(i - 1));
            }
            //查询总数
            int total = ((BigInteger) countQuery.getResultList().get(0)).intValue();
            //原sql查询到内容
            List<T> list = nativeQuery.getResultList();
            //设置分页信息
            return new PageImpl<>(list, page, getTotalPages(total, page.getPageSize()));
        }
    
    

    最后调用findPage查询方法,就能获取到对应的参数了

    //分页参数
    Pageable pageRequest = PageRequest.of(1, 2);
    //查询的sql语句
    StringBuilder sql = new StringBuilder("select s.student_id StudentId,s.student_name StudentName,t.teacher_id teacherId,t.teacher_name teacherName " +
            "from tb_student s left join tb_teacher t  on s.teacher_id = t.teacher_id where 1=1 ");
    String studentName = "小明";
    //where条件的list
    List<String> conditionList = new ArrayList<>();
    //模拟是否需要添加条件
    if (!TextUtils.isEmpty(studentName)) {
        sql.append(" and s.student_name = ? ");
        conditionList.add(studentName);
    }
    Page<StudentVO> page = findPage(sql, pageRequest, new StudentVO(), conditionList);
    
    

    四、总结

    总的来说查询有三种方法:

    • 单纯使用注解

    比较简单,一般需要创建外键,如果不是多对多也可以不创,不能分页查询,如果只是简单一对一可以使用,其他情况复杂不推荐。

    • 使用@Query注解

    也是比较简单,可以帮你实现分页逻辑,但不能动态条件参数查询,不适合查询条件参数不确定的情况,如果查询条件确定,那么是推荐使用这种。

    • 使用EntityManager

    用起来相当复杂,需要自己拼接查询条件和分页条件,但如果抽成方法用起来还是蛮舒服的,所以最终还是推荐使用EntityManager进行复杂查询。

    展开全文
  • Kibana:几种创建 filter 的方法

    千次阅读 2021-01-04 11:40:40
    在 实际的 Kibana 使用中,我们经常会使用... 例如,过滤器和搜索都将转换为查询 DSL(Elasticsearch 使用的查询),并且两者都可以过滤将要显示的文档。 但是,过滤器提供的主要优点之一是您不仅限于一个过滤器。 您可
  • SQL优化常用的几种方法

    万次阅读 多人点赞 2020-06-29 14:42:42
    在使用JPA时常常出现业务复杂不方便使用名称解析的情况,这时可采用原生SQL来实现,SQL在请求并发数量较多时效率会影响系统的整体效率,在此记录一下sql优化的常用几种方法。 二、优化方法 1、对查询进行优化,...
  • 创建Image图像的几种方法

    千次阅读 2017-01-17 16:46:02
    创建Image图像的方式主要分三,一是通过File文件创建Image图像,二是通过ImageIcon创建Image图像,三是通过Toolkit中的函数创建Image图像。  一、通过File文件创建Image图像 1、通过文件选择器选择文件,创建File...
  • 1.创建并启动线程的6方式: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和FutureTask创建线程 4)使用线程池,例如用Executor框架 5)Spring实现多线程(底层是线程池) 6)定时器Timer ...
  • 数据仓库常用几种建模方法

    万次阅读 2019-02-18 14:43:31
    数据模型是抽象描述现实世界的一工具和方法,是通过抽象的实体及实体之间联系的形式,来表示现实世界中事务的相互关系的一映射。在这里,数据模型表现的抽象的是实体和实体之间的关系,通过...
  • neo4j - 查询效率的几种优化思路

    万次阅读 2019-04-14 18:44:12
    尊敬的读者您好:笔者很高兴自己的文章能被阅读,但...若觉得本文对您益处还请帮忙点个赞鼓励一下,笔者在此感谢每一位读者,如需联系笔者,请记下邮箱:zengzenghe@gmail.com,谢谢合作! 最近在公司实...
  • sql优化常用的几种方法,19种最有效的sql优化技巧 本文我们来谈谈项目中常用的MySQL优化方法,共19条,具体如下: 1、EXPLAIN 做MySQL优化,我们要善用EXPLAIN查看SQL执行计划。 下面来个简单的示例,标注(1...
  • 2019access创建数据表、查询和窗体

    万次阅读 2019-10-25 13:59:14
    打开access,在菜单栏选择创建,我们可以看到 “表格” 、“查询”、“窗体”等模块,我们可以通过这些按钮来进行表的创建查询设计、窗体的创建。 图一图一图一 1.创建表 1)点击 “表” 点击 “表” ,出现下...
  • SQL Server创建链接服务器的几种方式

    万次阅读 2020-11-24 13:04:53
    了链接服务器,我们不需要写任何的程序,就可以实现将一个数据库的数据复制到另一个数据库。 SQL Server链接服务器不仅可以帮助你链接SQL Server,还可以链接Oracle、Access、MySQL、ODBC数据源。 1. SQL Server...
  • 为什么要使用线程池;常见的创建线程池的4方式

    万次阅读 多人点赞 2018-04-14 17:51:49
    常用的几种线程池 5.1  newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 这种类型的线程池特点是: 工作线程的创建数量几乎没有限制 ( 其实...
  • MySQL数据库优化的几种方式

    万次阅读 2018-08-07 20:28:13
    分享一下常见的几种MySQL数据优化方式。。。。。。。 选取最适合的字段属性 1、MySQL可以很好的支持数据量的很大的存取,但是一般说来,数据库中的表越小其查询的速度就也快。所以,可以在建表的时候,为了获取更好...
  • 索引的几种类型以及索引的优缺点

    千次阅读 2020-04-08 19:41:54
    索引的几种类型分别是普通索引、唯一索引、聚集索引、主键索引、全文索引。 唯一索引:在创建唯一索引时要不能给具有相同的索引值。 主键索引:在我们给一个字段设置主键的时候,它就会自动创建主键索引,用来...
  • 【MySQL】创建外键的两方式

    万次阅读 多人点赞 2019-02-19 10:55:21
    使用MySQL关联数据表时,创建外键的两方式:创建表时增加外键,已存在表增加外键。以下案例通过Navicat for MySQL实现。 1.创建表时增加外键 首先创建第一张被关联表Vendors商品供应商表。 -- 供应商列表 ...
  • Bmob中的几种查询方法

    万次阅读 2015-12-19 15:03:52
    //执行查询方法 query.findObjects(this, new FindListener() { @Override public void onSuccess(List<Lost> object) { // TODO Auto-generated method stub showToast("查询成功:共" + object.size() + "条...
  • oracle两临时表的创建及使用方法

    万次阅读 2017-08-23 15:50:19
    oracle数据库的临时表可以用来保存一个会话session的数据,或者一个事务...创建临时表方式:  1、会话级临时表 on commit delete rows; 当COMMIT的时候删除数据(默认情况)  2、事务级临时表 on commit p
  • sql优化的几种方式

    万次阅读 多人点赞 2018-11-05 10:20:46
    我们开发项目上线初期,由于业务数据量相对较少,一些SQL的执行效率对程序运行效率的影响不太明显,而开发和运维人员也无法判断SQL对程序的运行效率多大,故很少针对SQL进行专门的优化,而随着时间的积累,业务...
  • 各种数据库查询条数据的方法

    万次阅读 2018-09-05 10:08:42
    sql在不同数据库查询条数据 关键字: sql 前条结果  sql在不同数据库查询条数据  1. ORACLE   SELECT * FROM TABLE1 WHERE ROWNUM&lt;=N    select * from stu_info where rownum&lt;=10 ...
  • Linux查看日志的几种方法

    万次阅读 2021-04-25 08:41:50
    $cat >filename //从键盘创建一个文件 $cat file1 file2 >file //将个文件合并为一个文件,只能创建新文件,不能编辑已文件 $cat -n textfile1 > textfile2 //将一个日志文件的内容追加到另一个; $cat : >text...
  • SQL Server的数据库创建、修改、查询、删除

    万次阅读 多人点赞 2018-08-14 10:08:40
    一、创建数据库(create database 数据库名) 基本常识: 语法: 建立数据库: 二、修改数据库 修改数据库名字 向数据库中添加文件组和文件 修改数据库文件 三、查询数据库sp_helpdb、sp_spaceued sp_helpdb:...
  • Hive插入数据的几种常用方法

    千次阅读 2020-12-20 23:45:49
    Hive的几种常见的数据导入方式这里介绍四种:(1)、从本地文件系统中导入数据到Hive表;(2)、从HDFS上导入数据到Hive表;(3)、从别的表中查询出相应的数据并导入到Hive表中;(4)、在创建表的时候通过从别的表中查询出...
  • sql优化的几种方法

    万次阅读 多人点赞 2017-08-17 20:59:55
    在sql查询中为了提高查询效率,我们常常会采取一些措施对查询语句进行sql优化,下面总结的一些方法需要的可以参考参考。 1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上...
  • 页面间传递数据的几种方法

    千次阅读 2017-06-09 09:09:00
    在页面间传递数据时,我们以下几种选择:  1、Query String   一个很常见的方法,Query String是URL中问号之后的那一部分。其优点在于它是轻量级的,不会给服务器带来任何负担。而它也几个缺点:传递的...
  • 今天看到一位博友的文章,觉得不错,转载一下,希望对大家帮助,更多文章,请访问... 4、内存不足 5、网络速度慢 6、查询出的数据量过大(可以采用多次查询,其他的方法降低数据量) 7、锁或者死锁(这也是查询...
  • Access中不匹配项查询的三种方法

    千次阅读 2020-12-30 17:36:11
    龙源期刊网http://www.qikan.com.cnAccess中不匹配项查询的三种方法作者:马鹏卫来源:《软件导刊》2013年第01期摘要:查找两个表之间不匹配项数据是全国计算机等级考试二级Access上机考题中新增加的考点,属于考试...
  • 几种SAP增强的查找方法

    万次阅读 2018-04-04 09:36:25
    ***方法一****************************************通过SE30,运行TCODE后,点Evaluate后,查看运行时间分析评估:命中清单。找以“exit”开头的SAP程序,如:EXIT_SAPLIE01_007,这个FUNCTION就是TCODE提供的一个...
  • 1、三事实表概述 2、三事实表对比 3、事实表设计 8 大原则 4、事实表设计方法 第一步:选择业务过程及确定事实表类型 第二步:声明粒度 第三步:确定维度 第四步:确定事实

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 523,883
精华内容 209,553
关键字:

创建查询的方法分别有哪几种