firewall-cmd --permanent --add-port=8080-8085/tcp
firewall-cmd --permanent --remove-port=8080-8085/tcp

Predicate<T>——接收T对象并返回boolean
Consumer<T>——接收T对象，不返回值
Function<T, R>——接收T对象，返回R对象
Supplier<T>——提供T对象（例如工厂），不接收值
UnaryOperator<T>——接收T对象，返回T对象
BinaryOperator<T>——接收两个T对象，返回T对象

objectName::instanceMethod

ClassName::staticMethod

ClassName::instanceMethod

List<Integer> nums = Lists.newArrayList(1,null,3,4,null,6);
nums.stream().filter(num -> num != null).count();

1.	JSP文件中的元素可分为5类：
A 注释 <!--  -->  隐藏注视：不发给客户  <%--  --%>    java中的注释
B 模板元素   HTMl元素
C 脚本元素 
1. 声明：<%!  %>   
2.表达式  <%=  %> 
3.Scriptlets  <%  %>  是JSP中页面处理请求是执行的Java代码
D 指令元素 
	1. page指令 
 2．include指令(静态，编译时包含检查错误了，区别于动作包含)  
3.taglib指令   允许使用自定义标签
E动作元素   <jsp:   >
2.	表达式语言用${}表示
3.	JSP内建对象
所有的内建对象都是由容器管理和实现，在所有的JSP页面中都可以使用该内部对象
1.	request           javax.servelt.ServletRequset的子类
2.	response          javax.servelt.ServletResponse的子类
3.	pageContext 		javax.servelt.jsp.PageContext的子类
4.	session 			javax.servlet.http.HtttpSession
5.	application   		javx.servlet.ServletContext
6.	out				javax.servlet.jsp.JspWriter
7.	config			javax.servlet.ServletConfig
8.	page				javax.lang.Object
9.	exception			java.lang.Throwable
4.	JSP内建对象详解
一．	Out对象
表示为客户打开的输出流PrintWriter通过他向客户端发送输出六，简单的说，它主要用来向客户端输出数据，代表输出流的对象
区分：out.clear();方法清除缓冲区的数据，并把数据输出到客户端
		 Out.clearBuffer();方法清除缓冲区的数据，但不把数据输出到客户端
其中的方法有print和println，但是println并没有换行的的作用，因为被浏览器忽略了，用println（“<br>”）；
二、	request对象
表示请求对象，通过gerParameter方法可以得到request对象的参数，通过Cookies、Referer等可以得到请求的HTTP头。
来自客户端的请求经Servlet容器处理后，由request对象进行封装。
isUserRole方法判断认证后的用户是否属于逻辑的Role的会员
三、	response对象
   response封装了JSP产生的响应，然后被发送到客户端以响应客户的请求，输出流是有缓冲的
四、	session对象
session对西安用来保存每个用户的信息，以便跟踪每个客户的操作状态。其中，session信息保存在容器中，session的ID保存在客户机的Cookie中。
如果客户端禁掉了Cookies，则会自动的转化为URL-rewriting(重写ＵＲＬ，这个ＵＲＬ中包含客户端的信息)，session自动为每个流程提供方便的存储信息的方法。
	Invalidate方法销毁这个session对象，使得和他绑定的对象都失效
五、	pageContext对象
他为ＪＳＰ页面包装了页面的上下文，管理对属于ＪＳＰ中特殊可见部分中已命名对象的访问。创建和初始化是由容器完成的。ＪＳＰ页面中可以直接使用pageContext对象的句柄
	pageContext对象的getXXX()/setXXX()/findXXX()方法可以用来根据不同的对象范围实现对不同范围内的对象的管理
	forward()方法重定向
注意： pageContext属性默认在当前的页面是共享的
	   Session中的属性在当前是session中是共享的
	   ServletContext对象中的属性对所有页面是共享的
六、	application对象
他为多个应用程序保存信息。对于一个容器而已，每个用户都共同是由一个application对象，他和服务器同生同死
getAttributeNames返回的是一个枚举的实例
可以用来做网站计数器（刷新的时候变了？当服务器关闭时就从0开始计数，解决方法是每当服务器宕机后设置技术的初始值）
七、	config对象
他表示servlet的配置，当一个容器初始化的时候，容器把某些信息通过此对象传递给这个Servlet
getServletContext（）返回执行者的Servlet上下文
getInitParameter 和getInitParameterNames返回初始值
八、	page对象
他指的是JSP实现类的实例，即他就是JSP本身，通过这个可以对他进行访问
九、	exception对象
他值得是运行时的异常，也就是被调用的错误页面（isErrorPage==true）的结果，只有在错误页面中才可以使用
5.	JSP中使用JavaBean
JavaBean往往封装了程序的页面逻辑，它是可重用的组建
区别：JavaBean和Enterprise  JavaBean概念是完全不同的。
	EJB为开发服务器端应用程序组件提供了一个模型，利用这个模型来创建可移植与分布式企业应用程序服务器或组件。
	JavaBean的属性是Bean组件内部状态的抽象表示，可分为四类：
A．Simple  B。Indexed （可以操作数组） C。Bound   D。Constrained
6、	动态页面和用户会话
	JSP是一种动态页面技术
动态网页的动态主要是以下几个方面获得：
1.	根据时间的动态
2.	根据用户类型的动态
3.	根据用户自定义信息的动态
4.	根据用户来自地区的动态
5.	根据数据库内容的动态
用户会会话跟踪
不同页面间的信息交换：
	1.	HTTP信息
将信息保存在HTTP头部，以淘汰了
2． 隐藏字段
<input type=”hiddern” name=”” value=””>
3. URL重写
<a href=”   ?name=3&……”></a>
缺点:不安全，连接长度   （URL长度一般是2KB）
4.Cookie
5.session
7  Sevlet技术
Servlet先于JEE平台而出现
Servlet是由服务器端调用和执行的、按照Servlet自身规范编写的Java类，可以实现Java编写的所有功能除图形界面以外
作用：可以处理客户端传过来的HTTP请求，并返回一个响应。
Servlet的生命周期：
1．	装载Servlet
2．	创建Servlet对象
3．	调用Servlet的init方法
4．	服务  调用service方法
5．	销毁   调用Servlet的destroy方法
平常编写Servlet一般都直接继承HttpServlet
重点：编写配置文件
8. Servlet常用接口的使用
一、  Servlet实现相关
Public interface Servlet 是所有Servlet必须直接或间接实现的接口，有init，destroy，service等方法
Public abstract class GenericServlet implements Servlet，ServletConfig，java.io.Serializable
其方法service是抽象方法
Public abstract class HttpServlet extends GenericServlet implements java.io.Serializable
他是针对使用HTTP协议的Web服务器的Servlet类，通过执行Servlet接口，能够提供HTTP协议的功能
二、Servlet配置相关
Javax.servlet.ServletConfig接口代表Servlet的配置，包括Servlet的名字，促使参数和上下文。
Public interface ServletConfig 有getInitParameter方法，getServletContext等方法
三、Servlet异常相关
1、public class ServletException extends Exception  方法getRootCase返回异常产生原因
2、public class UnavailableException  extends ServletException
当Servelet或Filter不能使用时抛出此异常
四、 请求和相应相关
ServletRequest 、ervletI/O、ServletRequestWrapper（ServletRequest的实现类）、HttpServletReqest等
五、会话跟踪
Public interface HttpSession
此接口被Servlet引擎用来实现HTTP客户端和HTTP会话两者之间的关联。Session用来再无状态的HTTP协议下越过多个请求页面来维持状态和识别用户
一个Session可以通过Coookie或URL来维持
六、Servlet上下文
public interface ServletContext
在服务器上使用Session对象维持与单个客户相关的状态，而当多个用户的Web应用维持一个状态时，则应使用Servlet环境（Context），ServletContext对象代表一组Servlet共享的资源。
七、Servlet协作
public interface RequestDispatcher，包含两个方法：forward和include
八、过滤
通过过滤可以对请求进行统一的编码、对请求进行认证等。每个filter可能只担任很少的任务，多个Filter可以相互协作，通过这种协作，可以完成一个复杂的功能。
public interface Filter  他是Filter必须实现的接口，包含init，doFilter，destroy等方法
public interface FilterChain  是代码的过滤链，通过它可以把过滤的任务在不同的Filter之间转移，包含doFilter方法
public interface FilterConfig 代表Filter的配置
十、	使用HttpServlet处理客户端的请求
Servlet被设计成轻轻驱动的。
当Web容器接受到某个对Servlet的请求时，把他封装成一个HttpServletRequest对象，然后把此对象传给Servlet的对应处理方法，如doGet和doPost等
doGet：可以获取服务器信息，并将其作为响应返回给客户端
doGet：用户把数据传送到服务器端，可以隐藏放松的数据，适合发送大量的数据
9、获得Servlet的初始化参数
   通过ServletConfig接口获得Servlet的初始参数 
10、Servlet的配置
第八章
15、JSP和Servlet结合的方法
   模式一：JSP+JavaBean
       所有数据通过Bean处理，JSP实现页面的表现
       小型应用中可以考虑
   模式二：JSP+Servlet+JavaBean 
       遵循MVC模式，Servlet作为控制器修改Bean的属性，JSP读取Bean的属性，然后进行显示，即JavaBean作为ＪＳＰ和Ｓｅｒｖｌｅｔ通信的中间工具
       大中型项目中使用
实际中，所有ＪＳＰ都必须编译成Servlet，并且在Servlet的容器中执行。
16、JSP开发中的常用技巧
一、在不同页面之间共享数据（同一用户）
A．ssession  B. Cookie C.隐含表单 D.ServletContext  E.application F.文件系统或者数据库
二、在不同用户之间共享数据
A．使用ServletContext     B、application对象
三、创建错误处理页面
在编译时出现错误，其代码为500.
在JSP中声明出错页面<%@ page errorPage=”error.jsp”%>;在error.jsp中首先要制定该isErrorPage=“true”，只有这样，这个页面才能进行错误处理 ，才能使用exception对象。
一句话：JSP 错误处理的本质是在不同的页面或者类中传递异常，并且在目标页面处理异常
17、自定义标签库的开发

 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath/>
</parent>
~~~ 
* spring-boot-starter-parent 模块中包含了自动配置、日志和YAML，使构建spring项目变得简单
* spring-boot-starter-parent它用来提供相关的Maven默认依赖，使用它之后，常用的包依赖可以省去version标签
* Spring Boot提供的jar包的依赖可参考.m2/repository/org/springframework/boot/spring-boot-dependencies/下pom文件

spring-boot-starter-web 模块，包括了Tomcat和Spring MVC的依赖

spring-boot-starter-test 测试模块，包括JUnit、Hamcrest、Mockito

* 在spring-boot中，模块的依赖都是以starter的方式进行，以 spring-boot-starter-方式命名，指明了具体的模块
* 使用starter的依赖方式，可以把相应需要依赖的包一起依赖到项目中，而不像传统的Spring 需要各自依赖包
* 更多starter作用，请参考：Spring Boot的启动器Starter详解(https://my.oschina.net/u/3235888/blog/887854)
* SpringBoot启动原理（推荐必读）：https://www.cnblogs.com/zheting/p/6707035.html

# 项目构建
方式一：在线构建 http://start.spring.io 
方式二：IDEA中IndexController构建spring-boot项目

# SpringBoot的属性配置
## 默认配置
* 如果需要修改starter模块中的默认配置，只需要在application.properties 中添加修改相应的配置
* spring boot启动的时候会读取application.properties默认配置
* 在spring boot中配置除了支持 application.properties，还支持application.yml的配置方式
* 详细SpringBoot配置可参考： https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

## 自定义属性配置

* 定义属性对应类需要添加@Component注解，让spring在启动的时候扫描到该类，并添加到spring容器中
* 在application.properties内可以直接通过${}引用其他属性的值；通过${random}获取随机数
* 如果不使用默认名称的配置文件，如改名为test.properties这份默认配置，则通过在bean添加@Configuration和@PropertySource("classpath:test.properties")来设置
1. 使用spring支持的@Value()加载

2. 使用@ConfigurationProperties(prefix="") 设置前缀，属性上不需要添加注解

使用：

## 属性配置优先级
application.properties和application.yml文件可以放在一下四个位置：
* 外置，在相对于应用程序运行目录的/congfig子目录里。
* 外置，在应用程序运行的目录里
* 内置，在config包内
* 内置，在Classpath根目录

相同优先级位置同时有application.properties和application.yml，那么application.yml里面的属性就会覆盖application.properties里的属性

## 多环境配置
在application.properties/在application.yml同目录下新建不同环境下的配置文件，格式：application-{profile}.properties，如：

在application.properties/在application.yml中设置spring.profiles.active的值为{profile}（dev／test／prod）来启用不同的配置属性

# 静态资源处理
## 默认静态资源映射
Spring Boot对静态资源映射提供了默认路径配置， 其内内容均为静态资源，可直接访问，提供的静态资源映射如下:
![image](/pub-images/静态资源优先级.png)

可以通过修改spring.mvc.static-path-pattern来修改默认的映射，例如我改成/test/**,那运行的时候访问http://lcoalhost:8080/test/index.html


## 自定义静态资源映射
如访问static下资源，如：http://localhost:8080/static/test.jpg，则可通过如下方式
方式1：在application.properties中添加配置：spring.mvc.static-path-pattern=/static/** 则只能通过/static/来访问静态资源
方式2：代码实现

# 模板引擎
* Spring Boot 推荐使用Thymeleaf、FreeMarker、Velocity、Groovy、Mustache等模板引擎，不建议使用JSP
* 默认 src/main/resources/templates 目录为以上模板引擎的配置路径
使用流程：
1. pom中对应模版starter引入
2. 编写controller
3. 在templates下编写模版

# 热部署
热部署:监听Class文件的变动，只把发生修改的Class重新加载，而不需要重启应用
1. 使用spring-boot-maven-plugin
* 把项目打包成一个可执行的超级JAR（uber-JAR）,包括把应用程序的所有依赖打入JAR文件内，并为JAR添加一个描述文件，其中的内容能让你用java -jar来运行应用程序。
* 搜索public static void main()方法来标记为可运行类
* 详细讲解参考：https://blog.csdn.net/taiyangdao/article/details/75303181
* 官网：https://docs.spring.io/spring-boot/docs/current/reference/html/build-tool-plugins-maven-plugin.html
2. 使用spring-boot-devtools 

# ControllerAdvice
可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，并应用到所有@RequestMapping中，通常用于拦截异常并统一处理
https://www.cnblogs.com/magicalSam/p/7198420.html

# SpringBoot项目运行模式
1. main方法方式
2. 用命令 mvn spring-boot:run”在命令行启动该应用,可通过IDEA的Maven插件中Plugins-》spring-boot找到
3. Jar／War方式 :运行“mvn package”进行打包时，会打包成一个可以直接运行的 JAR 文件，使用“java -jar”命令就可以直接运行，war包形式，需要有webapp->WEB-INF->web.xml，java -jar [war名称.war]

# 默认日志框架配置
* SLF4J——Simple Logging Facade For Java，它是一个针对于各类Java日志框架的统一Facade抽象
* SLF4J定义了统一的日志抽象接口，而真正的日志实现则是在运行时决定的——它提供了各类日志框架的binding
* Logback是log4j框架的作者开发的新一代日志框架，它效率更高、能够适应诸多的运行环境，同时天然支持SLF4J。
* Spring Boot在所有内部日志中使用Commons Logging，但是默认配置也提供了对常用日志的支持
* 默认情况下，Spring Boot会用Logback来记录日志，并用INFO级别输出到控制台
* spring-boot-starter-logging为logback的starter，一般会包含在其他starter中如spring-boot-starter，不需要显式引入
* 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL
* 可以按如下规则组织配置文件名：Logback：logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy

参考文章：https://www.cnblogs.com/zheting/p/6707041.html

# 自定义 Filter

# JPA数据库操作
http://www.ityouknow.com/springboot/2016/08/20/spring-boo-jpa.html

* Jpa 是利用 Hibernate 生成各种自动化的 sql，如果只是简单的增删改查，基本上不用手写了，Spring 内部已经帮大家封装实现了
* Spring Data Jpa 还有很多功能，比如封装好的分页，可以自己定义 SQL，主从分离等等

# mybatis
http://www.ityouknow.com/springboot/2016/11/06/spring-boo-mybatis.html



# Redis

# Spring Factories机制
* Java SPI(Service Provider Interface)机制:为某个接口寻找服务实现的机制
1. 当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件,该文件里就是实现该服务接口的具体实现类
2. 当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入
* Spring Boot中的SPI机制:Spring Factories(Spring Boot中一种非常解耦的扩展机制)
1. 在META-INF/spring.factories文件中配置接口的实现类名称
2. 当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。这种自定义的SPI机制是Spring Boot Starter实现的基础。

# 自定义starter
* starter可以理解为一个可拔插式的插件
* starter的artifactId的命名规则
1. 官方Starter通常命名为spring-boot-starter-{name}如 spring-boot-starter-web
2. 非官方Starter命名应遵循{name}-spring-boot-starter的格式, 如mybatis-spring-boot-starter

Starter的工作原理:
1. Spring Boot在启动时扫描项目所依赖的JAR包，寻找包含spring.factories文件的JAR包，
2. 读取spring.factories文件获取配置的自动配置类AutoConfiguration，
3. 将自动配置类下满足条件(@ConditionalOnXxx)的@Bean放入到Spring容器中(Spring Context)
4. 这样使用者就可以直接用来注入，因为该类已经在容器中了 

自定义starter步骤：
1. maven引入：

* spring-boot-configuration-processor：spring默认使用yml中的配置，但有时候要用传统的xml或properties配置，则需要依赖他，这样就可以在你的配置类开头加上@PropertySource("classpath:your.properties")，其余用法与加载yml的配置一样
* spring-boot-autoconfigure: http://ifeve.com/spring-boot-autoconfigure/
2. 定义自己的Properties类,如PersonProperties.java：

3. 核心服务类,如PersonService.java：

4. 自动配置类:一般每个starter都至少会有一个自动配置类，一般命名规则使用XxxAutoConfiguration,如：PersonServiceAutoConfiguration

所用注解说明：

5. src/main/resources/META-INF/spring.factories
注意：META-INF是自己手动创建的目录，spring.factories也是手动创建的文件,在该文件中配置自己的自动配置类

6. 打包mvn clean install,生成starter的jar包
7. 使用starter 
* 创建新项目，引入starter
* 配置application.properties，如：

* 调用

title : 字符串，设置默认 title。
width/height : 主窗口的大小。
toolbar : bool 值。是否显示导航栏。
icon : 窗口的 icon。
position :字符串。窗口打开时的位置，可以设置为“null”、“center”或者“mouse”。
min_width/min_height : 窗口的最小值。
max_width/max_height : 窗口显示的最大值。
resizable : bool 值。是否允许调整窗口大小。
always-on-top : bool 值。窗口置顶。
fullscreen : bool 值。是否全屏显示。
show_in_taskbar : 是否在任务栏显示图标。
frame : bool 值。如果设置为 false，程序将无边框显示。

{
  "name": "helloworld", 
  "version": "0.0.1",
  "main": "index.html" 
}

NW.js app : 可以是当前项目目录，但要包含package.json文件. 或者是一个.nw的文件
NW.js interpreter 指定可执行的 nw(官网下的包中的) (mac下是nwjs),如：/MyDeveloper/nwjs-v0.22.1-osx-x64/nwjs.app
working direction ： 项目目录

参考资料
《ECMAScript 6 入门》： http://es6.ruanyifeng.com/

<script src="traceur.js"></script>
<script src="bootstrap.js"></script>
<script type="module">
    //此出写ES6代码
</script>

//test.js
'use strict'
let a=2;
console.log(a);

//i表示数组或者json的值，for in中i是下标，for of中表示key+value，实质是jsonObj.entrys(),类似的还有jsonObj.keys()、jsonObj.values()
for(var i of arr){
    console.log(i);
}

function foo() { 
  var f = (...args) => args[0]; 
  return f(2); 
}

foo(1); // 2

//以前
var person={
    name:'abc',
    age:100,
    showName:function(){
        alert(this.name);       //this有问题
    }
}

//ES6
var name='abc';
var age =100;
var person={
    name,
    age,
    showName(){
        alert(this.name);
    }
}

//以前面向对象
function Person(name,age){  //类和构造函数一体
    this.name = name;
    this.age = age;
}
Person.prototype.showName=function(){
    return this.name;
}
var p1 = new Person('abc',100);
alert(p1.name);

//ES6面向对象
class Person{
    constructor(name='defalut',age=0){  //此处可以设置默认值，这是函数的功能，即：函数参数可以给默认值
        this.name = name;
        this.age = age;
    }
    showName(){
        return this.name;
    }
}

var p1 = new Person('abc',100);
alert(p1.name);     
alert(p1.showName());

//以前  子类.prototype = new 父类();
function Worker(name,age){
    Person.apply(this,arguments);
}
Worker.prototype=new Person();

//ES6
class Woker extends Person{
    constructor(){
        super();    //调用父级构造
    }
}

//定义
export default {a,b}
//引用
import modA from './a.js';
//使用
var sum = modA.a + modA.b

pending(等待、处理中)  ---> Resolve（完成）   
                     ---> Reject  (拒绝)

var p1 = new Promise(function(resolve,reject){
    if(异步处理成功了)
        resolve(成功数据)
    else
        reject(失败原因)
});

所有方法都支持链式编程
*  then(成功(resolve数据),失败（reject数据）)  //此方法可以防止异步编程括号深度太多的的问题
*  catch（function（e）{}）；    // 用来捕获错误
*  all[p1,p2,p3....]  //用于将多个promise对象组合／包装成一个全新的promise对象,数组中的Promise又一个错误则按错误流程走，所有都成功则按成功流程走
*  Promise.race([p1,p2....]).then(function(value){}); //返回最先执行的Promise的结果
*  Promise.reject()         //生成错误的Promise
*  Promise.resolve()        //生成成功的Promise

//普通函数
function show(){
    
}
//generator函数
function* show(){
    yield “Hello”；
    yield "World";
}
//generator函数
*show(){
    yield “Hello”；
    yield "World";
}

var res=show();
console.log(res.next());  //{value:"Hello",done:false}
console.log(res.next());  //{value:"World",done:false}
console.log(res.next());  //{value:"undefined",done:true}
~~~ 
* Generator函数调用后的对象有next方法
* next方法每次返回一个value和done结果，value位yield后面的值，done代表是否遍历结束
* yield语句本身没有返回值或每次返回undefined
* next可以带参数，所带参数给了上一个yield
* for ...of循环支持Generator函数

#### 展开运算符
 扩展语法允许一个表达式在期望多个参数（用于函数调用）或多个元素（用于数组文本）或多个变量（用于解构赋值）的位置扩展
1. 用于函数调用

2. 用于数组字面量

npm install dva-cli -g
dva -v
dva new dva-quickstart
cd dva-quickstart
npm start

// .babelrc or babel-loader option
{
  "plugins": [
    ["import", { "libraryName": "antd", "libraryDirectory": "es", "style": "css" }] // `style: true` 会加载 less 文件
  ]
}