java一站式输出

置顶 3.3Gb请求GC

已于 2022-04-11 18:34:25 修改

阅读量606

点赞数

分类专栏：笔记文章标签： java spring spring boot 数据结构后端

于 2020-02-19 21:22:28 首次发布

本文链接：https://blog.csdn.net/weixin_45970468/article/details/104397268

版权

笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

何为编程?

编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码,并最终达到结果的过程.为了能让计算机理解人的意图,人类必须要将解决问题的思路,方法,和手段通过计算机能够理解的方式告诉计算机,使得计算机能够根据人类的指令去一步一步的去工作,完成某种特定的任务.这种人和计算机之间的交流的过程就是编程.

什么是Java?

Java是一门面向对象的编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++难以理解的多继承,指针等概念.因此Java语言具有的功能强大和简单易用的两个特征.Java语言作为静态面向对象编程语言的代表,极好的实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程.

JVM,JRE,JDK之间的关系?

JVM是java虚拟机的规范,java程序需要运行在虚拟机上,不同的平台有自己的虚拟机,所以java语言是可以实现跨平台的
JRE 包括了Java虚拟机和Java程序所需要的核心类库等.核心类库主要是java.lang包:包含了运行java程序必不可少的系统类,如基本数据类型,基本数学函数,字符串处理,线程,异常处理类等,如果想要运行一个开发好的java程序,计算机中只需要安装JRE即可.
JDK 是提供给开发人员使用的,其中包含了java的开发工具,也包括了JRE,所以安装了JDK就无须单独的安装JRE了,其中的开发工具:编译工具(javac.exe),打包工具(jar.exe)等.
JVM&JRE&JDK关系图:
在这里插入图片描述

什么是跨平台?原理是什么?

所谓的跨平台就是指java语言的程序,一次编译后可以实现在多个平台上运行
实现的原理就是:java程序是通过java虚拟机的在系统平台上运行,只要该系统安装响应的java虚拟机,该系统就可以运行java程序.

Java语言有哪些特点?

简单易学:java语言的语法与C和C++很接近
面向对象:
跨平台:虚拟机可实现跨平台
支持网络编程:java语言诞生就是为了简化网络编程设计的
支持多线程:多线程机制可以试应用程序在同一时间并行执行多项任务
健壮性:java语言是强类型机制,异常的处理,以及垃圾的回收
安全性.

JAVA中的编译器和解释器

先看下java中的编译器和解释器:
Java中引入了虚拟机的概念,即在机器和编译程序之间加入了一层抽象的虚拟机器,这台虚拟机器在任何平台下都提供给编译器一个共同的接口.编译器只需要面向虚拟机,生成虚拟机能够理解的代码.然后再由解释器来将虚拟机代码转化为特定系统的机器码执行.在Java中,这种虚拟机理解的代码叫做字节码, 它不面向任何特定的处理器,只面向虚拟机.每一种平台的解释器都是不同的,但是实现的虚拟机却都是相同的,java源代码经过javac编译器编程字节码,字节码由虚拟机解释执行,虚拟机将每一条要执行的字节码送给解释器,解释器将其翻译成特定的机器上的机器码然后在特定的机器上运行,实现java的特点编译与解释并存的解释.
Java源代码----------->编译器(javac)--------------->JVM可执行的java字节码--------------->JVM(JVM解释器)------------------>机器可执行的二进制机器码---------------------->程序运行

什么是java程序的主类?应用程序和小程序的主类有何不同?

一个程序可以有很多类,但只能有一个类是主类.在java程序中,这个类是包含了main()方法的类.而在java小程序中,这个类是一个继承自系统类JAPPlet或Applet的子类.应用程序的主类不一定要求是public类,但小程序主类必须是public类
Java应用程序与小程序之间有哪些差别?
简单的说java程序是从主程序启动(也就是main方法)
Applet小程序没有main方法,只要是嵌入在浏览器页面上执行(调用init 或者run方法来启动)

Java和C++的区别?

1.都是面向对象的语言,都支持封装,继承和多态
2.Java不提供指针来直接访问内存,程序内存更加安全
3.Java类是单继承,C++支持多继承;虽然java类不支持多继承但是接口可以多继承
4.Java有自动内存管理机制,不需要程序员手动释放无用的内存

Oracle JDK和OpenJDK的对比?

OracleJDK版本将每年发布一次而openJDK没三个月发布一次;
OpenJDK 是一个参考模型并且完全开源,而Oracle JDK是openJDK的一个实现并且不是完全开源的
OracleJDK比openJDK更加的稳定,两个的代码几乎相同,而oracleJDK有更多的类并修复了一些错误,而使用openJDK可能会有很多的应用程序奔溃的可能.
在响应JVM性能方面 OracleJDK提供了更好的性能
OracleJDK根据二进制代码许可协议获得许可,而openJDK 根据GPL v2许可获得许可

JVM内存示意图

jvm的三大组件,内存,类加载

jvm三大组件

类加载子系统
运行时内存区
JVM执行引擎

类加载

概念:从磁盘中加载到jvm内存中的行为,也就是将字节码对象加载到JVM内存中
双亲委派模式(注意加载顺序是先由BootstrapClassLoader加载object类等祖先类,再由ExtClassLoader加载父类最后才是 APPClassLoader加载我们自己写的类)
作用:保护了基层类劣势是不能够指定的加载自己的类.例如 (自己写一个 java.lang包下的Object类时 ).
何时会触发类加载:
1.使用类加载器直接加载
2.构建本类或者子类对象时
3.访问类中的成员变量时(包括属性和方法)这里注意的是有static final修饰的8中基本类型以及string类型不会触发类加载(属于优化代码时使用优化了方法区内存)

获取字节码对象的方法:

              1.类名.class (获取的对象静态代码块不加载)  
              2.Class.ForName(包名+类名)(获取的对象静态代码块加载)
              3.实例对象.getClass()

             **面试题:类加载时 静态代码块一定会加载吗?**

获取字节码对象也是反射的基础(反射的细节)https://blog.csdn.net/weixin_45970468/article/details/104449479

/**
 * 
 * @author renjiaxing
 *测试类加载时静态代码块是否会加载?
 */
public class TestClassLoader {
	               Class<?> aClass=MyClass1.class;
	   public static void main(String[] args) {
		        System.out.println("hello-classloader");
	}
}
class MyClass1{
    static{
	     System.out.println("我就是学不来要低调");
}
}

      执行结果如下:

在这里插入图片描述
从结果我们可以看出类名.class 触发类加载时不会加载静态代码块
我们再使用第二种方式来进行测试:

 * 
 * @author renjiaxing
 *测试类加载时静态代码块是否会加载?
 */
public  class TestClassLoader {
	              // Class<?> aClass=MyClass1.class;
	public static void main(String[] args) {
		Class<MyClass1> aClass=null;
		try{
			aClass= (Class<MyClass1>) Class.forName("myproject2.MyClass1");
			System.out.println("helloClassLoader");
		} catch(ClassNotFoundException e){
			e.printStackTrace();
		}
	}
}

class MyClass1{
    static{
	     System.out.println("我就是学不来要低调");
}
    
}

结果如下:
在这里插入图片描述
测试我们看出了结果静态代码块已经加载了
总结:类加载时静态代码块不一定加载要看是什么方式加载的!
如果类中既有静态属性又有静态代码块时则要按照定义时的顺序来决定

字节码对象,实例对象

什么是字节码,使用字节码的最大的好处是什么?
字节码:java源代码经过虚拟机编译器的编译后产生的文件(即扩展名为.class文件),它不面向任何特定的处理器只面向虚拟机.
采用字节码的好处?
Java语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点,所以java程序运行比较高效,而且,由于字节码对象并不专对一种特定的机器,因此java程序无序重新编译便可在多种不同的计算机上运行.
对象的创建
1.通过new对象来创建实例对象
2.通过reflect反射来获取对象
区别:new对象时在编译时就已经知道了创建对象的类型
反射获取对象只有在运行时才能获取对象的类型
对象的作用
1.存储数据 pojo对象 ,VO对象也是一种特殊的pojo对象通过对象的属性来存储数据
2.执行业务逻辑 controller service dao
对象的内存存储位置
字节码对象和实例对象大部分都会存储在JVM堆中但是也有例外 ,没有逃逸的对象可能会在栈中,逃逸的对象在堆中
栈上分配的对象的优势: 频繁的GC会造成全局的暂停影响性能,使用栈上分配的对象销毁时不会启动GC.
对象的生命周期以及四大引用
强引用: Object o1=new Object();
弱应用: weak…在GC时就会被回收
软引用: soft…内存不足时回收
虚引用: 回收时写日志
例如:mybatis中二级缓存中就有弱引用,软引用缓存,以及在shiro框架中的缓存也是应用了软引用缓存来实现淘汰机制.

内存泄露和内存溢出

内存泄露:系统不会奔溃(对象已经不在使用但是还在占用内存空间)是内存溢出的导火线.
内存溢出:系统会奔溃
弱引用和软引用主要是为了避免内存的溢出现象.

常量池

常量池分为三种:
1)全局字符串常量池(String Pool)
全局字符串常量池中存放的内容实在类加载完成后存到Stringpool中的,在每个JVM中只有一份,存放的是字符串常量的引用值(在堆上生成字符串对象实例)
2)Class文件常量池(ClassConstantPool)
Class常量池是在编译时每个class都有的,在编译阶段,存放一些常量(文本字符串,final常量等)和符号的引用
3)运行时常量池(RuntimeConstantPool)
运行时常量池是在类加载完成以后,将每个class常量池中的符号引用值转存到运行时常量池中,也就是说,每个class都有一个运行时常量池,类在解析之后,将符号引用替换成直接引用,与全局常量池中的引用值保持一致.
以String类型为例:
String类专题
String又称:不可变字符串序列,为于java.lang包下java字符串默认就是Unicode字符序列(注:字符串效果上是一个char[]数组,当底层是byte[]字节数组) java没有内置的字符串类型,而是在标准的java类库中提供了一个预定义的类String,每个用双引号括起来的字符串都是String类型的一个实例.
String的创建,拼接以及内存问题?
String的实例化很简单,直接双引号创建或者new String对象即可.
字符串是(final类)常量,它们的值创建后就不能更改!!
(注:字符串的拼接不叫更改字符串的值,拼接的本质是创建了一个新的字符串对象.String对象一旦被创建就是固定不变的,对String对象的任何改变都不会影响原对象,相关的任何Change操作都会生成新的对象) 通过+ 拼接
在这里插入图片描述
每当我们创建一个字符串对象的时候,首先就会检查字符串中是否存在在面值相等的字符串,如果有,则不会创建,直接返回字符串的引用.若没有,则创建然后放入常量池中并且返回新创的引用(也就是说,只要出现双引号””字符串,就一定会在常量池中去找引用,没有就创建一个)
注:对于基本数据类型 == 是数值的比较,引用类型 ==是地址值的比较
那么为什么会出现这种结果?
以str1为例,创建str1存在于栈中,str1会查找字符串常量池中是否存在字符串”我的短发短发姑娘~”,若存在就返回str1引用地址,不存在就在常量池中创建一个,然后返回引用地址!str2同理图如下:
在这里插入图片描述
Str3:在常量池中是否有”我的短发短发姑娘_{”对象?没有就在堆中创建一个对象String(“我的短发短发姑娘}”) str3 引用的就是堆中的对象的地址值
因此 str3 与1 ,2 不同

Str4:是在运行时调用了intern()方法,返回String POOl 中 “我的短发短发姑娘~” 的引用值,如果没有就将 str3的引用值填上去

因此字符串的比较通常用 equals()

String相关

字符型常量和字符串常量的区别
形式上: 字符常量是单引号引起的一个字符字符串常量是双引号引起的若干个字符
含义上: 字符常量相当于一个整形值(ASCII值),可以参加表达式运算字符串常量代表一个地址值(该字符串在内存中存放位置)
占内存大小字符常量只占一个字节字符串常量占若干个字节(至少一个字符结束标志)
什么是字符串常量池？
字符串常量池位于堆内存中，专门用来存储字符串常量，可以提高内存的使用率，避免开辟多块空间存储相同的字符串，在创建字符串时 JVM 会首先检查字符串常量池，如果该字符串已经存在池中，则返回它的引用，如果不存在，则实例化一个字符串放到池中，并返回其引用。
String 是最基本的数据类型吗
不是。Java 中的基本数据类型只有 8 个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type），剩下的都是引用类型（referencetype），Java 5 以后引入的枚举类型也算是一种比较特殊的引用类型。
这是很基础的东西，但是很多初学者却容易忽视，Java 的 8 种基本数据类型中不包括 String，基本数据类型中用来描述文本数据的是 char，但是它只能表示单个字符，比如 ‘a’,‘好’ 之类的，如果要描述一段文本，就需要用多个 char 类型的变量，也就是一个 char 类型数组，比如“你好” 就是长度为2的数组 char[] chars = {‘你’,‘好’};
但是使用数组过于麻烦，所以就有了 String，String 底层就是一个 char 类型的数组，只是使用的时候开发者不需要直接操作底层数组，用更加简便的方式即可完成对字符串的使用。
String有哪些特性
不变性：String 是只读字符串，是一个典型的 immutable 对象，对它进行任何操作，其实都是创建一个新的对象，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时，可以保证数据的一致性。
常量池优化：String 对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，会直接返回缓存的引用。
final：使用 final 来定义 String 类，表示 String 类不能被继承，提高了系统的安全性。
String为什么是不可变的吗？
简单来说就是String类利用了final修饰的char类型数组存储字符，源码如下图所以：

/** The value is used for character storage. */
private final char value[];

String真的是不可变的吗？
我觉得如果别人问这个问题的话，回答不可变就可以了。下面只是给大家看两个有代表性的例子：

String不可变但不代表引用不可以变

String str = "Hello";
str = str + " World";
System.out.println("str=" + str);

结果：
str=Hello World
解析：
实际上，原来String的内容是不变的，只是str由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已，也就是说多开辟了一块内存区域给"Hello World"字符串。

通过反射是可以修改所谓的“不可变”对象

// 创建字符串"Hello World"， 并赋给引用s
String s = "Hello World";
System.out.println("s = " + s); // Hello World
// 获取String类中的value字段
Field valueFieldOfString = String.class.getDeclaredField("value");
// 改变value属性的访问权限
valueFieldOfString.setAccessible(true);
// 获取s对象上的value属性的值
char[] value = (char[]) valueFieldOfString.get(s);
// 改变value所引用的数组中的第5个字符
value[5] = '_';
System.out.println("s = " + s); // Hello_World

结果：
s = Hello World
s = Hello_World
解析：
用反射可以访问私有成员，然后反射出String对象中的value属性，进而改变通过获得的value引用改变数组的结构。但是一般我们不会这么做，这里只是简单提一下有这个东西。

是否可以继承 String 类
String 类是 final 类，不可以被继承。
如何将字符串反转？
使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。
示例代码：

// StringBuffer reverse
StringBuffer stringBuffer = new StringBuffer();
stringBuffer. append("abcdefg");
System. out. println(stringBuffer. reverse()); // gfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder. append("abcdefg");
System. out. println(stringBuilder. reverse()); // gfedcba

数组有没有 length()方法？String 有没有 length()方法
数组没有 length()方法，有 length 的属性。String 有 length()方法。JavaScript中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。
String 类的常用方法都有那些？
indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。
在使用 HashMap 的时候，用 String 做 key 有什么好处？
HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以当创建字符串时，它的 hashcode 被缓存下来，不需要再次计算，所以相比于其他对象更快。
String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的
1.可变性
String类中使用字符数组保存字符串，private　final　char　value[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。
2.线程安全性
String中的对象是不可变的，也就可以理解为常量，线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
3.性能
每次对String 类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
对于三者使用的总结
如果要操作少量的数据用 = String
单线程操作字符串缓冲区下操作大量数据 = StringBuilder
多线程操作字符串缓冲区下操作大量数据 = StringBuffer

包装类相关

自动装箱与拆箱
装箱：将基本类型用它们对应的引用类型包装起来；
拆箱：将包装类型转换为基本数据类型；
int 和 Integer 有什么区别
Java 是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int 的包装类就是 Integer，从 Java 5 开始引入了自动装箱/拆箱机制，使得二者可以相互转换。
Java 为每个原始类型提供了包装类型：
原始类型: boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

Integer a= 127 与 Integer b = 127相等吗
对于对象引用类型：==比较的是对象的内存地址。
对于基本数据类型：==比较的是值。

如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer对象，而是直接引用常量池中的Integer对象，超过范围 a1==b1的结果是false

public static void main(String[] args) {
    Integer a = new Integer(3);
    Integer b = 3;  // 将3自动装箱成Integer类型
    int c = 3;
    System.out.println(a == b); // false 两个引用没有引用同一对象
    System.out.println(a == c); // true a自动拆箱成int类型再和c比较
    System.out.println(b == c); // true

    Integer a1 = 128;
    Integer b1 = 128;
    System.out.println(a1 == b1); // false

    Integer a2 = 127;
    Integer b2 = 127;
    System.out.println(a2 == b2); // true
}

单例设计

 如何设计才能保证如下类的实例对象在内存中只有一份?

1)让外界从一个池中获取对象 (池化思想)通过池保证实例只有一份
例如 integer a1 =100;
integer a2 =100;
System .out printle(a1a2)---------------------true
integer a3 =200;
integer a4=200;
System .out printle(a3a4)---------------------false

2)让外界直接通过类的静态方法获取类内部创建的静态的类的实例
1.适用于小对象线程安全高并发如果是大对象会有一部分内存占用
Class singleton01{
Static singleton01 instance =new singleton01();
Public singleton01{
Public static singleton01 getinstance(){
Return instance
2.适用于大对象单线程线程不安全
Class singleton02{
Public singleton02{}
Private static singleton02 instsnce;
Public static singleton02 getinstance(){
If(instsncenull){
instsnce =New singleton02()
}
Return instance
线程不安全?导致线程不安全的原因有哪些?
1)多个线程并发执行
2)多线程有共享的数据集
3)多个线程在共享数据上的操作不是原子操作
3.适用于大对象线程不是很多时线程安全
优化代码在保证线程安全的基础上尽量减少线程的阻塞
Class singleton03{
Public singleton03{}
Private static singleton03 instsnce;
Public static singleton03 getinstance(){
If(instsncenull){
Synchronized(singleton03.class){
If(instsnce==null){
instsnce =New singleton03()
}
Return instance
4.适合于大对象高并发线程安全高性能
Class singleton04{
Public singleton04{}
Static class inner(){
volatile static singleton04 instance=new singleton04() ;
}
Public static singleton04 getinstance(){
Return inner.instance;

JVM 指令重排序问题 instance=new singleton04() ;
系统底层会执行的指令
1)分配空间
2)对象属性的初始化
3)执行构造方法
4)将对象赋值给instance变量
JVM 默认会将性能优化的顺序为 1 4 2 3 也就是多线程访问时对象的属性可能还没有初始化出现出现高并发时线程不安全的问题
解决方法有两种

1.关键字 volatile 的作用 :

1.禁止指令的重排序 (JVM 对java 程序进行编译时会有指令重排)
2.保证内存可见性(多CPU 一个线程对共享变量的修改,另一个线程是可见的)
3.不保证原子性(synchronized 可以保证原子性)
对于volatile原理有两种说法:
在这里插入图片描述
第一种:就是说使用了volatile关键字以后不会使用CPU中的缓存而是直接去修改了JVM内存中的数据.
第二种:就是说使用了volatile关键字以后CPU2就会检测CPU1.达到可见性

2.ThreadLocal作用: 提供了一种线程绑定机制能够将某个对象绑定到当前线程也可以从当前线程获取某一对象,借助此对象可以实现线程内部的单例
应用场景:线程内部单例取消线程共享
例如存在的问题:SimpleDateFarmat 是一个线程不安全放在方法外实现共享线程不安全放在方法中会出现内存问题 ,每次调用时都会new 一个新的对象
在阿里的开发手册中写到使用时需要加锁加锁会影响性能或使用 DateTimeFormetter代替 SimpleDateFarmat 会使用ThreadLocal 泛型的方式
Private static ThreadLocal td =new ThreadLocal (){
@override
Initiatvalue(){
return new SimpleDateFarmat (“yyyy—”)
}
};
常用方法:get /set
应用的原理:

ThreadLocal的原理 :是将当前的线程作为key值将对象作为value值实现线程的绑定 (只能存一个Entry) 并且 Entry 还是一个弱引用.

基础语法

数据类型

Java有哪些数据类型

定义:java语言是强类型的语言,对于每一种数据都明确的具体的数据类型,在内存中分配了不同大小的内存空间.
分类:
1.基础数据类型
数值型整数类型: byte short int long 浮点类型: float double
字符类型: char
布尔类型:boolean
2.引用类型类,接口, 数组…
Java基本数据类型

Switch是否能作用在byte上,是否能够作用在long上,是否能够作用在String上?

在JDK5之前,switch(expr)中,expr的取值只能是 byte short int char
在JDK5以后开始引入了枚举类型
在JDK7以后expr还可以是String类型,但是long类型在目前的版本是不支持的

用有效率的方式计算2*8?

2<<3(左移3位相当于乘以2的3次方,右移3位相当于除以2的三次方)

Math.round(11.5) 等于多少?Math.round(-11.5)等于多少?

四舍五入的结构是在参数的基础上+0.5然后在取整所以 Math.round(11.5)返回值12 Math.round(-11.5)返回值是11

Float f=3.4;这样定义是否正确?

不正确,因为3.4是双精度数属于double类型属于向下转型需要强转 float f=(float)3.4;或者 float f=3.4F;

Short s1=1;s1=s1+1;有错吗?short s1=1;s1+=1;有错吗?

Short s1=1;s1=s1+1;由于 s1=s1+1 中1是int类型属于强转所以有错
而short s1=1;s1+=1;中s1+=1;相当于 s1=short(s1+1)其中有隐含的强转,所以可以正常编译.

编码

Java编码采用的是何种编码?有何特点?
Java语言采用的是Unicode编码标准,Unicode(标准码)它为每个字符制定了一个唯一的数值,因此在任何的语言平台,程序都可以放心的使用.

访问修饰符

访问修饰符 public protected private 以及不写默认时的区别?
Public是所有的类都可以访问
Protected是当前类当前包以及子类(就算子类不在当前的包下也可以访问)
Default 当前的包当前的类可以访问
Private只有当前的类可以访问

运算符

&与&&的区别?
&运算符的两种用法按位与(&)逻辑与(&&)
逻辑与和按位与之间的区别还是很大的:虽然两者都要求运算两边的Boolean运算都是true才为true,但是逻辑与(&&)又有短路运算,当左边的Boolean为false时直接短路不会进行右面的运算.
(|)与||之间的关系也是相似.

关键字

在这里插入图片描述

Java中有没有goto?

goto是java中的保留字,在目前版本中还没有使用.

Final有什么作用?

用于修饰类,属性,方法,修饰的类不能被继承,方法不能重写,变量不能被改变,不可变的是变量的引用,而不是引用所指向的内容,内容是可以改变的.

Final,finally,finalize区别

Final可以修饰类,方法,属性修饰的类不能被继承,方法不能重写,修饰变量表示该变量是一个常量,不能被重新赋值.
Finally是用在try catch中通常我们把必须要执行的代码放在finally中
Finalize是一个object提供的方法,用于垃圾回收时一个对象是否可回收是使用.

this关键字的用法

this关键字:是自身的一个对象,代表对象本身,可以理解为指向对象本身的一个指针.
使用场景为:
1.普通的直接引用,相当于指向当前对象本身
2.形参与成员变量名字重名时用this来区分
引用本类的构造方法

super关键字的用法

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
super也有三种用法：
1.普通的直接引用
与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。
2.子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分
3、引用父类构造函数
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
this与super的区别
super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
super()和this()均需放在构造方法内第一行,尽管可以用this调用一个构造器，但却不能调用两个。
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

Static关键字存在的主要意义

static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！
static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

Static独特之处
1、被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法不属于任何一个实例对象，而是被类的实例对象所共享。
(怎么理解 “被类的实例对象所共享” 这句话呢？就是说，一个类的静态成员，它是属于大伙的【大伙指的是这个类的多个对象实例，我们都知道一个类可以创建多个实例！】，所有的类对象共享的，不像成员变量是自个的【自个指的是这个类的单个实例对象】…我觉得我已经讲的很通俗了，你明白了咩？)
2、在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行初始化，注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。
3、static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。赋值的话，是可以任意赋值的！
4、被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。
static应用场景
因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。
因此比较常见的static应用场景有：
1、修饰成员变量 2、修饰成员方法 3、静态代码块 4、修饰类【只能修饰内部类也就是静态内部类】 5、静态导包
static注意事项
1、静态只能访问静态。 2、非静态既可以访问非静态的，也可以访问静态的。

流程控制语句

break ,continue ,return 的区别及作用
break 跳出总上一层循环，不再执行循环(结束当前的循环体)
continue 跳出本次循环，继续执行下次循环(结束正在执行的循环进入下一个循环条件)
return 程序返回，不再执行下面的代码(结束当前的方法直接返回)
在 Java 中，如何跳出当前的多重嵌套循环
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环

对象的特性

1)对象的核心特性:封装,继承,多态
其中Java 面向对象编程三大特性：封装继承多态
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。
多态性：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
2)扩展 :组合

封装特性:
广义封装:一个项目有哪些系统构成,一个系统有哪些模块,一个模块有哪些对象,对象又有哪些属性,对象与对象之间的关系
狭义封装:对象属性私有化,方法能公开就公开
继承特性:
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码
优势:实现代码的优化的复用,提高程序的扩张性
劣势:大范围的扩展会造成方法区的溢出,会降低类的可维护性
关于继承如下 3 点请记住：
子类拥有父类非 private 的属性和方法。
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。

实例1: LinkedHashMap LRU(缓存淘汰算法) 通过继承 LRU算法 :实现最少最近
linkedHashMap简介
1)存储结构:链表+散列表
2)存储算法:LRU+散列算法(哈希算法)
特性: 1)记录元素的添加顺序,访问数据

线程不安全(hashMap 本身就线程不安全 LinkedHashMap 继承 hashmap 只是添加了一个linked 对添加顺序)

多态特性:

1.编译时多态:方法重载名字相同参数列表不同
2.运行时多态
方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。
实现程序之间的解耦合,提高程序的可扩展性,返回值参数能用抽象就用抽象
LinkedLIst 记录key得顺序 map 记录对象的数据缓存 maxCap 记录容器最大的容器
原则: OCP 对扩展开发,对修改关闭
模式:装饰模式
方法: 组合
实现类似于mybatis的cache

?你了解的缓存有哪些?以及有什么区别?底层是什么?淘汰策略有哪些?有什么好处?
?基于缓存知识谈Spring中使用的缓存?与Mybatis中使用的缓存?使用了什么设计模式?有哪些优化的地方?
?我们知道spring会创建对象,当我们使用缓存时,spring创建的缓存是谁?以及它的淘汰策略是什么?
首先我们知道基于AOP的思想,会有一个过滤器我们spring中的过滤是:CacheInterceptor 将请求拦截下来以后再由CacheManager调用提供缓存:

public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {

	private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);  注意:业务层时会有线程安全问题所以使用的是单元格锁

	private boolean dynamic = true;

	private boolean allowNullValues = true;

	private boolean storeByValue = false;

	@Nullable
	private SerializationDelegate serialization;

?Mybatis中使用到的缓存有那些?有什么作用?淘汰策略是什么?用了什么模式?底层使用什么存储?
在这里插入图片描述
PerpetualCache:永久cache,不涉及淘汰策略,只负责存储 (使用HashMap)

public class PerpetualCache implements Cache {
     private final String id;
     private Map<Object, Object> cache = new HashMap<>();
     public PerpetualCache(String id) {
     this.id = id;
  }

FIFOCache: 先进先出只负责提供淘汰使用LinkedHashMap或者使用双端队列

public class FifoCache implements Cache {
  private final Cache delegate;
  private final Deque<Object> keyList;
  private int size;
  public FifoCache(Cache delegate) {
 ........
  @Override
  public Object removeObject(Object key) {
    return delegate.removeObject(key); 注意:在此处只是移除了缓存中的key值没有移除存储值.虽然没有使用此方法!
  }
  @Override
  public void clear() {
    delegate.clear();
    keyList.clear();
  }

LRUCache: 最近最少只负责提供淘汰策略 (注意:使用LinkedHashMap 存储结构:链表+hash表利用链表记录存储顺序,和访问顺序(构造方法)())

 public class LruCache implements Cache {
  private final Cache delegate;
  private Map<Object, Object> keyMap;
  private Object eldestKey;
 .....
  public void setSize(final int size) {
    keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
      private static final long serialVersionUID = 4267176411845948333L;

      @Override
      protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        boolean tooBig = size() > size;
        if (tooBig) {
          eldestKey = eldest.getKey();
        }
 return tooBig;

WeakCache:GC时清除缓存
SoftCache:内存不足时清除缓存
SynchronizedCache:线程安全加锁
LoggingCache:提供日志,显示命中率
SerializedCache:序列化缓存(保证字节码对象有一份,对象是多例)


```java
public class SerializedCache implements Cache {
  private final Cache delegate;
  .....
  @Override
  public void putObject(Object key, Object object) {
    if (object == null || object instanceof Serializable) {
      delegate.putObject(key, serialize((Serializable) object));
    } else {
      throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);
    }
  }
  @Override
  public Object getObject(Object key) {
    Object object = delegate.getObject(key);
    return object == null ? null : deserialize((byte[]) object);
  }
 .........
  private byte[] serialize(Serializable value) {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos)) {
      oos.writeObject(value);注意:默认使用了Java 的objectOutputStream
      oos.flush();    效率低速度慢 使用Kryo体积小,但是性能高! 但是它本身又有一些线程安全问题   我们使用了ThreadLocal解决的
      return bos.toByteArray();
    } catch (Exception e) {
      throw new CacheException("Error serializing object.  Cause: " + e, e);
    }
  }
  private Serializable deserialize(byte[] value) {
    Serializable result;
    try (ByteArrayInputStream bis = new ByteArrayInputStream(value);
         ObjectInputStream ois = new CustomObjectInputStream(bis)) {
      result = (Serializable) ois.readObject();
    } catch (Exception e) {
      throw new CacheException("Error deserializing object.  Cause: " + e, e);
    }
    return result;
  }

使用的模式: 装饰
Mybatis中的一级缓存以及二级缓存图如下:
在这里插入图片描述
Mybatis中的一级缓存:是在session创建的时候开启,并且多个的session之间是不能共享的,所以不存在多线程同时访问的问题,所以使用性能较高的 perp 底层使用hashmap
二级缓存:是多个session共享的,二级缓存的开启跟命名空间有关,session事务的提交或者关闭会保存到缓存中

面向对象五大基本原则是什么（可选）

单一职责原则SRP(Single Responsibility Principle)
类的功能要单一，不能包罗万象，跟杂货铺似的。
开放封闭原则OCP(Open－Close Principle)
一个模块对于拓展是开放的，对于修改是封闭的，想要增加功能热烈欢迎，想要修改，哼，一万个不乐意。
里式替换原则LSP(the Liskov Substitution Principle LSP)
子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~
依赖倒置原则DIP(the Dependency Inversion Principle DIP)
高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。
抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的抽象是中国人，而不是你是xx村的。
接口分离原则ISP(the Interface Segregation Principle ISP)
设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多。

Java两大抽象

抽象类和接口的对比
抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。
从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
相同点
接口和抽象类都不能实例化
都位于继承的顶端，用于被其他实现或继承
都包含抽象方法，其子类都必须覆写这些抽象方法
不同点

|参数|抽象类 |接口|
|–|–|–|–|
| 声明 | 抽象类使用abstract关键字声明 |接口使用interface关键字声明|
| 实现 | 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现 |子类使用implements关键字来实现接口。它需要提供接口中所有声明的方法的实现|
| 构造器 | 抽象类可以有构造器 |接口不能有构造器|
| 访问修饰符 |抽象类中的方法可以是任意访问修饰符 |接口方法默认修饰符是public。并且不允许定义为 private 或者 protected|
| 多继承 | 一个类最多只能继承一个抽象类 |一个类可以实现多个接口|
|字段申明 |抽象类的字段声明可以是任意的 |接口的字段默认都是 static 和 final 的|
备注：Java8中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。

接口:定义规范,标准
1)解耦:对象之间存在耦合时尽量耦合与接口,解耦并不是没有耦合
2)扩展:一个接口可以有很多的实现类
接口中的
1)属性默认都是static final 修饰的静态属性
2)方法默认都是抽象方法
3)但是 JDK8 以后接口中可以允许存在default方法可以添加方法体
JDK8以前接口(所有的方法默认都是抽象方法都需要重写)-------------->>通过抽象类当做适配器,抽象类中都是一些空方法========>类继承有选择性的去重写接口中的方法
[default方法的特点:适用于default关键字修饰可以有方法的实现(例如 JDK8 中的Collection接口)]
适用场景: 1扩展目标接口子类无需做任何修改
2取代抽象类中默认空方法的实现不再需要抽象类做适配器
4)JDK8以后在接口中允许直接定义静态方法
当现在有一个工具类此类中所有的方法都是静态方法,构造方法私有时候 JDK8 以后推荐是用接口
5)@functionInterface 函数接口
[特点:必须有一个抽象方法,且只能有一个可以有多个default方法或者多个静态方法]
应用场景:配合Lambda表达式应用
抽象类:对标准的部分共性作出实现,特性交给子类实现
普通类和抽象类有哪些区别？
普通类不能包含抽象方法，抽象类可以包含抽象方法。
抽象类不能直接实例化，普通类可以直接实例化。
抽象类能使用 final 修饰吗？
不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类
创建一个对象用什么关键字？对象实例与对象引用有何不同？
new关键字，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）

变量与方法

成员变量与局部变量的区别有哪些

变量：在程序执行的过程中，在某个范围内其值可以发生改变的量。从本质上讲，变量其实是内存中的一小块区域成员变量：方法外部，类内部定义的变量
局部变量：类的方法中的变量。

成员变量和局部变量的区别
作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结束后，就自动释放。
生命周期
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：当方法调用完，或者语句结束后，就自动释放。
初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，使用前必须赋值。
使用原则
在使用变量时需要遵循的原则为：就近原则
首先在局部范围找，有就使用；接着在成员位置找。

构造函数

在Java中定义一个不做事且没有参数的构造方法的作用
Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？
帮助子类做初始化工作。
一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
构造方法有哪些特性？
名字与类名相同；
没有返回值，但不能用void声明构造函数；
生成类的对象时自动执行，无需调用。

变量

静态变量和实例变量区别
静态变量：静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
实例变量：每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。
静态变量与普通变量区别
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

方法

静态方法和实例方法有何不同？
静态方法和实例方法的区别主要体现在两个方面：
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制
在一个静态方法内调用一个非静态成员为什么是非法的？
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
什么是方法的返回值？返回值的作用是什么？
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！

内部类

什么是内部类？
在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。
内部类的分类有哪些
内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。
静态内部类
定义在类内部的静态类，就是静态内部类。
静态内部类可以访问外部类所有的静态变量,而不能访问外部类的非静态变量;

public class Outer {
    private static int radius = 1;
    static class StaticInner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
        }
    }
}

成员内部类
定义在类内部，成员位置上的非静态类，就是成员内部类。
成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例(创建实例对象.成员内部类).

public class Outer {
    private static  int radius = 1;
    private int count =2;
     class Inner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
            System.out.println("visit outer   variable:" + count);
        }
    }
}

局部内部类
定义在方法中的内部类，就是局部内部类。
定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。

public class Outer {
    private  int out_a = 1;
    private static int STATIC_b = 2;
    public void testFunctionClass(){
        int inner_c =3;
        class Inner {
            private void fun(){
                System.out.println(out_a);
                System.out.println(STATIC_b);
                System.out.println(inner_c);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
    public static void testStaticFunctionClass(){
        int d =3;
        class Inner {
            private void fun(){
                // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                System.out.println(STATIC_b);
                System.out.println(d);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
}

匿名内部类
匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

public class Outer {
    private void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类" );
                }
            }
        }.method();
    }
 }
 //匿名内部类必须继承或实现一个已有的接口 
 interface Service{
    void method();
}

除了没有名字，匿名内部类还有以下特点
匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
内部类的优点
我们为什么要使用内部类呢？因为它有以下优点：
一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
内部类不为同一包的其他类所见，具有很好的封装性；
内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
匿名内部类可以很方便的定义回调。
内部类有哪些应用场景
一些多算法场合
解决一些非面向对象的语句块。
适当使用内部类，使得代码更加灵活和富有扩展性。
当某个类除了它的外部类，不再被其他的类使用时。
局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

public class Outer {
    void outMethod(){
        final int a =10;
        class Inner {
            void innerMethod(){
                System.out.println(a);
            }
        }
    }
}

以上例子，为什么要加final呢？是因为生命周期不一致，局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。

内部类相关，看程序说出运行结果

public class Outer {
    private int age = 12;
    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Outer.this.age);
        }
    }
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.print();
    }
}

结果:
局部变量：14
内部类变量：13
外部类变量：12

重写与重载

构造器（constructor）是否可被重写（override）
构造器不能被继承，因此不能被重写，但可以被重载。
重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。
重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

对象相等判断

== 和 equals 的区别是什么
== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
说明：
String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

hashCode 与 equals (重要)

HashSet如何检查重复
两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？
hashCode和equals方法的关系
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”
hashCode()介绍
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode()函数。
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
为什么要有 hashCode
我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：
当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
hashCode()与equals()的相关规定
如果两个对象相等，则hashcode一定也是相同的
两个对象相等，对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的
因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
对象的相等与指向他们的引用相等，两者有什么不同？
对象的相等比的是内存中存放的内容是否相等而引用相等比较的是他们指向的内存地址是否相等。

值传递

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递
是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的
为什么 Java 中只有值传递
首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。它用来描述各种程序设计语言（不只是Java)中方法参数传递方式。
Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。
举例说明一下:

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;
    swap(num1, num2);
    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}
public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

结果:
a = 20
b = 10
num1 = 10
num2 = 20
通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，

 public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        System.out.println(arr[0]);
        change(arr);
        System.out.println(arr[0]);
    }
    public static void change(int[] array) {
        // 将数组的第一个元素变为0
        array[0] = 0;
    }

结果:
1
0
array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。因此，外部对引用对象的改变会反映到所对应的对象上。
通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。
很多程序设计语言（特别是，C++和Pascal)提供了两种参数传递的方式：值调用和引用调用。有些程序员认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s1 = new Student("小张");
        Student s2 = new Student("小李");
        Test.swap(s1, s2);
        System.out.println("s1:" + s1.getName());
        System.out.println("s2:" + s2.getName());
    }
    public static void swap(Student x, Student y) {
        Student temp = x;
        x = y;
        y = temp;
        System.out.println("x:" + x.getName());
        System.out.println("y:" + y.getName());
    }
}

结果:
x:小李
y:小张
s1:小张
s2:小李
通过上面两张图可以很清晰的看出：方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝
总结
Java程序设计语言对对象采用的不是引用调用，实际上，对象引用是按值传递的。
下面再总结一下Java中方法参数的使用情况：
一个方法不能修改一个基本数据类型的参数（即数值型或布尔型》
一个方法可以改变一个对象参数的状态。
一个方法不能让对象参数引用一个新的对象

值传递和引用传递有什么区别
值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷贝，也就是说传递后就互不相关了。
引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。

Java包

JDK 中常用的包有哪些
java.lang：这个是系统的基础类；
java.io：这里面是所有输入输出有关的类，比如文件操作等；
java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；
java.net：这里面是与网络有关的类；
java.util：这个是系统辅助类，特别是集合类；
java.sql：这个是数据库操作的类。

import java和javax有什么区别
刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来说使用。然而随着时间的推移，javax 逐渐的扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包将是太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。
所以，实际上java和javax没有区别。这都是一个名字。

IO流

java 中 IO 流分为几种?
按照流的流向分，可以分为输入流和输出流；
按照操作单元划分，可以划分为字节流和字符流；
按照流的角色划分为节点流和处理流。
按照操作方式分类结构图:
BIO,NIO,AIO有什么区别?
BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。
详细回答
BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
Files的常用方法都有哪些？
Files. exists()：检测文件路径是否存在。
Files. createFile()：创建文件。
Files. createDirectory()：创建文件夹。
Files. delete()：删除一个文件或目录。
Files. copy()：复制文件。
Files. move()：移动文件。
Files. size()：查看文件个数。
Files. read()：读取文件。
Files. write()：写入文件

泛型

泛型 :参数的一种类型,使用的参数可理解为形参编译时的一种类型此类型仅仅在编译时有效运行时无效
1.Class a <a,b,c,d>{} 正确
2.Interface IA <k,v>{} 正确
3.List list =new ArrayList(); 错误泛型中Object不是所有类的父类 List<? extends Object> 4.Listlist=new ArrayList(); 错误泛型中Object不是所有类的父类 List<? super String> 5.List List =new ArrayList(); 错误 6.Class AB extends ArrayList{} 正确 7.Class AB extends ArrayList{} 正确 8.Class AB extends ArrayList{} 正确 9.Class AC extends HashMap

序列化与反序列化

序列化和反序列是java进行数据存储和数据传输的一种方式
1)对象序列化:将对象转换为字节的过程对象转化为字符串的也叫序列化
2)对象反序列化:将字节转化为对象的过程字符串转化为对象也叫反序列化
对象序列化与反序列化的实现
1)对象直接或间接事项serializable接口
2)添加序列化id 为反序列化提供保障
说明:serializable接口只起一个标志性的作用,序列化的顺序是一体的先序列化的先反序列化

装饰模式:
在这里插入图片描述
可以序列化到磁盘中,内存中,或者是网络中
Public Class SerializedCache implements Cache{
Private Cache cache;
Public SerializedCache (Cache cache){
This.cache=cache;
}
将对象实现序列化为字节码
Private Byte[] serialize(Object object){
ObjectOutPutStream oos=New ObjectOutPutStream(bos);
ByteArrayOutStream bos=New ByteArrayOutStream();
Oos.writeObject(Object);
Byte[] array= bos.toByteArray();
Oos.close;
Bos.close;
Return array;
}
对象反序列化为对象
Private Object deserialize(Byte[] array){
ObjectInPutStream ois=New ObjectOutInStream(bis);
ByteArrayInStream bis=New ByteArrayInStream(array);
Ois.close;
Bis.close;
Return ois.readobject();

@orerride 序列化存储
Public void putObject(Object key, Object value){
Byte[] array=Serialize(value);
Cache.putObject(key,array);}
@orerride 反序列化为对象
Public object getObject(Object key){
Byte[] array=Cache.getobject(key)
Object object =Deserialize(array);
Return object;
分析:序列化缓存线程安全(每次从缓存中拿出的对象都是基于字节码对象复制出来的新对象)
之前写的加锁的缓存已经解决了线程安全问题 ,但是序列缓存与加锁的缓存的应用场景不同 .加锁的缓存是阻塞式只允许一个进入而序列化的缓存是每次拿出的都是一个新的对象线程与线程之间对象不干扰

序列化的粒度如何控制?
1)不需要序列化的属性使用 transient 关键字修饰
2)让序列化对象实现Externalizable 接口要序列化的对象对应的类必须使用public修饰(一个.Java文件中只能有一个public修饰的类)
序列化的性能问题及如何优化?

Kryo	hession	java	protostuff
优势:速度快,序列化后体积小劣势:跨语言支持较复杂	默认支持跨语言,较慢	使用方便可序列化所有的类 ,速度慢占空间	速度快基于 protostuff,需要静态编译
为什么Kryo的速度快?
默认的objectoutputstream 性能较差 kryo 自己写了一个流 output
为什么Kryo占空间小?
序列化的时候扔掉了元数据
Mybatis中的序列化缓存存在可优化的问题速度慢效率低,使用第三方的kryo框架写一个工具类解决但是 kryo本身又存在一些问题例如线程不安全我们使用了 threadlocal
Dubbo框架中也支持了 kryo 和 FSt 作为序列化

枚举

枚举:基于枚举更好的限定变量的取值
Public enum Retentionpalicy{
SOURCE, CLASS,RUNTIME; n 个对象每个枚举对象默认有一个无参构造必须私有
基于枚举的单例模式:
Enum singleton{ 饿汉式单例:类加载时就加载
Instance;}

注解

@Retention() 描述何时有效默认是编译时有效
@Target()描述类型
@interface Entry{
}
如何知道一个类上的注解?(通过反射)
1.获取字节码对象
2.获取类上的注解
getDeclaredAnnotation(Entry.class)
如何获取属性上的注解>?
GetDeclaredFieldId(“id”)

线程

有关线程的知识https://blog.csdn.net/weixin_45970468/article/details/104756136

线程与进程
进程:操作系统中资源分配的基本单位.
线程:是在进程中任务调度和执行的基本单位.
线程的创建
继承Thread(重写run方法,启动线程)
实现Runnable
线程的辅助工具
- 线程池Executors :
  1. newFixedThreadPools()创建最大线程数为5
  2.newCacheThreadpool()足够多的线程有空闲任务就会创建
  3.newSingleThreadExecutor()只创建一个线程
  线程池pool配合 execute()将数据丢进线程池没有返回值
- Callable/future: future 凭证小票
  Future与submit()方法进行配和使用,也是将数据丢进线程池返回一个凭证小票.如果是实现Runnable则返回的小票没有结果,执行future.get()方法只是进行线程暂停进行下一项,如果是实现了callable 则有返回值并且可以获取返回值.
  Callable与Runnable的区别:Runnable 不能抛异常,不能有返回值
  Callable是在Runnable上可以抛出异常,可以有返回值
线程的状态
线程的5种状态: 新建,可执行,执行,阻塞,销毁

当新建的线程执行了start()方法的时候进入可运行线程池中,变的可运行,等待获取CPU的使用权,执行状态就是线程获取了CPU的使用权.阻塞状态就是线程因为某种原因放弃了CPU的使用权,暂时停止了运行,直到线程重新就绪,才可以继续执行销毁状态就是正常结束或者出现异常 return
阻塞的情况有三种:
1. 等待阻塞:运行的线程执行了 wait()方法进入了等待池,只有等到 notify() notifyAll()才重新获取锁运行
  2.同步阻塞:运行的线程在获取对象的锁的时候,若该对象的同步锁被别的线程占用,会将该线程放进锁池中
  3.其他的阻塞:运行的线程执行了sleep()或者join()方法或者发出了IO请求时
线程的方法
Thread.currentThread() 获取当前线程的实例
Thread.sleep()让线程暂停
Thread.yield() 放弃CPU时间
GetName() setName() 获取线程的名字和设置
Interrupt() 打断线程的执行
Join() 一个线程等待另一个线程结束
SetDaemon()后台线程
线程的同步
Synchronized的三种方式:
1. synchronized (对象){} 共享代码
2. Synchronized void f(){} 抢当前实例的锁
3. Static synchronized void f(){} 抢当前类的锁
乐观锁与悲观锁
Synchronized 与lock

Synchronized (悲观锁)
Lock(乐观锁)
|=>>ReentrantLock 重入锁
|=>>>ReentrantReadWriteLock 重入读写锁
方法: Lock()
unLock()
Volatile与ThreadLocal
见之前的单例设计
sleep与wait的区别
Sleep()是线程(Thread)类的方法,导致此线程的暂停执行指定时间,把执行机会给其他的线程,但是监控状态依然保持,到时候会自动回复.调用sleep()不会释放对象锁.
Wait()是Object类的方法,对此对象调用的wait()方法导致本线程放弃了对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify()方法(或notifyAll())后线程才进入对象锁定池准备获得对象锁进入运行状态.

集合

集合其他的内容https://blog.csdn.net/weixin_45970468/article/details/104481422
这里我们就简单的讲一件hashMap(散列表)

HashMap简介:内部是Entry[]数组存放对象(键值对的形式,用键快速定位查找,提取对应的数据,注意键不可重复重复会覆盖)
流程如下
key.hashCode()获取键的哈希值,用哈希值和数组的长度来计算下标,新建一个Entry实例来封装键值对数据,将Entry对象放在指定的下标位置
这里注意:
- 如果是空的话,直接放入
- 如果有数据的话,依次使用equals()比较键是否相等,如果键相等的话直接覆盖,如果不相等的话,链表连接在一起
  
  链表长度达到8时,会转化为红黑树(平衡的二叉树)减少到6时会转回链表
Hashmap是后端面试常客,比如默认的初始容量是多少?加载因子是多少?是线程非安全的码?put,get,操作简单说一下?在jdk1.7与1.8实现上有什么不同?

针对1.8:
我们在使用hashmap 的时候,如果用默认的构造器,就会建一个初始容量为16,加载因子为0.75的Hashmap.这样做的缺点,就是数据量比较大时,会进行频繁的扩容操作,扩容会发生数据的移位,为了避免扩容,提高性能.看源码:

解决两个问题?1.如何设置比初始容量大的最小的2的幂次方整数?
通过源码我们可以知道hashmap容量最大值是2^30 ,也就是说Hashmap的数组部分的长度的范围是[0, 2^30]然后计算比初始容量大的最小的2的幂次方整数,其中tableSizeFor方法是重点,我们看源码:

这个方法设计的非常的巧妙,因为Hashmap要保证容量是2的整数次幂,该方法实现的效果就是如果你输入cap 本身就是偶数时会返回cap本身;如果输入的cap是奇数时,返回的就是比cap大的最小的2的整数次幂.
为什么容量可以保持2的整数次幂?
因为获取的key在数组中对应的下标识通过key的哈希值与数组长度-1进行运算的,如tab[i=(n-1)&hash]
1.n为2的整数次幂,这样n-1后,之前的为1 的位数后面就全是1,这样就能保证(n-1)&hash后相应的位数既有0有可能有1,这取决于hash的值,这样能够保证散列的均匀,同时与运算的效率高
2.如果n 不是2的整数次幂会造成很多次的hash冲突
该方法首先执行了cap-1操作,这样的好处就是避免了cap是偶数次,最后计算的数是cap的2倍的情况,因为设置的偶数cap就已经满足了Hashmap的要求了,没有必要要初始化一个2倍容量的hashmap了
前面我们已经介绍了HashMap的最大的容量是2^30,所以容量的最大就是30bit的整数,假如我们就用30位的一个数演示以下算法的移位取或的操作,假设 n=001xxxxx xxxxx xxxxx xxxxx xxxxx xxxxx(x代表的是0或者是1我们不用担心)
第一次右移 n|=n>>>1 该操作,使用n本身和n右移移位以后的数进行或操作操做代码如下:

最后会对n和最大的容量作比较,如果>=2^30, 就取做大容量,如果<2^30,就对n进行+1操作,因为后面的位数都为1,所以+1就相当于找比这个数大的最小的2的整数次幂.
hashmap中对key做hash处理时,做了什么特殊的操作?
首先我们知道HashMap在做Put操作是会对key做hash操作,直接定位源码的位置:

可以看出在对key进行操作是操作了 (h=key.hashCode())^(h>>>16)

这个操作是将key的hashCode值与hashCode值右移16位异或,这样就是把哈希值的最高位和最低位一起混合计算,这样就使得生成的hash值更离散
哈希冲突:通过前面的说明,我们知道数组的容量范围[0~2^30],比如我们默认的大小16.假设三个不同的key生成的hashCode 低于16位的完全一样,但高于16位的不同,在计算他们在数组中的下标时通过(n-1)&hash 这里n是16 -1就是15 15的二进制000000000…1111
最后三个数与15的二进制 &运算通过计算他们会被放在同一个下标下的链表或红黑树下显然不符合我们的预期.
解决hash冲突:右移16位后在进行异或操作解决了哈希碰撞问题,思想就是把最高位和低位进行混合计算,提高分散性.

框架

在这里插入图片描述

Mybatis 与jdbc
mybatis相关内容点击链接https://blog.csdn.net/weixin_45970468/article/details/104906551
Jdbc是java提供一种操作数据库的API 对数据库进行操作时需要注册数据库驱动,获取连接,获取传输器发送sql语句处理结果集释放资源等操作这个过程中有很多的重复的代码和操作而且sql语句分布在每个类中可读性差不利于维护
Sql------------>数据库
而mybatis是基于ORM思想框架封装了jdbc是一个支持sql语句查询,储存和高级映射的优秀的持久层框架,mybatis 几乎消除了所有的jdbc代码和参数的手工设置使用简单的Xml文件和注解与Dao层接口和数据库中的记录映射以及对结果集进行封装成为pojo对象

ORM思想描述对象与数据库之间的映射的元数据将面向对象语言程序中的对象自动持久化到关系数据库中

Mybatisplus是如何实现不需要写SQL语句的?
1)接口实现baseMapper接口,动态的转化为SQL语句
2)利用注解使得pojo中的对象名与表名属性与字段对应实现映射关系
JSP与servlet的关系
Jsp与servlet的区别
Jsp是servlet技术的扩展,本质上就是一个servlet的简易方式.
两者都是实现了与HTML的呈现数据的功能
只不过是jsp更擅长于前端页面的呈现 servlet则是后端的逻辑的处理

Servlet 是在java代码中通过httpservletResponse对象动态的输出HTML内容 servlet在Java中通过的是字符串的拼接这样做就是在后期维护会很困难可读性差
Jsp 呈现数据是将java代码嵌入在HTML中当被动态执行后生成Html的内容虽然避开了 servlet的劣势但是将太多的java代码和一些逻辑混入HTML中也是不可取的
所以我们扬长避短通过mvc的思想将servlet放在controller中将jsp放在view中
JSP的作用域有哪些?以及作用范围?
范围从小到大为:
Page域, 在当前页面有效,即在当前的一个jsp页面上是有效的
Request域在当前请求中有效,在整个请求阶段都是有效的
Session域在当前会话中有效,从浏览器访问开始这个指的是用户一个访问,到访问结束
Application域作用于从服务器启动到关闭整段时间在所有的应用程序中有效
Ajax

常见的Ajax方法有几种? get post getjson Ajax
第一种:$.get(url,参数,callback返回函数,数据类型),示例如下

  //利用jQuery 加载页面    函数式编程
               $(function(){
                   //发送ajax 请求  获取用户页面数据
                   /*jQuery 的参数有四个
                      url:待载入 页面Url地址
                      data:待发送的key  value参数
                      callback:载入成功时的回调函数
                      type :返回的内容格式,xml   HTML   script json 等
                   */
                   $.get("/findAjaxUser",function(result){
                       //result是返回的数据 格式为json 被Js对象解析为js对象
                       //获取状态码信息
                       if(result.status==200){
                              addTr(result.data)
                           }else{
                                 alert(result.msg)
                               }
                      
                      function    addTr(data){
                             var trs=" "
                             $(data).each(function(index,user){
                                 /*    var id= data[index].id
                                    var name=data[index].name
                                    var  age=data[index].age
                                    var sex=data[index].sex */
                                    var id=user.id;
                                     var name= user.name;
                                    var age= user.age;
                                     var sex= user.sex;
                                    trs+= "<tr><td>"+id+"</td><td>"+name+"</td><td>"+age+"</td><td>"+sex+"</td><td><a href='doDeleteById?' class='delete'>删除</a> <a href='#' class='update'>修改</a></td></tr>"
                                    })
                                     $("#tableId") .append(trs);
   /*Ajax常见的方式有四种   get post getJson Ajax  最重要的是 Ajax
            	请求方式有四种  get   相当于  select   用于 获取数据
            	                          post 相当于  save     用于提交数据
            	                          put   相当于 update 用于修改数据
            	                          delect 相当于 delect 用于删除数据
            	数据的参数类型有两种形式
            	                          1.{key:value,key2:value2}
                                           2.key1=value1&key2=value2
         */
                   $.ajax({
                           url: "/findAjaxUser",
                           type: "get",
                           data: "id=1&name=tomcat",
                           async:  true,  //默认是异步,如果是嵌套Ajax嵌套关系  考虑同步的情况
                           success: function(data){
                              //程序执行成功以后执行的回调函数     
                               },
                           error:  function(){
                                 alert("服务器正在维护!!!")
                                 }
                       });

Spring
spring中有两大核心:
1.IOC控制反转
2.AOP面向切面编程
其他的都是辅助者两个核心做的辅助
SpringIOC如何理解?
IOC是spring中提供的一种控制反转机制目的就是将我们项目中的对象的依赖管理交给 spring来管理,这样可以更好的实现对象之间的解耦,提高程序的可扩展性
IOC 控制反转一般创建对象是由开发者来创建和维护控制反转就是将对象的创建和生命周期的管理交给spring管理
核心思想:框架解耦
案例 jdbc 和 mybatis框架
DI依赖注入
Set注入
构造方法注入
Spring是如何管理对象的
1)配置信息 <bean id=” ” , class=” ”/>
2)注解
底层是map<k,v>的形式如果是配置文件 k是id v是class对应的类 (利用反射机制是调用的是对象的无参构造)
如果是注解的话 k是类名 v是类
Spring是如何管理对象的生命周期
1)单例容器启动时对象创建容器销毁对象销毁
2)多例什么时候使用什么时候创建对象使用完成之后销毁
3)懒加载:概念只是延迟加载什么时候使用什么时候创建
Aop与oop的联系与区别
oop 面向对象编程思想,核心思想是将客观存在的事物抽象成相互独立的类,然后把事物的属性和行为封装类中,并通过继承与多态来定义彼此间的关系,最后通过操作类的实例对象来完成实际业务的逻辑功能需求.
Aop面向切面编程思想,核心思想是将业务逻辑与类不相关的通用功能切面式的提取分离出来,让多个类共享一个行为,一旦这个行为反生改变不需要修改类只需要修改这个行为即可
Oop与Aop的联系:两者是一个相互补充相互完善的关系
Oop与Aop的区别:1.oop面向对象的目标是名词类型而Aop面向切面的目标是动词类型
2.oop面向对象的结构是一种纵向的结构 Aop面向切面的结构是一种横向的结构
3.Oop注重业务逻辑单元的划分而Aop侧重于业务处理过程中某个阶段或某个过程
Aop步骤:1.添加Aop的依赖 Spring 整合 AspectJ框架
2.创建Aspect的实体类 @Aspect @component @slf4j
|-------1.切入点方法 pointCut() @point(四种定义的方式
| bean: 指定bean对象的方法
| within:指定包下所有的类的方法
| @annotation :指定注解修饰的方法
| execution:指定语法下修饰的方法)
|-------2.通知方法五种通知方法
1.@Around 2.@before 3.@After 4.@AfterThrowing 有异常时抛出5.@Afterreturning
Spring Aop原生方式的实现
DefaultAdvisorAutoProxyCreator 实现了BeanProcessor 接口当ApplicationContext
读取Bean信息以后这个类会扫描上下文寻找所有的Advisor(切入点与通知的总称) 并将所有的Advisor 应用到符合切入点的Bean
SpringMvc
SpringMVC封装了servlet与浏览器进行交互
首先servlet 是一种后端服务器与前端交互作用操作从httpservletrequest 中获取参数的值封装到 request域中呈现给前端页面
SpringMVC 框架是一种封装了servlet 并且分离了控制层模型对象视图呈现等各个角色各司其职这种分离更容易定制而且将降低了开发难度不是象servlet 一个servlet只能处理一个请求而是通过前端控制器进行操作不同的请求
流程:首先用户发送请求 -->前端控制器根据用户的url 查询handlermapping(底层是一个map集合 k是一个映射路径,v是个要执行的方法) 通过适配器从而定位到了准确的controller 执行controller service Dao 访问数据库并且返回modelandview 前端控制器在调用视图解析器将数据呈现
SpringMvc核心拦截器
SpringMVC参数提交方式
1.简单类型提交
2.采用对象接收参数
为对象的应用赋值
Springboot
Springboot:基于spring框架的基础上.使用spring启动,我们避免了之前我们必须做的所有的样板和配置.可以帮助我们开发人员以最少的工作量,开箱即用的使用Spring的功能
Springboot有哪些优点?
1)减少开发,测试的时间和工作量.
2)使用javaConfig 有助于避免Xml
3)避免大量的Maven导入和各种版本的冲突
4)通过提过默认值快速开始开发
5)没有单独的web服务器需要,不需要启动Tomcat,或其他的东西
6)需要更少的配置,没有很多的xml文件只需添加注解类
Springboot源码以及配置文件的总结:
Pom.xml文件中

定义的是自己的打包位置

<groupId>com.jt</groupId>
	<artifactId>springboot-demo1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-demo1</name>
	<description>Demo project for Spring Boot</description>

一般打包的位置有两个一个就是target下面的的jar或者是war包另一个就是在本地的maven库中生成

<!-- 定义了父级的依赖项 -->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.2.2.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

为什么我们可以使用mvc而不需要以前配置很多的配置做到开箱即用是因为springboot启动器中已经帮我们配好;

 <!-- 开箱即用 spring-boot-starter  springboot的启动器   -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

Springboot的主启动类中,为什么只用一个main方法启动的确是一个Tomcat

@SpringBootApplication
public class SpringbootDemo1Application {
	public static void main(String[] args) {
		SpringApplication.run(SpringbootDemo1Application.class, args);
	}
}

查看springbootApplication源码

@Target(ElementType.TYPE)  表示作用的是类
@Retention(RetentionPolicy.RUNTIME) 作用范围是运行时
@Documented 修饰文档
@Inherited 继承关系
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),  排除过滤器
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

最重要的就是springbootconfiguration就是一个配置文件和 EnableAutoConfiguration 查看源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

查看它的自动扫描包源码

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
		@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImport(metadata).getPackageName());
		}

也就是说自动扫描具有注解的包下面的类
Springboot的配置信息只能是在pom文件中有配置

  <include>**/application*.yml</include>
          <include>**/application*.yaml</include>
          <include>**/application*.properties</include>

Springboot读取配置信息

jdbc:
   name: mysql数据库
   jdbcDriver: mysql驱动

其中的一种只适合于较少的读取,如果读取较多的配置信息是就会显得代码冗余

/**
	 * 1.yml文件信息已经交给了spring容器管理
	 * 2.用key从容器中动态的获取
	 * 3.利用spel表达式动态获取spring自己提供的
	 * @return
	 */
	    @Value("${jdbc.name}")
	   private String jdbcName;
	    @Value("${jdbc.jdbcDriver}")
	   private String jdbcDriver;
	    //动态获取yml文件并进行呈现数据
	@RequestMapping("/jdbc")
     public String JDBCMsg() {
		return jdbcName+":"+jdbcDriver;
    	 
     }

第二种读取配置文件的信息就会适合很多的配置信息读取

Jdbc2:
   name: mysql数据库
   jdbcDriver: mysql驱动

需要添加一个jar包
<

!--添加属性注入依赖 -->
			<dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-configuration-processor</artifactId>
				<optional>true</optional>
			</dependency>

@ConfigurationProperties(prefix = "jdbc2")
public class JDBCController2 {
	/**
	 * 1.yml文件定义属性
	 * 2.属性名称与yml名称一致
	 * 3.jar包
	 * 4.根据前缀注入数据
	 * 5.注入时需要添加set方法
	 * @return
	 */
	   private String Name;
	   private String jdbcDriver;
	   
	    public String getName() {
		return Name;
	}

	public void setName(String Name) {
		this.Name = Name;
	}

	public String getJdbcDriver() {
		return jdbcDriver;
	}

	public void setJdbcDriver(String jdbcDriver) {
		this.jdbcDriver = jdbcDriver;
	}

第三种方法通过配置文件为属性赋值

jdbc3.name=mysql
jdbc3.driver=mysqlDriver

@PropertySource("classpath:/properties/jdbc.properties")
//@PropertySource({@PropertySource("classpath:/properties/jdbc.properties")})
public class JDBCController3 {
	  @Value("${jdbc3.name}")
      private String name;
	  @Value("${jdbc3.driver}")
      private String jdbcDriver;
	  //动态获取yml文件中的数据 之后展现
	  @RequestMapping("/jdbc3")
	  public String jdbcMsg() {
		return name+":"+jdbcDriver;

总结读取springboot的配置文件中的信息的方法有两种:
1.就是使用@value注解括号中的格式${“xxx.xxx”} 弊端就是适合读取较少的配置信息
2.使用ConfigurationProperties(prefix = “jdbc2”)注解需要引入属性注入的jar包并且属性名一定的和yml中的名称相同,并且还要有get.set方法
3.使用配置文件为属性赋值 propertySource(“classpath+配置文件的路径”)++@value属性
Springboot用于分别读取开发和上线的配置文件
spring:
profiles:
active: prod
—分割线

spring:
  profiles: dev
---
 spring:
  profiles: prod

Json介绍

对象格式(无序的)
{“key1”:”value1”}

数组格式(有序的)
[“value1”,”value2”]
复杂格式(嵌套的)

RestFul风格

1.实现通用页面的跳转

 /**实现页面通用的跳转
	  * /page/item-add'
	  * page/item-list
	  * /page/item-param-list'
	  * 实现步骤
	  * 1.将变量使用/的方式进行分割
	  * 2.使用{}的方式包裹数据
	  * 3.实现数据的转换  参数+注解
	  */
	  @RequestMapping("/page/{modelName}")
	  public String ItemAdd(@PathVariable String modelName) {
		return modelName;
		  
	  }

2.简化url地址的写法
需求:只是用”/user”实现增删改查的功能
实现策略:可以通过不同的请求方式实现CRUd操作
案例1.
Url:”/user” method=”get” requestMapper 只接受get请求实现查询
Url:”/user” method=”post” requestMapper 只接受post请求实现新增

 @GetMapping("/user")
	  public String getUser() {
		return null;
		  
	  }
 @PostMapping("/user")
	  public String saveUser() {
		return null;
		  
	  }

Shiro
有关shiro框架的知识https://blog.csdn.net/weixin_45970468/article/details/104755697
Shiro 框架是一个开源的安全框架,它将软件系统中的安全认证等功能提取出来实现用户的身份认证,权限授权,加密,会话,缓存等功能的管理组成一个通用的安全认证框架

1.shiro身份认证的过程分析及实现(判定用户身份的合法性),为什么要认证?
2.Shiro授权过程分析及实现(对资源访问进行权限授权)为什么要授权?
3.Shiro 缓存,会话时长,记住我等功能的实现.为什么要使用此缓存,是否可以使用第三方缓存?
4.Shiro框架的核心组件?Shiro中的session的默认时长是多少?
?Shiro 缓存,会话时长,记住我等功能的实现.为什么要使用此缓存,是否可以使用第三方缓存?
Shiro缓存中底层使用的softHashMap 在JVM内存满时清除缓存!
使用缓存的原因是因为每次进行授权的时候,都要进行查询数据库中多张表的操作,如果在高并发的时候使用缓存更能提高性能!

?记住我功能的实现,以及为什么要设计这个功能?
记住我功能是shiro框架自己带的特性,需要在服务器端创建cookie 在客户端存储用户信息.所以要打开cookie,服务器配置cookiemanager 同时注入给安全管理器修改过滤信息
设计记住我功能是因为用户选择性的使用,记住我可以实现不用每次登陆都需要验证
?Shiro中使用的会话是谁?httpsession默认时长?30分钟

 private Cookie sessionIdCookie;
    private boolean sessionIdCookieEnabled;
    private boolean sessionIdUrlRewritingEnabled;
    public DefaultWebSessionManager() {
        Cookie cookie = new SimpleCookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
        cookie.setHttpOnly(true); //more secure,

我们使用了 ShiroHttpSession查看源码:

public class ShiroHttpSession implements HttpSession {
    //TODO - complete JavaDoc
    public static final String DEFAULT_SESSION_ID_NAME = "JSESSIONID";
    private static final Enumeration EMPTY_ENUMERATION = new Enumeration() {

? 我们来猜测我们使用的shiro中的session是否是web HTTP中的HTTPSession,以及它的调用过程是怎样的呢?
?通过我们断点跟踪发现确实是将数据存到了HTTPSession 但是却没有执行它的实现类中任何add以及put 的方法,那么它是如何实现将数据存储到HTTPSession中的呢?
这时候我们就假设它并不是继承或者实现而是一种has a关系我们查看了原来shiro 自己还有一个Session接口,源码如下:
在这里插入图片描述
通过断点我们得出了shiro 使用了 SimpleSession 同时注入了HttpServletSession 在HttpServletSession源码构造方法中我们可以看出has a httpSession

public class HttpServletSession implements Session {
    private static final String HOST_SESSION_KEY = HttpServletSession.class.getName() + ".HOST_SESSION_KEY";
    private static final String TOUCH_OBJECT_SESSION_KEY = HttpServletSession.class.getName() + ".TOUCH_OBJECT_SESSION_KEY";
    private HttpSession httpSession = null;
    public HttpServletSession(HttpSession httpSession, String host) {
        if (httpSession == null) {
            String msg = "HttpSession constructor argument cannot be null.";
            throw new IllegalArgumentException(msg);
        }

如何实现存储?直接调用了put方法

  public void setAttribute(Object key, Object value) {
        if (value == null) {
            removeAttribute(key);
        } else {
            getAttributesLazy().put(key, value);
        }
    }

HttpClient与JSONP区别?

HttpClient(重点知识)
业务说明:当用户点击前台服务器是需要连接后台服务器返回商品数据
Httpclient介绍
支持http协议的API
Jsonp(跨域)
本地访问本地服务器 json数据能够访问的到
远程访问本地服务器因为同源策略的 (协议名称://域名:端口号都相同满足同源策略浏览器能够访问并且能够解析返回数据但是如果不满足则能够访问却处于安全考虑不能够解析返回数据)
跨域访问的原理
1.利用JavaScript中的src属性可以实现跨域访问
2.定义回调函数callback
3.将返回值结果进行特殊的形式的封装 callback(json数据)
总结httpclient与jsonp的区别
1.发送的请求的位置不同:
JSONP:浏览器解析js发出的请求
HttpClient:是业务层java模拟发出的HTTP请求
2.返回值的格式不同
JSONP:返回数据是必须要有回调函数.
HttpClient:直接返回JSON数据即可
3.代码的层次不同
JSONP:代码层次一般3层
HTTPClient:一般5层
Dubbo

在这里插入图片描述
SOA:面向服务编程
模式:代理模式
Dubbo含义:高性能,轻量级开源的java RPC框架,提供了三大核心能力:
1)面向接口的远程方法调用
2)智能容错和负载均衡
3)服务的自动注册和发现.
Dubbo支持哪些协议,每种协议的应用场景,优缺点?
1.dubbo:单一长连接和NIO异步通讯,适合大并发小数据的服务调用,消费者远大于提供者传输协议 TCP,异步,Hessian序列化;
2.Rmi:采用JDK标准的rmi协议实现传输和返回参数对象需要实现serializable接口.使用Java标准序列化机制,使用阻塞式短连接,传输数据包大小混合,消费者与提供者差不多,可传文件,传输协议TCP.同步传输.适合常规的远程调用和rmi互操作.但是在低版本的包中,java序列化存在安全漏洞.
3.Webservice:基于WebService的远程调用协议集成CXF实现,提供原生的webservice的互操作.多个短连接,基于http传输,同步传输,适用于系统集成和跨语言调用
4.http:基于http表单提交的远程调用协议,集成Spring的HTTPInvoke实现.多个短连接,传输协议:HTTP,传输参数大小混合,提供者个数大于消费者需要给应用程序和浏览器Js调用
5.Hessian:集成Hessian服务,基于HTTP通讯采用servlet暴露服务,Dubbo内嵌Jetty作为服务器是默认实现,提供给Hession服务互操作.多个短连接,同步HTTp传输 hessian序列化,传入参数太大,可传文件.
6.Memcache:基于memcache实现的RPC协议
7.Redis:基于redis实现的Rpc协议
什么是RPC?
分布式系统中系统之间的通信的方式成为RPC及远程调用过程调用无需关注具体协议细节可通过RPC直接获取

RPC 是一种远程调用,他是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议.RPC协议假定某些传输协议的存在,如TCP和UDP,为通信程序之间携带信息数据.RPC跨越了传输层和应用层.RPC使得开发分布式程序变得更加容易.

Zookeeper

zookeeper搭建集群,为什么都是单数台?
原因是偶数台和单数台容灾效果相同,所以没有必要搭建偶数台
集群选举中如果出现了平票会发生什么?如何预防?
如果连续3次平票则可能出现脑裂概率是1/8 增加集群节点的数量有效的降低脑裂
zookeeper服务器宕机 Dubbo服务器是否可以正常工作?
依然可以正常访问,因为消费者启动时已经将服务信息缓存到本地
后台有一个提供者宕机问用户是否报错?
不会报错

Quartz定时任务(订单超时)
执行流程
SpringCloud+Solr(Lucene)+rabbitMQ+Docker+k8s
Dubbo含义:高性能,轻量级开源的java RPC框架,提供了三大核心能力:
1)面向接口的远程方法调用
2)智能容错和负载均衡
3)服务的自动注册和发现.

概念: springcloud是一系列框架的集合,是微服务的工具集.
Springcloud (RestTemplate,Feign)与Dubbo对比
服务之间的通信方式主要有HTTP和RPC两种方式,而两种方式典型的代表正是SpringCloud和阿里的Dubbo.
Dubbo只是一个远程调用(RPC)框架,默认基于长连接,支持多种序列化格式
SpringCloud是一个框架集,提供了一整套的微服务解决方案,基于Http调用使用RestAPI
SpringCloud两种restful调用方式 RestTemplate,Feign
第一种方式:RestTemplate 是通过调用服务器的url(服务器的名称接口名称以及参数)
那么假如服务器的集群是不确定的IP和端口,就不太好处理
第二种方式:Feign:声明式客户端,声明一个接口就可以调用后台服务
分布式与微服务之间的区别
分布式强调的是服务化以及服务的分散性,而微服务强调的是服务的专业化和精细分工
从架构上来谈微服务通常是分布式,但是返过来说就不一定成立,微服务是意味着要解决分布式的各种难题.

Eureka(注册中心:维护所有服务的地址表,服务器启动会连接eureka服务器进行注册,服务调用通过eureka之间发现)
eureka(注册名+地址) 1. 注册:每30秒连接一次eureka尝试进行注册直到注册成功为止
2. 拉取:每30秒拉取一次注册表,刷新注册表
3. 心跳:每30秒发送一次心跳数据,连接丢3次说明微服务宕机,删除注册消息
4.自我保护模式:15分钟85%的服务器心跳异常进入保护模式(开发时期很容易触发)
Zookeeper与eureka的区别:
Zookeeper cp:一致性,分区容错性集群: 主从结构
Eureka: ap:可用性,分区容错性集群: 对等结构
Ribbon (对RestTemplate进行了封装,提供了负载均衡和重试的功能)
RestTemplate :SpringBoot提供的rest远程调用工具(http请求)
在springcloud框架中,RestTemplate,Feign,和网关zuul都默认使用了软负载均衡Ribbon,及调用方式集成了负载均衡Ribbon
负载均衡Ribbon的核心内容:
核心流程是由ServerList获取所要的所有的服务实例,ServerlistFilter过滤掉一部分地址,IRule用来获取一个实例
Ribbon默认的负载均衡算法是轮询.
Hystrix断路器(提供一种容错机制,服务故障或运行缓慢超时,可以避免其他服务器故障造成雪崩的效应)
1.降级:当请求后台服务失败,可以执行当前服务器上的一段代码返回
Hystrix设置超时时间:默认超时时间是1秒此设置要大于ribbon的最大的重试时间
2.熔断:当请求后台后10秒20次请求并且50%都失败执行了降级代码会触发熔断(加了降级熔断自动生效).断路器打开5秒进入半开状态,会尝试向后台服务器发送一次请求如果失败继续保持打开状态,如果成功会关闭断路器,恢复正常
Hystrix dashboard断路器监控仪表盘
Actuator:springboot 提供的一种数据监控工具可以监控项目的各种运行的情况数据,例如健康状态,环境变量,spring容器中的对象.暴露hystrix.stream监控端点.
Feign(声明式Rest客户端,采用了基于接口的注解)
Feign:
1.提供一种声明时客户端,只需要声明一个接口,就可以通过接口调用后台服务
2.整合ribbon和hystrix
Feign+ribbon:负载均衡和重试,默认启用ribbon的负载均衡和重试
Feign+hystrix:默认不启用,不推荐在feign中使用hystrix
Turbine集群聚合监控+hystrix dashboard
Zuul api网关统一的调用入口,统一的权限校验,整合ribbon默认负载均衡,不支持重试.整合hystrix
feign和zuul的区别:
Feign 后台微服务器之间的调用,所以没有必要添加断路器,一般断路器添加在zuul
Zuul部署在最前面,作为一个系统的入口,或者是作为权限的统一校验.不支持重试,理由是如果zuul后面的服务器频繁重试整条电路造成很大的压力

Bus消息总线配置刷新配合消息队列服务器使用 rabbitmq
Config+Github仓库,配置中心统一的维护和管理配置文件
sleuth链路跟踪 +zipkin
Solr(Lucene)是一个高性能基于Lucene采用倒排索引全文搜索引擎ES-ElesticSeurch 也是类似的搜索引擎
RabbitMQ消息队列服务器
应用场景:
1.服务解耦
2.流量削峰
3.异步调用
订单流量削峰
在这里插入图片描述

RabbitMQ的6种模式:
1.简单模式:
在这里插入图片描述
2.工作模式

3.发布订阅模式

4.路由模式

5.主题模式

6.RPC模式

Docker轻量级虚拟机

Docker与VMware虚拟机的区别
VMware虚拟所有的硬件,完全的系统资源运行环境,完整的操作系统,所以占用的内存较大
Docker:充分利用宿主机资源比如硬件资源,操作系统资源
Docker作用:开发运维一体化的核心技术,使用Docker可以让开发运维测试环境完全一致.
Docker 的安装有两种: 在线安装+离线安装包安装
Docker的镜像仓库 hub.docker.com
镜像:虚拟机的静态文件
容器:从镜像启动的虚拟机 Docker称为容器
从镜像启动的虚拟机 Docker成为容器
宿主机与Docker之间相互访问
在这里插入图片描述
自己制作镜像(注意每进行一次操作就会新增一层层数越多效率越慢所以指令越少能合并的指令尽量合并)
Kubernetes容器自动化部署管理工具
使用kubease项目Ansible脚本(连接其他服务器,在多台服务器之间执行命令,可以执行Ansible的制动脚本执行一系列命令.执行一键安装脚本搭建集群)完成k8s集群一键完成

Etcd 注册中心集群必须是奇数
在这里插入图片描述

Redis
redis详情请点击https://blog.csdn.net/weixin_45970468/article/details/104433114
什么是Redis?
Redis是一个完全开源免费内存中的数据结构存储系统,可以用作高性能的键值数据库,缓存和消息中间件,它支持多种类型的数据结构,如字符串,(hash)散列表(存对象),列表(也就是消息中间件),集合,有序集合等.

Redis中的事务: multi exec discard
Redis两种持久化的方式与比较
Redis的持久化方式有两种,AOF和RDB.
RDB持久化方式能够在指定的时间间隔能对你的数据进行快照存储.
AOF持久化方式记录每次对服务器写的操作当服务器重启的时候会重新执行这些命令来恢复原始数据,AOF命令以redis协议追加保存每次写的操作到文件末尾.redis还能对AOF文件进行后台重写,使得AOF文件体积不至于很大.
两个区别就是: 一个就是持续的用日志记录写操作,crash(奔溃)后利用日志恢复;一个是平时写操作的时候不触发写,只有手动提交save命令,或者shutdown关闭命令时,才触发备份操作
说说redis哈希槽的概念?redis集群最大的节点个数是多少?16384
Redis集群没有使用一致性hash,而是引入了哈希槽的概念,redis集群中有16384个哈希槽,每个key通过出CRC16校验后对16384取模来决定放置那个槽位,集群的每个节点负责一部分的hash槽
Redis中的管道有什么作用?
一次请求/响应服务器能实现处理新的请求即使旧的请求还没被响应,这样就可以将多个命令发送到服务器,而不用等待回复,最后在一个步骤中读取该答复, 这就是管道.大大加快了从服务器下载新邮件的过程.
怎么理解redis事务?
事务是一个单独的隔离操作:事务中的所有命令都会序列化,按照顺序的执行,事务在执行的过程中,不会被其他的客户端发送来的命令所打断.事务是一个原子性的操作:事务的操作要么全执行要么全部不执行.
Redis中如何做到内存优化?
尽可能的使用散列表,散列表是使用的内存非常的小,所以应该尽可能的将你的数据模型抽象到一个散列表里面,比如你的web服务器中有一个用户对象,不要为这个用户的名称,姓氏,邮箱,设置单独的key,而是应该把这个用户的所有的信息存储到一个散列表中.

3.3Gb请求GC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java一站式输出

JVM内存示意图jvm三大组件类加载子系统运行时内存区JVM执行引擎类加载概念:从磁盘中加载到jvm内存中的行为,也就是将字节码对象加载到JVM内存中双亲委派模式(注意加载顺序是先由BootstrapClassLoader加载object类等祖先类,再由ExtClassLoader加载父类最后才是 APPClassLoader加载我们自己写的类)作用:保护了基层类 ...
复制链接

扫一扫