目录

java水平提升记录

以下是我不熟的

  1. try with resource:

    • 语法格式：try( Scanner scanner=new Scanner){ // scan } finally {scanner.close();}
      • 不写catch。 编译器会自动在finally里面加 变量.close()
      • 语法糖
    • 需要对象本身实现了 java.lang.AutoCloseable
    • 优点： 比使用finalize 回收对象更可控

  2. 构造函数赋值： 使用双花括号可以实现类似 with的效果，不用写 this.

    • 语法格式： Person = new Person(){{ name = 'abc'; age=11;}}
    • 用途： 针对没有相应构造函数，但是又要赋值的情况。

  3. 内部类：

    • 定义和声明：把一个类的声明 class InnerExample 放到另外一个类里面
      • 编译器会生成 xxx$xxx 这样的class文件
      • 内部类不能和外部类重名
    • 使用：
      • 在封装内部类的内部使用跟其他普通类没差别
      • 在其他地方使用：
        • 类名前要冠以外部类的名字
        • 在用new创建内部类的时候，也要在new 前面冠以对象变量： 外部对象名.new 内部类名(参数)
    • 注意：
      • 内部类可以访问外部类的字段和方法，即使private的也可以
      • 当内部类中有和外部类同名的字段或方法，可以用 外部类名.this.字段及方法
      • 内部类可以用public protected,private 修饰符，外部类只能用public或者默认
      • 内部类可以用 final, abstract 修饰符
      • 用static修饰符定义内部类的时候，它实际被声明成为了外部类（有人认为这是嵌套类）
      • 当使用static类的时候：
        • 实例化的时候，new签名不需要对象实例变量（因为static跟实例无关）
        • static类中不能访问其外部类的非static字段和方法，只能访问static成员
        • static方法中不能访问非static的域及方法，也不能不带前缀地new 一个非static的内部类

  4. 局部类（在方法里面定义的类 local class）

    • 注意：
      • 不能用public private protected static修饰
      • 可以用final 或者abstract修饰
      • 可以访问其外部类的成衣
      • 不能访问局部变量，除非它是final的

  5. 匿名类： 一种特殊的内部类(anonymous class)

    • 定义：
      • 定义和创建同时使用和完成，类的定义前面有一个new
        • new 类名 或接口名 (){......}
        • 不使用关键字class，也不使用extends 及 implements
      • 不取名字，直接用其父类或接口的名字，该类是父类的子类，或者实现了一个接口
      • 编译器生成 xxxxx$1 之类的名字
      • 在构造对象的时候使用父类构造方法
    • 典型应用：
      1. 界面的事件处理：
        1. uiObj.addActionListener(someAction)
        2. uiObj.addActionListener(new ActionListener(){ public void actionPerformed(Event e){ /事件处理代码/ } });
      2. 作为方法的参数：eg排序，实现一个比较大小的接口
        1. Arrays.sort(books, new Comparator(){ public int compare(Book b1, Book b2){ return b1.price - b2.price; } });
    • 类似闭包

  6. Lambda表达式：

    • 信息：Lambda expression.
      • 大体上相当于其他语言的"匿名函数" 或 "函数指针"
      • java中他实际上是"匿名类的一个实例"
    • 写法： (参数)->结果
    • eg:
      • (String s) -> s.length()
      • () -> { System.out.println("abc"); }
      • x -> x*x
      • 求积分例子: double d = Integra( x-> Math.sin(x), 0, Math.PI, 1e-5);
    • 意义：
      • Lambda表达式大大简化了书写：线程，积分函数，按钮事件处理 等等
    • 限制：
      • 能写成 Lambda表达式的接口 要求 **包含且最多只能有一个 ** 抽象函数，
      • 这样的接口可以(但不强制)用注记：
    • 总结：
      • Lambda表达式 是 接口 或者 接口函数的简写

  7. 高级语法：装箱，枚举，注解

    • 信息：从JDK 1.5开始增加的一些新的语法糖
      • 基本类型的包装类：将基本类型(Primitive type )包装成 Object(引用类型)
      • 共8类：Boolean, Byte, Short, Character, Integer, Long, Float, Double
    1. 装箱(Boxing)和拆箱(Unboxing)
      • 把基本类型直接赋值给引用类型 Integer I = 10; int i=I;
        • 翻译为： Integer I = Integer.valueOf(10); Object [] ary = {1, "aaa};
    2. 枚举(enum) 是一种特殊的class类型
      • 写法： enum Lignt {Red, Yellow, Green}; , Light light = Light.Red;
      • 实际上生成了： class Light extends java.lang.Enum
      • 可以在enum定义体重，添加 字段，方法，构造方法
    3. 注解(annotation) 注记，标记，标注，用于在各种语法要素删加上附加信息，供编译器和其他程序使用

  8. java语言的"指针"：引用与指针：

    • 信息：
      1. 引用(reference)实质上就是指针(point)
      2. 引用是受控的，安全的：
        1. 会检查空指针
        2. 没有指针运算 *(p+5)
        3. 不能访问没有引用到的内存
        4. 自动回收垃圾
    • 变通： 数组，指向节点，JNI
    • 判断是否相等：
      • 简单来说： 基本类型：比较值相等 引用类型：引用相等
      • 具体判断：
        • 数值类型：转换后比较
        • 浮点数：最好不直接用 ==， 判断差的绝对值是否很小
        • Double.NAN == Double.NAN 结果是false， 见文档
        • boolean 和int无法比较
        • 枚举类型：可以直接比较，因为内部进行了唯一实例化
        • 引用对象：
          • 直接比较连个引用是否一样
          • 如果要判断内容是否一样，要重写 equals() 方法
          • 如果重写equals方法，最好也重写 hashCode() 方法
        • String 相等：
          • 判断的时候一定不要用 ==，要用equals
          • 但是，字符串常量(string literal)和字符串常量会进行内部化( interned)，相同的字符串常量是相等的

  9. java的异常：

    • 分为两种： 运行时异常(及其子类)， 受检异常
      • 运行时异常(及其子类)可以不明确处理
      • 受检异常，必须明确进行语法处理，要么捕获 catch，要么抛出 throws
    • 子类如果覆盖了父类的一个方法，子类可以抛出子类异常(更具体的异常)，但是不能抛出更一般的异常
    • 自定义异常：
      • 继承自 Exception 或者 某个Exception的子类
      • 异常的链接：
        • 处理异常以后如果需要再次抛出，可以抛出当前异常，可以抛出另一个异常，也可以抛出一个新异常，并把当前异常的cause()作为内部异常一起抛出

  10. 断言和测试：

    1. 断言： assertion
      • 格式： assert 表达式; 或者 assert 表达式:信息;
    2. 测试： JUnit

  11. Java的错误 Error：

    1. 分类: 语法错误(Syntax error), 运行错误(Runtime error), 逻辑错误(Logic error)

  12. 集合，排序：

    1. list和set的区别
      1. List: (Collection的子接口)记录元素的保存顺序， 且允许有重复元素
      2. Set: (Collection的子接口) 不记录元素的保存顺序，且不允许有重复元素

  13. 多线程：

    1. 实现方法：
      1. extends Thread
      2. implements Runnable
      3. 用匿名类， new Thread(){ public void run(){ /* 内容*/ } }
      4. 用lambda表达式, new Thread( ()->{ /* 内容*/ } ).start();
    2. 对线程的控制
      1. 启动: .start()
      2. 结束: . 设定标记变量
      3. 阻止执行
      4. 设定优先级：
    3. 线程类型：
      1. 普通线程(非 deamon线程): 如果一个java程序中还存在deamon线程，程序就不会结束
      2. daemon线程（守护线程，后台线程）： 不阻止程序结束
        1. setDaemon(true);
    4. 线程的同步：
      1. 原因： 线程的不确定性： eg: cnt++ 的例子
      2. 概念： 互斥锁：
      3. 用法: synchronized(代码片段) synchronized 方法
        1. 使用 wait() 方法可以释放对象锁
        2. 使用 notify() 或 notifyAll() 可以让等待的一个或所有线程进入就绪状态
      4. 在Java中可以讲wait和notify放在synchronized里面，因为java是这样处理的：
        • 在 synchronized代码执行期间，线程调用对象的wait()方法，会释放对象锁标志，然后进入等待状态，然后由其他线程调用notify()或者notifyAll()方法通知正在等待的线程
      5. 为了避免问题，方便使用，JDK1.5中增加了更多的类，以便更灵活的使用锁机制
        1. java.util.concurrent.locks 包
        2. Lock接口， ReentrantLock 类 ： lock() tryLock() unlock()
        3. ReadWriteLock接口， ReentrantReadWriteLock类 .writeLock().lock() .readLock().unlock()

  14. 并发API

    1. 来自： java.util.concurrent包及子包
      • 从JDK1.5开始，提供了一系列的工具，更好更方便地使用线程
      • 实用类： 单变量， 集合， Timer， 线程池
      • 集合与线程：
        • ArrayList/ HashMap是线程不安全的 ----> Vector 和HashTable是线程安全的
        • 产生一个线程安全的集合对象 Collections.synchronizedArrayList(list) // 相对安全一些
      • 方便使用的线程安全类：
        • CopyOnWriteArrayList CopyOnWriteArraySet 适用于很少写入而读取频繁的对象
        • ConcurrentHashMap : putIfAbsent(), remove(), replace()
        • ArrayBlockingQueue: 生产者与消费者， 使用put()及 take()
    2. 原子类型(线程安全) java.util.concurrent.atomic
    3. 线程池：
      1. 相关类： ExecutorService接口， ThreadPoolExecutor 类， Executors工具类
      2. 常见用法： ExecutorService pool = Executors.newCachedThreadPool(); 使用其 execute(Runnable r)方法
    4. Timer 计时器： java.util.Timer 重复某件事， javax.swing.Timer类 重复执行 ActionListener
      1. 特别注意： 在线程中更新图形化界面，要调用 SwingUtilites.invokeLater

  15. 流式操作和并行流： 流式操作 ≈ 流水线操作， 函数式风格的操作

    1. 类似 js的 underscore / lodash
    2. 流操作分成两类：
      1. 中间的： 保持流打开状态，并允许后续操作: filter, sorted, limit, map
      2. 末端的： 必须是对流的最终操作： max, min, count, forEach, findAny
    3. 步骤：获取流，中间操作，末端操作
      1. 数组： Arrays.stream(ary)
      2. Collection(包括List) list.stream()
      3. Map： 没有流，但是有类似方法： map.putIfAbsent map.computeIfPresent map.merge
      4. Stream的子接口： DoubleStream, IntStream, LongStream, Stream
      5. 并行计算： 只需要把 .stream() 换成 .parallelStream() 其他都不变，就可以实现并行计算

  16. 输入输出：

    1. 信息：java.io/ java.nio / java.nio2 文件流，内存流，网络流， 字符流/字符流， 节点流/处理流(过滤流)

      • 输入： 字节流： InputStream 字符流： Reader
      • 输出： 字节流： OutputStream 字符流： Writer

    2. 常用类：

      1. InputStream 类 read()方法， 逐字节地以二进制原始方式读入数据
      2. OutputStream 类 write()方法，
      3. Reader 类
      4. Writer 类
      5. java.util.Scanner 类：(JDK1.5+)
      6. java.nio.file.Files -> readAllLines() 方法

    3. 常见节点流：

    4. 概念：

      1. 流的包装(链接)：一个流对象经过其他流的多次包装，称为流的链接。
        • 处理流的构造方法总是要带一个其他的流对象作为参数
        • eg. BufferedReader in2 = new BufferedReader( newInputStreamReader( new FileInputStream(file), "utf-8"));
          • 从字节的 FileInputStream包装成 字符的 InputStreamReader，最后包装成BufferedReader以后，我们就可以执行 in2.readLine();
      2. 获取字符集： Charset.forName("utf8")

    5. 对象的读写： 序列号与反序列化

      1. 使用的类：
        1. 对象: ObjectInputStream, ObjectOutputStream
        2. 基本数据: DataInputStream, DataOutputStream
      2. 必须实现 Serializable 接口，才能实现序列化与反序列化:
        1. 该接口没有方法，只是一个标记

  17. 网络流

    1. 概念
    2. 常用类： URL,

  18. 文件流：

    1. 概念
    2. 常用类： File( 目录也当成File处理), RandomAccessFile

  19. 正则表达式：

    1. 概念： 用于匹配字符串的一种模式 字符{数量}位置
    2. 写法：
    3. 常用类： java.util.regex 模式类 Pattern 匹配类 Matcher, Pattern.matches(pattern, variable)
      • Matcher类的方法：
        • find方法扫描输入序列，寻找下一个与Pattern匹配的地方
        • appendReplacement方法
      • Matcher中的group (分组)
        • group(分组)，是指正则表达式中一对圆括号括起来的一部分
        • group(0)或 group()表示整个匹配项， group(1), group(2) 表示各个分组，
        • 替换时， $0 表示整个匹配项，$1, $2 … 表示各个分组(圆括号)

  20. 图形用户界面组件及分类：

    1. 概念：
      • AWT: Abstract Window Toolkit
      • Swing: JDK 1.2以后引入的，功能更强，界面更丰富，轻量级，各种平台上更统一
      • 组件：
        • 容器组件， 非容器组件
        • 容器： 顶层容器(JFrame, JDialog, JApplet )，非顶层容器
        • JComponent: 非顶层容器
      • 实现图形三个步骤： 组件Component，布局 Layout，事件 Event,
    2. 常用类：
      • java.awt 包
        • Frame, Buttom, Label, TextField, TextArea, Panel
      • javax.swing 包
        • JFrame, JButton, Jlabel, Jtextfield, JtextArea, JPanel
    3. 写法：
    4. 事件处理：
    5. 常用组件：
      1. JOptionPane: 约等于 dialog

  21. 网络编程：

    1. 概念：
      1. Socket/ ServerSocket： 客户端和服务端相连的方式
    2. 常用类：
      1. java.net.URL
      2. Appache的 httpclient (外部引用)
    3. 写法：

  22. 多媒体编程：

    1. 概念：
      1. Java Media API
      2. JAI : Java Advanced Imaging
      3. Java 3D
      4. JMF : Java Media Framework
    2. 常用类：
      1. 组件的 get Graphics()
      2. Canvas 及 JComponent 对象 -> Canvas的 paint() JComponent 的 paintComponent(Graphics g)
      3. JPanel -> setDoubleBuffered(true) 画图时间长的情况下，使用双缓存，避免闪烁
      4. Graphics.drawImage() 显示图像
      5. javax.imageio.ImageIO.read( new File() ) 载入图片
      6. BufferedImage 类 后台画图 getGraphics()
      7. ImageIO read() write()
    3. 写法：

  23. 数据库编程：

    1. 概念：
      1. JDBC: Java Database Connectivity. Java8 开始不再支持 ODBC
    2. 常用类：
      1. Connection 连接
      2. Statement 语句
      3. ResultSet 结果集 next() 遍历所有结果
      4. PreparedStatement 经过编译的语句 （多次执行相同语句速度略快， 可以方便地加参数, 避免SQL注入攻击 ）
      5. swing.JTable 用于显示的数据表
    3. 写法：
      1. 加载驱动程序 Class.forName("org.sqlite.JDBC");
      2. 得到连接： String connString = "jdbc:sqlite:d:test.db"; Connection conn = DriverManager.getConnection(connString);
      3. 得到 Statement对象 stmt = con.createStatement();
      4. 执行非查询： stmt.executeUpdate("delete from TestTable");
      5. 查询得到数据集： rs = stmt.executeQuery("SELECT * from DemoTable ORDER BY id");

  24. 设计模式：

    1. 分类：
      • Creational Patterns
      • Structural Patterns
      • Behavioral Patterns
    2. GoF 原则：
      1. 单一职责原则
      2. 开放封闭原则
      3. 替换原则
      4. 依赖倒置原则： 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不一定改依赖于实现细节，实现细节应该依赖于抽象
      5. 接口隔离原则： 客户端不应该依赖它不需要的接口； 一个类对另一个类的依赖应该建立在最小的接口上
    3. GRASP 原则； General Responsibility Assignment Software Pattern
      1. Information Expert (信息专家)
      2. Creator (创造者)
      3. Low Coupling (低耦合)
      4. High Cohesion (高内聚)
      5. Controller (控制器)
      6. Polymorphism (多态)
      7. Pure Fabrication (纯虚构)
      8. Indirection (间接)
      9. Protected Variations (受保护变化)
    4. 常见：
      1. 工厂模式，抽象工厂模式： 隔离内部实现细节
      2. 适配器模式：把一个接口或是类变成另一种，是不兼容的接口兼容
      3. 组合模式 Composite: 一致性地对待组合对象和独立对象，让使用者把单独的对象和组合对象混用
      4. 装饰器模式 Decorator： 为类添加新功能，防止类继承带来的爆炸式增长，为一个对象动态的加上一系列动作，而不需要因为这些动作的不同而产生大量的继承类
      5. 观察者模式 Observer： 隔离事件的发布者和处理者

  25. 反射：

    1. 概念： reflection: 在运行状态中对于任何一个类都能够知道这个类的所有属性和方法，对于任何一个对象，都能够调用它的任何一个方法和属性
      • 在一些框架性的程序中，反射是相当重要的：eg： plugin
      • 跟PHP反射一个样
    2. 常用类：
      • java.lang.reflect.*:
    3. 用法：
      1. 得到Class对象的3种方法：
        1. 类名.class： Class<?> clss = String.class;
        2. 对象.getClass() String str = "abc"; Class<?> cls = str.getClass();
        3. Class.forName(类的全名) Class<?> cls = Class.forName("java.lang.String");
      2. 动态创建对象，调用相关方法
    4. Annotation 注记：添加一些信息，在编译中或者在框架中使用
      1. 自定义注记：
        1. 定义：
          • 使用 @interface 来定义一个类型，表示它是一个注记
          • 使用 方法名() 来表示它的一个属性 (值或数组)， 其中 value() 是默认属性，default 表示默认值

以下都是正确的说法

  1. 父类的非私有方法可以被子类自动继承。
  2. 字段变量可以自动赋初值。
  3. 多态是指一个程序中相同的名字表示不同的含义的情况。
  4. 系统在回收垃圾时会自动调用对象的finalize() 方法。
  5. try-with-resources语句可以自动执行close()方法。
  6. Error是Throwable的子类。
  7. Java方法签名包括: 方法头指定修饰符(例如static)、返回值类型、方法名、和形式参数。
  8. Java子类中，使用super访问父类的域和方法 super.attributName = 1; super.parentClassFunction();
  9. java中 final所修饰的变量，是只读量
    • 当使用final修饰变量时，表示该变量是不可改变的
      1. 一个永不改变的编译时常量
      2. 一个在运行时才被赋初值的变量，但不希望该变量的值被修改
  10. 在接口中定义的方法具有public, abstract的特点（Java8以前）
    • 在jdk8之前，interface之中可以定义变量和方法，变量必须是public、static、final的，方法必须是public、abstract的
    • JDK8及以后，允许我们在接口中定义static方法和default方法。
      • 如果两个接口中定义了一模一样的默认方法，并且一个实现类同时实现了这两个接口，那么必须在实现类中重写默认方法，否则编译失败
  11. SimpleDateFormat类可以用来解析日期字符串。 是的， 用parse() 返回Date对象
  12. TreeMap的底层实现是红黑树
  13. Set的主要实现包括HashSet及TreeSet
  14. 迭代的基本模式是while(){ x=f(x); }。
  15. List会记录元素的保存顺序。
  16. List的主要实现包括LinkedList及ArrayList
  17. Queue的主要实现包括LinkedList
  18. for-each语句可以用于所有的Collection及数组。
  19. list和set的区别
    1. List中允许插入重复的元素，而在Set中不允许重复元素存在。 ​
    2. List是有序集合，会保留元素插入时的顺序，Set是无序集合。 ​
    3. List可以通过下标来访问，而Set不能。
  20. Java的集合框架体系总结
    1. Iterator被xxx实现： Collection, ListIterator, Map
    2. Collection 被 Set List 实现
    3. Set 被 HashSet TreeSet 实现
    4. List 被 ArrayList LinkedList 实现
    5. Map 被 HashMap， TreeMap(红黑树)实现
    6. HashSet 被 LinkedHashSet 实现/继承
    7. HashMap 被 LinkedHashMap 实现/继承
    8. Vector HashTable 均已经被替代
    9. java集合继承关系图
  21. 早期类或接口的新版替换：
    1. Vector -> ArrayList 相当于动态数组， 有elementAt
    2. Stack -> LInkedList Stack是Vector的子类，push,pop, peek
    3. Hashtable -> HashMap Hashtable 实现了Map接口，参见Properties类
    4. Enumeration -> Iterator
      • Enumeration用另一种方式实现Iterator功能
  22. JComponent组件都是Container
  23. 事件监听器是一些接口,其中含有一些方法
    • 事件监听器是一些事件的接口, 接口中含有相关的方法, 这些方法带一个事件对象作为参数

以下都是错误的说法：

  1. 如果一个类被abstract所修饰，说明这个类没有构造方法
    • 例子
      • 抽象类的构造方法定义为protected，因为他只能被子类使用，即用super(params);
  2. protected修饰的成员，不能在包中访问，只能在子类中访问。
    • 示意图
  3. private可以修饰类、也可以修饰类的成员（字段、方法）。
    • private只能修饰内部类，不能修饰外部类
    • private关键字只能修饰内部类，不能修饰外部类。 但是，这个地方一定要注意了：内部类中方法只能是static的，因此，内部类也要声明为静态的！
  4. 虚方法调用是指编译时就决定了调用哪个类中的哪个方法。
    • 运行时才知道
  5. instanceof是判断一个对象实例是不是某种类型及其父类型。
    • 只判断一种类型
  6. 抽象类不能有构造方法。
    • 可以有
  7. 匿名类可以定义构造方法。
    • 不可以
  8. 编译器会为所有的类加一个default构造方法，即使用户已定义了构造方法。
    • 用户不写构造方法的时候编译器才会加一个默认的
  9. finally语句是指没有异常出现时要执行的语句。
    • NO
  10. 构造方法（constructor )的返回类型是void。
    • 错误，返回值是构造方法所在类，这个类型的对象
  11. 如果省略访问控制符，则表示private
    • 错误，表示friendly, 包内使用 （待确认）
  12. String 与数组一样，有一个属性叫length。
    • 错误。 string.length() 是方法不是属性。 数组 ( String[] arr ) 才有 .length 属性
  13. String a = "abcdef"; 则a.substring(1,3)的结果为"bcd"。
    • 错误， java的 String.substring 方法的两个参数，是起始和结束位置，不是起始位置和长度
  14. for-each语句可以用于所有的Enumerable对象。
    • 错误 ????
  15. DataOutputStream可以以二进制的方式写入double。
    • 错误 ????
  16. 所有的事件监听接口都可以用Lambda表达式。
    • 错误 针对只有一个方法的接口，可以使用lambda表达式
  17. SQL中语句用双引号表示字符串
    • 错误，用单引号
  18. 方法签名（signature)包括参数的类型及参数的名字。
    • 错误。 包括一堆。。。。
  19. this和super是两个不同的对象
    • 错误。 super是当前对象的父类，不是对象
  20. 如果一个类被abstract所修饰，说明这个类没有构造方法
    • 错误： 抽象类的构造方法定义为protected，因为他只能被子类使用，即用super(paraments);
  21. 实例初始化，先于静态初始化执行
    • 错误： 顺序： 父类静态初始化， 子类静态初始化，父类初始化，父类构造，子类初始化，子类构造
  22. 内部类中不能访问外部类的private字段及方法
    • 错误： 可以的
  23. 若父类中的方法声明了throws异常，则子类Override时一定也要throws异常。
    • 错误： 子类重写父类方法要抛出与父类一致的异常，或者不抛出异常。 子类重写父类方法所抛出的异常不能超过父类的范畴。
  24. Integer I = 5 实际表示Integer I = new Integer(5)。
    • 错误： 1-127 是在integerCache里面的，不会new 一个Integer
  25. 后台线程（deamon）不会自动结束
    • 错误： 守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出
  26. JDBC中RecordSet表示结果集
    • 错误： ResultSet表示结果集， RecordSet目测是VB的
  27. Java中的输入输出流的连接实际上使用了"装饰模式“。
    • 错误：

实例初始化，先于静态初始化执行

各种缩写词

  • POJO : "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者SessionBean。 POJO不担当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB，JDBC等等。

  • Aspectj : AspectJ是一个易用的功能强大的AOP框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

  • JavaBean : JavaBean是一种符合命名规范的class，它通过getter和setter来定义属性

    • JavaBeans是Java中一种特殊的类，可以将多个对象封装到一个对象（bean）中。特点是可序列化，提供无参构造器，提供getter方法和setter方法访问对象的属性。名称中的“Bean”是用于Java的可重用软件组件的惯用叫法
      1. 有一个public的无参数构造函数。
      2. 属性可以透过get、set、is（可替代get，用在布尔型属性上）方法或遵循特定命名规则的其他方法访问。
      3. 可序列化。

  • YAML : YAML 是 "YAML Ain't a Markup Language"（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）。

    • YAML 的语法和其他高级语言类似，并且可以简单表达清单、散列表，标量等数据形态。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）。YAML 的配置文件后缀为 .yml

  • SpEL : Spring Expression Language（简称SpEL）是一种强大的表达式语言，支持在运行时查询和操作对象图。 语言语法类似于Unified EL，但提供了额外的功能，特别是方法调用和基本的字符串模板功能。 同时因为SpEL是以API接口的形式创建的，所以允许将其集成到其他应用程序和框架中

  • POM: Project Object Model

    • Apache Maven，是一个软件（特别是Java软件）项目管理及自动构建工具。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤

  • JAXB : JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。 该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。

    • Jaxb2Marshaller : Jaxb2Marshaller类同时实现 Spring 的Marshaller和Unmarshaller接口。它需要上下文路径才能运行。您可以通过设置contextPath属性来设置上下文路径。上下文路径是冒号分隔的 Java 程序包名称的列表，其中包含模式派生的类。它还提供了classesToBeBound属性，该属性使您可以设置编组支持的类的数组。通过向 bean 指定一个或多个模式资源来执行模式验证
    • Castor XMLMap 是一个开源 XML 绑定框架。它使您可以将 Java 对象模型中包含的数据与 XML 文档进行相互转换。默认情况下，它不需要任何进一步的配置，尽管您可以使用 Map 文件来更好地控制 Castor 的行为。
      • 与 JAXB 一样，CastorMarshaller实现Marshaller和Unmarshaller接口

  • JPA: Java Persistence API（Java持久层API）

    • JPA全称为Java Persistence API（Java持久层API），它是Sun公司在JavaEE 5中提出的Java持久化规范。 它为Java开发人员提供了一种对象/关联映射工具，来管理Java应用中的关系数据，JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作

  • JMS: Java消息服务（Java Message Service）

    • JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。 Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。

  • Spring AMQP: 高级消息队列协议（AMQP）

    • 高级消息队列协议（AMQP）是面向消息的中间件的平台中立的线级协议。 Spring AMQP项目将核心Spring概念应用于基于AMQP的消息传递解决方案的开发。 Spring Boot为通过RabbitMQ使用AMQP提供了一些便利，包括spring-boot-starter-amqp “Starter”

  • Hessian / Caucho : 通过使用 Spring 的HessianProxyFactoryBean和HessianServiceExporter，您可以通过 Caucho 提供的基于 HTTP 的轻量级二进制协议透明地公开您的服务。

  • JCA CCI : 公共的客户端接口：JCA还定义了用户级的编程接口，称为公共客户端接口（CCI，Common Client Interface）。 这个接口集在JCA 1.0中是可选的，允许EIS客户程序的开发者按照一种标准的方式，连接目标EIS系统，或与目标EIS交互（执行命令并获取结果）

  • AOP : Aspect Oriented Programming的缩写，意为：面向切面编程

  • Neo4j: Neo4j是一个高性能的,NOSQL图形数据库

    • Neo4j是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。 它是一个嵌入式的、基于磁盘的、具备完全的事务特性的Java持久化引擎，但是它将结构化数据存储在网络(从数学角度叫做图)上而不是表中。 Neo4j也可以被看作是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。

  • Lettuce :

  • Lucene:

    • Lucene 是一个高效的，基于 Java 的全文检索库。是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构

  • Apache Solr:

    • Apache Solr是一个开源的搜索服务，使用Java语言开发，主要基于HTTP和Apache Lucene实现的。 Apache Solr 中存储的资源是以Document 为对象进行存储的。 每个文档由一系列的Field 构成，每个Field 表示资源的一个属性。
    • Solr是基于Lucene的面向企业搜索的web应用Solr是一个独立的企业级搜索应用服务器，它对外提供类似于Web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过HttpGet操作提出查找请求，并得到xml/json格式的返回结果
    • 一分钟带你了解Solr - 知乎

  • Mustache / Thymeleaf :

    • (aa)

  • FreeMarker:

    • FreeMarker是一款模板引擎： 即一种基于模板和要改变的数据， 并用来生成输出文本（HTML网页、电子邮件、配置文件、源代码等）的通用工具。 它不是面向最终用户的，而是一个Java类库，是一款程序员可以嵌入他们所开发产品的组件
    • 什么是FreeMarker? - FreeMarker 中文官方参考手册

  • HATEOAS: Hypermedia as the engine of application state

  • Spring Integration :

    • Spring Integration 是Spring 框架创建的又一个API，面向企业应用集成（EAI）。 … Spring Integration 可以和EJB、RMI、JMS 这些标准技术协同使用，能让你在一处对复杂的解决方法进行建模，从而对标准技术有所增强。 这在很大程度上简化了这些技术的使用
    • Spring Integration入门-InfoQ

  • JAX-RS / Jersey : 构建 RESTful web 应用的支持。spring-boot-starter-web 的替代方案

  • JOOQ : JOOQ代表Java Object Oriented Query, 可以把你的数据库模型的基本信息，比如表名，字段名生成相应的Java类，这些是自动化的，提高了效率，也避免了手动写POJO代码产生的错误。 JOOQ是直接帮你生成好相应的Java类，然后你也可以用这些Java类和数据库打交道

  • JTA: Java事务API（Java Transaction API，简称JTA ） 是一个Java企业版 的应用程序接口，在Java环境中，允许完成跨越多个XA资源的分布式事务

  • Atomikos JTA / Bitronix JTA / Narayana JTA

  • JNDI : Java Naming and Directory Interface,Java命名和目录接口

    • JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互

  • Quartz :

  • Hamcrest / Mockito 单元测试

  • Actuator : 提供了生产就绪功能，帮助您监控和管理应用

  • Jetty : 嵌入式 servlet 容器。可代替 spring-boot-starter-tomcat

  • Undertow / 嵌入式 servlet 容器，可代替 spring-boot-starter-tomcat

  • Reactor Netty : 内嵌响应式 HTTP 服务器

  • Log4j2 : 日志组件。可代替 spring-boot-starter-logging

  • Logback : 默认的日志

  • JRebel : JVM 热插拔 工具

    • 热部署插件 JRebel： 是一个 JVM Java 代理，它与应用服务器集成，使得类可以用现有的类加载器重新加载。
    • 只有修改过的类才会重新编译并立即在运行的应用程序中加载

  • Spring WebFlux : Spring WebFlux是Spring Framework 5.0中引入的新的反应式Web框架。 与Spring MVC不同，它不需要Servlet API，完全异步和非阻塞，并通过Reactor项目实现Reactive Streams规范。

  • Spring MVC : Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架，它是Spring的一部分，它和Struts2一样都属于表现层的框架。

  • Spring Repository : 在Spring中有Repository的概念，repository原意指的是仓库，即数据仓库的意思。Repository居于业务层和数据层之间，将两者隔离开来，在它的内部封装了数据查询和存储的逻辑。

    • 这样设计的好处有两个：
      1. 降低层级之间的耦合：更换、升级ORM引擎（Hibernate）并不会影响业务逻辑
      2. 提高测试效率：如果在测试时能用Mock数据对象代替实际的数据库操作，运行速度会快很多
    • Repository和DAO的区别:
      • DAO是传统MVC中Model的关键角色，全称是Data Access Object。DAO直接负责数据库的存取工作。
      • Repository蕴含着真正的OO概念，即一个数据仓库角色，负责所有对象的持久化管理
      • DAO则没有摆脱数据的影子，仍然停留在数据操作的层面上
      • Repository是相对对象而言，DAO则是相对数据库而言

  • Annotation 注解： Java原生注解和Spring注解的说明

  • YAML : YAML 入门教程 - Runoob

  • SpEL : Spring 表达式语言 (SpEL)

  • Hibernate : Hibernate 中文文档| Hibernate 中文网

  • SpringCloud : Spring Cloud 中文文档

  • Spring Framework : Spring Framework 中文文档

  • 一堆常用框架 : 开发人员常用框架文档整理及中文翻译 - docs4dev.com

  • Spring WebFlux : Spring Framework 中文文档 - docs4dev.com

  • Spring MVC : []()

  • 微服务：

  • Apache Commons Logging: Commons Logging是一个第三方日志库，它是由Apache创建的日志模块。Commons Logging的特色是，它可以挂接不同的日志系统，并通过配置文件指定挂接的日志系统。默认情况下，Commons Loggin自动搜索并使用Log4j（Log4j是另一个流行的日志系统），如果没有找到Log4j，再使用JDK Logging。

  • Jackson : Jackson 是 spring-boot-starter-json 的一部分

  • Gson :

  • JSON-B :

  • Hazelcast : Hazelcast 是由Hazelcast公司开发的一款开源的分布式内存级别的缓存数据库，可以为基于JVM环境运行的各种应用提供分布式集群和分布式缓存服务。 利用Hazelcast可以满足“分布式”、“集群服务”、“网格式内存数据”、“分布式缓存“、“弹性可伸缩服务”等的要求。

  • Quartz : 调度器。 Quartz是OpenSymphony提供的强大的开源任务调度框架

  • JUnit : 面向 Java 的面向程序员的测试框架。由 Spring Framework 在其测试套件中使用。

  • TestNG ：官网 受 JUnit 启发的测试框架，它对 Comments，测试组，数据驱动的测试，分布式测试和其他功能提供了额外的支持。

  • AssertJ ：文档 “ Java 的 assert”，包括对 Java 8 lambda，流和其他功能的支持。

  • Mock Objects ：维基百科

  • MockObjects.com ：官网 专门用于模拟对象的网站，一种用于在测试驱动的开发中改进代码设计的技术。

  • Mockito ：基于Test Spy 模式的 Java 模拟库。

  • EasyMock ：Java 库“通过使用 Java 的代理机制动态生成接口来提供模拟对象(以及通过类扩展的对象)。”由 Spring Framework 在其测试套件中使用。

  • JMock ：支持使用模拟对象进行 Java 代码的测试驱动开发的库。

  • DbUnit ：JUnit 扩展(也可与 Ant 和 Maven 一起使用)，针对数据库驱动的项目，除其他外，它使数据库在测试运行之间进入已知状态。

  • The Grinder ：Java 负载测试框架。

  • 声明式 TransactionManagement : xx

  • 用于 JDBC 数据库访问的方法:

    • JdbcTemplate 的三种风格 : JdbcTemplate是经典且最受欢迎的 Spring JDBC 方法。这种“最低级别”的方法以及所有其他方法都在幕后使用了 JdbcTemplate
      • NamedParameterJdbcTemplate : 包装JdbcTemplate以提供命名参数，而不是传统的 JDBC ?占位符。当您有多个 SQL 语句参数时，此方法可提供更好的文档编制和易用性
    • SimpleJdbcInsert和SimpleJdbcCall优化数据库元数据以限制必要的配置量。这种方法简化了编码，因此您只需要提供表或过程的名称，并提供与列名称匹配的参数 Map 即可。仅当数据库提供足够的元数据时，此方法才有效。如果数据库不提供此元数据，则必须提供参数的显式配置
    • RDBMS 对象(包括MappingSqlQuery，SqlUpdate和StoredProcedure)要求您在初始化数据访问层期间创建可重用且线程安全的对象。此方法以 JDO Query 为模型，其中您定义查询字符串，声明参数并编译查询。完成后，可以使用各种参数值多次调用 execute 方法。

  • Spring常见面试题

  • 史上最全Spring面试71题与答案

  • 阿里P8架构师谈：开源搜索引擎Lucene、Solr、Sphinx等优劣势比较

666    ·   1

(点赞功能开发中)

评论列表
{{item.userName}}
{{item.lastUpdate}}
{{item.content}}
{{item.like}}    |   {{item.unlike}}
{{ sItem.userName }}
{{ sItem.lastUpdate }}
{{ sItem.content }}
{{ sItem.like }}    |   {{ sItem.unlike }}