总结....

简述spring的优势与劣势

spring是基于IOC和AOP的轻量级框架
   优点  通过IOC进行解耦优化
        通过AOP功能拓展 事务管理
        测试简单
        易与其他开源框架整合
        封装一些JavaEE API  简化操作  降低使用难度   
        源码较为经典,易于了解底层Java
​
缺点
   不宜拆分
   配置文件会随着系统工程的增大大量增加

什么是Spring的IOC？

IOC   全称 Inversion of Control  控制反转
是面向对象编程的规则
简单讲就是一般我们都需要在类的内部主动创建依赖对象,这会导致类与类之间耦合度变高,程序变的繁琐
IOC的作用就是把创建和查找依赖对象的过程交给了容器去操作,由容器去进行操作,这样的好处就是对象与对象之间都是松散耦合,程序的体系结构变的很灵活
​
​
提到IOC必须要说到IOC的两种实现方式
     依赖查找
     依赖注入
     
 依赖查找的主要作用是为组件提供一个回调接口以及上下文的环境    这样就将部分的功能实现都封在容器中 
 IOC的控制反转就体现在回调方法上   spring容器调用这些回调方法,更方便的应用代码 然后实现
 
 
 依赖注入(DI)  (Dependency Injection) 重点
    DI就是组件之间的依赖关系是由容器在运行的时候决定的,简单讲就是容器在程序运行时动态的将某个依赖关系注入到组件之中.    DI的目的不是扩展功能,主要目的是提高组件的复用性和频率,使得程序平台更为灵活
    通过DI,只需要简单的配置就可以指定资源,调用资源,完成逻辑
    
    几大重点:
    ●谁依赖于谁：当然是应用程序依赖于IoC容器；
    ●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
    ●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
    ●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。
    
    
在spring中依赖注入的方式主要有四个:
    基于注解注入方式、
    set注入方式、
    构造器注入方式、
    静态工厂注入方式。            推荐使用基于注解注入方式，配置较少，比较方便。
​

什么是Spring的Aop?

AOP  全称是Aspect Oriented Programming   面向切面编程
​
是一种通过预编译方式和运行期动态代理实现程序功能的整合技术
​
AOP是OOP(面向对象)的延续,主要使用在Spring框架中  
              -----OOP  (Object Oriented Programming)面向对象  特征是:封装,继承,多态
​
简单来讲AOP就是在不影响程序原有功能的基础上,提供横向扩展功能
通过AOP我们可以实现指定在某个类上实现某个方法,不牵扯复用和修改   可以理解为一个插拔式的功能拓展
通过这样,能够有效的降低程序之间的耦合性  方便代码管理和维护
​
​
AOP使用中的涉及
      Aspect（切面）： 
                 Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
                 
      Joint point（连接点）：
                 表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
      
      Pointcut（切点）：
               表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
      
      Advice（增强）：
              Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
      
      Target（目标对象）：
               织入 Advice 的目标对象.。
               
      Weaving（织入）：
               将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程
​
​
并且   在spring中   主要是通过动态代理技术实现AOP
​
spring AOP 有五种类型的通知
​
前置通知[Before]：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。 
正常返回通知[After returning]：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。 
异常返回通知[After throwing]：在连接点抛出异常后执行。 
返回通知[After]：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。 
环绕通知[Around]：环绕通知围绕在连接点前后，比如一个方法调用的前后。
​

Spring的循环依赖是什么？Spring是如何解决的？

首先,循环依赖就是在Spring中两个以上的bean互相依赖对方   形成闭环 
​
解决方法是通过三级缓存
步骤是
Spring首先从一级缓存singletonObjects中获取。
如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取。
如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()(三级缓存)获取
​
​
​

Spring的Bean的生命周期是什么？

笼统的讲   有四个阶段    实例化  设置属性    初始化   销毁
​
细分   
容器找到Spring配置文件中Bean的定义无参构造函数
再利用java反射机制实例化Bean；
​
Bean容器为实例化的Bean设置属性值
​
然后初始化,初始化方式有三个，分别是：
InitializingBean的afterPropertiesSet方法
PostConstruct注解标注的方法
配置的init-method
​
​
最后销毁,方式也有三个，分别是：
preDestroy注解标注的方法
DisposableBean接口的destroy方法
配置的destroy-method

SpringMVC的执行流程是？

1）用户发送请求至前端控制器 DispatcherServlet； 
2）DispatcherServlet 收到请求后，调用 HandlerMapping 处理器映射器，请求获取 Handler； 
3）处理器映射器根据请求 url 找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给 DispatcherServlet； 
4）DispatcherServlet 通过 HandlerAdapter 处理器适配器调用执行处理器 Handler； 
5）Handler 执行完成返回 ModelAndView 给处理器适配器 HandlerAdapter； 
6）HandlerAdapter 将 Handler 执行结果 ModelAndView 返回给 DispatcherServlet； 
7）DispatcherServlet 将 ModelAndView 传给 ViewResolver 视图解析器进行解析； 
8）ViewResolver 解析后返回具体 View； 
9）DispatcherServlet 对 View 进行渲染视图,然后响应用户
​
​

SpringMVC是如何解析传入的JSON为实体类对象的？

@requestBody将json格式的数据绑定到对应的实体类中
​

SSM项目中的注解有哪些，并介绍注解的作用

@Controller：作用于表现层（spring-mvc的注解），它注解的类进行前端请求的处理，转发，重定向。包括调用Service层的方法。
​
@Service：作用于业务逻辑层（service层）
​
@Repository：作用于持久层（dao层），它注解的类作为DAO对象（数据访问对象，Data Access Objects），这些类可以直接对数据库进行操作
​
@Component：是一个通用的Spring容器管理的单例bean组件，最普通的组件，可以被注入到spring容器进行管理。@Component是通用注解，其他三个注解是这个注解的拓展，并且具有了特定的功能。
​
@RequestMapping：是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
​
@Mapper：作用是为了把mapper这个DAO交给Spring容器管理
​
@Autowired：实现依赖注入
​
@RequestParame：接收的参数是来自requestHeader请求头
​
@RequestBody：接收的参数是来自requestBody请求体
​
@Aspect:声明一个切面(类上)使用 @After、@Before、@Around 定义通知(advice)，可直接将拦截规则（切点）作为参数
​
@PointCut:声明切点，在 java 配置类中使用
​
@After:在方法执行之后执行(方法上)
​
@Before:在方法执行之前执行(方法上)
​
@Around:在方法执行之前与之后执行(方法上)
​
@Transactional:声名事务
​

Mybatis 是如何进行进行接口与xml的映射？

通过java的动态代理实现.xml映射到接口
​
在初始化时会把获取到的Mapper接口注册到MapperRegistry(映射器注册)，
注册的时候创建一个Mapper代理工厂，这个工厂通过JDK的代理创建一个执行对象，创建代理需要的InvocationHandler(调用处理器程序)为MapperProxy
从knownMappers中根据接口类型取出对应的代理创建工厂，用该工厂创建代理。
调用代理方法会进入到MapperProxy的
public Object invoke(Object proxy, Method method, Object[] args)方法
​
最终执行sql会进入到MapperMethod中execute方法：

Mybatis的优势是什么？# 与$ 的区别是？

Mybatis的概念   
这是一个半自动化的持久层框架，一般我们都分为三层，控制层，业务层，持久层，所谓的持久层就是专门负责写入数据库的层次。
​
优势:
这是一个支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。
避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
并且mybatis还给我们提供了很多第三方插件（分页插件 / 逆向工程）；
​
#是将传入的值当做字符串的形式
$是将传入的数据直接显示生成sql语句
​
使用#可以很大程度上防止sql注入(防止添加判断)
​
​
​

Linux的常用命令？

cd /        切换到根目录
cd /usr     切换到根目录下的usr目录
cd ../      切换到上一级目录 或者  cd ..
cd ~        切换到home目录
cd -        切换到上次访问的目录
​
ls               查看当前目录下的所有目录和文件
ls -a            查看当前目录下的所有目录和文件包含隐藏类
ls -l  / ll      列表查看当前目录下的所有目录和文件
ls /dir          查看指定目录下的所有目录和文件
​
mkdir    名称          在当前目录下创建目录
mkdir    /路径/名称     在指定目录下创建目录
​
rm 文件          删除当前目录下的文件
rm -f 文件       删除当前目录的的文件-直接删除
rm -r 文件名     递归删除当前目录下的指定文件
rm -rf 文件名    递归删除当前目录下的指定文件（不询问）
​
rm -rf *    当前目录下全部删除
rm -rf /*   将根目录下的所有文件全部删除   ---从头再来   自杀式袭击
​
mv 当前目录  新目录      重命名
mv 目录名称 目录的新位置     移动 
​
​
wq     保存并退出编辑
q!     撤销本次修改并退出编辑
​
tar -zcvf 打包压缩后的文件名 要打包的文件
tar [-zxvf] 压缩文件  
tar -xvf 文件.tar -C /usr------C代表指定解压的位置    指定解压
​
pwd     查看当前目录路径
​
ps -ef    查看所有正在运行的进程
kill pid 或者 kill -9 pid(强制杀死进程)           pid:进程号
ifconfig   查看网卡
ping ip   查看IP
service network restart  重启网络
ctrl + l  清屏
​

Docker的常用命令？

​
docker images # 查看docker镜像
docker images -a   查看所有
docker images -q   查看本地
​
docker search 所要搜索的镜像名称 
docker rmi 镜像名称   删除本地镜像
docker save -o 导出的路径/名字  镜像id  将本地镜像导出
docker load -i 镜像文件   加载本地镜像
docker run 镜像的id    启动镜像
docker ps -a   查看全部的容器
docker ps -q   查看容器的标识
docker stop 容器id   停止运行容器
docker rm 容器id   删除容器
​
docker pull 下载地址   
​
​
​
docker volume create 数据卷的名称    创建数据卷
docker volume inspect 数据卷名称    查看数据卷
docker volume ls     罗列数据卷
docker volume rm 数据卷的名称     删除数据卷
​
​
docker build -t 镜像名称[:tag] .制作镜像

说说你了解的安全框架？并介绍认证/授权流程

shiro
这是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。使用Shiro易于理解的API，您可以快速轻松地保护任何应用程序—从最小的移动应用程序到最大的web和企业应用程序
​
​
三大组件
  subject   主体
  SecurityManager   安全管理器
  Realms   域
  
其他组件
  Authenticator: 认证器，
  Authorizer:授权器
  Session Manager:会话管理
  Cryptography:加密
  CacheManager:缓存管理
  Cryptography:密码管理
​
​
​
认证流程
​
​

Springboot的自动装配原理

启动类的 @SpringBootApplication
​
           @SpringBootConfiguration
                 使用javaconfig的方式进行配置
​
           @EnableAutoConfiguration
                 自动载入应用程序所需要的所有默认配置
​
​
           @AutoConfigurationPackage
                    自动配置包           
                 

Jpa是如何进行使用的？注解有哪些？作用是？

JPA   ----  Java Persistence API，就是java持久化api
​
@Entity 声明类为实体或表
@Table  声明表名
@Basic  指定非约束明确的各个字段
@Id 主键
@GeneratedValue 指定如何标识属性可以被初始化，例如自动、手动、或从序列表中获得的值
@Column 指定持久属性栏属性
@Transient  指定的属性，它是不持久的，即：该值永远不会存储在数据库中
​
@OneToOne   一对一双向关联
@OneToMany  一对多单向关联

Redis是什么？存储结构？存储类型？持久化方式？三大场景问题？应用场景？淘汰策略？

是一个基于内存的  非关系型数据库
​
数组和链表
​
支持五种数据类型：字符串、列表、集合、散列表、有序集合
​
  持久化有两种解决
  
  AOF
  将Redis执行的每次写命令记录到单独的日志文件中，当重启Redis会重新将持久化的日志中文件恢复数据
  优点：
     1、数据安全，aof 持久化可以配置 appendfsync 属性，有 always，每进行一次 命令操作就记录到 aof 文件中一次。
     2、通过 append 模式写文件，即使中途服务器宕机，可以通过 redis-check-aof 工具解决数据一致性问题。
     3、AOF 机制的 rewrite 模式。AOF 文件没被 rewrite 之前（文件过大时会对命令 进行合并重写），可以删除其中的某些命令（比如误操作的 flushall）)
   缺点：
     1、AOF 文件比 RDB 文件大，且恢复速度慢。
     2、数据集大的时候，比 rdb 启动效率低。
​
  
  RDB
  按照一定的时间将内存的数据以快照的形式保存到硬盘中，对应产生的数据文件为dump.rdb。
  快照的时间通过配置文件中的save参数来定义
  优点：
     1、只有一个文件 dump.rdb，方便持久化。
     2、容灾性好，一个文件可以保存到安全的磁盘。
     3、性能最大化，fork 子进程来完成写操作，让主进程继续处理命令，所以是 IO 最大化。使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能
     4.相对于数据集大时，比 AOF 的启动效率更高。
  缺点：
     1、数据安全性低。RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候)
     2、AOF（Append-only file)持久化方式： 是指所有的命令行记录以 redis 命令请 求协议的格式完全持久化存储)保存为 aof 文件。
​
​
三大场景问题:
1.缓存的穿透
   当用户使用数据库不存在的key进行问时，会穿透过Redis直接访问到数据库
      解决方案是放置null值,设置失效时间
2.缓存击穿
   指的是当前的redis中的key持续的呗高并发一直请求,当key突然失效的时候,高并发的额请求会全部请求到数据库m,,造成数据库的压力提升      解决方案    热点永不失效
3.缓存雪崩
   指的是对于常用的经常更新   失效时间短一些
   不常用的失效时间长一些
   
   
   应用场景
    快速缓存
    数据排序(排行榜)
    计数
    最新数据
    消息队列
    分布式会话
    分布式锁
   
   淘汰策略
1.随机删除一个未设过期时间的key
2.随机删除一个设过期时间的key
3.删除设置了过期时间的最早过期的key
4.删除未设过期时间使用量最少的key
5.删除设置过期时间使用量最少的key
6.直接报错
​
​

nginx 是什么？作用是什么？有哪些负载均衡的策略？

前端和后台服务器中间的   桥梁
​
Nginx是一款轻量级的Web服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器，在BSD-like 协议下发行。特点是占有内存少，并发能力强
 
 nginx可作为 Web 服务器
 负载均衡服务器
 邮件代理服务器
 
 负载均衡的策略    
    轮询 
     指定权重
       IP绑定
         fair
           url_hash 
 
​

mysql的索引是什么？如何进行设置？

首先,索引是对数据库表中指定字段的一种存储结构
可以当做也是一张表   表中存放着数据的目录
通过索引可以提高对表中数据的检索速度
 但是索引会减慢写入速度,同时创建和维护所以需要耗费时间
​
create index index_name on table_name(column_name)   创建索引
drop index_name on table_name;    删除索引
show index from table_name;     查看索引

写出最擅长的排序方式 （除了 冒泡排序）

static void selectsort(int[] arr) {
            for(int i=0;i<arr.length-1;i++) {
                         int minIndex=i;
                for(int j=i+1;j<arr.length;j++) {
                    if(arr[j]<arr[minIndex]) {
                        minIndex=j;
                    }
                }
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
        }
​
        public static void main(String[] args) {
            int[] arr= {22,11,33,555};
            System.out.println("选择排序前：");
            System.out.println(Arrays.toString(arr));
            selectsort(arr);
            System.out.println("选择排序后：");
            System.out.println(Arrays.toString(arr));
​
        }
    }
​
​
​
结果
    选择排序前：
[22, 11, 33, 555]
选择排序后：
[11, 22, 33, 555]
​
​

说出最熟悉的设计模式，以及是怎么在程序中应用的

不深入,附上概念
​
​
​
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：
​
创建型模式：共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式：共7种：适配器模式、装饰器模式、代理模式、桥接模式、外观模式、组合模式、享元模式
行为型模式：共11种：策略模式、模板方法模式、观察者模式、责任链模式、访问者模式、中介者模式、迭代器模式、命令模式、状态模式、备忘录模式、解释器模式
​
​
设计模式的六大原则：
（1）开闭原则 (Open Close Principle) ：
        开闭原则指的是对扩展开放，对修改关闭。在对程序进行扩展的时候，不能去修改原有的代码，想要达到这样的效果，我们就需要使用接口或者抽象类
​
（2）依赖倒转原则 (Dependence Inversion Principle)：
        依赖倒置原则是开闭原则的基础，指的是针对接口编程，依赖于抽象而不依赖于具体
​
（3）里氏替换原则 (Liskov Substitution Principle) ：
        里氏替换原则是继承与复用的基石，只有当子类可以替换掉基类，且系统的功能不受影响时，基类才能被复用，而子类也能够在基础类上增加新的行为。所以里氏替换原则指的是任何基类可以出现的地方，子类一定可以出现。
        里氏替换原则是对 “开闭原则” 的补充，实现 “开闭原则” 的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏替换原则是对实现抽象化的具体步骤的规范。
​
（4）接口隔离原则 (Interface Segregation Principle)：
        使用多个隔离的接口，比使用单个接口要好，降低接口之间的耦合度与依赖，方便升级和维护方便
​
（5）迪米特原则 (Demeter Principle)：
        迪米特原则，也叫最少知道原则，指的是一个类应当尽量减少与其他实体进行相互作用，使得系统功能模块相对独立，降低耦合关系。该原则的初衷是降低类的耦合，虽然可以避免与非直接的类通信，但是要通信，就必然会通过一个“中介”来发生关系，过分的使用迪米特原则，会产生大量的中介和传递类，导致系统复杂度变大，所以采用迪米特法则时要反复权衡，既要做到结构清晰，又要高内聚低耦合。
        
（6）合成复用原则 (Composite Reuse Principle)：
        尽量使用组合/聚合的方式，而不是使用继承。
​
​
​