java知识点

ls：列出当前目录下的文件和文件夹。
pwd：显示当前所在的工作目录。
cd：切换目录。
touch：创建一个空文件或者修改已存在文件的时间戳。
mkdir：创建一个新目录。
rm：删除指定的文件或目录。
mv：移动文件或目录，或者重命名文件。
cp：复制文件或目录。
cat：查看文件内容。
grep：在文件中搜索指定的模式。
chmod：修改文件或目录的权限。
chown：修改文件或目录的所有者。
tar：打包和解压缩文件。
find：根据指定的条件在文件系统中搜索文件。
ps：显示当前运行的进程。
top：实时显示系统资源占用情况以及进程信息。
ssh：通过安全的远程连接登录到另一台计算机。
scp：安全地复制文件到远程计算机。
wget：从网络上下载文件。
apt-get：用于安装、更新或删除软件包。

8.string方法中的实现字符串反转的方法

StringBuffer.reverse()

9.接口和抽象类的区别

接口中的变量是常量public static final修饰
抽象类中的方法可以有普通方法，接口中全是抽象方法。
在jdk1.8后，子类可以不重写接口中的 static 和 default 方法。
抽象类也是类只能单继承，但是接口可以实现多继承。

10.抽象类和类的区别

抽象类由abstract修饰。
抽象类不能创建实例，可以创建子类的实例。
抽象类中的具有抽象方法，抽象方法，只有方法的声明，没有方法的实现。
抽象类中，可以有普通方法，也可以有抽象方法。
abstract(也就是说抽象类和接口)不能和 private static final一起使用。

11.垃圾回收机制

垃圾回收机制是由java虚拟机自行执行的，不需要程序员手动去释放对象内存。在jvm中，有一个垃圾回收线程，他的优先级比较低，正常情况下，他不会执行，只有在虚拟机空闲时或者堆内存不足时，才会执行，回收那些没有被引用的对象，将他们放入将要回收的集合中，进行回收。
11.1分代回收，为什么不一次性回收？
不同的对象，有不同的声明周期。如果不考虑存活时间，垃圾回收机制会进行遍历，很有可能多次遍历后，声明周期长的对象，依然存在。所以说分代回收就是把他们放在不同的代上，分而治之，不同的代采用适合它的垃圾回收方式进行回收。

11.2回收策略以及Minor GC和Major GC
对象优先在堆的Eden区分配
大对象直接进入老年代
长期存活的对象将直接进入老年代

当Eden区没有足够的空间进行分配时，虚拟机会执行一次Minor GC.Minor GC通常发生在新生代的Eden区，在这个区的对象生存期短，往往发生GC的频率较高，回收速度比较快;Full Gc/Major GC 发生在老年代，一般情况下，触发老年代GC的时候不会触发Minor GC,但是通过配置，可以在Full GC之前进行一次Minor GC这样可以加快老年代的回收速度。

12.8种基本数据类型

byte short int long char boolean float double
1 2 4 8 2 4 8

13.把两个结果集合并的关键字

union和union all
union: 对两个结果集进行合并操作,去掉重复行,同时按默认规则对数据进行排序
union all: 对两个结果集进行合并操作, 包括重复行, 即所有的结果全部显示, 不进行排序

14.数据库数据量大，该如何优化

12点

15.distinct作用

去掉重复的值。在一个语句中只能出现一次。必须出现在select的后方。

16.跨域访问

协议、IP、端口必须一致。

17.Map接口中的键，允许为空吗？

答案：不一定。HashTable的键不能为空，HashMap的键可以为空。

18.事务的隔离级别

1.读未提交 Read uncommitted

2.读以提交 Read committed

3.重复读 Repeatable read

4.序列化 Serializable

MqSQL默认级别是重复读

19.什么是线程安全？如何解决

20. 什么是自动装箱拆箱，int 和 Integer 的区别

基本数据类型不具备对象的特征，不能调用方法。

20.1 java为什么要引入自动拆箱装箱的功能？

List集合中只能放对象，而不能放基本数据类型。因此要将整数自动装箱为对象

编译原理：实际是javac编译器的语法糖。底层是通过Integer.valueOf()和Integer.intValue()方法实现。

20.2区别

1. Integer是int的包装类，int是java的基本数据类型

2.Integer变量必须实例化后才能使用，而int变量不需要

3.Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值

4.Integer默认值是null，int是0

21.HashMap和HashTable区别 44
线程安全性不同

HashMap是线程不安全的，HashTable是线程安全的，其中的方法是Synchronized，在多线程并发的情况下，可以直接使用HashTable，但是使用HashMap时必须自己增加同步处理。

是否提供contains方法
HashMap只有containsValue和containsKey方法；HashTable有contains、containsKey和containsValue三个方法，其中contains和containsValue方法功能相同。

key和value是否允许null值
Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

数组初始化和扩容机制
HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。

Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。
哈希值不同

哈希值使用不同，HashTable直接使用对象key的hashCode作为hash值。而HashMap是对hashCode又进行hash算法计算得到hash值

22.什么叫做多线程

操作系统可以并发多个任务

22.1实现多线程的几种方式

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口(有返回值，可以使用get方法获取)

#### 代码演示
import java.util.concurrent.*;
public class threadTest{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //继承thread
        ThreadClass thread = new ThreadClass();
        thread.start();
        Thread.sleep(100);
        System.out.println("#####################");
 
        //实现runnable
        RunnableClass runnable = new RunnableClass();
        new Thread(runnable).start();
        Thread.sleep(100);
        System.out.println("#####################");
 
        //实现callable
        FutureTask futureTask = new FutureTask(new CallableClass());
        futureTask.run();
        System.out.println("callable返回值：" + futureTask.get());
        Thread.sleep(100);
        System.out.println("#####################");
 
        //线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 2, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
        threadPoolExecutor.execute(thread);
        threadPoolExecutor.shutdown();
        Thread.sleep(100);
        System.out.println("#####################");
 
        //使用并发包Executors
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.execute(thread);
        executorService.shutdown();
    }
}
 
class ThreadClass extends Thread{
    @Override
    public void run() {
        System.out.println("我是继承thread形式：" + Thread.currentThread().getName());
    }
}
 
class RunnableClass implements Runnable{
    @Override
    public void run(){
        System.out.println("我是实现runnable接口：" + Thread.currentThread().getName());
    }
}
 
class CallableClass  implements Callable<String> {
    @Override
    public String call(){
        System.out.println("我是实现callable接口：");
        return "我是返回值，可以通过get方法获取";
    }
}

22.2 进程和线程的区别

根本区别：进程是操作系统资源分配的基本单位。线程：是任务调度和执行的基本单位。

包含关系：一个进程中包含多个线程。而一个线程只能属于一个进程。一个线程程可以看成一个轻量化的进程。

开销方面：每个进程都有独立的代码和数据空间，程序之间的上下文切换开销比较大。同一类线程，可以共享代码和数据空间，程序之间的上下文切换开销比较小。

22.3保证线程安全的方式有哪些

互斥访问：在多线程的情况下，保证同一时刻，只能有一个线程对同一资源进行访问。可以使用synchronized关键字和Lock接口实现互斥。

原子操作：一系列不可再分的操作单元，线程在执行时，不能被其他线程所影响。在多线程的情况下，使用原子操作，以避免数据的不一致性。可以使用java.util.concurrent.atomic包提供的原子包装类实现原子操作。

可见性：一个线程对共享资源进行修改，修改后的数据是可见的，防止发生数据错乱。可以使用volatile关键字来保证变量的可见性。

23.单线程和多线程的区别

1. 执行方式：

- 单线程：单线程指的是程序只有一个执行线程，按照顺序逐个执行任务。当一个任务执行完毕后，才能执行下一个任务。

- 多线程：多线程指的是程序可以同时执行多个线程，每个线程可以独立执行任务。多线程可以同时处理多个任务，提高程序的执行效率。

2. 并发性：

- 单线程：由于只有一个线程，单线程程序只能按照顺序执行任务，无法同时处理多个任务。当一个任务执行时间较长时，会导致其他任务等待。

- 多线程：多线程程序可以同时执行多个线程，每个线程可以独立执行任务。多线程可以实现并发执行，提高程序的响应速度和并发性。

3. 资源管理：

- 单线程：单线程程序只有一个执行线程，对于共享资源的访问是串行的，需要进行同步操作来避免数据竞争和冲突。

- 多线程：多线程程序中，多个线程可以同时访问和修改共享资源。但同时也需要注意线程安全问题，使用锁、信号量等机制来保证共享资源的正确访问。

4. 性能：

- 单线程：由于单线程程序只能按照顺序执行任务，当某个任务执行时间较长时，会导致整个程序的执行效率下降。

- 多线程：多线程程序可以同时执行多个线程，可以充分利用多核处理器的优势，提高程序的执行效率和性能。

多线程和单线程的区别主要在于执行方式、并发性、资源管理和性能方面。多线程程序可以同时执行多个线程，提高程序的并发性和执行效率，但同时也需要注意线程安全问题。单线程程序只能按照顺序执行任务，适用于简单的任务和资源访问较少的场景。根据具体的需求和场景，选择合适的执行模式可以提高程序的效率和性能。

24.wait vs sleep

共同点

wait() ，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态

不同点

方法归属不同
- sleep(long) 是 Thread 的静态方法
- 而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有
醒来时机不同
- 执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
- wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
- 它们都可以被打断唤醒
锁特性不同（重点）
- wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
- wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃 cpu，但你们还可以用）
- 而 sleep 如果在 synchronized 代码块中执行，并不会释放对象锁（我放弃 cpu，你们也用不了）

(-自加-)interrupt会抛出异常，然后唤醒sleep和wait的线程。

25.File类中常用的方法

isDirectory() 是否为文件夹

isFile() 是否为文件

getPath() 得到file的路径

getName() 得到最后一层的名字

getParent() 得到去掉最后一层的路径

getParentFile() 得到父类路径的新文件

renameTo() 改名

mkdir() 创建新文件夹，只能创建一层

mkdirs() 创建新文件夹，可以多层

createNewFile() 创建新文件，只能一层

exists() 路径是否存在

delete() 删除文件或者目录（为空的目录）

list() 返回该路径下文件或者文件夹的名字数组

listFiles() 返回该路径下文件或者文件夹组成的File数组

separator 代替文件或文件夹路径的斜线或反斜线，防止跨平台出现错误

26.Linux常用的命令

Linux常用命令大全_Zeal.Zhang的博客-CSDN博客

27.Linux运行jar包的命令

java -jar XXX.jar

28.Maven的打包命令

mvn package

29.JS中的几种数据类型

number：数字类型。

string：字符串类型。值必须了出现在一对引号中。

boolean：只有true/false。

object：对象类型。例如：Date()，null等。

function：函数类型。

undefined：未定义类型。在JS中声明变量没赋值时，变量默认为：undefined。

30.mysql中数据类型，char和varchar区别

一.共同点

varchar 和 char 是 MySQL 中的两种数据类型，都是用来存储字符串的。

二.不同点

1.varchar 类型的长度是可变的，而 char 类型的长度是固定的(可能会浪费空间)

2.varchar 类型的查找效率比较低，而 char 类型的查找效率比较高

31.什么是索引，好处和缺点。什么情况下不适用索引

索引是一种用于加速对表中数据行进行检索的存储结构，它可以通过维护一个有序的目录，使得数据检索变得更快。

索引的好处：

提高数据检索速度：通过索引，可以快速定位到所需的数据，避免全表扫描，从而加快查询速度。
加速表与表之间的连接：在进行多表关联查询时，通过索引可以快速定位到需要连接的表，减少连接的时间。
在分组和排序进行检索时，可以减少查询中分组和排序的时间。

索引的缺点：

创建索引和维护索引需要耗费时间，这种时间随着数据量的增加而增加。
索引需要占用物理空间，数据量越大，占用空间越大。
降低表的增删改的效率，因为每次增删改索引，都需要进行动态维护。

不适合用索引的情况

1.对于表记录太少的情况(小表)

2.对于频繁更换字段，经常进行增删改操作的表

3.在进行大量数据插入，修改，删除时，不使用索引。

4.对于数据重复且分布平均的字段

5.对于长文本的列

6.对于很少被搜索的列，很少被用到的列

32.什么是试图

视图就是一种伪表，视图中没有数据，他的数据来自于表。

它可以简化查询，但是不能提高查询的效率。可以提高安全性。

33.三大范式

第一范式：列不可再分原子性。

第二范式：满足第一范式，非主属性完全依赖主属性。

第三范式：满足第二范式，非主属性之间不能存在传递依赖，非主属性必须直接依赖主属性。

34.Object类常用的方法

1 toString⽅法

2 hashCode()

3 equals⽅法

4 Class getClass()

5 Object clone()-克隆

6 void finalize() -Gc垃圾回收机制

7.wait(long timeout)

8.wait(long timeout, int nanos)

9.wait()

10.notify()

11.notifyAll()

35.String判断是否为空

　　1、str == null;

　　2、"".equals（str）；

　　3、str.length <= 0;

　　4、str.isEmpty（）；

36.springboot工程结构

1.工程启动类(ApplicationServer.java)置于com.springboot.build包下

2.实体类(Entity)置于com.springboot.domain
3.数据访问层(Mapper)置于com.springboot.repository
4.数据服务层(Service)置于com,springboot.service,数据服务的实现接口(serviceImpl)至于com.springboot.service.impl

5.前端控制器(Controller)置于com.springboot.controller

6.工具类(utils)置于com.springboot.utils

7.常量接口类(constant)置于com.springboot.constant

8.配置信息类(config)置于com.springboot.config

9.数据传输对象(dto)置于com.springboot.dto
10.视图包装对象(vo)置于com.springboot.vo

视图包装对象View Object用于封装客户端请求的数据，防止部分数据泄露如：管理员ID，保证数据安全，不破坏原有的实体类结构
11.拦截器（interceptor）

37.bootstrap如何实现自适应

Bootstrap通过使用栅格系统和响应式CSS类来实现自适应设计。栅格系统是Bootstrap的核心组件之一,它将页面水平划分为12列,并使用CSS类将内容放置在这些列中。通过灵活地组合这些列,可以实现在不同屏幕大小下的布局调整。

38.模糊查询有几种方法

39.sql截取字符串

（1）SUBSTRING(string, start, length)

其中，string是要截取的字符串，start是开始位置的索引，length是要截取的字符数。

例如，下面的SQL语句可以截取字符串“Hello World”中的“World”：

SELECT SUBSTRING('Hello World', 7, 5);

上述SQL语句的输出结果为“World”。

需要注意的是，如果start为负数，则表示从字符串的末尾开始计算，例如：

SELECT SUBSTRING('Hello World', -5, 5);

上述SQL语句的输出结果为“World”。

（2）LEFT和RIGHT函数

LEFT函数用于从字符串的左边开始截取，RIGHT函数用于从字符串的右边开始截取。

LEFT(string, length)

RIGHT(string, length)

其中，string是要截取的字符串，length是要截取的字符数。

例如，下面的SQL语句可以截取字符串“Hello World”中的“Hello”：

SELECT LEFT('Hello World', 5);

上述SQL语句的输出结果为“Hello”。

需要注意的是，如果length的值大于字符串的长度，LEFT和RIGHT函数会返回整个字符串。

（3）CHARINDEX函数

CHARINDEX(substring, string) charindex

其中，substring是要查找的子字符串，string是要在其中查找的字符串。

例如，下面的SQL语句可以查找字符串“Hello World”中的字符“W”的位置：

SELECT CHARINDEX('W', 'Hello World');

上述SQL语句的输出结果为7。

需要注意的是，如果子字符串不存在于查找的字符串中，CHARINDEX函数会返回0。

40.http请求方式

GET、POST、PUT、DELETE、HEAD、OPTIONS

41.ArrayList的排序

对于ArrayList排序，有两种常见的方法：

使用Collections.sort()方法：这是一种简单而直接的方法，适用于对元素进行自然排序（即元素实现了Comparable接口）或者根据自定义的Comparator进行排序。例如，如果我们有一个存储整数的ArrayList，我们可以直接调用Collections.sort()方法进行排序。如果ArrayList中存储的是自定义对象，我们需要提供一个Comparator对象来告诉Java如何比较这些对象。

	`ArrayList<Integer> numbers = new ArrayList<Integer>();`
	`numbers.add(5);`
	`numbers.add(9);`
	`numbers.add(1);`
	`numbers.add(3);`
	`Collections.sort(numbers);`

使用Java 8的Stream API：这是一种更现代和灵活的方法，可以使用lambda表达式和链式调用来进行排序。例如，我们可以使用sorted()方法来对ArrayList进行排序：

	`ArrayList<Integer> numbers = new ArrayList<Integer>();`
	`numbers.add(5);`
	`numbers.add(9);`
	`numbers.add(1);`
	`numbers.add(3);`
	`List<Integer> sortedNumbers = numbers.stream().sorted().collect(Collectors.toList());`

请注意，第一种方法会直接修改原始的ArrayList，而第二种方法则会返回一个新的已排序的List对象，原始的ArrayList不会被修改。

42.linux重命名命令

mv命令、rename命令

43.索引缺点，什么时候用到。

索引的缺点主要包括：

占用更多的物理存储空间：创建索引需要额外的物理存储空间，这对于大数据量的表可能会成为一个问题。
降低数据维护效率：当对表中的数据进行增加、删除和修改时，索引也需要进行相应的更新和维护，这可能会降低数据维护的效率。
可能降低查询性能：虽然索引可以提高查询效率，但在某些情况下，使用索引可能会降低查询性能。例如，对于大量数据的表，如果使用不当的索引或者索引的字段不是查询的主要条件，那么查询性能可能会降低。

在以下情况下，可以考虑使用索引：

对于经常需要搜索的列，可以考虑创建索引，以提高查询效率。
对于主键或者具有唯一约束的列，可以创建唯一性索引，以保证数据的唯一性。
对于经常用于连接的列，可以考虑创建索引，以提高连接效率。
对于经常需要根据某列进行排序或者分组的查询，可以考虑创建索引，以提高排序或者分组的效率。
对于查询中统计或者分组字段，也可以考虑创建索引。

然而，在以下情况下，不建议创建索引：

对于很少被搜索的列，不建议创建索引。
对于基数很低的列，即列中不同的值很少(重复元素多)，不建议创建索引。
对于长文本或者BLOB类型的列，不建议创建索引。
对于查询条件很少出现的列，不建议创建索引。
如果表经常进行大量的插入、删除和修改操作，那么建议谨慎使用索引，因为这会降低数据维护的效率。
对于小表，一般不建议创建索引，因为查询可以直接扫描全表。

总的来说，是否使用索引需要根据具体情况进行权衡，需要根据表的大小、查询的频率和复杂度、数据的维护需求等因素综合考虑。

44.hashmap和hashSet的区别

HashMap和HashSet的区别如下：

实现接口不同：HashMap实现了Map接口，而HashSet实现了Set接口。
实现方式不同。HashMap是基于哈希表实现的，而HashSet底层是基于HashMap实现的。
存储内容不同：HashMap存储的是键值对，其中键是唯一的，而值可以是任意对象。而HashSet存储的是对象，并且每个对象都是唯一的。
添加元素的方法不同：在HashMap中，使用put()方法添加元素，该方法将键和值作为参数。而在HashSet中，使用add()方法添加元素，该方法只将对象作为参数。
计算hashCode的方式不同：HashMap使用键来计算hashCode，而HashSet使用成员对象来计算hashCode。对于两个对象来说，他们的hashCode值可能相同，所以还需要使用equals()方法来判断对象的相等性。
效率不同：因为HashMap使用唯一的键来获取对象，所以相对于HashSet来说，它在某些情况下会更快一些。

总的来说，HashMap和HashSet在存储方式、添加元素、计算hashCode和效率等方面存在差异。选择使用哪一个取决于具体的需求和场景。

45.事务的回滚

事务回滚是指当事务中的某个操作失败时，将撤销该事务中已经完成的所有操作，使数据库回到事务开始前的状态。

在编程中，也可以使用相关API来实现事务回滚，例如在Java中可以使用Connection对象的rollback()方法来回滚事务。

46.内连接和左外连接

内连接：

-- 查询所有员工的last_name,department_name。
select e.last_name,d.department_name
from employees e join departments d on e.department_id=d.department_id
where e.department_id=50;

左外连接：

-- 查询所有员工的last_name,department_name。
select e.last_name,d.department_name
from employees e left join departments d
on e.department_id=d.department_id;

null

47.List遍历方式

1.普通for循环

2.增强for循环 for-each

3.foreach循环

4.迭代器遍历

5.Lambda表达式

6.利用streamAPI遍历

7.先调用toArray()，在利用for循环，遍历这个数组。

48.ArrayList集合1的数据添加到集合2中，有什么方法

1.使用增强for循环遍历，调用add()方法挨个添加。

2.使用addAll()方法

ArrayList<Integer> list1 = new ArrayList<>();  
ArrayList<Integer> list2 = new ArrayList<>();  
  
list1.add(1);  
list1.add(2);  
list1.add(3);  
  
// 使用addAll方法将list1的所有元素添加到list2中  
list2.addAll(list1);

3.使用迭代器遍历

ArrayList<Integer> list1 = new ArrayList<>();  
ArrayList<Integer> list2 = new ArrayList<>();  
  
// 假设我们在list1中添加了一些元素  
list1.add(1);  
list1.add(2);  
list1.add(3);  
  
// 使用迭代器将list1的元素添加到list2中  
Iterator<Integer> iterator = list1.iterator();  
while (iterator.hasNext()) {  
    list2.add(iterator.next());  
}

49.ArrayList线程安全么

默认情况下是不安全的。可以使用使用线程安全的集合类型：CopyOnWriteArrayList。也可以使用Vector动态数组。

50.子类继承父类，怎么调用父类的方法

1.使用子类对象调用

2.使用super关键字

51.sql的执行顺序

from where groupby having select orderby limit

52.mapper接口中有两个参数，怎么传值

在参数前使用@Param注解，将指定的参数名放在占位符中。平时使用的是实体类，这样更加简便，因为属性名和数据库字段名相同，可以省去配置。约定大于配置

53.8个基本数据类型

54.int和Integer的区别

基本数据类型引用数据类型。包装类面向对象。集合只能使用引用类型。

55. 字符串"1,2,3,4,5"，分隔取值

split(",")，返回值时数组

56. 字符串截取字符串

substring()方法

(1参数)，从当前索引到末尾

(2参数) ，左闭右开

57.数据库设计表--学生选课

学生表、课程表、选课表

选课表进行关联，所具有字段(学生id和课程id)

58.情景--接口1

你发现一个别人写的接口，他的执行速度非常慢？你怎么解决？
考验逻辑，首先要定位，找到接口中的哪个代码执行速度慢(通过打日志)，可以看运行时间，再去优化他。定位如果是数据库，就优化数据库问题。

59.情景--接口2

你和B同学，组长发布了同一个任务，B同学用时1个小时，你用时4个小时。你怎么看？
1.首先任务量相同，你花了4个小时，90%都是自身的问题。
2.这个时候就要学会去问前辈(懂得观察别人的状态)
3.去看别人优秀的地方，学习时间可以放在下班后去学习。

60. SpringMVC控制器用的什么注解？

@Controller

61.批量提交用mybatis 什么标签

62、spring bean 生命周期

Spring Bean的生命周期涉及从Bean实例化到最终销毁的整个过程。这个过程主要包括以下阶段：

实例化：为Bean分配内存空间。
属性注入：将当前类依赖的Bean属性进行注入和装配。
初始化：
- 执行各种通知。
- 执行初始化的前置方法。
- 执行初始化方法。
- 执行初始化的后置方法。
  需要注意的是，“初始化”是将程序的执行权从系统级别转换到用户级别，并开始执行用户添加的业务代码。
使用Bean：在程序中使用Bean对象。
销毁Bean：在Spring容器关闭时，会调用Bean的销毁方法，将Bean对象进行销毁操作。

在Bean的生命周期中，Spring还提供了许多扩展点，使得开发者能够定制Bean的行为。例如，通过实现Spring的InitializingBean和DisposableBean接口，开发者可以让容器在Bean初始化和销毁时执行特定的操作。另外，使用JSR-250的@PostConstruct和@PreDestroy注解也可以达到类似的效果。

请注意，Spring Bean的生命周期及其管理是由Spring IoC容器（例如ApplicationContext）负责的。ApplicationContext是BeanFactory的一个具体实现，提供了更多的功能和特性，如国际化、事件发布和AOP等。

总的来说，理解Spring Bean的生命周期对于有效地使用Spring框架进行开发至关重要，它有助于开发者更好地控制和管理Bean的行为，从而实现更健壮、更高效的应用程序。

63. 什么地方用到了拦截器监听器？

64、AOP的底层原理，动态代理？

动态代理——拦截器——责任链——AOP面向切面编程底层原理详解(迪丽热巴版)_动态代理写拦截器-CSDN博客

65.redis什么地方用到了

Redis在多个方面都有广泛的应用，其强大的功能和性能使得它成为许多系统架构中的关键组件。以下是一些Redis的主要应用场景：

缓存：这是Redis使用最广泛的场景之一。通过将频繁读写的数据存储在Redis中，可以显著减轻数据库的压力，提高系统的性能和响应速度。例如，在电商领域，Redis可以缓存热门商品的静态信息或用户数据，从而在大流量访问时加速访问速度。此外，Redis也可以作为数据库和缓存之间的中间件，先将数据从慢速的磁盘数据库加载到快速的Redis内存存储中，再从Redis中读取数据，以此提高读取效率。
会话管理：Redis也可以用于管理用户会话状态，例如Web应用程序中的用户登录状态、购物车内容等。由于其快速的读写速度，Redis适用于需要快速访问和更新的数据。
排行榜和计数器：Redis提供了有序集合数据结构，可以很方便地实现排行榜和计数器功能。例如，游戏中的玩家排名、网站中的热门文章排行等，都可以通过Redis来实现。
消息队列：Redis支持发布/订阅模式，可以用作轻量级的消息队列系统，用于异步任务处理、事件处理等。与传统的消息队列系统相比，Redis作为消息传输的代理具有高效性、简单性和可靠性等优点。
地理空间应用：Redis支持地理空间数据，可以用于构建地理位置应用，如附近的位置查找、位置跟踪等。
分布式锁：在分布式系统中，Redis分布式锁机制可以保证资源的唯一性和可靠性。例如，在微服务架构中，多个服务同时调用同一个接口时，可以使用Redis分布式锁来保证接口在同一时刻只能被一个服务调用。此外，Redis分布式锁还可以用于任务调度和限流等场景。

除此之外，Redis还在在线游戏、物联网（IoT）应用、数据科学和分析等多个领域有广泛的应用。通过其灵活的数据结构和强大的功能，Redis为开发者提供了丰富的工具来解决各种复杂的问题。

二、java高级

1.线程池底层工作原理

1.线程池在刚创建时，里面没有任何线程，当有任务时，才开始创建线程。也可以调用prestartAllCoreThreads() 或者 prestartCoreThread() 方法创建corePoolSize核心线程数目。

2.execute()提交一个任务时，核心线程会先去执行。

3.当核心线程满了时，任务会进入任务队列中缓存。

4.当等待队列满了时，救急线程会去执行再来的任务。

5.当核心线程，等待队列，救急线程都满了时，会执行拒绝策略(默认：AbortPolicy，即抛出RejectedExecutionException异常)。

2.什么是线程池，线程池的创建有哪些？为什么使用线程池？

线程池就是先将多个线程对象放到一个容器中，当时用的时候，不用new线程，直接去线程池中去使用，节省开辟线程时间，提高代码的执行效率。

2.1线程池的创建

在 JDK 的 java.util.concurrent.Executors 中提供了生成多种线程池的静态方法。

1.newCachedThreadPool

创建一个可缓存线程池，可灵活回收空闲线程，如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

2.newFixedThreadPool

创建一个指定工作线程数量的线程池如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

3.newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行，如果这个线程异常结束，会有另一个取代它，保证顺序执行

4.newScheduleThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行。例如延迟3秒执行。

2.2为什么使用线程池

线程池做的工作主要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
主要特点:线程复用;控制最大并发数:管理线程。

第一:降低资源消耗。通过重复利用己创建的线程降低线程创建和销毁造成的消耗。

第二:提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

第三:提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

2.3核心参数

corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、RejectedExecutionHandler

corePoolSize 核心线程数目 - 池中会保留的最多线程数
maximumPoolSize 最大线程数目 - 核心线程+救急线程的最大数目
keepAliveTime 生存时间 - 救急线程的生存时间，生存时间内没有新任务，此线程资源会释放
unit 时间单位 - 救急线程的生存时间单位，如秒、毫秒等
workQueue - 当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务
threadFactory 线程工厂 - 可以定制线程对象的创建，例如设置线程名字、是否是守护线程等
handler 拒绝策略 - 当所有线程都在繁忙，workQueue 也放满时，会触发拒绝策略
1. 抛异常 java.util.concurrent.ThreadPoolExecutor.AbortPolicy
2. 由调用者执行任务 java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy(-自加-可能是主方法去执行)
3. 丢弃任务 java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
4. 丢弃最早排队任务 java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy

2.4线程创建的方式

继承Thread类
实现Runnable接口
实现Callable接口,这种方式可以获得线程结束后的返回值

2.5线程的状态和英文

3.JVM内存结构

执行 javac 命令编译源代码为字节码 (-自加-平时写的代码，是java Source ，java源代码)
执行 java 命令
1. 创建 JVM，调用类加载子系统加载 class，将类的信息存入方法区
2. 创建 main 线程，使用的内存区域是 JVM 虚拟机栈，开始执行 main 方法代码
3. 如果遇到了未见过的类，会继续触发类加载过程，同样会存入方法区 (-zj- 类放在方法区)
4. 需要创建对象，会使用堆内存来存储对象 (-zj-new，创建的实例，放在堆中)
5. 不再使用的对象，会由垃圾回收器在内存不足时回收其内存
6. 调用方法时，方法内的局部变量、方法参数所使用的是 JVM 虚拟机栈中的栈中内存 (-zj-方法参数也是局部变量，基本类型变量，引用类型变量全都在栈中。 )
7. 调用方法时，先要到方法区获得到该方法的字节码指令，由解释器将字节码指令解释为机器码执行
8. 调用方法时，会将要执行的指令行号读到程序计数器，这样当发生了线程切换，恢复时就可以从中断的位置继续(-zj-记录的是程序执行到了哪行代码)
9. 对于非 java 实现的方法调用(不是自己写的方法)，使用内存称为本地方法栈（见说明）(-zj- 例如hashCode()方法)
10. 对于热点方法调用，或者频繁的循环代码(频繁出现)，由 JIT 即时编译器将这些代码编译成机器码缓存，提高执行性能

4.什么情况下会产生StackOverflowError（栈溢出）和OutOfMemoryError（堆溢出）

出现 StackOverflowError 的区域(-栈溢出错误，写代码时出现的错误-)

JVM 虚拟机栈，原因有方法递归调用未正确结束、反序列化 json 时循环引用(-zj-和上面区分开，这个是线程内方法调用过多，把线程内的1M内存耗尽)

出现 OutOfMemoryError 的情况(内存溢出)

堆内存耗尽 – 对象越来越多，又一直在使用，不能被垃圾回收
方法区内存耗尽 – 加载的类越来越多，很多框架都会在运行期间动态产生新的类(-zj-这种情况很少见，一般方法区内存没有设置上限，物理内存有多大，就可以使用多大。)
虚拟机栈累积 – 每个线程最多会占用 1 M 内存，线程个数越来越多，而又长时间运行不销毁时(-zj-线程个数多)

5.什么地方用到事务，具体举例

1.订单页面

在订单页面中，事务可以确保在执行一系列操作时保持数据的一致性和完整性。具体来说，事务可以应用于订单的创建和支付等核心环节。

在创建新订单时，可能需要执行以下操作：

检查用户身份和权限。
查询商品信息。
计算订单总价。
生成订单号。
创建订单对象并保存到数据库。
创建订单详情并将它们保存到数据库。

这些操作要么全部成功要么全部失败，这样可以保持数据的一致性和完整性。如果在执行上述操作的过程中出现任何错误，事务将回滚所有已经完成的操作，以确保数据库的完整性和一致性。

此外，如果在支付环节出现问题，比如支付失败或支付被取消，事务也可以确保这些操作不会对已生成的订单造成影响。如果发生这种情况，事务将回滚所有对数据库所做的修改，保证数据的一致性。

总的来说，事务在订单页面中的应用可以大大提高系统的可靠性和稳定性，避免因操作失败而导致的数据不一致问题。

三、框架

Mybatis

什么是ORM

怎么理解Mybatis、Mybatis与jdbc相比的优势、Mybatis和JDBC的区别

占位符${}、#{}的区别

字符拼接、预编译

Mybatis怎么处理结果集映射

Mybatis的原理

Mybatis的优点

减少代码量，简单持久化框架，易学灵活，不会对程序和数据库的设计造成任何影响，SQL语句写在xml文件实现解耦便于管理。提供xml标签，可以编写动态sql语句，提供结果映射标签，支持对象和数据库ORM字段关系映射。

MyBatis最核心的功能，就是实现了输入映射和输出映射。

输入映射将Java对象转换为可供SQL语句执行的参数

输出映射SQL查询结果映射为Java对象。

mybatis一个语句,传入两个参数,用什么注解

Spring

DI依赖注入

AOP面向切面

Spring中@Autowired和@Resource的区别

@Autowired和@Resource的主要区别体现在装配方式、参数数量和使用范围上。

注解所属：@Autowired是spring-beans模块提供的注解，而@Resource是JSR 250规范提出的注解，由JDK自带。
装配方式：@Autowired注解只能按照类型装配依赖，如果需要按照名称装配则需要指定@Qualifier注解。@Resource默认依赖bean的名称为属性名，并且可以通过其属性name进行指定。默认依赖的bean的类型为属性的类型，并且可以通过type属性进行指定。如果未指定依赖的bean的名称并且属性名对应的bean在容器中不存在时才会按照类型进行注入，否则按照名称进行注入依赖。(@Autowired默认按type自动装配，而@Resource默认按name自动装配。当然，@Resource注解可以自定义选择，如果指定了name，则根据name自动装配，如果指定了type，则用type自动装配)
参数数量：@Autowired只包含一个参数：required，表示是否开启自动准入，默认是true。而@Resource包含七个参数，其中最重要的两个参数是：name和type。
注解使用范围：@Autowired能够用在构造器、方法、参数、成员变量和注解上，而@Resource则用在类、成员变量和方法上。

为什么用springboot

Spring Boot 是一个开源的 Java Web 框架，它可以帮助开发者快速创建独立、可运行的、生产级别的 Spring 应用程序。以下是使用 Spring Boot 的一些原因：

独立运行：Spring Boot 应用程序可以作为独立的应用程序运行，不需要部署到 Web 服务器或应用服务器。它内置了一个嵌入式服务器，例如 Tomcat 或 Jetty，使应用程序能够快速启动和运行。
自动配置：Spring Boot 具有自动配置的特性，可以根据项目中的类路径、属性设置和条件来自动配置应用程序。这减少了手动配置的工作量，使开发者能够专注于编写业务逻辑。
简化开发：Spring Boot 提供了很多开箱即用的功能，例如安全性、数据库访问、消息传递等。它还提供了许多插件和扩展点，可以快速集成其他功能和组件。这些特性可以加速开发过程，使开发者能够更快速地构建应用程序。
可定制化：虽然 Spring Boot 提供了许多默认配置和插件，但它也允许开发者根据需要进行定制。开发者可以通过修改配置文件、扩展默认插件或创建自定义插件来满足特定的需求。
微服务支持：Spring Boot 非常适合构建微服务架构的应用程序。它可以轻松创建独立的、可扩展的微服务，并通过轻量级通信协议（如 HTTP 和 RESTful API）进行通信。
社区支持：Spring Boot 拥有庞大的开发者社区和生态系统，提供了丰富的资源和支持。开发者可以从社区中获取帮助、学习最佳实践并分享自己的经验。

总之，Spring Boot 通过提供自动化配置、简化开发过程、支持微服务架构和提供强大的社区支持等特性，帮助开发者更高效地构建和部署 Java 应用程序。

springboot和springmvc的区别

1.springboot快速搭建web项目的工具，springmvc更属于是三层架构，将每层之间的依赖关系降到最低，实现解耦，提高了代码的可重用性，扩展性。。

2.springboot更专注与后台数据接口，不开发前端视图，同时遵循约定优于配置，简化了配置流程，不需要配置XML文件。SpringBoot的所有自动配置类都在spring-boot-autoconfigure.jar中spring.factories里面。导入了对应的starter，就有对应的启动器，有了启动器就能帮我们进行自动配置类

springmvc覆盖前端视图开发、文件配置、后台接口逻辑，XML和config等配置相对复杂。

3.Spring Boot可以创建独立的Spring应用程序，内嵌Tomcat

Spring MVC的项目通常需要部署在Web服务器上

4.Spring Boot更注重整体应用的开发和启动，而Spring MVC更注重Web应用的MVC架构设计和组件的解耦。

springboot常用注解

(自己手写) mapper \ service \ controller \ restcontroller \ autowried \ requestmapping \ getmapping \ postmapping \ putmapping \ deletemapping \ requestbody \ responsebody \ param \ pathvariable \ springbootapplication \ mapperscan \ configuration \ bean \ component \ data \ allargs... \ noargs.. \ EnableTransactionManagement \ tablename \ tableid \ enableautoconfiguration

Spring Boot 提供了许多常用的注解，以下是一些常用的注解：(官方答案)

@SpringBootApplication：这是一个复合注解，通常用在主类上，它组合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。
@EnableAutoConfiguration：它告诉 Spring Boot 根据添加的 jar 依赖自动配置项目。
@ComponentScan：这个注解使 Spring 能够发现并加载你项目中定义的组件，这通常通过扫描你的类路径中定义的特定包来完成。
@Configuration：用于定义配置类，可替换 XML 配置文件。
@RestController：是 @Controller 和 @ResponseBody 的组合注解，用于创建 RESTful web 服务。
@RequestMapping：用于映射 Web 请求到特定的处理器类或者处理器方法上。
@Autowired：Spring 中的一个依赖注入注解，它可以对类成员变量、方法及构造函数进行标注，让 Spring 完成 bean 自动装配的工作。
@Service：用于标注业务层组件。
@Repository：用于标注数据访问组件 (DAO组件)。
@Entity：用于标注实体类。
@Transactional：用于声明一个方法或类应该被 Spring 的事务管理器用作事务边界。
@EnableScheduling：启用 Spring 的定时任务功能。
@Scheduled：用于标注定时任务。
@Profile：表示当指定的 Profile 激活时，组件或配置才有效。
@Bean：用在方法上，声明一个方法返回一个对象，这个对象要被 Spring 管理。

以上只是一部分常用的注解，Spring Boot 和 Spring 框架包含了许多其他的注解，可以根据你的具体需求选择使用。