面试笔记

面试题笔记

一、SpringBoot热部署

spring开发者提供了spring-boot-devtools的模块，
使用Springboot应用支持热部署，
提交开发者的开发效率，无需重启SpringBoot应用，
达到代码更新的效果。

devtools的原理

深层原理使用了两个ClassLoader，
一个ClassLoader加载那些不会改变的类(第三方Jar包)，
另外一个ClassLoader加载会更改类，
称为restart ClassLoader，
这样代码在更改之后，
原来的restart ClassLoader会被舍弃掉，
重新创建一个restart ClassLoader，
由于需要加载的类比较少，所以实现了较快的重启时间

实现方式

1、先引入spring-boot-devtools的模块依赖

2、在标签下的里加入

<plugin>

<!--热部署配置-->

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<!--fork:如果没有该项配置,整个devtools不会起作用-->

<fork>true</fork>

</configuration>

</plugin>

3、设置IDEA自动编译

### 1)、File-Settings-Compiler勾选 Build Project automatically

### 2)、快捷键 ctrl + shift + alt + /,选择Registry,勾上 Compiler autoMake allow when app running

二、抽象类和接口的区别

### 1、抽象类是使用abstract关键字

### 2、接口是使用interface关键字

相同点

#### 1)、都是不能被实例化

#### 2)、接口的实现类或者抽象类的子类
都只有实现了接口或者抽象类的方法后才能实例化

不同点

#### 1）、接口只能定义、不能有方法的实现(方法体)、
java8中可以定义default方法体；

#### 而抽象类可以有定义与方法的实现、方法可以在抽象类中实现

#### 2)、实现接口的关键字是implements/ˈɪmplɪm(ə)nt/ ,
继承抽象类的关键字是extends /ɪk'stendz;/

#### 3)、一个类可以实现多个接口（间接实现多继承）、一个类只能继承一个抽象类

#### 4)、接口成员变量默认都是public static final,必须赋值（也就是所谓的常量）
之后不能被修改

#### 5)、接口所有的方法都是public abstract的。
抽象方法被abstract修饰之后，不能被private、static等修饰

三、redis五种数据类型

string(字符串)、list(链表)、set(集合)、zset(有序集合)、hash(散列集合)

四、redis的应用场景

1、缓存
在高访问量前，如果每次用户的访问都要进行数据库查询的话，会增加数据库的压力，使用redis缓存技术，减压
//  定义键
userRedisKey = "user:info:" + id;
//  从 Redis 获取值
value = redis.get(userRedisKey);
if (value != null) {
//  将值进行反序列化为 UserInfo 并返回结果
userInfo = deserialize(value);
return userInfo;
}

2、接口防刷
验证码登录、一般验证码都是手机短信调用的是第三方接口，
如果有心之人利用它的话，会造成不必要的损失，解决方法就是限流
phoneNum = "136xxxxxxxx";
key = "shortMsg:limit:" + phoneNum;
// SET key value EX 60 NX
isExists = redis.set(key,1,"EX 60","NX");
if(isExists != null || redis.incr(key) <=5){
//  通过
}else{
//  限流
}

六、简述SpringBean的生命周期

1、bean定义：在配置文件里使用bean标签进行定义
2、bean初始化：两种方式初始化
  1)、配置文件通过指定init-method属性来完成
  2)、实现InitializingBean接口
3、bean调用：有三种方式bean实例(注入)，然后调用
  1)、set注入
  2)、构造器注入
  3)、注解注入
4、bean销毁：两种方式
  1)、配置文件通过destroy-method属性完成
  2)、实现DisposeableBean接口

七、什么是死锁？如何避免

死锁：
	当两个线程互相等待对方释放资源时造成的阻塞现象，无外力作用，它们无法推进下去
产生条件：
1)、互斥条件
	临界资源是独占资源，进程互斥且排他使用这些资源
2)、占用和等待条件
	进程在请求资源得不到满足而等待，不释放已有资源
3)、不可剥夺条件
	不可抢占，已获资源只能线程自愿释放，不允许其他线程剥夺
4)、循环等待条件
	存在循环等待链，其中，每个进程都在等待链中等待下一个进程所持有的资源，造成这组进程处于永远等待状态

八、什么是反射？获取对象的方式，应用场景

反射就类似黑客，在黑客面前是隐私可言的；
反射是在运行状态，
	对于任意类、知道任意类的所有属性和方法；
	对于任意对象、可以调用对象的属性和方法；
java中有一个反射机制：
	动态获取信息以及动态调用对象的功能
获取对象的三种方式：
	1、通过实例对象.getClass()方法获取
	Person person = new Person();
	Class<?> class1 =  person.getClass();
	2、通过类的class属性获取
	Class<?> class2 =  Person.class;
	3、通过Class类的静态方法-forName()获取
	Class<?> class2 =  Class.forName("com.tao.pojo.Person");
应用场景：
	代理模式的Method.invoke()
	注解：通过获取class对象
缺点：性能消耗较大	

九、手写单例模式

//单例模式：
	单例模式主要避免多个对象的创建导致资源浪费，多个实例对象的调用容易结果出现错误，整个应用中有且只能有一个实例对象。
//懒汉式
public class Singleton{
	//直接创建对象
	private static Singleton instance = new Singleton();
	//将构造器私有化
	private Singleton(){
	
	}
	//返回对象实例
	public static Singleton getInstance(){
		return instance;
	}
}
//饿汉式
public class Singleton{
    private static Singleton instance;
    //将结构器私有化
    private Singleton(){
        
    }
    //提供对外方法
    public Singleton getInstance(){
        if(instance==null){
            return new Singleton();
        }
        return instance;
    }
}
//双检锁/双重校验锁(饿汉式)
public class Singleton{
	//声明变量
	private static volatile Singleton singleton = null;
	//私有化构造器
	private Singleton(){
	
	}
	//提供对外方法
	public static Singleton getInstance(){
		if(singleton==null){
		    synchronized(Singleton.class){
		    	if(singleton==null){
		    		singleton = new Singleton();
                    /**
                    *1、分配内存空间
                    *2、执行构造方法，对象初始化
                    *3、把对象指向分配的内存空间
                    *可能会指令重排-可能123或132，使用volatile保证原子性，静止JVM指令重排
                    */
		    	}
		    }
		}
		return singleton;
	}
}

十、脏读、不可重复读、幻读

脏读：就是一个事务对数据库的某一条数据进行访问并且进行了修改、还没有提交事务，然后另一个事务，刚好访问这一条还没提交事务的数据，然后使用这条数据；
不可重复读：就是第一个事务读取多次同一条数据，然后事务还没结束，然后第二个事务对这个数据进行修改，最后导致第一个前后读取的结果不一致；
幻读：当前事务不独立执行时，插入或者删除的事务影响到当前事务的结果；
	事务A将数据库所有数据删除的同时，事务B新插入一个数据，事务A删除后查询数据库时，发现还有一条数据，就跟产生幻觉类似。
总结：
	不可重复读：重点强调是修改
	幻读：重点强调的是新增跟删除。

十二、观察者模式

观察者模式：一种行为型模式，一对多的关系依赖，如果一个对象被修改或者删除，会同时通知其他依赖的对象。
/**
 * 注册一个观察者
 */
public void registerObserver(Observer observer);

/**
 * 移除一个观察者
 */
public void removeObserver(Observer observer);

/**
 * 通知所有观察者
 */
public void notifyObservers();
------------------------------------------------------------------
@Override
 public void registerObserver(Observer observer) {
     observers.add(observer);
 }
 @Override
 public void removeObserver(Observer observer) {
     int index = observers.indexOf(observer);
     if (index >= 0) {
         observers.remove(index);
     }
 }
 @Override
 public void notifyObservers() {
     for (Observer observer : observers) {
         observer.update(msg);
     }
 }
 /**
  * 主题更新信息
  */
 public void setMsg(String msg) {
     this.msg = msg;
     notifyObservers();
 }
----------------------------------------------------------
 public ObserverUser1(Subject subject) {
     subject.registerObserver(this);
 }
 @Override
 public void update(String msg) {
     Log.e("-----ObserverUser1 ", "得到 3D 号码:" + msg + ", 我要记下来。");
 }	
----------------------------------------------------------
  // 创建服务号
  objectFor3D = new ObjectFor3D();
  // 创建两个订阅者
  observerUser1 = new ObserverUser1(objectFor3D);
  observerUser2 = new ObserverUser2(objectFor3D);
  // 两个观察者,发送两条信息
  objectFor3D.setMsg("201610121 的3D号为:127");
  objectFor3D.setMsg("20161022 的3D号为:000");    

十三、数据库三范式

第一范式：强调的是原子性，就是数据库表的字段每一列都是不可再分的
第二范式：每个表必须有且只有一个主键，其他属性需要完全依赖主键
第三范式：数据库中每一列都和主键是直接相关，而不能间接相关

十四、truncate和delete区别

truncate属于DDL语言，默认是直接清空表内容，然后被清空的内容不能回退，删除速度比delete速度快
delete属于DML语言，删除可以带条件，被删除的内容可以回退

十六、你有什么要问的么

贵公司有什么对于新人的一些培训项目吗，
倘若我进入贵公司实习，想尽快转正，请问有没有什么晋升途径。
您在贵公司中一天工作都有哪些？

作为公司的管理层人员，您认为优秀的员工应该具备怎么样的特质？
如果我有幸入职贵公司，请问有什么要提前学习和准备呢？
假如我在贵公司实习，请问在贵公司工作有什么特别的体验？
能否为我介绍一下工作环境，或者是否有机会能参观一下贵公司？　
您觉得工作过程中，有什么需要注意的点？

十七、JSP执行流程

1、客户端浏览器发起请求
2、Tomcat服务器解析请求地址，找到对应的具体应用(servlet)
3、找到对应的jsp文件，jsp文件转化成。java的文件
4、java文件编译成字节码class文件
5、响应给客户端

十八、jsp九大内置对象

1、Request:封装客户端的请求，请求一般包含get和post
2、Response:封装服务器对客户端的响应
3、Page:类似于java类中的this关键字
4、PageContext:提供对Jsp页面所有对象以及命名空间的访问
5、Session:一种会话技术，一般记录登录用户的基本相关信息
6、Out：类似java中的输出流对象
7、Config:可以通过此对象获取一些配置的信息
8、Exception:java中的异常对象，代表jsp页面中对应的异常对象
9、Application:类似全局变量，在这个对象中保存的信息，在整个应用中一直有效

十九、重载和重写的区别

重载：发生在同一个类中，
	必须相同的条件：方法名必须相同，
	要点(参数列表)：是参数列表不同(参数个数，参数类型，参数顺序)，
	访问修饰符：可以不同。
重写：
含义：就是子类对父类可以访问的方法进行一个重新的编写，
	必须相同的条件：发生在子类中，要求的方法名相同，返回类型也要相同，
	抛出的异常：如果重写的方法，父类有抛出异常，子类重写的方法要小于等于父类的抛出异常
	访问修饰符：访问修饰符大于等于父类。