面试准备-根据自己简历

==================== javaSE部分开始 ==============

JDK与JRE跟JVM的关系

JDK就是java开发工具包，其中包含了JRE其中里面bin目录包含了java.exe,跟javac.exe一个运行一个编译的还有一个javadoc编译成文档
JRE是java运行时环境，里面包含了JVM，如果普通用户使用的话，只需要一个JRE就可以了
JVM也就是java虚拟机JVM是java跨平台的核心
JDK > JRE > JVM

java关键字(了解 不记那么多)

数据类型

数据类型分为两大类

1. 基本数据类型
   整数类型：byte、short、int、long
   浮点类型：float、double
   字符型：char
   布尔型：boolean
2. 引用数据类型
   类：class
   接口：interface
   数组
   String

数据类型默认初始值

从测试可以看出他们的默认值

== 与 equals的区别

== 是一个运算符比较，而equals是一个方法，底层源码就有 ==
对于基本类型和引用数据类型作用效果是不同的
基本类型比较的值是否相同
引用类型：比较的引用是否相同
演示代码

public static void main(String[] args) {
    String x = "string";
    String y = "string";
    String z = new String("string");
    System.out.println(x==y); // true
    System.out.println(x==z); // false
    System.out.println(x.equals(y)); // true
    System.out.println(x.equals(z)); // true
  }

因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String()方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。

final在java中有什么作用

final 修饰的类叫最终类，改类不能被继承
final 修饰的方法不能被重写
final 修饰的变量叫常量，常量必须初始化，初始化值后就不能被修改

Java操作字符串有哪些类?他们之间有什么区别？

操作字符串的类有String、StringBuffer、StringBuilder，都实现了序列化接口

区别是：String : final修饰，String类的方法都是返回new String。即对String对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以new StringBuilder对象，调用StringBuilder对象的append、replace、delete等方法修改字符串。
StringBuffer的安全性能高，适合多线程使用；Stringbuider性能更低适合单线程操作。
参考链接地址

String str="i"与 String str=new String(“i”)一样吗

不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。

面向对象

java是一种面向对象的语言

1. 什么是对象
   在我刚学习Java的时候，就有这么一句话蹦出来，万物皆对象，可以理解为我们所看到的一切当成一个对象，比如桌子是一个对象，椅子，电脑等等
2. 什么是面向对象
   人关注的一切都是对象，从程序设计的角度出发：面向对象就是把一个对象描述，设计出其中的属性跟方法
3. 什么是类
   从生活的角度出发：比如人是一个类(Person)，自己本身就是一个对象，别人也是对象，类中描绘了面向对象，其中的属性，方法
4. 类和对象的关系
   对象是类的实例，类就是对象的类型
   5.什么是属性和方法
   属性：对象的特征，比如人这个类有我这个对象，我有名字(name)，年龄(age)，身高(height)
   方法：对象具有的各种动态行为，就是我这个对象能做什么，我能吃东西对吧这个方法，看电影等等，也就是我能干什么
   ============================= 代码实现上述 ==============================

/**
 5. Created with IntelliJ IDEA.
 6.  7. @Auther: Adger
 8. @Date: 2020/06/08/19:06
 9. 这是一个人(Person)类
 */
public class Person {
  //属性：姓名、年龄、体重、
  String name;
  int age;
  int height;

  //方法
  public void eat(){
    System.out.println("吃饭");
  }

  public void watchMovie(){
    System.out.println("看电影");
  }
}

/**
 10. Created with IntelliJ IDEA.
 11.  12. @Auther: Adger
 13. @Date: 2020/06/08/19:14
 */
public class PersonTest {
  public static void main(String[] args) {
    //实列化对象
    Person person = new Person();
    person.name = "刘杰";
    person.age = 19;
    person.height = 168;
    System.out.println(person.name);
    System.out.println(person.age);
    System.out.println(person.height);
    person.eat();
    person.watchMovie();
  }
}

如果你要搞成谁吃饭，谁看电影就得重载了，这里为什么会写两个类执行，不在一个类执行，下面原则清楚的说了

单一职责原则

简单来说就是一个类最好只干一个功能，如果一个类中功能越多，耦合性会越高，能被复用的可能性越低，就比如过马路的时候，一边玩手机一边打电话，现在就是把不同类中的职责封装到不同类当中
其他原则还有

面向过程与面向对象的区别

面向过程(POP)和面向对象(OOP)两者本质区别在于一个在于面向过程在于实现这个方法，依次调用而面向对象就相当于有很多人去干这件事，这也是 java分布式的积淀

面向对象三大特征(封装、继承、多态)

1. 什么是封装(重点)
   将类的某些信息隐藏在类内部，不允许外部程序直接访问，通过该类提供的公开方法来实现对隐藏信息的操作与访问
   
2. 什么是继承(重点)
   从生活角度很容易理解：比如我继承我爸的亿万财产😂，从程序的角度出Person类，人这个类，都有姓名，年龄，身高，能吃饭，刘杰有这些属性跟方法，朱次斌(我朋友)也有这些属性跟方法，都可以继承这个类(父类)降低了代码冗余，利于代码复用，需要注意的是：java没有多继承，C我记得好像是有多继承的
3. 什么是多态
   封装和继承都是为了多态准备的
   什么是多态
   每个人都有姓名，身高，年龄，吃饭会吃不同的饭，程序角度出发：父类型的引用指向子类型的对象。用一句比较通俗的话：同一操作作用于不同的对象，可以产生不同的效果。这就是多态。
   多态在程序设计中的优势
   提高了代码的维护性(继承能看出来)
   提高了代码的扩展性(多态看出) 向上转型，向下转型

static 关键字

方便在没有创建对象的情况下进行调用(方法/变量)，在以后自己的DbUtils会被用到，一个数据库链接，里面自己定义的方法基本是静态的方法，方便调用

特点：是一个修饰符，可以修饰成员变量和成员函数(方法)，随着类的加载而加载，随着类的消失而消失，生命周期最长
静态代码块：随着类的加载而加载，并且执行一次，并优先于主函数的执行
静态方法只能访问静态变量和静态成员方法
静态方法不可以定义this super关键字

冒泡排序

直接来代码吧

/**
 1. Created with IntelliJ IDEA.
 2.  3. @Auther: Adger
 4. @Date: 2020/06/09/18:56
 5. 冒泡排序
 */
public class TheBubbling {
  /**
 6. 冒泡排序原理：就是比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们两个的位置
 7. 每一次比较，都会产生一个最大，或者最小的数
 8. 下一轮可以少一次排序
 9. 依次循环，直到结束
 10. @param args
   */
  public static void main(String[] args) {
    int[] a= {1,10,3,2,5,9,5,7,8};
    int[] sort = sort(a);
    System.out.println(Arrays.toString(sort));
  }

  public static int[] sort(int[] arr){
    //临时变量
    int temporary = 0;
    //外层循环，判断我们要走多少次 其中 -1 是为了数组访问越界
    for (int i = 0; i < arr.length-1; i++) {
      //内层循环 如果第一数比第二数大，则交换位置
      for (int j = 0; j < arr.length-1-i ; j++) {
        //如果 arr[j+1] 后面的一位数 大于arr[j] 当前位置
        if(arr[j+1] < arr[j]){
          //临时变量装载
          temporary = arr[j];
          //值给arr[j]
          arr[j] = arr[j+1];
          //两个交换位置
          arr[j+1] = temporary;
        }
      }
    }
    return arr;
  }

重写和重载(面试可能会问)

Overload是重载的意思、表示同一个类中、允许存在一个以上同名的方法，只要他们的参数个数不同或者参数类型不同就可以了
Override代表重写的意思、他与返回值类型无关，只看参数列表

范围不同

overload在相同的类范围内内执行，override发生在两类具有继承（继承）的关系。

参数不同

overload参数必须不同。 override参数必须相同。

抽象类

抽象类的特点：
1、抽象方法和抽象类使用 abstract 修饰、
2、抽象类不能实例化。
3、抽象方法只有只有方法名字没有实现
4、抽象类中可以写普通方法
5、抽象方法必须在抽象类中，相当于一个约束

接口(重点)

以后会经常听到面向接口编程
接口是什么：在我的脑海里面，我更感觉他是一个约束
接口的特点：
1.接口中所有的定义其实都是抽象的
2.接口不能实列化
3.类实现接口不是继承，而是 实现，可以多实现几个接口
4.接口关键字：interface
5.实现的关键字：implements

异常

什么是异常从这个字面意思来说就是意外的意思，从程序的角度出发就是程序出现了错误，这里的异常可以分为两类：编译时异常、运行时异常
程序当中是通过Throwable进行描述的，他是异常的根类，重要的两个子类是Error、Exception，Error指代是程序无法处理的错误，表示运行应用程序中比较严重的问题，比如VirtualMachineError(JVM虚拟机错误)、OutOfMemoryError(内存溢出)、ThreadDeath(线程死锁)，Exception代表程序本身可以处理的异常，异常处理通常指针对这种类型异常的处理，有一个编译时的异常，运行时异常，RuntimeException里面又很多异常，比如空值异常，数组下标越界异常，算数异常，类型转换异常

内部类

什么是内部类：可以将一个类定义在另一个类里面或者一个方法里面，这样称之为内部类
特点：内部类隐藏在外部类之内，更好的实现了隐藏信息
内部类的分类：

1.成员内部类
2.静态内部类
3.方法内部类
4.匿名内部类

包装类

为什么有包装类：基本数据类型没有属性、方法、无法对象化交互，通过包装类拥有属性、方法、可以对象化交互
包装类：

拆箱与装箱

装箱： 基本数据类型 变成包装类。
拆箱：包装类变成基本数据类型

集合(重点 面试问烂的)

什么是集合：在我的印象里面集合是一个装载数据的容器，以后用的非常多
集合的分类：主要为两类Collection、Map，在Collection就会存储类的对象，Map的话就是以键值对的形式来存储信息
Collection是一个接口，他的下面主要有三个子接口List(序列)、Queue(队列)、Set(集)
List和Queue存放的数据要求是有序的，并且允许重复的，而Set存放的数据是无序的，不允许重复的，每个接口下面又有各自的实现类、List下面有一个常用的实现类ArrayList(长度动态增长的数组)，Queue下面的实现类LinkedList，这个实现类同时也实现了List接口，表示的是链表的内容，Set的实现类主要是HashSet，也就是hash集，Map的主要实现类是HashMap

List 属于java.util包中

List是元素有序并且可以重复的集合，称为序列
List可以精确的控制每个元素的插入位置，或删除某个位置的元素
List主要两个实现类是ArrayList和LinkedList，其中ArrayList底层是数组实现的
ArrayList中的元素可以为空

Set

Set是元素无序并且不可以重复的集合、被称为集
重要的实现类是HashSet，HashSet是Set的一个重要实现类，称为哈希集
HashSet中元素无序，并且不可以重复，HashSet中只允许一个Null元素

Map

是以键值对的形式存储(Key,Value)，这个在我用用户登录注册的时候用的比较多
其中主要的实现类是HashMap，基于哈希表的Map接口的实现，允许使用null值和null键
key值不允许重复
HashMap中的Entry对象是无序排列的

Iterator

Iterator接口以统一的方式对各种集合元素进行遍历

多线程(重点)

什么是线程：就比如你用的QQ是一个进程，但是你会在QQ这个进程里面，跟很多人聊天很多窗口，每个窗口就相当于一个线程

线程的创建
创建线程的方式有三种

1. 创建一个Thread类，或者一个Thread字类的对象
2. 创建一个Runnanble接口的类的对象
3. 实现Callable接口,接口中要覆盖的方法是 public call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值
   
   

Runnable接口

只有一个方法Run();Runnable是java中实现线程的接口，任何实现线程功能的类都必须实现该接口

IO

Java中IO是以流为基础进行输入输出的
输入输出流，就比如下面代码段

System.out.println()

向控制台输出一个你写的内容，输出到控制台上，通常输出流是以流的方式输出过去，中间是以流(stream)的方式写出write，流就是指一连串流动的字符串，以先进先出的方式发送信息的通道，System.out输出流

输入流，比如

Scanner sc = new Scanner(System.in)

System.in输入流
文件输入------- 读
文件输出--------写

字节流

字节输入流：InputStream
字节输出流：OutputSteam

字符流

字符输入流Reader
字符输出流Writer

注解

注解是jdk1.5引入过来的新特性，一种特殊的接口类型，在interface加上一个@符号，注释是给人看到，注解是给程序看的，可以声明在类上、方法上、属性上、

反射

反射是框架设计的灵魂，将类的各个组成部分封装为其他对象，这就是反射机制

================== javaWeb ===================

Tomcat

tomcat容器是如何创建servlet类实例？用到了什么原理？

当容器启动时，会读取在webapps目录下所有的web应用中的web.xml文件，然后对xml文件进行解析，
并读取servlet注册信息。然后，将每个应用中注册的servlet类都进行加载，并通过反射的方式实例化。
（有时候也是在第一次请求时实例化）在servlet注册时加上如果为正数，则在一开始就实例化，
如果不写或为负数，则第一次请求实例化
参考链接

javaWeb三大组件

Servlet、Filter、Listener
他们的区别与作用可以看这个链接
生命周期与区别 详细参考

Servlet的生命周期

大致分三部分生命周期

1. 第一个阶段：Servlet 通过调用 init () 方法进行初始化。
2. 第二个阶段：Servlet 调用 service() 方法来处理客户端的请求。
3. 第三个阶段：Servlet 通过调用 destroy() 方法终止（结束）。
4. 第四个阶段：最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
   详细了解

Servlet执行的原理

1.当服务器接受到客户端浏览器的请求后，会解析这个请求的URL路径，获取访问的Servlet的资源路径
2.查找web.xml文件是否有对应的<url-pattern>标签体内容
3.如果有则在找到对应的<servlet-class>全类名
4.tomcat会将字节码文件加载进内存，并且创建其对象
5.调用其方法

Servlet与Jsp的区别

Jsp经过编译后就成了Servlet，Servlet没有内置对象，Jsp有内置对象，Jsp更侧重于视图，Servlet更重于逻辑，就像一个控制器
Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat)识别的规则
JSP的本质就是Servlet，

JSP九大内置对象

1. request 请求对象
2. response 响应对象
3. session 会话对象
4. application 页面上下文对象
5. out 输出对象
6. pageContext 页面上下文对象
7. config 配置对象
8. page 页面对象
9. exception 列外对象

重定向与转发

转发forward()

1. 地址栏不发生变化，显示的是上一个页面的地址
2. 请求次数：只有1次请求
3. 请求域中数据不会丢失

重定向sendRedirect()
     5. 地址栏发生变化
     6. 请求次数：2次
     7. 请求域中的数据会丢失，因为是2次请求

Cookie和Session

这两个都是会话技术，什么是会话：一次会话中包含多次请求和响应
一次会话指的是：浏览器访问服务器，第一次给服务器资源发送请求，会话建立，直到一方断开为止
学习会话技术能干嘛：在一次会话范围内、共享数据
由于HTTP是一种无状态的协议,
客户端会话技术：Cookie
服务端会话技术：Session
大概不同，我觉得跟面试官说出这些应该够了，记不到太多，详细以后自己看下面
1.存储方式不同
2.存储位置不同
3.存储容量不同
区别参考地址
应用场景等参考地址

================= 框架部分(SSM) ==================

Spring中的IOC跟AOP(面试问到烂)

什么是IOC：控制反转，IOC是一种设计思想，他只能干一件事就是解耦合，其中的他底层的设计模式是：工厂模式，是Spring的核心，在有的时候也叫依赖注入
什么叫IOC中的控制反转其中的控制指的是：控制对象的创建和销毁，指对象的生命周期
什么叫IOC中的反转：之前我们创建对象都是new出来的，有了IOC之后，对象的控制权交给了IOC容器

什么是AOP：面向切面编程，是OOP(面向对象)的一种延续，AOP在不修改源码的方式上，在主干功能上添加功能

Spring中的IOC属于哪种设计模式

SpringIOC中的设计模式是工厂

Spring中的AOP属于哪种设计模式

Spring中AOP底层模式是：代理模式

谈谈Spring IoC 和 DI 的理解，它们有什么区别？

推荐这篇文章

简单谈谈 IoC 容器的原理。

推荐这篇文章

springmvc执行的流程(问到几率很高)

springMVC的执行流程，大致讲下就可以

mybatis中的缓存

清楚概念

PageHelper

大概讲下怎么使用的

mybatisplus

mybatisplus是一个mybatis的扩展

#{}和${}的区别是什么？

#{}是预编译处理，${}是字符串替换。

Struts2(了解)

Struts2面试题

hibernate(了解)

hibernate常见面试题

mybatis逆向工程

这个是什么，这个是可以帮我们快速搭建出许多实体类，跟封装了一些对增删改查的操作，但是只针对单表的增删改查非常有用

Springcloud

还有这篇
这篇文章

SpringBoot常用的注解有哪些

1.@SpringBootApplication 标注SpringBoot启动类
2. @Service: 注解在类上，表示这是一个业务层bean
3. @Controller：注解在类上，表示这是一个控制层bean
4. @Repository: 注解在类上，表示这是一个数据访问层bean
5. @Component： 注解在类上，表示通用bean ，value不写默认就是类名首字母小写
6. @Autowired：按类型注入
7. @Configuration：注解在类上，表示这是一个IOC容器，相当于spring的配置文件
8. @Bean： 注解在方法上，声明当前方法返回一个Bean
9. @Value：注解在变量上，从配置文件中读取。
10.@SpringBootTest 测试类注解

Springboot启动过程

推荐

=============== 数据库跟中间件 ===================

redis

Redis是一个非关系型的数据库，以key，value的形式存储，其中五种类型有：String,Hash,List,Set,Zset

什么是Redis持久化

持久化就是把内存的数据写道磁盘中去，防止服务器宕机丢失了内存数据，Redis提供了两种持久化方式：RDB形式，这个是Redis默认的和AOF其中AOF是写入保存

rabbitmq

rabbitmq是实现了高级消息队列代理软件，一般叫为中间件

使用rabbitmq的好处

1. 解耦和，程序的设计思想就是，高内聚，低耦合，
2. 异步，将消息写入消息队列，非必要的业务逻辑以异步的方式进行，加快响应速度
3. 削峰：并发量大的时候，所有的请求直接访问数据库，造成数据库连接异常

消息基于什么传输

由于TCP的创建和销毁开销比较大，并发数手系统资源限制，会造成性能瓶颈，RabbitMq使用信道的方式来传输数据，信道是建立在真实的TCP连接内的虚拟连接，，并且每条TCP连接信息上没有数量限制

使用了消息队列有什么缺点

1.系统可用性降低，如果消息队列挂了，其他也就没了
2.系统复杂性变高，会考虑到很多方面，一致性问题，消息不被重复消费

Oracle

oracle是一个关系型数据库

Oracle中的表中间的概念

表空间是一个逻辑概念，但属于表空间的数据文件是存于磁盘上的物理文件，用户的数据存在于表中，而表就存在于表空间中，一个表空间可以有多个属于自己的数据文件，但一个数据文件只能属于一个表空间

Oracle的体系结构

4. 数据库实例，包括:系统全局区(SGA)，和后台进程(数据写入进程，重做日志进程，检查点进程，用户监控进程等)，实例在启动时首先到初始化参数文件中找到控制文件，再从控制文件中找到日志文件和数据文件
5. 数据库文件，包括:数据文件(.dbf)日志文件(.log)控制文件(.ctl)
   其中数据文件又分 系统数据文件 用户数据文件 临时数据文件和回滚数据文件
   日志文件可以有多组，一组写满换另一组，在切换时有检查点进程保证数据的完成性
   控制文件是二进制文件，最大可以为64M

Oracle中表空间和数据文件有什么关系

一个表空间可以有多个属于自己的数据文件，但一个数据文件只能属于一个表空间

MySQL

Mysql存储引擎都有哪些？

1）InnoDB存储引擎
InnoDB 是事务型数据库的首选引擎，支持事务安全表（ACID），支持行锁定和外键， InnoDB 是默认的 MySQL 引擎。

2）MyISAM存储引擎
MyISAM 基于 ISAM 存储引擎，并对其进行扩展。它是在 Web、数据仓储和其他应用环境下 最常使用的存储引擎之一。MyISAM 拥有较高的插入、查询速度，但不支持事物。

3）MEMORY存储引擎
MEMORY 存储引擎将表中的数据存储到内存中，未查询和引用其他表数据提供快速访问。
推荐这篇文章

============== Linux ==========================

Liunx

说出十个Linux命令

1. 查找文件
   find / -name 文件名
2. 查看一个程序是否运行
   ps -ef|grep 程序名(tomcat)
3. 终止线程
   kill -9 线程数
4. 查看文件 包括隐藏文件
   ls -al
5. 查看当前工作目录
   pwd
6. 创建文件夹
   mkdir 文件夹名字
7. 删除文件夹
   rmdir 文件夹
8. 删除文件包括子文件
   rm -rf 文件
9. 切换用户
   su -用户名
10. 修改文件权限
    chmod 777 文件名
11. 压缩命令
    tar -czf 压缩文件名
12. 解压缩文件
    tar -xvzf test.tar.gz
13. 查看ip地址
    ifconfig
14. 启动Vi编辑器
    vi

================== 前端部分 ====================

常用CSS选择器有哪些

1. 标签选择器(重要)
2. id选择器(重要)
3. 类选择器(重要)
4. 子选择器(重要)
   演示列子：

div > p

5. 包含选择器(重要)

div p

6. 兄弟选择器
7. 相邻选择器
8. 通配符选择器
9. 群选择器(重要)

div,p

10. 属性选择器
11. 伪类选择器

Javascript

javascript是一个脚本语言

javascript中的变量类型：分为基本数据类型和引用数据类型

1.基本数据类型：Undefined、Null、Boolean、Number、String
2.引用数据类型：称为Object对象，主要包括对象、数组和函数

基本类型和引用数据类型的区别

基本类型和引用类型存储于内存不同的位置、基本类型直接存储在栈中、而应用类型的对象存储在堆中、与此同时栈中存储了指针

undefined和not defined在JavaScript中有什么区别？

not defined:：未定义；一个未定义的变量是没有声明的变量，这样的变量在使用时会直接报错误。
undefined:：不明确的,一个定义了但未赋值的变量

什么是JavaScript中的“闭包”？

闭包就是指能够读取其他函数内部变量的函数

Bootstarp

Bootstarp是一个前端样式框架

Bootstarp的优点

1：响应式设计
2：非常容易上手

什么是BootStarp的栅格系统

系统最多自动分为12列，栅格系统用于通过一行一列的组合来创建页面布局，你的内容就会放如这些创建好的布局里面

Bootstarp的原理

其中他的原理是媒体查询

jquery

jquery是一个javascript的库，不是框架

JQuery有哪些经典应用

文档选择，文档操作，动画, ajax, json, js扩展等.

node.js

node是什么

node是一个运行javascript的环境

Vue

对于Vue中的MVVM理解
其中M是Model层，就是模型层，V代表View视图的意思嘛，然后就是VM这是一个比较头疼的问题，就是数据模型发生改变的时候视图层也会去改变，数据双向绑定，在我做后端用Vue的时候就是一个感觉，通过js中的数据，去渲染数据

Vue中的生命周期
这篇文章不错

=============== 版本控制工具(git) ===============

git

常用的git命令

1. git init需要一个干净的仓库初始化，该目录下会新增一个隐藏的.git文件夹
2. git add添加缓存区
3. git commit -m “要提交的信息”
4. git checkout 将单个文件代码回滚到上个版本
5. git clone url克隆远程仓库
6. git push 推送到远程本地仓库
7. git pull如果push的时候，本地和文件和远端文件有冲突，就要先pull、然后手动解决冲突，才能继续push，先拉取到远程仓库到本地仓库，就比如远程仓库你有初始化的.md文件，本地仓库却没得，就会发生冲突
8. git checkkout 分支 切换分支
9. git add . 代表所有文件提交其中注意是 . 点

Swagger2

swagger2是什么

Swagger是一个RESTFUL 接口的文档在线自动生成和功能测试的框架。
经常使用的注解有

1. @EnableSwagger2 启用Swagger2
2. @Api：用在类上，说明该类的作用
3. @ApiOperation：用在方法上，说明方法的作用
4. @ApiParam 定义在参数上
5. @ApiModel 描述一个数据模型类的信息
6. @ApiModelProperty 描述数据模型的属性
   到后面的东西太多了，写不完，如果你愿意看到最后，说明你可以的😂