反射 Reflection

概念

静态语言和动态语言

动态语言是一类在运行时可以改变其结构的语言。例如新的函数、对象甚至代码都可以在运行时引进，已有的函数可以被删除，或者结构上做一些其他的变化。主要的动态语言有：C#、JavaScript、PHP、Python等。

静态语言是运行时结构不可变的语言。例如Java、C、C++。Java虽然不是动态语言，但可以称之为准动态语言。即Java有一定的动态性，可以利用反射机制获得类似动态语言的特性。

Class类

JRE为每个类都保留了一个不变的Class类型的对象。

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个class文件
• 通过Class可以完整地得到一个类中的所有被加载的结构
• Class类是Reflection的根源，针对任何想动态加载、运行的类，只有先获得相应的Class对象

常用方法

类的加载与ClassLoader的理解

• 加载

  将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

  标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

• 链接

  将Java类的二进制代码合并到JVM的运行状态之中的过程。

  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
  • 准备：正式为类变量分配内存并设置变量默认初始值的阶段，这些内存都将在方法区中进行分配。
  • 解析：虚拟机常量池内的**符号引用(常量名)替换为直接引用(地址)**的过程。

• 初始化

  • 执行类构造器<clinit>()方法的过程。该方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（静态代码合并，按先后顺序执行）。
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先出发其父类的初始化。
  • 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

  以下情况不会发生类的初始化：

  • 访问一个静态域时，只有真正声明这个域的类才会被初始化。例如通过子类引用父类的静态变量，不会导致子类初始化。
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会出发此类的初始化(在链接阶段就存入调用类的常量池中了)

类加载器的作用

类加载器将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时结构数据，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

• 引导类加载器 Bootstrap Classloader

  C++编写，JVM自带的类加载器，负责Java平台核心库，用来装载核心类库，无法直接获取。

• 扩展类加载器 Extension Classloader

• 系统类加载器 System Classloader / Application Classloader

  是最常用的类加载器

反射 (Reflection) 是 Java 的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。程序中一般的对象的类型都是在编译期就确定下来，而 Java 反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类的结构信息，可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以形象地称之为反射。

反射的核心是 JVM 在运行时才动态加载类或调用方法/访问属性，它不需要事先知道运行对象是谁。

Java 反射主要提供以下功能：

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
• 在运行时调用任意一个对象的方法
• 在运行时处理注解
• 生成动态代理

使用场景

很多人都认为反射在实际的 Java 开发应用中并不广泛，其实不然。当我们在使用 IDE(如 Eclipse，IDEA)时，当我们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。

反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的，为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射，运行时动态加载需要加载的对象。

对于框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。

反射的使用

反射相关的类一般都在java.lang.relfect包里。

获得Class对象

可以获得Class对象的类型：

1. 各种Class（外部类、成员内部类、静态内部类、局部内部类、匿名内部类）
2. interface
3. 数组
4. enum
5. 注解
6. 基本数据类型
7. void

有4种方法可以获得Class对象：

1. 若已知具体的类，通过类的class属性获取，该方法最安全可靠，程序性能最高。

1
2
3

Class c1 = Person.class;

Class c2 = int.class;

2. 已知某个类的实例对象，调用对象的getClass()方法获取Class对象

   1	Class c1 = person.getClass();

3. 已知一个类的全类名，且在该类的类路径下，可使用Class类的静态方法forName()获取，可能抛出ClassNotFoundException

1

Class c1 = Class.forName("com.hunter.reflection.User");

4. 内置基本数据类型可以直接使用类名.Type

   1	Class c3 = Integer.TYPE;

判断是否为某个类的实例

一般地，我们用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中 Class 对象的 isInstance() 方法来判断是否为某个类的实例，它是一个 native 方法：

1

public native boolean isInstance(Object obj);

native方法：具体实现由非java语言实现的方法

创建实例

通过反射来生成对象主要有两种方式。

1. 使用Class对象的newInstance()方法来创建Class对象对应类的实例

类必须要有一个无参构造器

1
2

Class<?> c = String.class; // 当赋值的类型不确定的时候，泛型用通配符？代替
Object str = c.newInstance();

2. 先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。

这种方法可以用指定的构造器构造类的实例。

1
2
3
4
5

Class<?> c = String.class;
Constructor constructor = c.getConstructor(String.class);
// 根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

获取方法

获取某个Class对象的方法集合，主要有以下几个方法：

1. getDeclaredMethods

   返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法

   1	public Method[] getDeclaredMethods() throws SecurityException

2. getMethods

   返回某个类的所有公共方法，包括继承的公用方法

   1	public Method[] getMethods() throws SecurityException

3. getMethod

   返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象。

   1	public Method getMethod(String name, Class<?>... parameterTypes)

举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class test1 {
	public static void test() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
	        Class<?> c = methodClass.class;
	        Object object = c.newInstance();
	        Method[] methods = c.getMethods();
	        Method[] declaredMethods = c.getDeclaredMethods();
	        //获取methodClass类的add方法
	        Method method = c.getMethod("add", int.class, int.class);
	        //getMethods()方法获取的所有方法
	        System.out.println("getMethods获取的方法：");
	        for(Method m:methods)
	            System.out.println(m);
	        //getDeclaredMethods()方法获取的所有方法
	        System.out.println("getDeclaredMethods获取的方法：");
	        for(Method m:declaredMethods)
	            System.out.println(m);
	    }
    }
class methodClass {
    public final int fuck = 3;
    public int add(int a,int b) {
        return a+b;
    }
    public int sub(int a,int b) {
        return a+b;
    }
}

获取构造器信息

获取类构造器的用法与上述获取方法的用法类似。

• getDeclaredConstructors()：所有public的构造方法
• getConstructors()：全部构造方法
• getDeclaredConstructor
• getConstructor

主要通过Class类的getConstructor方法得到Constructor类的一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例：

1

public T newInstance(Object... initargs)

获取类的成员变量信息

• getDeclaredFields：所有已声明的成员变量，但不能得到父类的成员变量
• getFields：访问公有的成员变量
• getField：获取指定的公有成员变量
• getDeclaredField：获取指定的已声明成员变量

反射调用方法

当从类中获取了一个方法后，就可以用invoke()方法来调用这个方法。

若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法。

Method、Field和Constructor对象都有setAccessible()方法，作用是启动和禁用访问安全检查的开关。

• 参数为true则指示反射的对象在使用时应该取消Java语言的访问检查。
  • 提高了反射效率
  • 可以访问私有成员

1

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException

下面是一个实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class test1 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> klass = methodClass.class;
        //创建methodClass的实例
        Object obj = klass.newInstance();
        //获取methodClass类的add方法
        Method method = klass.getMethod("add",int.class,int.class);
        //调用method对应的方法 => add(1,4)
        Object result = method.invoke(obj,1,4);
        System.out.println(result);
    }
}
class methodClass {
    public final int fuck = 3;
    public int add(int a,int b) {
        return a+b;
    }
    public int sub(int a,int b) {
        return a+b;
    }
}

反射操作注解

1
2
3
4
5
6

Annotation[] annotations = c1.getAnnotations(); // 获取注解
for (Annotation annotation : annotations) {
    System.out.println(annotation);
    String value = annotaion.value();
    System.out.println(value);
}

setAccessible

设置可访问方法、属性、构造器对象能否访问的方法。

setAccessible(true)指示反射的对象在使用时取消Java语言的访问检查，有两点作用：

1. 提高反射效率
2. 可以访问原本无法访问的私有对象

反射的优点

• 灵活性：可以动态创建对象和编译。

• 可扩展性 ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。

• 类浏览器和可视化开发环境 ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。

• 调试器和测试工具 ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。

反射的缺点

尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。

• 性能开销 ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
• 安全限制 ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
• 内部暴露 ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。

注解 Annotation

Annotation是JDK 1.5引入的技术，是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。它以**@注释名的形式在代码中存在，还可以添加一些参数值**，例如@SuppressWarnings(value="unchecked")。

Annotation可以附加在package、class、method、filed等上面，通过反射机制编程实现对这些元数据的访问。

内置注解

• @Override：定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。

• @Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择。

• @SuppressWarnings：定义在java.lang.Suppresswarnings中，用来抑制编译时的警告信息。

  与前两个注释有所不同，需要添加一个参数才能正确使用。这些参数都是已经定义好了的，选择性使用即可：

  • @SuppressWarnings("all")：镇压全部警告
  • @SuppressWarnings("unchecked")：镇压未检查的警告
  • @SuppressWarnings(value = {"unchecked", "deprecation"})

元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他 annotation类型作说明。这些类型和它们所支持的类在java.lang.annotation包中可以找到：

• @Target：用于描述注解的使用范围

• @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期

  (SOURCE < CLASS < RUNTIME)，（自定义的注解一般都写在RUNTIME）

• @Document：说明该注解将被包含在javadoc中

• @Inherited：说明子类可以继承父类中的该注解

自定义一个注解：

1
2
3
4
5
6
7

@Target(value = {ElementType.METHOD, ElementType.TYPE) // value 是参数名
@Retention(value = RetentionPolicy.RUNTIME)
@Document
@Inherited
@interface MyAnnocation {
    
}

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口。

分析：

• @interface用来声明一个注解，格式：public @Interface 注解名{定义内容}
• 其中的每一个方法实际上是声明了一个配置参数
• 方法的名称就是参数的名称
• 返回值类型就是参数的类型(只能是基本类型、Class、String、enum)
• 可以通过default来声明参数的默认值
• 如果只有一个参数成员，一般参数名为value
• 注解元素必须要有值，我们定义注解元素时，经常使用空字符串、0作为默认值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Test {
    @MyAnnovation2(age = 18, name = "Hunter")
    public void test(){}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(Retentionpolicy.RUNTIME)
@interface Myannotation2 {
    //注解的参数：参数类型 参数名();
    String name() default ""; //空字符串
    int age() default 0;
    int id() default -1; //如果默认值为-1，代表不存在
    String[] schools() default {"西南大学", "东南大学"};
}

概览

容器除了数组，主要包括Collection和Map这两种接口，两者也常被统称为集合框架：

• Collection存储对象的集合（单列）
• Map存储键值对的映射表（双列）

数组和集合框架的区别：

• 数组长度固定；集合的长度可变
• 数组可以存储基本数据类型；集合只能存储对象，而且对象的类型可以不一致（泛型）

在开发中，一般当对象多的时候，使用集合框架进行存储。

Collection 接口

java.util.Collection是单列集合类的根接口。

常用方法：

• boolean add(E e)：添加指定对象到当前集合
• void clear()：清空集合中所有的元素
• boolean remove(E e)：从当前集合中删除指定对象
• boolean contains(E e)：判断当前集合中是否包含给定的对象
• boolean isEmpty()：判断当前集合是否为空
• int size()：返回集合中元素个数
• Object[] toArray()：把集合中的元素存储到数组中

继承了Collection的接口：

• List 接口
• Set 接口
• Queue 接口

Iterator 接口

java.util.Iterator接口也是Java集合中的一员，主要用于迭代访问（即遍历）Collection中的元素。

Collection继承了Iterable接口，其中的public Iterator iterator()方法能够产生一个Iterator对象，通过这个对象就可以迭代遍历Collection中的元素。

迭代：即Collection集合元素的通用获取方式。需要先判断集合中有没有元素，如果有，就取出来，直至全部取出。

常用方法：

• public E next()：返回迭代的下一个元素
• public boolean hasNext()：如果仍有元素可以迭代，则返回true

1
2
3
4
5
6
7
8
9
10
11

Collection<String> col = new ArrayList<>();
//往集合中添加元素
col.add("甲");
col.add("乙");
col.add("丙");
col.add("丁");

Iterator<String> it = col.iterator(); //迭代器的泛型由创建它的Collection的泛型决定
while(it.hasNext()) {
    System.out.println(it.next());
}

从JDK 1.5 之后，可以使用增强for循环——foreach方法来遍历实现了Iterable接口的聚合对象：

1
2
3
4
5
6

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
    System.out.println(item);
}

List 接口

java.util.List存储的元素有序且可重复。习惯性地会将实现了List接口的对象称为List集合，可以通过索引来访问集合中的指定元素。

常用方法

除了继承自Collection接口中的全部方法，还增加了一些根据元素索引来操作集合的方法：

• void add(int index, E element)：将指定元素添加到指定位置，原index及之后位置的元素都向后移动
• E get(int index)：返回指定位置的元素
• E remove(int index)：移除指定位置的元素，返回被移除的元素
• E set(int index, E element)：用指定元素替换集合中指定位置的元素，返回被替换的元素

list集合的三种遍历方式：

1. 普通for循环
2. 使用迭代器
3. 增强for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");

// 1. 普通for循环
for(int i = 0; i < list.size(); i++) {
    String str = list.get(i);
    System.out.println(str);
}

// 2. 使用迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String str = it.next();
    System.out.println(str);
}

// 3.增强for循环
for (String str : list) {
    System.out.println(str);
}

ArrayList

java.util.ArrayList集合的存储结构是动态数组。由于日常开发中使用最多的功能为查询和遍历数据，而不是增删操作，因此ArrayList是最常用的集合。

LinkedList

java.util.LinkedList集合的存储结构是双向链表，可以快速完成插入和删除元素的操作。LinkedList能用作栈、队列和双向队列。

LinkedList包含了大量操作首尾元素的方法，使用这些方法时，不能使用多态：

• void addFirst(E e)

  void push(E e)等效于该方法

• void addLast(E e)

  void add(E e)等效于该方法，可读性不如

• E getFirst()

• E getLast()

• E removeFirst()

  E pop()等效于该方法

• E removeLast()

Vector

和ArrayList类似，但它是线程安全的。

Set 接口

java.util.Set同样继承自Collection接口，它与Collection接口中的方法基本一致，没有进行功能上的扩充，只是更严格。Set接口中，元素无序且不可重复。

Set不允许重复元素的原理

Set集合在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复。存储的元素必须重写hashCode方法和equals方法，建立自己的比较方式。

HashSet

java.util.HashSet是Set接口的一个实现类，元素无序且不可重复，基于哈希表（实际上是一个HashMap实例）实现。

HashSet根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。

jdk 1.8之前，哈希表 = 数组 + 链表；jdk 1.8开始，哈希表 = 数组 + 链表/红黑树。数组的初始容量为16。

1. 先计算元素的hash值，hash值即作为在数组中对应的下标；
2. 存在不同的元素拥有相同的hash值（hash冲突），数组中存储的元素为链表/红黑树，链表/红黑树中存放最终的元素（相同hash值的元素超过了8个，就会改链表为红黑树存储元素）。

LinkedHashSet

java.util.LinkedHashSet继承了HashSet类，基于哈希表 + 双向链表（维护元素的插入顺序），保证元素有序。

TreeSet

基于红黑树实现，元素有序。

查找效率不如HashSet，HashSet查找的时间复杂度为O(1)，TreeSet则为O(logN)。

Queue 接口

Queue实现了一个FIFO的队列，常用方法如下：

PriorityQueue

• PriorityQueue基于堆结构实现，可以用它来实现优先队列。

• PriorityQueue在获取队首元素时，总是返回优先级最高的元素。

• 默认按元素比较的顺序（小顶堆）排序（必须实现Comparable接口）

• 可以通过Comparator自定义排序算法（不必实现Comparable接口）

Deque

Deque实现了一个双端队列（Double Ended Queue），实现类有：

• ArrayDeque
• LinkedList

总是使用xxxFirst/xxxLast，以便和Queue的方法区分开。

1
2

// 多态，让LinkedList这种具有多种功能的类的角色更明确
Deque<String> deque = new LinkedList<>();

Collections 类

java.utils.Colletcions是集合工具类，用来对集合进行操作。部分方法如下：

• static <T> boolean addAll(Collection<T> c, T... elements)：往集合中添加多个元素
• static void shuffle(List<?> list)：打乱集合顺序
• static <T> void sort(List<T> list)：将集合中元素按照默认规则(升序)排序
• static <T> void sort(List<T> list, Comparator<? super T>)：将集合中元素按照指定规则排序

1
2
3
4

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d", "e");

Collections.shuffle(list);

sort(List<T> list) 方法的使用

参与排序的集合中存储的元素，必须实现comparable接口，重写接口中的compareTo方法，定义默认排序的规则。

Comparable接口的排序规则：

• compareTo方法返回0，认为相等
• compareTo方法返回正数，当前对象后置
• compareTo方法返回负数，当前对象前置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Person implements Comparable<Persion> {
    private String name;
    private int age;
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    // 重写排序的规则
    @override
    public int compareTo(Person p) {
        // 返回0表示：认为元素是相同的
        
        //自定义比较规则，比较两个人的年龄
        return this.getAge() - p.getAge(); // 按年龄升序排序
    }
    
}

sort(List<T> list, Comparator<? super T>) 方法的使用

Comparator和Comparable的区别：

• Comparable是自己(this)和别人(参数)比较，需要实现Comparable接口，重写compareTo方法
• Comparator相当于找一个裁判，重写compare方法，不需要实现Comparable接口

1
2
3
4
5
6
7
8
9
10
11

Collections.sort(list1, new Comparator<Student>() { //匿名类
    //重写比较规则
    @Override
    public int compare(Student s1, Student s2) {
        int result = s1.getAge() - s2.getAge(); // 返回正数，s1后置；返回负数，s1前置
        if (result == 0) {
		result = o1.getName().charAt(0) - o2.getName().charAt(0);
        }
        return result;
    }
})

Map 接口

Map<K, V>是将键映射到值的对象。元素无序且不能包含重复的键（可以有一对一和多对一的关系）。

常用方法：

• V put(K key, V value)：如果插入的键值key未重复，返回值的V为null；否则返回被替换的value
• V get(Object key)
• V remove(Object key)
• boolean containsKey(Object key)

遍历相关方法：

• Set<K> keySet()：获取Map集合中所有的键，存储到Set集合中

  第一种遍历方式：通过键找值的方式

  1. 使用Map集合的keySet()方法，把Map集合所有的key取出来，存储到一个Set集合中
  2. 遍历Set集合，获取每个key
  3. 通过Map集合的get(key)方法，通过key找到value

  1 2 3 4 5 6 7 8

  Map<String, Integer> map = new HashMap<>(); map.put("苏炳添", '32'); map.put("刘翔", '38'); for(String key : map.keySet()) { Integer value = map.get(key); System.out.println(key + "=" + value); }

• Set<Map.Entry<K, V>> entrySet()

  Map.Entry<K, V>是Map接口中的一个内部接口，当Map集合创建，就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象、键与值的映射关系）。

    - `K getKey()`
    - `V getValue()`
  

  entrySet()方法将Map集合内部的多个Entry对象取出来，存储到一个Set集合中。

  第二种遍历方式：通过Entry对象遍历

  1. 使用Map集合中的方法entrySet()，把Map集合中多个Entry对象取出来， 存储到一个Set集合中
  2. 遍历Set集合，获取每一个Entry对象
  3. 使用Entry对象中的getKey()和getValue()获取键与值

  1 2 3 4 5 6 7 8 9 10 11

  Map<String, Integer> map = new HashMap<>(); map.put("苏炳添", '32'); map.put("刘翔", '38'); Set<Entry<String, Integer>> set = map.entrySet(); for(Map.Entry<String, Integer> entry : set) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key + "-->" + value); }

HashMap

java.util.HashMap<K, V>是Map接口的一个实现类，元素无序且不能包含重复的键，基于哈希表实现。

jdk 1.8之前，哈希表 = 数组 + 链表；jdk 1.8开始，哈希表 = 数组 + 链表/红黑树。数组的初始容量为16。

1. 先计算元素的hash值，hash值即作为在数组中对应的下标；
2. 存在不同的元素拥有相同的hash值（hash冲突），数组中存储的元素为链表/红黑树，链表/红黑树中存放最终的元素（相同hash值的元素超过了8个，就会改链表为红黑树存储元素）。

HashMap 不允许重复键的原理

HashMap在调用put方法的时候，put方法会调用key的hashCode方法和equals方法，判断元素是否重复。存储的元素必须重写hashCode方法和equals方法，建立自己的比较方式。

LinkedHashMap

java.util.LinkedHashMap继承了HashMap类，基于哈希表 + 双向链表（维护元素的插入顺序），保证元素有序。

HashTable

与其他集合框架不同，HashTableK/V都不允许存储null对象，底层是一个哈希表。另外它是线程安全的。

它是遗留类，不应该去使用它，而是使用ConcurrentHashMap来支持线程安全，ConcurrentHashMap的效率会更高，因为ConcurrentHashMap引入了分段锁。

HashTable的子类Properties(唯一和IO流相结合的集合)依然活跃着。

TreeMap

基于红黑树实现

容器中的设计模式

适配器模式

java.util.Arrays.asList()可以把数组类型转换为List类型：

1
2

@SafeVarargs
public static <T> List<T> asList(T... a)

值得注意的是，asList的参数是泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。

1
2
3
4
5

Integer[] arr = {1, 2, 3};
List list = Arrays.asList(arr);

// 也可以采用如下方式调用asList()
List list = Arrays.asList(1, 2, 3);

泛型

泛型即参数化类型。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

举例

1
2
3
4
5
6
7
8

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型测试","item = " + item);
}

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了在编译阶段解决类似这样的问题，泛型应运而生。

1

List<String> arrayList = new ArrayList<String>();

特性

泛型只在编译阶段有效。看下面的代码：

1
2
3
4
5
6
7
8
9

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

输出结果：D/泛型测试: 类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型的使用

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类的最基本写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

// 例子
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T> {
    //key这个成员变量的类型为T，T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey() { //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

1
2
3
4
5
6
7
8

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试", "key is " + genericInteger.getKey());
Log.d("泛型测试", "key is " + genericString.getKey());

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

1
2
3
4

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

1
2
3
4

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

• 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中。

  1 2 3 4 5 6 7

  // 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class" class FruitGenerator<T> implements Generator<T>{ @Override public T next() { return null; } }

• 当实现泛型接口的类，传入泛型实参时

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  /** * 定义一个生产器实现这个接口，虽然我们只创建了一个泛型接口Generator<T> * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型 * 即：Generator<T>，public T next();中的T都要替换成传入的String类型。 */ public class FruitGenerator implements Generator<String> { private String[] fruits = new String[]{"Apple", "Banana", "Pear"}; @Override public String next() { Random rand = new Random(); return fruits[rand.nextInt(3)]; } }

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定时，无法通过Object类型表示任意类型，因为泛型没有继承的概念，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符：不知道使用什么类型来接收的时候可以使用?，表示未知通配符。

泛型通配符不能在创建对象时使用，只能作为方法的参数使用。

例：定义一个能遍历所有类型的ArrayList集合。使用通配符 ? 的方法不能向 list 添加除 null 以外的任何元素。

1
2
3
4
5
6
7
8

public static void printArray(ArrayList<?> list) {
    // 使用迭代器遍历集合
    Iterator<?> it = list.iterator();
    while(it.hasNext()) {
        Object o = it.next(); //next方法返回Object类型的元素
        System.out.println(o);
    }
}

泛型通配符高级使用——受限泛型

JAVA的泛型可以指定上限和下限。

• 泛型的上限

  类型名称 <? extends 类> 对象名称：只能接收该类型及其子类

• 泛型的下限

  类型名称 <? super 类> 对象名称：只能接收该类型及其父类

红黑树

特点

1. 根节点是黑节点

2. 叶子节点（红黑树只有null节点称为叶子节点)是黑节点(红黑树是一棵满二叉树)

   可知，红黑树中至少有一半以上的节点是黑节点

3. 红节点的子结点必须是黑节点（红节点出现的条件很严苛，红节点出现最频繁的情况下，树中的节点也是红黑交错的）

4. 新插入的节点是红节点（为了达到平衡，后续也可能会变成黑节点）

5. 从任意一个节点出发，到任意叶子节点的路径上，黑节点的数量都一样（红黑树的平衡条件）

平衡二叉树（AVL树）的平衡条件是左右子树的深度差<=1；而红黑树没有这么严格，根据上述特点，可以得知其平衡条件为左右子树深度差在一倍以内（特点3 + 5），因此红黑树写的性能更高些。

如果将红黑树中的红节点忽略，黑节点构成的树就是一棵平衡二叉树。红黑树最差情况下（红黑相间，深度翻一倍）的时间复杂度为$O(2\log n_{black}) = O(2\log {n\over2})=O(2(\log n- 1))=O(\log n)$​

相关面试题：JAVA 1.8 HashMap的实现，每一个桶？是一个链表，当链表的长度>=8，就会变成红黑树。为什么要选择红黑树这种结构，而不是二叉搜索树或者平衡二叉树？

当元素有序时，二叉搜索树会退化为链表，没有实现性能的优化；AVL树相对于红黑树，其平衡条件更严格，红黑树的插入效率要更高一些，在实际的应用中，红黑树更符合性能的需要。

网络通信的要素

1. 通信双方的地址

   • IP地址
   • 端口号

2. 通信协议

   • TCP/IP 参考模型

     • 应用层

       HTTP、FTP、SMTP

     • 传输层

       TCP、UDP

     • 网络层

       IP

     • 数据链路层

Java 中的网络支持：

• InetAddress：用于表示网络上的硬件资源，即 IP 地址；
• URL：统一资源定位符；
• Sockets：使用 TCP 协议实现网络通信；
• Datagram：使用 UDP 协议实现网络通信。

IP

IP地址的类：InetAddress

• IP地址能唯一定位一台网络上的计算机

• 127.0.0.1：本机 localhost

• IP地址的分类

  • IPV4/IPV6

  • 公网/局域网

    192.168.xx.xx(专门给组织内部使用)

• 域名

InetAddress没有公有的构造函数，只能通过静态方法来创建实例：

1
2

InetAddress.getByName(String host);
InetAddress.getByAddress(byte[] address);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//测试IP
public class TestIP {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("localhost");
            System.out.println(inetAddress1);
            InetAddress inetAddress2 = InetAddress.getLocalHost();
            System.out.println(inetAddress2);

            //查询网站ip地址
            InetAddress inetAddress3 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress3);

            //常用方法
            System.out.println(inetAddress3.getCanonicalHostName()); //规范的主机名
            System.out.println(inetAddress3.getHostAddress()); // IP
            System.out.println(inetAddress3.getHostName()); // 域名或自己的计算机名
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

端口

端口表示计算机上一个程序的对外的接口。

• 不同的进程有不同的端口号，用来区分软件

• 规定端口号范围：0-65535

• 相同协议下，端口号不能冲突（不同协议，可以使用相同端口号）

• 端口分类：

  • 公有端口：0-1023

    一般会被内置的进程、服务器使用，尽量不要使用

    • HTTP端口: 80
    • HTTPS端口: 443
    • FTP端口: 21
    • SSH: 22
    • Telent: 23

  • 程序注册端口：1024-49151

    分配给用户或程序

    • Tomcat: 8080
    • MySQL: 3306
    • Oracle: 1521
    • SQL Server：1433

  • 动态、私有端口：49152-65535

    1 2 3

    netstat -ano #查看端口命令 netstat -ano|findstr "5900" #查看指定的端口 tasklist|findstr "1584" #查看指定端口的进程

1
2
3
4
5
6
7
8
9
10

public class TestSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("localhost", 8080);

        System.out.println(socketAddress);
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());
        System.out.println(socketAddress.getPort()); //获取端口
    }
}

URL

URL(统一资源定位符)用于定位网络资源，可以直接从URL中读取字节流数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String[] args) throws IOException {

    URL url = new URL("http://www.baidu.com");

    /* 字节流 */
    InputStream is = url.openStream();
    BufferedReader br = new BufferedReader(new InputStreamReader(is, "utf-8"));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    br.close();
}

下载网络资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

URL url = new URL("https://pic3.zhimg.com/v2-77fd9b17781556ee25be582af6a9cd4c_r.jpg?source=1940ef5c"); // 资源地址(图片)

// 连接到该资源
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

InputStream is = urlConnection.getInputStream();
BufferedInputStream bis = new BufferedInputStream(is); // 图片、音频、视频等类型使用缓冲字节流，含中文的文档类资源使用缓冲字符流


// 判断文件夹是否存在
File file = new File("C:\\Users\\Hunter\\Downloads");
if (!file.exists()) {
    file.mkdirs();
}
FileOutputStream fos = new FileOutputStream(file + File.separator + "Hunter" + System.currentTimeMillis() + new Random().nextInt(999999) + ".jpg");

BufferedOutputStream bos = new BufferedOutputStream(fos);

byte[] bytes = new byte[4 * 1024]; // 存储每次读取的数据
int len = 0;
while ((len = bis.read(bytes)) != -1) {
    bos.write(bytes, 0, len);
}
bos.close();
bis.close();
urlConnection.disconnect();

通信协议

TCP/IP协议簇：

• TCP(Transmission Control Protocol) 传输控制协议

• UDP(User Datagram Protocol) 用户数据报协议

• IP(Internet Protocol) 网络互连协议

TCP 和 UDP 的对比

TCP（类比：打电话）

• 需要连接，稳定

• 三次握手，四次挥手

  1 2 3 4 5 6 7 8 9 10

  // 至少需要三次，保证稳定连接 C：我喜欢你 S：我也喜欢你 C：我们在一起吧 // 四次挥手 C：我要走了 S：我知道你要走了 S：你已经走了吗？ C：我已经走了

• 有明确的客户端和服务端角色

• 传输完成后释放连接，效率低

UDP（类比：发短信）

• 不需要连接，不稳定

TCP

Socket：套接字，指两台设备之间通讯的端点，是包含了IP地址和端口号的网络单位。

• java.net.ServerSocket

  服务器端类，相当于开启一个服务，并等待客户端的连接

• java.net.Socket

  客户端类，向服务器发出连接请求，服务端响应请求后，两者建立连接，开始通信（三次握手）

服务端

java.net.ServerSocket

构造方法

ServerSocket(int port)：创建绑定到指定端口的服务端套接字

成员方法

Socket accept()：侦听并接收客户端的连接

实现步骤

1. 创建服务器端对象ServerSocket，指定端口
2. 等待用户的连接，通过accept方法获取请求的客户端对象
3. 使用获取到的客户端对象的getInputStream方法获取网络字节输入流InputStream对象
4. 使用网络字节输入流对象的read方法读取客户端发来的数据
5. 使用获取到的客户端对象的getOutputStream获取网络字节输出流OutputStream对象
6. 使用网络字节输出流对象的write方法给客户端发送数据（传输结束标记）
7. 释放资源

服务器没有IO流，而是通过获取请求的客户端对象Socket，使用Socket提供的IO流和客户端进行交互：

• 服务器使用客户端的字节输入流InputStream读取客户端发送的数据
• 服务器使用客户端的字节输出流OutputStream向客户端写回数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

ServerSocket serverSocket = new ServerSocket(2000);
while (true) { // 服务端的持久运行
    // 2. 获取请求的客户端对象
    Socket socket = serverSocket.accept();

    // 3. 读取客户端消息
    InputStream is = socket.getInputStream();
    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    // 向客户端发送数据
    OutputStream os = socket.getOutputStream();
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
    bw.write("你在教我做事？");
    bw.newLine();
    bw.flush(); // 重要

    // 网络流的传输不同于本地，不会传输结束的标记
    socket.shutdownOutput(); // 禁用套接字的输出流，同时会传输一个结束标记

    br.close();
    bw.close();
    socket.close();
}

客户端

java.net.Socket

构造方法

Socket(String host, int port)：创建一个套接字，并连接到指定主机上指定的端口号。

• String host：服务器主机的名称/服务器的IP地址

成员方法

• OutputStream getOutputStream()：返回套接字的输出流
• InputStream getInputStream()：返回套接字的输入流
• void close()：关闭套接字

实现步骤

1. 创建一个客户端对象Socket
2. 使用getOutputStream方法获取网络字节输出流OutputStream对象
3. 使用网络字节输出流对象的write方法给服务器发送数据（传输结束标记）
4. 使用getInputStream获取网络字节输入流InputStream对象
5. 使用网络字节输入流对象的read方法读取服务器传回的数据
6. 释放资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Socket socket = new Socket("127.0.0.1", 2000);

OutputStream os = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
bw.write("教练，我想打篮球");
bw.newLine();
bw.flush(); // 重要

// 网络流的传输不同于本地，不会传输结束的标记
socket.shutdownOutput(); // 禁用套接字的输出流，同时会传输一个结束标记

// 3. 读取服务端消息
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}

bw.close();
br.close();
socket.close();

文件上传

注意事项

1. 为保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如WEB-INF目录下。
2. 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名（时间戳 + uuid + md5加密）。
3. 限制上传文件的最大值。
4. 限制上传文件的类型，判断后缀名是否合法。

服务端

1. 创建服务器ServerSocket对象
2. 使用ServerSocket对象中的accept方法，获取到请求的客户端Socket对象
3. 使用Socket对象的getInputStream方法，获取到网络字节输入流
4. 判断指定存储的文件夹是否存在，不存在则创建
5. 创建一个本地字节输出流FileOutputStream对象
6. 读取客户端上传的文件，写入至服务器中指定的文件夹下
7. 获取网络字节输出流对象，返回上传成功的消息（传输结束标记）
8. 释放资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

ServerSocket serverSocket = new ServerSocket(8888);

while (true) {
    Socket socket = serverSocket.accept();
    InputStream is = socket.getInputStream();
    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    // 判断文件夹是否存在
    File file = new File("C:\\Users\\Hunter\\Downloads");
    if (!file.exists()) {
        file.mkdirs();
    }

    // 使用【域名 + 系统时间 + 随机数】用于命名
    FileOutputStream fos = new FileOutputStream(file + File.separator + "Hunter" + System.currentTimeMills() + new Random().nextInt(999999) + ".md");
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
    // 将本地上传的文件内容输出至指定文件
    String line;
    while ((line = br.readLine()) != null) { // 客户端socket.shutdownOutput()的操作，会传来文件的结束标记
        bw.write(line);
        bw.newLine(); // 换行（根据不同的操作系统，获取不同的行分隔符）
    }
    bw.close();

    // 返回上传成功的消息
    OutputStream os = socket.getOutputStream();
    BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(os));
    bw2.write("上传成功");

    bw2.flush();
    socket.shutdownOutput(); // 禁用套接字的输出流，同时会传输一个结束标记

    // 释放资源
    bw2.close();
    br.close();
    socket.close();
}

客户端

1. 创建一个本地字节输入流FileInputStream对象，读取本地文件
2. 创建客户端Socket对象
3. 使用Socket对象的getOutputStream方法，获取到网络字节输出流
4. 通过网络字节输出流传输本地文件内容至服务器（传输结束标记）
5. 读取服务端返回的消息
6. 释放资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 创建本地字节输入流
FileInputStream fis = new FileInputStream("C:\\Users\\Hunter\\Downloads\\xx.md");
BufferedReader br = new BufferedReader(new InputStreamReader(fis));

// 创建客户端Socket对象
Socket socket = new Socket("127.0.0.1", 8888);
// 获取网络字节输出流
OutputStream os = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
// 将本地的文件上传至网络字节输出流
String line;
while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine(); // 换行（根据不同的操作系统，获取不同的行分隔符）
}
bw.flush();
socket.shutdownOutput(); // 上传完文件， 给服务端一个结束标记，否则服务端将阻塞

// 获取上传结果
InputStream is = socket.getInputStream();
BufferedReader br2 = new BufferedReader(new InputStreamReader(is));
while ((line = br2.readLine()) != null) {
    System.out.println(line);
}

// 释放资源
br.close();
br2.close();
socket.close();

文件上传优化 —— 多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
    Socket socket = serverSocket.accept();
    /*
    * 使用多线程，提高程序效率
    * 有一个客户端上传文件，就开启一个线程，完成文件的上传
    * */
    new Thread(() -> {
        try {
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 判断文件加是否存在
            File file = new File("C:\\Users\\Hunter\\Downloads");
            if (!file.exists()) {
                file.mkdirs();
            }

            // 使用【域名 + 系统时间 + 随机数】用于命名
            FileOutputStream fos = new FileOutputStream(file + File.separator + "Hunter" + System.currentTimeMillis() + new Random().nextInt(999999) + ".md");
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
            // 将本地上传的文件内容输出至指定文件
            String line;
            while ((line = br.readLine()) != null) { // 客户端socket.shutdownOutput()的操作，会传来文件的结束标记
                bw.write(line);
                bw.newLine(); // 换行（根据不同的操作系统，获取不同的行分隔符）
            }
            bw.close();

            // 返回上传成功的消息
            OutputStream os = socket.getOutputStream();
            BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(os));
            bw2.write("上传成功");

            bw2.flush();
            socket.shutdownOutput(); // 禁用套接字的输出流，同时会传输一个结束标记

            // 释放资源
            bw2.close();
            br.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

进阶

对于文件上传，浏览器将文件以流的形式提交到服务器，使用原生态的文件上传流request.getInputStream()获取十分麻烦，一般采用apache的开源工具commons-fileupload，其依赖于commons-io。

ServletFileUpload类

ServletFileUpload负责处理上传的文件数据，使用其parseRequest(HttpServletRequest)方法，会将表单中每个HTML标签封装成一个FileItem对象，以List的形式返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

package com.hunter.servlet;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;

public class FileServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 判断上传的文件是否普通表单
        if (!ServletFileUpload.isMultipartContent(req)) {
            return;
        }

        // 创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
        String uploadPath = this.getServletContext().getRealPath("/WEB-INF/upload");
        File uploadFile = new File(uploadPath);
        if (!uploadFile.exists()) {
            uploadFile.mkdir();
        }

        // 缓存临时文件
        //  临时路径，假如文件超过了预期的大小，就放到临时文件中，超过设定的时间后自动删除，或提醒用户转存为永久
        String tmpUploadPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
        File tmpUploadFile = new File(tmpUploadPath);
        if (!tmpUploadFile.exists()) {
            tmpUploadFile.mkdir();
        }

        /*
         * ServletFileUpload负责处理上传的文件数据，使用其parseRequest(HttpServletRequest)方法，
         * 会将表单中每个HTML标签封装成一个FileItem对象，以List的形式返回。
         * 而使用ServletFileUpload对象解析请求时，需要DiskFileItemFactory对象。
         */
        try {
            // 1. 创建DiskFileItemFactory对象，处理文件上传 路径或大小限制
            DiskFileItemFactory diskFileItemFactory = getDiskFileItemFactory(tmpUploadFile);
            // 2. 获取ServletFileUpload
            ServletFileUpload servletFileUpload = getServletFileUpload(diskFileItemFactory);
            // 3. 处理上传的文件
            String msg = uploadParseRequest(req, uploadPath, servletFileUpload);

            req.setAttribute("msg", msg);
            req.getRequestDispatcher("info.jsp").forward(req, resp);
        } catch (FileUploadException e) {
            e.printStackTrace();
        }
    }

    private String uploadParseRequest(HttpServletRequest request, String uploadPath, ServletFileUpload servletFileUpload)
            throws FileUploadException, IOException {
        String msg = "";
        // parseRequest(HttpServletRequest)方法，会将表单中每个HTML标签封装成一个FileItem对象，以List的形式返回。
        List<FileItem> fileItems = servletFileUpload.parseRequest(request);
        for (FileItem fileItem : fileItems) {
            // 是否普通表单
            if (fileItem.isFormField()) {
                // 前端表单控件的name
                String fieldName = fileItem.getFieldName();
                // UTF-8 处理乱码
                String value = fileItem.getString("UTF-8");
                System.out.println(fieldName + ": " + value);
            } else {
                String uploadFileName = fileItem.getName();
                // 文件名可能不合法
                if (uploadFileName == null || uploadFileName.trim().equals("")) {
                    continue;
                }
                // 获得文件名
                String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
                System.out.println("文件信息【文件名：" + fileName + "】");

                // 使用UUID，保证文件名唯一。网络传输的东西，都需要序列化。
                String uuidPath = UUID.randomUUID().toString();
                String realPath = uploadPath + "/" + uuidPath;
                // 给每个文件创建一个对应的文件夹
                File realPathFile = new File(realPath);
                if (!realPathFile.exists()) {
                    realPathFile.mkdir();
                }

                // 获得文件上传的流
                InputStream inputStream = fileItem.getInputStream();

                // 创建一个文件输出流
                FileOutputStream fileOutputStream = new FileOutputStream(realPath + "/" + fileName);
                // 创建一个缓冲区
                byte[] buffer = new byte[1024 * 1024];
                int len = 0;
                while ((len = inputStream.read(buffer)) > 0) {
                    fileOutputStream.write(buffer, 0, len);
                }

                // 关闭流
                fileOutputStream.close();
                inputStream.close();
                msg = "文件上传成功";
                // 清除临时文件
                fileItem.delete();
            }
        }
        return msg;
    }

    /**
     * 获取ServletFileUpload
     *
     * @param diskFileItemFactory diskFileItemFactory
     * @return ServletFileUpload
     */
    private ServletFileUpload getServletFileUpload(DiskFileItemFactory diskFileItemFactory) {
        ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);

        // 监听文件上传进度
        servletFileUpload.setProgressListener(
                (pBytesRead, pContentLength, pItems) ->
                        System.out.println("总大小：" + pContentLength + " B，已上传：" + pBytesRead + " B。"));

        // 处理乱码问题
        servletFileUpload.setHeaderEncoding("UTF-8");
        // 设置单个文件的最大值，10MB
        servletFileUpload.setFileCountMax(1024 * 1024 * 10);
        // 设置总共能上传文件的大小，10MB
        servletFileUpload.setSizeMax(1024 * 1024 * 10);
        return servletFileUpload;
    }

    /**
     * 创建DiskFileItemFactory对象，处理文件上传 路径或大小限制
     *
     * @param tmpUploadFile tmpUploadFile
     * @return DiskFileItemFactory
     */
    private DiskFileItemFactory getDiskFileItemFactory(File tmpUploadFile) {
        DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();

        // 通过这个工厂类，设置一个大小为1MB的缓冲区，当上传文件大于这个缓冲区时，放到临时文件中
        diskFileItemFactory.setSizeThreshold(1024 * 1024);
        diskFileItemFactory.setRepository(tmpUploadFile);
        return diskFileItemFactory;
    }
}

UDP

java.net.DatagramPacket：数据报包，包括目的地址和传递的数据

java.net.DatagramSocket：数据包套接字，通过send方法发送数据报包DatagramPacket对象

发送端

1
2
3
4
5
6
7
8
9
10
11
12

// 1. 建立一个socket
DatagramSocket socket = new DatagramSocket();

// 2. 建一个包
String msg = "教练，我想打球";
InetAddress localhost = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, 9090);

// 3. 发送包
socket.send(packet);

socket.close();

接收端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 开放端口
DatagramSocket socket = new DatagramSocket(9090);

// 接收数据包
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

// 3. 接收包
socket.receive(packet);

// 获取发送端的相关信息
System.out.println(packet.getAddress().getHostAddress());
System.out.println(new String(packet.getData(), 0, packet.getLength())); // 实际接收到的数据长度

// 4. 关闭连接
socket.close();

互相聊天

实现了Runnable接口的接收类和发送类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public class TalkSend implements Runnable {

    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIp;
    private int toPort;

    public TalkSend(int fromPort, String toIp, int toPort) {
        this.fromPort = fromPort;
        this.toIp = toIp;
        this.toPort = toPort;

        try {
            // 1. 建立一个socket
            socket = new DatagramSocket(this.fromPort);
            // 控制台读取System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                // 2. 建一个包
                byte[] msg = reader.readLine().getBytes();
                DatagramPacket packet = new DatagramPacket(msg, 0, msg.length,
                        new InetSocketAddress(this.toIp, this.toPort));

                // 3. 发送包
                socket.send(packet);
                if (new String(msg).equals("bye")) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 4. 关闭连接
        socket.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class TalkReceiver implements Runnable {

    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceiver(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            // 开放端口
            socket = new DatagramSocket(this.port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                // 接收数据包
                byte[] buffer = new byte[1024];
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                socket.receive(packet);

                // 判断是否断开连接
                String receiveData = new String(packet.getData(), 0, packet.getLength());
                System.out.println(msgFrom + ": " + receiveData);
                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

创建有发送和接收信息功能的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class TalkTeacher {
    public static void main(String[] args) {
        // 发送进程一个端口，接收进程一个端口；发送的目的端口和接收的端口要与聊天的对象对应起来
        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceiver(9999,"student")).start();
    }
}

public class TalkStudent {
    public static void main(String[] args) {
        // 开启两个线程，发送进程一个端口，接收进程一个端口；发送的目的端口和接收的端口要与聊天的对象对应起来
        new Thread(new TalkSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceiver(8888, "teacher")).start();
    }
}

SMTP与POP3协议

• SMTP

  发送邮件。

• POP3

  接收邮件。

• MIME

  附件。

电子邮件

要在网络上实现邮件功能，必须有专门的邮件服务器。

SMTP服务器地址一般是smtp.xx.com。

要发送邮件，需要获得协议和支持，开启服务POP3/SMTP

例如网易邮箱：

Ctrl + Shift + R：刷新IntelliSense

在经过种种不可考的、操作当时觉得并无不妥的操作后，SSMS(Sql Server Management Studio)突然在某一天开始，无法在其窗口中打开多个.sql文件，即双击sql文件后，会另外启动一个新的SSMS程序，而不是在当前的SSMS界面中打开文件。更准确的描述是无法在单独的SSMS实例中打开多个sql文件。

没有什么故障是卸载重装解决不了的，如果有，那就再装一次！痛苦的时光从此开始，没想到重装之后不但没有解决上述问题，甚至连将SSMS作为sql文件的打开方式都变得困难且异常起来！而且，SQL Server作为一个中文环境下相对冷门的数据库，居然找不到任何靠谱的网上解答！在此要感谢最近被迫阅读英文论文的自己，导致对去英语环境下查找解决之法没有以前那么抗拒。

先说结论：感谢歪果网友，让我（我相信还有很多同仁！）得到了救赎！

上述问题以及恶化的情况在如下操作后，能够一并解决：

1. 不需要因为SSMS的问题，把SQL Server也卸载重装。

2. 卸载SSMS

3. (微软的产品，恶心人的地方似乎都在注册表)

   打开注册表编辑器（Win + R，输入regedit，确定）

4. 删除如下条目：

   1. HKEY_CLASSES_ROOT\.sql
   2. HKEY_CLASSES_ROOT\Applications\Ssms.exe
   3. HKEY_CLASSES_ROOT\sql_auto_file
   4. HKEY_CURRENT_USER\Software\Microsoft\SQL Server Management Studio
   5. HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\ApplicationAssociationToasts 下，包含SSMS字符的所有记录(而不是删除这个路径下的所有内容)
   6. HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts.sql
   7. HKEY_USERS.DEFAULT\Software\Microsoft\SQL Server Management Studio

5. 重启电脑

6. 重新安装SSMS

完结，撒花。

参考：database - How to open multiple .sql files in only one ssms instance - Stack Overflow

T-SQL 查询和编程基础

数据生命周期

联机事务处理 (OLTP，OnLine Transactional Processing)

OLTP系统的重点是数据输入，而不是生成报表。主要处理的事务包括插入、更新和删除数据。关系模型的目标主要定位于OLTP系统，一个规范化的模型可以为数据输入和数据一致性提供更好的性能。在规范化的环境中，每个数据表用于表示一个实体，并将数据冗余保持在最低限度。当要修改一个实体事实时，只要在一个地方进行修改，使修改操作得以优化，同时也减少了发生错误的机会。

但OLTP环境不适合生成报表，因为规范化的数据模型通常涉及许多表，表间关系非常复杂，导致查询复杂、性能低下。

数据仓库 (Data Warehouse)

数据仓库是专门针对数据检索和生成报表而设计的环境。当这样的环境服务于整个企业，就称之为数据仓库。主要为了支持数据检索，而对数据仓库中的数据模型进行设计和优化。模型有意保持了一定的冗余，允许通过更少的表和更简单的关系，得到比OLTP环境更加简单和有效的查询。

数据仓库最简单的设计是star schema，它包括多个维度表(dimension table)和一个事实表(fact table)。每个维度代表一个如何分析数据的主题。

例如，在处理订单和销售的系统中，可能要按照客户、产品、雇员、时间等不同的维度对数据进行分析。在star schema中，每个维度实现为一个具有冗余数据的表。例如，一个产品维度应该实现为一个ProductDim表，而不是规范化的三个表：Products、ProductSubCategories和ProductCategories。如果规范化一个维度表，生成表示该维度的多个表，得到的就是所谓的**雪花形维度(snowflake dimension)，包含雪花形维度的模式就称为雪花模式(snowflake schema)**。

事实表存储用户感兴趣的事实和度量(measure)，比如与维度主键的每个组合相关的数量和值。例如，对于客户、产品、雇员，以及日期的每个组合，在事实表中将有一行相关的数量和值。数据仓库中的数据通常会预先聚合到某个特定级别的粒度(如日期)，而在OLTP环境中的数据通常按照事务级别来记录。

ETL（Extract Transform and Load）：从源系统(OLTP以及其它系统)抽取数据，对数据进行处理，并将数据加载到数据仓库的工具。SQL Server提供了叫做Microsoft SQL Server Intergration Services(SSIS)的工具来处理ETL请求。

联机分析处理技术(OLAP, OnLine Analytical Processing)

OLAP系统支持对聚合后的数据进行动态的在线分析，这通常涉及频繁地请求不同级别的聚合。后者又必须对数据进行切片(slicing)和切块(dicing)。如果对于每个这样的请求都要扫描和聚合大量数据，代价高，响应时间久，因此可以预先计算好不同级别的聚合，如时间维度、产品维度。

预先计算不同级别聚合的方法：

1. 在关系数据仓库中计算和存储不同级别的聚合。这需要编写一套复杂的过程来处理聚合的初始化和增量更新。
2. 适用专门为OLAP需求而设计的特殊产品——Microsoft SQL Server Analysis Services（SSAS）。SSAS是独立于SQL Server服务的一种服务(或引擎)，它可以计算不同级别的聚合，并将其保存在一种经过优化的多维结构(多维数据集，cube)中。用于管理和查询SSAS数据方块的语言称为多维表达式(MDX, Multidimensional Expressions)。

数据挖掘(DM, Data Mining)

在动态分析处理中，为了找到有用的信息，用户必须不断地从一种聚合视图定位到另一种视图(进行数据切片和切块)。数据挖掘算法可以梳理数据，从中筛选出有用的信息。

SSAS支持用数据挖掘算法(聚类分析、决策树等)来解决这些需求。用于管理和查询数据挖掘模型的语言是数据挖掘扩展插件语句(DMX, Data Mining Extensions)。

SQL Server 体系结构

SQL Server 实例

SQL Server实例是指安装的一个SQL Server数据库引擎/服务。一台计算机上可以安装多个实例。

数据库

每个SQL Server实例可以包含多个数据库。安装程序创建的系统数据库包括：

1. master

保存SQL Server实例范围内的源数据信息、服务器配置、实例中所有数据库的信息，以及初始化信息。

2. model

   model数据库是创建新数据库的模板。每个新创建的数据库最初都是model的一个副本(copy)。如果想在所有新创建的数据库中都包含特定的对象(比如数据类型)，或者想在所有新创建的数据库中都以特定的方式来配置某些数据库属性，就可以先把这些对象或配置属性放在model数据库中。

   对model数据库做出的修改不会影响已有的数据库，只影响之后新创建的数据库

3. tempdb

   tempdb数据库是SQL Server保存临时数据的地方，包括工作表(work table)、排序空间(sort space)、行版本控制(row versioning)信息等。SQL Server允许用户创建临时表，其存储位置就是tempdb。

   每次重新启动SQL Server实例时，会删除这个数据库的内容，并将其重新创建为model的一个副本。

4. msdb

   msdb是SQL Server Agent保存其数据的地方。SQL Server Agent负责自动化处理，包括记录有关作业(job)、计划(schedule)和警报等实体的信息。SQL Server Agent也是负责复制的服务。msdb还用于保存一些有关其他SQL Server功能的信息，例如Database Mail和Service Broker。

可以在数据库级上定义一个称为collation（排序规则）的属性，由它确定数据库中字符数据使用的排序规则信息（包括支持的语言、区分大小写和排序顺序）。如果在创建数据库时不指定collation属性，将使用实例默认的排序规则设置。

如下图，数据库在物理上由数据文件和事务日志文件组成。当创建数据库时，能够定义每个文件的各种属性，包括文件名、保存位置，以及文件自动扩展的增量。

每个数据库必须至少有一个数据文件和一个日志文件。

• 数据文件(.mdf, .ndf)：保存数据库对象数据；
• 日志文件(.ldf, log data file)：保存SQL Server为了维护事务而需要的信息；

SQL Server可以并行写多个数据文件，但只能顺序写日志文件，因此使用多个日志文件也不能提升系统的性能。多个数据文件在逻辑上按照文件组（filegroup）的形式进行分组管理。对象数据可能会保存在属于目标文件组的多个文件中。数据库至少要有一个主文件组。PRIMARY文件组包含主数据文件（**.mdf**, Master Data File）和数据库的系统目录（catalog），可以选择性地为PRIMARY增加多个辅助数据文件(.ndf, secondary data file)。用户定义的文件组只能包含辅助数据文件。

可以指定默认文件组，当对象创建语句没有明确指定目标文件组时，就将其创建在默认文件组中。

架构 (Schema) 和对象

如下图所示，一个数据库包含多个架构，每个架构包含多个对象。可以将架构（Schema）看作是各种对象的容器，这些对象可以是表（table）、视图（view）、存储过程（store procedure）等。

可以在架构级别上控制对象的访问权限。

另外架构也是一个命名空间，用作对象名称的前缀。如果在引用对象时省略架构名称，SQL Server会自行分析，导致可能得到的对象不是原本想要的。

创建表和定义数据完整性

表属于架构，架构属于数据库。

在SQL Server环境中创建一个名为testdb的数据库：

1
2

IF DB_ID('testdb') IS NULL
CREATE DATABASE testdb;

DB_ID函数接受一个数据库名称作为参数，返回它的内部数据库ID，如果指定的数据库不存在，将返回NULL。
在这个简单的CREATE DATABASE语句中，采用了默认的文件设置（例如区域和初始大小）。在产品环境中，通常应该显式指定所有需要的数据库和文件的设置。

上述例子中使用的架构是dbo，在每个数据库中都会自动创建dbo架构，并作为默认架构。

创建表

以下代码创建一个名为Employees的表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

USE testdb;

IF OBJECT_ID('dbo.Employees', 'U') IS NOT NULL
DROP TABLE dbo.Employees;

CREATE TABLE dbo.Employees
(
	empId	INT	NOT NULL,
	firstName	VARCHAR(30)	NOT NULL,
	lastName	VARCHAR(30)	NOT NULL,
	hireDate	DATE	NOT NULL,
	mgrId	INT	NULL, -- 经理ID，允许有雇员没有经理，如CEO
	ssn	VARCHAR(20)	NOT NULL, -- social security number，社会保险号
	salary	MONEY	NOT NULL	
);

USE语句将当前的数据库上下文切换为testdb，它能确保后续操作会在目标数据库中进行。
IF语句调用OBJECT_ID函数，检查当前数据库中是否已经存在Employees表。OBJECT_ID函数接受一个对象名称和类型作为参数，U代表用户定义的表。可填写的类型见SQL SERVER 中的 object_id()函数。如果匹配给定参数的对象存在，该函数就返回内部的对象ID，否则返回NULL。

对于表的每个属性，需要指定它的属性名称、数据类型和是否允许NULL值。如果不显式指定一个列是否允许NULL值，SQL Server则采用默认值，ANSI规定默认为NULL。除非有明显的原因必须要支持NULL，各属性最好都定义为NOT NULL。

定义数据完整性

• 声明式(declarative)数据完整性：作为表定义的一部分而实施的数据完整性。
• 过程式(procedural)数据完整性：用代码来实施的数据完整性。

为属性选择数据类型和是否与允许NULL值，甚至数据模型本身，都是声明式数据完整性约束的例子。当用CREATE TABLE语句创建表时，可以同时定义这些约束；或者在表已创建的情况下，用ALTER TABLE语句增加这些约束。

除了DEFAULT约束以外，其他所有约束都可以定义为组合约束(即基于一个或多个属性的约束)。

主键约束 (Primary Key Constraints)

主键约束用于实施行的唯一约束，同时不允许约束属性取NULL值，表内的每行数据可以被唯一确定。每个表只能定义一个主键。

以上述创建的Employees表为例，在empId上定义一个主键约束：

1
2
3

ALTER TABLE dbo.Employees
ADD CONSTRAINT PK_Employees
PRIMARY KEY(empId);

为了实施逻辑主键约束的唯一约束，SQL Server在幕后创建一个唯一索引(unique index)。也可以用索引来加速查询的处理，避免对整个表进行不必要的扫描。

唯一约束 (nique Constraints)

唯一约束用来保证数据行的一个列(或一组列)数据的唯一，可以在数据库中实现关系模型的替换键（alternate key）的概念。与主键不同，同一个表中可以定义多个唯一约束，唯一约束也不限于只定义在NOT NULL列上。SQL Server支持只允许在唯一约束列中有一个列可以为NULL值。

以下代码在Employees表中定义了ssn列上的一个唯一约束：

1
2
3

ALTER TABLE dbo.Employees
ADD CONSTRAINT UNQ_Employees_ssn -- 增加约束
UNIQUE(ssn);

和主键约束一样，SQL Server也在幕后为唯一约束创建一个唯一索引。

外键约束

外键约束用于实施引用完整性。这种约束在引用表（referencing table）的一组属性上进行定义，并指向被引用表（referenced table）中的一组候选键（主键或唯一约束）。引用表和被引用表可能是同一个表。外键的目的是为了将外键列允许的值域限制为被引用列中现有的值。

以下代码创建了一个名为Orders的表，其主键定义在orderid列上：

1
2
3
4
5
6
7
8
9
10
11
12
13

IF OBJECT_ID('dbo.Orders', 'U') IS NOT NULL
DROP TABLE dbo.Orders;

CREATE TABLE dbo.Orders
(
	orderId	INT NOT NULL,
    empId	INT NOT NULL,
    custId	VARCHAR(10)	NOT NULL,
    orderTs	DATETIME	NOT NULL,
    qty	INT	NOT NULL,
    CONSTRAINT PK_Orders -- 定义约束
    PRIMARY KEY(OrderID)
);

接下来在Orders表的empId列上定义一个外键约束，让它指向Employees表的empId列：

1
2
3
4

ALTER TABLE dbo.Orders
ADD CONSTRAINT FK_Orders_Employees
FOREIGN KEY(empId)
REFERENCES dbo.Employees(empId);

引用表和被引用表可能是同一个表。

限制Employees表的mgrId列的值域为同一个表中已存在的那些empId列的值，可以增加如下外键约束：

1
2
3
4

ALTER TABLE dbo.Employees
ADD CONSTRAINT FK_Employees_Employees
FOREIGN KEY(mgrId) -- 依然允许NULL值
REFERENCES dbo.Employees(empId);

注意：即使被引用的候选列不存在NULL值，在外键列中也允许NULL值。

以上定义的外键，当试图删除或更新被引用的相关数据时，如果在引用表中存在相关的行，则操作不能执行。这种情况可以通过定义具有级联操作的外键来解决，可在外键定义中将ON DELETE和ON UPDATE选项定义为CASCADE、SET DEFAULT和SET NULL之类的操作。

• CASCADE：操作被级联到引用表中相关的列
• SET DEFAULT / SET NULL：将引用表中相关行的外键属性设置为列的默认值或NULL

1
2
3
4
5
6
7
8
9

ALTER TABLE dbo.Employees
DROP CONSTRAINT FK_Employees_Employees

ALTER TABLE dbo.Employees
ADD CONSTRAINT FK_Employees_Employees
FOREIGN KEY(mgrId) -- 依然允许NULL值
REFERENCES dbo.Employees(empId)
ON DELETE CASCADE
ON UPDATE SET DEFAULT;

检查约束 (Check)

检查约束用于定义在表中输入或修改一行数据之前必须满足的一个谓词。

以下的检查约束可以保证Employees表的salary列只支持正数：

1
2
3

ALTER TABLE dbo.Employees
ADD CONSTRAINT CHK_Employees_salary
CHECK(salary > 0);

当谓词计算结果为TRUE或UNKNOWN时，RDBMS接受对数据行的修改，即NULL值会被接受。

默认约束 (Default)

默认约束与特定的属性关联。当插入一行数据时，如果没有为属性显式指定明确的值，就可以用一个表达式作为其默认值。

例如，以下代码为orderTs属性定义了一个默认约束（表示订单时间的时间戳）：

1
2
3

ALTER TABLE dbo.Orders
ADD CONSTRAINT DFT_Orders_orderTs
DEFAULT(CURRENT_TIMESTAMP) FOR orderTs;

CURRENT_TIMESTAMP函数返回当前的日期和时间值。

单表查询

先执行示例数据库脚本，构建一个示例数据库。

SELECT 语句的元素

1
2
3
4
5
6
7
8

USE TSQLFundamentals2008;

select empid, YEAR(orderdate) AS orderYear, count(*) AS numOrders
from Sales.Orders
where custid = 71
group by empid, YEAR(orderdate)
having count(*) > 1
order by empid, orderYear;

各子句在逻辑上按以下顺序进行处理：

1. FROM
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY

因此，上述代码实际的处理顺序如下：

1
2
3
4
5
6

from Sales.Orders -- 查询数据行
where custid = 71 -- 保留客户ID = 71 的记录
group by empid, YEAR(orderdate) -- 按雇员ID和订单年份进行分组
having count(*) > 1 -- 保留具有多个订单的分组
select empid, YEAR(orderdate) AS orderYear, count(*) AS numOrders -- 返回指定行
order by empid, orderYear -- 按指定顺序对输出结果进行排序

分隔标识符名称：

如果标识符是非常规的（例如名称中嵌入了空格或其他特殊字符、以数字开头、或是SQL Server的保留字），就必须分隔这样的标识符。ANSI SQL分隔标识符的标准格式是使用双引号（例如，“Order Details”）。SQL Server的特殊格式是使用方括号（[Order Details]）。

WHERE 子句

WHERE子句对查询性能有重要影响。在过滤表达式的基础上，SQL Server会计算使用什么索引来访问请求的数据。通过使用索引，有时可以大幅减少SQL Server在获取请求的数据时付出的代价。

要实可记住T-SQL使用的是三值谓词逻辑（TRUE, FALSE, UNKNOWN）。如果WHERE阶段要返回结果为TRUE的行，UNKNOWN也不会被返回。

GROUP BY 子句

所有的聚合函数都会忽略NULL值，除了**COUNT(*)**。

例如，假设一个组有5行，其qty列的值分别为30、10、NULL、10、10。COUNT(*)返回5，COUNT(qty)返回4，COUNT(DISTINCT qty)返回2；

SELECT 子句

当表达式中进行了一定的处理（例如，YEAR(orderDate)），或者没有基于原始表的列（如调用CURRENT_TIMESTAMP函数），这时如果不为表达式起一个别名，查询的结果集中就不能拥有列名。在某些情况下，T-SQL允许查询返回没有名称的结果集列，但关系模型不允许这样。因此强烈推荐将诸如YEAR(orderDate)之类的表达式起一个别名。
除了<表达式> AS <别名>这种格式，T-SQL还支持<别名> = <表达式>，和<表达式> <别名>这两种格式，后者非常不明确，避免使用这种定义别名的方式。
由于SELECT字句是在FROM、WHERE、GROUP BY，以及HAVING子句之后处理。这意味着在SELECT子句中为表达式分配的别名，在SELECT子句之前处理的那些子句中并不存在。
以下就是在WHERE子句中使用这种无效引用的一个例子：

1
2
3

SELECT orderId, YEAR(orderDate) AS orderYear
FROM Sales.Orders
WHERE orderYear > 2006;

解决这一问题的一种方法就是在WHERE子句和SELECT子句中重复使用表达式YEAR(orderDate)，SQL Server能够标识在查询中重复使用的同一表达式，因此，表达式其实只会被计算一次。
除了很少数的例外，在绝大多数情况下，使用星号*是一种糟糕的编程习惯。建议即使需要被查询表的所有列，也应该显式地指定它们。虽然使用星号时，为了解析列名需要付出一些额外的代价，但重要的问题在于查询过程中无法察觉到的代价，前者的代价反而显得微不足道。
在SELECT子句中不能引用当前SELECT子句中创建的别名列，例如：

1
2

SELECT orderId, YEAR(orderDate) AS orderYear, orderYear + 1 AS nextYear
FROM Sales.Orders;

如前所述，解决这一问题的方法就是重复使用表达式（虽然繁琐，但这就是SQL…）。

ORDER BY 子句

带有ORDER BY 子句的查询会产生一种ANSI称之为游标（cursor）的结果（一种非关系结果，其中的行有固定的顺序）。
在SQL中的某些语言元素和运算预期只对查询的表结果进行处理，而不能处理游标，例如表表达式和集合运算。

下例中的查询，按照雇员ID和顶顶那年份对输出结果进行排序：

1
2
3
4
5

SELECT empid, YEAR(orderDate) AS orderYear, COUNT(*) AS numOrders
FROM Sales.Orders
WHERE custId = 71
GROUP BY empid, YEAR(orderDate)
ORDER BY empId, orderYear;

可见，ORDER BY 子句成功引用了SELECT子句中的别名列orderYear——可知ORDER BY子句是在SELECT阶段之后被处理的。
SQL和T-SQL都支持在ORDER BY子句中指定表示该列名称或别名在SELECT列表中所处位置的非负整数。
上述代码的GROUP BY empId, orderYear也可以写成GROUP BY 1, 2，但这是一种糟糕的方式。首先，在关系模型中，属性本身没有顺序位置，要通过名称来引用它们。其次，当修改SELECT子句时，可能会忘记对ORRDER BY 子句中的引用位置做相应的修改。
T-SQL支持在ORDER BY子句中指定没有在SELECT子句中出现过的元素，例如，如下查询按照雇佣日期对雇员行进行排序，但最后并没有返回hireDate列：

1
2
3

SELECT empId, firstName, lastName, country
FROM HR.Employees
ORDER BY hireDate;

当指定了DISTINCT以后，ORDER BY子句就只能选取在SELECT列中出现的元素。因为当指定DISTINCT时，一个结果行可能代表多个原始行，因此无法判断应该使用ORDER BY列表值中多个可能值中的哪一个。

TOP 选项

TOP选项是T-SQL特有的，用于限制查询返回的行数或百分比。当在查询中指定了ORDER BY子句时，TOP将依赖该子句来定义行的逻辑优先顺序。例如，从Orders表返回最近的5个订单的代码如下：

1
2
3

SELECT TOP (5) orderId, orderDate, custId, empId
FROM Sales.Orders
ORDER BY orderDate DESC;

从逻辑查询处理的角度来看，TOP选项是作为SELECT阶段的一部分而处理，紧接着DISTINCT子句处理之后。当查询中指定了TOP以后，ORDER BY子句就起到了双重作用。首先，作为SELECT处理阶段一部分的TOP选项要依靠ORDER BY子句先为各个行定义它们的逻辑优先顺序，在此基础上再去过滤其他请求。其次，作为SELECT处理阶段之后的ORDER BY阶段，与为了展示数据而行进行排序的ORDER BY子句完全一样。
当使用TOP时，同一ORDER BY子句既担当了为TOP决定行的逻辑优先顺序的角色，也担当了展示数据的常规角色，最终生成的结果由表变成了具有固定顺序的游标。
在TOP选项中可以使用PERCENT关键字，SQL Server会按照百分比来计算应该返回的满足条件的行数（向上取整）。例如，以下查询请求最近更新过的前1%（向上取整）个订单：

1
2
3

SELECT TOP (1) PERCENT orderId, orderDate, custId, empId
FROM Sales.Orders
ORDER BY orderDate DESC;

由于orderDate 的取值不是唯一的，具有相同订单日期的行之间的优先关系没有定义，这会让查询结果具有不确定性，多个查询结果都可以认为是正确的。SQL Server只是根据物理上最先访问到了哪行，就选择相应的行。如果想让查询结果是确定的，就要让ORDER BY列表能唯一地决定一行。
除了在ORDER BY列表增加额外的属性，还可以请求返回所有与TOP n行中最后一行具有相同结果的行，为此必须增加一个WITH TIES选项。

1
2
3

SELECT TOP (5) WITH TIES orderId, orderDate, custId, empId
FROM Sales.Orders
ORDER BY orderDate DESC;

OVER 子句

OVER子句用于为行定义一个窗口（window），以便进行特定的运算，可以把行的窗口简单地认为是运算将要操作的一个行的集合。聚合函数和排名函数都是可以支持OVER子句的运算类型，由于OVER子句为这些函数提供了一个行的窗口，所以这些函数也称之为开窗函数（window function）。
聚合函数传统上一直以GROUP BY查询作为操作的上下文，聚合开窗函数使用OVER子句提供的窗口作为上下文，对窗口中的一组值进行操作。这样就能在不进行分组的情况下，在同一行中同时返回基础行的列和聚合列。
带有空的圆括号的OVER子句会提供所有行进行计算，这里的所有行是在FROM、WHERE、GROUP BY以及HAVING处理阶段完成后仍然可用的行。注意：只有在SELECT和ORDER BY处理阶段才允许使用OVER子句。
如果想对行进行限制或分区，可以使用PARTITION BY子句。例如，想返回当前客户（和当前行具有相同custId(某属性)的所有行）的总价格，则可以指定SUM(val) OVER(PARTITION BY custId)。

1
2
3
4

SELECT orderId, custId, val,
	SUM(val) OVER() AS TTLvalue,
	SUM(val) OVER(PARTITION BY custId) AS custTTLvalue
FROM Sales.OrderValues;

OVER子句还可以在表达式中混合使用基本列和聚合值列。例如，以下查询为OrderValues的每一行计算当前价格占总价格的百分比，以及当前价格占客户总价格的百分比：

1
2
3
4

SELECT orderId, custId, val,
	100. * val / SUM(val) OVER() AS pctAll,
	100. * val / SUM(val) OVER(PARTITION BY custId) AS pctCust
FROM Sales.OrderValues;

表达式中使用的是十进制实数100.，这样可以隐式地将整数值val和SUM(val)转换成十进制实数值。
OVER子句也支持四种排名函数：

• ROW_NUMBER 行号
• RANK 排名
• DENSE_RANK 密集排名
• NTILE

  1 2 3 4 5 6 7

  SELECT orderId, custId, val, ROW_NUMBER() OVER(ORDER BY val) AS rowNum, RANK() OVER(ORDER BY val) AS rank, DENSE_RANK() OVER(ORDER BY val) AS dense_rank, NTILE(10) OVER(ORDER BY val) AS ntile FROM Sales.OrderValues ORDER BY val;

  ROW_NUMBER函数用于为查询的结果集中的各行分配递增的序列号，即使行的排序值相同，也会生成唯一的行号值，如果ORDER BY不能唯一确定行的顺序，查询可能会返回多个正确的结果。如果想对排序值中的相同值以同样的方式处理，可以考虑使用RANK或DENSE_RANK函数。

RANK和DENSE_RANK与ROW_NUMBER类似，但它们为具有相同逻辑排序值的所有行生成同样的排名。RANK和DENSE_RANK的区别是：RANK表示之前有多少个具有更低的排序值的行，而DENSE_RANK则表示之前有多少个更低的排序值（这正是该函数被称为密集排名的原因）。

NTILE函数可以把结果中的行关联到组（title，相当于由行组成的指定数目的组），并为每一行分配一个所属的组的编号。NTILE函数接受一个表示组的数量的参数，并要在OVER子句中指定逻辑顺序。上述的查询例子有830行，请求将其分成10组，因此组的大小就是83。

NTILE函数在逻辑上需要依赖于ROW_NUMBER函数，整个过程是先根据对val的排序结果，为每一行分配行号；再基于前面计算好的组的大小83行，将第1行到第83行分配到第1组，以此类推。如果组数无法整除行数，余数会被一一分配到前面的每个组。例如，假设有102行，请求分成5组，那么前两组将有21行。

OVER子句中指定的ORDER BY逻辑与数据展示没什么关系，不会改变查询结果表最终的任何内容。如果在SELECT处理阶段指定了开窗函数，开窗计算会在DISTINCT子句之前进行处理（TOP选项是紧接着DISTINCT处理之后）。
总结目前位置讨论过的所有子句的逻辑处理顺序：