JAVA

本导图根据廖雪峰网站学习总结的JAVA知识点，包含MAVEN、网络编程、java基础、XML与JSON、JDBC、javaEE。

JAVA

java基础

基本知识

版本

JAVASE

JAVAEE

JAVAME

JDK和JRE

┌─ ┌──────────────────────────────────┐ │ │ Compiler, debugger, etc. │ │ └──────────────────────────────────┘ JDK ┌─ ┌──────────────────────────────────┐ │ │ │ │ │ JRE │ JVM + Runtime Library │ │ │ │ │ └─ └─ └──────────────────────────────────┘ ┌───────┐┌───────┐┌───────┐┌───────┐ │Windows││ Linux ││ macOS ││others │ └───────┘└───────┘└───────┘└───────┘

JSR规范

设置环境变量

JAVA_HOME

PATH

运行java程序

javac

java

数据类型

基本类型

┌───┐ byte │ │ └───┘ ┌───┬───┐ short │ │ │ └───┴───┘ ┌───┬───┬───┬───┐ int │ │ │ │ │ └───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┬───┬───┬───┐ long │ │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ ┌───┬───┬───┬───┐ float │ │ │ │ │ └───┴───┴───┴───┘ ┌───┬───┬───┬───┬───┬───┬───┬───┐ double │ │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ ┌───┬───┐ char │ │ │ └───┴───┘

整数

下划线

十六进制

二进制

long型结尾

浮点数

科学计数法

float类型

字符

转义字符'\u'

布尔

引用类型

String字符串

常量

final NAME

var关键字

运算

整数相除

只会得到结果的整数部分 除数为0时编译不报错，运行报错

整数左移

负数右移

无符号右移

位运算

与

或

非

亦或

转义字符

\" 表示字符" \' 表示字符' \\ 表示字符\ \n 表示换行符 \r 表示回车符 \t 表示Tab \u#### 表示一个Unicode编码的字符

空值null

流程控制

输入和输出

格式化输出

%d 格式化输出整数 %x 格式化输出十六进制整数 %f 格式化输出浮点数 %e 格式化输出科学计数法表示的浮点数 %s 格式化字符串 连续两个%%表示一个%字符本身。

用0位补足8位

public class Main { public static void main(String[] args) { int n = 12345000; System.out.printf("n=%d, hex=%08x", n, n); // 注意，两个%占位符必须传入两个数 } }

输入

scanner

if

switch

匹配字符串内容相等

java12

->

public class Main { public static void main(String[] args) { String fruit = "apple"; int opt = switch (fruit) { case "apple" -> 1; case "pear", "mango" -> 2; default -> 0; }; // 注意赋值语句要以;结束 System.out.println("opt = " + opt); } }

yield

public class Main { public static void main(String[] args) { String fruit = "orange"; int opt = switch (fruit) { case "apple" -> 1; case "pear", "mango" -> 2; default -> { int code = fruit.hashCode(); yield code; // switch语句返回值 } }; System.out.println("opt = " + opt); } }

for

for each

数组

List

Map

while

break

continue

数组

冒泡排序

Arrays.sort（）

多维数组

Arrays.deepToString()

可变参数

class Group { private String[] names; public void setNames(String... names) { this.names = names; } }

static

静态字段

推荐用类名来访问静态字段。可以把静态字段理解为描述class本身的字段（非实例字段）。

静态方法

import

import static java.lang.System.*;

import java.lang.*

作用域

public

protected

继承

private

嵌套类

package

final

阻止继承

阻止被覆写

阻止被赋值

classpath

系统环境变量

启动JVM时设置

java -classpath .;C:\work\project1\bin;C:\shared abc.xyz.Hello java -cp .;C:\work\project1\bin;C:\shared abc.xyz.Hello

jar

jar包实际上就是一个zip格式的压缩文件，而jar包相当于目录。如果我们要执行一个jar包的class，就可以把jar包放到classpath中 java -cp ./hello.jar abc.xyz.Hello

MANIFEST.MF

java -jar hello.jar

模块

java9

jmod

编写模块

bin

build.sh

src

code

module-info.java

module hello.world { requires java.base; // 可不写，任何模块都会自动引入java.base requires java.xml; }

执行模块

javac -d bin src/module-info.java src/com/itranswarp/sample/*.java

打包jar

jar --create --file hello.jar --main-class com.itranswarp.sample.Main -C bin

将jar包转换成模块

jmod create --class-path hello.jar hello.jmod

运行模块

java --module-path hello.jar --module hello.world

打包jre

jlink --module-path hello.jmod --add-modules java.base,java.xml,hello.world --output jre/ jre/bin/java --module hello.world

访问权限

字符编码

Unicode

UTF-8

ANSI

ISO-8859-1

ASCLL

GBK

GB2312

BIG5

面向对象编程

基础

方法

构造方法

重载

抽象类

抽象方法

面向抽象编程

接口

接口继承

静态字段

public static final

default

继承

超类

父类

子类

基类

扩展类

protected

super

阻止继承

sealed

sealed类在Java 15中目前是预览状态，要启用它，必须使用参数--enable-preview和--source 15。

java15

向上转型

Person p = new Student();

向下转型

Person p1 = new Student(); // upcasting, ok Person p2 = new Person(); Student s1 = (Student) p1; // ok Student s2 = (Student) p2; // runtime error! ClassCastException!

instanceof

多态

Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。

@Override

Object方法

toString()

equals()

equalsIgnoreCase()

hashCode()

@Overload

final

方法

类

属性

构造方法

包

包没有父子关系。java.util和java.util.zip是不同的包，两者没有任何继承关系。

内部类

Inner Class

public class Main { public static void main(String[] args) { Outer outer = new Outer("Nested"); // 实例化一个Outer Outer.Inner inner = outer.new Inner(); // 实例化一个Inner inner.hello(); } } class Outer { private String name; Outer(String name) { this.name = name; } class Inner { void hello() { System.out.println("Hello, " + Outer.this.name); } } }

Anonymous Class

public class Main { public static void main(String[] args) { Outer outer = new Outer("Nested"); outer.asyncHello(); } } class Outer { private String name; Outer(String name) { this.name = name; } void asyncHello() { Runnable r = new Runnable() { @Override public void run() { System.out.println("Hello, " + Outer.this.name); } }; new Thread(r).start(); } }

Static Nested Class

public class Main { public static void main(String[] args) { Outer.StaticNested sn = new Outer.StaticNested(); sn.hello(); } } class Outer { private static String NAME = "OUTER"; private String name; Outer(String name) { this.name = name; } static class StaticNested { void hello() { System.out.println("Hello, " + Outer.NAME); } } }

Java核心类

String字符串

转义字符'\'

多行字符串

Java13

字符串不可变

public class Main { public static void main(String[] args) { String s = "hello"; String t = s; s = "world"; System.out.println(t); // 输出hello } } public class Main { public static void main(String[] args) { String s1 = "hello"; String s2 = "HELLO".toLowerCase(); System.out.println(s1); System.out.println(s2); if (s1 == s2) { System.out.println("s1 == s2"); } else { System.out.println("s1 != s2");//输出 } } }

equals与==

equalsIgnoreCase()

indexOf

lastIndexOf()

contains()

startsWith

endsWith

substring

trim()

strip()

stripLeading()

stripTrailing

isEmpty()

isBlank()

replace（）

replaceAll()

split（）

join（）

format（）

%s

%d

%x

%f

valueOf()

parseInt()

parseBoolean()

getInteger()

char[]

toCharArray()

new String()

getBytes

byte[] b1 = "Hello".getBytes(); // 按系统默认编码转换，不推荐 byte[] b2 = "Hello".getBytes("UTF-8"); // 按UTF-8编码转换 byte[] b2 = "Hello".getBytes("GBK"); // 按GBK编码转换 byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换

new String()

byte[] b = ... String s1 = new String(b, "GBK"); // 按GBK转换 String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换

StringBuilder

append()

StringJoiner

add()

public class Main { public static void main(String[] args) { String[] names = {"Bob", "Alice", "Grace"}; var sj = new StringJoiner(", ", "Hello ", "!"); for (String name : names) { sj.add(name); } System.out.println(sj.toString()); } }

join()

包装类型

基本类型包装类

boolean java.lang.Boolean byte java.lang.Byte short java.lang.Short int java.lang.Integer long java.lang.Long float java.lang.Float double java.lang.Double char java.lang.Character

int和Integer的互相转换

Integer n = null; Integer n2 = new Integer(99); Integer n3 = Integer.valueOf(99); int n3 = n2.intValue();

Auto Boxing

不变类

equals

进制转换

public class Main { public static void main(String[] args) { System.out.println(Integer.toString(100)); // "100",表示为10进制 System.out.println(Integer.toString(100, 36)); // "2s",表示为36进制 System.out.println(Integer.toHexString(100)); // "64",表示为16进制 System.out.println(Integer.toOctalString(100)); // "144",表示为8进制 System.out.println(Integer.toBinaryString(100)); // "1100100",表示为2进制 } }

Number

// 向上转型为Number: Number num = new Integer(999); // 获取byte, int, long, float, double: byte b = num.byteValue(); int n = num.intValue(); long ln = num.longValue(); float f = num.floatValue(); double d = num.doubleValue();

处理无符号整型

public class Main { public static void main(String[] args) { byte x = -1; byte y = 127; System.out.println(Byte.toUnsignedInt(x)); // 255 System.out.println(Byte.toUnsignedInt(y)); // 127 } }

JavaBean

getter

setter

isBoolean

枚举属性

public class Main { public static void main(String[] args) throws Exception { BeanInfo info = Introspector.getBeanInfo(Person.class); for (PropertyDescriptor pd : info.getPropertyDescriptors()) { System.out.println(pd.getName()); System.out.println(" " + pd.getReadMethod()); System.out.println(" " + pd.getWriteMethod()); } } } class Person { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

枚举类

enum

比较

name()

ordinal()

指定int值

toString（）

switch

记录类

JAVA14

record类

构造方法

of()

public record Point(int x, int y) { public static Point of() { return new Point(0, 0); } public static Point of(int x, int y) { return new Point(x, y); } }

BigInteger

pow()

add()

longValue()

longValueExact()

BigDecimal

scale（）

返回负数

setScale()

public static void main(String[] args) { BigDecimal d1 = new BigDecimal("123.456789"); BigDecimal d2 = d1.setScale(4, RoundingMode.HALF_UP); // 四舍五入，123.4568 BigDecimal d3 = d1.setScale(4, RoundingMode.DOWN); // 直接截断，123.4567 System.out.println(d2); System.out.println(d3); }

stripTrailingZeros()

除数

BigDecimal d1 = new BigDecimal("123.456"); BigDecimal d2 = new BigDecimal("23.456789"); BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入 BigDecimal d4 = d1.divide(d2); // 报错：ArithmeticException，因为除不尽

求除数和余数

public class Main { public static void main(String[] args) { BigDecimal n = new BigDecimal("12.345"); BigDecimal m = new BigDecimal("0.12"); BigDecimal[] dr = n.divideAndRemainder(m); System.out.println(dr[0]); // 102 System.out.println(dr[1]); // 0.105 } }

equals()

compareTo()

常用工具类

Math

abs()

max(),min()

pow()

sqrt()

exp()

log()

log10()

三角函数

Math.sin(3.14); // 0.00159... Math.cos(3.14); // -0.9999... Math.tan(3.14); // -0.0015... Math.asin(1.0); // 1.57079... Math.acos(1.0); // 0.0

数学常量

PI

E

random()

生成指定区间的随机数

// 区间在[MIN, MAX)的随机数 public class Main { public static void main(String[] args) { double x = Math.random(); // x的范围是[0,1) double min = 10; double max = 50; double y = x * (max - min) + min; // y的范围是[10,50) long n = (long) y; // n的范围是[10,50)的整数 System.out.println(y); System.out.println(n); } }

Random

Random r = new Random(); r.nextInt(); // 2071575453,每次都不一样 r.nextInt(10); // 5,生成一个[0,10)之间的int r.nextLong(); // 8811649292570369305,每次都不一样 r.nextFloat(); // 0.54335...生成一个[0,1)之间的float r.nextDouble(); // 0.3716...生成一个[0,1)之间的double

SecureRandom

public class Main { public static void main(String[] args) { SecureRandom sr = null; try { sr = SecureRandom.getInstanceStrong(); // 获取高强度安全随机数生成器 } catch (NoSuchAlgorithmException e) { sr = new SecureRandom(); // 获取普通的安全随机数生成器 } byte[] buffer = new byte[16]; sr.nextBytes(buffer); // 用安全随机数填充buffer System.out.println(Arrays.toString(buffer)); } }

异常

┌───────────┐ │ Object │ └───────────┘ ▲ │ ┌───────────┐ │ Throwable │ └───────────┘ ▲ ┌─────────┴─────────┐ │ │ ┌───────────┐ ┌───────────┐ │ Error │ │ Exception │ └───────────┘ └───────────┘ ▲ ▲ ┌───────┘ ┌────┴──────────┐ │ │ │ ┌─────────────────┐ ┌─────────────────┐┌───────────┐ │OutOfMemoryError │... │RuntimeException ││IOException│... └─────────────────┘ └─────────────────┘└───────────┘ ▲ ┌───────────┴─────────────┐ │ │ ┌─────────────────────┐ ┌─────────────────────────┐ │NullPointerException │ │IllegalArgumentException │... Exception │ ├─ RuntimeException │ │ │ ├─ NullPointerException │ │ │ ├─ IndexOutOfBoundsException │ │ │ ├─ SecurityException │ │ │ └─ IllegalArgumentException │ │ │ └─ NumberFormatException │ ├─ IOException │ │ │ ├─ UnsupportedCharsetException │ │ │ ├─ FileNotFoundException │ │ │ └─ SocketException │ ├─ ParseException │ ├─ GeneralSecurityException │ ├─ SQLException │ └─ TimeoutException

分类

ERROR

EXCEPTION

RuntimeException及其子类

非RuntimeException

不需要捕获的异常

必须捕获的异常

throw

try catch

多个catch

finally

printStackTrace()

异常的转化

public class Main { public static void main(String[] args) { try { process1(); } catch (Exception e) { e.printStackTrace(); } } static void process1() { try { process2(); } catch (NullPointerException e) { throw new IllegalArgumentException(e); } } static void process2() { throw new NullPointerException(); } }

Throwable.getCause()

异常屏蔽

Throwable.addSuppressed()

public class Main { public static void main(String[] args) throws Exception { Exception origin = null; try { System.out.println(Integer.parseInt("abc")); } catch (Exception e) { origin = e; throw e; } finally { Exception e = new IllegalArgumentException(); if (origin != null) { e.addSuppressed(origin); } throw e; } } }

自定义异常

NullPointerException

JAVA14

java -XX:+ShowCodeDetailsInExceptionMessages Main.java

Assertion

可选的断言消息

assert x >= 0 : "x must >= 0";

启用断言

java -ea Main.java

Logging

JDK Logging

级别

SEVERE

WARNING

INFO

CONFIG

FINE

FINER

FINEST

Commons Logging（日志API)

级别

FATAL

ERROR

WARNING

INFO

DEBUG

TRACE

log.error

Log4j(日志底层）

<?xml version="1.0" encoding="UTF-8"?> <Configuration> <Properties> <!-- 定义日志格式 --> <Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property> <!-- 定义文件名变量 --> <Property name="file.err.filename">log/err.log</Property> <Property name="file.err.pattern">log/err.%i.log.gz</Property> </Properties> <!-- 定义Appender，即目的地 --> <Appenders> <!-- 定义输出到屏幕 --> <Console name="console" target="SYSTEM_OUT"> <!-- 日志格式引用上面定义的log.pattern --> <PatternLayout pattern="${log.pattern}" /> </Console> <!-- 定义输出到文件,文件名引用上面定义的file.err.filename --> <RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}"> <PatternLayout pattern="${log.pattern}" /> <Policies> <!-- 根据文件大小自动切割日志 --> <SizeBasedTriggeringPolicy size="1 MB" /> </Policies> <!-- 保留最近10份 --> <DefaultRolloverStrategy max="10" /> </RollingFile> </Appenders> <Loggers> <Root level="info"> <!-- 对info级别的日志，输出到console --> <AppenderRef ref="console" level="info" /> <!-- 对error级别的日志，输出到err，即上面定义的RollingFile --> <AppenderRef ref="err" level="error" /> </Root> </Loggers> </Configuration>

SLF4J

Logback

<?xml version="1.0" encoding="UTF-8"?> <configuration> <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> </encoder> </appender> <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> <charset>utf-8</charset> </encoder> <file>log/output.log</file> <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy"> <fileNamePattern>log/output.log.%i</fileNamePattern> </rollingPolicy> <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"> <MaxFileSize>1MB</MaxFileSize> </triggeringPolicy> </appender> <root level="INFO"> <appender-ref ref="CONSOLE" /> <appender-ref ref="FILE" /> </root> </configuration>

反射

定义

如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。 这种通过Class实例获取class信息的方法称为反射（Reflection）。

作用

反射是为了解决在运行期，对某个实例一无所知的情况下，如何调用其方法。

获取一个class的Class实例

通过静态变量

Class cls = String.class;

实例变量的getClass（）方法

String s = "Hello"; Class cls = s.getClass();

完整类名Class.forName()

Class cls = Class.forName("java.lang.String");

Class实例与instanceof的差别

用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。

newInstance()

// 获取String的Class实例: Class cls = String.class; // 创建一个String实例: String s = (String) cls.newInstance();

public的无参构造方法

动态加载

访问字段

getField()

getName()

getType()

getModifiers()

getDeclaredField()

getFields()

getDeclareFields()

获取字段值

Field.get(Object)

Field.setAccessible(true)

设置字段值

Field.set()

调用方法

public class Main { public static void main(String[] args) throws Exception { // String对象: String s = "Hello world"; // 获取String substring(int)方法，参数为int: Method m = String.class.getMethod("substring", int.class); // 在s对象上调用该方法并获取结果: String r = (String) m.invoke(s, 6); // 打印调用结果: System.out.println(r); } }

getMethod()

getName()

getReturnType()

getParameterTypes()

getModifiers()

getDeclaredMethod()

getMethods()

getDeclareMethods()

invoke()

调用静态方法

调用非public

Method.setAccessible(true)

多态

调用构造方法

getConstructor()

getDeclaredConstructor()

getConstructors()

getDeclaredConstructors()

获取继承关系

获取父类的class

getSuperClass()

interface

getInterfaces()

isAssignableFrom()

// Integer i = ? Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer // Number n = ? Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number // Object o = ? Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object // Integer i = ? Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

动态代理

interface实例

public class Main { public static void main(String[] args) { InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(method); if (method.getName().equals("morning")) { System.out.println("Good morning, " + args[0]); } return null; } }; Hello hello = (Hello) Proxy.newProxyInstance( Hello.class.getClassLoader(), // 传入ClassLoader new Class[] { Hello.class }, // 传入要实现的接口 handler); // 传入处理调用方法的InvocationHandler hello.morning("Bob"); } } interface Hello { void morning(String name); }

接口方法的调用

InvocationHandler

创建interface实例

newProxyInstance()

classloader

实现的接口数组

调用的InvocationHandler实例

将Object强制转型为接口

注解

定义

注解是放在Java源码的类、方法、字段、参数前的一种特殊“注释”： 注释会被编译器直接忽略，注解则可以被编译器打包进入class文件，因此，注解是一种用作标注的“元数据”。

分类

编译器使用

工具处理.class文件使用

程序运行时可以读取

配置参数

所有基本类型

String

枚举类型

基本类型、String、Class以及枚举的数组

元注解

@Target

METHOD

FIELD

@Retention

SOURCE

CLASS

RUNTIME

@Repeatable

@Inherited

定义注解

public @interface Report { int type() default 0; String level() default "info"; String value() default ""; }

定义

添加参数

元注解配置注解

处理注解

判断注解是否存在

isAnnotationPresent()

读取注解

getAnnotation()

泛型

向上转型

泛型接口

静态泛型方法

多个泛型类型

擦拭法

无法持有基本类型

无法取得带泛型的class

不能判断带泛型类型的类型

无法实例化T类型

借助额外参数

public class Pair<T> { private T first; private T last; public Pair(Class<T> clazz) { first = clazz.newInstance(); last = clazz.newInstance(); } }

泛型继承

┌────┐ │Type│ └────┘ ▲ │ ┌────────────┬────────┴─────────┬───────────────┐ │ │ │ │ ┌─────┐┌─────────────────┐┌────────────────┐┌────────────┐ │Class││ParameterizedType││GenericArrayType││WildcardType│ └─────┘└─────────────────┘└────────────────┘└────────────┘

PECS原则

extends通配符

static int add(Pair<? extends Number> p) { Number first = p.getFirst(); Number last = p.getLast(); return first.intValue() + last.intValue(); }

限定T类型

super通配符

使用<? super Integer>通配符表示： 允许调用set(? super Integer)方法传入Integer的引用； 不允许调用get()方法获得Integer的引用。

无限定通配符

<?>

集合

List

方法

add

末尾添加元素

指定索引添加元素

remove

删除指定索引

删除某个元素

get

获取指定索引的元素

size

of

contains

equals

indexOf

转化

List——>Array

toArray()

toArray(T[])

public class Main { public static void main(String[] args) { List<Integer> list = List.of(12, 34, 56); Number[] array = list.toArray(new Number[3]); //Integer[] array = list.toArray(new Integer[list.size()]); for (Number n : array) { System.out.println(n); } } }

toArray(Integer[]::new)

Array——>List

实现类

ArrayList

LinkedList

链表

Map

map中不存在重复的key Map<String, Integer> map = new HashMap<>(10000);

实现类

HashMap

覆写equals方法

覆写hashCode方法

int hashCode() { return Objects.hash(firstName, lastName, age); }

哈希冲突

EnumMap

SortedMap

TreeMap

不用equals和hascode方法

Comparable

public class Main { public static void main(String[] args) { Map<Person, Integer> map = new TreeMap<>(new Comparator<Person>() { public int compare(Person p1, Person p2) { return p1.name.compareTo(p2.name); } }); map.put(new Person("Tom"), 1); map.put(new Person("Bob"), 2); map.put(new Person("Lily"), 3); for (Person key : map.keySet()) { System.out.println(key); } // {Person: Bob}, {Person: Lily}, {Person: Tom} System.out.println(map.get(new Person("Bob"))); // 2 } } class Person { public String name; Person(String name) { this.name = name; } public String toString() { return "{Person: " + name + "}"; } }

方法

get

put

contains

遍历

key

keySet

public class Main { public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("apple", 123); map.put("pear", 456); map.put("banana", 789); for (String key : map.keySet()) { Integer value = map.get(key); System.out.println(key + " = " + value); } } }

key，value

entrySet

public class Main { public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("apple", 123); map.put("pear", 456); map.put("banana", 789); for (Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key + " = " + value); } } }

getKey

getValue

配置文件

本质上是从hashtable派生的

读取配置文件

#setting.properties last_open_file=/data/hello.txt auto_save_interval=60 //demo String f = "setting.properties"; Properties props = new Properties(); props.load(new java.io.FileInputStream(f)); String filepath = props.getProperty("last_open_file"); String interval = props.getProperty("auto_save_interval", "120");

创建properties实例

调用load（）读取文件

利用FIleInputStream和getClass可以实现覆盖默认配置文件： 可以把默认配置文件放到classpath中，然后，根据机器的环境编写另一个配置文件，覆盖某些默认的配置。

FileInputStream

props.load(new java.io.FileInputStream(f));

getClass()

Properties props = new Properties(); props.load(getClass().getResourceAsStream("/common/setting.properties"));

getProperty（）获取配置

classpath读取

Properties props = new Properties(); props.load(inputStreamFromClassPath("/default.properties")); props.load(inputStreamFromFile("./conf.properties"));

写入配置文件

Properties props = new Properties(); props.setProperty("url", "http://www.liaoxuefeng.com"); props.setProperty("language", "Java"); props.store(new FileOutputStream("C:\\conf\\setting.properties"), "这是写入的properties注释");

编码

inputstream是字节流，Reader是字符流，字符流在内存中以char类型表示，不涉及编码。

Set

方法

add

remove

contains

实现类

HashSet

覆写equals

覆写hascode

SortedSet

TreeSet

Queue

实现类

LinkedList

PriorityQueue

Comparable接口

public class Main { public static void main(String[] args) { Queue<User> q = new PriorityQueue<>(new UserComparator()); // 添加3个元素到队列: q.offer(new User("Bob", "A1")); q.offer(new User("Alice", "A2")); q.offer(new User("Boss", "V1")); System.out.println(q.poll()); // Boss/V1 System.out.println(q.poll()); // Bob/A1 System.out.println(q.poll()); // Alice/A2 System.out.println(q.poll()); // null,因为队列为空 } } class UserComparator implements Comparator<User> { public int compare(User u1, User u2) { if (u1.number.charAt(0) == u2.number.charAt(0)) { // 如果两人的号都是A开头或者都是V开头,比较号的大小: return u1.number.compareTo(u2.number); } if (u1.number.charAt(0) == 'V') { // u1的号码是V开头,优先级高: return -1; } else { return 1; } } } class User { public final String name; public final String number; public User(String name, String number) { this.name = name; this.number = number; } public String toString() { return name + "/" + number; } }

Deque接口

实现类

ArrayDeque

LinkedList

方法

First

Last

模拟stack

push

pop

peek

计算中缀表达式

编辑器将中缀表达式转化为后缀表达式

方法

size

add

offer

remove

poll

element

peek

Iterator

自定义集合实现迭代器

Iterable接口

iterator

要求返回iterator对象，即需要自定义iterator对象，该对象需要实现iterator接口

Iterator接口

hasNext

next

Collections

创建空集合

List<T> emptyList()

Map<K, V> emptyMap()

Set<T> emptySet()

创建单元素集合

List<T> singletonList(T o)

Map<K, V> singletonMap(K key, V value)

Set<T> singleton(T o)

排序

sort

洗牌

shuffle

将可变集合封装成不可变集合

public class Main { public static void main(String[] args) { List<String> mutable = new ArrayList<>(); mutable.add("apple"); mutable.add("pear"); // 变为不可变集合: List<String> immutable = Collections.unmodifiableList(mutable); // 立刻扔掉mutable的引用: mutable = null; System.out.println(immutable); } }

List<T> unmodifiableList(List<? extends T> list)

Set<T> unmodifiableSet(Set<? extends T> set)

Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m)

线程

List<T> synchronizedList(List<T> list)

Set<T> synchronizedSet(Set<T> s)

Map<K,V> synchronizedMap(Map<K,V> m)

IO

同步和异步

File对象

定义file

绝对路径

相对路径

获得路径

getPath

getAbsolutePath

getCanonicalPath

获得当前平台的系统分隔符

separator

判断存在

isFile

isDirectory

文件权限和大小

canRead()

canWrite()

canExecute()

length()

创建和删除文件

createNewFile

delete

createTempFile

deleteOnExit

创建和删除目录

mkdir

mkdirs

delete

遍历文件和目录

list

listFiles

FilenameFilter

accept

endWith

Path对象

get

toAbsolutePath

normalize

toFile

遍历

for (Path p : Paths.get("..").toAbsolutePath()) { // 可以直接遍历Path System.out.println(" " + p); }

序列化

定义

Serializable

空接口，又叫标记接口（Marker Interface）

ObjectOutputStream

public class Main { public static void main(String[] args) throws IOException { ByteArrayOutputStream buffer = new ByteArrayOutputStream(); try (ObjectOutputStream output = new ObjectOutputStream(buffer)) { // 写入int: output.writeInt(12345); // 写入String: output.writeUTF("Hello"); // 写入Object: output.writeObject(Double.valueOf(123.456)); } System.out.println(Arrays.toString(buffer.toByteArray())); } }

ObjectInputStream

try (ObjectInputStream input = new ObjectInputStream(...)) { int n = input.readInt(); String s = input.readUTF(); Double d = (Double) input.readObject(); }

ClassNotFoundException

InvalidClassException

serialVersionUID

字节流

Filter

┌─────────────┐ │ InputStream │ └─────────────┘ ▲ ▲ ┌────────────────────┐ │ │ ┌─────────────────┐ │ FileInputStream │─┤ └─│FilterInputStream│ └────────────────────┘ │ └─────────────────┘ ┌────────────────────┐ │ ▲ ┌───────────────────┐ │ByteArrayInputStream│─┤ ├─│BufferedInputStream│ └────────────────────┘ │ │ └───────────────────┘ ┌────────────────────┐ │ │ ┌───────────────────┐ │ ServletInputStream │─┘ ├─│ DataInputStream │ └────────────────────┘ │ └───────────────────┘ │ ┌───────────────────┐ └─│CheckedInputStream │ └───────────────────┘ ┌─────────────┐ │OutputStream │ └─────────────┘ ▲ ▲ ┌─────────────────────┐ │ │ ┌──────────────────┐ │ FileOutputStream │─┤ └─│FilterOutputStream│ └─────────────────────┘ │ └──────────────────┘ ┌─────────────────────┐ │ ▲ ┌────────────────────┐ │ByteArrayOutputStream│─┤ ├─│BufferedOutputStream│ └─────────────────────┘ │ │ └────────────────────┘ ┌─────────────────────┐ │ │ ┌────────────────────┐ │ ServletOutputStream │─┘ ├─│ DataOutputStream │ └─────────────────────┘ │ └────────────────────┘ │ ┌────────────────────┐ └─│CheckedOutputStream │ └────────────────────┘

InputStream

方法

read()

close()

try(resource)自动关闭

public void readFile() throws IOException { try (InputStream input = new FileInputStream("src/readme.txt")) { int n; while ((n = input.read()) != -1) { System.out.println(n); } } // 编译器在此自动为我们写入finally并调用close() }

AutoCloseable接口

缓冲

public void readFile() throws IOException { try (InputStream input = new FileInputStream("src/readme.txt")) { // 定义1000个字节大小的缓冲区: byte[] buffer = new byte[1000]; int n; while ((n = input.read(buffer)) != -1) { // 读取到缓冲区 System.out.println("read " + n + " bytes."); } } }

int read(byte[] b)

int read(byte[] b, int off, int len)

阻塞

实现类

FileInputStream

ByteArrayInputStream

模拟InputStream

public class Main { public static void main(String[] args) throws IOException { byte[] data = { 72, 101, 108, 108, 111, 33 }; try (InputStream input = new ByteArrayInputStream(data)) { int n; while ((n = input.read()) != -1) { System.out.println((char)n); } } } }

FilterInputStream

ZipInputStream

读取zip包

try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) { ZipEntry entry = null; while ((entry = zip.getNextEntry()) != null) { String name = entry.getName(); if (!entry.isDirectory()) { int n; while ((n = zip.read()) != -1) { ... } } } }

getNextEntry()

read()

ZipEntry

getName

isDirectory

写入zip包

try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) { File[] files = ... for (File file : files) { zip.putNextEntry(new ZipEntry(file.getName())); zip.write(getFileDataAsBytes(file)); zip.closeEntry(); } }

putNextEntry()

write()

close()

getResourceAsStream()

try (InputStream input = getClass().getResourceAsStream("/default.properties")) { if (input != null) { // TODO: } }

OutputStream

方法

write()

void write(byte[])

public void writeFile() throws IOException { try (OutputStream output = new FileOutputStream("out/readme.txt")) { output.write("Hello".getBytes("UTF-8")); // Hello } // 编译器在此自动为我们写入finally并调用close() }

close()

flush()

缓冲

阻塞

实现类

FileOutputStream

ByteArrayOutputStream

模拟OutputStream

public class Main { public static void main(String[] args) throws IOException { byte[] data; try (ByteArrayOutputStream output = new ByteArrayOutputStream()) { output.write("Hello ".getBytes("UTF-8")); output.write("world!".getBytes("UTF-8")); data = output.toByteArray(); } System.out.println(new String(data, "UTF-8")); } }

FileOutputStream

方法

print

println

System.out

System.err

字符流

Reader

方法

read()

子类

FileReader

public void readFile() throws IOException { // 创建一个FileReader对象: Reader reader = new FileReader("src/readme.txt"); // 字符编码是??? for (;;) { int n = reader.read(); // 反复调用read()方法，直到返回-1 if (n == -1) { break; } System.out.println((char)n); // 打印char } reader.close(); // 关闭流 }

指定编码

Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8);

缓冲区

public void readFile() throws IOException { try (Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8)) { char[] buffer = new char[1000]; int n; while ((n = reader.read(buffer)) != -1) { System.out.println("read " + n + " chars."); } } }

CharArrayReader

try (Reader reader = new CharArrayReader("Hello".toCharArray())) { }

StringReader

try (Reader reader = new StringReader("Hello")) { }

InputStreamReader

//将字节流转化为字符流 try (Reader reader = new InputStreamReader(new FileInputStream("src/readme.txt"), "UTF-8")) { // TODO: }

Writer

方法

void write(int c)

void write(char[] c)

void write(String s)

子类

FileWriter

try (Writer writer = new FileWriter("readme.txt", StandardCharsets.UTF_8)) { writer.write('H'); // 写入单个字符 writer.write("Hello".toCharArray()); // 写入char[] writer.write("Hello"); // 写入String }

CharArrayWriter

try (CharArrayWriter writer = new CharArrayWriter()) { writer.write(65); writer.write(66); writer.write(67); char[] data = writer.toCharArray(); // { 'A', 'B', 'C' } }

StringWriter

StringBuffer

PrintWriter

public class Main { public static void main(String[] args) { StringWriter buffer = new StringWriter(); try (PrintWriter pw = new PrintWriter(buffer)) { pw.println("Hello"); pw.println(12345); pw.println(true); } System.out.println(buffer.toString()); } }

OutputStreamWriter

try (Writer writer = new OutputStreamWriter(new FileOutputStream("readme.txt"), "UTF-8")) { // TODO: }

Files和Paths

方法

读取文件

readAllBytes

byte[] data = Files.readAllBytes(Paths.get("/path/to/file.txt"));

readString

// 默认使用UTF-8编码读取: String content1 = Files.readString(Paths.get("/path/to/file.txt")); // 可指定编码: String content2 = Files.readString(Paths.get("/path/to/file.txt"), StandardCharsets.ISO_8859_1);

readAllLines

// 按行读取并返回每行内容: List<String> lines = Files.readAllLines(Paths.get("/path/to/file.txt"));

写入文件

// 写入二进制文件: byte[] data = ... Files.write(Paths.get("/path/to/file.txt"), data); // 写入文本并指定编码: Files.writeString(Paths.get("/path/to/file.txt"), "文本内容...", StandardCharsets.ISO_8859_1); // 按行写入文本: List<String> lines = ... Files.write(Paths.get("/path/to/file.txt"), lines);

write

writeString

读写小文件

JavaEE

技术

JDBC

JNDI

EJB

Servlet

RMI

JSP

XML

JMS

JAVA IDL

JTS

JTA

JavaMail

JAF

框架

SSH

Structs

Spring

Hibernate

SSM

Spring

SpringMVC

MyBatis

spring

Spring Framework

模块

支持IoC和AOP的容器； 支持JDBC和ORM的数据访问模块； 支持声明式事务的模块； 支持基于Servlet的MVC开发； 支持基于Reactive的Web开发； 以及集成JMS、JavaMail、JMX、缓存等其他模块。

IoC容器（依赖注入）

作用

将组件的创建+配置与组件的使用相分离，并且，由IoC容器负责管理组件的生命周期。

注入方法

set（）

public class BookService { private DataSource dataSource; public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } }

构造方法

public class BookService { private DataSource dataSource; public BookService(DataSource dataSource) { this.dataSource = dataSource; } }

bean

装配bean

ApplicationContext

public class Main { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("application.xml"); UserService userService = context.getBean(UserService.class); User user = userService.login("[e-mail]", "password"); System.out.println(user.getName()); } }

BeanFactory

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("application.xml")); MailService mailService = factory.getBean(MailService.class);

二者区别

BeanFactory的实现是按需创建，即第一次获取Bean时才创建这个Bean，而ApplicationContext会一次性创建所有的Bean

方式

xml

读取xml文件后使用反射完成的 <beans> <bean id="dataSource" class="HikariDataSource" /> <bean id="bookService" class="BookService"> <property name="dataSource" ref="dataSource" /> </bean> <bean id="userService" class="UserService"> <property name="dataSource" ref="dataSource" /> </bean> </beans>

注入bean

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userService" class="com.itranswarp.learnjava.service.UserService"> <property name="mailService" ref="mailService" /> </bean> <bean id="mailService" class="com.itranswarp.learnjava.service.MailService" /> </beans>

注入数据类型

<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource"> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test" /> <property name="username" value="root" /> <property name="password" value="password" /> <property name="maximumPoolSize" value="10" /> <property name="autoCommit" value="true" /> </bean>

Annotation

@Component

@Autowired

@Configuration

@ComponentScan

定制bean

scope

我们每次调用getBean(Class)，容器都返回一个新的实例，这种Bean称为Prototype（原型），它的生命周期显然和Singleton不同。声明一个Prototype的Bean时，需要添加一个额外的@Scope注解 @Component @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // @Scope("prototype") public class MailSession { ... }

注入列表

@Order(1)

可选注入

@Autowired(required = false)

创建第三方类

Spring对标记为@Bean的方法只调用一次，因此返回的Bean仍然是单例。

初始化和销毁

@PostConstruct

调用构造方法创建MailService实例； 根据@Autowired进行注入； 调用标记有@PostConstruct的init()方法进行初始化。

@PreDestroy

指定别名

@Bean("name")

@Bean+@Qualifier("name")

@Primary

注入

@Autowired(required = false) @Qualifier("z") // 指定注入名称为"z"的ZoneId

工厂模式

@Component public class ZoneIdFactoryBean implements FactoryBean<ZoneId> { String zone = "Z"; @Override public ZoneId getObject() throws Exception { return ZoneId.of(zone); } @Override public Class<?> getObjectType() { return ZoneId.class; } }

getObject()

getObjectType()

Resource

@Value

@Component public class AppService { @Value("classpath:/logo.txt") private Resource resource; private String logo; @PostConstruct public void init() throws IOException { try (var reader = new BufferedReader( new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8))) { this.logo = reader.lines().collect(Collectors.joining("\n")); } } }

注入配置

方式

properties

@PropertySource("app.properties")

@Value("${app.zone:Z}")

"${app.zone}"表示读取key为app.zone的value，如果key不存在，启动将报错； "${app.zone:Z}"表示读取key为app.zone的value，但如果key不存在，就使用默认值Z。

javaBean持配置

JavaBean

@Component public class SmtpConfig { @Value("${smtp.host}") private String host; @Value("${smtp.port:25}") private int port; public String getHost() { return host; } public int getPort() { return port; } }

配置注入

@Component public class MailService { @Value("#{smtpConfig.host}") private String smtpHost; @Value("#{smtpConfig.port}") private int smtpPort; }

条件装配

@Profile

@Conditional

@Conditional(OnSmtpEnvCondition.class)

@ConditionalOnProperty(name="app.smtp", havingValue="true")

@ConditionalOnClass(name = "javax.mail.Transport")

AOP

访问数据库

JDBC

Spring Boot

Spring Cloud

JDBC

MySQL

安装配置

my.ini

[client] port=3306 default-character-set=utf8 [mysqld] basedir=D:\development\mysql-5.7.36-winx64\ datadir=D:\development\mysql-5.7.36-winx64\data\ port=3306 #最大连接数 max_connections=200 #编码 character-set-server=utf8 default-storage-engine=INNODB sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES [mysql] #编码 default-character-set=utf8

环境变量

管理员身份运行命令行

mysqld -install

mysqld --initialize

net start mysql

设置MySQL密码

net stop mysql

skip-grant-tables

net start mysql

mysql -u root -p

use mysql

update user set authentication_string=password("xxxxxx") where user="root";

手动停止MySQL服务

删除skip-grant-tables

net start mysql

mysql -u root -p

alter user user() identified by "xxxxxx";

检查编码

mysql> show variables like '%char%'; +--------------------------+--------------------------------------------------------+ | Variable_name | Value | +--------------------------+--------------------------------------------------------+ | character_set_client | utf8 | | character_set_connection | utf8 | | character_set_database | utf8 | | character_set_filesystem | binary | | character_set_results | utf8 | | character_set_server | utf8 | | character_set_system | utf8 | | character_sets_dir | /usr/local/mysql-5.1.65-osx10.6-x86_64/share/charsets/ | +--------------------------+--------------------------------------------------------+ 8 rows in set (0.00 sec)

JDBC驱动

结构图

┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ │ ┌───────────────┐ │ │ Java App │ │ └───────────────┘ │ │ │ ▼ │ ┌───────────────┐ │ │JDBC Interface │<─┼─── JDK └───────────────┘ │ │ │ ▼ │ ┌───────────────┐ │ │ JDBC Driver │<───── Vendor │ └───────────────┘ │ │ └ ─ ─ ─ ─ ─│─ ─ ─ ─ ─ ┘ ▼ ┌───────────────┐ │ Database │ └───────────────┘

添加maven依赖

<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> <scope>runtime</scope> </dependency>

数据类型



JDBC连接

Connection

URL

mysql

jdbc:mysql://<hostname>:<port>/<db>?key1=value1&key2=value2 jdbc:mysql://localhost:3306/learnjdbc?useSSL=false&characterEncoding=utf8

用户名

口令

获得连接

// JDBC连接的URL, 不同数据库有不同的格式: String JDBC_URL = "jdbc:mysql://localhost:3306/test"; String JDBC_USER = "root"; String JDBC_PASSWORD = "password"; // 获取连接: Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD); // TODO: 访问数据库... // 关闭连接: conn.close();

Connection

close

DriverManager

getConnection

CRUD

SQL注入

PreparedStatement

User login(String name, String pass) { ... String sql = "SELECT * FROM user WHERE login=? AND pass=?"; PreparedStatement ps = conn.prepareStatement(sql); ps.setObject(1, name); ps.setObject(2, pass); ... }

setObject

JDBC查询

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) { try (Statement stmt = conn.createStatement()) { try (ResultSet rs = stmt.executeQuery("SELECT id, grade, name, gender FROM students WHERE gender=1")) { while (rs.next()) { long id = rs.getLong(1); // 注意：索引从1开始 long grade = rs.getLong(2); String name = rs.getString(3); int gender = rs.getInt(4); } } } }

Connection

createStatement

Statement

executeQuery

ResultSet

getInt

getString

getLong

JDBC插入

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) { try (PreparedStatement ps = conn.prepareStatement( "INSERT INTO students (id, grade, name, gender) VALUES (?,?,?,?)")) { ps.setObject(1, 999); // 注意：索引从1开始 ps.setObject(2, 1); // grade ps.setObject(3, "Bob"); // name ps.setObject(4, "M"); // gender int n = ps.executeUpdate(); // 1 } }

获取自增主键

Statement.RETURN_GENERATED_KEYS

getGeneratedKeys

JDBC更新

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) { try (PreparedStatement ps = conn.prepareStatement("UPDATE students SET name=? WHERE id=?")) { ps.setObject(1, "Bob"); // 注意：索引从1开始 ps.setObject(2, 999); int n = ps.executeUpdate(); // 返回更新的行数 } }

JDBC删除

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) { try (PreparedStatement ps = conn.prepareStatement("DELETE FROM students WHERE id=?")) { ps.setObject(1, 999); // 注意：索引从1开始 int n = ps.executeUpdate(); // 删除的行数 } }

JDBC事务

ACID特性

原子性

一致性

隔离性

Read Uncommitted

Read Committed

Repeatable Read

Serilizable

持久性

Connection

setTransactionIsolation

REPEATABLE READ

MYSQL默认隔离级别

setAutoCommit

true

false

commit

rollback

close

JDBC Batch

try (PreparedStatement ps = conn.prepareStatement("INSERT INTO students (name, gender, grade, score) VALUES (?, ?, ?, ?)")) { // 对同一个PreparedStatement反复设置参数并调用addBatch(): for (Student s : students) { ps.setString(1, s.name); ps.setBoolean(2, s.gender); ps.setInt(3, s.grade); ps.setInt(4, s.score); ps.addBatch(); // 添加到batch } // 执行batch: int[] ns = ps.executeBatch(); for (int n : ns) { System.out.println(n + " inserted."); // batch中每个SQL执行的结果数量 } }

addBatch

excuteBatch

JDBC 连接池

连接池的实现

HikariCP

依赖

<dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> <version>2.7.1</version> </dependency>

DataSource

创建DataSource实例

HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://localhost:3306/test"); config.setUsername("root"); config.setPassword("password"); config.addDataSourceProperty("connectionTimeout", "1000"); // 连接超时：1秒 config.addDataSourceProperty("idleTimeout", "60000"); // 空闲超时：60秒 config.addDataSourceProperty("maximumPoolSize", "10"); // 最大连接数：10 DataSource ds = new HikariDataSource(config);

getConnection

C3P0

BoneCP

Druid

XML与JSON

XML

结构

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE note SYSTEM "book.dtd"> <book id="1"> <name>Java核心技术</name> <author>Cay S. Horstmann</author> <isbn lang="CN">1234567</isbn> <tags> <tag>Java</tag> <tag>Network</tag> </tags> <pubDate/> </book>

转义



支持技术

DTD和XSD

Namespace

XSLT

XPath

解析API

DOM

InputStream input = Main.class.getResourceAsStream("/book.xml"); DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.parse(input);

DocumentBuilderFactory

newInstance

newDocumentBuilder

DocumentBuilder

parse

接收InputStream，File或者URL

Document

遍历

void printNode(Node n, int indent) { for (int i = 0; i < indent; i++) { System.out.print(' '); } switch (n.getNodeType()) { case Node.DOCUMENT_NODE: // Document节点 System.out.println("Document: " + n.getNodeName()); break; case Node.ELEMENT_NODE: // 元素节点 System.out.println("Element: " + n.getNodeName()); break; case Node.TEXT_NODE: // 文本 System.out.println("Text: " + n.getNodeName() + " = " + n.getNodeValue()); break; case Node.ATTRIBUTE_NODE: // 属性 System.out.println("Attr: " + n.getNodeName() + " = " + n.getNodeValue()); break; default: // 其他 System.out.println("NodeType: " + n.getNodeType() + ", NodeName: " + n.getNodeName()); } for (Node child = n.getFirstChild(); child != null; child = child.getNextSibling()) { printNode(child, indent + 1); } }

SAX

InputStream input = Main.class.getResourceAsStream("/book.xml"); SAXParserFactory spf = SAXParserFactory.newInstance(); SAXParser saxParser = spf.newSAXParser(); saxParser.parse(input, new MyHandler());

SAXParserFactory

newInstance

newSAXParser

SAXParser

DafaultHandler

class MyHandler extends DefaultHandler { public void startDocument() throws SAXException { print("start document"); } public void endDocument() throws SAXException { print("end document"); } public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { print("start element:", localName, qName); } public void endElement(String uri, String localName, String qName) throws SAXException { print("end element:", localName, qName); } public void characters(char[] ch, int start, int length) throws SAXException { print("characters:", new String(ch, start, length)); } public void error(SAXParseException e) throws SAXException { print("error:", e); } void print(Object... objs) { for (Object obj : objs) { System.out.print(obj); System.out.print(" "); } System.out.println(); } }

Jackson

maven依赖

com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.10.1 org.codehaus.woodstox:woodstox-core-asl:4.4.1

JacksonXmlModule

XmlMapper

readValue

Book(自定以JavaBean）

JSON

优点

UTF-8编码

双引号为key，\转义

浏览器内置JSON支持

层次结构

键值对

数组

字符串

数值

布尔值

空值

解析

Jackson

InputStream input = Main.class.getResourceAsStream("/book.json"); ObjectMapper mapper = new ObjectMapper(); // 反序列化时忽略不存在的JavaBean属性: mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); Book book = mapper.readValue(input, Book.class); String json = mapper.writeValueAsString(book);

maven依赖

com.fasterxml.jackson.core:jackson-databind:2.12.0

ObjectMapper

configure

readValue

writeValueAsString

解析为特定的Java对象

maven依赖

com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.12.0

JavaTimeModule()

ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule());

自定义解析

JsonDeserializer

public class IsbnDeserializer extends JsonDeserializer<BigInteger> { public BigInteger deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { // 读取原始的JSON字符串内容: String s = p.getValueAsString(); if (s != null) { try { return new BigInteger(s.replace("-", "")); } catch (NumberFormatException e) { throw new JsonParseException(p, s, e); } } return null; } }

注解

public class Book { public String name; // 表示反序列化isbn时使用自定义的IsbnDeserializer: @JsonDeserialize(using = IsbnDeserializer.class) public BigInteger isbn; }

反序列化

网络编程

IP地址

IPV4

IPV6

公网IP地址

内网IP地址

127.0.0.1

网关

路由

域名

nslookup

localhost

网卡

配置

IPV4地址

IPV4子网掩码

IPV4默认网关

OSI网络模型

应用层

表示层

会话层

传输层

网络层

链路层

物理层

TCP/IP模型

常用协议

IP协议

分组交换

TCP协议

面向连接

可靠传输

UDP协议

无连接

不可靠传输

socket

IP地址

端口号

0~65535 特权端口：1024以下 普通端口：1024以上

TCP编程

服务器端

步骤

指定端口监听

返回socket实例

多线程

ServerSocket

accept

Socket

getRemoteSocketAddress

客户端

步骤

连接服务器端并指定接口

socket流

flush

Socket

getInputStream

getOutputStream

UDP编程

服务器端

DatagramSocket

receive

send

DatagramPacket

getData

getOffset

getLength

setData

客户端

DatagramSocket

setSoTimeout

connect

send

receive

disconnect

DatagramPacket

getData

getOffset

getLength

Email

MUA

MTA

MDA

POP3协议

IMAP协议

发送Email

准备SMTP登录信息

MTA邮件服务器地址和端口号

用户名

登录口令

导入依赖

<dependency> <groupId>javax.mail</groupId> <artifactId>javax.mail-api</artifactId> <version>1.6.2</version> </dependency> <dependency> <groupId>com.sun.mail</groupId> <artifactId>javax.mail</artifactId> <version>1.6.2</version> </dependency>

JavaMail API连接到SMTP服务器

// 服务器地址: String smtp = "smtp.office365.com"; // 登录用户名: String username = "[e-mail]"; // 登录口令: String password = "********"; // 连接到SMTP服务器587端口: Properties props = new Properties(); props.put("mail.smtp.host", smtp); // SMTP主机名 props.put("mail.smtp.port", "587"); // 主机端口号 props.put("mail.smtp.auth", "true"); // 是否需要用户认证 props.put("mail.smtp.starttls.enable", "true"); // 启用TLS加密 // 获取Session实例: Session session = Session.getInstance(props, new Authenticator() { protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication(username, password); } }); // 设置debug模式便于调试: session.setDebug(true);

发送邮件

MimeMessage

setFrom

setRecipient

setSubject

setText

Transport

send

发送html邮件

setTerxt

发送附件

Multipart multipart = new MimeMultipart(); // 添加text: BodyPart textpart = new MimeBodyPart(); textpart.setContent(body, "text/html;charset=utf-8"); multipart.addBodyPart(textpart); // 添加image: BodyPart imagepart = new MimeBodyPart(); imagepart.setFileName(fileName); imagepart.setDataHandler(new DataHandler(new ByteArrayDataSource(input, "application/octet-stream"))); multipart.addBodyPart(imagepart); // 设置邮件内容为multipart: message.setContent(multipart);

Multipart

addBodyPart

BodyPart

setContent

添加纯文本

添加html文本

附件

setFileName

setDataHandler

发送内嵌图片的html邮件

setHeader

Multipart multipart = new MimeMultipart(); // 添加text: BodyPart textpart = new MimeBodyPart(); textpart.setContent("<h1>Hello</h1><p><img src=\"cid:img01\"></p>", "text/html;charset=utf-8"); multipart.addBodyPart(textpart); // 添加image: BodyPart imagepart = new MimeBodyPart(); imagepart.setFileName(fileName); imagepart.setDataHandler(new DataHandler(new ByteArrayDataSource(input, "image/jpeg"))); // 与HTML的<img src="cid:img01">关联: imagepart.setHeader("Content-ID", "<img01>"); multipart.addBodyPart(imagepart);

常见问题

535登陆失败

554拒绝发送错误

554被识别为垃圾邮件

接受Email

准备登录信息

启动SSL

连接到Store

获取收件箱

获取Message对象

递归解析获取邮件正文

关闭Folder和Store

HTTP编程

HTTP请求

HTTP Header

Host

User-Agent

Accept

Accept-Language

HTTP Body

GET请求

Header

POST请求

Header

Body

Content-Type

Content-Length

HTTP响应

响应代码： 1xx：表示一个提示性响应，例如101表示将切换协议，常见于WebSocket连接； 2xx：表示一个成功的响应，例如200表示成功，206表示只发送了部分内容； 3xx：表示一个重定向的响应，例如301表示永久重定向，303表示客户端应该按指定路径重新发送请求； 4xx：表示一个因为客户端问题导致的错误响应，例如400表示因为Content-Type等各种原因导致的无效请求，404表示指定的路径不存在； 5xx：表示一个因为服务器问题导致的错误响应，例如500表示服务器内部故障，503表示服务器暂时无法响应。

编程

HttpClient

JAVA11

newBuilder

send

HttpRequest

newBuilder

header

timeout

version

POST

build

HttpReponse

BodyHandlers

ofString

ofByteArray

ofInputStream

body

RMI远程调用

┌ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ┌─────────────┐ ┌─────────────┐ │ │ Service │ │ │ │ Service │ │ └─────────────┘ └─────────────┘ │ ▲ │ │ ▲ │ │ │ │ │ │ │ │ │ ┌─────────────┐ Network ┌───────────────┐ ┌─────────────┐ │ │ Client Stub ├─┼─────────┼>│Server Skeleton│──>│Service Impl │ │ └─────────────┘ └───────────────┘ └─────────────┘ └ ─ ─ ─ ─ ─ ─ ─ ─ ┘ └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘

服务器端(skeleton)

WorldClock

UnicastRemoteObject.exportObject(worldClock, 0

Registry

rebind

LocateRegistry

createRegistry

客户端(stub)

WorldClock

Registry

lookup

LocateRegistry

getRegistry

LocalDateTime

MAVEN

构成

groupId

artifactId

version

依赖管理

依赖关系

compile

test

junit

runtime

mysql

provided

唯一ID

MAVEN镜像仓库

<settings> <mirrors> <mirror> <id>aliyun</id> <name>aliyun</name> <mirrorOf>central</mirrorOf> <!-- 国内推荐阿里云的Maven镜像 --> <url>https://maven.aliyun.com/repository/central</url> </mirror> </mirrors> </settings>

搜索第三方组件

search.maven.org

编译jar包

mvn clean package

构建流程

lifecycle

phase

常用phase

clean

compile

test

package

goal

自定义插件

<project> ... <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.2.1</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> ... </configuration> </execution> </executions> </plugin> </plugins> </build> </project>

插件配置

<configuration> <transformers> <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> <mainClass>com.itranswarp.learnjava.Main</mainClass> </transformer> </transformers> </configuration>

模块管理

模块继承

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.itranswarp.learnjava</groupId> <artifactId>parent</artifactId> <version>1.0</version> <relativePath>../parent/pom.xml</relativePath> </parent> <artifactId>module-a</artifactId> <packaging>jar</packaging> <name>module-a</name> </project>

模块依赖

<dependencies> <dependency> <groupId>com.itranswarp.learnjava</groupId> <artifactId>module-b</artifactId> <version>1.0</version> </dependency> </dependencies>

仓库

中央仓库

私有仓库

本地仓库

mvnw

安装

mvn -N io.takari:maven:0.7.6:wrapper -Dmaven=3.3.3

发布artifact

以静态文件发布

创建maven工程目录

how-to-become-rich ├── maven-repo <-- Maven本地文件仓库 ├── pom.xml <-- 项目文件 ├── src │ ├── main │ │ ├── java <-- 源码目录 │ │ └── resources <-- 资源目录 │ └── test │ ├── java <-- 测试源码目录 │ └── resources <-- 测试资源目录 └── target <-- 编译输出目录

pom

<project ...> ... <distributionManagement> <repository> <id>local-repo-release</id> <name>GitHub Release</name> <url>file://${project.basedir}/maven-repo</url> </repository> </distributionManagement> <build> <plugins> <plugin> <artifactId>maven-source-plugin</artifactId> <executions> <execution> <id>attach-sources</id> <phase>package</phase> <goals> <goal>jar-no-fork</goal> </goals> </execution> </executions> </plugin> <plugin> <artifactId>maven-javadoc-plugin</artifactId> <executions> <execution> <id>attach-javadocs</id> <phase>package</phase> <goals> <goal>jar</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>

mvn clean package deploy

推到github

使用

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>example</groupId> <artifactId>how-to-become-rich-usage</artifactId> <version>1.0-SNAPSHOT</version> <packaging>jar</packaging> <properties> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <java.version>11</java.version> </properties> <repositories> <repository> <id>github-rich-repo</id> <name>The Maven Repository on Github</name> <url>https://michaelliao.github.io/how-to-become-rich/maven-repo/</url> </repository> </repositories> <dependencies> <dependency> <groupId>com.itranswarp.rich</groupId> <artifactId>how-to-become-rich</artifactId> <version>1.0.0</version> </dependency> </dependencies> </project>

以Nexus发布到仓库

注册账号

central.sonatype.org 1. 在Publish Your Project下方点击“Learn how »” 2. 找到Provide project details，点击Provide 3. 在Error页面点击“sign up”注册

正确创建GPG签名

setting.xml

用户名

口令

GPG口令

添加OSS的Maven repo地址

mvn clean package deploy

发布到私有仓库