每日面试题~更新ing

今日主题：kafka

1.Kafka的设计时什么样的呢？

Kafka将消息以topic为单位进行归纳

将向Kafka topic发布消息的程序成为producers.

将预订topics并消费消息的程序成为consumer.

Kafka以集群的方式运行，可以由一个或多个服务组成，每个服务叫做一个broker.

producers通过网络将消息发送到Kafka集群，集群向消费者提供消息

2.数据传输的事物定义有哪三种？

数据传输的事务定义通常有以下三种级别：

（1）最多一次: 消息不会被重复发送，最多被传输一次，但也有可能一次不传输

（2）最少一次: 消息不会被漏发送，最少被传输一次，但也有可能被重复传输.

（3）精确的一次（Exactly once）: 不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次，这是大家所期望的

3.Kafka判断一个节点是否还活着有那两个条件？

（1）节点必须可以维护和ZooKeeper的连接，Zookeeper通过心跳机制检查每个节点的连接

（2）如果节点是个follower,他必须能及时的同步leader的写操作，延时不能太久

4.producer是否直接将数据发送到broker的leader(主节点)？

producer直接将数据发送到broker的leader(主节点)，不需要在多个节点进行分发，为了帮助producer做到这点，所有的Kafka节点都可以及时的告知:哪些节点是活动的，目标topic目标分区的leader在哪。这样producer就可以直接将消息发送到目的地了

5、Kafa consumer是否可以消费指定分区消息？

Kafa consumer消费消息时，向broker发出”fetch”请求去消费特定分区的消息，consumer指定消息在日志中的偏移量（offset），就可以消费从这个位置开始的消息，customer拥有了offset的控制权，可以向后回滚去重新消费之前的消息，这是很有意义的

6、Kafka消息是采用Pull模式，还是Push模式？

Kafka最初考虑的问题是，customer应该从brokes拉取消息还是brokers将消息推送到consumer，也就是pull还push。在这方面，Kafka遵循了一种大部分消息系统共同的传统的设计：producer将消息推送到broker，consumer从broker拉取消息

一些消息系统比如Scribe和Apache Flume采用了push模式，将消息推送到下游的consumer。这样做有好处也有坏处：由broker决定消息推送的速率，对于不同消费速率的consumer就不太好处理了。消息系统都致力于让consumer以最大的速率最快速的消费消息，但不幸的是，push模式下，当broker推送的速率远大于consumer消费的速率时，consumer恐怕就要崩溃了。最终Kafka还是选取了传统的pull模式

Pull模式的另外一个好处是consumer可以自主决定是否批量的从broker拉取数据。Push模式必须在不知道下游consumer消费能力和消费策略的情况下决定是立即推送每条消息还是缓存之后批量推送。如果为了避免consumer崩溃而采用较低的推送速率，将可能导致一次只推送较少的消息而造成浪费。Pull模式下，consumer就可以根据自己的消费能力去决定这些策略

Pull有个缺点是，如果broker没有可供消费的消息，将导致consumer不断在循环中轮询，直到新消息到t达。为了避免这点，Kafka有个参数可以让consumer阻塞知道新消息到达(当然也可以阻塞知道消息的数量达到某个特定的量这样就可以批量发

7.Kafka存储在硬盘上的消息格式是什么？

消息由一个固定长度的头部和可变长度的字节数组组成。头部包含了一个版本号和CRC32校验码。

• 消息长度: 4 bytes (value: 1+4+n)

• 版本号: 1 byte

• CRC校验码: 4 bytes

• 具体的消息: n bytes

8.Kafka高效文件存储设计特点：

(1).Kafka把topic中一个parition大文件分成多个小文件段，通过多个小文件段，就容易定期清除或删除已经消费完文件，减少磁盘占用。

(2).通过索引信息可以快速定位message和确定response的最大大小。

(3).通过index元数据全部映射到memory，可以避免segment file的IO磁盘操作。

(4).通过索引文件稀疏存储，可以大幅降低index文件元数据占用空间大小。

9.Kafka 与传统消息系统之间有三个关键区别

(1).Kafka 持久化日志，这些日志可以被重复读取和无限期保留

(2).Kafka 是一个分布式系统：它以集群的方式运行，可以灵活伸缩，在内部通过复制数据提升容错能力和高可用性

(3).Kafka 支持实时的流式处理

10.Kafka创建Topic时如何将分区放置到不同的Broker中

• 副本因子不能大于 Broker 的个数；
• 第一个分区（编号为0）的第一个副本放置位置是随机从 brokerList 选择的；
• 其他分区的第一个副本放置位置相对于第0个分区依次往后移。也就是如果我们有5个 Broker，5个分区，假设第一个分区放在第四个 Broker 上，那么第二个分区将会放在第五个 Broker 上；第三个分区将会放在第一个 Broker 上；第四个分区将会放在第二个 Broker 上，依次类推；
• 剩余的副本相对于第一个副本放置位置其实是由 nextReplicaShift 决定的，而这个数也是随机产生的

11.Kafka新建的分区会在哪个目录下创建?

在启动Kafka集群之前，我们需要配置好log.dirs参数，其值是Kafka数据的存放目录，这个参数可以配置多个目录，目录之间使用逗号分隔，通常这些目录是分布在不同的磁盘上用于提高读写性能。当然我们也可以配置log.dir参数，含义一样。只需要设置其中一个即可。如果log.dirs参数只配置了一个目录，那么分配到各个Broker上的分区肯定只能在这个目录下创建文件夹用于存放数据。但是如果log.dirs参数配置了多个目录，那么Kafka会在哪个文件夹中创建分区目录呢？答案是：Kafka会在含有分区目录最少的文件夹中创建新的分区目录，分区目录名为Topic名+分区ID。注意，是分区文件夹总数最少的目录，而不是磁盘使用量最少的目录！也就是说，如果你给log.dirs参数新增了一个新的磁盘，新的分区目录肯定是先在这个新的磁盘上创建直到这个新的磁盘目录拥有的分区目录不是最少为止。

12.partition的数据如何保存到硬盘?

topic中的多个partition以文件夹的形式保存到broker，每个分区序号从0递增，且消息有序Partition文件下有多个segment（xxx.index，xxx.log）segment文件里的大小和配置文件大小一致可以根据要求修改默认为1g如果大小大于1g时，会滚动一个新的segment并且以上一个segment最后一条消息的偏移量命名

13.kafka的ack机制?

request.required.acks有三个值01-10:生产者不会等待broker的ack，这个延迟最低但是存储的保证最弱当server挂掉的时候就会丢数据1：服务端会等待ack值leader副本确认接收到消息后发送ack但是如果leader挂掉后他不确保是否复制完成新leader也会导致数据丢失-1：同样在1的基础上服务端会等所有的follower的副本受到数据后才会受到leader发出的ack，这样数据不会丢失

14.Kafka的消费者如何消费数据?

消费者每次消费数据的时候，消费者都会记录消费的物理偏移量（offset）的位置等到下次消费时，他会接着上次位置继续消费

15.消费者负载均衡策略?

一个消费者组中的一个分片对应一个消费者成员，他能保证每个消费者成员都能访问，如果组中成员太多会有空闲的成员

16.数据有序?

一个消费者组里它的内部是有序的消费者组与消费者组之间是无序的17.kafaka生产数据时数据的分组策略生产者决定数据产生到集群的哪个partition中每一条消息都是以（key，value）格式Key是由生产者发送数据传入所以生产者（key）决定了数据产生到集群的哪个partition

今日主题：Spring

1 什么是Spring框架？Spring框架有哪些主要模块？

Spring框架是一个为Java应用程序开发提供综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。Spring框架本身也是按照设计模式精心打造，这使得我们可以在开发环境中安心地集成Spring框架，不必担心Spring是如何在后台工作的。

Spring大约18个基本模块，大致分为4类；分别是核心模块、AOP、数据访问、Web模块、测试模块。

核心模块包括：core、beans、context、context-support、expression共5个模块；

AOP模块包括：aop、aspects、instrument共3个模块；

数据访问模块包括：jdbc、tx、orm、oxm共4个模块；

Web模块包括：web、webmvc、websocket、webflux共4个模块；

集成测试模块：test模块。

2 使用Spring框架能带来哪些好处？

下面列举了一些使用Spring框架带来的主要好处。

（1）Dependency Injection(DI) 方法使得构造器和JavaBean properties文件中的依赖关系一目了然。

（2）与EJB容器相比较，IOC容器更加趋向于轻量级。这样一来IOC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。

（3）Spring并没有闭门造车，Spring利用了已有的技术，比如ORM框架、logging框架、J2EE、Quartz和JDK Timer，以及其他视图技术。

（4）Spring框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块，开发者只需选用他们需要的模块即可。

（5）要测试一项用Spring开发的应用程序十分简单，因为测试相关的环境代码都已经囊括在框架中了。更加简单的是，利用JavaBean形式的POJO类，可以很方便地利用依赖注入来写入测试数据。

（6）Spring的Web框架也是一个精心设计的Web MVC框架，为开发者们在Web框架的选择上提供了一个除主流框架比如Struts、过度设计的、不流行Web框架以外的选择。

（7）Spring提供了一个便捷的事务管理接口，适用于小型的本地事务处理（比如在单DB的环境下）和复杂的共

同事务处理（比如利用JTA的复杂DB环境）。

3 什么是控制反转（IOC）？什么是依赖注入？

（1）控制反转是应用于软件工程领域的，在运行时被装配器对象用来绑定耦合对象的一种编程技巧，对象之间的耦合关系在编译时通常是未知的。在传统的编程方式中，业务逻辑的流程是由应用程序中早已被设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是由对象关系图来决定的，该对象关系图由装配器负责实例化，这种实现方式还可以将对象之间的关联关系的定义抽象化。绑定的过程是通过“依赖注入”实现的。

（2）控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式，并在我们的实际工作中起到了有效的作用。

（3）依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能，所以依赖注入是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件呢？

4 在Java中依赖注入有哪些方式？

（1）构造器注入。

（2）Setter方法注入。

（3）接口注入。

5 BeanFactory和ApplicationContext有什么区别？

BeanFactory 可以理解为含有Bean集合的工厂类。BeanFactory 包含了bean的定义，以便在接收到客户端请求时将对应的Bean实例化。

BeanFactory还能在实例化对象时生成协作类之间的关系。此举将Bean自身从Bean客户端的配置中解放出来。BeanFactory还包含Bean生命周期的控制，调用客户端的初始化方法（initialization Methods）和销毁方法（destruction Methods）。

从表面上看，ApplicationContext如同Bean Factory一样具有Bean定义、Bean关联关系的设置，以及根据请求分发Bean的功能。但ApplicationContext在此基础上还提供了其他功能。

（1）提供了支持国际化的文本消息。

（2）统一的资源文件读取方式。

（3）已在监听器中注册的Bean的事件。

以下是三种较常见的 ApplicationContext 实现方式。

（1）ClassPathXmlApplicationContext：从classpath的XML配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。

ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);

（2）FileSystemXmlApplicationContext ：由文件系统中的XML配置文件读取上下文。

ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);

（3）XmlWebApplicationContext：由Web应用的XML文件读取上下文。

6 Spring提供几种配置方式来设置元数据？

将Spring配置到应用开发中有以下三种方式：

（1）基于XML的配置。

（2）基于注解的配置。

（3）基于Java的配置。

7 如何使用XML配置的方式配置Spring？

在Spring框架中，依赖和服务需要专门的配置文件中实现，我一般用XML格式的配置文件。这些配置文件的格式采用通公共的模板，由一系列的Bean定义和专门的应用配置选项组成。

Spring XML配置的主要目的是使所有的Spring组件都可以用XML文件的形式来进行配置。这意味着不会出现其他的Spring配置类型（比如声明的方式或基于Java Class的配置方式）。

Spring的XML配置方式是使用被Spring命名空间所支持的一系列的XML标签来实现的。Spring有以下主要的命名空间：context、beans、jdbc、tx、aop、mvc和aso。

<beans>

  <!-- JSON Support -->

  <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>

  <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>

  <bean id="restTemplate" class="org.springframework.web.client.RestTemplate"/>

</beans>

下面这个web.xml仅配置了DispatcherServlet，这最简单的配置便能满足应用程序配置运行时组件的需求。

<web-app>

  <display-name>Archetype Created Web Application</display-name>

  <servlet>

   <servlet-name>spring</servlet-name>

   <servlet-class>

​     org.springframework.web.servlet.DispatcherServlet

   </servlet-class>

   <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

   <servlet-name>spring</servlet-name>

   <url-pattern>/</url-pattern>

  </servlet-mapping>

</web-app>

8 Spring提供哪些配置形式?

Spring对Java配置的支持是由@Configuration注解和@Bean注解来实现的。由@Bean注解的方法将会实例化、配置和初始化一个新对象，这个对象将由Spring的IOC容器来管理。@Bean声明所起到的作用与元素类似。被@Configuration所注解的类则表示这个类的主要目的是作为Bean定义的资源。被@Configuration声明的类可以通过在同一个类的内部调用@bean方法来设置嵌入Bean的依赖关系。

最简单的@Configuration 声明类请参考下面的代码：

@Configuration

public class AppConfig{

  @Bean

  public MyService myService() {

   return new MyServiceImpl();

  }

}

与上面的@Beans配置文件相同的XML配置文件如下：

<beans>

  <bean id="myService" class="com.gupaoedu.services.MyServiceImpl"/>

</beans>

上述配置方式的实例化方式如下：

public static void main(String[] args) {

  ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);

  MyService myService = ctx.getBean(MyService.class);

  myService.doStuff();

}

要使用组件组建扫描，仅需用@Configuration进行注解即可：

@Configuration

@ComponentScan(basePackages = "com.gupaoedu")

public class AppConfig {

}

在上面的例子中，com.gupaoedu包首先会被扫描到，然后在容器内查找被@Component 声明的类，找到后将这些类按照Spring Bean定义进行注册。

如果你要在Web应用开发中选用上述配置方式，需要用AnnotationConfigWebApplicationContext类来读取配置文件，可以用来配置Spring的Servlet监听器ContrextLoaderListener或者Spring MVC的DispatcherServlet。

<web-app>

  <context-param>

   <param-name>contextClass</param-name>

   <param-value>

​     org.springframework.web.context.support.AnnotationConfigWebApplicationContext

   </param-value>

  </context-param>

  <context-param>

   <param-name>contextConfigLocation</param-name>

   <param-value>com.gupaoedu.AppConfig</param-value>

  </context-param>

  <listener>

   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  </listener>

  <servlet>

   <servlet-name>dispatcher</servlet-name>

   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

   <init-param>

​     <param-name>contextClass</param-name>

​     <param-value>

​      org.springframework.web.context.support.AnnotationConfigWebApplicationContext

​     </param-value>

   </init-param>

   <init-param>

​     <param-name>contextConfigLocation</param-name>

​     <param-value>com.gupaoedu.web.MVCConfig</param-value>

   </init-param>

  </servlet>

  <servlet-mapping>

   <servlet-name>dispatcher</servlet-name>

   <url-pattern>/web/*</url-pattern>

  </servlet-mapping>

</web-app>

9 怎样用注解的方式配置Spring？

Spring在2.5版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代XML方式的Bean描述，可以将Bean描述转移到组件类的内部，只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在XML注入之前处理，所以后者会覆盖前者对于同一个属性的处理结果。

注解装配在Spring中是默认关闭的，需要在Spring文件中配置一下才能使用基于注解的装配模式。如果你想要在应用程序中使用注解的方式，请参考如下配置：

<beans>

  <context:annotation-config/>

</beans>

标签配置完成以后，就可以用注解的方式在Spring中向属性、方法和构造方法中自动装配变量。

下面是几种比较重要的注解类型。

（1）@Required：该注解应用于设值方法。

（2）@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。

（3）@Qualifier：该注解和@Autowired注解搭配使用，用于消除特定Bean自动装配的歧义。

（4）JSR-250 Annotations：Spring支持基于JSR-250 注解的注解，@Resource、@PostConstruct 和 @PreDestroy。

10 请解释Spring Bean的生命周期？

Spring Bean的生命周期简单易懂。在一个Bean实例被初始化时，需要执行一系列初始化操作以达到可用的状态。同样，当一个Bean不再被调用时需要进行相关的析构操作，并从Bean容器中移除。

Spring Bean Factory 负责管理在Spring容器中被创建的Bean的生命周期。Bean的生命周期由两组回调方法组成。

（1）初始化之后调用的回调方法。

（2）销毁之前调用的回调方法。

Spring框架提供了以下四种方式来管理Bean的生命周期事件：

（1）InitializingBean和DisposableBean回调接口。

（2）针对特殊行为的其他Aware接口。

（3）Bean配置文件中的Custom init()方法和destroy()方法。

（4）@PostConstruct和@PreDestroy注解方式。

使用customInit()和 customDestroy()方法管理Bean生命周期的代码样例如下：

<beans>

  <bean id="demoBean" class="com.gupaoedu.task.DemoBean" init-Method="customInit" destroy-Method="customDestroy">

  </bean>

</beans>

11 Spring Bean作用域的区别是什么？

Spring容器中的Bean可以分为5个范围。所有范围的名称都是自说明的，但是为了避免混淆，还是让我们来解释一下。

（1）singleton：这种Bean范围是默认的，这种范围确保不管接收到多少个请求，每个容器中只有一个Bean的实例，单例的模式由Bean Factory自身来维护。

（2）prototype：原形范围与单例范围相反，为每一个Bean请求提供一个实例。

（3）request：在请求Bean范围内为每一个来自客户端的网络请求创建一个实例，在请求完成以后，Bean会失效并被垃圾回收器回收。

（4）Session：与请求范围类似，确保每个Session中有一个Bean的实例，在Session过期后，Bean会随之失效。

（5）global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量，那么这个全局变量需要存储在global-session中。全局作用域与Servlet中的Session作用域效果相同。

12 什么是Spring Inner Bean？

在Spring框架中，无论何时Bean被使用时，当仅被调用了一个属性，一个明智的做法是将这个Bean声明为内部Bean。内部Bean可以用setter注入“属性”和用构造方法注入“构造参数”的方式来实现。

比如，在我们的应用程序中，一个Customer类引用了一个Person类，我们要做的是创建一个Person的实例，然后在Customer内部使用。

public class Customer{

  private Person person;

}

public class Person{

  private String name;

  private String address;

  private int age;

}

内部Bean的声明方式如下：

<bean id="CustomerBean" class="com.gupaoedu.common.Customer">

  <property name="person">

   <bean class="com.gupaoedu.common.Person">

          <property name="name" value="lokesh" />

      <property name="address" value="India" />

      <property name="age" value="34" />

   </bean>

  </property>

</bean>

13 Spring框架中的单例Bean是线程安全的吗？

Spring框架并没有对单例Bean进行任何多线程的封装处理。关于单例Bean的线程安全和并发问题需要开发者自行搞定。但实际上，大部分Spring Bean并没有可变的状态（比如Serview类和DAO类），所以在某种程度上说，Spring的单例Bean是线程安全的。如果你的Bean有多种状态（比如View Model对象），就需要自行保证线程安全。

最浅显的解决办法就是将多态Bean的作用域由“singleton”变更为“prototype”。

14 请举例说明如何在Spring中注入一个Java集合？

Spring提供了以下四种集合类的配置元素：

（1）<list>标签用来装配可重复的list值。

（2）<set>标签用来装配没有重复的set值。

（3）<map>标签可用来注入键和值，可以为任何类型的键值对。

（4）<props>标签支持注入键和值都是字符串类型的键值对。

下面看一下具体的例子：

<beans>

  <bean id="javaCollection" class="com.gupaoedu.JavaCollection">

   <property name="customList">

     <list>

      <value>INDIA</value>

      <value>Pakistan</value>

      <value>USA</value>

      <value>UK</value>

     </list>

   </property>

   <property name="customSet">

     <set>

      <value>INDIA</value>

      <value>Pakistan</value>

      <value>USA</value>

      <value>UK</value>

     </set>

   </property>

   <property name="customMap">

     <map>

      <entry key="1" value="INDIA"/>

      <entry key="2" value="Pakistan"/>

      <entry key="3" value="USA"/>

      <entry key="4" value="UK"/>

     </map>

   </property>

   <property name="customProperies">

    <props>

      <prop key="admin">admin@gupaoedu.com</prop>

      <prop key="support">support@gupaoedu.com</prop>

     </props>

   </property>

  </bean>

</beans>

15 如何向Spring Bean中注入java.util.Properties?

第一种方法是使用如下面代码所示的标签：

<bean id="adminUser" class="com.gupaoedu.common.Customer">

  <property name="emails">

   <props>

     <prop key="admin">admin@gupaoedu.com</prop>

     <prop key="support">support@gupaoedu.com</prop>

   </props>

  </property>

</bean>

也可用“util:”命名空间来从properties文件中创建一个propertiesbean，然后利用setter方法注入Bean的引用。

16 请解释Spring Bean的自动装配？

在Spring框架中，在配置文件中设定Bean的依赖关系是一个很好的机制，Spring容器还可以自动装配合作关系Bean之间的关联关系。这意味着Spring可以通过向Bean Factory中注入的方式自动搞定Bean之间的依赖关系。自动装配可以设置在每个Bean上，也可以设定在特定的Bean上。

下面的XML配置文件表明了如何根据名称将一个Bean设置为自动装配：

<bean id="employeeDAO" class="com.gupaoedu.EmployeeDAOImpl" autowire="byName" />

除了Bean配置文件中提供的自动装配模式，还可以使用@Autowired注解来自动装配指定的Bean。在使用@Autowired注解之前需要按照如下的配置方式在Spring配置文件中进行配置。

<context:annotation-config />

也可以通过在配置文件中配置AutowiredAnnotationBeanPostProcessor 达到相同的效果。

<bean class ="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

配置好以后就可以使用@Autowired来标注了。

@Autowired

public EmployeeDAOImpl ( EmployeeManager manager ) {

   this.manager = manager;

}

17 自动装配有哪些局限性？

自动装配有如下局限性。

• 重写：你仍然需要使用和< property>设置指明依赖，这意味着总要重写自动装配。
• 原生数据类型：你不能自动装配简单的属性，如原生类型、字符串和类。
• 模糊特性：自动装配总是没有自定义装配精确，因此如果可能尽量使用自定义装配。

18 请解释各种自动装配模式的区别？

在Spring框架中共有5种自动装配，让我们逐一分析。

（1）no：这是Spring框架的默认设置，在该设置下自动装配是关闭的，开发者需要自行在Bean定义中用标签明确地设置依赖关系。

（2）byName：该选项可以根据Bean名称设置依赖关系。当向一个Bean中自动装配一个属性时，容器将根据Bean的名称自动在配置文件中查询一个匹配的Bean。如果找到就装配这个属性，如果没找到就报错。

（3）byType：该选项可以根据Bean类型设置依赖关系。当向一个Bean中自动装配一个属性时，容器将根据Bean的类型自动在配置文件中查询一个匹配的Bean。如果找到就装配这个属性，如果没找到就报错。

（4）constructor：它的自动装配和byType模式类似，但是仅适用于有与构造器相同参数的Bean，如果在容器中没有找到与构造器参数类型一致的Bean，那么将会抛出异常。

（5）autodetect：该模式自动探测使用构造器自动装配或者byType自动装配。首先会尝试找合适的带参数的构造器，如果找到就是用构造器自动装配，如果在Bean内部没有找到相应的构造器或者是无参构造器，容器就会自动选择byTpe的自动装配方式。

19 请举例解释@Required Annotation？

在产品级别的应用中，IOC容器可能声明了数十万了Bean，Bean与Bean之间有着复杂的依赖关系。设值注解方法的短板之一就是验证所有的属性是否被注解是一项十分困难的操作。可以通过设置“dependency-check”来解决这个问题。

在应用程序的生命周期中，你可能不大愿意花时间验证所有Bean的属性是否按照上下文文件正确配置。或者你宁可验证某个Bean的特定属性是否被正确设置。即使用“dependency-check”属性也不能很好地解决这个问题，在这种情况下你需要使用@Required 注解。

需要用如下的方式使用来标明Bean的设值方法。

public class EmployeeFactoryBean extends AbstractFactoryBean<Object> {

  private String designation;

  public String getDesignation() {

   return designation;

  }

  @Required

  public void setDesignation(String designation) {

   this.designation = designation;

  }

}

RequiredAnnotationBeanPostProcessor是Spring中的后置处理器，用来验证被@Required 注解的Bean属性是否被正确设置了。在使用RequiredAnnotationBeanPostProcesso验证Bean属性之前，要在IOC容器中对其进行注册：

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />

但是如果没有属性被用@Required注解过，后置处理器会抛出一个BeanInitializationException异常。

20 请举例说明@Qualifier注解？

@Qualifier注解意味着可以在被标注Bean的字段上自动装配。Qualifier注解可以用来取消Spring不能取消的Bean应用。

21 构造方法注入和设值注入有什么区别？

请注意以下明显的区别：

（1）设值注入方法支持大部分的依赖注入，如果我们仅需要注入int、string和long型的变量，不要用设值的方法注入。对于基本类型，如果我们没有注入，可以为基本类型设置默认值。构造方法注入不支持大部分依赖注入，因为在调用构造方法时必须传入正确的构造参数，否则会报错。

（2）设值注入不会重写构造方法的值。如果我们对同一个变量同时使用了构造方法注入和设值方法注入，那么构造方法将不能覆盖由设值方法注入的值。很明显，因为构造方法只在对象被创建时调用。

（3）在使用设值注入时有可能还不能保证某种依赖是否已经被注入，也就是说，这时对象的依赖关系有可能是不完整的。而在另一种情况下，构造器注入则不允许生成依赖关系不完整的对象。

（4）在设值注入时如果对象A和对象B互相依赖，在创建对象A时Spring会抛出sObjectCurrentlyInCreationException异常，因为在对象B被创建之前对象A是不能被创建的，反之亦然。Spring用设值注入的方法解决了循环依赖的问题，因为对象的设值方法是在对象被创建之前被调用的。

22 Spring框架中有哪些不同类型的事件？

Spring的ApplicationContext 提供了支持事件和代码中监听器的功能。

我们可以创建Bean来监听在ApplicationContext 中发布的事件。ApplicationEvent类和在ApplicationContext接口中处理的事件，如果一个Bean实现了ApplicationListener接口，当一个ApplicationEvent 被发布以后，Bean会自动被通知。

public class AllApplicationEventListener implements ApplicationListener<ApplicationEvent> {

  @Override

  public void onApplicationEvent(ApplicationEvent applicationEvent) {

   //process event

  }

}

Spring 提供了以下5种标准的事件：

（1）上下文更新事件（ContextRefreshedEvent）：该事件会在ApplicationContext被初始化或者更新时发布。也可以在调用ConfigurableApplicationContext 接口中的refresh()方法时被触发。

（2）上下文开始事件（ContextStartedEvent）：当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。

（3）上下文停止事件（ContextStoppedEvent）：当容器调用ConfigurableApplicationContext的Stop()方法停止容器时触发该事件。

（4）上下文关闭事件（ContextClosedEvent）：当ApplicationContext被关闭时触发该事件。容器被关闭时，其管理的所有单例Bean都被销毁。

（5）请求处理事件（RequestHandledEvent）：在Web应用中，当一个HTTP请求（Request）结束时触发该事件。

除了上面介绍的事件，还可以通过扩展ApplicationEvent 类来开发自定义的事件。

public class CustomApplicationEvent extends ApplicationEvent {

  public CustomApplicationEvent ( Object source, final String msg ){

   super(source);

   System.out.println("Created a Custom event");

  }

}

为了监听这个事件，还需要创建一个监听器：

public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >{

  @Override

  public void onApplicationEvent(CustomApplicationEvent applicationEvent) {

  }

}

之后通过applicationContext接口的publishEvent()方法来发布自定义事件：

CustomApplicationEvent customEvent = new CustomApplicationEvent(applicationContext, “Test message”);

applicationContext.publishEvent(customEvent);

23 FileSystemResource和ClassPathResource有何区别？

在FileSystemResource 中需要给出spring-config.xml文件在项目中的相对路径或者绝对路径。在ClassPathResource中Spring会在ClassPath中自动搜寻配置文件，所以要把ClassPathResource 文件放在ClassPath下。

如果将spring-config.xml保存在了src文件夹下，只需给出配置文件的名称即可，因为src文件夹是默认的。

简而言之，ClassPathResource在环境变量中读取配置文件，FileSystemResource在配置文件中读取配置文件。

24 Spring 框架中都用到了哪些设计模式？

Spring框架中使用了大量的设计模式，下面列举了比较有代表性的：

（1）代理模式：在AOP和remoting中被用得比较多。

（2）单例模式：在Spring配置文件中定义的Bean默认为单例模式。

（3）模板模式：用来解决代码重复的问题。比如RestTemplate、JmsTemplate、JpaTemplate。

（4）委派模式：Srping提供了DispatcherServlet来对请求进行分发。

（5）工厂模式：BeanFactory用来创建对象的实例，贯穿于BeanFactory / ApplicationContext接口的核心理念。

（6）代理模式：AOP思想的底层实现技术，Spring中采用JDK Proxy和CgLib类库。

25 在Spring框架中如何更有效地使用JDBC？

使用Spring JDBC框架，资源管理及错误处理的代价都会减轻。开发人员只需通过statements和queries语句从数据库中存取数据。Spring通过使用模板类能更有效地使用JDBC，也就是所谓的JdbcTemplate。

26 请解释下Spring框架中的IOC容器

Spring中的org.springframework.beans包和org.springframework.context包构成了Spring框架IOC容器的基础。

BeanFactory接口提供了一个先进的配置机制，使得任何类型的对象的配置都成为可能。ApplicationContex接口对BeanFactory（是一个子接口）进行了扩展，在BeanFactory的基础上添加了其他功能，比如与Spring的AOP更容易集成，也提供了处理Message Resource的机制（用于国际化）、事件传播及应用层的特别配置，比如针对Web应用的WebApplicationContext。

27 在Spring中可以注入null或空字符串吗?

完全可以。

今日主题 并发

1.并行和并发有什么区别？

并行：多个处理器或多核处理器同时处理多个任务。

并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

如下图：

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

2.线程和进程的区别？

一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序的执行速度。

3.创建线程有哪几种方式？

创建线程有三种方式：

继承 Thread 重写 run 方法；

实现 Runnable 接口；

实现 Callable 接口。

4.线程有哪些状态？

线程的状态：

NEW 尚未启动

RUNNABLE 正在执行中

BLOCKED 阻塞的（被同步锁或者IO锁阻塞）

WAITING 永久等待状态

TIMED_WAITING 等待指定的时间重新被唤醒的状态

TERMINATED 执行完成

5.sleep() 和 wait() 有什么区别？

类的不同：sleep() 来自 Thread，wait() 来自 Object。

释放锁：sleep() 不释放锁；wait() 释放锁。

用法不同：sleep() 时间到会自动恢复；wait() 可以使用 notify()/notifyAll()直接唤醒。

6.notify()和 notifyAll()有什么区别？

notifyAll()会唤醒所有的线程，notify()之后唤醒一个线程。notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

7. 线程的 run() 和 start() 有什么区别？

start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

8. 在 Java 程序中怎么保证多线程的运行安全？

· 方法一：使用安全类，比如 Java. util. concurrent 下的类。

· 方法二：使用自动锁 synchronized。

· 方法三：使用手动锁 Lock。

手动锁 Java 示例代码如下：

Lock lock = new ReentrantLock();

lock. lock();

try {

  System. out. println(“获得锁”);

} catch (Exception e) {

  // TODO: handle exception

} finally {

  System. out. println(“释放锁”);

  lock. unlock();

}

9. 多线程中 synchronized 锁升级的原理是什么？

synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。

锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。

10. 什么是死锁？

当线程 A 持有独占锁a，并尝试去获取独占锁 b 的同时，线程 B 持有独占锁 b，并尝试获取独占锁 a 的情况下，就会发生 AB 两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。

11. 怎么防止死锁？

· 尽量使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。

· 尽量使用 Java. util. concurrent 并发类代替自己手写锁。

· 尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。

· 尽量减少同步的代码块。

12. ThreadLocal 是什么？有哪些使用场景？

ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal 的经典使用场景是数据库连接和 session 管理等。

13. 说一下 synchronized 底层实现原理？

synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。但在 Java 6 的时候，Java 虚拟机 对此进行了大刀阔斧地改进，提供了三种不同的 monitor 实现，也就是常说的三种不同的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。

14. synchronized 和 volatile 的区别是什么？

· volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。

· volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。

· volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

15. synchronized 和 Lock 有什么区别？

· synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。

· synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。

· 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

16. synchronized 和 ReentrantLock 区别是什么？

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。

主要区别如下：

· ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；

· ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；

· ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。

· volatile 标记的变量不会被编译器优化；synchronized 标记的变量可以被编译器优化。

反射

1. 什么是反射？

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

2. 什么是 Java 序列化？什么情况下需要序列化？

Java 序列化是为了保存各种对象在内存中的状态，并且可以把保存的对象状态再读出来。

以下情况需要使用 Java 序列化：

• 想把的内存中的对象状态保存到一个文件中或者数据库中时候；

• 想用套接字在网络上传送对象的时候；

• 想通过RMI（远程方法调用）传输对象的时候。

3. 动态代理是什么？有哪些应用？

动态代理是运行时动态生成代理类。

动态代理的应用有 spring aop、hibernate 数据查询、测试框架的后端 mock、rpc，Java注解对象获取等。

4. 怎么实现动态代理？

JDK 原生动态代理和 cglib 动态代理。JDK 原生动态代理是基于接口实现的，而 cglib 是基于继承当前类的子类实现的。

对象拷贝

为什么要使用克隆？

克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠克隆方法了。

7. 如何实现对象克隆？

• 实现 Cloneable 接口并重写 Object 类中的 clone() 方法。
• 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

Java Web

1. JSP 和 servlet 有什么区别？

JSP 是 servlet 技术的扩展，本质上就是 servlet 的简易方式。servlet 和 JSP 最主要的不同点在于，servlet 的应用逻辑是在 Java 文件中，并且完全从表示层中的 html 里分离开来，而 JSP 的情况是 Java 和 html 可以组合成一个扩展名为 JSP 的文件。JSP 侧重于视图，servlet 主要用于控制逻辑。

2. JSP 有哪些内置对象？作用分别是什么？

JSP 有 9 大内置对象：

• request：封装客户端的请求，其中包含来自 get 或 post 请求的参数；

• response：封装服务器对客户端的响应；

• pageContext：通过该对象可以获取其他对象；

• session：封装用户会话的对象；

• application：封装服务器运行环境的对象；

• out：输出服务器响应的输出流对象；

• config：Web 应用的配置对象；

• page：JSP 页面本身（相当于 Java 程序中的 this）；

• exception：封装页面抛出异常的对象。

3. 说一下 JSP 的 4 种作用域？

• page：代表与一个页面相关的对象和属性。
• request：代表与客户端发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件；需要在页面显示的临时数据可以置于此作用域。
• session：代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的 session 中。
• application：代表与整个 Web 应用程序相关的对象和属性，它实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域。

4. session 和 cookie 有什么区别？

• 存储位置不同：session 存储在服务器端；cookie 存储在浏览器端。
• 安全性不同：cookie 安全性一般，在浏览器存储，可以被伪造和修改。
• 容量和个数限制：cookie 有容量限制，每个站点下的 cookie 也有个数限制。
• 存储的多样性：session 可以存储在 Redis 中、数据库中、应用程序中；而 cookie 只能存储在浏览器中。

5. 说一下 session 的工作原理？

session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

今日主题： MyBatis

1. MyBatis 中 #{}和 ${}的区别是什么？

#{}是预编译处理，${}是字符替换。 在使用 #{}时，MyBatis 会将 SQL 中的 #{}替换成“?”，配合 PreparedStatement 的 set 方法赋值，这样可以有效的防止 SQL 注入，保证程序的运行安全。

2. MyBatis 有几种分页方式？

分页方式：逻辑分页和物理分页。

逻辑分页： 使用 MyBatis 自带的 RowBounds 进行分页，它是一次性查询很多数据，然后在数据中再进行检索。

物理分页： 自己手写 SQL 分页或使用分页插件 PageHelper，去数据库查询指定条数的分页数据的形式。

3. RowBounds 是一次性查询全部结果吗？为什么？

RowBounds 表面是在“所有”数据中检索数据，其实并非是一次性查询出所有数据，因为 MyBatis 是对 jdbc 的封装，在 jdbc 驱动中有一个 Fetch Size 的配置，它规定了每次最多从数据库查询多少条数据，假如你要查询更多数据，它会在你执行 next()的时候，去查询更多的数据。就好比你去自动取款机取 10000 元，但取款机每次最多能取 2500 元，所以你要取 4 次才能把钱取完。只是对于 jdbc 来说，当你调用 next()的时候会自动帮你完成查询工作。这样做的好处可以有效的防止内存溢出。

Fetch Size 官方相关文档：https://docs.oracle.com/cd/A97335_02/apps.102/a83724/resltse5.htm

4. MyBatis 逻辑分页和物理分页的区别是什么？

• 逻辑分页是一次性查询很多数据，然后再在结果中检索分页的数据。这样做弊端是需要消耗大量的内存、有内存溢出的风险、对数据库压力较大。

• 物理分页是从数据库查询指定条数的数据，弥补了一次性全部查出的所有数据的种种缺点，比如需要大量的内存，对数据库查询压力较大等问题。

5. MyBatis 是否支持延迟加载？延迟加载的原理是什么？

MyBatis 支持延迟加载，设置 lazyLoadingEnabled=true 即可。

延迟加载的原理的是调用的时候触发加载，而不是在初始化的时候就加载信息。比如调用 a. getB(). getName()，这个时候发现 a. getB() 的值为 null，此时会单独触发事先保存好的关联 B 对象的 SQL，先查询出来 B，然后再调用 a. setB(b)，而这时候再调用 a. getB(). getName() 就有值了，这就是延迟加载的基本原理。