面试题

最新推荐文章于 2021-06-29 22:02:39 发布
原创 最新推荐文章于 2021-06-29 22:02:39 发布 · 213 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1.简单基础

1.谈谈对抽象类与接口的理解

(1)接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的

(2)实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法

(3)接口只可以继承一个或多个其它接口,抽象方法可以继承一个类和实现多个接口

2.谈谈重写与重载

(1)重写发生在父子类中,方法名相同,参数列表相同,方法体不同

(2)重载发生在一个类中，方法名相同，参数列表不同，方法体不同

(3)什么时候去用?

当子类继承或者实现某个类必须要重写其所有方法,这就是重写.重写是用父类方法实现某个功能,而方法重载就是一种面向对象的概念。假设你已经有了一个方法A，去完成某个逻辑或行为。当你还是需要完成这个A方法所能完成的逻辑或行为，但是为了完成这个行为而需要不同于A方法的参数，那么你就可以重载一个方法，使用和A同样的方法名，但是使用不同的参数。

3.string,stringbuffer,stringbuilder区别

(1)string不可改变字符串常量,其它两个创建后对象可改变(字符串变量).string和stringbuilder不是线程安全的,stringbuffer是线程安全的,但是stringbuilder操作字符串的速度要比其它两个快,在不考虑线程安全的情况下stringbuilder>stringbuffer>string

(2)三者总结

1）如果操作少量的数据用String

2）单线程下操作大量的数据用StringBuilder

3）多线程下操作大量的数据用StringBuffer

4.spring事务认识及使用

(1)事务的认识:

1)原子性（Atomicity）:事务最基本的操作单元，要么全部成功，要么全部失败，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚到事务开始前的状态，就像这个事务从来没有执行过一样。(简单记住就是:要么数据提交成功,要么失败回滚)

2)一致性（Consistency）:事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。如果事务成功地完成，那么系统中所有变化将正确地应用，系统处于有效状态。如果在事务中出现错误，那么系统中的所有变化将自动地回滚，系统返回到原始状态。(简单举例记住:两个账户无论怎么操作数据,两个账户的都要相等)

3)隔离性（Isolation）:指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。(简单记住:最底层对数据库操作数据时,一个事务不能去干扰另一个事务)

4)持久性（Durability）:指的是只要事务成功结束，它对数据库所做的更新就必须永久保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。(简单记住:一个事务一旦提交数据,那么它在数据库中应该是永久性的)

(2)事务的使用:

1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。

2）基于 TransactionProxyFactoryBean的声明式事务管理

3）基于 @Transactional 的声明式事务管理

4）基于Aspectj AOP配置事务

在做项目的时候有这么一个问题:

在service层添加@transactional注解声明事务,方法里面如果对异常进行了捕获，该事务是不会进行回滚.

原来默认spring事务只在发生未被捕获的 runtimeexcetpion时才回滚。 

解决方案：  
  方案1.例如service层处理事务，那么service中的方法中不做异常捕获，或者在catch语句中最后增加throw new RuntimeException()语句，以便让aop捕获异常再去回滚，并且在controller层要继续捕获这个异常并处理 

  方案2.在service层方法的catch语句中增加：TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();语句，手动回滚，这样上层就无需去处理异常

(3)事务的传播特性

事务传播行为就是多个事务方法调用时，如何定义方法间事务的传播。Spring定义了7中传播行为：

（1）propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是Spring默认的选择。

（2）propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。

（3）propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。

（4）propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。

（5）propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

（6）propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。

（7）propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作。

(4)事务的隔离级别

（1）read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。

（2）read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。

（3）repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。

（4）serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读

（5）脏读、不可重复读、幻象读概念说明：

a.脏读：指当一个事务正字访问数据，并且对数据进行了修改，而这种数据还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据还没有提交那么另外一个事务读取到的这个数据我们称之为脏数据。依据脏数据所做的操作肯能是不正确的。

b.不可重复读：指在一个事务内，多次读同一数据。在这个事务还没有执行结束，另外一个事务也访问该同一数据，那么在第一个事务中的两次读取数据之间，由于第二个事务的修改第一个事务两次读到的数据可能是不一样的，这样就发生了在一个事物内两次连续读到的数据是不一样的，这种情况被称为是不可重复读。

c.幻象读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同，我们称之为幻象读（两次执行同一条 select 语句会出现不同的结果，第二次读会增加一数据行，并没有说这两次执行是在同一个事务中）

有关事务面试题:https://mp.youkuaiyun.com/mdeditor/74907930

5.

2.核心基础

1.集合

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。

Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。

List（有序、可重复）
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。

Set（无序、不能重复）
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

Map（键值对、键唯一、值不唯一）
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

Iterator：所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含以下三种方法：
1.hasNext()是否还有下一个元素。
2.next()返回下一个元素。
3.remove()删除当前元素。

Iterator是遍历数据的底层，

可参考-里面有具体的代码试着跑下：https://blog.youkuaiyun.com/whatisthespring/article/details/81218747

Arraylist 与 LinkedList 、Vector区别

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

 

ArrayList和Vector都是用数组实现的，主要有这么三个区别：

  1. Vector是多线程安全的，线程安全就是说多线程访问同一代码，不会产生不确定的结果。而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

  2. 两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。

  3. Vector可以设置增长因子，而ArrayList不可以。

  4. Vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。

适用场景分析：

  1. Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。

  2. 如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

 

HashMap 和 Hashtable 的区别

1.hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。

2.hashTable同步的，而HashMap是非同步的，效率上比hashTable要高。

3.hashMap允许空键值，而hashTable不允许。

注意：
TreeMap：非线程安全基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

 

ConcurrentHashMap 和 LinkedHashMap

1.ConcurrentHashMap线程安全，并且锁分离。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。

2.LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性。

 

HashSet 和 HashMap 

set是线性结构，set中的值不能重复，hashset是set的hash实现，hashset中值不能重复是用hashmap的key来实现的。

map是键值对映射，可以空键空值。HashMap是Map接口的hash实现，key的唯一性是通过key值hash值的唯一来确定，value值是则是链表结构。他们的共同点都是hash算法实现的唯一性，他们都不能持有基本类型，只能持有对象

 

HashMap与TreeMap
1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
两个map中的元素一样，但顺序不一样，导致hashCode()不一样。
同样做测试：
在HashMap中，同样的值的map,顺序不同，equals时，false;
而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。

 

2.多线程

为什么要用多线程?

1、避免阻塞（异步调用） 

单个线程中的程序，是顺序执行的。如果前面的操作发生了阻塞，那么就会影响到后面的操作。电脑的多线程就是这样,多个

软件并发运行,合理使用CPU，这样CPU就不会出现空闲时间。

2.提升性能

提升性能还是指程序并发运行，给CPU分配空间，这样不会出现闲置时间。使用多线程也不是越多越好，如果把一个任务拆分

多个子任务，这些子任务必须不能有先后顺序的依赖，还是有条件的，而且线程过多的话，操作系统还会分配过多的内存

这样线程在切换的时候会浪费大量的时间。

如何使用线程？

1.理解线程的生命周期

2.线程类常用的方法

  •        sleep(): 强迫一个线程睡眠Ｎ毫秒。 
  • 　　isAlive(): 判断一个线程是否存活。 
  • 　　join(): 等待线程终止。 
  • 　　activeCount(): 程序中活跃的线程数。 
  • 　　enumerate(): 枚举程序中的线程。 
  •        currentThread(): 得到当前线程。 
  • 　　isDaemon(): 一个线程是否为守护线程。 
  • 　　setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束) 
  • 　　setName(): 为线程设置一个名称。 
  • 　　wait(): 强迫一个线程等待。 
  • 　　notify(): 通知一个线程继续运行。 
  • 　　setPriority(): 设置一个线程的优先级。
  •        start():使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

3.如何创建线程？

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程。

1)通过实现 Runnable 接口来创建线程

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public void run()

你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

Thread 定义了几个构造方法，下面的这个是我们经常使用的：

Thread(Runnable threadOb,String threadName);

这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。

新线程创建之后，你调用它的 start() 方法它才会运行。

void start();

//实例
class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

2)通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

//实例
class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

3)通过 Callable 和 Future 创建线程

  •  创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
  • 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
  • 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
  • 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
//实例
public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

 三种方式对比:

  • 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

  • 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

这些只是线程的基础,更多还需要继续学习。

3.框架

1.spring 是什么？

一个轻量级开源框架，核心aop，ioc,DI等等。

1）spring好处是什么？

轻量：Spring 是轻量的，基本的版本大约2MB

控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们

面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开

容器：Spring 包含并管理应用中对象的生命周期和配置

MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品

事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）

异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常

2）核心：

核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

3)什么是Spring的依赖注入？

依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC容器）负责把他们组装起来。

4)有哪些不同类型的IOC（依赖注入）方式？

构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

5)什么是AOP?

面向切面的编程，或AOP， 是一种编程技术，允许程序模块化横向切割关注点，或横切典型的责任划分，如日志和事务管理。

6)在Spring AOP 中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。

横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。

 

2.springMVC

   1)  Spring 配备构建Web 应用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成，如Struts，Spring 的MVC框架用控制反转把业务对象和控制逻辑清晰地隔离。它也允许以声明的方式把请求参数和业务对象绑定。

    spring mvc是一个基于mvc的web框架。spring mvc是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合。

   2)  Spring MVC的请求流程：

    第一步：发起请求到前端控制器(DispatcherServlet)

    第二步：前端控制器请求HandlerMapping查找Handler可以根据xml配置、注解进行查找

    第三步：处理器映射器HandlerMapping向前端控制器返回Handler

    第四步：前端控制器调用处理器适配器去执行Handler

    第五步：处理器适配器去执行Handler

    第六步：Handler执行完成给适配器返回ModelAndView

    第七步：处理器适配器向前端控制器返回ModelAndView。ModelAndView是springmvc框架的一个底层对象，包括 Model和view

    第八步：前端控制器请求视图解析器去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)

    第九步：视图解析器向前端控制器返回View

    第十步：前端控制器进行视图渲染。视图渲染将模型数据(在ModelAndView对象中)填充到request域

    第十一步：前端控制器向用户响应结果

 

3) SpringMVC常用注解

　　@Controller

　　负责注册一个bean 到spring 上下文中

　　@RequestMapping

　　注解为控制器指定可以处理哪些 URL 请求

　　@RequestBody

　　该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上 ,再把HttpMessageConverter返回的对象数据绑定到 controller中方法的参数上

　　@ResponseBody

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

　　@ModelAttribute 　　　

　　在方法定义上使用 @ModelAttribute 注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了@ModelAttribute 的方法

　　在方法的入参前使用 @ModelAttribute 注解：可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数 –绑定到对象中，再传入入参将方法入参对象添加到模型中 

　　@RequestParam　

　　在处理方法入参处使用 @RequestParam 可以把请求参 数传递给请求方法

　　@PathVariable

　　绑定 URL 占位符到入参

　　@ExceptionHandler

　　注解到方法上，出现异常时会执行该方法

　　@ControllerAdvice

　　使一个Contoller成为全局的异常处理类，类中用@ExceptionHandler方法注解的方法可以处理所有Controller发生的异常

4)

 

3.spring boot

1)什么是spring boot?

spring大家族衍生出来的一个产品,更像一个工具,一个专注于框架的框架。它提供了一种更简单、更快捷的方法来设置、配置和运行简单和基于Web的应用程序。

优点：1.去除了大量的xml配置文件

      2.简化复杂的依赖管理

      3.配合各种starter使用，基本上可以做到自动化配置

      4.快速启动容器

      5. 配合Maven或Gradle等构件工具打成Jar包后，Java -jar 进行部署运行还是蛮简单的

      6.Spring Boot可以选择内嵌Tomcat、jetty或者Undertow,这样我们无须以war包形式部署项目，极大的提高了开发、部署效率;

      7.微服务的底层,一个spring boot 可以看做一个组件,Spring cloud的基础

SpringBoot几个常用的注解

（1）@RestController和@Controller指定一个类，作为控制器的注解 ，并说明其区别
（2）@RequestMapping方法级别的映射注解，这一个用过Spring MVC的小伙伴相信都很熟悉 
（3）@EnableAutoConfiguration和@SpringBootApplication是类级别的注解，根据maven依赖的jar来自动猜测完成正确的spring的对应配置，只要引入了spring-boot-starter-web的依赖，默认会自动配置Spring MVC和tomcat容器
（4）@Configuration类级别的注解，一般这个注解，我们用来标识main方法所在的类,完成元数据bean的初始化。
（5）@ComponentScan类级别的注解，自动扫描加载所有的Spring组件包括Bean注入，一般用在main方法所在的类上 
（6）@ImportResource类级别注解，当我们必须使用一个xml的配置时，使用@ImportResource和@Configuration来标识这个文件资源的类。 
（7）@Autowired注解，一般结合@ComponentScan注解，来自动注入一个Service或Dao级别的Bean
（8）@Component类级别注解，用来标识一个组件，比如我自定了一个filter，则需要此注解标识之后，Spring Boot才会正确识别。

( 9 )@transactional注解,springboot是如何管理事务的？直接写@transactional注解就行，在方法就是方法事务，类上就是类事务
 

4.mybatis

什么是mybatis?为什么要使用?

  1. MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。MyBatis 摒除了大部分的JDBC代码、手工设置参数和结果集重获。MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型、Map 接口和POJO 到数据库记录。相对Hibernate和Apache OJB等“一站式”ORM解决方案而言，Mybatis 是一种“半自动化”的ORM实现。

  2. 需要使用的Jar包：mybatis-3.0.2.jar（mybatis核心包）。mybatis-spring-1.0.0.jar(与Spring结合包)。

MyBatis的优点:

简单易学，容易上手（相比于Hibernate） —- 基于SQL编程

消除了JDBC大量冗余的代码，不需要手动开关连接

很好的与各种数据库兼容（因为MyBatis使用JDBC来连接数据库，所以只要JDBC支持的数据库MyBatis都支持，而JDB提供了可扩展性，所以只要这个数据库有针对Java的jar包就可以就可以与MyBatis兼容），开发人员不需要考虑数据库的差异性。

提供了很多第三方插件（分页插件 / 逆向工程）

能够与Spring很好的集成

Mybatis-Plus:

Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

特性

  • 无侵入：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的 Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性

  • 依赖少：仅仅依赖 Mybatis 以及 Mybatis-Spring

  • 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作

  • 预防Sql注入：内置 Sql 注入剥离器，有效预防Sql注入攻击

  • 通用CRUD操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求

  • 多种主键策略：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题

  • 支持热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动

  • 支持ActiveRecord：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可实现基本 CRUD 操作

  • 支持代码生成：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（P.S. 比 Mybatis 官方的 Generator 更加强大！）

  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）

  • 支持关键词自动转义：支持数据库关键词（order、key......）自动转义，还可自定义关键词

  • 内置分页插件：基于 Mybatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询

  • 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能有效解决慢查询

  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，预防误操作

常用实体注解:

  1. 表名注解@TableName
  2. 主键注解@TableId
  3. 字段注解@TableFieId
  4. 序列主键策略注解@KeySequence
  5. 乐观锁注解@version

条件构造器:

实体包装器，用于处理 sql 拼接，排序，实体参数查询等！更多条件参数查看官网文档

 

5.jdbcTemplate

什么是jdbc?什么又是jdbcTemplate?

JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。而多的这个template,就是模板,是Spring框架为我们提供的.所以JDBCTemplate就是Spring对JDBC的封装,通俗点说就是Spring对jdbc的封装的模板

优点：开发效率高；可维护性高；

缺点：高效率的开发 对应也要失去性能，处理复杂关系时，性能会变差；

JDBC、JDBCTemplate、MyBatis、Hiberante 比较:

JDBC

优点：运行期：快捷、高效

缺点：编辑器：代码量大、繁琐异常处理、不支持数据库跨平台

JDBCTemplate

优点：运行期：高效、内嵌Spring框架中、支持基于AOP的声明式事务

缺点：必须于Spring框架结合在一起使用、不支持数据库跨平台、默认没有缓存

MyBatis

优点: 高效、支持动态、复杂的SQL构建, 支持与Spring整合和AOP事务、结果集做了轻量级Mapper封装、支持缓存

缺点：不支持数据库跨平台, 还是需要自己写SQL语句

Hiberante

优点:高效、sql自动生成不需要手写、支持缓存

缺点：复杂的sql查询生成不了，不支持数据库夸平台，更新时发送所有字段不能手动更新所需要的字段

4.项目

(1)项目框架

(2)项目亮点或不足

(3)项目总结

 

 

数据库常见面试题（附答案）
csdn问鼎
03-13 46万+
1.事务四大特性 原子性，要么执行，要么不执行 隔离性，所有操作全部执行完以前，其它会话不能看到过程 一致性，事务前后，数据总额一致 持久性，一旦事务提交，对数据的改变就是永久的 2.数据库隔离级别，每个级别会引发什么问题，mysql默认是哪个级别 脏读：事务B读取事务A还没有提交的数据 不可重复读：两次事务读的数据不一致 幻读:事务A修改了数据，事务B也修改了数据，这时在事务A看...
接口里可以有变量么？
weixin_34290631的博客
07-27 3682
浅谈为什么Java接口中不允许定义变量？ 它们是公共的，静态的，最终的常量。相当于全局常量。抽象类是不“完全”的类，相当于是接口和具体类的一个中间层。即满足接口的抽象，也满足具体的实现。   如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，可以通过实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是考虑这样的情况。如果接口 ...
接口与抽象类
12-17 182
1.接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类可以有私有方法和私有变量，抽象类可以定义构造器。2.abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重实现。接口还有标识（里面没用任何方法）和数据共享（里面有常量数据）的作用。3.abstract class中可以有自...
Java错题集(十七)
qq_45839708的博客
03-29 2607
目录 如果要建立一个java.scut.computer的包，叙述正确的是？ () 下面有关java object默认的基本方法，说法错误的是 以下JAVA程序的运行结果是什么() （）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0 尝试编译以下程序会产生怎么样的结果？（） 下面关于变量及其范围的陈述哪些是不正确的（） 下面有关值类型和引用类型描述正确的是（） 以下哪项不属于java类加载过程？ 下列程序的运行结果 下面哪些赋值语句是正确的（） ...
抽象类和接口的区别
iteye_14920的博客
01-17 123
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。 （2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。 （3）在abstra...
java中抽象类和接口的区别？
chen_657164的专栏
02-24 312
最近发现很久没看JAVA基础，发现基础知识忘记很厉害~！ 简单来说， 接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的， 另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。 还有，接口可以实现多重继承，而一个类只能继承
最新Java面试题，常见面试题及答案汇总
热门推荐
Jack方
07-12 70万+
Java最新面试题、面试题答案汇总
2023最新JAVA面试题集
03-28
2023年最新版--Java+最常见的+200++面试题汇总+答案总结汇总 阿里百度美团面试题合集 大数据面试题 100道 多线程面试59题（含答案） 最新JAVA面试题总结之基础/框架/数据库/JavaWeb/Redis BIO,NIO,AIO,Netty面试题 ...
牛客大数据面试题集锦+答案，共523道，46W+字。大厂必备
09-04
大数据面试题V3.0完成了。共523道题，679页，46w+字，来源于牛客870+篇面经。 主要分为以下几部分： Hadoop面试题：100道 Zookeeper面试题：21道 Hive面试题：47道 Flume面试题：11道 Kafka面试题：59到 HBase面试题...
2023java八股文高频面试题
03-19
这份资源是一份2023年Java面试题集，适用于准备Java开发岗位面试的人员。本资源收集了大量的Java面试题，旨在帮助读者熟悉Java编程语言以及相关的编程技术和知识点，从而在面试中更好地展现自己的能力和潜力。本资源...
java 一个接口 多个实现_JAVA:一个类实现多个接口
weixin_39640520的博客
02-12 8331
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制。它们之间区别：接口是公开的，里面不能有私有的方法或变量，而抽象类是可以有私有方法或私有变量的；代码演示：接口Apublic interface A {public abstract void play() ;public abstract void beFriendly();}接口Bpublic in...
java 接口和抽象类
Fuly的博客
06-06 371
参考: https://blog.youkuaiyun.com/yeqiuBOke/article/details/80866509 https://blog.youkuaiyun.com/zhangquan2015/article/details/82808399 https://www.cnblogs.com/dolphin0520/p/3811437.html https://blog.youkuaiyun.com/u012092924/article/details/78342193 接口定义: java中的一个抽象类型,是抽象方法的
Java9新特性之——接口中的私有方法
tracy的博客
09-25 1万+
Java9新特性之——接口中的私有方法
多线程学习总结
qq_16657805的博客
09-30 349
为什么使用多线程 为了更高效的完成任务和利用CPU资源，现在的操作系统设计为多任务操作系统，而多进程和多线程是实现多任务的方式。 进程和线程 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。 进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 同步和异步&并发和并行 同步：排队执行，效率低但是安全 异步：同时执行，效
Java 多线程编程
lighter
04-04 804
Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守候线
springboot2——5.web实战
CW
06-29 291
一、静态资源导入 打开WebMvcAutoConfiguration.java源码： 可以看到第一个静态资源存放路径： 打开后面红线的源码： 还有四个地方储存静态资源： 优先级为：
java基础常见问题解析（七）javaWeb基础知识
wanghaoxin的博客
05-13 906
javaWeb基础知识 javaWeb的虚拟目录 虚拟目录 是指在开发中用到的目录结构层次，但这些在部署的时候有些并不真实存在； 比如在进行javaWeb项目开发的过程中，我们会用到的WebRoot : 是虚拟目录 （存放jsp页面） 和 src ： 虚拟目录 ，这些目录名称在javaWeb项目部署到web服务器上的时候其实根本不存在，所以称为虚拟目录 Web项目部署到Tomc...
JDBC、JDBCTemplate、MyBatis、Hiberante 比较与分析
chengbinbbs的专栏
02-03 1352
JDBC (Java Data Base Connection,java数据库连接) JDBC(Java Data Base Connection,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成.JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序   优
C语言编程面试题精选
标题：“面试题编程 C语言”知识点： 1. C语言概述：C语言是高级编程语言，适用于系统编程、嵌入式开发等领域，因其运行速度快、性能高而受到广泛应用。 2. C语言基础：包括数据类型、变量、运算符、表达式、控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值