个人笔记 - 知识点总结

Java servlet 技术点

servlet API 官网
servlet API 中文说明文档

servlet 14110807

 1：14 — 十四个servlet核心接口
  – Servlet、ServletRequest、ServletResponse、ServletConfig、ServletContext、RequestDispatcher、Filter、FilterConfig、FilterChain、ServletRequestListener、ServletRequestAttributeListener、ServletContextListener、ServletContextAttributeListener、SingleThreadModel
 2：11 — 十一个默认servlet实现类
  – GenericServlet、ServletInputStream、ServletOutputStream、ServletRequestWrapper、ServletResponseWrapper、ServletRequestEvent、ServletRequestAttributeEvent、ServletContextEvent、ServletContextAttributeEvent、ServletException、UnavailableException
 3：08 — 基于HTTP协议的八个Servlet技术框架接口
  – HttpServletRequest、HttpServletResponse、HttpSession、HttpSessionListener、HttpSessionAttributeListener、HttpSessionBindingListener、HttpSessionActivationListener、HttpSessionContext（该接口在新本Http协议中已被废除）
 4：07 — 基于HTTP协议的Servlet技术框架的七个默认实现类
  – HttpServlet、HttpServletRequestWrapper、HttpServletResponseWrapper、Cookie、HttpSessionEvent、HttpSessionBindingEvent、HttpUtils

Java Spring 技术点

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

spring 04070907050507

 1：04 — 四个核心接口
  – ApplicationContext 、BeanFactory、 BeanAware、 FactoryBean

 2：07 — 七个扩展接口
  – BeanFactoryPostProcessor、 BeanDefinitionRegistryPostProcessor、 BeanPostProcessor
  – InitializingBean、 DisposableBean 、ApplicationListener 、ApplicationContextAware

 3：09 — 九个bean的创建步骤
  – 构造函数
  – 依赖注入
  – BeanNameAware
  – BeanFactoryAware
  – ApplicationContextAware
  – BeanPostProcessor 前置方法
  – InitializingBean
  – init
  – BeanPostProcessor后置方法

 4：07 — 七种bean作用域，Scopebean的scope是指bean的作用域，request、session、global-session是在web服务中使用的scope
  – singleton默认情况下是单例模式，这也是使用最多的一种方式；
  – prototype多例模式，即每次从beanFactory中获取bean都会创建一个新的bean；
  – request每次请求都创建一个实例；
  – session是在一个会话周期内保证只有一个实例；
  – global-session在5.x版本中已经不在使用；
  – Application保证在一个ServletContext中只创建一个实例；
  – Websocket保证在一个WebSocket中只创建一个实例；

 5：05 — 五大事件机制
  – contextRefreshEvent 、contextStartedEvent
  – contextStoppedEvent 、contextClosedEvent 、requestHandledEvent

 6：05 — 五种事务隔离级别
  – ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应【默认】

  – ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读【隔离级别最低，并发性能高 】
  – ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。【锁定正在读取的行】

  – ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。【锁定所读取的所有行】

  – ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。【锁表】

 7：07 — 七种事务传播机制
  – PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。【默认】

  – PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。

  – PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

  – PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

  – PROPAGATION_NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务。

  – PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常

  – PROPAGATION_NESTED如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

如果子事务回滚，父事务会回滚到进入子事务前建立的save point，然后尝试其他的事务或者其他的业务逻辑，父事务之前的操作不会受到影响，更不会自动回滚。
如果父事务回滚，子事务也会跟着回滚。因为父事务结束之前，子事务是不会提交的，因为子事务是父事务的一部分。
事务的提交：子事务先提交，父事务再提交。
子事务是父事务的一部分，由父事务统一提交。
spring 框架 系列

spring mvc 040403

 1：04 — 四个核心接口
  – DispatcherServlet 、HandlerMapping 、Controller 和 ViewResolver

 2：04 — 四类处理
  – 类型转换器 、格式化转化器 、验证器 和 拦截处理器

 2：04 — 三种统一异常处理 http://c.biancheng.net/view/4470.html
  – 使用 org.springframework.web.servlet.handler.SimpleMappingExceptionResolver 类统一处理异常时需要在配置文件中提前配置异常类和 View 的对应关系。

  – org.springframework.web.servlet.HandlerExceptionResolver 接口用于解析请求处理过程中所产生的异常。开发者可以开发该接口的实现类进行 Spring MVC 应用的异常统一处理。

  – 创建 BaseController 类，并在该类中使用 @ExceptionHandler 注解声明异常处理方法

spring boot 030903

spring boot 框架系列
 1：03 — springApplication 构造函数主要完成以下三件事
  – 跟据classpath下的jar包判断需要创建哪种类型的ApplicationContext
  – 加载设置ApplicationContextInitializer
  – 加载设置ApplicationListener

 2：09 — springApplication.run() 完成以下九件事
  – 创建运行监听器并发布开始消息
  – 创建应用上下文环境
  – 创建应用上下文
  – 配置应用上下文
  – 刷新应用上下文
  – 调用应用上下文的后置处理方法
  – 发布应用上下文启动完成消息
  – 调用应用运行器方法（ApplicationRunner.run()）
  – 发布应用上下文运行消息（listeners.running(context)）

 3：03 — spring IOC容器的初始化过程
  – 第一步：Resource定位
  – 第二步：BeanDefinition的载入
  – 第三个过程：注册BeanDefinition

 4：06 — Spring boot 六大特性
  – 创建独立的Spring 应用程序
  – 直接内嵌Tomcat、Jetty
  – 提供 Starter 简化配置
  – 自动配置Spring和第三方库
  – 提供可用于生产的特性，如度量、运行状况检查和外部化配置
  – 不需要XML配置

Spring IOC 容器的初始化过程

spring cloud 2008

 1：20 — 二十个以上的核心组件
  – spring cloud context
  – spring cloud commons
  – spring cloud config
  – spring cloud netflix
  – spring cloud openfeign
  – spring cloud stream
  – spring cloud bus
  – spring cloud sleuth
  – spring cloud consul
  – spring cloud zookeeper
  – spring cloud security
  – spring cloud for cloud foundry
  – spring cloud vault
  – spring cloud gateway
  – spring cloud kubernetes
  – spring cloud gcp
  – spring cloud contract
  – spring cloud contract stub runner
  – spring cloud contract wiremock
  – stub runner
  – contract dsl
  – gradle
  – Binder

 2：08 — 微服务的八个模块
  – 指标接口、链路跟踪注入、日志引流、服务注册发现、路由规则，熔断、限流，服务降级

前端技术要点

Easyui 050302

EasyUI 文档
 1：05 — 五个基础组件
  – Panel、TextBox、ComBo、Menu、Tree

 2：03 — 三个高级容器
  – Layout 布局、Accordion 折叠面板、Tabs 标签页/选项卡

 3：02 — 二个弹窗
  – Messager 消息框、Dialog 对话框

VUE

VUE 官方文档
 1：** — 一个JavaScript的渐进式框架

React 0605070307

React 官方文档
react w3cschool 教程
 1：06 — 六个核心特性
  – 声明式设计 −React采用声明范式，可以轻松描述应用。

  – 高效 −React通过对DOM的模拟，最大限度地减少与DOM的交互。

  – 灵活 −React可以与已知的库或框架很好地配合。

  – JSX − JSX 是 JavaScript 语法的扩展。React 开发不一定使用 JSX ，但我们建议使用它。

  – 组件 − 通过 React 构建组件，使得代码更加容易得到复用，能够很好的应用在大项目的开发中。

  – 单向响应的数据流 − React 实现了单向响应的数据流，从而减少了重复代码，这也是它为什么比传统数据绑定更简单。

 2：05 — 组件构成的五个部分
  – render、getDefaultProps（设置默认属性）、getInitialState（设置初始化状态）
  – handleClick（点击事件处理方法）、propTypes（属性验证器）

 3：07 — 七个React 组件 API
  – 设置状态：setState
  – 替换状态：replaceState
  – 设置属性：setProps
  – 替换属性：replaceProps
  – 强制更新：forceUpdate
  – 获取DOM节点：findDOMNode
  – 判断组件挂载状态：isMounted

 4：03 — 组件生命周期的三个状态
  – Mounting：已插入真实 DOM
  – Updating：正在被重新渲染
  – Unmounting：已移出真实 DOM

 5：07 — 组件生命周期的方法
  – componentWillMount 在渲染前调用,在客户端也在服务端。

  – componentDidMount : 在第一次渲染后调用，只在客户端。之后组件已经生成了对应的DOM结构，可以通过this.getDOMNode()来进行访问。 如果你想和其他JavaScript框架一起使用，可以在这个方法中调用setTimeout, setInterval或者发送AJAX请求等操作(防止异部操作阻塞UI)。

  – componentWillReceiveProps 在组件接收到一个新的prop时被调用。这个方法在初始化render时不会被调用。

  – shouldComponentUpdate 返回一个布尔值。在组件接收到新的props或者state时被调用。在初始化时或者使用forceUpdate时不被调用。
可以在你确认不需要更新组件时使用。

  – componentWillUpdate在组件接收到新的props或者state但还没有render时被调用。在初始化时不会被调用。

  – componentDidUpdate 在组件完成更新后立即调用。在初始化时不会被调用。

  – componentWillUnmount在组件从 DOM 中移除的时候立刻被调用。

JavaScript 0704040402

JavaScript MDN文档
 1：07 — 七种基本类型
  – Number（数字）
  – String（字符串）
  – Boolean（布尔）
  – Symbol（符号）（ES2015 新增）
  – Object（对象）
  – null（空）
  – undefined（未定义）

 2：04 — 四种高级类型
  – Function（函数）
  – Array（数组）
  – Date（日期）
  – RegExp（正则表达式）

 3：04 — 四种原型对象扩展
  – New-initialization 支持目前以及所有可想象到的浏览器(IE5.5都可以使用). 这种方法非常快，非常符合标准，并且充分利用JIST优化。

function foo(){}
foo.prototype = {
  foo_prop: "foo val"
};
function bar(){}
var proto = new foo;
proto.bar_prop = "bar val";
bar.prototype = proto;
var inst = new bar;
console.log(inst.foo_prop);
console.log(inst.bar_prop);

  – Object.create 支持当前所有非微软版本或者 IE9 以上版本的浏览器。允许一次性地直接设置 proto 属性，以便浏览器能更好地优化对象。同时允许通过 Object.create(null) 来创建一个没有原型的对象。

function foo(){}
foo.prototype = {
  foo_prop: "foo val"
};
function bar(){}
var proto = Object.create(
  foo.prototype
);
proto.bar_prop = "bar val";
bar.prototype = proto;
var inst = new bar;
console.log(inst.foo_prop);
console.log(inst.bar_prop);

  – Object.setPrototypeOf 支持所有现代浏览器和微软IE9+浏览器。允许动态操作对象的原型，甚至能强制给通过 Object.create(null) 创建出来的没有原型的对象添加一个原型。

function foo(){}
foo.prototype = {
  foo_prop: "foo val"
};
function bar(){}
var proto = {
  bar_prop: "bar val"
};
Object.setPrototypeOf(
  proto, foo.prototype
);
bar.prototype = proto;
var inst = new bar;
console.log(inst.foo_prop);
console.log(inst.bar_prop);

  – proto 支持所有现代非微软版本以及 IE11 以上版本的浏览器。将 proto 设置为非对象的值会静默失败，并不会抛出错误。

function foo(){}
foo.prototype = {
  foo_prop: "foo val"
};
function bar(){}
var proto = {
  bar_prop: "bar val",
  __proto__: foo.prototype
};
bar.prototype = proto;
var inst = new bar;
console.log(inst.foo_prop);
console.log(inst.bar_prop);

var inst = {
  __proto__: {
    bar_prop: "bar val",
    __proto__: {
      foo_prop: "foo val",
      __proto__: Object.prototype
    }
  }
};
console.log(inst.foo_prop);
console.log(inst.bar_prop)

 4：04 — 4种实例对象的创建以及原型链的生成
  – 使用语法结构创建的对象

var o = {a: 1};
// o 这个对象继承了 Object.prototype 上面的所有属性
// o 自身没有名为 hasOwnProperty 的属性
// hasOwnProperty 是 Object.prototype 的属性
// 因此 o 继承了 Object.prototype 的 hasOwnProperty
// Object.prototype 的原型为 null
// 原型链如下:
// o ---> Object.prototype ---> null
var a = ["yo", "whadup", "?"];
// 数组都继承于 Array.prototype 
// (Array.prototype 中包含 indexOf, forEach 等方法)
// 原型链如下:
// a ---> Array.prototype ---> Object.prototype ---> null
function f(){
  return 2;
}
// 函数都继承于 Function.prototype
// (Function.prototype 中包含 call, bind等方法)
// 原型链如下:
// f ---> Function.prototype ---> Object.prototype ---> null

  – 使用构造器创建的对象

function Graph() {
  this.vertices = [];
  this.edges = [];
}

Graph.prototype = {
  addVertex: function(v){
    this.vertices.push(v);
  }
};

var g = new Graph();
// g 是生成的对象，他的自身属性有 'vertices' 和 'edges'。
// 在 g 被实例化时，g.[[Prototype]] 指向了 Graph.prototype。

  – 使用 Object.create 创建的对象

var a = {a: 1}; 
// a ---> Object.prototype ---> null

var b = Object.create(a);
// b ---> a ---> Object.prototype ---> null
console.log(b.a); // 1 (继承而来)

var c = Object.create(b);
// c ---> b ---> a ---> Object.prototype ---> null

var d = Object.create(null);
// d ---> null
console.log(d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype

  – 使用 class 关键字创建的对象

"use strict";

class Polygon {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}

class Square extends Polygon {
  constructor(sideLength) {
    super(sideLength, sideLength);
  }
  get area() {
    return this.height * this.width;
  }
  set sideLength(newLength) {
    this.height = newLength;
    this.width = newLength;
  }
}

var square = new Square(2);

 5：02 — 2种方法函数调用API
  – *.call（object、非数组参数列表）
如果你执行 var a1 = new A(); var a2 = new A(); 那么 a1.doSomething 事实上会指向 Object.getPrototypeOf(a1).doSomething，它就是你在 A.prototype.doSomething 中定义的内容。
也就是说：Object.getPrototypeOf(a1).doSomething == Object.getPrototypeOf(a2).doSomething == A.prototype.doSomething（补充：实际上，执行 a1.doSomething() 相当于执行 Object.getPrototypeOf(a1).doSomething.call(a1)==A.prototype.doSomething.call(a1)）

简而言之， prototype 是用于类的，而 Object.getPrototypeOf() 是用于实例的（instances），两者功能一致。

[[Prototype]] 看起来就像递归引用， 如 a1.doSomething、Object.getPrototypeOf(a1).doSomething、Object.getPrototypeOf(Object.getPrototypeOf(a1)).doSomething 等等等， 直到它被找到或 Object.getPrototypeOf 返回 null。

因此，当你执行：

var o = new Foo();
JavaScript 实际上执行的是：

var o = new Object();
o.__proto__ = Foo.prototype;
Foo.call(o);

  – *.apply（object、 arguments（数组参数））