mybatis 排序 mybatis排序不生效

ja中的>>怎么算

public Criteria andSaleNotBetween(Integer value1, Integer value2) {

int index = 7;

mybatis 排序 mybatis排序不生效

mybatis 排序 mybatis排序不生效

list.add("Jam");

int index2 = index>1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成的sql为order by "id".>1,则表示将7转化为二进制数后向右移动一位，而原值不变，故index = 7 ,index2 = 3；

int index3 = index>>=1,则表示将7转化为二进制数后向右移动一位并且将结果赋值给原值，故 index = 3 ，index3 = 3.

mybatis中的#和$的区别

自定义打印：Jam

首先通过下面两条sql及打印的执行sql，清楚明了的看一下它们的区别：

select

user

where

userId=${id}

password=#{pwd}

12345678

假设入参ja中>>代表的是向右移位运算，而>>=代表的是向右移位运算时将运算的结果同时赋值给原值，举个例子说明一下：传入的是1，打印执行sql如下：

Preparing:select

user

where

id=1

password=111111

select

user

where

userId=#{id}

password=#{pwd}

12345678

同样入参传入1，打印的执行sql如下：

Preparing:select

user

where

id=？

p4、熟练运用jaAPI相关知识；assword=?

Parameters:1(String),111111(String)

MyBatis启用了预编译功能，在SQL执行前，会先将上面的SQL发送给数据库进行编译；执行时，如果入参为#{}格式的，将入参替换编译好的sql中的占位符“?”；如果入参格式为${}，则直接使用编译好的SQL就可以了。因为SQL注入只能对编译过程起作用，所以使用#{}入参的方式可以很好地避免了SQL注入的问题。

mybatis预编译底层实现原理

MyBatis是如何做到SQL预编译的呢？其实在框架底层，是JDBC中的PreparedStatement类在起作用，PreparedStatement是我们很熟悉的Statement的子类，它的对象包含了编译好的SQL语句。这种“准备好”的方式不仅能提高安全性，而且在多次执行同一个SQL时，能够提高效率。原因是SQL已编译好，再次执行时无需再编译。

总结

#{}：相当于JDBC中的PreparedStatement

${}：是输出变量的值

简单说，#{}是经过预编译的，是安全的；${}是未经过预编译的，仅仅是取变量的值，是非安全的，存在SQL注入。

番外（sql注入）

还是以上面的两条sql为例，入参id的值传入“1

or

userId=2”,入参pwd的值传入“111111”。以#{}格式传入入参后的执行sql：

select

user

where

userId=”1

or

userId=2”

=“111111”;

以${}格式传入入参后的执行sql：

select

user

where

userId=1

or

userId=2

=111111;

很显然，以${}格式传入入参后的执行sql打乱了我们的预期sql格式及查询条件，从而实现sql注入。所以，除了order

by

等需要传入数据库字段等的入参使用${},其他的尽量使用#{}。

mybatis中的#和$的区别 以及 防止sql注入

作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfB// spliterator1:8~10 spliterator3:6~7oundsException。

4.$方式无法防止Sql注入。

字符串替换

默认情况下，使用#{}格式的语导致MyBatis创建预处理语句属性并以它为背景设置安全的值（比如?）。这样做很安全，很迅速也是做法，有时你只是想直接在SQL语句中插入一个不改变的字符串。比如，像ORDER BY，你可以这样来使用：

这里MyBatis不会修改或转义字符串。

重要：接受从用户输出的内容并提供给语句中不变的字符串，这样做是不安全的。这会导致潜在的SQL注入攻击，因此你不应该允许用户输入这些字段，或者通常自行转义并检查setOrderByClause方法注入。

MyBatis中#和$的区别详解

from

mybatis中的#和$的区别

#相当于对数据 加上 双引号，$相当于直接显示数据

4.$方式无法防止Sql注入。

字符串替换

默认情况下，使用#{}格式的语导致MyBatis创建预处理语句属性并以它为背景设置安全的值（比如?）。这样做很安全，很迅速也是做法，有时只是想直接在SQL语句中插入一个不改变的字符串。比如，像ORDER BY，可以这样来使用：

这里MyBatis不会修改或转义字符串1.3 spliterator方法。

重要：接Jam受从用户输出的内容并提供给语句中不变的字符串，这样做是不安全的。这会导致潜在的SQL注入攻击，因此不应该允许用户输入这些字段，或者通常自行转义并检查。

ja类哪个函数可以

阶段六：全栈项目实战

ja里面的函数

boolean retainAll(Collection> c); //将c中不包含的元素移除

ja里面的函数_ja【1】——— 从接口框架说起

百里方欣

原创

关注

0点赞·155人阅读

(一) ja分类

之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说ja里面的类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列的规范，每次只能存储一个元素，而Map接口定义了双列的规范，每次能存储一对元素。

Iterable接口:主要是实现遍历功能

Collection接口: 允许重复

Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。

List接口：有序且可重复，可以根据元素的索引来访问中的元素。

Queue接口：队列

Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。

整个接口框架关系如下(来自百度百科)：

(1) Iterable接口

1. 内部定义的方法

ja最源头的接口，实现这个接口的作用主要是对象可以通过迭代器去遍历每一个元素。

源码如下：

// 返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)

Iterator iterator();

// 遍历内部元素，action意思为动作，指可以对每个元素进行作(JDK1.8添加)

default void forEach(Consumer super T> action) {}

// 创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。

default Spliterator spliterator() {

return Spliterators.spliteratorUnknownSize(iterator(), 0);

}从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Ja 8 新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。

下面我们分别展示三个接口的调用：

1.1 iterator方法

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Sam");

// 返回迭代器

Iterator iterator=list.iterator();

while(iterator.hasNext()){

//next()作用是返回当前指针指向的元素,之后将指针移向下个元素

System.out.println(iterator.next());

}}

当然也可以使用for-each loop方式遍历

for (String : list) {

System.out.println();

}但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：

public class IterableTest {

public IterableTest() { }

public static void main(String[] args) {

iteratorHasNext();

}public static void iteratorHasNext() {

List list = new ArrayList();

list.add("Sam");

Iterator iterator = list.iterator();

Iterator var2 = list.iterator();

String = (String)var2.next();

System.out.println();

}}

}需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。

public static void iteratorHasNext(){

List list=new ArrayList();

list.add("Sam");

for (String : list) {

if(.equals("Jam")){

list.remove();

}System.out.println();

}}

从下面的错误我们可以看出，个元素是有被打印出来的，也就是remove作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。

Exception in thread "main" ja.util.ConcurrentModificationException

at ja.util.ArrayList$Itr.checkForComodification(ArrayList.ja:909)

at ja.util.ArrayList$Itr.next(ArrayList.ja:859)

at IterableTest.iteratorHasNext(IterableTest.ja:15)

at IterableTest.main(IterableTest.ja:7)

1.2 forEach方法

其实就是把对每一个元素的作当成了一个对象传递进来，对每一个元素进行处理。

Objects.requireNonNull(action);

for (T t : this) {

action.accept(t);

}}

```ja

当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在ja8中参数是`ja.util.function.Consumer`,可以称为消费行为或者说动作类型。

```ja

list.forEach(x -> System.out.print(x));

同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。

public class ConsumerTest {

public static void main(String[] args) {

List list=new ArrayList();

list.add("Sam");

MyConsumer myConsumer = new MyConsumer();

Iterator it = list.iterator();

list.forEach(myConsumer);

}static class MyConsumer implements Consumer {

@Override

public void accept(Object t) {

System.out.println("自定义打印：" + t);

}}

}输出的结果：

自定义打印：Jane

自定义打印：Sam

这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，ja默认在框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：

// stream使用的就是spliterator

default Stream stream() {

return StreamSupport.stream(spliterator(), false);

return Spliterators.spliterator(this, 0);

}public static Stream stream(Spliterator spliterator, boolean parallel) {

Objects.requireNonNull(spliterator);

return new ReferencePipeline.Head<>(spliterator,

StreamOpFlag.fromCharacteristics(spliterator),

parallel);

}使用的方法如下：

public static void spliterator(){

List list = Arrays.asList("1", "2", "3","4","5","6","7","8","9","10");

// 获取可迭代器

Spliterator spliterator = list.spliterator();

// 一个一个遍历

System.out.println("tryAance: ");

spliterator.tryAance(->System.out.print(+" "));

spliterator.tryAance(->System.out.print(+" "));

System.out.println("\n-------------------------------------------");

// 依次遍历剩下的

System.out.println("forEachRemaining: ");

spliterator.forEachRemaining(->System.out.print(+" "));

// spliterator1:0~10

// spliterator1:6~10 spliterator2:0~5

Spliterator spliterator2 = spliterator1.trySplit();

Spliterator spliterator3 = spliterator1.trySplit();

System.out.println("spliterator1: ");

spliterator1.forEachRemaining(->System.out.print(+" "));

System.out.println("spliterator2: ");

spliterator2.forEachRemaining(->System.out.print(+" "));

System.out.println("spliterator3: ");

spliterator3.forEachRemaining(->System.out.print(+" "));

}tryAance() 一个一个元素进行遍历

forEachRemaining() 顺序地分块遍历

trySplit()进行分区形成另外的 Spliterator，使用在并行作中，分出来的是前面一半，就是不断把前面一部分分出来

结果如下：

tryAance:

1 2

-------------------------------------------

forEachRemaining:

------------------------------------------

spliterator1:

8 9 10

------------------------------------------

split2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id, 如果传入的值是id，则解析成的sql为order by id.erator2:

1 2 3 4 5

------------------------------------------

还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。

2. Collection接口 extend Iterable

Collection接口可以算是类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的异比较大。

2.1 内部定义的方法

源码如下：

boolean add(Object o) //添加元素

boolean remove(Object o) //移除元素

boolean addAll(Collection c) //批量添加

boolean removeAll(Collection c) //批量移除

void clear() //清空

int size() //大小

boolean isEmpty() //是否为空

boolean contains(Object o) //是否包含在中

boolean containsAll(Collection c) //是否包含所有的元素

Iterator iterator() // 获取迭代器

Object[] toArray() // 转成数组

default boolean removeIf(Predicate super E> filter) {} // 删除中复合条件的元素，删除成功返回true

boolean equals(Object o)

int hashCode()

default Spliterator spliterator() {} //获取可分割迭代器

default Stream stream() {} //获取流

default Stream parallelStream() {} //获取并行流

里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。

List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

list.parallelStream()

.forEach(out::println);

2.2 继承Collection的主要接口

graph LR;

Collection -->List-有顺序,可重复

List-有顺序,可重复 -->LinkedList-使用链表实现,线程不安全

List-有顺序,可重复 -->ArrayList-数组实现,线程不安全

List-有顺序,可重复 -->Vector-数组实现,线程安全

Vector-数组实现,线程安全 -->Stack-堆栈,先进后出

Collection-->Set-不可重复,内部排序

Set-不可重复,内部排序-->TreeSet-二叉树实现,排序

Collection-->Queue-队列,先进先出

2.2.1 List extend Collection

继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。

最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的作，不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList作的效率会比Vector好一些。

里面是接口定义的方法：

int size(); //获取大小

boolean isEmpty(); //判断是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); // 转化成为数组(对象)

T[] toArray(T[] a); // 转化为数组(特定位某个类)

boolean add(E e); //添加

boolean remove(Object o); //移除元素

boolean containsAll(Collection> c); // 是否包含所有的元素

boolean addAll(Collection extends E> c); //批量添加

boolean addAll(int index, Collection extends E> c); //批量添加，指定开始的索引

boolean removeAll(Collection> c); //批量移除

default void replaceAll(UnaryOperator operator) {}//替换

default void sort(Comparator super E> c) {}// 排序

void clear();//清除所有的元素

boolean equals(Object o);//是否相等

int hashCode(); //计算获取hash值

E get(int index); //通过索引获取元素

E set(int index, E element);//修改元素

void add(int index, E element);//在指定位置插入元素

E remove(int index);//根据索引移除某个元素

int indexOf(Object o); //根据对象获取索引

int lastIndexOf(Object o); //获取对象元素的一个元素

ListIterator listIterator(); // 获取List迭代器

ListIterator listIterator(int index); // 根据索引获取当前的位置的迭代器

List subList(int fromIndex, int toIndex); //截取某一段数据

default Spliterator spliterator(){} //获取可切分迭代器

上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。

说起List的实现子类：

ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List。线程不安全。

LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。

Vector：和ArrayList不多，但是是线程安全的，即同步。

2.2.2 Set extend Collection

Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。

下面是源码方法：

int size(); //获取大小

boolean isEmpty(); //是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); //转化成为数组

T[] toArray(T[] a); //转化为特定类的数组

boolean add(E e); //添加元素

boolean remove(Object o); //移除元素

boolean containsAll(Collection> c); //是否包含所有的元素

boolean addAll(Collection extends E> c); //批量添加

boolean retainAll(Collection> c); //移除所有不存在于c中的元素

boolean removeAll(Collection> c); //移除所有在c中存在的元素

void clear(); //清空

boolean equals(Object o); //是否相等

int hashCode(); //计算hashcode

default Spliterator spliterator() {} //获取可分割迭代器

主要的子类：

HashSet

允许空值

通过HashCode方法计算获取hash值，确定存储位置，无序。

LinkedHashSet

HashSet的子类

有顺序

TreeSet

如果无参数构建Set，则需要实现Comparable方法。

亦可以创建时传入比较方法，用于排序。

2.2.3 Queue extend Collection

队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。

下面是源码：

boolean add(E e); //插入一个元素到队列，失败时返回IllegalStateException (如果队列容量不够)

boolean offer(E e); //插入一个元素到队列，失败时返回false

E remove(); //移除队列头的元素并移除

E poll(); //返回并移除队列的头部元素，队列为空时返回null

E element(); //返回队列头元素

E peek(); //返回队列头部的元素，队列为空时返回null

主要的子接口以及实现类有：

Deque(接口):Queue的子接口，双向队列，可以从两边存取

ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中

AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法

PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，

BlockingQueue： 在ja.util.concurrent包中，阻塞队列，满足当前无法处理的作。

(2) Map接口

定义双列的规范Map，每次存储一对元素，即key和value。

key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。

key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。

下面的源码的方法：

V put(K key, V value); // 添加元素

V remove(Object key); // 删除元素

void putAll(Map extends K, ? extends V> m); // 批量添加

void clear() // 移除所有元素

V get(Object key); // 通过key查询元素

boolean isEmpty(); // 是否为空

boolean containsKey(Object key); // 是否包含某个key

boolean containsValue(Object value); // 是否包含某个value

Set keySet(); // 获取所有key的set

Collection values(); // 获取所有的value的set

Set> entrySet(); // 返回键值对的set，每一个键值对是一个entry对象

boolean equals(Object o); // 用于比较的函数

int hashCode(); // 计算hashcode

default V getOrDefault(Object key, V defaultValue) // 获取key对应的Value，没有则返回默认值()

default void forEach(BiConsumer super K, ? super V> action) {} // 遍历

default void replaceAll(BiFunction super K, ? super V, ? extends V> function) {} // 批量替换

// 缺少这个key的时候才会添加进去

// 返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value

default boolean remove(Object key, Object value) {} // 移除元素

default boolean replace(K key, V oldValue, V newValue) {} // 替换

default V replace(K key, V value) {} //替换

// 和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值

default V comIfAbsent(K key,Function super K, ? extends V> mappingFunction) {}

// 和comIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回

default V comIfPresent(K key,BiFunction super K, ? super V, ? extends V> remappingFunction) {}

// 不管如何都会执行映射函数，返回value

default V com(K key,BiFunction super K, ? super V, ? extends V> remappingFunction) {}

default V merge(K key, V value,BiFunction super V, ? super V, ? extends V> remappingFunction) {}

值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.

Map的常用的实现子类：

HashMap：由数组和链表组成，线程不安全，无序。

LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。

ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。

HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。

(二)总结

这些原始接口到底是什么？为什么需要？

我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千世界。

秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Ja源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~

Mybatis中如何在添加数据时候实现字段增

ORDER BY ${columnName}

因为是字符串型的数据，而加一作只适用于数值型的数。没有好的办法!

考虑到效率问题，的办法是：在code创建索引，查询code的值（void retainAlwhile(var2.hasNext()) {l(Collection c) // 移除在c中不存在的元素说白了，就是排序），然后在程序中加一作（注意数据类型转换！）

Mybatis中example[Criteria]使用

MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。

Stock.ja

}default Spliterator spliterator() {

StockMapper.ja:

我看只看countByExample接口，看名字就知道是返回给定example参数的结果个数。

再看

StockMapper.xml该方法实现：

再看

foreach表示循环，分隔符是or（或者）重点在于数据集oredCriteria,我们去给定参数StockExample中寻找oredCriteria

再看GeneratedCriteria

我们发现Criteria里面居然还有一个list,我们翻上去看刚好与上面一个foreach里面还有一个foreach对应，那接下来研究Criterion

这就是该类的声明，里面有这些值，这时候应该结合着之前xml第二层foreach属性看了，知道这些值有啥用

一看我们根据when知道有四类情况，noValue,singleValue,betweenValue,listValue,对应着查询中四种情况

1.只是单纯是否非空

2.value=?多少查询

3.两者之间查询

4.在list中查询。

所以我们构建的查询参数就是criterion，看一下上面四种咋构建吧

以下均是lGeneratedCriterial类中方法,addCriterion是把生成的Criterion加到Ctriteria中

1.是否非空：

2.值查询

public Criteria andIdEqualTo(Integer value) {

addCriterion("id =", value, "id");

return (Criteria) this;

}3.两者之间

addCriterion("sale not between", value1, value2, "sale");

return (Criteria) this;

}4.list

public Criteria andVersionNotIn(List values) {

addCriterion("version not in", values, "version");

return (Criteria) this;

}完结，相信通过上面的源码剖析，大家都知道如何构建查询条件了把。

总结

StockExample.ja 构造

三个参数

orderByClause:返回结果升降排序，字段+空格+acs/dcs(升序/降序）例子count acs

distinct：true/false 返回结果去不去重复,setDistinct注入

oredC// hashNext可以判断是否还有元素riteria：就是查询参数，之前狗讲了啥意思，构造方法

构造Criteria

收工。

python后端开发需要学什么?

default void forEach(Consumer super T> action) {

阶段：Python语言基础 主要学习Python最基础知识，如Python3、数据类型、字符串、函数、类、文件作等。阶段课程结束后，学员需要完成Py实战飞机大战、2048等项目。

int size(); // 查询大小

第二阶段：Python语言高级 主要学习Python库、正则表达式、进程线程、爬虫、遍历以及MySQL数据库。

1、熟练掌握ja的开发环境与编程核心知识；

第三阶段：Pythonweb开发 主要学习HTML、CSS、JaScript、jQuery等前端知识，掌握python三大后端框架(Django、 Flask以及Tornado)。需要完成网页界面设计实战;能开发网站。

第四阶段：Linux基础 主要学习Linux相关的各种命令，如文件处理命令、压缩解压命令、权限管理以及Linux Shell开发等。

第五阶段：Linux运维自动化开发 主要学习Python开发Linux运维、Linux运维报警工具开发、Linux运维报警安全审计开发、Linux业务质量报表工具开发、Kali安全检测工具检测以及Kali 实战。

第六阶段：Python爬虫 主要学习python爬虫技术，掌握多线程爬虫技术，分布式爬虫技术。

第七阶段：Python数据分析和大数据 主要学习numpy数据处理、pandas数据分析、matplotlib数据可视化、scipy数据统计分析以及python 金融数据分析;Hadoop HDFS、python Hadoop MapReduce、python Spark core、python Spark SQL以及python Spark MLlib。

第八阶段：Python机器学习 主要学习KNN算法、线性回归、逻辑斯蒂回归算法、决策树算法、朴素贝叶斯算法、支持向量机以及聚类k-means算法。

关于python后端开发需要学什么的内容，青藤小编就和您分享到这里了。如果您对python编程有浓厚的兴趣，希望这篇文章可以为您提供帮助。如果您还想了解更多关于python编程的技巧及素材等内容，可以点击本站的其他文章进行学习。

以下是python全栈开发课程学习路线，可以按照这个课程大纲有规划的进行学习：

阶段一：Python开发基础

Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件作、函数、装饰器、迭代器、内置方法、常用模块等。

阶段二：Python高级编程和数据库开发

Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。

阶段三：前端开发

Python全栈开发与人工智能之前端开发知识学习内容包括：Html、CSS、JaScript开发、Jquery&bootstrap开发、前端框架VUE开发等。

阶段四：WEB框架开发

Python全栈开发与人工智能之WEB框架开发学习内容包括：Django框架基础、Django框架进阶、BBS+Blog实战项目开发、缓存和队列中间件、Flask框架学习、Tornado框架学习、Restful API等。

阶段五：爬虫开发

Python全栈开发与人工智能之爬虫开发学习内容包括：爬虫开发实战。

Python全栈开发与人工智能之全栈项目实战学习内容包括：企业应用工具学习、CRM客户关系管理系统开发、路飞学城在线教育平台开发等。

阶段七：数据分析

Python全栈开发与人工智能之数据分析学习内容包括：金融量化分析。

阶段八：人工智能

Python全栈开发与人工智能之人工智能学习内容包括：机器学习、数据分析 、图像识别、自然语言翻译等。

阶段九：自动化运维&开发

Python全栈开发与人工智能之自动化运维&开发学习内容包括：CMDB资产管理系统开发、IT审计+主机管理系统开发、分布式主机系统开发等。

阶段十：高并发语言GO开发

Python全栈开发与人工智能之高并发语言GO开发学习内容包括：GO语言基础、数据类型与文件IO作、函数和面向对象、并发编程等。

对于初学Ja并且有志于后端开发的同学来说，需要重点关注以下几个部分：

基础：比如计算机系统、算法、编译原理等等

Web开发： 主要是Web开发相关的内容，包括HTML/CSS/js（前端页面）、 Servlet/JSP（J2EE）以及MySQL（数据库）相关的知识。它们的学习顺序应该是从前到后，因此学习的应该是HTML/CSS/JS（前端页面）。

J2EE：你需要学习的是Servlet/JSP（J2EE）部分，这部分是Ja后端开发必须非常精通的部分，因此这部分是这三部分中最需要花精力的。关于Servlet/Jsp部分视频的选择，业界比较认可马士兵的视频。

一步，你需要学会使用数据库，mysql是个不错的入门选择，而且Ja领域里主流的关系型数据库就是mysql。这部分一般在你学习Servlet/Jsp的时候，就会接触到的，其中的JDBC部分就是数据库相关的部分。你不仅要学会使用JDBC作数据库，还要学会使用数据库客户端工具，比如nicat，sqlyog，二选一即可。

开发框架：目前比较主流的是SSM框架，即spring、springmvc、mybatis。你需要学会这三个框架的搭建，并用它们做出一个简单的增删改查的Web项目。你可以不理解那些配置都是什么含义，以及为什么要这么做，这些留着后面你去了解。但你一定要可以快速的利用它们三个搭建出一个Web框架，你可以记录下你次搭建的过程，相信我，你一定会用到的。还要提一句的是，你在搭建SSM的过程中，可能会经常接触到一个叫men的工具。这个工具也是你以后工作当中几乎是必须要使用的工具，所以你在搭建SSM的过程中，也可以顺便了解一下men的知识。在你目前这个阶段，你只需要在网络上了解一下men基本的使用方法即可，一些高端的用法随着你工作经验的增加，会逐渐接触到的。

总而言之，这个阶段，你需要做的是深入了解Ja底层和Ja类库，也就是JVM和JDK的相关内容。而且还要更深入的去了解你所使用的框架，方式比较看源码或者看文档。

学python后端 学什么 这不一定 主流的框架 django。falsk 比较不错。建议一定要系统学习。 建议如果是没有入行。如果在老男孩教育不错 可以了解一下

mybatis中的$和#的区别？

spliterator3:

#相当于对数据 加上 双引号，$相当于直接显示数据

#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id#，如果传入的值and是111,那么解析成sql时的值为order by "111", 如果传入的值是id，则解析成Set-不可重复,内部排序-->HashSet-hash表存储的sql为order by "id".

$将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id, 如果传入的值是id，则解析成的sql为order by id.

4.$方式无法防止Sql注入。