1. 每个类都有构造方法。如果没有直接为类定义构造方法，Java将会自动为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
2. java序列化 需要实现java.io.serializable 接口
a.HashMap就实现了此接口支持序列化 线程不安全 key为null的键值对永远都放在以table[0]为头结点的链表中。
哈希表中的每一个元素 都是单链表的节点，
b.Hashtable 线程安全实现了此接口支持序列化
区别在于：HashMap 线程不安全 Hashtable线程安全
HashMap是允许key和value为null值的 HashTable键值对都不能为空
3.String requestURI = request.getRequestURI(); 获取请求路径（除了host） String requestURI = request.getRequestURL() 获取请求全路径
request.requestURI("/web")获取 包含/web的请求路径
4.线程生命周期：初始化状态--运行状态 (实现Runnable接口 用run()方法启动用start()执行)--阻塞状态--等待状态(你在主线程里面建立了一个线程A，调用A.join()，那么你的主线程是得等A执行完了才会继续执行，这是你的主线程就是等待状态。)--终止状态
5.java序列化：需要实现java.io.serializable 接口 然后通过 ObjectOutputStream out = new ObjectOutputStream(fileOut); 序列化一个对象
FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser"); 创建一个文字字节流FileOutputStream 来创建一个文件 然后通过ObjectOutputStream进行序列化数据把这个文件中的数据
后得以读写操作
6.如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。 如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。
7.泛型就好比一种约束吧，比如集合只能传与泛型一样的类型
8.npm升级 npm install -g npm 或者升级到指定版本 npm -g install npm@5.6.0 (@ 后跟着的是指定的版本)
npm install express # 本地安装 npm install express -g # 全局安装
a.写入缓冲区 buf.write(string[, offset[, length]][, encoding])-----> 写入缓冲区 String 写入缓冲区的字符串，offset 缓冲区开始写入的索引值，默认从0开始，length 写入的字节数，默认为buffer.length
b.从缓冲区中读取数据:buf.toString([encoding[, start[, end]]]) encoding - 使用的编码。默认为 'utf8'. start - 指定开始读取的索引位置，默认为 0. end - 结束位置，默认为缓冲区的末尾。
c.将buffer 转成JSON 对象 buf.toJSON();
d.缓冲区合并 用buffer.concat();Buffer.concat(list[, totalLength]) list - 用于合并的 Buffer 对象数组列表。 totalLength - 指定合并后Buffer对象的总长度。
e.缓冲区比较 buf.compace(otherBuffer) otherBuffer 与buf 比较的另一个Buffer对象 返回的是一个数字 标识在之前还是之后或者相同 一般>0 ; 如果返回的数<0 那么otherBuffer在buf之后 ; ==0
f.创建缓冲区buffer 1.Buffer.from(array)： 返回一个被 array 的值初始化的新的 Buffer 实例（传入的 array 的元素只能是数字，不然就会自动被 0 覆盖）
2.Buffer.alloc(size[, fill[, encoding]])： 返回一个指定大小的 Buffer 实例，如果没有设置 fill，则默认填满 0
3.Buffer.allocUnsafe(size)： 返回一个指定大小的 Buffer 实例，但是它不会被初始化，所以它可能包含敏感的数据
4.Buffer.from(buffer)： 复制传入的 Buffer 实例的数据，并返回一个新的 Buffer 实例
5.Buffer.from(string[, encoding])： 返回一个被 string 的值初始化的新的 Buffer 实例
9.数据库的存储过程用 create procedure porcedureName() 业务逻辑和sql写在begin和end之间。 mysql中可用call porcedureName ();来调用过程。
删除存储过程 drop procedure if exists porcedureName
10.var readerStream = fs.createReadStream('input.txt'); 创建可读流
var writerStream = fs.createWriteStream('output.txt'); 创建一个可以写入的流
fs.createReadStream('input.txt')
.pipe(zlib.createGzip())
.pipe(fs.createWriteStream('input.txt.gz')); //压缩input.txt文件为input.txt.gz
11.node.js模块 exports 是模块公开的接口， require 用于从外部获取一个模块的接口 （首先加载缓冲区的信息--> 在加载原生模块）
a.function 方法名 {} ; module.exports = 方法名; var 名字 = require('js模块路径');(得到的是一个函数) js中定义的方法名
b.module.exports = function () {}匿名替换
c.exports.a = function () {} 导出多个变量 module.exports.a = function () {} 这样也行 功能是一样的
12.EventEmitter 绑定事件 获取事件 一般用on()方法绑定事件 然后用emit()方法获取这个绑定事件
13.Node.js 是单进程单线程应用程序
14.var http = require("http"); 获取服务 器信息模块 http.createServer(...); 服务器模块 http中有一个方法 createServer http.createServer(onRequest).listen(8888); 设置端口号 用 HTTP 服务器或客户端功能必须调用 http 模块
HTTP协议中request和response常用方法 request 客户端向后端请求数据 response 对客户端的请求做出响应
response.writeHead(第一个参数是状态码 第二个参数是数据类型 第三个参数是编码格式)
15.var pathname = url.parse(request.url).pathname; urlparse()把url拆分为6个部分，scheme(协议)，netloc(域名)，path(路径)，params(参数)分号前面就是参数，query(连接的键值对)问好后面就是查询条件，fragment(特殊锚)get类型的url #后面的就是锚点 用于定义内部的下拉位置，并且以元组形式返回。
16.util.inspect 将任意对象转换成字符串的方法
17.var fs = require("fs")文件系统APi s.readFile() 异步读取文件信息
DNS 模块用于解析域名 Domain(域) 简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的异常 Net 模块提供了一些用于底层的网络通信的小工具，包含了创建服务器/客户端的方法 path 模块提供了一些用于处理文件路径的小工具
os 模块提供了一些基本的系统操作函数
18. Express 是一个简洁而灵活的 node.js Web应用框架, 提供了一系列强大特性帮助你创建各种 Web 应用，和丰富的 HTTP 工具。
app.get('/', function (req, res) {}) 响应和处理请求 第一个参数是访问路径
express.static 中间件来设置静态文件路径 app.use('/public', express.static('public')); 将js等文件放到public目录下了
19.node.js 中有4个模块 一种原生模块和三个文件模块 首先加载文件模块的缓冲区
20.execute() function say(word) {console.log(word);} function execute(someFunction, value) {someFunction(value);} execute(say, "Hello");把 say 函数作为execute函数的第一个变量进行了传递。这里传递的不是 say 的返回值，而是 say 本身,因为 say 有一个变量， execute 在调用 someFunction 时可以传递这样一个变量。
21.__filename 将输出文件所在位置的绝对路径 __dirname 表示当前执行脚本的所在目录; setTimeout(cb, ms) 给方法设置执行时间 cd是需要执行的方法名 ms 是时间 setInterval(cb, ms) 跟setTimeout(cb, ms)一个样 区别在于前者只执行一次,后者会会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。
22.执行node.js文件 用node 文件名
23.var events = require('events'); var eventEmitter = new events.EventEmitter(); eventEmitter.on('自定义名字', 方法名); 绑定事件 eventEmitter.emit('自定义名字'); 执行事件
24.node.js post 方法 首先定义一个post变量用来暂存请求体信息 req.on('data', function(chunk){post += chunk;});通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中，req.on('end', function(){post = querystring.parse(post);res.end(util.inspect(post));});
// 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。 在这个方法中写逻辑
25.var mysql = require('mysql'); 添加数据库模块var connection = mysql.createConnection({连接数据库的基本驱动信息密码账号端口号等}); connection.connect(); 用这个连接
connection.query(sql语句,function (err, result) {执行后返回的信息}); connection.end(); 最会需要加上end方法结束
新增数据 时 sql语句 写2个 一个是SQL语句 另一个是需要添加的信息：
var addSql = 'INSERT INTO websites(Id,name,url,alexa,country) VALUES(0,?,?,?,?)';
var addSqlParams = ['菜鸟工具', 'https://c.runoob.com','23453', 'CN'];
connection.query(addSql,addSqlParams,function (err, result) {执行后返回的信息});
更新数据跟新增数据一个样只是sql改成修改的而已 删除跟查询的一样sql不一样而已
26.SpringCloud
服务消费者与服务提供者
服务消费者依赖于服务提供者
为其他服务提供服务的服务
一个人 -----> 电影票服务--->用户信息服务
一个人去买票 首先 走的是 电影票服务。电影票出票之前会到用户信息服务中去寻找这个人的信息 有的话就出票反之不出
电影票服务 就是服务消费者；用户信息服务就是服务提供者
Eureka包含两个组件 一个是注册中心 即 Eureka Server 另一个是个 java客户端Eureka Client
各个服务在启动时会向Eureka Server 注册自己的信息(ip地址,端口号,微服务名字等) Eureka Server会存储这些信息;
微服务启动以后 每隔30s向注册中心发送一次心跳即为请求之类的 证明自己还有用即为向注册中心交房租，90s注册中心未收到房租 就会注销该实例
Eureka Server也是Eureka Client 多个Eureka Server实例，互相之间通过复制的方式，来实现服务注册表中数据的同步。
Eureka Client 会缓存注册中心表中的信息，所以无需每次都去请求注册中心
创建一个springcloud项目
子类继承父类的依赖 在子类中添加一个 parent 标签 groupId artifactId version 把父类中的这三个标签复制过来即可
举个例子：
这是nqkj-cloud-master项目名就把：
<groupId>com.12316yun.cloud</groupId>
<artifactId>nqkj-cloud-master</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
复制到子类中即可
1 创建一个Maven工程 SpringBoot 项目 引入 springboot跟springcloud的jar包 这个pom文件作为父pom文件，起到一个依赖版本控制的作用其他module工程的pom文件继承此pom文件(就是把父工程中的依赖复制到此pom文件中后然后再添加其他的独有依赖)
2.创建两个model工程 一个作为注册中心 即为Eureka Server 另一个作为java客户端Eureka Client
以创建server为例子，详细说明创建过程
IDEA 创建工程 右键工程->创建model-> 选择spring initialir--->下一步->选择cloud discovery->eureka server ,然后一直下一步就行了。
3.创建完后 pom文件就继承了父pom文件(就是把父工程中的依赖复制到此pom文件中后然后再添加其他的独有依赖) 添加spring-cloud-starter-netflix-eureka-server依赖
4.修改启动类，在启动类上添加@EnableEurekaServer注解，声明这是一个Eureka Server即为注册中心。
5.添加配置类 application.yml 在其中添加几个配置：
server:
port: 8761//端口号
eureka:
instance:
hostname: localhost//ip地址
client:
register-with-eureka: false # 是否将自己注册到Eureka Server，默认为true。由于当前应用就是Eureka Server，故而设为false
fetch-registry: false # 表示是否从Eureka Sever获取注册信息，默认为true。因为这个一个单节点的Eureka Server，不需要同步其他的Eureka Server节点的数据，故而设为false
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka # 设置与Eureka Server交互的地址，查询服务和注册服务都需要依赖这个地址。
spring:
application:
name: eurka-server (配置文件名)
通过设置的service-url URL地址 进行访问即可成功表明注册中心 创建成功
6.服务提供者 Eureka Client
不同的是在启动类中将@EnableEurekaServer注解改成@EnableEurekaClient注解 证明自己是服务提供者
在配置文件中设置自己的端口号(每一个配置文件都要有不同的端口号) 以及：
spring:
application:
name: service-hi (配置文件名)这个一定要设置为以后相互调用提供方便
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/ 这个地址跟注册中心的地址一样即指向注册中心
然后启动 注册中心 就会有服务了
在微服务架构中，根据业务来拆分成一个个的服务，服务与服务之间可以相互调用（RPC），在Spring Cloud可以用RestTemplate+Ribbon和Feign来调用
A:ribbon是一个负载均衡客户端
B:Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
第一种方式：
7.新建一个springboot工程 作为服务消费者 (创建的是ribbon服务)
在pom文件中 继承父pom文件的依赖(就是把父工程中的依赖复制到此pom文件中后然后再添加其他的独有依赖)
如：spring-cloud-starter-netflix-eureka-client
spring-cloud-starter-netflix-ribbon 这几个依赖
8. 在配置中心中进行配置(跟之前的一样)
例子
server:
port: 8764
spring:
application:
name: service-ribbon (配置文件名)
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/ 这个地址跟注册中心的地址一样即指向注册中心
在启动类中添加@EnableDiscoveryClient注解表明为注册消费者
在启动类中 添加
@Bean//向ioc中注册一个bean
@LoadBalanced//负载均衡 可以访问多个端口号 表明这个restRemplate开启负载均衡的功能。
RestTemplate restTemplate() {
return new RestTemplate();
}
然后就进行测试即可 (在ribbon中它会根据服务名来选择具体的服务实例，根据服务实例在请求的时候会用具体的url替换掉服务名)
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
第二种方式
9.新建一个springboot工程 作为服务消费者(创建一个feign的服务)
在pom文件中引入
Feign的起步依赖spring-cloud-starter-feign、Eureka的起步依赖spring-cloud-starter-netflix-eureka-client、Web的起步依赖spring-boot-starter-web
配置文件跟之前的一样
server:
port: 8765
spring:
application:
name: service-feign (配置文件名)
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/ 这个地址跟注册中心的地址一样即指向注册中心
10.在启动类中加入@EnableFeignClients注解开启Feign的功能
11.测试一下：创建一个feign 接口 然后通过注解@FeignClient("服务名")来指明访问哪一个服务提供者
然后新建一个controller 来调用它即可
12.Netflix开源了Hystrix组件，实现了断路器模式
当一个请求调用多个服务是 一个服务出现故障就会导致连锁故障 当调用一个服务 5秒20次后还是掉用不了的时候 断路器就会打开
举个例子
比如 在ribbon使用断路器
首先添加断路器的依赖 spring-cloud-starter-netflix-hystrix
在启动类中加入@EnableHystrix注解开启Hystrix
在执行的方法上加一个注解 @HystrixCommand(fallbackMethod = "当无法调用服务是返回的错误信息的方法名 a") 创建一个返回错误信息的方法 a；跟如果就差不多(当无法成功调用服务时会走这个方法)
在Feign使用断路器
@FeignClient("服务名",fallback = service类.class)
service类要实现SchedualServiceHi 接口并注入到Ioc容器中
13.zuul默认和Ribbon结合实现了负载均衡的功能
Zuul的主要功能是路由转发和过滤器 其实就是一个路由或者是一个过滤器用于安全监测
新建一个springboot 项目工程
pom文件在复制了父文件后 添加几个自己独有的依赖如：spring-cloud-starter-netflix-zuul
在启动类中添加@EnableZuulProxy，开启zuul的功能
在配置文件中添加配置文件：
例子：
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka/
server:
port: 8769
spring:
application:
name: service-zuul
zuul:
routes:
api-a:
path: /api-a/** //以这个开头的就走service-ribbon
serviceId: service-ribbon
api-b:
path: /api-b/** 以这个开头的 就走service-feign
serviceId: service-feign
zuul不仅只是路由，并且还能过滤，做一些安全验证
继承ZuulFilter 类 会有几个方法
1.filterType 返回字符串类型 可以返回四种类型
pre：路由之前
routing：路由之时
post： 路由之后
error：发送错误调用
filterOrder：过滤的顺序
shouldFilter：这里可以写逻辑判断，是否要过滤，本文true,永远过滤。
run：过滤器的具体逻辑。可用很复杂，包括查sql，nosql去判断该请求到底有没有权限访问。
14.在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件(就是管理配置文件的)
分布式配置中心组件spring cloud config 可以放到本地 也可以的放到git仓库中
分为两种 一是config server，二是config client。
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
构建Config Server 配置服务中
创建一个springboot pom文件在复制了父文件后 添加自己独有的依赖文件 如：spring-cloud-config-server
在启动类中添加注解@EnableConfigServer注解开启配置服务器的功能
添加配置文件
例子：
spring.application.name=config-server
server.port=8888
//如果在git仓库中时需要添加以下配置
然后添加以下配置
spring.cloud.config.server.git.uri：配置git仓库地址
spring.cloud.config.server.git.searchPaths：配置仓库路径
spring.cloud.config.label：配置仓库的分支
spring.cloud.config.server.git.username：访问git仓库的用户名
spring.cloud.config.server.git.password：访问git仓库的用户密码
构建config client
新建一个springboot工程添加pom文件
bootstrap.properties添加其配置文件
spring.cloud.config.label 指明远程仓库的分支
spring.cloud.config.profile
dev开发环境配置文件
test测试环境
pro正式环境
spring.cloud.config.uri= http://localhost:8888/ 指明配置服务中心的网址。
进行测试 结果得出config-client从config-server获取了foo的属性，而config-server是从git仓库读取的
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
config-client 与 Eureka Client 是一个东西 都是客户端服务
当有很多服务都从配置中心中获取配置信息是 把配置中心做成多个服务 其实意思就是把 配置中心 跟 注册中心 服务提供者 服务消费者 合起来
首先在配置中心pom文件中 加上spring-cloud-starter-netflix-eureka-client 依赖
在配置中心中添加一个配置 eureka.client.serviceUrl.defaultZone=http://localhost:8889/eureka/ //配置的是注册中心的地址
在启动类中添加注解@EnableEureka
从创建config-client 的springboot项目pom文件中添加依赖
spring-cloud-starter-netflix-eureka-client
配置中心中 添加eureka.client.serviceUrl.defaultZone //配置的是注册中心的地址
spring.cloud.config.discovery.enabled 是从配置中心读取文件。
spring.cloud.config.discovery.serviceId 配置中心的servieId，即服务名。
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
Spring Cloud Bus 将分布式的节点用轻量的消息代理连接起来 它可以用于广播配置文件的更改或者服务之间的通讯，也可以用于监控。本文要讲述的是用Spring Cloud Bus实现通知微服务架构的配置文件的更改。
下载 rabbitMq
创建一个springboot文件 pom文件中添加spring-cloud-starter-bus-amqp依赖
然后在配置文件中添加RabbitMq 的相关配置RabbitMq的地址、端口，用户名、密码。并需要加上spring.cloud.bus的三个配置，具体如下：spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.cloud.bus.enabled=true
spring.cloud.bus.trace.enabled=true
management.endpoints.web.exposure.include=bus-refresh
主要作用是打到类似热部署的效果
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
Spring Cloud Sleuth 主要功能就是在分布式系统中提供追踪解决方案
构建server-zipkin
下载jar包java -jar zipkin-server-2.10.1-exec.jar 并运行
创建springboot项目 在pom文件中添加依赖 spring-cloud-starter-zipkin
第二步在其配置文件application.yml指定zipkin server的地址，头通过配置“spring.zipkin.base-url”指定举个例子：
server.port=8988 端口号
spring.zipkin.base-url=http://localhost:9411 注册中心的ip地址及端口号
spring.application.name=service-hi 配置文件的配置名
<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
地区编号：2位省；4位市；6位区；9县/镇；12村/社
27.shiro 三个核心组件：Subject, SecurityManager 和 Realms.
第一步 添加相关依赖 shiro-spring-boot-web-starter这个依赖中包含了web所需要的依赖 thymeleaf这个是页面模板的依赖，一般需要使用到 thymeleaf-extras-shiro这个是thymeleaf中引入shiro标签的依赖
第二步 创建一个项目,创建一个类作为配置类，加注解@configrtion注解
第三步 配置类中写三个方法
1.shiroFilterFoctoryBean
2.Defaultwebsecaritymanager
3.Realm （此方法需要独自创建一个 之后会在这里调用）
第四步 创建Realm类 这个类让他继承AuthorizingRealm方法
继承之后会出想两个方法 一个是认证；一个是授权
第五步 在 shiroFilterFoctoryBean 中写一些 拦截器过滤器之类的东西
常用的一些有：anon 无拦截所有都可以访问
authc 必须认证才可以访问
user 如果使用remberMe的功能才可以访问
perms 该资源必须得到资源授权才可以访问 -->资源授权
role 该资源必须得到角色授权才可以访问 -->角色授权
举个例子：
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("login", "anon"); 第一个是文件 第二个是拦截属性
28 redis+springboot的整合 springboot redis 项目实战 完整篇 - 简书
第一步：创建springboot项目 添加redis 相关jar包
第二步：设置配置文件 如：
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000
因为自动配置RedisTemplate 不能实例化 所以自己写一个配置类
第三步：设置redis配置类 添加连个配置类@Configuration通过这个注解注明此类为配置类
@EnableCaching 通过这个注解开启redis
创建RedisTemplate对象
RedisTemplate redisTemplate = new RedisTemplate();
template.setConnectionFactory(RedisConnectionFactory);配置redis连接工厂
进行序列化操作
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
// 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);
// 值采用json序列化
template.setValueSerializer(jacksonSeial);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
// 设置hash key 和value序列化模式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();
设置redis工具类
其中的接口方法 其实就是redis的一些封装好的命令。
29 springboot+mybatis的整合
添加mybatis的jar包
在配置文件中添加mybatis的配置信息 数据源等
写一个接口 作为mapper的接口
写一个xml文件作为 mapper.xml文件 写sql的
在启动类中添加扫描直接@ComponentScan 对mapper进行扫描
30 客户端发送请求之后 服务端通过 HttpServletRequest 和 HttpServletResponse 获取客户端传过来的信息
HttpServletRequest 获得请求中的参数，这些参数一般是客户端表单中的数据
HttpServletResponse 向客户端相应数据，发送一些信息到客户端
举个例子：
@RequestMapping(value = "/showDataMetaConfig.afmmd")
public String showDataMetaConfig(HttpServletRequest request,HttpServletResponse response){
return "/metaConfig/dataMetaRegConfig";
}
@Action指定一个类为action
Struts2中的一个直接 定义一个 Action 跟url差不多
@Action(value = "testAction",results = {@Result(name="success",location="/success.jsp")})
testAction ：
Action 名字
results：
返回的结果集属性
interceptorRefs：
配置拦截器
@Result：
配置详细的返回结果
success
返回值
location：
返回到的地址
type：
type属性
results是用来声明多个结果集 就是可以在results里面写多个@result
@Results是用来声明多个结果集；@Result配置详细返回结果。
@Result能够在类上声明，假设在类上声明，那么就是全局的
@WebServlet注解用于标注在一个继承了HttpServlet类之上，属于类级别的注解。
继承了HttpServlet的类需要写两个方法 doGet();doPost()
springMVC的新特性
@GetMapping，处理get请求
@PostMapping，处理post请求
@PutMapping，处理put请求
@DeleteMapping，处理delete请求
struts2获取实体类
最好的方法就是实现ModelDriven方法 然后走getModel()方法 获取实体类
request.getParameter()方法是获取通过类似post，get等方式传入的数据，即获取客户端到服务端的数据，代表HTTP请求数据。
request.setAttribute()方法是将request.getParameter()方法获取的数据保存到request域中，即将获取的数据重新封装到一个域中。
request.getAttribute()方法是返回在request.setAttribute()封装的域中存在的数据。
在前端使用java语言时要加上：
<%xxxx%>
用作属性的时候要这样写：
<%=xxxx%>作为属性的时候
json之间的转换使用组件来完成的，一般用fastjson这个即可
ajax 是异步传输 from表单中的action属性 是同步传输 区别就在这
其中ajax 也可以设置成同步传输 true 与false 的区别而已
request.setAttribute(“curruser”,curruser)
User myuser =
<%(User)request.getAttribute("curruser")%>
在页面显示的话 就用<%=myuser.getName()%>
31 javaWeb 项目 不是maven项目 再导入svn时 会报错 一般解决报错问题的步骤：
右键项目--Build path ---- Configure Build path --- java Build path ---- Libraries ---- 添加tomcat 然后删除jdk 重新导入一遍 Apply 一下即可
32 StringUtils 工具类 共有130多个的方法 都是静态方法 静态方法可以直接调用，非静态方法需要创建对象然后调用
33 成员变量有默认初始值，局部变量没有默认初始值 使用变量遵循一个就近原则，先从方法中找然后再从类中找
变量分为 成员变量 跟局部变量 成员变量 分为类变量(静态变量) 实例变量
34.当 DOM（文档对象模型） 已经加载，并且页面（包括图像）已经完全呈现时，会发生 ready 事件 就是加载完了之后 会走ready事件
当发生ready事件的时候执行此方法 Zepto.js是手机端的知识
Zepto(function($){
alert('Ready to Zepto!')
})
@RequestParam 将指定的参数赋值给当前方法的形参
35.springMvc 创建项目：创建maven项目 pom添加相关依赖。新建
web.xml文件: listener-class 配置
request.setCharacterEncoding("utf-8"); 处理post请求是乱码问题
或者用过滤器：springmvc 中在web.xml文件中添加以下配置
<filter>
<filter-name>charsetFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
springMVC是spring的框架的一个模块，是基于MVC框架的web框架
springMVC 的工作流程：
a.客户端发送请求。
b.前端控制器 DispatcherServlet 接收请求，并调用HandlerMapping映射器
c.映射器找到具体的处理器进行处理，生成处理器对象Handler以及拦截器
d.前端控制器DispatcherServlet调用适配器 HandlerAdapter。适配器调用相应的处理器生成ModelAndView，并返回 ModelAndView 对象(ModelAndView是springMVC的一个底层对象 包括Model；View)
e.适配器HandlerAdapter将ModelAndView返回给前端控制器DispatcherServlet
f.前端控制器DispatcherServlet 将ModelAndView 传给视图解析器ViewReslover 视图解析器进行解析返回View
g.前端控制器DispatcherServlet 根据View渲染视图，传给用户
HandlerMapping映射器的作用是通过getHandler 获取请求的handler(处理器对象)与Interceptors(拦截器)，继承了一个抽象类AbstractHandlerMapping
java中当使用 "+" 连接字符串的时候,编辑器会自动引入spring.lang.Stringbuilder类，编辑器会创建Stringbuilder对象，并为每个字符串调用一次append()方法
在使用循环连接字符串的时候，因为每次进入循环都会创建stringbuilder对象，所以处理方法就是自己创建一个stringbuilder对象调用append()方法
string 是final类所以不能被继承 string类是通过数组的形式来保存字符串的，
对string对象的任何改变都不会影响原对象，因为在改变对象时会重新生成新的字符串对象
Stringbuilder 是在原有的对象上进行改变的
StringBuffer线程安全
方法名首字母必须大写
git 是分布式的 svn不是 git 是按元数据方式存储，svn是按文件
36.MultipartFile工具类 文件上传用的 多文件上传 MultipartFile file;多文件上传 MultipartFile[] file 判断文件是否为空：!file.isEmpty() -- 不为空
String filePath = request.getSession().getServletContext().getRealPath("/")+ "upload/" + file.getOriginalFilename(); 获取文件保存路径
file.transferTo(new File(filePath));转存文件
file.getOriginalFilename()； 上传文件的原名
37.substring(start,stop) 用来截取字符串的 start 提取字符串的第一个开始位置 非负整数 stop 结束位置 如果不写直接截取到字符串结尾 提取的子串的最后一个字符在 stringObject 中的位置多 1。
indexOf 和 lastIndexOf 区别在于 前者从前往后查(即为从左向右);后者从后往前查(即为从右往左查)虽然是从右往左查 但是位置的下标还是从前向后的
38.split() 方法用于把一个字符串分割成字符串数组
var str = data.split(',');当遇到逗号就分割
39.align-items 纵向位置 align-items：center 即为上下居中 div会显示在中心
40. 设计模式的六大原则：开闭原则 里氏代换原则 依赖倒转原则 接口隔离原则 迪米特法则 合成复用原则
41.jdbc连接数据库步骤：1.获取数据库连接的参数 2加载驱动 class.forName(driver) 3 创建数据库的连接 Connection con = DriverManager.getConnection(url, user, password); 4要执行SQL语句，必须获得java.sql.Statement实例
执行动态SQL语句。通常通过PreparedStatement实例实现 PreparedStatement pst = conn.prepareStatement(sql); 5.执行sql语句 pst.其中的方法 比如 pst.executeUpdate(); 修改的方法
42.isBlank 判断某字符串是否为空或者长度为0 或者有空白符构成如 (" ") 如果是空 返回true; 不为空 返回 false
isEmpty 判断某字符串是否为空 为空的标准是str==null或str.length()==0
43.Mybatis 的优点；与spring能更好的集成；很好的与各种数据库连接(Mybatis中封装了JDBC) sql写在Xml里解除sql与程序代码的耦合 便于统一管理
缺点： 依赖于数据库 不能随便更换数据库，sql编写工作量较大
44. ${} 与 #{} 的区别 前者是字符串替换 编译时会把 ${} 替换成变量 #{} 会替换成 ？占位符 调用PreparedStatement set方法赋值
45. JSON.stringify() 将json转换成json字符串 JSON.parse() 将json字符串转换成json对象
46.maysql 是关系型数据库 开源的不需要费用
start transaction 或者 begin开始一个事务 要么commit 提交将修改的数据持久保存 要么rollback 撤销所有的修改
47 SpringCache缓存功能的实现是依靠下面的这几个注解完成的。
@EnableCaching：开启缓存功能
@Cacheable：定义缓存，用于触发缓存
@CachePut：定义更新缓存，触发缓存更新
@CacheEvict：定义清除缓存，触发缓存清除
@Caching：组合定义多种缓存功能
@CacheConfig：定义公共设置，位于class之上
spring核心文件中 由-javadoc个的为帮助文档 -sources 为源码 什么也不带的为jar包
自定义的Realm需要集成AuthorizingRealm 其中实现两个方法 一个是授权的方法GetAuthorizationInfo ；GetAuthenticationInfo一个是认证的抽象方法
loginUrl ：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
successUrl ：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。
unauthorizedUrl ：没有权限默认跳转的页面
getBytes()将String字符串转换成字节数组byte
一般情况下UsernamePasswordToken已经可以满足我们的大我数需求。当我们遇到需要声明自己的Token类时，可以根据需求来实现AuthenticationToken，HostAuthenticationToken或RememberMeAuthenticationToken。
如果不需要“记住我”，也不需要“主机验证”，则可以实现AuthenticationToken；
如果需要“记住我”，则可以实现RememberMeAuthenticationToken；
如果需要“主机验证”功能，则可以实现HostAuthenticationToken；
如果需要“记住我”，且需要“主机验证”，则可以像UsernamePasswordToken一样，同时实现RememberMeAuthenticationToken和HostAuthenticationToken。
一般情况下UsernamePasswordToken已经可以满足我们的大我数需求。当我们遇到需要声明自己的Token类时，可以根据需求来实现AuthenticationToken，HostAuthenticationToken或RememberMeAuthenticationToken。
如果不需要“记住我”，也不需要“主机验证”，则可以实现AuthenticationToken；
如果需要“记住我”，则可以实现RememberMeAuthenticationToken；
如果需要“主机验证”功能，则可以实现HostAuthenticationToken；
如果需要“记住我”，且需要“主机验证”，则可以像UsernamePasswordToken一样，同时实现RememberMeAuthenticationToken和HostAuthenticationToken。
你所知道的微服务技术栈？
维度(springcloud)
服务开发：springboot spring springmvc
服务注册与发现:Eureka,Zookeeper
服务路由（API网关）Zuul
消息队列:Kafka
服务配置 阿里的Diamond
负载均衡的意义是什么?
在计算中，负载均衡可以改善计算资源负载 网络链接 ，避免一些资源的过载
微服务之间是如何独立通讯的?
消息中间件
远程调用 feign
服务发布时 将指定的服务名 注册到注册中心上去
注册中心加@EnableEurekaServer 服务用@EnableDiscoveryClient 然后用feign 什么的调用
.Eureka和Zookeeper区别
eureka本质是一个工程，Zookeeper只是一个进程。
.eureka自我保护机制是什么? 当Eureka Server节点在短时间内丢失了过多实例的连接时（比如网络故障或频繁启动关闭客户端）节点会进入自我保护模式，保护注册信息，不再删除注册数据，故障恢复时，自动退出自我保护模式。
什么是服务熔断？什么是服务降级?
服务熔断：相当于保险丝，出现某个异常，直接熔断整个服务，而不是一直等到服务超时。通过维护一个自己的线程池，当线程到达阈值的时候就启动服务降级，如果其他请求继续访问就直接返回fallback的默认值。
ribbon是一个负载均衡客户端
feigin 采用接口注解 具有堵在均衡的能力 加依赖 启动类加注解 @EnableFeignClients 在接口@FeignClient(name=“xxx”)指定调用哪个服务
Ribbon和Feign的区别？
Ribbon是@RibbonClient feign的是@EnableFeignClients
微服务架构中，需要几个基础的服务治理组件
注册中心 负载均衡 配置管理 路由 断路器
进程有独立的地址空间 线程没有独立的地址空间 线程是某个进程的执行路径，多进程比多线程的程序健壮 进程是资源分配的最小的单位，线程是cpu调度的最小单位进程之间的切换比线程大
BeanFactory和ApplicationContext有什么区别？
BeanFactory和ApplicationContext 是spring的两大核心接口
ApplicationContext是BeanFactory 的子接口
ApplicationContext在容器启动时就创建所有的bean，BeanFactory 采用延迟加载 调用getbean方法是才会创建bean
BeanFactory用编程的方式出创建，ApplicationContext可以用声明的方式创建ContextLoaderListener
aop术语
目标类 需要代理的类
连接点 可能被拦截的方法
切入点 已经被拦截的方法（已经被增增强的连接点）
织入 将通知引用到目标对象中
通知 增强的代码
代理类 目标类与通知的结和
切面类 切入点与通知的结合
bean的生命周期
初始化
依赖注入
处理一些aware接口
如果bean在spring配置文件中配置了 init-method 属性，会自动调用初始化方法
如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。
微服务 开发效率高一个服务聚焦于一件事 松耦合 有功能意义的服务如 spring-cloud-config 配置 易于第三方集成 可以用不同语言开发，面向接口编程 一个服务聚焦于一件事 可以部署在一个或多个服务器上
多服务运维难度加大 操作比较多很繁琐 服务多了管理比较复杂
springcloud 是基于springBoot的spring集成应用程序 提供与外部系统的集成
Spring Cloud Task 给springboot 应用程序提供创建短期运行的微服务功能
springcloud与dubbo的区别 springcloud 的注册中心是eureka(you wei ka) dubbo zookeeper (zu kei po)
springcloud 与git完美集成 springcloud 的网关是Zuul dubbo 需要集成第三方技术
jvm是Java虚构的计算机 有自己的指令 堆栈内存 xms 堆内存的初始值 xmx是堆内存的最大值
内存值得是什么；
jvm 结构由 堆内存和非 堆内存组成 堆内存是运行时存的是实例对象 非 堆内存一般村的是final 静态变量 构造方法
垃圾回收
当实例化一个对象的时候会再 堆 分配一个内存 当对象不被使用后 jvm自动回收 降低内存溢出风险 垃圾回收 算法有两种 一是引用记数 创建对象 使用时记数增加 当引用为null 或超出作用域范围计数减少 当为0时 回收 二是引用遍历 遍历从根对象到最后整个对象图 进行标记 。再通过扫描整个堆栈处理不可到达的对象
根对象就是垃圾回收器 能够访问的对象
Spring启动过程
1 web 应用启动的时候 会创建ServletContext对象 是以key-value 方式存储的 然后 读取web.xml文件 其中配置了一个ContextLoaderListener 调用contextInitialized()方法 这个方法当中调用了initWebApplicationContext()这个方法 此方法 初始化WebApplicationContext ioc容器 是一个接口类 实现的时XmlWebApplicationContext
initWebApplicationContext方法 用getServletContext获取ServletContext作为形参传到方法当中 然后通过key判断是否由此实例没有就通过 然后调用createWebApplicationContext()方法 创建实例 并存到ServletContext中 这个方法通过 BeanUtils.instanceClass()方法创建实例
spring是什么；
spring 是一站式的 分层的轻量级的开源框架
spring的优点是什么；
1spring对于主流的应用框架提供了集成支持。
2 spring aop 允许将一些通用的任务 集中管理
3 spring orm dao 提供与第三方框架的良好整合
4 spring 中的di 降低了业务替换的负责性
什么是依赖注入
在ioc容器运行期间 动态的将所需要的以来注入到对象当中
spring IOC 的注入方式
set注入
就是通过get set 方法注入 set集合注入就是传概念多个property
set 自动注入 由 byname bytype byname通过property name进行注入 ； bytype 通过set方法中的参数注入
构造器注入 分为 下标注入 属性的数据类型注入
注解注入： @Autowired 默认按照byType匹配的方式进行注入,如果没有一个bean的类型是匹配的则会抛异常,如果有多个bean的类型都匹配成功了,那么再按byName方式进行选择
@Resource的作用和@Autowired差不多,只不过 @Resource是默认先用byName,如果找不到合适的就再用byType来注入
@Component
Spring支持的几种bean的作用域。
singleton
prototype
request
session
什么是控制反转
以前创建对象需要自己手动new一个对象 现在将创建对象的控制权交由ioc容器来管理 将对象之间的依赖关系交给ioc容器管理 并完成对象之间的注入
对象与对象之间没有任何关系 他们通过ioc容器连接 控制权在ioc容器这
优点：简化应用开发 ioc采用了工厂模式 spring对于主流的应用框架提供了集成支持。单例模式
什么是aop面向切面编程
将一些公用的任务 代码块 配置等独立出来 进行封装
优点就是 便于管理 减少代码 降低耦合性 便于维护
java 当中说的上下文就是执行环境 你就相当于web程序，家就相当于web程序的上下文，你可以在家里放东西，也可以取东西，你的衣食住行都依赖这个家，这个家就是你生活的上下文环境。
WebApplicationContext的实现类名称则通过determineContextClass()方法获得 这个方法中通过defaultStrategies.getProperty()获取实现类的名称 defaultStrategies 是ContextLoader.properties 配置的
^ 异或 意思就是 符号两边的数先转化成二进制 然后从高位一个数一个数比较 相同就些0 不相同就些1
8转为二进制是1000，11转为二进制是1011.从高位开始比较得到的是：0011.然后二进制转为十进制，就是Integer.parseInt("0011",2)=3;
二进制为8位数 没有的前面补0 2的二进制为10 前面补0 00000010 16 >>> 3 16分别除以3个2后 进行二进制运算
Hash值=（hashcode）^(hashcode >>> 16) 数组下标计算 hash&(16-1) = hash%16
&：都是1，结果才是1
^：一个1一个0，结果是1
|：只要有1，结果是1
十进制转16进制 把数除以16 直到商为0 为止 以倒序的方式排列 即可 120 / 16 =7---8 8/16--0---7 16进制 78
十进制转二进制 11／2得5余1 5／2得2余1 2／2得1余0 1／2得0余1 二进制1 0 1 1
3%5==3 余 数 3除以5取余数
HashMap 是以数组的形式存储 引入 Hash 算法又导致了 Hash 冲突 当出现Hash冲突时会在冲突的地方转为链表形式存储 key值 时通过Hash算法计算出的 , 将 key 映射成数组下标 数组上的链表长度超过 8 之后转而将链表转变成红黑树 当红黑树只有6个节点 就会改为链表
为什么要用hashMap 因为hashMap是存储简直对的容器 不需要单独解决如何将健与值对应起来
HashMap是基于hashing的原理 我们使用put() 方法传入数据 利用 get() 方法获取数据 在传入数据的时候 调用put()方法会调用hashcode()方法 对key只进行hash值运算 获取一个下标 然后通过这个下标将value 放到指定位置 如果冲入 就利用链表形式存储 在 下标当前位置假next 然后一个箭头 指向另一个 位置 把多出的放到其中 超过8 采用红黑树形式 分叉储存
用户发送给请求到前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器
处理器映射器找到具体的处理器（注解或者xml配置），生成处理器对象以及处理器拦截器（若有），返回给DispatcherServlet
DispatcherServlet调用HandlerAdapter处理器适配器
HandlerAdapter经过适配调用具体的处理器（Controller）
Controller执行完成返回ModelAndView
HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet
DispatcherServlet将ModelAndView传给ViewReslover视图解析器
视图解析器解析后返回具体的View
DispatcherServlet根据View进行渲染视图（将模型数据填充到视图）
DispatcherServlet响应用户
HandlerAdapter处理器适配器：按照规则去执行Handler
HandlerMapping处理器映射器：根据url来寻找Handler，可以用配置文件方式、注解等
Handler处理器：这个就是我们写的东西了，就是业务需求
view是视图对象 jsp
springboot starter 是一个第三方类库集合 通过 springboot starter web 引入 引入的库有：aop springMvc json序列化 tomcat 日志框架之类的
假如对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上 由于IOC容器的加入，对象A与对象B之间失去直接联系。当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。
对象A获得依赖对象B的过程,由主动行为变为被动行为，控制权颠倒过来，这就是"控制反转"这个名称的由来。
依赖注入，就是由IOC容器在运行期间，动态地将对象某种依赖关系注入到对象之中。
我有坐车的需求，告诉滴滴平台我什么时间点需要什么样子的车，滴滴平台召集司机端的司机，根据我需要的要求分配一辆车给我。 这样子就很好解释Ioc,滴滴平台做为Ioc,我和司机就是Ioc的对象或bean。
Spring中提供两种IoC容器 BeanFactory ApplicationContext应用上下文
pring Boot Starter Parent 是应用程序的父项目 统一管理版本 之类的信息
BeanFactory 加载以后 等到调用getBean方法才会抛出异常 ApplicationContext则在初始化自身是检验这样有利于检查所依赖属性是否注入
Spring Beans 是spring的核心对象 spring中的bean 都是单例的 要想为原型bean bean注解中有一属性性singleton
hashMap 扩容 当需要添加的数据下标大于等于数据长度 并且 数组中的位置为null（即为链表形式存储 将信息存到链表出来的位置 数组中的为值为null） 是才会扩容 扩容就是重新new一个数组 然后执行双重循环第一重循环数组长度 第二重循环链表的长度 然后的得到数组下标填到新的数组中去 从而实现扩容
HashMap 死循环 是指线程1 跟线程2 线程1 先循环扩容 扩容完之后 线程2 开始 就会形成
链表 查询慢 插入快 树插入快 查询慢 红黑树
jdk8 中 当链表中的位置是最后一个 就把这个数放到这个下标位置
什么是hashcode Java虚拟机每new Object() 一个对象（创建对象时都会将这个Object 放到hash表中去 当取得时候会依据hashcode来取 提高获取对象的效率）
1、Spring是什么?
spring时一个轻量级ioc aop容器框架 是Java应用程序提供基础服务的一套框架 开发者只需要关心业务需求即可 主要由几个模块组成分别为
spring MVC 提供面向Web应用的Model-View-Controller实现。
spring AOP AOP服务
Spring DAO：对JDBC的抽象，简化了数据访问异常的处理；
Spring ORM：对现有的ORM框架的支持；
Spring Web：提供了基本的面向Web的综合特性，例如多方文件上传；
Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；
Spring Core：核心类库，提供IOC服务；
2、Spring 的优点？
spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性；
Spring提供了AOP技术，支持将一些通用任务，进行集中式管理，从而提供更好的复用。
spring对于主流的应用框架提供了集成支持。
jdk8 hashMap 有哪些改动 hash 算法 红黑树 链表节点添加 扩容机制
便利集合 迭代循环遍历
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");
Iterator<String> ite=list.iterator();
while(ite.hasNext())//判断下一个元素之后有值
{
System.out.println(ite.next());
}
垃圾回收机制：标记删除 中由两个部分 一个是 垃圾回收器collector ;垃圾回收器以外的部分 一些应用程序主要作用 创建对象 读写内存内容 mutator 垃圾货收器会从mutator 根对象（可以被垃圾回收器访问到的对象 存在最之外 一般是 静态变量 或者全局变量）遍历 每一个从根对象可以访问到的 就会被标记 垃圾回收器遍历 最内存 没有标记的就会被回收 然后把标记的 数据上的标识删除
堆 栈
堆是指程序运行时申请的动态内存 堆是在程序运行时，而不是在程序编译时，申请某个大小的内存空间
所有通过new创建的对象的内存都在堆中分配
栈 一种运算受限的线性表 仅允许在表的一端进行插入和删除运算
栈就是一个桶，后放进去的先拿出来，它下面本来有的东西要等它出来之后才能出来（即先进后出）
堆 存放在二级缓存 由jvm 的垃圾回收机制 来进行出来 栈存在以及缓存 调用时获取内存 调用完毕释放内存
新生代 老年代
新生代 新创建的对象就是新生代 一般用复制算法 老年代是那些多次标记还存在的对象为老年代 用标记删除
map就是用于存储键值对（<key,value>）的集合类 hashmap 就是利用好数组链表红黑树来实现map类
spring 容器 可以分为五个范围 singleton 每一个bean 只有一个实例 prototype 为每一个bean 都创建一个实例 request 为每一个网络请求创建一个bean 在请求完成以后，bean会失效并被垃圾回收器回收 session 确保内一个session 都有一个实例 在请求完成以后，bean会失效并被垃圾回收器回收
spring框架是线程安全的吗
一般是 因为每一个bean 只有一个实例 状态是不可动态改变的 如果有多个状态的话 就为每一个bean 添加一个实例
Spring通知有哪些类型？前置通知 在某连接点执行前通知 返回后通知 在某连接点正常完成后执行的通知 抛出异常后通知 抛出异常后通知 后通知 在某个节点退出后通知 环绕通知 在调用方法前后执行通知
spring aop 几个名词 连接点 一个连接点 值得是一个方法 通知 一个连接点上所执行的动作 切入点 对某个连接点 进行拦截
切入点 与 连接点 是aop的关键
Spring 提供了以下5中标准的事件： 上下文更新事件 上下文开始事件调用Start()方法开始 上下文停止事件调用stop()方法停止 上下文关闭事件 请求处理事件
spring 的设计模式 单例模式 spring配置文件定义的bean就是一个单例的 工程模式BeanFactory 创建对象的实例
事务具备ACID四种特性，ACID是Atomic（原子性）、Consistency（一致性）、Isolation（隔离性）和Durability（持久性）
Spring事务机制主要包括声明式事务和编程式事务。
StringBuilder 数组容量为16
数据库账号 数据库名 需要保存的位置以及文件名
数据备份 mysqldump -u root -p bank > d://mysql_all.sql
恢复数据 创建数据库 create database bank
选中数据库 use bank 数据库的名字之前备份的
恢复数据库 source d://mysql_all.sql
高并发问题
在表中加一个字段 version 或者 自动更新的时间字段timestamp
没修改一条数据 version 就加1 然后判断 判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对 如果相同就修改反之不修改 或者 检查当前数据库中数据的时间戳和自己更新前取到的时间戳进行对比 如果相同就修改反之不修改
update task set value = newValue,version = versionValue + 1 where version = versionValue;
多线程与高并发的区别
多线程 对应cpu
高并发 对应访问请求 可以单线程 也可以多线程
并发变成三要素 原子性 一个操作 要么全部执行成功 要么全部失败 有序性 程序执行的顺序按照代码的先后顺序执行 可见性 程序执行的顺序按照代码的先后顺序执行
线程的5大状态：创建 就绪 运行 阻塞 死亡
thymeleaf常用配置：
#spring.thymeleaf.cache = true ＃启用模板缓存。
#spring.thymeleaf.check-template = true ＃在呈现模板之前检查模板是否存在。
#spring.thymeleaf.check-template-location = true ＃检查模板位置是否存在。
#spring.thymeleaf.content-type = text / html ＃Content-Type值。
#spring.thymeleaf.enabled = true ＃启用MVC Thymeleaf视图分辨率。
#spring.thymeleaf.encoding = UTF-8 ＃模板编码。
#spring.thymeleaf.excluded-view-names = ＃应该从解决方案中排除的视图名称的逗号分隔列表。
#spring.thymeleaf.mode = HTML5 ＃应用于模板的模板模式。另请参见StandardTemplateModeHandlers。
#spring.thymeleaf.prefix = classpath：/ templates / ＃在构建URL时预先查看名称的前缀。
#spring.thymeleaf.suffix = .html ＃构建URL时附加到查看名称的后缀。
#spring.thymeleaf.template-resolver-order = ＃链中模板解析器的顺序。
#spring.thymeleaf.view-names = ＃可以解析的视图名称的逗号分隔列表。/ templates / ＃在构建URL时先查看名称的前缀。
#spring.thymeleaf.suffix = .html ＃构建URL时附加到查看名称的后缀。
#spring.thymeleaf.template-resolver-order = ＃链中模板解析器的顺序。
#spring.thymeleaf.view-names = ＃可以解析的视图名称的逗号分隔列表。/ templates / ＃在构建URL时先查看名称的前缀。
#spring.thymeleaf.suffix = .html ＃构建URL时附加到查看名称的后缀。
#spring.thymeleaf.template-resolver-order = ＃链中模板解析器的顺序。
#spring.thymeleaf.view-names = ＃可以解析的视图名称的逗号分隔列表。
## Redis 配置
## Redis数据库索引（默认为0）
spring.redis.database=0
## Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=6379
## Redis服务器连接密码（默认为空）
spring.redis.password=
## 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
## 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
## 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
## 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
## 连接超时时间（毫秒）
spring.redis.timeout=1200
ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作
request.getRequestURL() 返回全路径
request.getRequestURI() 返回除去host（域名或者ip）部分的路径
request.getContextPath() 返回工程名部分，如果工程映射为/，此处返回则为空
request.getServletPath() 返回除去host和工程名部分的路径
String queryString = request.getQueryString();
上面这句话的意思是：获取查询字符串。
http://localhost/test.do?a=b&c=d&e=f
通过request.getQueryString()得到的是
a=b&c=d&e=f
（1）anon：匿名过滤器，表示通过了url配置的资源都可以访问，例：“/statics/**=anon”表示statics目录下所有资源都能访问
（2）authc：基于表单的过滤器，表示通过了url配置的资源需要登录验证，否则跳转到登录，例：“/unauthor.jsp=authc”如果用户没有登录访问unauthor.jsp则直接跳转到登录
（3）authcBasic：Basic的身份验证过滤器，表示通过了url配置的资源会提示身份验证，例：“/welcom.jsp=authcBasic”访问welcom.jsp时会弹出身份验证框
（4）perms：权限过滤器，表示访问通过了url配置的资源会检查相应权限，例：“/statics/**=perms["user:add:*,user:modify:*"]“表示访问statics目录下的资源时只有新增和修改的权限
（5）port：端口过滤器，表示会验证通过了url配置的资源的请求的端口号，例：“/port.jsp=port[8088]”访问port.jsp时端口号不是8088会提示错误
（6）rest：restful类型过滤器，表示会对通过了url配置的资源进行restful风格检查，例：“/welcom=rest[user:create]”表示通过restful访问welcom资源时只有新增权限
（7）roles：角色过滤器，表示访问通过了url配置的资源会检查是否拥有该角色，例：“/welcom.jsp=roles[admin]”表示访问welcom.jsp页面时会检查是否拥有admin角色
（8）ssl：ssl过滤器，表示通过了url配置的资源只能通过https协议访问，例：“/welcom.jsp=ssl”表示访问welcom.jsp页面如果请求协议不是https会提示错误
（9）user：用户过滤器，表示可以使用登录验证/记住我的方式访问通过了url配置的资源，例：“/welcom.jsp=user”表示访问welcom.jsp页面可以通过登录验证或使用记住我后访问，否则直接跳转到登录
（10）logout：退出拦截器，表示执行logout方法后，跳转到通过了url配置的资源，例：“/logout.jsp=logout”表示执行了logout方法后直接跳转到logout.jsp页面
String str = new String("abc");
String str = "abc";
第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。
而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。
== 变量内存存放对象内存地址 用来判断两个对象地址是否相同
redis.conf配置详细解析 - 太清 - 博客园 redis.conf配置文件的解释
数据库的一些命令方法
show databases;查询所有数据库
CREATE TABLE 创建数据库
show create table 表名 查看建表语句
DROP TABLE 删除表
CHARSET 设置编码格式
show tables; 查询数据库所有表
alter table 表名 add column 字段名 字段类型 加列
alter table 表名 modifycolumn 字段名 字段类型 修改列
alter table 表名 drop column 字段名 字段类型 减列
create 索引类型 （普通索引 唯一索引 主键索引 组合索引）索引名 on 表名(字段名 字段类型);
alter table 表明 add 索引类型 （普通索引 唯一索引 主键索引 组合索引）索引名(字段名 字段类型);
1 CREATE INDEX必须提供索引名，对于ALTER TABLE，将会自动创建，如果你不提供；
2、CREATE INDEX一个语句一次只能建立一个索引，ALTER TABLE可以在一个语句建立多个，如：ALTER TABLE HeadOfState ADD PRIMARY KEY (ID), ADD INDEX (LastName,FirstName);
3、只有ALTER TABLE 才能创建主键，
使用 CREATE USER 语句创建一个用户 drdsuser，密码为 123456
reate user drdsuser@'%' identified by '123456';
授权用户 drdsuser 可检索数据库 sample_db 内的表
grant insert,update,delete,select on sample_db.* to drdsuser@'%';
查询用户 drdsuser 的权限
show grants for drdsuser@'%'
删除用户 drdsuser
drop user drdsuser@'%'
@ 表示局部变量
@@ 表示全局变量
# 表示本地临时表的名称，以单个数字符号打头；它们仅对当前的用户连接是可见的
## 表示全局临时表
... 三个点 是 扩展运算符 可以代表一些数 把这些数放在新的数里边
比如：
const adrian = {
fullName: 'Adrian Oprea',
occupation: 'Software developer',
age: 31,
website: 'https://oprea.rocks'
};
const bill = {
...adrian,
fullName: 'Bill Gates',
website: 'https://microsoft.com'
};
StringBuffer：线程安全的
StringBuffer类中的方法都添加了synchronized关键字，也就是给这个方法添加了一个锁，用来保证线程安全。
StringBuilder：线程非安全的
