SSM+Spring Boot+ springcloud面试

最新推荐文章于 2024-05-12 06:41:02 发布

静静七分醉

最新推荐文章于 2024-05-12 06:41:02 发布

阅读量2.7k

点赞数 8

分类专栏：面试

本文链接：https://blog.csdn.net/m0_37657725/article/details/98210670

版权

面试专栏收录该内容

7 篇文章 1 订阅

订阅专栏

2.Spring里面applicationContext.xml文件能不能改成其他文件名？

5.构造器注入和 setter 依赖注入，那种方式更好？

6.依赖注入和工厂模式之间有什么不同？

7.Spring和web应用整合？

8．列出IOC的3种主要注入方式？

9．简述Spring中常用的几种Advice？

10.Spring常用的技术点是什么？用到了j2se的哪部分知识？

11.Spring中什么时候引起NotWritablePropertyException和Could not open path resource[ApplicationContext.xml]

12.什么是Spring 的aop,aop的作用是什么？

13. 1）请描述spring 中lazy-init属性的作用和优缺点。

14.Spring 中事务隔离级别有哪些，并对其进行描述。

15.简述Spring的Aop和IOC

SpringMVC常见面试题

MyBatis常见面试题

1.请描述一下spring MVC工作原理。

2.你觉得spring对你的编程有什么好处？或者使用心得（注意：不要写怎么使用）

安全框架常见面试题

1.Shiro认证过程登录过程,就用shiro控制如何登录

Spring Security

springcloud

1. 什么是spring cloud bus 我们需要它吗?

2. SpringCloud和Dubbo的区别，你如何技术选型？

3. 什么是熔断,什么是服务降级(fallback)

4. Eureka和ZooKeeper都可以提供服务注册与发现的功能,请说说两个的区别

5. 如何重新加载Spring Boot上的更改，而无需重新启动服务器？

springboot

1. springboot常用注解有哪些（spring）

2. springboot如何实现分页功能

3. springboot的优点

4. base理论和cap理论是什么

spring框架:
1.IOC和DI原理 ,底层就是map集合
1.解析spring的清单文件,就是xml解析,把xml内容解析到内存中
   2.循环遍历清单文件中的bean节点,每一个bean节点就需要创建一个对象
   3.把创建完的对象存储到一个map集合,此map集合就是一个容器
   4.bean节点有property节点,需要注入数据,
   循环每一个bean节点中的property节点,读取name属性和ref属性
   反射调用set方法,并对象注入
2.spring aop:
静态代理,动态代理(jdk,cglib)
3.spring的事务管理:
spring 的声明式事务
spring 编程式事务
spring mvc框架:
spring mvc的原理
tomcat启动:
加载web项目,加载web.xml
用户发送请求,又做了什么
最后浏览器显示响应的页面信息

mybatis:
mybatis的原生api
selectList();
selectMap();
select();
这些方法的实现原理
mybatis mapper用法,底层用的是jdk的代理对象
接口类型代理对象=sqlSession.getMapper(接口类型.class);
用代理对象.目标方法();//实际上执行的是InvocationHandler接口中的invoek方法
shiro框架:
不用研究代码实现,学习shiro登录认证过程
学习shiro权限控制过程

使用Spring框架的好处是什么？

Spring主线内容

解耦和减少侵入

Spring 核心 IOC DI

Spring aop

轻量：Spring 是轻量的
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
容器：Spring 包含并管理应用中对象的生命周期和配置。
MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

2. 什么是Spring IOC 容器？

Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。

3. IOC的优点是什么？

IOC 或依赖注入把应用的代码量降到最低。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

4. ApplicationContext通常的实现是什么?

FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。
AnnotationConfigApplicationContext:解析带有注解的

5. Bean 工厂和 Application contexts 有什么区别？

1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。

2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resource rs = ctx. getResource(“classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口

Application contexts提供一种方法处理文本消息，一个通常的做法是加载文件资源（比如镜像），它们可以向注册为监听器的 bean发布事件。另外，在容器或容器内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作，可以在 Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口，该接口的实现以可插拔的方式提供获取本地化消息的方法。

依赖注入

6. 什么是Spring的依赖注入？

依赖注入，是Spring IOC来实例化对象，DI把对象从容器中取出来，按照需要的方式注入到合适的地方

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

构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

8. 哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？

你两种依赖方式都可以使用，构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

Spring Beans

9.什么是Spring beans?

Spring bean就是一个对象,既然有的对象.考虑对象的生命周期

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中<bean/> 的形式定义。

Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如果它被赋为 TRUE，bean 就是单件，否则就是一个 prototype bean。默认是TRUE，所以所有在Spring框架中的beans 缺省都是单件。

10. 一个 Spring Bean 定义 包含什么？

一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。

11. 如何给Spring 容器提供配置元数据?

这里有三种重要的方法给Spring 容器提供配置元数据。

XML配置文件。
基于注解的配置。
基于java的配置。

12. 你怎样定义类的作用域?

当定义一个<bean> 在Spring里，我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如，当Spring要在需要的时候每次生产一个新的bean实例，bean的scope属性被指定为prototype。另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope 属性必须设为 singleton。

13. 解释Spring支持的几种bean的作用域。

Spring框架支持以下五种bean的作用域：

singleton : bean在每个Spring ioc 容器中只有一个实例。
prototype：一个bean的定义可以有多个实例。
request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

缺省的Spring bean 的作用域是Singleton.

14. Spring框架中的单例bean是线程安全的吗?

不，Spring框架中的单例bean不是线程安全的。

15. 解释Spring框架中bean的生命周期。

初始: 单例,在spring容器加载的时候就生命周期开始
中间: init_method=”init”
消亡: 在spring容器消亡的时候 destroy_method=”destroy”

16. 哪些是重要的bean生命周期方法？ 你能重载它们吗？

Init_method=”任意方法名称” destroy_method=”任意方法名称” 可以重载

17. 什么是Spring的内部bean？

<bean id=”” class=””>

<property name=”” >

<bean class=””””>//就是内部bean

</property>

</bean>

当一个bean仅被用作另一个bean的属性时，它能被声明为一个内部bean，为了定义inner bean，在Spring 的基于XML 的配置元数据中，可以在 <property/>或 <constructor-arg/> 元素内使用<bean /> 元素，内部bean通常是匿名的，它们的Scope一般是prototype。

18. 在 Spring中如何注入一个java集合？

Spring提供以下几种集合的配置元素：

<list>类型用于注入一列值，允许有相同的值。
<set> 类型用于注入一组值，不允许有相同的值。
<map> 类型用于注入一组键值对，键和值都可以为任意类型。
<props>类型用于注入一组键值对，键和值都只能为String类型。

19. 解释不同方式的自动装配 。

有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。

no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
byName：通过参数名自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
byType:通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
constructor：这个方式类似于byType，但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

20.自动装配有哪些局限性 ?

可以提高开发效率,但是降低了程序的可读性

Spring注解

21. 什么是基于Java的Spring注解配置? 给一些注解的例子.

实例化对象:

@Controller @Service @ Repository @Component

<context:component-scan>：用这个来解析注解

注入:

@Resource @Autowired @Qualifier @Inject @Named

<context:component-scan>

22. 怎样开启注解装配？

注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置 <context:annotation-config/>元素。

<context:component-scan>

23. @Required 注解

修饰在setter方法上,要求setter方法必须存储数据

24. @Autowired 注解

列如：

@Autowired @Qualifier

Private UserDao userDao; 先按userDao名称找，如果找不到按类型UserDao 找

25. @Qualifier 注解

当有多个相同类型的bean却只有一个需要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定需要装配的确切的bean。

Spring数据访问

26.在Spring框架中如何更有效地使用JDBC?

Springjdbc把常规的代码都封装起来,使用的时候就直接调用

Spring jdbc中有一个JdbcTemplate（JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JdbcTemplate）

使用SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需写statements 和 queries从数据存取数据，

27. JdbcTemplate

JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。

28. Spring对DAO的支持

Spring对数据访问对象（DAO）的支持旨在简化它和数据访问技术如JDBC，Hibernate or JDO 结合使用。这使我们可以方便切换持久层。编码时也不用担心会捕获每种技术特有的异常。

29. Spring支持的ORM

Spring支持以下ORM：

Hibernate
iBatis
JPA (Java Persistence API)
TopLink
JDO (Java Data Objects)
OJB

30. Spring支持的事务管理类型

Spring支持两种类型的事务管理：

编程式事务管理：这意味你通过编程的方式管理事务，给你带来极大的灵活性，但是难维护。
声明式事务管理：这意味着你可以将业务代码和事务管理分离，你只需用注解和XML配置来管理事务。

31. Spring框架的事务管理有哪些优点？

它为不同的事务API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。
它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API
它支持声明式事务管理。
它和Spring各种数据访问抽象层很好得集成。

32. 你更倾向用那种事务管理类型？

大多数Spring框架的用户选择声明式事务管理，因为它对应用代码的影响最小，因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理，虽然比编程式事务管理（这种方式允许你通过代码控制事务）少了一点灵活性。

Spring面向切面编程（AOP）

33、Spring的AOP如何理解？

OOP面向对象，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致了大量代码的重复，而不利于各个模块的重用。

AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。

AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

（1）AspectJ是静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。

（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理：

①JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。

②如果代理类没有实现 InvocationHandler 接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

（3）静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最终生成的代理实例; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。

33、你的项目中哪里用到切面编程，并且如何应用的？

异常管理

性能管理

事务管理 @Transaction

权限管理 @Privilege(name=””)

补充：

1.简述一下spring的事务管理。

答案：
事务：事务是一系列操作组成的工作单元，该工作单元内的操作是不可分割的，即要么所有操作都做，要么所有操作都不做。从数据库的角度来说，就是一组SQL语句。
事务具有4个特性，缺一不可，即：ACID（原子性、一致性、隔离性和持久性）

原子性：事务是不可分割的最小单元，事务内的操作要么全部都做，要么全部都不做。
一致性：事务执行时，是从一个一致状态变成另一个一致状态。
隔离性：一个事务的执行，不受其他事务（进程）的干扰。
持久性：事务一旦提交，对数据库的改变是持久的。

Spring框架提供了基于编程式事务管理和基于声明式事务管理。

2.Spring里面applicationContext.xml文件能不能改成其他文件名？

答案：
ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/xyz.xml</param-value>
        </context-param>
    </listener-class>
</listener>

5.构造器注入和 setter 依赖注入，那种方式更好？

答案：
用setter方式注入：
1）与传统的JavaBean的写法更相似，程序开发人员更容易理解、接受。通过setter方法设定依赖关系显得更加直观、自然。
2)对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建Bean实例时，需要同时实例化其依赖的全部实例，因而导致性能下降。而是用设置注入可以避免这些问题。
3）尤其在某些属性可选的情况下，多参数的构造器更加笨重。
用构造方式注入：
1）与传统的JavaBean的写法更相似，程序开发人员更容易理解、接受。通过setter方法设定依赖关系显得更加直观、自然。
2)对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建Bean实例时，需要同时实例化其依赖的全部实例，因而导致性能下降。而是用设置注入可以避免这些问题。
3）尤其在某些属性可选的情况下，多参数的构造器更加笨重。

采用setter注入为主，构造注入为辅的注入策略。对于依赖关系无需变化的注入，尽量采用构造注入；而其它的依赖关系的注入，则考虑设值注入。

6.依赖注入和工厂模式之间有什么不同？

答案：
虽然两种模式都是将对象的创建从应用的逻辑中分离，但是依赖注入比工厂模式更清晰。通过依赖注入，你的类就是 POJO，它只知道依赖而不关心它们怎么获取。使用工厂模式，你的类需要通过工厂来获取
难度等级：简单

7.Spring和web应用整合？

答案：
实施spring mvc项目的步骤：
1.添加jar包的依赖（maven，zip的开发包手动导入）
spring mvc必备jar包
spring-web
spring-webmvc
spring mvc辅助jar（处理json数据controller—》页面）
jackson-core com.fasterxml.jackson.core.jackson-core
jackson-databind com.fasterxml.jackson.core.jackson-databind
spring容器的必备jar包
spring-context

2.添加配置文件
spring.xml 除了springmvc和mybatis之外的spring配置项
spring_mvc.xml spring mvc相关的配置项

      <!--扫描spring mvc的注解(@RequestMapping @ResponseBody)-->
      <mvc:annotation-driven ></mvc:annotation-driven>

web.xml

    <!-- 全局初始化数据，用于读取spring配置文件，
     多个文件用分号分割 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:conf/spring.xml</param-value>
    </context-param>
    <!-- spring处理中文乱码问题 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- spring mvc的前端控制器，需要提前加载，非restful模式 -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:conf/spring_mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <!-- spring 容器的入口 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

3.建立Controller类，spring mvc controller类不需要
继承任何类，所以说springmvc是轻量级框架（没有任何
侵入性和耦合性或依赖性）
a.在类上添加@Controller注解（特别注意，不能写@Component）
如果在类上添加@RequestMapping(“/user”),/user相当于一个
命名空间，区分和管url
如果有@Controller注解需要spring的组件扫描

b.在当前controller类里添加一个方法，方法名任意
方法的参数跟客户端js发送json字符串中的key是一样
方法的返回值类型就是响应数据会客户端js的对象类型
（需要借助第三方工具jackson）
c.在controller类里的当前方法前面添加两个注解
@RequestMapping(value=”login1.do”,method=RequestMethod.GET)
value:请求的url的实际地址，当客户端请求此实际地址
那么springmvc就调用此注解修饰的方法，方法定位
method：指的是请求的方法（get，pot，put，delete）
@ResponseBody 此注解是指定当前方法返回的对象可以是
一个对象，并可以借助第三方工具jackson
工具转换json字符串响应给客户端的js

d.程序员就只需要关注业务的实现
4 启动tomcat服务器，初始化tomcat容器，spring容器
spring mvc容器

难度等级：简单

8．列出IOC的3种主要注入方式？

答案：
1.构造方法注入；
2.设置属性注入；
3.接口注入。

9．简述Spring中常用的几种Advice？

答案：
1.前置通知
2.后置通知
3.异常通知
4.最终通知
5.环绕通知（可以替换成前四种通知）

10.Spring常用的技术点是什么？用到了j2se的哪部分知识？

答案：
特点：
1.方便解耦，简化开发
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2.AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
3.声明事物的支持
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
4.方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
5.方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。
6.降低Java EE API的使用难度
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。
7.Java 源码是经典学习范例
Spring的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

用到了，javase的相关技术：集合，io，xml读写等

11.Spring中什么时候引起NotWritablePropertyException和Could not open path resource[ApplicationContext.xml]

答案：

在spring的配置文件中的bean节点中的property节点的name属性，对应的类中没有setter方法时会报NotWritablePropertyException

applicationContext.xml的路径放置错误，读取不到这个文件时会报Could not open path resource[ApplicationContext.xml]

12.什么是Spring 的aop,aop的作用是什么？

答案：

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为”横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为”Aspect”，即切面。所谓”切面”，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用”横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

13. 1）请描述spring 中lazy-init属性的作用和优缺点。

2）描述init-method和destory-method属性的作用。

3）描述factory-method属性的作用。

答案：

lazy-init属性的作用和优缺点：
一个设置为lazy-init属性的bean，就意味要延迟加载，也就是IoC 容器将第一次被用到时才开始实例化。
bean的默认lazy-init=false，不需要延迟加载，IoC 容器将在服务器启动的时候，会解读ApplicationContext.xml文件，不管你是不是要使用该bean，都会先进行实例化。这会造成启动的时候，特别的慢。但是，也是最保险的方法。
描述init-method和destory-method属性的作用:
init-method和destroy-method方法来实现Bean的初始化和销毁时附加的操作
factory-method属性的作用:
用静态工厂的方式实例化

<bean id="userDao" class="com.tarena.dao.impl.TestDao"
      factory-method="getObject" />
  id:指定要实例化的对象名称
  class:是一个普通的java类，在此类中有一个静态的方法
        getObject，在此方法中return出一个UserDaoMySql
        的对象
  factory-method:是一个静态方法的方法名

14.Spring 中事务隔离级别有哪些，并对其进行描述。

答案：

在spring中定义了5中不同的事务隔离级别：

ISOLATION_DEFAULT(一般情况下使用这种配置既可) ;
这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。
ISOLATION_READ_UNCOMMITTED
这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
大部分数据库缺省的事物隔离级别都不会出现这种状况)
ISOLATION_READ_COMMITTED
保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。
什么是脏读？（修改且未提交引起）
例如：
张三的工资为5000,事务A中把他的工资改为8000,但事务A尚未提交。与此同时，事务B正在读取张三的工资，读取到张三的工资为8000。随后，事务A发生异常，而回滚了事务。张三的工资又回滚为5000。最后，事务B读取到的张三工资为8000的数据即为脏数据，事务B做了一次脏读。
(大部分数据库缺省的事物隔离级别都不会出现这种状况) ;
ISOLATION_REPEATABLE_READ
这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
什么是不可重复读？（修改引起）
例如：
在事务A中，读取到张三的工资为5000，操作没有完成，事务还没提交。
与此同时，事务B把张三的工资改为8000，并提交了事务。随后，在事务A中，再次读取张三的工资，此时工资变为8000。在一个事务中前后两次读取的结果并不致，导致了不可重复读。
(大部分数据库缺省的事物隔离级别都不会出现这种状况) .
ISOLATION_SERIALIZABLE
这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻读。
什么是幻读？（添加新记录引起）
例如:
A目前工资为5000的员工有10人，事务A读取所有工资为5000的人数为10人。此时，事务B插入一条工资也为5000的记录。这是，事务A再次读取工资为5000的员工，记录为11人。此时产生了幻读。
大部分数据库缺省的事物隔离级别都会出现这种状况，此种事物隔离级别将带来表级锁)

说明：Oracle数据库缺省的事物隔离级别已经保证了避免脏读和不可重复读。但可能会幻读，避免幻读需要加表级锁，Oracle缺省行级锁。在基于Spring的事物配置中一定要慎重使用ISOLATION_SERIALIZABLE的事物隔离级别。这种配置会使用表级锁，对性能影响巨大。一般没有特殊需要的话，配置为使用数据库缺省的事物隔离级别便可。

15.简述Spring的Aop和IOC

答案：

spring 的优点？
1.降低了组件之间的耦合性，实现了软件各层之间的解耦
2.可以使用容易提供的众多服务，如事务管理，消息服务等
3.容器提供单例模式支持
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能
5.容器提供了众多的辅助类，能加快应用的开发
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring属于低侵入式设计，代码的污染极低
8.独立于各种应用服务器
9.spring的DI机制降低了业务对象替换的复杂性
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部

什么是DI机制？
依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者
因此也称为依赖注入。
spring以动态灵活的方式来管理对象，注入的两种方式，设置注入和构造注入。
设置注入的优点：直观，自然
构造注入的优点：可以在构造器中决定依赖关系的顺序。

什么是AOP？
面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面
1.面向切面编程提供声明式事务管理
2.spring支持用户自定义的切面

面向切面编程（aop）是对面向对象编程（oop）的补充，
面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。
AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象，
是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。

aop框架具有的两个特征：
1.各个步骤之间的良好隔离性
2.源代码无关性

Spring的事务管理机制实现的原理，就是通过这样一个动态代理对所有需要事务管理的Bean进行加载，并根据配置在invoke方法中对当前调用的方法名进行判定，并在method.invoke方法前后为其加上合适的事务管理代码，这样就实现了Spring式的事务管理。Spring中的AOP实现更为复杂和灵活，不过基本原理是一致的。

难度等级：简单

SpringMVC常见面试题

1.什么是SpringMVC

SpringMVC是一个前端控制框架,主要用来接收用户提交的参数,和响应数据..SpringMVC是Spring家族的一大组件.

Spring是一个父级容器,

SpringMVC是一个子级容器.子级容器中的某写特定用法,不能用到Spring中

2.Servlet的缺点:

1.每编写一个Servlet都需要编写8行配置文件.

2.每个Servlet的入口;方法只有一个,只能处理一个业务.如果处理多个业务必须编写多个Servlet.这样的设计模式,太繁琐.

3.servlet获取参数时,必须一个一个的获取.并且参数类型必须手动转化

3.SpringMVC的组件

3.1前端控制器(DispatcherServlet) 功能:转发request和response

3.2处理器映射器根据用户提交的url.找到能够处理的Controller

3.3处理器适配器根据特定的规则执行用户的请求.

3.4视图解析器将用户返回的页面名称,自动拼接为具体页面路径.

4.SpringMVC核心调用过程

Url:localhost:8090/项目名/hello.action

服务端接收到请求后,servlet-sevice-dao(handler).给用户一个响应.

步骤:

1.客户端发送请求:localhost:8090/项目名/hello.action,发送给前端控制器

2.前端控制请求处理器映射器,查询能够处理该请求的Controller

3.将找到的Controller路径返回给前端控制器.

4.请求处理器适配器找到合适的处理器.处理请求.

5.处理器适配器找到合适的处理器.执行请求代码.(controller-service-dao)

6.将处理后的结果和响应页面封装到ModelAndView对象中,返回给处理器适配器.

7.将ModelAndView对象返回给前端控制器.

8.请求视图解析器帮助解析View对象,到底是哪个页面.

9.视图解析器内部拼接.将页面名称拼接成真实的页面路径,返回给前端控制器.View=hello /WEB-INF/hello.jsp 拼接前缀和后缀

10.将数据填充到页面中(request域中)该过程叫做视图渲染.之后返回给用户进行展现.

MyBatis常见面试题

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

答：${}是Properties文件中的变量占位符，它可以用于标签属性值和sql内部，属于静态文本替换，比如${driver}会被静态替换为com.mysql.jdbc.Driver。#{}是sql的参数占位符，Mybatis会将sql中的#{}替换为?号，在sql执行前会使用PreparedStatement的参数设置方法，按序给sql的?号占位符设置参数值，比如ps.setInt(0, parameterValue)，#{item.name}的取值方式为使用反射从参数对象中获取item对象的name属性值，相当于param.getItem().getName()。

2、Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？

3、最佳实践中，通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

答：Dao接口，就是人们常说的Mapper接口，接口的全限名，就是映射文件中的namespace的值，接口的方法名，就是映射文件中MappedStatement的id值，接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement，举例：com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中，每一个<select>、<insert>、<update>、<delete>标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

4、Mybatis是如何进行分页的？分页插件的原理是什么？

答：Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页，可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。

举例：select * from student，拦截sql后重写为：select t.* from （select * from student）t limit 0，10

5、简述Mybatis的插件运行原理，以及如何编写一个插件。

答：Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是InvocationHandler的invoke()方法，当然，只会拦截那些你指定需要拦截的方法。

实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

6、Mybatis执行批量插入，能返回数据库主键列表吗？

答：能，JDBC都能，Mybatis当然也能。

7、Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理不？

其执行原理为，使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

8、Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？

结果集的列名字跟实体的中的setter和getter匹配

比如结果集列名字为 username -> Username ->setUsername ->getUsername

答：第一种是使用<resultMap>标签，逐一定义列名和对象属性名之间的映射关系。第二种是使用sql列的别名功能，将列别名书写为对象属性名，比如T_NAME AS NAME，对象属性名一般是name，小写，但是列名不区分大小写，Mybatis会忽略列名大小写，智能找到与之对应对象属性名，你甚至可以写成T_NAME AS NaMe，Mybatis一样可以正常工作。

有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

9、Mybatis能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别。

答：能，Mybatis不仅可以执行一对一、一对多的关联查询，还可以执行多对一，多对多的关联查询，多对一查询，其实就是一对一查询，只需要把selectOne()修改为selectList()即可；多对多查询，其实就是一对多查询，只需要把selectOne()修改为selectList()即可。

关联对象查询，有两种实现方式，一种是单独发送一个sql去查询关联对象，赋给主对象，然后返回主对象。另一种是使用嵌套查询，嵌套查询的含义为使用join查询，一部分列是A对象的属性值，另外一部分列是关联对象B的属性值，好处是只发一个sql查询，就可以把主对象和其关联对象查出来。

那么问题来了，join查询出来100条记录，如何确定主对象是5个，而不是100个？其去重复的原理是<resultMap>标签内的<id>子标签，指定了唯一确定一条记录的id列，Mybatis根据<id>列值来完成100条记录的去重复功能，<id>可以有多个，代表了联合主键的语意。

同样主对象的关联对象，也是根据这个原理去重复的，尽管一般情况下，只有主对象会有重复记录，关联对象一般不会重复。

举例：下面join查询出来6条记录，一、二列是Teacher对象列，第三列为Student对象列，Mybatis去重复处理后，结果为1个老师6个学生，而不是6个老师6个学生。

t_id t_name s_id

| 1 | teacher | 38 |
| 1 | teacher | 39 |
| 1 | teacher | 40 |
| 1 | teacher | 41 |
| 1 | teacher | 42 |
| 1 | teacher | 43 |

10、Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

答：Mybatis仅支持association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在Mybatis配置文件中，可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

它的原理是，使用CGLIB创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用a.getB().getName()，拦截器invoke()方法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB(b)，于是a的对象b属性就有值了，接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

当然了，不光是Mybatis，几乎所有的包括Hibernate，支持延迟加载的原理都是一样的。

11、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

答：不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。

原因就是namespace+id是作为Map<String, MappedStatement>的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

12、Mybatis中如何执行批处理？

答：使用BatchExecutor完成批处理。

13、Mybatis都有哪些Executor执行器？它们之间的区别是什么？

答：Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。

ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。

BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

14、Mybatis中如何指定使用哪一种Executor执行器？

答：在Mybatis配置文件中，可以指定默认的ExecutorType执行器类型，也可以手动给DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数。

15、Mybatis是否可以映射Enum枚举类？

答：Mybatis可以映射枚举类，不单可以映射枚举类，Mybatis可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler，实现TypeHandler的setParameter()和getResult()接口方法。TypeHandler有两个作用，一是完成从javaType至jdbcType的转换，二是完成jdbcType至javaType的转换，体现为setParameter()和getResult()两个方法，分别代表设置sql问号占位符参数和获取列查询结果。

16、Mybatis映射文件中，如果A标签通过include引用了B标签的内容，请问，B标签能否定义在A标签的后面，还是说必须定义在A标签的前面？

答：虽然Mybatis解析Xml映射文件是按照顺序解析的，但是，被引用的B标签依然可以定义在任何地方，Mybatis都可以正确识别。

原理是，Mybatis解析A标签，发现A标签引用了B标签，但是B标签尚未解析到，尚不存在，此时，Mybatis会将A标签标记为未解析状态，然后继续解析余下的标签，包含B标签，待所有标签解析完毕，Mybatis会重新解析那些被标记为未解析的标签，此时再解析A标签时，B标签已经存在，A标签也就可以正常解析完成了。

17、简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系？

答：Mybatis将所有Xml配置信息都封装到All-In-One重量级对象Configuration内部。在Xml映射文件中，<parameterMap>标签会被解析为ParameterMap对象，其每个子元素会被解析为ParameterMapping对象。<resultMap>标签会被解析为ResultMap对象，其每个子元素会被解析为ResultMapping对象。每一个<select>、<insert>、<update>、<delete>标签均会被解析为MappedStatement对象，标签内的sql会被解析为BoundSql对象。

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

答：Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

面试题看似都很简单，但是想要能正确回答上来，必定是研究过源码且深入的人，而不是仅会使用的人或者用的很熟的人，以上所有面试题及其答案所涉及的内容，在我的Mybatis系列博客中都有详细讲解和原理分析。

1.请描述一下spring MVC工作原理。

答案：
1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.
2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找到处理请求的处理器（Handler）。
3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler（Handler将具体的处理进行封装），再由具体的HandlerAdapter对Handler进行具体的调用。
5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。
6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。
7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。

2.你觉得spring对你的编程有什么好处？或者使用心得（注意：不要写怎么使用）

答案：

1.使用Spring的IOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，让我们更专注于应用逻辑
2.可以提供众多服务，事务管理，WS等。
3.AOP的很好支持，方便面向切面编程。
4.对主流的框架提供了很好的集成支持，如Hibernate,Struts2,JPA等
5.Spring DI机制降低了业务对象替换的复杂性。
6.Spring属于低侵入，代码污染极低。
7.Spring的高度可开放性，并不强制依赖于Spring，开发者可以自由选择Spring部分或全部

安全框架常见面试题

1.Shiro认证过程登录过程,就用shiro控制如何登录

2.简述Shiro的核心组件

Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是Shiro的“用户”概念。
Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。

SecurityManager：它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。

Realm： Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

Shiro主要组件还包括：
Authenticator ：认证就是核实用户身份的过程。这个过程的常见例子是大家都熟悉的“用户/密码”组合。多数用户在登录软件系统时，通常提供自己的用户名（当事人）和支持他们的密码（证书）。如果存储在系统中的密码（或密码表示）与用户提供的匹配，他们就被认为通过认证。
Authorizer ：授权实质上就是访问控制 - 控制用户能够访问应用中的哪些内容，比如资源、Web页面等等。
SessionManager ：在安全框架领域，Apache Shiro提供了一些独特的东西：可在任何应用或架构层一致地使用Session API。即，Shiro为任何应用提供了一个会话编程范式 - 从小型后台独立应用到大型集群Web应用。这意味着，那些希望使用会话的应用开发者，不必被迫使用Servlet或EJB容器了。或者，如果正在使用这些容器，开发者现在也可以选择使用在任何层统一一致的会话API，取代Servlet或EJB机制。
CacheManager :对Shiro的其他组件提供缓存支持

3.Shiro如何自实现认证

需要继承AuthorizingRealm类
重写doGetAuthenticationInfo方法,实现登录认证
重写doGetAuthorizationInfo方法,实现授权认证

4.Shiro授权过程

5.Shiro的优点

易于理解的 Java Security API；
简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
对角色的简单的签权（访问控制），支持细粒度的签权；
支持一级缓存，以提升应用程序的性能；
内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
异构客户端会话访问；
非常简单的加密 API；
不跟任何的框架或者容器捆绑，可以独立运行。

6.比较SpringSecurity和Shiro

首先Shiro较之 Spring Security，Shiro在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。

Shiro是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：

易于理解的 Java Security API；
简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
对角色的简单的签权（访问控制），支持细粒度的签权；
支持一级缓存，以提升应用程序的性能；
内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
异构客户端会话访问；
非常简单的加密 API；
不跟任何的框架或者容器捆绑，可以独立运行。

Spring Security

除了不能脱离Spring，shiro的功能它都有。而且Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。Spring Security的权限细粒度更高

springcloud

1. 什么是spring cloud bus 我们需要它吗?

springcloudbus 消息总线

spring cloud是按照spring的配置对一系列微服务框架的集成，spring cloud bus是其中一个微服务框架，用于实现微服务之间的通信。
spring cloud bus整合 java的事件处理机制和消息中间件消息的发送和接受，主要由发送端、接收端和事件组成。针对不同的业务需求，可以设置不同的事件，发送端发送事件，接收端接受相应的事件，并进行相应的处理。
例如,可以实现spring cloud bus 整合spring cloud config去动态获取git上的配置文件,就不需要每次更新配置,重启config客户端了;
后端服务器一般都做了集群化，很多台服务器，而且在经常发生服务的扩容、缩容、上线、下线。这样，后端服务器的数量、IP就会变来变去，如果我们想进行一些线上的管理和维护工作，就需要维护服务器的IP。也可以使用消息总线;
总之在项目中,消息总线可以动态,异步的处理框架中各个微服务的事件通信.

2. SpringCloud和Dubbo的区别，你如何技术选型？

两者区别:

springcloud中微服务治理机制,基于http的restFul的,所以只有这一种协议,占带宽,治理组件只能使用eureka,但是整体微服务框架的组件非常丰富,适合轻量级的开发工程;
dubbo中的治理除了支持http,也支持rpc的其他非常多的协议,治理中心可以使用redis或者zookeeper,但是开发难度较大,接口逻辑复杂;

技术选型

大型企业,大型项目对于并发,性能要求严格,要使用dubbo,
中小企业,开发成本较低,开发周期短,选择spring cloud

3. 什么是熔断,什么是服务降级(fallback)

在微服务中，有熔断必定服务降级

熔断：举个例子解释，生活中每家每户都在用电，小明家的电线因为故障导致了小明家停电了。而小李、小张家的电是正常使用的。电力公司没有因为小明家有故障线路而停掉其他人家的电，同时小明家没有使用有故障的电路的电。这时即为熔断。熔断的目的是当A服务模块中的某块程序出现故障后为了不影响其他客户端的请求而做出的及时回应。换句话将就是牺牲故障的局部,保全大局（胳膊被毒蛇咬了，砍断胳膊）
降级:当某一个正常服务,由于访问压力过大,或者熔断的出现无法正常使用,微服务可以采用降级的方法,将剩余访问使用另外的服务进行相应;好比你买个红萝卜,老板说没了,但是不能把你轰走,就只能说,白萝卜也是萝卜,可以买一个;换句话将,就是一个服务由于各种原因无法正常提供相应,将会转向一个认为定义,或者服务定义好的降级服务去处理,很有可能这种降级的服务是其他功能使用的

4. Eureka和ZooKeeper都可以提供服务注册与发现的功能,请说说两个的区别

1. Eureka支持的协议是http,zookeeper协议与之不同,两者的选择涉及到技术选型;
2. cap利用
eureka更重视ap的结合，也就是系统可用有效;
zookeeper更注重一致性cp,所以响应速度比较慢
这个可以配合dubbo和springcloud的对比解答

5. 如何重新加载Spring Boot上的更改，而无需重新启动服务器？

在微服务框架中可以使用config+spring cloud bus,由config从git仓库读取配置文件,每次更新都发送refresh消息到bus总线,config客户端作为消费者接收refresh,更新配置

springboot

1. springboot常用注解有哪些（spring）

除了springboot,spring,springmvc的都是

@SpringBootApplication
@ComponentScan
@AutoEnableCOnfiguration
@ResponseBody
@RequestMapping
@RequestParam
@RequestBody
@Configuration
@Service
@Controller
@Component
@Bean
@Value
@ConfigurationProperties

甚至JPA mybatis注解都可以说说,都是项目常用的;其实这个题考察什么不重要,重要的是展示你的经验

2. springboot如何实现分页功能

实现方法非常多,不是一种,所以这个问题考察的是经验

整合mybatis实现分页
整合jpa实现分页
pageHelper实现分页
pageAble

3. springboot的优点

编码简化
配置简化(配置自动化)
部署简化
技术引入简化（底层支持很多技术的封装spring-data数据中间件，rabbitTemplate redisTemlate（重新学习api）

4. base理论和cap理论是什么

BASE理论:Basically Available（基本可用）、Soft state（软状态）和Eventually consistent（最终一致性）三个短语的缩写。BASE理论是对CAP中一致性和可用性权衡的结果，其来源于对大规模互联网系统分布式实践的总结，是基于CAP定理逐步演化而来的。BASE理论的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。接下来看一下BASE中的三要素：
1、基本可用:指分布式系统在出现不可预知故障的时候，允许损失部分可用性----注意，这绝不等价于系统不可用。比如：
（1）响应时间上的损失。正常情况下，一个在线搜索引擎需要在0.5秒之内返回给用户相应的查询结果，但由于出现故障，查询结果的响应时间增加了1~2秒
（2）系统功能上的损失：正常情况下，在一个电子商务网站上进行购物的时候，消费者几乎能够顺利完成每一笔订单，但是在一些节日大促购物高峰的时候，由于消费者的购物行为激增，为了保护购物系统的稳定性，部分消费者可能会被引导到一个降级页面
2、软状态:指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据同步的过程存在延时
3、最终一致性（系统在某一个时间点的数据可能不一致，但是过一段时间，总会保持一致）:强调的是所有的数据副本，在经过一段时间的同步之后，最终都能够达到一个一致的状态。因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性。
总的来说，BASE理论面向的是大型高可用可扩展的分布式系统，作为理论一句完成局部继续选型；

静静七分醉

关注

8
点赞
踩
33

收藏

觉得还不错? 一键收藏
1
评论
SSM+Spring Boot+ springcloud面试

目录Spring主线内容依赖注入SpringBeansSpring注解Spring数据访问30.Spring支持的事务管理类型Spring面向切面编程（AOP）2.Spring里面applicationContext.xml文件能不能改成其他文件名？5.构造器注入和 setter 依赖注入，那种方式更好？6.依赖注入和工厂模式之间有什么不同？7...
复制链接

扫一扫