自增变量:写出i，j，k的值

public static void main(String[ ] args) {int i = 1;i = i++;int j = i++;int k= i + ++i * i++;system.out.println("i=" +i);system.out.println("j=" +j);system.out.println("k=" +k);
}

答案：i = 4 ， j = 1， k = 11
解析：

public static void main(String[ ] args) {int i = 1; //i初始化为1i = i++; //i++,i先赋值再++，此时i=1int j = i++;  //i++,i先赋值再++，此时j=1，i=2//开始i=2,++i之后，i=3,i++之后，i=4//k = 2 + 3[++i(先++后赋值)，i=3] * 3[i++(先赋值后++),i=3] = 11int k= i + ++i * i++;system.out.println("i=" +i);system.out.println("j=" +j);system.out.println("k=" +k);
}

单例模式（Singleton）

Singleton：在Java中即指单例设计模式，它是软件开发中常见的设计模式之一。
单：唯一
例：实例
单例设计模式，即某个类在系统中只能有一个实例对象可被获取和使用的代码模式。
例如：代表JVM运行环境的Runtime类。
要点：
- 一是某个类只能有一个实例：
  - 构造器私有化
- 二是它必须自行创建这个实例：
  - 含有一个该类的静态变量来保存这个唯一的实例
- 三是它必须自行向整个系统提供这个实例：
  - 对外提供获取该实例对象的方式：
    （1）直接暴露（2）用静态变量的get方法获取
- 常见的形式
  - 饿汉式：直接创建对象，不存在线程安全问题
    - 直接实例化饿汉式（简洁直观）
    - 枚举式（最简洁）
    - 静态代码块饿汉式（适合复杂实例化）
  - 懒汉式：延迟创建对象
    - 线程不安全（适用于单线程）
    - 线程安全（适用于多线程）
    - 静态内部类形式（适用于多线程）

/*** 饿汉式：*      直接创建实例对象*      （1）构造器私有化*      （2）自行创建，并且用静态变量保存*      （3）向外提供这个实例*      （4）强调这是一个单例，我们可以使用final修饰*          final修饰的类不可被继承*          final修饰的方法不能被重写*          final修饰的变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。*/
public class Singleton {public static  final Singleton INSTANCE = new Singleton();private Singleton(){}
}

/*** 枚举类型，表示该类型的对象是有限的几个* 我们可以限定为一个，就成了单例*/
public enum SingletonEnum {INSTANCE
}

/*** 懒汉式(单线程模式)：*      延迟创建这个是实例对象*      （1）构造器私有化*      （2）用一个静态变量保存这个唯一的实例*      （3）提供一个静态方法，胡哦去这个实例对象*/
public class Singleton{private static Singleton instance;private Singleton(){};public static Singleton getInstance(){if(instance == null){instance = new Singleton();}return instance;}
}

/*** 懒汉式（多线程模式）：*      延迟创建这个是实例对象*      （1）构造器私有化*      （2）用一个静态变量保存这个唯一的实例*      （3）提供一个静态方法，胡哦去这个实例对象* synchronized ：*       （1）类锁*            类锁作用于synchronized修饰的静态方法，或者是同步方法块中的类.class。*             类的实例对象可以有多个，但是每个类只有一个class类型的对象*         （2）对象锁*           对象锁作用的是synchronized修饰的非静态方法，或者是同步方法块中this对象和非this对象。*/
public class Singleton{private static Singleton instance;private Singleton(){};public static Singleton getInstance(){if(instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}

类的加载过程，以及对象初始化的过程

public class Father{private int i = test();private static int j = method();static{System.out.print("(1)");}Father(){System.out.print("(2)");}{System.out.print("(3)");}public int test(){System.out.print("(4)");return 1;}public static int method(){System.out.print("(5)");return 1;}
}

public class Son extends Father{private int i = test();private static int j = method();static{System.out.print("(6)");}Son(){//      super();//写或不写都在，在子类构造器中一定会调用父类的构造器System.out.print("(7)");}{System.out.print("(8)");}public int test(){System.out.print("(9)");return 1;}public static int method(){System.out.print("(10)");return 1;}public static void main(String[] args) {Son s1 = new Son();System.out.println();Son s2 = new Son();}
}

输出的值为：5 1 10 6 9 3 2 9 8 7
9 3 2 9 8 7
解析：
加载顺序：
父类静态成员(顺序执行，且只执行一次，不需要考虑到方法的重载)
–> 子类静态成员(顺序执行，且只执行一次，不需要考虑到方法的重载)
–> 父类普通成员(顺序执行，可以执行多次，需要考虑到方法的重载)
–> 父类构造器方法()
–> 子类普通成员(顺序执行，可以执行多次，需要考虑到方法的重载)
–> 子类构造器方法()

类初始化过程：
（1）一个类要创建实例需要先加载并初始化该类
main方法所在的类需要先加载和初始化
（2）一个子类要初始化需要先初始化父类
（3）一个类初始化就是执行()方法
()方法由静态类变量复制显示复制代码和静态代码块组成
类变量显示复制代码和静态代码块代码从上到下顺序执行
()方法只执行一次

JVM层面：
类加载过程
1.加载
1）通过全类名去查找二进制字节流
2）将类的静态存储结构转换为运行时数据结构
3）在内存中创建一个class对象，作为方法区数据的入口
2.验证
通过文件格式，字节码，类元信息以及符号引用验证类是否正确
3.准备
为类成员变量分配内存，并赋0值
4.解析
将负号引用转换为直接引用
5.初始化
调用()方法，进行真正的初始化

实例加载的过程（对象创建的过程）：
1.检查该指令的参数，在常量池中是否存在一个符号引用，如果存在，则检查这个符号引用所代表的类是否被加载，解析，初始化，如果没有就先进行类加载。
2.类加载完成之后，由Java虚拟机为新生对象进行内存的分配
3.内存分配完成之后，由Java虚拟机为对象的成员变量赋初值0
4.赋值完成之后，就为对象设置对象头（对象头中包含哈希码，gc信息，锁信息，以及类元信息）
5.进行真正的初始化，执行()方法，初始化成员变量，执行实例化代码块，调用构造方法，将对象的首地址赋值给引用对象

实例初始化过程
（1）实例化初始化就是执行()方法
()方法可能重载有多个，有几个构造器就有几个()方法
()方法由非静态实例变量显示赋值代码和非静态代码块，对应构造器代码块组成
非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
每次创建实例对象，调用对应构造器，执行的就是对应的()方法
()方法的首行是super()或super(实参列表)，即对应父类的()方法

在子类的构造器中一定会调用父类的构造器，如果父类的构造器被重载了，子类就要调用父类的重载构造器，且放在构造器中的第一行

加载顺序：
父类静态成员(顺序执行，且只执行一次，不需要考虑到方法的重载)
–> 子类静态成员(顺序执行，且只执行一次，不需要考虑到方法的重载)
–> 父类普通成员(顺序执行，可以执行多次，需要考虑到方法的重载)
–> 父类构造器方法()
–> 子类普通成员(顺序执行，可以执行多次，需要考虑到方法的重载)
–> 子类构造器方法()

编译以及运行规则：编译看左边，运行看右边
在调用成员变量以及静态方法时，“编译看左边，运行看左边”，
即程序编译时创建了一个Animal类型的对象，并且使用new Cat()对于
这个Animal对象赋值，但最终得到的还是一个Animal类的对象，只需
要看“=”左边的Animal animal即可。
但是要调用非静态方法时，由于Animal类的对象是用Cat()来实例
化的，这个非静态方法在运行时会被重写，从而输出子类中方法重写后
的结果。这就是“编译看左边，运行看右边”。
举例：
Father son = new Son();
Son son = new Son();

方法的重写Override
不能被重写的方法：
final方法
static方法
private等子类中不可见的方法

对象的多态性
子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
非静态方法默认的调用对象是this
this对象在构造器或者说()方法中就是正在创建的对象

方法的参数传递机制

public class Exam4 {public static void main(String[] args) {int i = 1;String str = "hello";Integer num = 200;int[] arr = {1,2,3,4,5};MyData my = new MyData();change(i,str,num,arr,my);System.out.println("i = " + i);System.out.println("str = " + str);System.out.println("num = " + num);System.out.println("arr = " + Arrays.toString(arr));System.out.println("my.a = " + my.a);}public static void change(int j, String s, Integer n, int[] a,MyData m){j += 1;s += "world";n += 1;a[0] += 1;m.a += 1;}
}
class MyData{int a = 10;
}

输出的值为：1 hello 200 [2,2,3,4,5] 2
解析：
在这个里面涉及到一个栈的名词，栈又被分为Java虚拟机栈和本地方法栈。
Java虚拟机栈是用来描述Java普通方法在运行时的内存模型，在线程创建时，会创建一个栈空间，栈空间中存放的元素是用来支持Java虚拟机进行方法调用的，在方法执行的时候，会创建一个栈帧，栈帧中存放的是局部变量表，操作数栈，动态链接，返回地址等信息。
本地方法栈则是为本地方法提供服务的，作用与Java虚拟机栈类似

在栈中为每一个方法都分配了内存空间，用于存放方法所携带的参数以及方法内部所定义的参数。

在进行方法调用，方法的形参列表接收实参时：
基本数据类型：数据值（值传递）
引用数据类型：地址值（引用传递）
特殊的（引用）类型：String（被private final修饰的char[]数组），包装类（被private final修饰的基本数据类型）等对象不可变性
值传递不会修改实参的值，而特殊的（引用）类型也不会修改实参的值，修改之后会产生一个新的对象，所以不会修改原参，引用传递才会修改实参的属性值，因为引用类型可以通过地址去操作数据。

编程题：有n步台阶，一次只能上1步或2步，共有多少种走法？(斐波那契数列)

public static int fibonacc(int n){if(n <= 2){return n;}return fibonacc(n-1) + fibonacc(n-2);}

成员变量与局部变量

public class Exam5 {static int s;//成员变量，类变量int i;//成员变量，实例变量int j;//成员变量，实例变量{int i = 1;//非静态代码块中的局部变量 ii++;j++;s++;}public void test(int j){//形参，局部变量,jj++;i++;s++;}public static void main(String[] args) {//形参，局部变量，argsExam5 obj1 = new Exam5();//局部变量，obj1Exam5 obj2 = new Exam5();//局部变量，obj1obj1.test(10);obj1.test(20);obj2.test(30);System.out.println(obj1.i + "," + obj1.j + "," + obj1.s);System.out.println(obj2.i + "," + obj2.j + "," + obj2.s);}
}

输出的值为：2，1，5
1，1，5
解析：
static成员变量（类变量）全局只加载一次，经过两次new对象，三次方法调用，所以 s 的值最后为5
普通成员变量（实例变量），new一次加载一次
i ：在代码块中定义了一个局部变量i，所以在代码块中操作的是局部变量i，而不是成员变量i，所以成员变量i此时还是为0，而成员变量j的值为1，但是在test()方法中没有定义局部变量i也没有携带形参i，而是携带了形参j，所以在test()方法中可以对成员变量i进行操作，而不能对成员变量j进行操作，所以j的值就为1，obj1.test()执行了两次，所以obj1.i的值为2，obj2.test()执行了一次，所以obj2.i的值为1。
局部变量与成员变量的区别：
1.声明的位置
局部变量：方法体中，形参，代码块中
成员变量：类中方法外
类变量：有static修饰
实例变量：没有static修饰
2.修饰符
局部变量：final
成员变量：public，protected，private，final，static，volatile，transient
3.值存储的位置：
局部变量：栈
实例变量：堆
类变量：方法区
4.作用域
局部变量：从声明出开始，到所属的}（例如方法的结束，if的结束，for循环的结束都是以}结束）结束
实例变量：在当前类中"this."（有时this.可以缺省），在其他类中"对象名.“访问
类变量：在当前类中"类名.”（有时类名.可以省略）,在其他类中"类名."或"对象名."访问
5.生命周期：
局部变量：每一个线程，每一次调用执行都是新的生命周期
实例变量：随着对象的创建而初始化，随着对象的回收而消亡，每一个对象的实例变量是独立的。
类变量：随着类的初始化而初始化，随着类的卸载而消亡，该类的所有对象的类变量是共享的。

堆：堆中主要存放的是实例对象，在Java中基本所有的对象都是在堆中进行内存分配的，堆是内存管理最大的一块，垃圾回收也是针对堆这块区域进行的。
栈：就是上面所说的Java虚拟机栈和本地方法栈
方法区：方法区主要用于存放Java虚拟机加载的类信息，常量，静态变量等信息。在jdk1.6中，方法区放在永久代中，容易出现内存溢出的情况，所以在jdk1.7中，将永久代中的字符串常量池以及静态变量移出了永久代，在jdk1.8中，将永久代移除了，改用基于内存实现的元空间，并将方法区放入了元空间中，并将jdk1.7中的内容也放入了元空间中。

Spring 中 Bean作用域之间的区别

在Spring中，可以在元素的scope属性里设置bean的作用域或使用@Bean和@Scope(“xxx”)注解，以决定这个bean是单实例还是多实例的。
默认情况下，Spring只为每个在IOC容器里声明的bean创建唯一的一个实例，整个IOC容器范围内都能共享该实例：所有后续的getBean()调用和bean引用都将返回这个唯一的bean实例，该作用域被称为singleton，它是所有bean的默认作用域。

类别	说明
singleton	在SpringIOC容器中仅存在一个Bean实例，Bean以单实例的方式存在（默认）
prototype	每次调用getBean()时，都会返回一个新的实例
request	每次Http请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个Http Session共享一个Bean，不同的Http Session 使用不同的Bean，读作用域仅适用于WebApplicationContext环境

singleton：当IOC容器被创建就会创建bean的实例，而且是单例的，每次得到的都是同一个。
prototype：当IOC容器被创建不再实例化该bean，每次调用getBean()方法时再实例化该bean，而且每次创建的的实例都不相同。
request：每次请求都会实例化一个bean
session：在一次会话中共享一个bean

Spring支持的常用数据库的事务属性之传播行为及隔离级别

事务的属性：
1.propagation：用来设置事务的传播行为
事务的传播行为：一个方法运行在一个开启了事务的方法中，当前方法时使用原来的事务还是开启一个新的事务

传播属性	描述
REQUIRED(默认)	如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUIRES_NEW	当前的方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将正在运行的事务挂起
SUPPORTS	如果当前有事务正在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTED	当前的方法不应该运行在事务中，如果有运行的事务，将正在运行的事务挂起
MANDATORY	当前的方法必须运行在事务中，如果没有正在运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行

事务的传播属性可以在@Transactional注解的propagation属性中定义

2.isolation：用来设置事务的隔离级别
会出现的问题：
1）.脏读：事务2读到事务1更新但未提交的数据，及读到了一个无效数据
2）.不可重复读：事务2第一次读出出来数据之后，事务1将数据修改了，事务2再次读取数据，导致前后两次读取的数据不一致
3）.幻读：事务2第一次读取数据记录之后，事务1新增了数据记录的条数，事务2第二次读取数据记录，导致前后两次读取的数据条数不一致
隔离级别：
1）读未提交：READ UNCOMMITTED 允许事务1读取到事务2未提交的数据（避免不了脏读，幻读，不可重复读）
2）读已提交：READ COMMITED 要求事务1只能读取事务2已提交的数据（可避免脏读，不可避免幻读，不可重复读）
3）可重复读：REPEATABLE READ 确保事务1可以多次从一个字段中读取到相同的值，即事务1执行期间禁止其他事务对这个字段进行更新（可避免脏读，不可重复读，不可以避免幻读）
4）串行化：确保事务1可以多次从一个表中读到相同的行，在事务1执行期间，禁止其他事务对这个表进行添加，更新，删除操作，可以必变任何并发问题，但是性能十分低下（可以避免脏读，幻读，不可重复读）

SpringMVC的工作流程：

1.浏览器向服务器发起http请求
2.DispatcherServlet（中央控制器）调用HandlerMapping（处理器映射器）
3.HandlerMapping（处理器映射器）通过url找到具体的Handler（处理器），生成HandlerExecutionChain（处理器执行链），其中包括处理器对象和处理器拦截器，一并返回给DispatcherServlet。
4.DispatcherServlet根据Handler（处理器）获取HandlerAdapter（处理器适配器）执行HandlerAdapter（处理器适配器）处理一系列的操作。如：封装参数，数据格式转换，数据验证等操作。
5.执行处理器.Handler（Controller ，也叫页面控制器）
6.Handler执行完成返回ModelAndView
7.HandlerAdapter将Handler执行结果ModelAndView返回到DispatcherServlet
8.DispatcherServlet将ModelAndView传给ViewResolver视图解析器
9.ViewResolver解析后返回具体VIew
10.DispatcherServlet对View进行渲染视图（即将模型数据model填充至视图中）
11.DispatcherServlet响应用户。

Git命令相关

创建分支：

git branch <分支名>
git branch -v 查看分支

切换分支：

git checkout <分支名>
一步完成： git checkout -b <分支名> 创建分支并切换

合并分支：

先切换到主干 git checkout master
git merge <分支名>

删除分支：

先切换到主干 git checkout master
git branch -D <分支名>

redis持久化

RDB：
优点：
1.节省磁盘空间
2.恢复速度快
缺点：
1.虽然Redis在fork时使用了写时拷贝技术，但是如果数据庞大时还是比较消耗性能
2.在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会失去最后一次快照后的所有修改。

AOF：
优点：
1.备份机制更稳健，丢失数据概率更低
2.可读的日志文件，通过操作AOF文件，可以处理误操作
缺点：
1.比起RDB占用更多的磁盘空间
2.恢复备份速度要慢
3.每次读写同步的话，有一定的性能压力
4.存在个别Bug，造成恢复不能

Mysql什么时候创建索引

索引是什么：Mysql官方对索引的定义为：索引（index）是帮助Mysql高效获取数据的数据结构。可以理解为“排好序的快速查找数据结构”。一般来说索引本身也很大，不可能全部存储在内存中，因此索引往往以索引文件的形式存储在磁盘上

优势：
1.类似大学图书馆建书名索引，提高数据检索的效率，降低数据库的IO成本。
2.通过索引列对数据进行排序，降低数据排序的成本，降低了CPU的消耗

劣势：
1、虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT，UPDATE和DELETE，因为更新表时，Mysql不仅要保存数据，还要保存一下索引文件每次更新添加了索引的字段，都会调整因为更新所带来的的键值变化后的索引信息
2.实际上索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录，所以索引列也是要占用空间的

哪些情况需要创建索引：
1.主键自动建立唯一索引
2.频繁作为查询条件的字段应该创建索引
3.查询中与其他关联的字段，外键关系建立索引
4.单键/组合索引的选择问题，组合索引性价比更高
5.查询中排序的字段，排序字段若通过索引去访问将大大提高排序速度
6.查询中统计或分组字段

哪些情况不要创建索引：
1.表记录太少
2.经常增删改的表或者字段
3.Where条件里用不到的字段创建索引
4.过滤性不好的不适合建立索引

垃圾回收机制

垃圾回收机制主要是针对 堆(Heap) 进行的
GC分为两类：
Minor GC：发生在新生区的垃圾回收被称为Minor GC，由于新生区对象的存活时间较短，所以Minor GC发生了也就比较频繁，所以Minor GC的回收速度也比较快
Full GC：Full GC 是针对整个堆进行的垃圾回收，会触发Full GC的情况有老生区内存不足，永久区内存不足，调用System.gc()方法，空间分配担保失败。

如何判断对象是垃圾：
1.引用计数法：定义一个引用计数器，当对象被引用时，计数器+1，当引用失效时，计数器-1，当计数器为0的时候，说明这个对象是垃圾，这种方法较难解决循环引用的问题。
解决循环引用的思路：在将引用置null之后，主动调用垃圾回收，两个对象会调用搁置的finalize()方法。
2.可达性分析：将GC Roots的根节点作为起始节点开始，从上至下搜索，当某个对象没有被搜索到，则说明这个对象是垃圾，可以作为GC Roots的根节点的对象有，Java虚拟机栈引用的对象，本地方法栈引用的对象，静态成员属性引用的对象，常量引用的对象。

标记清理算法：
1.标记清除算法：将垃圾对象标记出来之后，统一清理，这样会产生大量的不连续的内存碎片
2.标记整理算法：将存活的对象标记出来，然后向内存的一端移动，然后清理端边界外的内存区域
3.标记复制算法：将内存分为两块大小相同的区域，每次只使用其中一块，当内存使用完后，将存活对象复制到另一块内存区域中，直接清理已使用完的内存区域。

新生区使用标记复制算法，老生区使用标记整理或标记清除算法。

Redis在项目中的使用场景

数据类型	使用场景
String	比如说：我想知道什么时候封锁一个IP地址。由于某个IP在一段时间内访问的特别频繁，就说明这个IP可能存在风险，所以需要封锁IP，记录当前IP地址访问的次数，可以使用IncrBy 命令
Hash	存储用户信息【id，name，age】使用方式：Hash(key,filed,value) 例：Hash(userKey,id,101) Hash(userKey,name,admin) Hash(userKey,age,18)
List	实现最新消息的排行，还可以利用List的push命令，将任务存在list集合中，同时使用另一个命令[pop]，将任务从集合中取出，Redis-list数据类型来模拟消息队列，【电商中的秒杀就可以采用这种方式来完成一个秒杀活动】
Set	特殊之处：可以自动去重，比如说微博中将每个人的好友存在集合中（Set集合）中，这样求两个人的共同好友的操作，我们只需要求交集即可。
Zset	以某一个条件为权重，进行排序，京东：显示商品列表的时候，都会有一个综合排名，还可以按照价格进行排名

Solr和Elasticsearch的区别

背景：它们都是基于Lucene搜索服务器基础之上开发，一款优秀的，高性能的企业级搜索服务器。【是因为他们都是基于分词技术构建的倒排索引的方式进行查询】
开发语言：Java语言开发
诞生时间：
Solr：2004年诞生
Es：2010年诞生
Es更新【功能越强大】
区别：
1.当实时建立索引的时候，solr和产生io阻塞，而es则不会，es查询要高于solr
2.在不断动态添加数据的时候，solr的检索效率会变得低下，而es则没有什么变化
3.solr利用zookeeper进行分布式管理，而es自身带有分布式系统管理功能。solr一般都要部署到web服务器上，比如tomcat，启动tomcat的时候需要配置tomcat与solr的关联。【solr的本质是一个动态web项目】
4.solr支持更多的格式数据[xml,json,csv等]，而es仅支持json文件格式
5.solr是传统搜索应用的有力解决方案，但是es更适用于新兴的实时搜索应用。单纯的对已有数据进行检索的时候，solr效率更好，高于es
6.solr官网提供的功能更多，而es本身注重与核心功能，高级功能多有第三方插件。

单点登录实现过程

单点登录：一处登陆多处使用
前提：单点登录多实用在分布式系统中

举例：
参观动物园流程：
检票员=认证中心模块
1.我直接带着大家进动物园，则会被检票员拦住【看我们是否有门票】，没有[售票处买票]
登录=买票
2.我去买票【带着票，带着大家一起准备进入动物园】检票员check【有票】
Token=票
3.我们手中有票就可以任意观赏动物园的每处景点。
京东：单点登录，是将token放入到cookie中的。
案例：将浏览器的cookie禁用，则在登录京东则失败！无论如何登录不了！

购物车实现过程

购物车：
1.购物车跟用户的关系?
a)一个用户必须对应一个购物车【一个用户不管买多少商品，都会存在属于自己的购物车中。】
b)单点登录一定在购物车之前。
2.跟购物车有关的操作有哪些?
a)添加购物车
i.用户未登录状态
1.添加到什么地方?未登录将数据保存到什么地方?
a)Redis
b)Cookie
ii.用户登录状态
1.Redis 缓存中【读写速度快】
a)Hash ：hset(key,field,value)
i. Key的定义 user:userId:xxx
ii. Hset(key,field,value);
2.存在数据库中【oracle，mysql】
b)展示购物车
i.未登录状态展示
1.直接从cookie/redis 中取得数据展示即可
ii.登录状态
1.用户一旦登录：必须显示数据库 + redis/cookie 中的购物车的数据
a)Cookie 中有三条记录
b)Redis中有五条记录
c)真正展示的时候应该是八条记录

消息队列在项目中的使用

背景：在分布式系统中是如何处理高并发的。
由于在高并发的环境下，来不及同步处理用户发送的请求，则会导致请求发生阻塞。比如说，大量的insert，update之类的请求同时到达数据库MYSQL，直接导致无数的行锁表锁，甚至会导致请求堆积很多。从而触发 too many connections 错误。使用消息队列可以解决【异步通信】
1.异步

2.并行

3.排队

消息队列电商使用场景：

消息队列的弊端：
消息的不确定性：延迟队列，轮询技术来解决该问题即可！

Java面试题合集（1）相关推荐

Java面试核心知识点（283页）Java面试题合集最新版（485页）
阿里.腾讯两大互联网企业传来裁员消息,很多人都陷入担心,不安情绪蔓延-- 其实大家应该更冷静和理性地看待大厂裁员.每年三四月都是大厂人员调整期,这个季节是各个公司战略调整.战略规划的一个关键期,肯定会 ...
【转】Java面试题合集
2013年年底的时候,我看到了网上流传的一个叫做<Java面试题大全>的东西,认真的阅读了以后发现里面的很多题目是重复且没有价值的题目,还有不少的参考答案也是错误的,于是我花了半个月时间对 ...
进入 IT 企业必读的Java面试题合集，强烈建议收藏！
说起要找工作了,你觉得此刻最该做的事情是什么? 当然是找个大厂的面试题看一下套路: 今天小编分享给大家一些Java面试题: 欢迎阅读! 更多2021最新Java面试题全部答案及Java零基础入门教程资 ...
超级准确的Android/JAVA面试题合集，背会你就10k！
原文转自:点击打开链接欢迎访问我的个人博客 Android常见的问题常见算法问题的 Java 实现资料可见算法介绍可见算法是很多公司面试必须,国内 BAT 基本面试中都会有,尤以百度为盛. ...
【面霸】10月最新184道阿里、百度、腾讯、头条Java面试题合集offer拿到手软！
最新2020整理收集的一线互联网公司面试真题(都整理成文档),有很多干货,包含netty,spring,线程,spring cloud等详细讲解,也有详细的学习规划图,面试题整理等,我感觉在面试这块讲 ...
java重写paint方法时怎么样不覆盖文字_美团十月社招Java面试题合集，JVM+Spring+Spring，看了答案其实也不难...
欢迎关注专栏<Java架构筑基>--专注于Java技术的研究与分享! Java架构筑基zhuanlan.zhihu.com Java架构筑基--专注于Java技术的研究与分享! 后续文章 ...
java 面试题合集_撩课-Java面试题合辑1-50题
1.简述JDK.JRE.JVM? 一.JDK JDK(Java Development Kit) 是整个JAVA的核心, 包括了Java运行环境(Java Runtime Envirnment), 一 ...
2022 Java最新面试题合集
2022最新Java面试题合集,包括 Java 集合.JVM.多线程.并发编程.设计模式.SpringBoot.SpringCloud.Java.MyBatis.ZooKeeper.Dubbo.Ela ...
9012年大厂面试题合集：Java技术栈为什么竞争越来越激烈？
就今年大环境来看,跳槽成功的难度比往年高很多,一个明显的感受:今年的Java技术栈面试,无论一面还是二面,都特别考验Java程序员的技术功底. 最近有人搜集了93套腾讯.阿里.美团.百度.网易等公司9 ...

Java面试题合集（1）