02-janycode.github.io

如果已打开项目 File >> Close Project
初识启动界面中 + Create New Project

Java Enterprise >> ☑Web Application >> Next

配置：
Project Structure图标 >> Artifacts >> +新增Web Application: Arichive选择当前项目xxx:war >> OK

生成：
Build >> Build Artifacts >> 选择xxx:war点击Build >> out/artifacts/xxx_war/xxx_war.war

部署：
将xxx_war.war包放在 Tomcat 的 webapps 目录下，启动服务器会自动解压该web项目，便于直接访问

模拟现实世界，解决现实问题。

Java有虚拟机，内置了垃圾收集器（GC），自动完成内存空间的管理。

跨操作系统（Windows<C#>，Unix-Linux，MacOS，Solaris）、服务器、数据库。

Java Platform Standard Edition (Java平台标准版) CoreJava

Java Platform Enterprise Edition (Java平台企业版) 企业级开发

Java Platform Micro Edition (Java平台微小版) Java最初的定位(机顶盒)

（Java Virtual Machine）虚拟机：使用软件在不同操作系统中模拟相同的环境。

（Java Runtime Environment）运行环境：包含JVM和解释器，完整的Java运行环境。

（Java Development Kit）开大环境：包含JRE[JVM+解释器] + 类库 + 开发工具包（编译器+调试工具）。

数据类型 变量名;
变量名 = 值;

byte

short

int

long

float

double

boolean

char

String

两种类型兼容，目标类型大于源类型

两种类型兼容，目标类型小于源类型

转换规则

提升优先级规律：double << float << long < int << short/byte

两个操作数中有一个为优先级中的类型，计算结果提升为优先级中对应类型

任何类型与String相加(+)时，实为拼接，结果自动提升为String

【坑】num1+num2+string1：两个操作数为数值时，相加；两个操作数中有一个为String时，拼接。

功能: 将外部class文件功能引入到自身文件中

位置: jdk1.8.0_121\jre\lib\rt.jar 压缩包中

.nextInt(); // 获得整数
.nextDouble(); // 获得小数
.next(); // 获得字符串
.next().charAt(0); // 获得字符串的第一个字符

适用于区间判断

语法正确、任意嵌套

可判断：byte,short,int,char,String(JDK7+)

switch中多个case的取值不可以相同

switch自动向下贯穿的特性，如需中止使用break关键字

首次即有入口条件，适用于循环次数明确的情况

先判断，再执行。

次数：0-n

首次没有入口条件，适用于循环次数不明确的情况

先执行，再判断。

次数：1-n

首次即有入口条件，适用于循环次数明确的情况

初始部分只执行一次，且可以省略

次数：0-n

终止循环，跳出当前层级循环(1层)

跳出switch结构、跳出循环结构

结束本次，跳过当前层级循环(1层)，进入下一次

public static void 函数名称 (函数形参) { // 形参 等价于 局部变量的声明
    // 函数主体
}

return value; // 表示结束当前函数，并伴有返回值，返回到函数的调用处

return; // 表示结束当前函数，直接会返回到函数调用处

TestFibonacci.java

循环将原数组内容逐一复制到新数组

System.arraycopy(原数组, 原数组起始, 新数组, 新数组起始, 长度);

java.util.Arrays.copyOf(原数组, 新长度); // 返回带有原数组值的新数组

TestArrayAction.java

相邻两个值比较大小(arr[j] > arr[j+1])，互换位置

记忆：外层0 ~ <length-1, 内层0 ~ <length-1-i

固定值与其他值比较大小(arr[i] > arr[j])，互换位置

记忆：外层0 ~ <length-1, 内层i+1 ~ <length

java.util.Arrays.sort(数组名); 

默认升序,降序需手工倒序

* 先声明、再分配
数据类型[][] 数组名;
数组名 = new 数据类型[高维长度][低维长度];

* 声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];

* 声明并赋值（繁）
数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组
数组名[i] = new 数据类型[j]; //自行new低维属组

* 声明并赋值（简）
数据类型[][] 数组名 = {{v1, v2, v3}, {v4, v5, v6}, {...}}; //显示初始化

Demo

this([实参])必须在构造方法的首行，仅可在构造方法中使用

构造方法：类中的构造方法，只负责创建本类对象，不可继承

private修饰的属性/方法：仅本类可见，不可继承

父子类不在同一个package中，且default修饰的属性和方法，不可继承

public 任何

protected 父子

default 同包

private 本类

写全限定名（包名.类名），eg: java.util.Arrays.copyOf(...);

导包（import），eg: import java.util.Arrays;

同名：方法覆盖

当父类提供的方法无法满足子类的需求时，可在子类中定义和父类相同的方法进行覆盖（Override）

方法覆盖原则

执行机制：子类覆盖父类方法后，调用时优先执行子类覆盖后的方法

用法1：子类去访问父类重名的属性/方法时(属性遮蔽、方法覆盖)，使用super.专项访问父类的属性/方法

用法2：子类构造方法在调用父类构造方法时

this与super

创建

流程

父类引用作为方法的【形参】，实现多态，使方法参数的类型更为宽泛 (该父类任一子类均可作为实参传入)

父类引用作为方法【返回值】，实现多态，使方法可以可以返回不同的子类对象

概念：父类引用中保存真实子类对象。(多态核心概念)

eg: Animal a = new Dog(); // 对象层面的自动类型转换

调用：仅可调用父类中所声明的属性和方法（遵循属性遮蔽/方法覆盖原则）

概念：将父类引用中的真实子类对象，强转回子类本身类型。

eg: Animal a = new Dog();
      Dog dog = (Dog)a; // 对象层面的强制类型转换
      Cat cat = (Cat)a; // Error: 不是真实子类对象new Dog()，编译OK，运行则会抛出类型转换异常：java.lang.ClassCastException

调用：只有转回子类真实类型，才可调用子类独有的属性和方法。

向下转型前应该判断引用中的对象真实类型，保证类型转换的正确性。

语法： 父类引用 instanceof 子类类型 // 返回boolean类型结果，意为：父类包含子类对象真实类型，true包含，false不包含

概念：不够完整，不够具体，不能独立存在 的对象模型

语法：abstract class 类名 {}

作用

经验：abstract修饰后的抽象父类，依附于子类对象存在

概念：抽象方法，不够完整、不够具体 的方法

语法：访问权限修饰符 abstract 返回值类型 函数名([参数列表]);

作用

总结

静态属性 - 类属性

静态方法 - 类方法

静态方法允许直接访问静态成员（不需要this.）；

静态方法不允许直接访问非静态成员；

静态方法中不允许使用this或super关键字(构造方法可以)；

静态方法可以继承，不能重写(覆盖)、没有多态；

在执行类时，希望先执行的初始化动作，
可以使用static定义一个静态代码区域，在类加载时即会被执行仅有的一次。

代码示例

JVM首次使用某个类时，需通过CLASSPATH查找该类的.class文件

将.class文件中对类的描述信息加载到内存中，进行保存

单独调用类加载语法：Class.forName("全限定名");

类加载时

类（最终类）

方法（最终方法）

变量（最终变量）

显式初始化、动态代码块、构造方法

要求

显式初始化、静态代码块

要求

final修饰基本类型：值不可变

final修饰引用类型：地址不可变

拷贝引用，为了避免引用值(地址)发生改变。
例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

接口的定义：代表了某种能力

方法的定义：能力的具体要求

耦合度：模块与模块之间的关联程度。
关联的越密切，耦合越高；
关联的越松散，耦合越低。√

定义语法：interface 接口名 { }

public interface MyInterface {
    public static final String FIELD = "value";
    String S = "str"; // public static final 默认隐式存在、修饰
    public abstract void method( );
    void m( ); // public abstract 默认隐式存在、修饰
}
//public 关键字仅限用于接口在于其同名文件中被定义

定义要求：

使用语法：implements 接口名,接口名,...

// 增加/赋予1种/多种能力（逗号分隔） [约定]
calss Sub extends Super implements 接口名,接口名 {
    @OverRide
    public 返回值 method( ) { ... }
    @OverRide
    public void m( ) { ... }
}

使用规范：

1.可编译为字节码文件(.class)
2.不能创建对象(接口不是类，也没有构造方法)
3.可以作为引用类型
4.具备Object类中所定义的方法

1.所有属性都只能且默认是公开静态常量，隐式使用public static final修饰
2.所有方法都只能且默认是公开抽象方法，隐式使用public abstract修饰
3.没有构造方法、没有动态/静态代码块

使用接口引用作为方法形参，实现更自然的多态（只关注能力-具备能力的类对象均可传入）

仅可调用接口中所声明的方法，不可调用实现类中独有的方法

可强转回真实类本身类型，进行独有方法调用（注意判断真实类对象 instanceof）

重在理解、应用。

对象数组排序使用Java已知的接口/标准

接口使用者，在工具类中成员方法传参形式调用（接口回调）

接口实现者，在实现类中编写对应覆盖方法逻辑（方法覆盖）

测试类 main( ) 中调用测试验证

class Outer {
    class Inner {
    } 
}

* 编译之后可生成独立的字节码文件
* 内部类可直接访问外部类的私有成员，而不破坏封装
* 可为外部类提供必要的内部功能组件

// 定义语法同 内部类

// 创建内部类对象
Outer out = new Outer();
Inner in = out.new Inner(); // 特殊：不具普适性

// 成员内部类访问外部类的重名属性
Outer.this.属性名

* 当外部类、内部类存在重名属性时，会优先访问内部类属性。
* 成员内部类不能定义静态成员

static 内部类 { }

* 只能直接访问外部类的静态成员（势力成员需实例化外部类对象）

class Outer {
    public void m( ) {
        class Inner {
        }
    }
}

* 不能有静态成员（属性/方法）
* 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
* 隐藏类的信息，限制类的使用范围

class Outer {
    public OutInterface m ( ) {
        return new OutInterface( ) { // 匿名内部类
            private int i = 0;
            public int getValue() {
                return i;
            }
        };
    }
}

* 必须继承一个父类或者实现一个接口
* 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
* 使用场景：① 显式继承父类时 ② 实现接口时
* 优点：可以减少代码量，书写的思路流畅
* 缺点：可读性较差

返回引用中存储的实际对象类型。
应用：通常用于判断两个引用中实际存储对象类型是否一致。

返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法，如展示对象各个属性值。
特点：
* 对象中属性的表现形式，常用于展示对象的各个属性。

返回该对象的十六进制的哈希码值（对象在内存中的数字型名字）。
哈希算法根据对象的地址或者字符串或者数字计算出来的int类型的数值。
哈希码并不唯一，可保证相同对象返回相同的哈希码，尽量保证不同对象返回不同的哈希码值。

默认实现为 this == obj, 比较两个地址是否相同。
特点：
* 可进行覆盖，比较两个对象的内容是否相同。

重写覆盖父类Object.equals()方法五步走

protected void finalize() throws Throwable { }

当对象被判定为辣鸡对象时，由JVM自动调用此方法，用以标记辣鸡对象，进入回收队列。
辣鸡对象：没有有效引用只想此对象时，为辣鸡对象。
垃圾回收：由GC销毁辣鸡对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有辣鸡对象。
手动回收机制：使用System.gc( );通知JVM触发垃圾回收。

面试题：final finalize finally
* final 修饰词，类不可继承/方法不可覆盖/基本类型值不能修改/引用类型地址不可修改
* finalize 方法，JVM自动调用，标记辣鸡对象进入回收队列；手动调用，使用System.gc()方法触发
* finally 关键字，作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。

s.charAt(0);

s.contains("llo");

s.toCharArray();

s.indexOf("o");

s.lastIndexOf("ld");

str.isEmpty()

s.length()

s2.trim()

hi.toUpperCase();

hi.toLowerCase();

upper.equals(lower) // 字符串完全一样返回true,否则false

upper.equalsIgnoreCase(lower)

filename.endsWith(".java");

s.replace('o', 'O');

s.replace("Hello", "GoodBye");

text.split("，");

text.substring(8);

可变长字符串，JDK5.0提供，运行效率快、线程不安全。

可变长字符串，JDK1.0提供，运行效率慢、线程安全。

1. 编译时即可检查，而非运行时抛出异常；
2. 访问时，不必类型转换（拆箱）；
3. 不同泛型之间引用不能相互赋值，泛型不存在多态。  

<T>

<?>

普通泛型

静态泛型

public static void sort(List<?> list) // 排序，要求：必须实现Comparable接口，必须可与自身类型比，以及父类类型比
public static void reverse(List<?> list) // 反转，倒置元素
public static void shuffle(List<?> list) // 随机重置顺序（洗牌）

特点：
1. 数组结构实现，查询快、增删慢；
2. JDK1.2版本，运行效率快、线程不安全；

场景：注册（1次） -> 查询（n次）

注意：
* JDK7之前，无参构造方法实际创建长度为 10 的Object数组，用还是不用，数组就在那里，爱用不用(占了内存)
* JDK8之后，无参构造方法实际创建长度为 0 的Object数组，首次add元素时，才执行数组扩容操作，然后真正向数组中插入数据（Lazy懒），用的时候创建或加载，有效降低无用内存的占用。

方法：参考jdk1.8-API文档

特点：
1. 数组结构实现，查询快、增删慢；
2. JDK1.0版本，运行效率慢、线程安全。

方法：参考jdk1.8-API文档

特点：
1. 链表结构实现，增删快，查询慢；

ArrayList：必须开辟连续空间，查询快，增删慢。运行快，线程不安全。
Vector：必须开辟连续空间，查询快，增删慢。运行慢，线程安全。
LinkedList：无需开辟连续空间，查询慢，增删快。

不同：对象一定不同（add成功）

相同：对象不一定不同

特点：
* 基于HashCode实现元素不重复 - 无序
* 当存入元素的哈希码相同时，会调用equals确认，结果为true，则拒绝后者加入
* 无参构建初始容量为16（负载因子0.75，即+75%容量扩容）
* 底层使用的HashMap类，即将所有需要存储的值，通过HashMap去重存入
* 先判断hashCode是否相同，再==比较地址是否相同，再equals内容是否相同

特点：
* 继承自HashSet，又基于LinkedHashMap来实现的
* 底层使用LinkedHashMap（链表结构）存储，节点形式独立存储数据，
   并可以指向下一个节点，通过顺序访问节点，可保留元素的插入顺序 - 插入顺序
* 所有方法与HashSet相同，用法也一模一样

特点：
* 基于排列顺序实现元素不重复 - 自动排序
* 实现了SortedSet接口，对所有插入集合的元素自动排序
* 元素对象的类型必须实现Comparable接口，指定排序规则（Integer/String类默认实现），
  通过重写CompareTo方法才能使用，以确定是否为重复元素

特点：
* JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value
* 无参构建初始容量为16（负载因子0.75，即+75%容量扩容）
* HashMap算法：拿到任何一个对象后，通过hash(key)做运算，key>>>16(除16)，只可能得到0-15之间的一个数组，作为插入数组的下标。

特点：HashMap的一个子类，保存了记录的插入顺序，也可在构造时带参数，按照访问次序排序。

特点：JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value

特点：Hashtable的子类，要求key和value都是String，通常用于配置文件的读取。

Demo

特点：实现了SortedMap接口（Map的子接口），可以对key自动排序。

RuntimeException类

CheckedException类

1.创建异常对象

2.结合throw关键字，抛出异常

用在【方法内】

声明：①需要声明该异常，传递出去； ②声明的异常类型与抛出的异常类型一致

抛出：throw new 自定义异常类名(异常提示字符串);

声明：可声明/可不声明

抛出：throw new 自定义异常类名(异常提示字符串);

① 继承Thread类
② 覆盖run()方法
③ 创建子类对象
④ 调用start()方法 - 启动线程

MyThread t1 = new MyThread();
t1.start();

① 实现Runnable接口
② 覆盖run()方法
③ 创建实现类对象
④ 创建线程对象(Thread父类有参构造)
⑤ 调用start()方法 - 启动线程

Thread t2 = new Thread(new MyRunnable());
t1.start();

* 只是将当前类变成线程任务类，本身不是个线程
* run任务是可以多线程对象共享（任务复用）
* 更灵活（还可以继承其他的类 + 实现其他的接口能力）

public interface Callable<V> {
    public V call() throws Exception;
}

* JDK5加入，与Runnable接口类似，实现之后代表一个线程任务；
* Callable具有泛型返回值，可以声明异常。

public interface Future<V>

* 异步接收ExecutorService.submit()所返回的状态结果，当中包含了call()的返回值；
* 成员方法：
    V get()以阻塞形式等待Future中的异步处理结果(call()的返回值), 该方法会抛出InterruptedException, ExecutionException异常

* 静态方法，直接类名调用Thread.sleep(1000);
* 使当前线程进入阻塞状态，在指定时间内不会执行，不推荐使用；
* sleep()被调用时该线程不会释放它所拥有的锁；
* 该方法会抛出InterruptedException中断异常；

* 静态方法，直接类名调用Thread.yield();
* yield只是使当前线程重新回到就绪状态，所以执行yield的线程有可能在进入到就绪状态后马上又被执行。
   yield只能使同优先级或更高优先级的线程有执行的机会。
* 可能对调试或测试有用，可能有助于根据竞态条件重现错误。
   在设计并发控制结构（例如java.util.concurrent.locks包中的并行控制结构）时也可能有用。

* 成员方法/最终方法，不能被覆盖；
* 如果某个线程在另一个线程t上调用t.join()，此线程将被挂起，直到目标线程t结束才恢复；
* 能够释放当前线程锁，其他线程可以调用次线程中的同步方法；
* 该方法会抛出InterruptedException中断异常；

synchronized (临界资源对象) { // 对临界资源加锁
    //代码（原子操作）
}

注意

synchronized 返回值类型 方法名称(形参列表) { // 对当前对象(this)加锁
    // 代码（原子操作）
}

注意

只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记

如果在调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用

① StringBuilder
② Vector
③ Hashtable

公开成员方法均为synchronized修饰的同步方法。

Object类的成员方法：
public final void wait()
public final void wait(long timeout)

说明：必须在对共享临界资源(obj)加锁的同步代码块/同步方法中。
在一个线程中调用obj.wait()时，此线程会释放其拥有的所有锁标记，同时此线程阻塞在obj的等待队列中。
即当前线程释放锁，进入等待队列（无限期等待 - 除非收到通知）。

Object类的成员方法：
public final void notify()
public final void notifyAll()

说明：必须在对共享临界资源(obj)加锁的同步代码块/同步方法中。
从obj的waiting中释放一个或全部线程，对自身没有任何影响。

* 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记，产生死锁。
* 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

若干个生产者在生产产品，这些产品将提供给若干个消费者去消费。
为了使生产者和消费者能并发执行，在两者之间设置一个能存储多个产品的缓冲区：
生产者将生产的产品放入缓冲区，消费者从缓冲区中取走产品进行消费。
显然生产者和消费者之间必须保持同步，
即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个满的缓冲区中放入产品。

public class CopyOnWriteArrayList<E>
extends Object
implements List<E>, RandomAccess, Cloneable, Serializable

特点：
* 符合List特点：有序、有下标、元素可重复
* 线程安全的ArrayList，加强版读写分离；
* 写有锁，读无锁，读写之间不阻塞，优于读写锁；
* 写入时，先copy一个容器副本、再添加新元素，最后替换引用；
* 使用方式与ArrayList无异。

List<String> alist = new CopyOnWriteArrayList<String>();

public class CopyOnWriteArraySet<E>
extends AbstractSet<E>
implements Serializable

说明：
* 符合Set特点：无序、无下标、元素不重复
* 线程安全的Set，底层使用CopyOnWriteArrayList实现；
* 唯一不同在于：使用addIfAbsent()添加元素(查重)，会遍历数组；
* 如存在元素，则不添加（扔掉副本）。

Set<String> aset = new CopyOnWriteArraySet<String>();

public class ConcurrentHashMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable

特点：
* 初识容量默认为16段(Segment)，使用分段锁设计；
* 不对整个Map加锁，而是为每个Segment加锁(16把锁)；
* 当多个对象存入同一个Segment时，才需要互斥；
* 最理想状态位16个对象分别存入16个Segment，并行线程数量16个；
* 使用方式与HashMap无异。
// JDK1.7: 分段锁设计 Segment
// JDK1.8: CAS交换算法（CAS比较和交换） + 同步锁（锁的是表头）

Map<String, Integer> chmap = new ConcurrentHashMap<String, Integer>();

字节流转换字符流步骤：
①创建字节流 Output/InputStream
②创建过滤流，设置字符编码集（按需） OutputStreamWriter/InputStreamReader
③封装过滤流 PrintWriter/BufferedReader
④读写数据 write/read
⑤关闭流 close

// @param className 类的全限定名
public static Object createInstance(String className) throws Exception {
    return Class.forName(className).newInstance( );
}

Demo

天生线程安全（无锁）、类加载时创建（不用也创建，占用资源）

Demo

天生线程不安全（需同步锁、效率低）、使用时创建

Demo

天生线程安全（无锁）、使用时创建（静态内部类）

Demo

步骤：
① 自定义一个代理类（增强类）实现和被代理类（被增强类）相同的接口
② 在代理类中声明被代理类的对象
③ 在代理类的方法中使用被代理类调用方法

优点：增强被代理类的功能，可以控制被代理类的对象
缺点：必须要重写被代理类接口的所有的方法(破坏单一职能原则，耦合性高)

步骤：
① 自定义一个装饰类（增强类）实现和被装饰类（被增强类）相同的接口
② 在装饰类中声明被装饰类的引用
③ 在装饰类的方法中使用被装饰类调用方法

优点：增强被代理类的功能，无法控制被代理类的对象
缺点：必须要重写被装饰类接口的所有的方法(破坏单一职能原则，耦合性高)

动态代理本质就是通过反射来生成的一个代理。
在Java中 java.lang.reflect 包下提供了一个 Proxy 类和 InvocationHandler 接口，通过使用这个类和接口就可以生成动态代理对象。
JDK提供的代理只能针对接口做代理，有更强大的代理cglib，Proxy类中的方法创建动态代理对象。

步骤：——基于接口的方法增强
① 编写一个代理类的接口
② 实现一个真正的代理类，实现该接口
③ 创建一个动态的代理类，实现 InvocationHandler 接口，并重写该 invoke() 方法
④ 在测试类中调用 Proxy.newProxyInstance() 方法生成动态代理对象
优化：③④可合并为匿名内部类实现。

优点：不需要重写接口中的所有方法，耦合度更低。

核心代码片段

① Demo

位置：java.util.function

① Predicate<T>接口（断言、返回真假）

② Consumer<T>接口（消费、有去无回）

③ Supplier<T>接口（创造、无中生有）

④ Function<T,R>接口（传递、返回数据）

Demo

Stream<T> stream = 集合或数组.stream();

Stream<T> filter(Predicate<? super T> predicate)
返回由与此给定谓词匹配的此流的元素组成的流。
Stream<T> limit(long maxSize)
返回由此流的元素组成的流，截短长度不能超过 maxSize 。
Stream<T> distinct()
返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
<R> Stream<R> map(Function<? super T,? extends R> mapper)
返回由给定函数应用于此流的元素的结果组成的流。
Stream<T> sorted()
返回由此流的元素组成的流，根据自然顺序排序。
Stream<T> sorted(Comparator<? super T> comparator)
返回由该流的元素组成的流，根据提供的 Comparator进行排序。

long count()
返回流中的元素个数。
void forEach(Consumer<? super T> action)
对此流的每个元素执行遍历操作。
boolean anyMatch(Predicate<? super T> predicate)
或，流中是否有包含指定规则的元素
boolean allMatch(Predicate<? super T> predicate)
且，流中是否全部包含指定规则的元素
boolean noneMatch(Predicate<? super T> predicate)
非，流中是否都不包含指定规则的元素
Optional<T> findFirst()
返回流的第一个元素的Optional，如果流为空，则返回一个空的Optional 。
Optional<T> findAny()
返回流的任意一个随机元素的Optional，如果流为空，则返回一个空的Optional 。
Optional<T> max(Comparator<? super T> comparator)
根据提供的 Comparator 返回此流的最大元素。
Optional<T> min(Comparator<? super T> comparator)
根据提供的 Comparator 返回此流的最小元素。

TreeSet

CopyOnWriteArraySet

ArrayBlockingQueue

LinkedBlockingQueue

1. 创建MYSQL_HOME : C:\Program Files\MySQL\MySQL Server 5.7
2. 追加Path：%MYSQL_HOME%\bin;

* 终端中输入cd ~ 进入目录，并检查.bash_profile是否存在，有则追加，无则创建
* 创建文件 touch .bash_profile
* 打开文件 open .bash_profile
* 输入export PATH=${PATH}:/usr/local/mysql/bin 保存并退出终端

客户端默认字符集，默认被注释，即遵循环境的字符集

服务器端默认字符集，默认被注释，即遵循环境的字符集

客户端和服务器端的端口号，默认 port=3306

MySQL默认存储引擎 INNODB

[mysql] # 第一处 line67
default-character-set=utf8

[mysqld] # 第二处 line102
character-set-server=utf8
collation-server=utf8_general_ci

重启MySQL服务：
win> net stop mysql57 && net start mysql57
Linux$ service mysql restart

SELECT 列名 FROM 表名;

运算 + - * / 没有 %(它现在是占位符)

列 AS '列别名'

DISTINCT 列名

SELECT 列名 FROM 表名 ORDER BY 排序列1  [排序规则], 排序列2 [排序规则]

排序规则

SELECT 列名 FROM 表名 WHERE 条件

等值判断 =

不等值判断 >、<、>=、<=、!=、<>(也是不等)

逻辑判断 AND, OR, NOT

区间判断 BETWEEN ... AND ...

NULL值判断 IS NULL, IS NOT NULL

枚举查询 IN(值1, 值2, 值3..)

模糊查询

分支结构查询

SELECT 时间函数([参数列表]);

SYSDATE() / NOW()  年-月-日 时:分:秒
CURDATE()  年-月-日
CURTIME()  时:分:秒
WEEK(DATE)  获取指定日期为一年中的第几周
YEAR(DATE) / MONTH(DATE) / DAY(DATE)  年、月、日
HOUR(TIME) / MINUTE(TIME) / SECOND(TIME)  时、分、秒
DATEDIFF(DATE1, DATE2)  两个日期的相隔天数
ADDDATE(DATE, N)  计算DATE加上N天后的日期(自然日)

SELECT 聚合函数(列名) FROM 表名;

COUNT(列)  总行数，忽略null值
SUM(列)  所有行中单列结果的综合
AVG(列)  平均值
MAX(列)  最大值
MIN(列)  最小值

SELECT 列名 FROM 表名 WHERE 条件 GROUP BY 分组依据列;

WHERE 条件 也可省略。

SELECT 列名 FROM 表名 WHERE 条件 GROUP BY 分组列 HAVING 过滤规则;

过滤规则：定义对分组后的数据进行过滤，相当于一个新的条件。

SELECT 字符串函数([参数列表]);

CONCAT(str1, str2, str...)  连接多个字符串
INSERT(str, pos, len, newstr)  将str中指定pos位置开始的len长度的内容替换为newstr
LOWER(str)  转小写
UPPER(str)  转大写
SUBSTRING(str, pos) / (str FROM pos) / (str, pos, len) / (str FROM pos FOR len)
将str字符串中指定pos位置开始截取到末尾或者len长度的内容

* 注意：MySQL 中字符串下标是从 1 开始。

SELECT 列名 FROM 表名 LIMIT 起始行,查询行数;

* 注意：LIMIT 的起始行是从 0 开始为第1 行。

【公式】第 i 页:  SELECT * FROM LIMIT 页长*(i-1), 页长

SELECT 列名 FROM 表名
WHERE 条件 GROUP BY 分组 HAVING 过滤条件
ORDER BY 排序列 LIMIT 起始行,总条数;

执行顺序：
⑤ SELECT 列名
① FROM 表名
② WHERE 条件
③ GROUP BY 分组
④ HAVING 过滤条件
⑥ORDER BY 排序列（asc|desc）
⑦LIMIT 起始行,总条数

子查询结果作为条件判断

子查询结果作为枚举查询条件

子查询结果作为一张表

去重合并

全部合并

列数必须相同，行内容向下追加。

SELECT 列名 FROM 表1 连接方式 表2 ON 连接条件;

四种连接方式

库中的数据类型

查看所有数据库

创建自定数据库

查看库创建信息

修改数据库信息

删除指定数据库

查看使用数据库

切换使用数据库

创建自定数据表

【DML】

* 标识每一列数据不重复、实体唯一。

主键约束

唯一约束

自动增长列

* 限制列的单元格的数据正确性。

非空约束

默认值约束

引用完整性约束

事务，是一个原子操作，是一个最小执行单元，可以由一个或多个SQL语句组成。
在同一个事务当中，所有的SQL语句都成功执行时，整个事务成功，有一个SQL语句执行失败，整个事务都执行失败。

开始：
上一个事务结束后的第一条增删改的语句，即事务的开始。
# 1.开启事务 方式一：
START TRANSACTION;
# 1.开启事务 方式二：
SET autoCommit = 0; # autoCommit = 0 关闭自动提交，1 开启自动提交

结束：
​ 1). 提交：
​ a. 显示提交：COMMIT;
​ b. 隐式提交：一条创建/删除的语句，正常退出（客户端退出连接）;
​ 2). 回滚：
​ a. 显示回滚：ROLLBACK;
​ b. 隐式回滚：非正常退出（断电/宕机）执行了创建/删除语句，但是失败了，会为这个无效的语句执行回滚。

数据库会为每一个客户端都维护一个`空间独立的缓存区`(回滚段)。
一个事务中所有的增删改语句的`执行结果都会缓存在回滚段`中，
只有当事务中所有 SQL 语句均`正常结束`（commit），
才会将回滚段中的数据同步到数据库。否则无论因为哪种原因失败，整个事务将回滚（rollback）。

Atomicity(原子性)
表示一个事务内的所有操作是一个整体，要么全部成功，要么全部失败。

Consistency(一致性)
表示一个事务内有一个操作失败时，所有的更改过的数据都必须回滚到修改前状态。

Isolation(隔离性)
事务查看数据操作时数据所处的状态，要么是另一并发事务修改它之前的状态，
要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。

Durability(持久性)
持久性事务完成之后，它对于系统的影响是永久性的。

应用环境：
基于增删改语句的操作结果（均返回操作后受影响的行数），
可通过程序逻辑手动控制事务提交或回滚。

模拟转账 Demo

CREATE USER 用户名 IDENTIFIED BY 密码;

GRANT ALL ON 数据库.表 TO 用户名;

REVOKE ALL ON 数据库.表名 FROM 用户名;

DROP USER 用户名;

视图，`虚拟表`，从一个表或多个表中查询出来的表，作用和真实表一样，`包含一系列带有行和列的数据`。
视图中，用户可以使用 SELECT 语句查询数据，也可以使用 INSERT、UPDATE、DELETE 修改记录(影响原表)，
视图可以使用户操作方便，并保障数据库系统安全。

特点

CREATE VIEW 视图名 AS 查询数据源表语句;

SELECT * 与正常的 TABLE 使用方式相同

方式① CREATE OR REPLACE VIEW 视图名 AS 查询语句;
方式② ALTER VIEW 视图名 AS 查询语句;

DROP VIEW 视图名;

Druid 是目前比较流行高性能的，分布式列存储
一、亚秒级查询
二、实时数据注入
三、可扩展的PB级存储
四、多环境部署
五、丰富的社区

链接：https://pan.baidu.com/s/1f0pl7CnEJ5vNkWGFS3kdrg
提取码：05wc

c: TestXxxxView

i: XxxxService

impl/

i: XxxxDao

impl/

c: Xxxx

c: DBUtils

c: DateUtils

// DBUtils中静态属性：null
private static DruidDataSource dataSource = null;

// DBUtils中静态代码块：创建Druid德鲁伊 dataSource 连接池对象
static {
    // ... database.properties
    dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
}

// DBUtils中静态方法：返回一个数据源
public static DataSource getDataSource() {
    return dataSource;
}

// DAO实现类中调用方式
// 1.创建 QueryRunner 对象，并传递一个数据源对象
private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());
// 2.使用 queryRunner 对象，DML-增删改使用 .update(); DQL-查询使用 .query();
Object[] params = {xxx.getXx()...}; // 对应占位符获取值
return queryRunner.update("insert into xxx(yyy...) values(?,?,?...)", params);
return queryRunner.query("select * from xxx where id = ?", new BeanHandler<[Xxx]>(Xxx.class), id);
return queryRunner.query("select * from user", new BeanListHandler<[Xxx]>(Xxx.class));

ThreadLocal 线程绑定当前使用的线程池中 connection 对象，
即可正确对事务进行开启、提交、回滚时操作的是同一个数据库连接！

# 数据库配置
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/account?useUnicode=true&characterEncoding=utf8
username=root
password=123456
# 初始化连接数
initialSize=10
# 最大连接数
maxActive=30
# 最小空闲连接数
minIdle=5
# 超时等待时间,单位：毫秒ms
maxWait=5000

<html> </html>

<head> </head>

<title> </title>  在头标签中

<meta charset="utf8">  在头标签中

<body> </body>

color="颜色"
bgcolor="背景色"
background="背景图路径"
颜色表示方式：① 颜色名称 red green ② RGB模式 #000000 #FFFFFF

<!-- 注释文本 -->

<br />

<p> </p>  自带换行，有行间距

属性

<hr />

属性

<div> </div>  独占一行，自带换行
默认宽度为浏览器部分宽度，高度会跟随元素内的文本内容而改变
应用：结合css做页面分块，布局

<span> </span>  所有内容都在同一行
默认宽度和高度都会随着内容改变
应用：友好提示信息的显示

<ul>
    <li> </li>
    <li> </li>
    <li> </li>
</ul>

<ol>
    <li> </li>
    <li> </li>
    <li> </li>
</ol>

<dl>  列表
    <dt>Coffee</dt>  标题
        <dd>Black hot drink</dd>  内容
    <dt>Milk</dt>
        <dd>White cold drink</dd>
</dl>

可以相互任意嵌套

src="图片地址"
height="高度"
width="宽度"
border="边框"
alt="图片未被加载时的提示文字"
title="图片被鼠标悬停时的提示文字"

href="跳转的地址"  // 跳转外网需要添加协议http/https
target="_self"(当前页) "_blank"(一直新页面) "_search"(仅1个新页面复用)

充当锚点(跳转顶部/跳转底部)
提供率 name 属性，为其赋值
点击跳转的标签 href 属性给 #name
<a name="tops"></a>
<a href="#tops">跳到顶部</a>

table

th

td

列合并

行合并

• 账户：<input type="text" name="username" placeholder="请输入账户" />
  
• 密码：<input type="password" name="password" placeholder="请输入密码" />
  
• 性别：

            <input type="radio" name="sex" value="male" checked="checked" />男
            <input type="radio" name="sex" value="female" />女

• 照片：type="file"
• 地址：<select name="city">

                <option value="zz">郑州</option>
                <option value="zz" selected="selected">南阳</option>
          </select>

• 爱好：

            <input type="checkbox" name="hobbys" value="basketball" checked="checked" />篮球
            <input type="checkbox" name="hobbys" value="football" checked="checked" />足球
            <input type="checkbox" name="hobbys" value="volleyball" checked="checked" />排球

• 介绍：<textarea name="introduce"></textarea>
• 提交：
  <input type="submit" name="submit" value="注册" />
  <button type="submit">注册</button>
• 清空：
  <input type="reset" name="reset" id="" value="清空" />
  <button type="reset">清空</button>

标签名[属性名="值"]{
    属性名:属性值;
}

父选择器>子选择器{
    属性名:属性值;
}
// 【子代】亲儿子不跨标签层级

• * 主要用于 a 标签上
  a:link {color: #FF0000}        /* 未访问的链接样式 */
• a:visited {color: #00FF00}   /* 已访问的链接样式 */
• a:hover {color: #FF00FF}     /* 鼠标移动到标签内容上 */
• a:active {color: #0000FF}    /* 选定时标签内容样式 */

注意：在 CSS 定义中，a:hover 必须被置于 a:link 和 a:visited 之后，才是有效的。
注意：在 CSS 定义中，a:active 必须被置于 a:hover 之后，才是有效的。
注意：伪类名称对大小写不敏感。

• font 简写属性。作用是把所有针对字体的属性设置在一个声明中。eg：font:oblique 700 30px "黑体"; /* 样式 加粗 大小 风格 */
• font-family 设置字体系列。
• font-size 设置字体的尺寸。
• font-style 设置字体风格。（斜体）
• font-weight 设置字体的粗细。
  

• color 设置文本颜色
• direction 设置文本方向。
• line-height 设置行高。
• text-align 对齐元素中的文本。（左对齐、居中、右对齐）
• text-decoration 向文本添加修饰。（上划线、下划线、删除线、无线条）
• text-indent 缩进元素中文本的首行（2em : 2个字符；20% : 20%的宽度）
• text-transform 控制元素中的字母。（全大写、全小写、所有单词首字母大写）
• unicode-bidi 设置文本方向。
• white-space 设置元素中空白的处理方式。（="nowrap" 禁止文本分行，即都在1行内）
• letter-spacing 设置字符间距。
• word-spacing 设置单词间距。

1.官网下载 tomcat.apache.org Tomcat8.0|8.5版本
2.解压到一个没有特殊符号的路径
3.进入到解压的目录下，bin\startup.bat启动
* 不要放入层次多的文件夹中、不建议放中文路径、依赖JAVA_HOME环境变量。

• bin 二进制可执行文件和启动脚本文件
• conf 配置目录：

     server.xml 配置整个服务器的信息
     tomcatusers.xml 存储tomcat用户信息
     web.xml 部署描述符文件,注册了很多MIME即文档类型
     context.xml 对所有应用的统一配置，通常不配置它

• lib 服务器启动以来的核心类库，jar包文件
• logs 日志文件，启动、关闭、错误、异常等信息
• temp 存放临时文件，可以在tomcat关闭后删除
• webapps 存放web项目的核心目录，其中每个文件夹都是一个项目，ROOT是未给出项目目录时的特殊项目
• work 运行时生成的文件，最终运行的文件都在这里，通过webapps中的项目生成的

bin/startup.bat 启动服务器
bin/shutdown.bat 关闭服务器

* 中文乱码解决：logging.properties >> 注释掉line47 #java.util.logging.ConsoleHandler.encoding = UTF-8

http://ip:port/project/资源 （静态[html/css/javascript]、动态[servlet/jsp]）

浏览器访问 http://localhost:8080  或  http://127.0.0.1:8080

默认访问 index.xml 或 index.jsp

常见错误

配置默认访问页

配置端口号：conf/server.xml

配置项目为默认启动项目：conf/server.xml

直接拷贝

conf/server.xml

conf/Catalina/localhost

Window >> Preferences >> Server

点击add >> 选择对应的版本 >> Finish

File >> Settings >> build-execution-deployment >> 选择Application Servers >> 添加Tomcat >> 选择Tomcat安装根目录
如：D:\tomcat\apache-tomcat-8.5.53

* 解决源码编译运行后打印中文乱码问题：Tomcat-8.5.53 >> Edit Configuration >> VM option:-Dfile.encoding=utf-8

@Override
方法覆盖注解

@Deprecated
过时标记注解

@SupressWarning("all")
压制所有警告注解

@FunctionaInterface
函数式接口注解

@SafeVarargs
安全的可变参数注解

Junit

Servlet

（框架注解）待补充

@Retention(RetentionPolicy.RUNTIME)
public @interface 自定义注解名 {
    数据类型 属性名1() default 默认值1;
    数据类型 属性名2() default 默认值2;
    数据类型 属性名3()[] default {元素值1, 元素值2, ...};
}

DBUtils

UserDaoImpl实现类

<servlet>
    <servlet-name>Demo01</servlet-name>
    <servlet-class>com.demo.t1.servlet.Demo01</servlet-class>
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>Demo01</servlet-name>
    <url-pattern>/demo</url-pattern>
</servlet-mapping>

web项目中会有 /demo 的访问资源，访问方式： http://localhost:8080/projname/demo

精确匹配  /具体的名称  只有url路径是具体的名称的时候才会触发Servlet
后缀匹配  *.xxx  只要是xxx结尾的就匹配触发Servlet
目录匹配  /a/b/c*  匹配对应目录资源下所有请求，包含服务器的所有资源
通配匹配  /  匹配所有请求，包含服务器的所有资源，不包含.jsp——为缺省Servlet(Tomcat自带缺省)

<load-on-startup>0</load-on-startup>
</servlet>

1) 标记容器是否在启动的时候就加载对应的 Servlet (实例化并调用其init()方法)
2) 它的值必须是一个整数，表示servlet应该被载入的顺序
3) 当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个 Servlet
4) 当值小于0或者没有指定时，则表示容器在该servlet被选择时才会去加载
5) 正数的值越小，该servlet的优先级越高，应用启动时就越先加载
6) 当值相同时，容器就会自己选择顺序来加载

分类：
① 带协议的绝对路径：http://localhost:8080/projname/img/pic.jpg
② 不带协议的绝对路径：/projname/img/pic.jpg
③ 相对路径：
    当前目录 ./  可省略
    上级目录 ../ 不可省略

<welcome-file-list>
    <welcome-file>page.html</welcome-file>
    <welcome-file>page.htm</welcome-file>
    <welcome-file>page.jsp</welcome-file>
</welcome-file-list>

<error-page>
    <!--当页面未找到报404时显示 location 标签指定的页面-->
    <error-code>404</error-code>
    <location>/error/404.html</location>
</error-page>

public Object getAttribute(String name)  获取域中指定参数名称的值
public void removeAttribute(String name)  将指定的参数和值移除
public void setAttribute(String name, Object object) 存储参数和值到到域中

Demo

<!--全局初始化参数:整个web应用，随着服务器的启动而初始化-->
<context-param>
    <param-name>username</param-name>
    <param-value>root</param-value>
</context-param>
<context-param>
    <param-name>password</param-name>
    <param-value>1234</param-value>
</context-param>
<!--或注解方式配置初始化参数-->

public String getInitParameter(String name)  获取初始化参数
public java.util.Enumeration<E> getInitParameterNames()  获取初始化参数集合

Demo

public String getRealPath(String path)  获取资源的真实路径
根据项目的当前路径 / 拼接，注意参数给的时候也是相对于 / 当前路径。

Demo

Demo

response.setStatus() 操作响应状态码，如200,302
response.sendError() 操作响应错误码，如404

response.setHeader() 覆盖原有响应头的值
response.addHeader() 在原有的响应头的基础上添加新值(Cookie)

response.getWriter().println("响应正文内容") 返回可将字符文本发送到客户端的 java.io.PrintWriter 对象

// ● 终极方案：同时设置服务器的编码，设置浏览器解码方式
response.setContentType("text/html;charset=utf-8");
// 其他方案：分别设置服务器编码、浏览器解码
response.setCharacterEncoding("utf-8") 设置服务器的编码方式
response.setHeader("Content-Type", "text/html;charset=utf-8") 设置浏览器的解码方式

/*定时跳转*/
response.setHeader("refresh", "5;url=/demo/demo02"); // 5s后跳转demo02

// 方式一：设置 Status Code=302 和 Location=url
response.setStatus(302);
response.setHeader("location", "/projname/success.html");
// ● 方式二：本质还是 Status Code=302 和 Location=url
response.sendRedirect("/projname/success.html");
response.sendRedirect(request.getContextPath() + File.separator + "资源/页面");

原理：
浏览器发送http请求 >> web服务器回复响应状态码302+响应头location给浏览器 >> 浏览器收到302则自动再发送1个http请求(url+location) >> 服务器根据新请求的url寻找资源响应给浏览器

特点：
1. 重定向是客户端行为
2. 重定向是浏览器做了至少 2 次的访问请求
3. 重定向浏览器地址改变
4. 重定向两次跳转之间传输的信息会丢失(request生命周期为单次请求)
5. 重定向可以定向到任何web资源(当前站点/外部站点)

request.getMethod() 获取请求方式
request.getRequestURI() 获取请求路径
request.getQueryString() 获取请求路径上的参数，仅限于GET

request.getHeader(String name) 根据请求头名称获取值，如 User-Agent

request.getParameter() 获取指定参数名称的值
request.getParameterValues() 获取指定参数名称的一组值
request.getParameterMap() 返回此请求的参数的 java.util.Map
request.getParameterNames() 获取所有的参数名称

@WebServlet(name = "任意名字", urlPatterns = "/资源路径")

<!--默认提交方式为 GET，同时可省略，POST不可省略-->
<form method="post" action="/projname/资源路径">...</form>

/* POST请求正文乱码，两种方式都可以；GET是QueryString乱码，只能用方式二 */
// ● 终极方案：设置请求正文编码，用于POST在Tomcat8.5环境。
request.setCharacterEncoding("utf-8");
// 其他方案：将请求中拿到的乱码字符串编码成iso8859-1字节，再将字节解码为utf-8字符串，通用Tomcat7.0&8.5环境。
String serverEncoding = request.getCharacterEncoding();
String tmp = request.getParameter("username");
String username = new String(tmp.getBytes(serverEncoding), "utf-8");
/* Tomcat8.5比7.0中新增了URIEncoding="utf-8"，修复了GET请求QueryString乱码，POST请求还需设置请求正文编码 */

// 转发，如提交成功自动进行一次配置路径的Servlet请求调用执行，此处为配置路径(无projname)
request.getRequestDispatcher("/资源路径").forward(request, response);

原理：
客户浏览器发送http请求 >> web服务器接收此请求 >> 服务器内部完成请求处理和转发动作 >> 将目标资源响应给客户

特点：
1. 转发是服务器行为
2. 转发是浏览器只做了 1 次访问请求
3. 转发浏览器地址不变
4. 转发两次跳转之间的信息不会丢失(request生命周期内可传递数据)
5. 转发只能将请求转发给同一个web项目内的资源

request.setAttribute(name, msg); // 设置数据msg取名name
request.getAttribute(name); // 获取数据与name对应
request.removeAttribute(name); // 删除数据与name对应
request.getAttributeNames(); // 获取所有的共享数据names

执行流程：
1.浏览器向服务器发送请求，服务器需要创建cookie，服务器会通过响应携带cookie，
   在产生响应时会产生Set-Cookie响应头，从而将cookie信息传递给了浏览器；
2.当浏览器再次向服务器发送请求时，会产生cookie请求头，将之前服务器的cookie信息再次发送给了服务器，
   然后服务器根据cookie信息跟踪客户端状态。

图示

// 用响应创建Cookie，等价于 response.addHeader("set-cookie", "name=value");
Cookie cookie = new Cookie(String name, String value); // Cookie: name=value
cookie.setMaxAge(seconds); // 设置Cookie的生命周期
cookie.setPath("/"); // 设置Cookie的共享范围
response.addCookie(cookie); // 添加1个Cookie

// 用请求获取Cookie
Cookie[] cookies = request.getCookies(); // 获取Cookies返回数组
// 需遍历
cookie.getName();
cookie.getValue();
// 修改Cookie
cookie.setValue(String);

// 设置Cookie的共享范围
cookie.setPath("/");

/ 当前项目下所有资源均可共享访问该Cookie对象内容
/project/demo 当前项目下只有资源demo均可共享访问该Cookie对象内容

// 设置Cookie生命周期，单位s
cookie.setMaxAge(int); // 7天：7*24*60*60

• <0：浏览器会话结束/浏览器关闭，内存存储(默认)
• =0：失效
• >0：生效时间，单位s

* 在生命周期内Cookie会跟随任何请求，可通过设置路径限制携带Cookie的请求资源范围。

中文：Unicode，4个字节    英文：ASCII，2个字节

Cookie的中文乱码需要进行编码和解码处理：
编码：java.net.URLEncoder 的 URLEncoder.encode(String str, String encoding)
解码：java.net.URLDecoder 的 URLDecoder.decode(String str, String encoding)

chrome://settings/content/cookies

chrome://settings/siteData

优点：
● 可配置三种到期规则：1次请求就失效，1次浏览器会话(关闭)失效，配置永久生效
● 简单性：基于文本的轻量结构，简单键值对
● 数据持久性：虽然Cookie可被客户端浏览器的过期处理和干预，但Cookie通常也是客户端上持续时间最长的数据保留形式

缺点：
● 大小受到限制：大多数浏览器的Cookie只有4kb大小的限制
● 用户配置禁用：客户浏览器设置了禁用接收Cookie的能力，限制了该功能
● 潜在安全风险：用户可能会操纵篡改浏览器上的Cookie，会造成Cookie应用程序执行失败的问题

LastVisitTimeServlet

HistoryServlet

request 1个用户可有多个；session 1个用户1个；servletContext 所有用户共用1个。
为了节省空间，提高效率，ServletContext 中要放必须的、重要的、所有用户需要共享的线程安全的一些信息。

执行流程：
1. 第一次请求，请求头中没有jsessionid的cookie，当访问到对应的servlet资源时，执行到getSession()会创建HttpSession对象；进而响应时就将session的id作为cookie的value，响应到浏览器 Set-cookie:jsessionid=xxxx;
2. 再一次请求时，http请求中就有一个cookie:jsessionid=xxxx信息，那么该servlet就可以通过getSession()获取到jsessionid在服务器内查找对应的session对象，有就使用，无就创建。

图示

// 获取session对象
HttpSession session = request.getSession();
// 获取session对象的唯一标识：sessionID (JSESSIONID=E925DE1EF00F7944537C01A3BC0E2688)
String jsessionid = session.getId();
// 销毁session对象中的jsessionid
session.invalidate();

// 往 session 中存储 msg
HttpSession session = request.getSession();
session.setAttribute("msg", "helloSession");
// 获取 msg
HttpSession session = request.getSession();
Object msg = session.getAttribute("msg");
// 删除域对象中的数据
session.removeAttribute("msg");

一般都是默认值 30 分钟，无需更改。

浏览器关闭：销毁Cookie中的jsessionid=xxx，原session对象会保留默认30min后才销毁，30分钟后为新的session;
session销毁：调用 session.invalidate() 方法后，立即将session对象销毁，再次访问时会创建新的session。

c3p0连接池

页面和Servlet

生命周期为服务器开启和关闭，而且所有用户都会共享，范围过大，保密性不高。

生命周期太短，一次请求就丢失，无法再重定向后再次获取内容

存储在客户端浏览器，不安全！客户端浏览器可对cookie进行查看或修改，而且cookie无法定义特殊符号

存储在服务器，默认30分钟才销毁更新，或者服务器中主动销毁，适合用户登陆信息的共享

public class Filter01 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter01 过滤器的初始化");
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter01 放行之前");
        // 通过过滤器链操作：放行
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("Filter01 放行之后");
    }
    @Override
    public void destroy() {
        System.out.println("Filter01 过滤器的销毁");
    }
}

<!--声明Filter01过滤器-->
<filter>
    <filter-name>Filter01</filter-name>
    <filter-class>com.demo.filter.Filter01</filter-class>
</filter>
<!--配置Filter01的过滤路径-->
<filter-mapping>
    <filter-name>Filter01</filter-name>
    <!--/ 代表所有资源都过滤-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!--无限接近SpringMVC中文乱码解决方案-->
<filter>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>com.demo.filter.EncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
        </init-param>
</filter>
<filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

步骤：声明过滤器，配置过滤路径。

匹配规则

@WebFilter注解
WebInitParam[] initParams() default {}; //配置初始化参数
String filterName() default ""; //配置过滤器名称
String[] servletNames() default {}; //配置过滤的Servlet
String[] urlPatterns() default {}; //配置过滤路径

使用注解

页面乱码处理 login.jsp 不会乱码

html 请求和响应乱码

1. 登陆账户后，根据是否勾选了自动登录选项框
2. 判断是否访问和登陆相关资源
    * 如果是，直接放行
    * 如果不是，判断是否已经在登陆状态
            * 如果已登陆，直接放行
            * 如果不是，需要从cookie中取出存储的用户信息，进行登陆操作
                    * 如果登陆成功，直接放行
                    * 如果登陆失败，就跳转到登陆页面

web.xml

使用动态代理模式在过滤器中增强 request.getParameter() 方法
使其在浏览器发起请求时拥有过滤敏感词功能。

一类监听器：监听域对象的创建、销毁

二类监听器：监听域对象中的属性变更（属性设置、属性替换、属性移除）

三类监听器：监听域对象中的java对象的绑定

事件源：request、session、servletContext三大域对象

监听器：Servlet对象（三种监听器）

绑定：web.xml配置 或 @WebListener注解

事件：域对象发生改变

ServletContextListener

HttpSessionListener

ServletRequestListener

ServletContextAttributeListener

HttpSessionAttributeListener

ServletRequestAttributeListener

HttpSessionBindingListener

配置 web.xml

@注解

login.html

login.html

/*
* Generated by the Jasper component of Apache Tomcat
* Version: Apache Tomcat/8.5.53
* Generated at: 2020-04-26 07:19:38 UTC
* Note: The last modified time of this file was set to
* the last modified time of the source file after
* generation to assist with modification tracking.
*/

设置jsp页面的基本属性

<%@ page contentType="text/html;charset=UTF‐8" language="java" import="java.util.List" isELIgnored="false" session="false"%>

• contentType="..."  相当于 response.setContentType("...") 设置编解码方式
• language="java"  jsp脚本上可以使用的语言，一般不用，默认java
• import="java.util.List"  页面上导入java包，多个包使用逗号分隔（IDEA可以导入包，默认导入jsp页面顶部-为单独的page指令导包）
• isELgnored="false"  是否忽略el表达式，默认false是不忽略
• errorPage="error.jsp"  用于指定错误页面，当前页面发生错误后，会跳转到指定的错误页面
• isErrorPage="true"  为true时可以在当前页面直接使用jsp内置对象exception，即 <%= exception.toString() %> 或 ${exception} 页面输出错误信息
• extends="org.apache.jasper.runtime.HttpJspBase"  默认继承自HttpJspBase类，不动！

在当前jsp页面导入 jstl 标签库（JSP标准标签库是由JCP所制定的标准规范）

uri属性确定标签库的位置，prefix属性指定标签库的前缀
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

嵌套其他jsp文件的jsp代码（其他jsp代码可以只是所需部分）

第一种 include指令：`通过file属性来指定被包含的页面`，当JSP转换成Servlet时引入指定文件，`一般不需要写头`
<%@ pagecontentType="text/html;charset=GB2312" language="java"errorPage=""%>
<%@ include file="head.jsp"%>
<%@ include file="body.jsp"%>
<%@ include file="tail.jsp"%>

第二种 <jsp:include>动作元素：`通过page属性来指定被包含的页面`，当JSP页面被请求时引入指定文件，`需要写头`
可以用<jsp:param>来向所包含页传递参数。
<%@ page contentType="text/html; charset=GB2312"language="java" errorPage=""%>
<jsp:include page="head.jsp"/>
    <jsp:param name="uid"value="username"/>
    <jsp:param name="pwd"value="password"/>
</jsp:include>
<jsp:include page="body.jsp"/>
<jsp:include page="tail.jsp"/>

代表 page 域，但是 jsp 中 page 它的类型是 Object，所以操作 page 域我们使用的是 pageContext 对象，page 域就是指当前页面

作用在当前页面

作用在一次请求

作用在一次会话

作用在整个项目

UserServlet

算术、关系、逻辑、三目运算 Demo

字符串判断/判空

获取方式

注意事项：
* 如果 el 表达式没有获取到结果，返回的不是 null 而是 "" 空字符串；
* ${name} 不指定域的写法，jsp 页面就会从小到大的域数据进行查找：
pageScope -> requestScope -> sessionScope -> applicationScope
* 域中的共享数据一定要区别 name 的名字，以区别不同的域；

获取内容

包含 4 个域对象：pageScope / requestScope / sessionScope / applicationScope
包含 7 个 web 对象：param / paramValues / initParam / header / headerValues / cookie / pageContext
常用：4个域对象 + cookie + pageContext

param <==> request.getParameter()
paramValues <==> request.getParameters()
initParam <==> 获取初始化参数
header <==> 获取单个请求头
headerValues <==> 获取一组请求头
cookie <==> 获取 Map 类型的 cookie 对象
pageContext <==> 获取 jsp 内置的 9 大对象

Demo

jstl.jar

standard.jar

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

向域中设置数据，等价于 域对象.setAttribute()

将数据从域中移除，等价于 域对象.removeAttribute()

捕获异常，等价于 try-catch

条件判断

遍历数组或集合

分割字符串

jsp：请求处理、业务处理、数据库操作、数据显示
javaBean：数据封装

优点：开发简单
缺点：维护难，代码几乎都在 jsp 中

jsp: 数据显示
Servlet: 请求处理、业务处理、数据库操作
javaBean: 数据封装

优点：维护方便，开发各司其职利于模块分工，适合开发复杂项目，组件可以重用
缺点：开发难度大，对开发要求高

BeanUtils 框架

regist.jsp

自定义 MyBeanUtils.populate()

Model

View

三层架构

环境

依赖

配置文件

https://simple.blog.csdn.net/article/details/105849671

一次性全部查询出来，存放到List中，在List中截取subList作为页数据

优：减少操作数据库的次数
缺：数据量非常大，查询时间比较长

页面查询一页，就从数据库里查询一页数量的数据

优：减少单次查询数据库的时间
缺：增加了操作数据库的次数

当前页数 currentPage

当前页数 currentPage

总页数 totalPage

总记录数 totalSize

每页记录数 pageSize

当前页数据 pageList

表单数据提交方式 POST

表单中设置文件上传项 <input type="file">

enctype=multipart/form-data

导入 jar 包

前台：文件上传项(JSP)

后台：编写 Servlet

ServletFileUpload 核心解析类

FileItem 文件项

文件名中文乱码

描述内中文乱码

文件名重复问题

bean

超链接

手动编写代码的方式下载

下载入口

设置媒体类型

设置下载窗口

IO读写(写-响应给浏览器)