一、Java基础

1、Java中两种数据类型（为后面进一步提问做铺垫）

（1）基本数据类型，分为boolean、byte、int、char、long、short、double、float；

（2）引用数据类型 ，分为数组、类、接口。

扩展：Java中引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

基本数据类型: boolean，char，byte，short，int，long，float，double

封装类类型： Boolean，Character，Byte，Short，Integer，Long，Float，Double

2、java中==和eqauls()的区别

== 分两类分析，既可以比较基本类型也可以比较引用类型，对于基本类型来说是比较的数值。对于引用类型来说比较的内存地址值；equals是属于java.lang.Object类里面的方法，Object里的equals里默认的是双等于==。分两种情况讨论：一种是自定义类，看自定义类有没有重写equals方法，通常情况下，如果重写了equals则比较的是类中相应属性是否相等。如果没有重写equals方法，则仍然使用==比较的是地址。

总结、：

== ：

基本类型：比较值是否相等

引用类型：比较的就是内存地址是否相同

equals :

引用类型：默认情况下，比较的是地址值。可以进行重写，使其比较对象的值是否相等。

3、说说int和Integer有何区别

（1）Integer是int的包装类；int是基本数据类型；

（2）Integer变量必须实例化后才能使用；int变量不需要；

（3）Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；

（4）Integer的默认值是null；int的默认值是0。

4、switch中能否使用string类型的参数作为变量（涉及到jdk版本的理解）

在JDK1.7之前，switch只能支持byte、short、char、int、float、double或者其对应的封装类以及Enum类型。JDK1.7开始支持String。当字符串不会频繁改变时可以用枚举来代替String。

5、说明ArrayList和LinkedList的区别和优缺点，在哪些场景会使用？

区别：

（1）ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构；

（2）对于随机访问的get和set方法，ArrayList要优于LinkedList，因为LinkedList要移动指针；

（3）对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据；

各自优缺点：

（1）对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是 统一的，分配一个内部Entry对象。

（2）在ArrayList集合中添加或者删除一个元素时，当前的列表移动元素后面所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。

（3）LinkedList集合不支持 高效的随机随机访问（RandomAccess），因为可能产生二次项的行为。

（4）ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

应用场景：

ArrayList使用在查询比较多，但是插入和删除比较少的情况，而LinkedList用在查询比较少而插入删除比较多的情况

6、实现多线程的几种方式，多线程的应用场景有哪些？

（1）、继承Thread类，重写run方法

（2）、实现Runnable接口，重写run方法。【可以避免由于Java的单继承特性而带来的局限。适合多个线程去处理同一资源的情况】

（3）、实现Callable接口，重写call方法。【有返回值，允许抛出异常】

（4）、使用线程池【减少创建新线程的时间，重复利用线程池中线程，降低资源消耗，可有返回值】

7、${}和#{}的区别

使用#{}：

（1）、传入参数，sql在解析的时候会加上" ",当成字符串来解析，如 id = “id”;

（2）、#{}能够很大程度上防止sql注入;

使用${}：

（1）、传入数据直接显示在生成的sql中，sql在解析的时候值为id = id。

（2）、${}方式无法防止sql注入

最后：能用#{}时尽量用#{}，但有些场合需要使用$。

注意MyBatis排序时使用order by 动态参数时需要注意，用$而不是#（#会自动拼接符号）

8、描述一下JVM加载class文件的原理机制和特点。

Java中的所有类，都需要由类加载器装载到JVM中才能运行。JVM中类的加载是由类加载器（ClassLoader）和它的子类来实现的。在我们使用一个类之前，JVM需要先将该类的字节码文件（.class文件）从磁盘、网络或其他来源加载到内存中（加载Class文件到JVM），并对字节码进行解析生成对应的Class对象，这就是类加载器的功能。我们可以利用类加载器，实现类的动态加载。在写程序的时候，我们几乎不需要关心类的加载，因为这些都是隐式装载的，除非我们有特殊的用法，像是反射，就需要显式的加载所需要的类。

Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(像是基类)完全加载到jvm中，至于其他类，则在需要的时候才加载。这当然就是为了节省内存开销。

进一步提问：类加载的方式有几种？区别是什么？

类装载方式有两类：隐式装载和显示装载，其中显示装载又分2种方式。

（1）、隐式装载，程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中，比如

Dog dog ＝ new Dog()；【第一种方式】

（2）、显式装载，

【第二种方式】使用Class.forName()通过反射加载类型，并创建对象实例，比如

Class clazz ＝ Class.forName(“Dog”)；

Object dog ＝clazz.newInstance()；

如果无法找到Dog，则抛出ClassNotFoundException。

【第三种方式】使用某个ClassLoader实例的loadClass()方法

Class clazz ＝ classLoader.loadClass(“Dog”);

Object dog＝clazz.newInstance();

如果无法找到Dog，则抛出ClassNotFoundException。

区别：

方式1和2使用的类加载器是相同的，都是当前类加载器（即：this.getClass.getClassLoader）。

方式3由用户指定类加载器。如果需要在当前类路径以外寻找类，则只能采用方式3。即第3种方式加载的类与当前类分属不同的命名空间。

方式1是静态加载，方式2和3是动态加载。

进一步提问：java内置的类加载器（ClassLoader）有哪些，简述一下类加载器工作原理

Java的类加载器有三个:![在这里插入图片描述](https://img-blog.csdnimg.cn/20210406162429151.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIwODI4NzY=,size_16,color_FFFFFF,t_70#pic_center

第一种是Bootstrap Loader(引导类加载器)。它的实现依赖于底层操作系统，由C编写而成，没有继承于ClassLoader类。根类加载器从系统属性sun.boot.class.path所指定的目录中加载类库。默认为jre目录下的lib目录下的class文件，该加载器没有父加载器。负责加载虚拟机的核心类库，如java.lang.*。Object类就是由根类加载器加载的。

第二种是Extended Loader(标准扩展类加载器)。它的父加载器为根类加载器。由java编写而成，是ClassLoader的子类。它从java.ext.dirs中加载类库，或者从JDK安装目录jre\lib\ext子目录下加载类库。如果把用户创建的jar文件放在该目录下，也会自动由扩展类加载器加载。

第三种是AppClass Loader(应用程序类路径类加载器)。它的父加载器为扩展类加载器。由java编写而成，是ClassLoader的子类，它从环境变量classpath或者系统属性java.class.path所指定的目录中加载类，是用户自定义的类加载器的默认父加载器。

加载类时，会以Bootstrap Loader→Extended Loader→AppClass Loader的顺序来寻找类，如果找不到，就会丢出NoClassDefFoundError。

9、在一个类中，声明了若干个static方法和非static方法，声明的static方法能否直接访问声明的非static方法？

static方法不能直接访问非static方法，因为static方法是属于这个类本身的一个方法，在编译期间就已经确定了；而非static方法是属于这个类的对象的方法，需要在实例化之后才能访问到。即：static方法调用时不需要创建对象，可以直接调用，非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，若在static方法中访问非static方法，非static方法不知道关联到哪个对象上，将不能通过编译。

进一步提问：说一下静态方法和非静态方法都是在什么时候被装载到内存中的？

静态方法（Static Method）与静态成员变量一样，属于类本身，在类装载的时候被装载到内存（Memory），不自动进行销毁，会一直存在于内存中，直到JVM关闭。

非静态方法（Non-Static Method）又叫实例化方法，属于实例对象，实例化后才会分配内存，必须通过类的实例来引用。不会常驻内存，当实例对象被JVM 回收之后，也跟着消失。

进一步提问：静态方法怎样访问非静态方法？

静态方法不能直接使用本类的非静态方法

解决方式有三种

（1）、两个方法都改成非静态

（2）、两个方法都改成静态

（3）、先创建类的实例，然后静态方法再调用这个实例的非静态方法

10、在Java中,对象什么时候可以被垃圾回收?

Java垃圾回收不是实时的，垃圾回收器的作用是查找和回收（清理）无用的对象。以便让JVM更有效的使用内存。垃圾回收器的运行时间是不确定的，由JVM决定，在运行时是间歇执行的。也可以通过System.gc()来强制回收垃圾，但是这个命令下达后JVM不一定会立即响应执行，但间隔一小段时间基本都会执行。

11、一个汉字占几个字节

中文在不同编码下占不定长的 2~4个字节。注意在utf-16中占用两个字节，在java 运行时用UTF-16编码在转码的时候会在前面加上表示字节顺序的字符，这个字符称为”零宽度非换行空格”（ZERO WIDTH NO-BREAK SPACE），用FEFF表示。FEFF占用两个字节。

   public static void main(String[] args) {try {String str0 = "你";System.out.println(str0+"           GBK编码  占用字节  ：" + str0.getBytes("GBK").length);//GBK是采用单双字节变长编码，英文使用单字节编码，中文部分采用双字节编码。System.out.println(str0+"        GB2312编码  占用字节  ：" + str0.getBytes("GB2312").length);System.out.println(str0+"         UTF-8编码  占用字节  ：" + str0.getBytes("UTF-8").length);//UTF-8使用1~4字节为每个字符编码,中文使用三字节编码System.out.println(str0+"        UTF-16编码  占用字节  ：" + str0.getBytes("UTF-16").length);//UTF-16使用2~4字节为每个字符编码,中文和英文使用双字节字节编码（一般情况）System.out.println("…………………………………………");String str = "你好";System.out.println(str+"       GBK编码  占用字节  ：" + str.getBytes("GBK").length);System.out.println(str+"    GB2312编码  占用字节  ：" + str.getBytes("GB2312").length);System.out.println(str+"     UTF-8编码  占用字节  ：" + str.getBytes("UTF-8").length);System.out.println(str+"    UTF-16编码  占用字节  ：" + str.getBytes("UTF-16").length);System.out.println("…………………………………………");String str2 = "你好呀HI";System.out.println(str2+"     GBK编码  占用字节  ：" + str2.getBytes("GBK").length);System.out.println(str2+"  GB2312编码  占用字节  ：" + str2.getBytes("GB2312").length);System.out.println(str2+"   UTF-8编码  占用字节  ：" + str2.getBytes("UTF-8").length);System.out.println(str2+"  UTF-16编码  占用字节  ：" + str2.getBytes("UTF-16").length);} catch (UnsupportedEncodingException e) {e.printStackTrace();}}

12、项目中使用Maven进行构建，有哪些优势？你使用过哪些maven命令？说一下maven中本地仓库和远程仓库的区别和联系。

优点：

（1）创建项目，自动关联和下载依赖的jar包，统一维护jar包

（2）升级框架版本方便

常用 Maven 命令：

（1）、安装项目到本地仓库：mvn install

（2）、创建maven项目：mvn archetype:generate

（3）、验证项目是否正确：mvn validate

（4）、maven 打包：mvn package

（5）、只打jar包：mvn jar:jar

（6）、生成源码jar包：mvn source:jar

（7）、产生应用需要的任何额外的源代码：mvn generate-sources

（8）、编译源代码： mvn compile

（9）、编译测试代码：mvn test-compile

（10）、运行测试：mvn test

（11）、运行检查：mvn verify

（12）、清理maven项目：mvn clean

Maven仓库关系：

maven的仓库只有两大类：1.本地仓库 2.远程仓库，在远程仓库中又分成了3种：2.1 中央仓库 2.2 私服 2.3 其它公共库

运行Maven的时候，Maven所需要的任何构件都是直接从本地仓库获取的。如果本地仓库没有，它会首先尝试从远程仓库下载构件至本地仓库，然后再使用本地仓库的构件。

13、Thread.sleep(0)有没有实际作用

触发操作系统立刻重新进行一次CPU竞争，操作系统重新计算线程的优先级（包括当前线程）。竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

二、前端框架

1、在项目中使用过哪些前端框架？

Vue（用于构建用户界面的 渐进式框架，特点：轻量级、双向数据绑定、组件化）、

React（构建用户界面的 JAVASCRIPT 库，特点：只负责显示、声明式框架、数据驱动DOM）、

Angular（前端JS框架，核心：MVVM、模块化、自动化双向数据绑定、语义化标签、依赖注入等）、

QucikUI（企业级web前端开发解决方案）、

Layui（前端 UI 框架）、

Avalon（前端MVVM框架）、

还有Dojo、Ember、Aurelia等

2、js中如何查看某变量的数据类型？可以查看的数据类型有哪些？

使用typeof查看变量的数据类型。

javascript共有6种数据类型：

基本类型5种：number、string、boolean、null、undefined。引用类型1种：object

typeof检测返回6种：undefined、boolean、string、number、object、function

3、前端进行文件下载时，能不能用ajax向后端发起请求？

Ajax不能实现文件下载功能

原因：ajax的返回值是json,text,html,xml类型，或者可以说ajax的接收类型只能是String字符串，不是流类型，所以无法实现文件下载。但用aja仍然可以获得文件的内容（可以读取到返回的response，但只是读取而已），该文件将被保留在内存中，无法将文件保存到磁盘，这是因为javascript无法和磁盘进行交互，否则这会是一个严重的安全问题，js无法调用浏览器的下载处理机制和程序，会被浏览器阻塞。

4、如何解决前后端交互过程中特殊字符的传参（比如中文、特殊符号等）？

（这个问题属于送分题，有一定项目经验的人，都会注意到在前后端进行交互时，需要进行decoder编码-Encoder解码的过程，防止乱码）

进一步提问：前后端数组传参如何处理？

前端：数据使用JSON.stringify(str)处理

后端：数据转换：List objectList = JSONObject.parseArray(str, Object.class)

5、FreeMarker、jsp、html 三者的区别

先说说freemarker和jsp的不同，运行机制就不大一样,jsp是编译成继承自servlet的class文件，运行jsp就是运行一个servlet（Java文件编译后会产生一个class文件，最终执行的就是这个class文件，JSP也一样，它也要编译成class文件。JSP不止要编译，它还得要转译，首先把JSP转译成一个Servlet文件，然后再编译成class文件。当用户访问JSP时就执行了class文件）。

而freemarker就是套模板，通过模板+内容直接生成HTML然后输出。

HTML（Hypertext Markup Language）文本标记语言，它是静态页面，和JavaScript一样是解释性语言。

JSP（Java Server Page）Java服务端的页面，它是动态页面，它是需要经过JDK编译后把内容发给客户端去显示。

6、vue实例内部和外部分别怎么调用vue中的方法?

内部调用： this.operate();

外部调用：vm.operate(); （vm是vue实例名）

三、后端技术

1、Spring:

（1）Spring中IOC和AOP的应用场景。

AOP：面向切面编程。可以运用在日志，事务和异常处理等。如果不使用aop，那么就必须在每个类和方法中去实现它们。代码纠缠在一起。每个类和方法中都包含日志、事务或者异常处理甚至是业务逻辑。在一个这样的方法中，很难分清代码中实际做的是什么处理。AOP 所做的就是将所有散落各处的事务代码集中到一个事务切面中。

AOP日志处理：使用Aop在接口方法上插入一行自定义的切面注解类，在切面处理类中可以记录接口名称、请求参数、请求ip、请求url、请求时间、响应参数、响应状态、调用时长等；
实体类：

import java.io.Serializable;
import java.util.Date;/*** @description: 接口日志记录实体类* @date 2021/01/13 10:02*/
public class InterfaceLog implements Serializable {private static final long serialVersionUID = 1L;//主键idprivate Long id;//接口名称private String interfaceName;//请求参数private String requestParam;//响应参数private String responseParam;//调用时长（毫秒）private long invokeTime;//接口状态（200：正常）private Integer responseState;//接口调用URLprivate String requestUrl;//接口调用时间private Date requestTime;//ipprivate String requestIp;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getInterfaceName() {return interfaceName;}public void setInterfaceName(String interfaceName) {this.interfaceName = interfaceName;}public String getRequestParam() {return requestParam;}public void setRequestParam(String requestParam) {this.requestParam = requestParam;}public String getResponseParam() {return responseParam;}public void setResponseParam(String responseParam) {this.responseParam = responseParam;}public long getInvokeTime() {return invokeTime;}public void setInvokeTime(long invokeTime) {this.invokeTime = invokeTime;}public Integer getresponseState() {return responseState;}public void setresponseState(Integer responseState) {this.responseState = responseState;}public String getRequestUrl() {return requestUrl;}public void setRequestUrl(String requestUrl) {this.requestUrl = requestUrl;}public Date getRequestTime() {return requestTime;}public void setRequestTime(Date requestTime) {this.requestTime = requestTime;}public String getRequestIp() {return requestIp;}public void setRequestIp(String requestIp) {this.requestIp = requestIp;}
}

切面处理类

import com.alibaba.fastjson.JSON;import net.hfmri.iafc.entity.InterfaceLog;
import net.hfmri.iafc.service.InterfaceLogService;
import net.hfmri.iafc.util.HttpContextUtils;
import net.hfmri.iafc.util.IPUtils;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import net.hfmri.iafc.config.annotation.MyLog;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.Map;/*** 系统日志：切面处理类*/
@Aspect
@Component
public class InterfaceLogAspect {@Autowiredprivate InterfaceLogService interfaceLogService;//定义切点 @Pointcut//在注解的位置切入代码@Pointcut("@annotation(net.hfmri.iafc.config.annotation.MyLog)")public void logPoinCut() {}@Around("logPoinCut()")public Object around(ProceedingJoinPoint point) throws Throwable {long beginTime = System.currentTimeMillis();// 执行方法Object result = point.proceed();// 执行时长(毫秒)long time = System.currentTimeMillis() - beginTime;//异步保存日志saveLog(point, time,result);return result;}/*** 切面* @param joinPoint* @param time* @param result* @throws Throwable*/void saveLog(ProceedingJoinPoint joinPoint, long time, Object result) {try {RequestAttributes ra = RequestContextHolder.getRequestAttributes();ServletRequestAttributes sra = (ServletRequestAttributes) ra;HttpServletRequest request = sra.getRequest();String url = request.getRequestURL().toString();int status = sra.getResponse().getStatus();//String method = request.getMethod();//保存日志InterfaceLog interfaceLog = new InterfaceLog();//从切面织入点处通过反射机制获取织入点处的方法MethodSignature signature = (MethodSignature) joinPoint.getSignature();//获取切入点所在的方法Method method = signature.getMethod();//获取操作MyLog myLog = method.getAnnotation(MyLog.class);if (myLog != null) {String value = myLog.value();interfaceLog.setInterfaceName(value);//保存获取的操作}//获取请求路径interfaceLog.setRequestUrl(url);//请求的参数Map<String,String[]> requestParam = request.getParameterMap();JSONObject jsonObject=JSONObject.fromObject(requestParam);String requestParamStr = jsonObject.toString();if(StringUtils.isNotEmpty(requestParamStr)){requestParamStr=requestParamStr.replaceAll("\\[","").replaceAll("]","");}interfaceLog.setRequestParam(requestParamStr);//不要在这个方法里面再写 Object result = joinPoint.proceed()，point.proceed()写多次，导致接口会多次调用interfaceLog.setResponseParam(JSON.toJSONString(result));interfaceLog.setRequestTime(new Date());//获取用户ip地址HttpServletRequest httpServletRequest = HttpContextUtils.getHttpServletRequest();interfaceLog.setRequestIp(IPUtils.getIpAddr(httpServletRequest));interfaceLog.setInvokeTime(time);interfaceLog.setresponseState(status);//调用service保存SysLog实体类到数据库interfaceLogService.save(interfaceLog);}catch (Exception e) {e.printStackTrace();}}}

AOP事务处理：Spring在方法访问数据库之前，自动开启事务，当访问数据库结束之后，自动提交/回滚事务；

AOP异常处理：自定义开启环绕通知，一旦运行接口报错，环绕通知捕获异常跳转异常处理页面。

IOC就是Inversion of Control，即控制反转，又称依赖注入。它不是什么技术，而是一种设计思想。在Java开发中，传统的创建对象的方法是直接通过 new 关键字（之前我们通过 "类名 对象名 = new 类名( )"的方式进行对象的创建，也就是说我们的程序负责对象的创建，控制了它是否被创建这件事情，这就叫做控制），而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。这称为控制反转。概括的说就是：

IOC 让程序员不再关注怎么去创建对象，而是关注于对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。

举个例子：梳理这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实例，被调用者)

(1) 原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

(2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

(3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的依赖注入。

第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。

生活中这种例子比比皆是，支付宝在整个淘宝体系里就是庞大的ioc容器，交易双方之外的第三方资金管理中心。

（2）Spring依赖注入的方式有哪些？

【set设值注入、构造函数注入、spring注解注入】

Spring IOC既可以通过XML的形式进行bean与依赖注入配置，也可以通过注解的方式。（在springmvc中，我们一般使用xml进行装配，而springboot使用全注解的形式）

①通过XML的形式进行bean与依赖注入

通常有两种: 设值注入&构造注入。

设值注入就是指要被注入的类中定义有一个setter（）方法，并在参数中定义需要注入的对象。

package com.cn.entity;public class User1 {private String name ;private int age ;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String toString(){return "姓名："+name + "，年龄：" + age ;}
}

 <bean id="user1" class="com.cn.entity.User1"><property name="name" value="编程侠1" /><property name="age" value="18" /></bean>

  //设值注入public static void main(String args[]){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml") ;User1 user = (User1)context.getBean("user1") ;System.out.println(user) ;}

构造注入就是指要被注入的类中声明一个构造方法，并在此方法的参数中定义要注入的对象。

package com.cn.entity;public class User2 {private String name ;private int age ;public User2(String name, int age) {this.name = name;this.age = age;}public String toString(){return "姓名："+name + "，年龄：" + age ;}
}

<bean id="user2" class="com.cn.entity.User2"><constructor-arg value="编程侠2" /><constructor-arg value="20" /></bean>

  //构造注入public static void main(String args[]){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml") ;User2 user = (User2)context.getBean("user2") ;System.out.println(user) ;}

②注解的方式：

注解包含三部分：

| 组件类型注解–声明当前类的功能与职责

|| 自动装配注解–根据属性特征自动注入对象

||| 元数据注解–更细化的辅助IoC容器管理对象的注解

A、四种组件类型注解

@Component：组件注解，通用注解，该注解描述的类将被IoC容器管理并实例化

@Controller：语义注解，说明当前类是MVC应用中的控制类

@Service：语义注解，说明当前类是Service业务服务类

@Repository：语义注解，说明当前类作用于业务持久层，通常描述对应Dao类

此外，在使用四种组件类型的注解时，必须开启组件扫描，详细配置如下：

B、两类自动装配注解

按类型装配

@Autowired

@Inject

按名称装配

@Named

@Resource

优先设置name属性，若未包含name属性，会按照@Autowired注入

C、元数据注解

@Primary–按类型装配时出现多个相同类型的对象，拥有此注解对象优先被注入

@PostContruct：相当于init-method

@PreDestory：相当于destory–method

@Scope：设置对象Scope属性

@Value：为属性注入静态数据

（3）为什么非使用依赖注入，我要用到一个其他对象时，new一个怎么就不好了。

本质上都是创建对象，最大的区别还是生命周期的管理以及复杂依赖的处理。

①、生命周期

比如一个类或者接口全程只要一个实例，用依赖注入的话只需要注册成单例即可，如果自己实例化的话你需要撸一个单机模式（饿汉、懒汉、线程安全等模式）的类，并发下还要考虑线程安全。

②、复杂依赖

如果这个类或者接口不依赖其他的类或者接口差异不明显，如果依赖的类比较多的情况下（A依赖B，B又依赖C，C又依赖D，D又依赖其他）自己实例化会很麻烦。要创建A, 要先B、C、D先new一遍再new A。用ioc就快多了，A(B b),其他自动创建，是不是快多了。

总结：在程序中如果不是必须同一个对象多个实例时，也就是一个对象只是在某个地方使用一下时new一下，依赖注入就比new一个对象更好，因为new一个对象必选面临频繁创建和销毁内存实例对象的问题。而ioc管控下实例对象都是单例模式的，就是在程序运行时始终只有一个对象实例生成不需要频繁创建和销毁，也因为在内存中只有一个实例对象，减少内存开销。

（4）描述一下DispatcherServlet的工作流程?

（5）SpringMVC如何区分控制器返回的是页面还是数据（比如JSON格式的数据）

使用@ResponseBody注解，该注解用于将Controller方法返回的对象，通过适当的HttpMessageConverter转化为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json，xml等）。（如果是在程序中返回的html页面代码，也可以使用@ResponseBody，在HttpServletResponse写入，设置ContentType为text/html）

（6）Spring全家桶有哪些？

Spring、Spring MVC、Spring Boot、Spring Cloud 、 Spring Security 、Spring Data

（7）Spring普通类与工具类如何调用service层方法，为什么不能直接使用注解调用？

Spring中的Service不是你想new就能new的，因为通过new实例化的对象脱离了Spring容器的管理，获取不到注解的属性值，所以会是null,就算调用service的类中有@Component注解加入了Spring容器管理，也还是null。

新建SpringContextUtil类,在application.xml配置SpringContextUtil，最后使用DictService dictService = (DictService) SpringContextUtil.getBean(“dictService”);

package com.test.framework.utils;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;public class SpringContextUtil implements ApplicationContextAware {private static ApplicationContext applicationContext; // Spring应用上下文环境// 下面的这个方法上加了@Override注解，原因是继承ApplicationContextAware接口是必须实现的方法@Overridepublic void setApplicationContext(ApplicationContext applicationContext)throws BeansException {SpringContextUtil.applicationContext = applicationContext;}public static ApplicationContext getApplicationContext() {return applicationContext;}public static Object getBean(String name) throws BeansException {return applicationContext.getBean(name);}public static Object getBean(String name, Class requiredType)throws BeansException {return applicationContext.getBean(name, requiredType);}public static boolean containsBean(String name) {return applicationContext.containsBean(name);}public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {return applicationContext.isSingleton(name);}public static Class getType(String name)    throws NoSuchBeanDefinitionException {return applicationContext.getType(name);}public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {return applicationContext.getAliases(name);}
}

DictService dictService = (DictService) SpringContextUtil.getBean("dictService");

2、Springboot:

(1) SpringBoot中如何进行单元测试？

导入spring-boot-starter-test依赖。测试类使用注解@SpringBootTest，测试的方法上加@Test注解。

(2) SpringBootApplication注解的作用。

@SpringBootApplication注解是一个组合注解，@SpringBootApplication注解的源码我们发现，它是由ComponentScan、SpringBootConfiguration、EnableAutoConfiguration等注解组合而成：

(3) 在一个Springboot+mybatis+mysql+oracle+redis+aop功能的项目中，在pom.xml中需要引入哪些jar包依赖？

<!-- 核心Spring Boot starter，包括自动配置支持，日志和YAML -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId>
</dependency><!-- 对全栈web开发的支持，包括Tomcat和 spring-webmvc -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency><!-- mysql 依赖jar -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId>
</dependency><!-- redis 依赖jar -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId><exclusions><exclusion><groupId>io.lettuce</groupId><artifactId>lettuce-core</artifactId></exclusion></exclusions>
</dependency><!--oracle 依赖jar-->
<dependency><groupId>com.oracle.database.jdbc</groupId><artifactId>ojdbc8</artifactId>
</dependency><!--mybatis 依赖jar -->
<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId>
</dependency><!--spring切面aop依赖jar-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

进一步提问：以redis为例，springboot 1.x与springboot 2.x引入的jar包有何不同？

在 springboot 1.5.x版本的默认的Redis客户端是Jedis实现的，springboot 2.x版本中默认客户端是用lettuce实现的。

3、SpringCloud:

（1）springCloud的核心组件有哪些，解决什么问题？

Eureka（注册中心）

每个微服务都有一个EurekaClient组件，专门负责将这个服务的信息注册到EurekaServer中，也就是告诉EurekaServer，自己在哪台机器上，监听着哪个端口。而EurekaServer是一个注册中心，里面有一个注册表，保存了各服务所在的机器和端口号。

Feign（REST客户端）

Feign是一个声明式REST客户端，主要是为了简便服务调用，更快捷、优雅地调用HTTPAPI。主要是实现原理是用动态代理，你要是调用哪个接口，本质就是调用Feign创建的动态代理。

Ribbon（负载均衡）

Ribbon的作用是负载均衡，会帮你在每次请求时选择一台机器，均匀地把请求分发到各个机器上，默认使用的最经典的RoundRobin轮询算法（如果发起10次请求，那就先让你请求第1台机器、然后是第2台机器、第3台机器，接着再来—个循环，第1台机器、第2台机器。。。以此类推）

Hystrix（熔断器）

微服务框架是许多服务互相调用的，要是不做任何保护的话，某一个服务挂了，就会引起连锁反应，导致别的服务也挂。Hystrix是隔离、熔断以及降级的一个框架。如果调用某服务报错或者挂了，就对该服务熔断，在5分钟内请求此服务直接就返回一个默认值，不需要每次都卡几秒，这个过程，就是所谓的熔断。但是熔断了之后就会少调用一个服务，此时需要做下标记，标记本来需要做什么业务，但是因为服务挂了，暂时没有做，等熔断的服务恢复了，就可以手工处理这些业务。这个过程，就是所谓的降级。

Zuul（服务网关）

Zuul微服务网关，负责网络路由。假设你后台部署了几百个服务，现在有个前端兄弟要来调用这些服务，难不成你让他把所有服务的名称和地址全部记住，这是不现实的，所以一般微服务架构中都必然会设计一个网关，所有请求都往网关走，网关会根据请求中的一些特征，将请求转发给后端的各个服务。而且有一个网关之后，还有很多好处，比如可以做统一的降级、限流、认证授权、安全，等等。

总结步骤：①服务注册—》②服务发现—》③负载均衡—》④服务调用—》⑤隔离、熔断与降级—》⑥网关路由

流程说明：各个服务启动时，Eureka Client都会将服务注册到Eureka Server，并且Eureka Client还可以反过来从Eureka Server拉取注册表，从而知道其他服务在哪里。服务间发起请求的时候，基于Ribbon做负载均衡，从一个服务的多台机器中选择一台。基于Feign的动态代理机制，根据注解和选择的机器，拼接请求URL地址，发起请求。发起请求是通过Hystrix的线程池来走的，不同的服务走不同的线程池，实现了不同服务调用的隔离，避免了服务雪崩的问题。如果前端、移动端要调用后端系统，统一从Zuul网关进入，由Zuul网关转发请求给对应的服务。

（2）SpringCloud和Dubbo两种微服务架构有何区别？

Dubbo的定位始终是一款RPC框架，而SpringCloud的目标是微服务架构下的一站式解决方案。如果非要比较的话，Dubbo可以类比到NetflixOSS技术栈，而SpringCloud集成了NetflixOSS作为分布式服务治理解决方案，但除此之外SpringCloud还提供了配置、消息、安全、调用链跟踪等分布式问题解决方案。

（3）SpringBoot和SpringCloud 侧重点分别在哪些方面？

SpringBoot是Spring的一套快速配置脚手架，可以基于SpringBoot快速开发单个微服务，SpringCloud是一个基于SpringBoot实现的云应用开发工具；

SpringBoot专注于快速、方便集成的单个微服务个体，SpringCloud关注全局的服务治理框架；

SpringBoot使用了默认大于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，SpringCloud很大的一部分是基于SpringBoot来实现。SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖的关系。

（4）springcloud如何实现服务的注册和调用?

1）服务发布时，指定对应的服务名（服务名包括了IP地址和端口）,将服务注册到注册中心(eureka 或者zookeeper)

2）注册中心加@EnableEurekaServer,服务用@EnableDiscoveryClient，然后用ribbon或feign进行服务直接的调用发现。（这一过程是springcloud自动实现 只需要在main方法添加@EnableDisscoveryClient。同一个服务修改端口就可以启动多个实例）

4、mybatis：

（1）Mybatis中mapper.xml映射文件，通常都会写一个Mapper接口与之对应，这个Mapper层接口是怎么能够找到指定xml下的方法的?

Mapper接口是没有实现类的，当调用接口方法时，接口全限名（就是映射文件中的namespace的值）+方法名拼接字符串作为key值，可唯一定位一个MapperStatement。在Mybatis中，每一个、、、标签，都会被解析为一个MapperStatement对象。

（2）Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；原因就是namespace+id是作为Map的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

（3）Mybatis中使用MySQL和Oracle分页的区别

MySQL分页：(利用LIMIT关键字）计算参数为开始序号(startNum)，要查的总条数(totalNum)

Oracle分页：(利用自带的rownum)计算参数为开始序号(startNum)，结束序号(endNum)【注意：Oracle分页利用其自带的rownum，但是rownum在表中不能使用>号(比如select rownum,a.* from A a where rownum > n,查出的都是空)，但是可以使用n(n>1的自然数)这种条件依旧不成立，所以查不到记录】

（4）Mybatis是如何将sql执行结果封装为目标对象并返回的？

第一种是使用resultMap标签，逐一定义列名和对象属性名之间的映射关系。

第二种是使用sql列的别名功能，将列别名书写为对象属性名，比如T_NAME AS NAME，对象属性名一般是name，小写，但是列名不区分大小写，Mybatis会忽略列名大小写，智能找到与之对应对象属性名，你甚至可以写成T_NAME AS NaMe，Mybatis一样可以正常工作。

进一步提问：resultMap和resultType有啥区别?

resultType：当使用resultType做SQL语句返回结果类型处理时，对于SQL语句查询出的字段在相应的pojo中必须有和它相同的字段对应，而resultType中的内容就是pojo在本项目中的位置。

resultMap：当使用resultMap做SQL语句返回结果类型处理时，通常需要先在mapper.xml中定义resultMap进行pojo和相应表字段的对应关系。然后再使用resultMap。

（5）Mybatis xml映射文件中，除了常见的select、insert、updae、delete标签之外，还有哪些标签及其作用？

除了这四个标签，还有<resultMap>、<parameterMap>、<sql>、<include>、<selectKey>，一个9个标签，其中为sql片段标签，通过<include>标签引入sql片段，<selectKey>为不支持自增的主键生成策略标签。

（6）为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

hibernate对很多数据库的操作已经进行了封装，hibernate操作对象时，比如往数据库添加一条记录，直接save就可以了。（Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取），而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，虽然现在已经有不少程序可以自动生成xml文件，但还是需要自己调整sql,所以称之为半自动ORM映射工具。这也从侧面可以看出hibernate的拓展性不如Mybatis（hibernate做了很多封装）。

（7）mybatis 为什么大于不用转义,小于必须转义？

mybatis不支持“<”，本质是xml不支持这个符号，<会引起xml格式的错误，xml文件中的标签是 <…> 这种形式的, 所以当出现 “<” 号时, 会认为是一个标签的开始。