基础知识money

如果没有重新定义父类已有的同名属性，则修改公有属性就是修改父类的公有属性，即父类的属性会一起改变!! 如果定义了，则各是各的

SDK是什么 SDK全称software development kit，软件开发工具包。一般都是一些软件工程师为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件时的开发工具的集合。 通俗来讲就是第三方服务商提供的实现产品软件某项功能的工具包

lamda表达式 就是函数编程 传入参数为接口类可写成（x）->{}  相当于就是传入了一个匿名接口类对象!!!  但是接口只能有一个方法！！！
匿名内部类就是实现接口方法  多个都要实现

Stack继承Vector类
pop移除 push压入 peek查看不溢出

queue linkedlist blockingQueue（阻塞）
add remove失败会报异常  poll移除 offer添加 

int Integer自动装箱和自动拆箱
装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。!!!!
精度小于int的数值运算的时候都回被自动转换为int后进行计算 !!!!!!!   两个byte类型相加，结果是int，也就是需要使用int接收!!!或者强制转换byte    Integer自动拆箱然后相加
1.5以后  因为-128到127这些数字是使用频率比较高的，就产生了一个整型常量池IntegerCache.cache[]  两个integer小于128相等 !!!  Integer valueOf
 

Maven的生命周期就是对所有的构建过程进行抽象和统一。包含了项目的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等几乎所有的构建步骤。
Maven有三套相互独立的生命周期，分别是clean、default(编译，测试，打包)和site（建立和发布项目站点）   mvn clean  mvn test   mvn clean install

springboot启动指定入口：build -》plugin-》mainClass   还可以java -cp bootApp.jar -Dloader.main=com.example.MyApplication
@SpringBootApplication组合了@SpringBootConfiguration(配置类)、@EnableAutoConfiguration(是否开启某一个功能自动配置 exclude排除或加入 import)、@ComponentScan(！！bean 实例化的包或类 @Componet加载到IoC容器中)，因此我们也可以直接使用这三个注解来替代它。   MapperScan
自动加载配置SpringFactoriesLoader属于Spring框架私有的一种扩展方案，其主要功能就是从指定的配置文件META-INF/spring.factories加载配置。
实例化Application(SF中找到ApplicationContext，找到main方法) -》started（找到SpringApplicationRunListener要启动）-》Environment(准备和通知)-》初始化创建ApplicationContext-》
最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。-》contextLoaded-》refresh

循环依赖 解决不了构造器依赖 反射   Spring的三级缓存主要是singletonObjects（初始化完的）、earlySingletonObjects（放原始的 bean 对象（尚未填充属性））、singletonFactories（单例对象工厂）这三个Map
没获取到依次三级获取，三级获取了，提升到二级  singletonFactory.getObject()获取 执行了构造器

java.lang.Class.forName(String name, boolean initialize, ClassLoader loader)  initialize -- 这说明这个类是否必须初始化。 loader -- 这是必须加载的类的类加载器

多线程 使用一个对象锁，一个类中两个方法锁，notify和wait唤醒
 

抽象类只能继承一次，但是可以实现多个接口  接口JDK1.8开始可以有默认的实现
接口和抽象类必须实现其中所有的方法，抽象类中如果有未实现的抽象方法，那么子类也需要定义为抽象类。抽象类中可以有非抽象的方法
接口中的变量必须用 public static final 修饰，并且需要给出初始值。所以实现类不能重新定义，也不能改变其值。
接口中的方法默认是 public abstract，也只能是这个类型，如果是 private，procted，那么就编译报错。不能是 static，接口中的方法也不允许子类覆写，抽象类中允许有static 的方法
抽象类无法创建对象

索引太多也不好 占空间  每插入、删除或更新一条数据，都要构建10个索引，性能低下

unchecked exceptions（运行时异常）都是RuntimeException类及其子类异常，就是我们在开发中测试功能时程序终止，控制台出现的异常 NullPointerException IndexOutOfBoundsException ClassCastException
非运行时异常 （编译异常）：是RuntimeException以外的异常，如果不处理，程序就不能编译通过。IOException SQLException

zk 和 redis  
redis分布式锁，其实需要自己不断去尝试获取锁，比较消耗性能zk分布式锁，获取不到锁，注册个监听器即可，不需要不断主动尝试获取锁，性能开销较小
另外一点就是，如果是redis获取锁的那个客户端bug了或者挂了，那么只能等待超时时间之后才能释放锁；而zk的话，因为创建的是临时znode，只要客户端挂了，znode就没了，此时就自动释放锁

returnType映射对象 底层也是returnMap  returnMap：自定义字段映射

#方式因为默认增加了双引号，能够很大程度防止sql注入  $方式属于字符的动态拼接，无法防止SSQL注入
使用#的sql进行了预编译，用？接受参数  效率高，可读性和可维护性

set和list区别 set实现hashset treeset list实现arraylist linkedlist TreeSet通过Comparator 或者 Comparable 维护了一个排序顺序
list可以允许重复对象和插入多个null值，而set不允许,set只允许插入一个null元素；list容器是有序的，而set容器是无序的等等
LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适，Vector 表示底层数组，线程安全  array是数组的连续内存，指针便宜很快  linked内存不连续，只有指针一个个移动

针对的是中节点位置  前序 :中左右 中序：左中右

算法

IP个数和子网个数  网络号+主机号+掩码   子网就是除以8剩下的位数 2的几次方  ip个数就是32-占用的/n 2的n次方-2 

0.0.0.0：它表示的是这样一个集合：所有不清楚的主机和目的网络  255.255.255.255：限制广播地址，这个地址不能被路由器转发。127.0.0.1：本机地址

父类的静态字段——>父类静态代码块——>子类静态字段——>子类静态代码块——>父类成员变量（非静态字段）——>父类非静态代码块——>父类构造器——>子类成员变量——>子类非静态代码块——>子类构造器90

tcp/ip 网络接口层（数据链路层）/网络层/传输层/应用层/  osi7层 物理层->数据链路层->网络层(icmp差错和信息报文 igmp组播 arp)->传输层->会话层->应用层->表示层

ping过程

hashtable不允许key和value为null,线程安全   hashmap可以
map中key不能为！！可变的对象！！！！因为通过hashcode来定位的，对象变了hashcode变了，就找不到对象了！！！
size不为2的倍数， 碰撞几率变大，不能均匀分配，造成空间浪费
hashmap造成死循环，cpu飙升   超过threshold，需要resize 两个线程同时resize可能导致循环链表

ThreadLocal 会造成内存泄漏  ThreadLocalMap是一个key弱引用WeakReference  key为null但是value不为null的entry项。set和get和remove方法清除

String  stringbuffer stringbuilder区别
都是final类，不能被继承 string长度不可变  stringbuffer线程安全

重写equals必须重写hashcode  不然两个对象可能有相同的hashcode,导之set存重复的值

多线程实现继承Thread 实现runnable  callable接口
sleep和wait区别  Thread.sleep不会让出持有锁

lock是显示锁，必须手动获取释放unlock  lock采用自旋锁，乐观锁，一定时间获取不到就截止
一个类有一个类锁(static，所有对象公用) 对象锁，只管一个对象

throwable->(error,exception) exception分为受检查和不受检查
nio:同步非阻塞 bio:同步并阻塞 aio:异步非阻塞
匿名内部类没有构造器，且访问外面变量要为final

索引特点：加快检索速度，一次只能使用一次索引。  创建时间和使用空间!!  acid原子性/持久/隔离/一致
有or会使索引失效！！！ 多列索引不是使用的第一部分  全表扫描使用更快
1NF:属性不可再分 2NF：完全依赖主键（消除部分依赖）3NF：不依赖其他非主属性（消除传递依赖）BCNF任何非主属性不能对主键子集依赖（消除主键子集依赖）
b树平衡多路查找  b+非叶结点仅具有索引作用，跟记录有关的信息均存放在叶结点中  树的所有叶结点构成一个有序链表!!!
IO次数更少  数据越多，层数不高，减少io
myisam不支持事务，锁只能表锁

jvm:程序计数器 栈，本地方法栈（navite方法，不是java方法）堆  方法区（永久，类信息，常量，静态）  运行时常量池
算法：标记清除，复制，标记整理
gc可达性分析：引用计数法（很难解决对象间的互循环引用的问题！！）  可达性分析算法GC Roots!!!
System.gc()方法的调用 老年代空间不足 永生区空间不足 堆中分配很大的对象直接进入老年代  会进行fullgc
收集器：serial是个单线程   parnew多线程版本，新生代为复制，老年代为标记-整理 和cms收集器一起用！！！  g1有优先级回收，用户指定停顿时间
cms收集器：使用与互联网网站，最短停顿时间收集器  初始标记（GC ROOT）->并发标记->重新标记（因为并发标记应用线程还在用）->并发清除->并发收集
                                                 STW（Stop The World）有初始标记,重新标记
双亲委派模型：先找顶层类加载，防止串改不安全  
Student s = new Student()  加载 连接（验证，准备，解析） 初始化 使用 卸载
class加载到堆中 为s在栈中开辟空间 堆内存student对象 为成员变量默认值 显示初始值  构造器 对象地址赋值变量s

请求转发是在服务器端的跳转，地址栏没有变化 不会丢失请求信息！！！！ request.getRequestDispatcher("/student_list.jsp").forward(request,response);
重定向是客户端的跳转，重定向地址栏有变化  转发必须是在同一台服务器下完成！！！不然跨域 response.sendRedirect();

cookie客户端 存sessionId，单个不超过4K，一个站点最多存20个 通过设置cookie的属性，达到使cookie长期有效的效果  支持跨域名访问
session服务器  session不能达到长期有效的效果 并发访问的用户十分多，会产生十分多的session，耗费大量的内存 不支持跨域名访问

http是运行在TCP之上的 https->ssl->tcp->对称加密->非对称加密443
tcp三次握手，四次挥手 syn建立连接 ack确认
                                                 

反射动态获取类的所有属性和方法，构造方法  一个类，只有一个Class对象产生
getClass Class.forName .class
getConstructor  newInstance
getDeclaredMethod  getmethod  invoke  带有Declared修饰的方法可以反射到私有的方法，没有Declared修饰的只能用来反射公有的方法
getAnnotation  
getFiled  成员变量为private,故必须进行此操作  setAccessible(true)应该取消 Java 语言访问检查!! 可以访问private method filed 且提高反射速度

序列化 持久化 RMI(远程方法调用) 网络中传递对象  将对象的状态转化成字节流
序列化是将对象状态转换为可保持或可传输的格式的过程  json是数据交换的格式
serialize在编码后大概是json的两倍  serialize的速度在大数据量的情况下比json差了快一个数量级。 交换json更好
json无法处理对象方法等数据。序列化使用serialize，特别是对象的存储  对象的状态,成员变量
对象序列化不会关注类中的静态变量。因为静态变量在全局区 !!!!!!

某个字段被声明为transient后，默认序列化机制就会忽略该字  
只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常
private static final long serialVersionUID = 1L来验证版本一致性的，在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较 一直才能反序列化
ObjectOutputStream  writeObject/readObject     Externalizable writerExternal/readExternal写需要序列化的filed 

对象声明为private  writeObject   但是ObjectOutputStream还是调用该方法，  是一个通过发射进行的方法调用！！！！！

当初始化一个类时，如果父类没有进行初始化，需要先初始化父类
编译.java文件经过编译之后得到.class文件
jvm 加载jar lib classpath下的 其他是动态加载
加载classloader(形成一个class对象在堆区)->验证->准备(为类变量分配内存，静态变量分配内存，并将其赋默认值)->解析(将常量池中的符号引用替换为直接引用)->初始化(为类的静态变量赋初值)->实例化（为实例变量分配内存和初始化值）->卸载(System.exit()，异常)

父类静态属性（成员变量） > 父类静态代码块 > 子类静态属性 > 子类静态代码块 > 父类非静态属性 > 父类非静态代码块 > 父类构造器 > 子类非静态属性 > 子类非静态代码块 > 子类构造器

一个编译单元必须只包含有一个public类  .java文件中包含有几个类，编译后就会生成几个.class文件。
父类中声明为 private 的方法，不能够被继承  父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
子类重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。！！！
父类没有写构造函数（系统默认有一个无参构造函数），子类可以不写构造函数（可以理解为：子类的系统默认构造函数，默认调用了super();）!!!
public > protected(对同一包内的类和所有子类可见,不同包只有子类) > default(包访问权限,在同一包内可见) > private。  private和protected修饰符不能用以修饰类/接口

 
封装：增强安全性  属性私有化，根据需要提供setter和getter方法来访问属性
继承：代码复用    多个相同的属性和方法提取出来，新建一个父类
多态：增加代码的灵活度     父类在调用方法时，优先调用子类的方法。如果子类没有重写父类的方法，则再调用父类的方法
      父类类型 变量名=new 子类类型()  调用子类的方法！！！  不需要强制转化   在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法  同学张三既是学生也是人，出现两种形态！！

多态的不同形态，重载是设计，重写是运行
重写: 重写父类方法
重载：Java允许方法名相同而参数不同（返回值可以相同也可以不相同）

java思想  面向过程相当于一个人干了所有事  面向对象相当于多个人各司其职干事情！！！！！！！！易扩展、复用性强!!!
面向过程:以过程为中心的一种编程思想，会围绕着一个问题有一步步的步骤去解决问题
面向对象:每一个类都只做一件相关事!!   易扩展、复用性强!!!
面向过程会让一个类越来越全能，就像一个管家一样做了所有的事。而面向对象像是雇佣了一群职员，每个人做一件小事，各司其职，最终合作共赢！

boolean result = obj instanceof Class   用来测试一个对象是否为一个类的实例！！！！‘

自定义注解
访问修饰符必须为public,不写默认为pubic；   关键字为@interface

元注解
@Target  表明该注解可以应用的java元素类型  ElementType.METHOD：应用于方法
@Retention  表明该注解的生命周期 RetentionPolicy.RUNTIME：由JVM 加载，包含在类文件中，在运行时可以被获取到
@Document  表明该注解标记的元素可以被Javadoc 或类似的工具文档化
@Inherited 表明使用了@Inherited注解的注解，所标记的类的子类也会拥有这个注解

利用反射解析注解
getClass  /判断当前元素是否被指定注解修饰 clazz.isAnnotationPresent(Info.class) getAnnotation|getAnnotations

自定义异常
一般会选择继承Exception和RuntimeException，如果不要求调用者一定要处理抛出的异常，就继承RuntimeException
Throwable是所有异常类的基类，它包括两个子类：Exception和Error

过滤器和拦截器的区别 
记住顺序 filter->servlet->inteceptor->controller   先执行filter,在inteceptor
inteceptor属于spring,所以可以ioc，上下文，httpservletrequest    filter不行，ServletRequest ，zuulfilter可以
filter调用链用的回调，inteceptor是反射，更大的弹性，可以到方法前后

aop
aspect切面 JoinPoint连接点 Pointcut切入点 advice通知/增强
通知顺序 around->before->around->after->aftereeturning|afterthrowing
within()所指定的连接点最小范围只能是类，而execution()所指定的连接点可以大到包，小到方法入参
around 必须pjp.proceed();//执行该方法  不然进入不了controller

SMB远程溢出攻击:远程代码执行漏洞运行代码 建议：关闭一些关口 telnet
DOS_ICMP_FLOOD_拒绝服务    ：短时间大量ping，造成服务器不响应 建议：防火墙路由器，切换Ip,
DGA域名请求: 随机生成域名  建议：关注NDS流量，不正常的域名解析

B主动调用类A的callback()方法  传入接口！！
A调用B传对象   this传递给调用方

上行下行 iftop
查进程  top  ps -aux    ps -elf
端口占用 netstat-anp|grep      lsof -i:port  
查看文件 df -hl    du -sh *

1.8新特性
hashmap变化 数组+链表+红黑树（碰撞8）  
ConcurrentHashMap  去掉锁分段，采用CAS 链表头加自旋

Lambda表达式 本质上是一段匿名内部类，也可以是一段可以传递的代码
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        
    }
};
风格简便 (x,y)  方法可以当参数传递 ()->{}
Runnable runnable = ()-> System.out.println("ss");
(x，y) -> {System.out.println(“xxx”);return xxxx;}； 有多个参数，有返回值，有多条lambda体语句

使用Stream API 不用定义过滤方法，直接在集合上进行操作  创建stream 中间操作（过滤、map）   终止操作(reduce和collectdeng)
proList.stream()
           .fliter((p) -> p.getPrice() <8000)
           .limit(2)
           .map(Product::getName)
           .forEach(System.out::println);
           
ForkJoin框架 递归分合、分而治之

新的日期API LocalDate | LocalTime | LocalDateTime
           

装载 连接(检查,准备,解析) 初始化:初始化静态变量，静态代码块。
类什么时候被加载/类加载时机   加载完以后JVM中就有了该类的元数据
生成该类对象的时候，会加载该类及该类的所有父类
访问该类的静态成员的时候
class．forName("类名")

hashcode决定了新天街的元素挂在数组那个位置，equals比较当前索引下两个内容是否相等 object用的是==    默认的equals方法同==
可能某两个对象明明是“相等”，而hashCode却不一样！！

forIndex 10 h% 4=2;使用10&（4-1） 也就是1010&0011  尾数是0 ，这样就相当于这几个位置存不到数据，造成空间浪费，减少碰撞的几率 使hash分布更均匀,避免形成链表的结构 
resize   认值为 0.75认情况下，数组大小为 16，那么当HashMap中元素个数超过 160.75=12 的时候，就把数组的大小扩展为 216=32，即扩大一倍
预设元素的个数能够有效的提高 HashMap 的性能  2的n次幂!  (n-1)的2进制也就是1111111***111这样形式的!!!!
多线程环境下，使用Hashmap进行put操作可能会引起死循环,CPU利用率接近100%   都需要扩容的话

Hashtable线程安全但效率低下
使用synchronized来保证线程安全，但在线程竞争激烈的情况下Hashtable的效率非常低下

ConcurrentHashMap所使用的锁分段技术
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段  size可以用voliate
JDK1.8的实现已经抛弃了Segment分段锁机制，利用CAS+Synchronized来保证并发更新的安全。数据结构采用：数组+链表+红黑树。
新增节点之后，所在链表的元素个数达到了阈值 8，则会调用treeifyBin方法把链表转换成红黑树  且数组大小大于64才转为红黑树  小于64优先扩容两倍在重新分配

类锁（又称全局锁，static synchronized）：该锁针对的是类，无论实例出多少个对象，那么线程依然共享该锁。
对于类锁，相当于将所有实例对象共享了这一唯一锁，因此即便是不同实例对象之间，仍然会被限制。所以不能被同时访问，有约束。

！！！！！
每个对象都有一个锁，且是唯一的。
不同的实例对象会生成不同的对象锁（对象锁对于不同的对象实例没有锁的约束），因此两者互不影响，可以同时访问（运行时成交替输出），无约束。
所有同步方法（synchronized func）全被lock  不限制非锁方法

在线程获得对象锁的同时，也可以获得该实例的类锁，即同时获得两个锁，这是允许的。    

spring提供了5种scope分别是singleton、prototype、request、session、global session

默认单例，所以就只有一个对象！！！但是调用一个方法，前提是能拿到，都是在栈内，互不影响

Spring 为啥把bean默认设计成单例？

答案：为了提高性能！！！从几个方面：少创建实例   垃圾回收  缓存快速获取

单例有啥劣势？
如果是有状态的话在并发环境下线程不安全

多线程，异步中会丢失上下文 相当于不属于spring容器管理了！！！！也不能使用@autowired  但是@asyc属于 可以用！！！

1 在@SpringBootApplication启动类 添加注解@EnableAsync！！！！这个才会异步！！！！
2 异步方法使用注解@Async ,返回值为void或者Future
3 切记一点 ,异步方法和调用方法一定要**** 写在不同的类中 ****,如果写在一个类中,！！！
是没有效果的

Future<Map<String, ResultObject>> future = allService.getAllAsys(map,paramPI,s);

future.get() 会阻塞  必须等到结果才行  就变成同步了

向线程池中提交任务的submit方法不是阻塞方法  而Future.get方法是一个阻塞方法

向线程池中提交任务的submit方法不是阻塞方法  而Future.get方法是一个阻塞方法
一般需要使用future.isDone先判断任务是否全部执行完成，完成后再使用future.get得到结果。（也可以用get (long timeout, TimeUniunit)方法可以设置超时时间，防止无限时间的等待）
要么使用isDone()轮询地判断Future是否完成，这样会耗费CPU的资源。
//            也会丢失token 上下文
Future<Map<String, ResultObject>> future = allService.getAllAsys(map,paramPI,s);
try {
while (future.isDone()){
    i++;
    System.out.println(future.get());
}

多线程类丢失token 上下文  不管是线程池还是Async

completionService
completionService.take().get()方法获取最快完成的线程的返回结果（若当前没有线程执行完成则阻塞直到最快的线程执行结束），循环！ 第二次调用则返回第二快完成的线程的返回结果
也会阻塞  但是其他线程异步进行
ExecutorService executorService = Executors.newCachedThreadPool();
CompletionService<Map<String, ResultObject>> completionService = new ExecutorCompletionService(executorService);
for(String s : index){
    completionService.submit(new AllThreadService(paramPI,s,
    iAptService,iGuardService,iSyslogService,iVirusService,iIacService,iSnmpService));
}
for(int i =1;i<=index.length;i++){
    System.out.println(completionService.take().get());
}
executorService.shutdown();
return map;

CompletableFuture接口
基于CompletableFuture创建任务和链式处理多个任务，并实现按照任务完成的先后顺序获取任务的结果
使用runAsync方法新建一个线程来运行Runnable对象(无返回值)
使用supplyAysnc方法新建线程来运行Supplier<T>对象(有返回值)

ExecutorService executorService = Executors.newCachedThreadPool();
CompletableFuture.supplyAsync(new MyThreadt444(commandstr02),executorService).whenComplete((result, e) -> {
    //执行线程执行完以后的操作。
    System.out.println(result + " " + e);
}).exceptionally((e) -> {
    //抛出异常
    System.out.println("exception " + e);
    return "exception";
});

 CompletableFuture.supplyAsync(new MyThreadt333(commandstr02),executorService).whenComplete((result, e) -> {
    //执行线程执行完以后的操作。
    System.out.println(result + " " + e);
}).exceptionally((e) -> {
    System.out.println("exception " + e);
    return "exception";
});

https://blog.csdn.net/A1342772/article/details/91349142
设计模式：为了重用代码、让代码更容易被他人理解、保证代码可靠性。使软件更容易修改和维护
良好的顶层设计可以减少开发量，bug  增加扩张性和复用性

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

单例模式分为饥饿加载和懒加载。 sychronized加在if(instance==null)判断语句里面，保证instance未实例化的时候才加锁

spring用到的那些模式 https://blog.csdn.net/qq_34337272/article/details/90487768
工厂: ApplicationContex/BeanFactory  getBean
单例: 检查缓存中是否存在实例  singletonObjects map
代理:AOP  默认JDK proxy针对实现接口InvocationHandler   CGLIB针对继承类生成类
模板:Template  在抽象类实现主体
观察者：ApplicationListener
适配器模式：DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler

项目用到的
模板：把分析公共方法拆解到主题内
工厂：根据传的参数来获取那个类解析
单例：计算器