框架部门面试题学习

IOC容器，AOP

• IOC ：依靠反转，将对象的创建，组装，管理的控制权限从应用步伐反转到IOC容器中。由springboot的来实现对象的自动装配和注入。
  
  
  • 当某个类使用了@Componnet 注解后，标志为一个组件。那么这个类在项目启动的时候，会自动执行Bean装配，生成一个Bean对象到依靠池中。
    
  • 当在其他的类中使用了@Auotwired 注解后，会执行bean加载（依靠注入），将依靠池中的对象拿出来。
    
  • IOC装配·Bean 的具体流程为：
    
    
    • 创建一个BeanFactory ，加载设置文件。根据设置文件，创建BeanDefination 对象。
      
    • 将BeanDefination 对象注册到 Bean工厂中 ，根具 BeanDefination 信息，举行Bean实例化，得到空的Bean 实例。
      
    • 使用@Auotwired 自动将依靠注入到Bean实例中。
      
    • 举行Bean的初始化，得到可用的bean实例，查抄依靠关系，添加到依靠池中。
      
    
    
  
  
• AOP ：面向切面编程。 在不修改原来的代码的基础上，在目的方法中增长新的功能大概拦截原有的功能实现。办理代码的耦合度与代码复用的题目。
  
  
  • 底层使用了JDK+CGLIB的动态代理方式实现。
    
  • 界说切面： 起首的界说i一个切面类，使用@Component 、@Aspect 注解。
    
  • @Pointcut 在切面中，界说一个切入点：定位到想要去拦截或添加功能的位置方法上。
    
  • @Before :界说切入点到目的方法执行前的方法。
    
  • @AfterReturning ：目的方法执行无非常竣过后执行。
    
  • @After :目的方法执行出现非常后执行
    
  • @AfterThrowing ：目的方法出现非常时执行的方法
    
  • @Around ():围绕关照，使用rtry-catc的方法实现，方法的执行前后的关照。
    
  • 最后使用切点定位目的方法的过程叫做织入，会生成一个代理对象，执行切面的方法。
    
  
  

1. /**
2. * 切⾯
3. *  
4. 切⼊点和通知的抽象   （与⾯向对象中的 类 相似）
5. *  
6. 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
7. */
8. @Component // 将对象交给IOC容器去实例化
9. @Aspect // 声明当前类是⼀个切⾯
10. public class LogCut {
11. /**
12. *  
13. *      
14. *  
15. 切⼊点：
16. 匹配规则。规定什么⽅法被拦截、需要处理什么⽅法
17. 定义切⼊点
18. *    @Pointcut("匹配规则")
19. *
20. *    Aop 切⼊点表达式简介
21. *       1. 执⾏任意公共⽅法：
22. *        
23. execution(public *(..))
24. *       2. 执⾏任意的set⽅法
25. *        
26. execution(* set*(..))
27. *   
28. *        
29. 3. 执⾏com.xxxx.service包下任意类的任意⽅法
30. execution(* com.xxxx.service.*.*(..))
31. *       4. 执⾏com.xxxx.service 包 以及⼦包下任意类的任意⽅法
32. *        
33. execution(* com.xxxx.service..*.*(..))
34. *
35. *      
36. *      
37. 注：表达式中的第⼀个* 代表的是⽅法的修饰范围
38. 可选值：private、protected、public （* 表示所有范围）   
39. */
40. @Pointcut("execution (* com.xxxx.service..*.*(..) )")
41. public void cut(){}
42. /**
43. * 声明前置通知   并将通知应⽤到定义的切⼊点上
44. * ⽬标类⽅法执⾏前 执⾏该通知
45. *
46. */
47. @Before(value = "cut()")
48. public void before() {
49. System.out.println("前置通知.....");
50.     }
51. /**
52. * 声明返回通知   并将通知应⽤到定义的切⼊点上
53. * ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
54. *
55. */
56. @AfterReturning(value = "cut()")
57. public void afterReturn() {
58. System.out.println("返回通知.....");
59.     }
60. /**
61. * 声明最终通知   并将通知应⽤到定义的切⼊点上
62. * ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
63. *
64. */
65. @After(value = "cut()")
66. public void after() {
67. System.out.println("最终通知.....");
68.     }
69. /**
70. *  
71. *  
72. *      
73. /**
74. * 声明异常通知   并将通知应⽤到定义的切⼊点上
75. * ⽬标类⽅法出现异常时 执⾏该通知
76. */
77. @AfterThrowing(value="cut()",throwing = "e")
78. public void afterThrow(Exception e) {
79. System.out.println("异常通知....." + "  异常原因：" + e.getCause());
80.     }
81. 声明环绕通知  并将通知应⽤到切⼊点上
82. ⽅法执⾏前后  通过环绕通知定义相应处理
83. 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
84. * @param pjp
85. * @return
86. */
87. @Around(value = "cut()")
88. public Object around(ProceedingJoinPoint pjp) {
89. System.out.println("前置通知...");
90. Object object = null;
91. try {
92. object = pjp.proceed();
93. System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
94. // System.out.println("返回通知...");
95.         }
96. catch (Throwable throwable) {
97. throwable.printStackTrace();
98. System.out.println("异常通知...");
99.         }
100. System.out.println("最终通知...");
101. return object;
102.     }
103. }

复制代码

Bean对象的循环依靠题目是什么，怎么办理

• 当两个类相互注入时，当spring实验创建其中一个对象，发现依靠于另一个，先去创建其对象。
  
• 办理：
  
  
  • 使用了springboot得的二，三级缓存，将没有完全实例化好的对象存储在二级缓存中，当出现循环依靠时，会在二级缓存中找到未实例化好的对象。
    
  • 的当出现AOP的循环依靠题目，三级缓存中存在多对多每个Bean都beanFactory ，通过getObject()可以得到未完全实例化好得到bean .存到二级缓存中。
    
  
  

AOP的使用场景有哪些，假如让你去模拟一个怎么举行实现

• 日记打印、性能分析、安全控制、事件处理、
  
• @EnableAspectJAutoProxy 在启动类上添加注解选择代理模式。用于开启基于 AspectJ 的自动代理功能
  
• 写一个切面类(日记打印)，@component @Aspect标志该切面类中 。
  
• 在切面类中 界说切点@pointcut(“execution()”)找到目的方法。（通过@interface 去实现自界说注解，匹配规则中，写下先自界说注解的全路径，通过自界说注解找到对应的目的方法）
  
• 切面中实现@before (“切入点”) @After() @AfterThrowing() @AfterRunner @Around()
  

Spring事件回滚流程

• spring事件通过Aop 来实现，先创建一个代理对象，根据aop的流程执行具体的逻辑操作。但是不通过aop的关照实现核心操作，而通过transacationlnterceptor来实现，调用invoker()方法实现具体的逻辑。
  
• 具体流程可以形貌为：
  
  
  • 先做准备工作，解析@Transaction注解的目的方法上的事件相关的属性，根据属性大概根据设置文件 中的事件管理器 （DataSourceTransactionManager）启动事件。当事件启动，其他的sq会等待事件竣事在执行。
    
  • 当开启事物，获取数据库连接，将数据库的自动提交模式设置为false.
    
  • 执行具体的业务逻辑操作。假如执行成功，将自动提交模式设置为true ,开释数据库连接资源。
    
  • 当操作执行失败，抛出非常，假如非常是一个runTimeException或error 通过completeTransaction 完成事件的回滚。否则不回滚事件。除非@Transaction()中指定提交指定了rollbackfor 。 具体是通过doRollBack实现。
    
  • 事件执行完成后，通过cleanupTransaction清除相关事件操作。
    
  
  

什么情况下事件会失效

• @Transactionnal 注解只能使用public的方法使用。
  
  
  • 非public方法可能无法抛出或捕捉非常。
    
  • 访问权限，无法被外部方法调用。
    
  • 事件是同过aop 代理方式实现，非public 的方法可能不能被拦截。
    
  
  
• 通过类 内部普通方法对 @Transactional注解的方法举行调用。
  
  
  • 事件的开始竣事，在service的最外层，内部发生可能导致，事件的范围不正确。
    
  • 导致事件的隔离级别不正确。
    
  • 非常未正确处理的不能正常回滚。
    
  • 导致数据库连接非常。事件不能正确举行。
    
  • 并发非常。
    
  
  
• 数据库不支持事件。
  
  
  • 使用了Myisam 。
    
  
  
• @transactional 默认只处理运行时的非常，举行回滚。通过rollbackFor 和norollbackFor 指定哪些非常需要回滚。
  
• 事件的流传属性设置不正确。以never 、not_supported 不见效
  
  
  • Required :默认的流传机制，存在支持当前的事件，不存在创建一个新的。
    
  • Supports:事件存在支持事件，不存在，支持非事件。
    
  • Mandatory:在正常的事件内执行，否则抛出非常。
    
  • Requires_new：不管存不存在，直接开启一个新事件。
    
  • Not_supported：只能以非事物执行。
    
  • Never:只能以非事物执行。存在事物抛非常。
    
  • Nested :不存在，开启事件，存在事件，运行一个嵌套事件。
    
  
  
• 捕捉非常未抛出。导致事件终止。
  
  
  • 捕捉非常后未回滚、提交
    
  • 捕捉非常后未记录日记或关照。
    
  • 捕捉非常后未处理或重新抛出。
    
  
  
• Bean没有被Spring容器管理。
  
• 事件的方法内启动新线程来举行异步操作。
  
  
  • 新线程异步操作在事件提交之前，导致事件不能提交。
    
  • 新线程的一部操做在事件的内部，而且事件的流传机制未supprot_new,会开启新的事物，与原事物无关。
    
  • 新线程的异步操作出现非常未处理，原事物订单不能回滚。
    
  
  

怎么证实你这个Controller方法是单例的

• 对控制器的构造方法使用日记打印，发起多次请求后，发现打印的日记只有一条。
  

1. // 创建LOgger对象，调用logger.info()打印日志。
2. @SpringBootApplication
3. public class Starter {
4. private static Logger logger = LoggerFactory.getLogger(Starter.class);
5. }
6. public static void main(String[] args) {
7. logger.info("SpringBoot 应用开始启动...");
8. SpringApplication.run(Starter.class);
9.     }

复制代码

• 对该方法打断点，多次发起请求，查看对象是否是同一个。
  

Spring的七大核心组件分别是哪些

• spring core ：核心容器创建和管理bean的容器。
  
• springcontext ：spring上下文设置文件，向spring提供上下文信息。
  
• spring Aop
  
• spring dao 用于访问数据的对象
  
• spring orm : 对象关系映射，办理对象与数据库不匹配的题目。
  
• spring web : 为基于web的应用步伐提供上下文。
  
• spring mvc ：spring 内置的MVC 框架。办理了web开辟常见的题目，参数担当、文件上传。支持restful 风格的URL 请求路劲。
  

IOC和AOP明确

一二三级缓存分别存储什么信息

• concurrentHashMap 存储完整创建的实例Bean ，当需要用时可以快速获取。
  
• ConcurrentHashMap 暂时未完成创建好的bean 对象。循环依靠中出现。
  
• concurrentHashMap 三级存储了一个bean工厂，在需要创建bean的时候来创建bean 对象。
  

具体的日记信息怎么得到

• springboot默认使用LogBack 日记系统。在yml 或 properties 文件中将日记输出的级别进步到Debug。
  

1. logging.level.root=DEBUG

复制代码

• 设置其他的日记系统–Log4J。
  

拦截器是怎么实现拦截的

• 起首先创建一个拦截器对象。实现interceptror 是接口，重写他的三个方法 preHandel（）hostHandel（）afterComletion()。
  
• 设置拦截器：实现WebMvcConfiguration 接口。通过重写addinterceptors（） 方法添加多个拦截器，的使用拦截器对象的addpathpatterns(“/”)添加拦截路经。
  

Spring中设置过滤器

• 实现Filter接口，重写三个方法 init() 、dofilter（）、destroy()，在实现类上使用@webFilter注解界说过滤路劲。
  
• 在启动类上添加@ServeltCompenetScan 举行自动设置。
  

Cookie,Session,Token三者的区别与使用

• cookie:存储在客户端的小文本数据 。安全性较低，cokie可以被直接获取。存储一些非敏感、与用户会话相关的小量信息当客户端访问服务器，服务器会发送给cookie到客户端存储，当下次访问时会带着cookie一起访问。服务器会相应对应的数据。
  
• session：存储在服务器中，当客户端访问服务器，服务器存储客户端的数据，返回一个session ID 到客户端。客户端带着这个id 访问服务器 ，服务器通过id找到对应的session,就能给出这个session 对应的客户端数据。安全性较高，存储用户的相关信息。
  
• token: 存储在客户端,通常是一个包含用户信息和签名的字符串.
  
• 客户端带着token 到服务器，服务器验证token ,返回true,则返回客户端数据。安全性主要看加密强度强弱。存储用户的权限标识。
  

MVC执行流程

• 用户发出请求->被前端控制器（dispatcherServlet）拦截。，调用处理器映射器（handerMapping）
  
• 处理器映射器去找到的具体的处理器（xml设置或注解），生成处理器对象、处理器拦截器，返回给前端控制器。
  
• 前端控制器调用处理器适配器（handerAdapter）去调用具体的处理器（handler\controller ）
  
• 具体的处理器执行返回ModelAndView 视图对象给处理器适配器。再返回给前端控制器。
  
• 前端控制器将视图给视图解析器（ViewReslover）解析，将解析的结果 View 返回给前端控制器。
  
• 前端控制器将视图举行渲染后返回给用户。
  

Controller层有哪些常用的注解，前端传给后端的数据应该通过哪些注解接收的

• 前端到后端的数据：
  
  
  • @RequestBody() : 解析json 格式，并将其转换为相应的java格式
    
  • @Requestparmar /@modelTribute /@RequestPart 接收前端传来的参数绑定到java 对象上。
    
  • @PathVariable ：接收URL路劲上的参数.
    
  • @RequestHeader ：获取请求头上的某个字段。
    
  • @XmlrootElement: 处理Xml数据与java对象之间的转换
    
  
  

前端发送到后端的对象是怎样酿成一个实体类的，后端返回给前端的实体类又是怎样酿成JSON字符串

• 前端将对象序列化为jon字符串，这个字符串中包含了对象的属性与值。
  
• 后端使用@RequestBody 注解标识实体，内置的解析器将json字符串中的属性与值通过反射来设置该对象。
  
• springboot 默认使用jackson 来处理序列化。当controller 返回数据时，自动调用jackson 序列化数据。使用阿里提供的–fastjson
  

SSM中涉及到哪些设计模式

• spring :
  
  
  • BeanFactory就是简朴工厂模式的体现，用来创建对象的实例；
    单例模式：Bean默认为单例模式。
    代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；
    模板方法：用来办理代码重复的题目。比如. RestTemplate, JmsTemplate, JpaTemplate。
    观察者模式：界说对象键一种一对多的依靠关系，当一个对象的状态发生改变时，全部依靠于它的对象都会得到关照被制动更新，如Spring中listener的实现–ApplicationListener。
    
  
  
• springMVC :
  
  
  • 组合模式：
    
  • 责任链模式：过滤器链
    
  • 策略模式：
    
  • 适配器模式
    
  
  
• mybatis :
  
  
  • 制作者模式 :
    比方 SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder；
    
  
  

工厂模式 :
比方SqlSessionFactory、ObjectFactory、MapperProxyFactory；
单例模式 :
比方ErrorContext和LogFactory；
代理模式 :
Mybatis实现的核心，比如MapperProxy、ConnectionLogger，用的jdk的动态代理；另有executor.loader包使用了cglib大概javassist到达延迟加载的效果；
组合模式 :
比方SqlNode和各个子类ChooseSqlNode等；动态SQL like、trim等
模板方法模式 :
比方BaseExecutor和SimpleExecutor，另有BaseTypeHandler和全部的子类比方IntegerTypeHandler；
适配器模式 :
比方Log的Mybatis接口和它对jdbc、log4j等各种日记框架的适配实现；
装饰者模式 :
比方cache包中的cache.decorators子包中等各个装饰者的实现；
迭代器模式 :
比方迭代器模式PropertyTokenizer；
简述mybatis中#与$区别

• #{} ￥{} 都是当访问maapper 接口时，通报给方法的形参值。
  
• 区别：
  
  
  • 执行过程：#{}：将读取到的参数用？来占用，编译sql ,用得到的值更换? ${}：直接将读取的值更换参数。 参数假如是字符串：#{} 不需要手动添加 ’ ’ ${}需要，否则报错
    
  • sql注入：#{} 预编译先用？更换参数，再用值更换？不出现sql注入。 ${}会出现。
    
  • 通报关键字：使用#{} 会自动添加’ ’ 会报错，${}不会。
    
  
  

mybatis在什么场景使用，mybatis出现取代了什么，没有mybatis的时候怎么处理

• 需要频繁操作数据库，复杂的业务场景编写原生sql ,与多种数据库兼容,机动的对象映射。
  
• 取代了传统的JDBC,开启jdbc,执行sql语句，关闭数据库连接等操作。
  
• mybatis 只需要在maper 文件中写好对应的sql，创建对应的接口。mybatis 会自动处理数据库的连接和开释。
  
• 使用纯JDBC封装。内里编写JDBC的连接、执行、开释等方法。 使用其他的ORM 框架。 数据库的存储过程和视图。
  

mybatis接收返回值类型怎么设置，有哪些

• 输入返回值类型：paremetertype :别名大概 全类名。
  
  
  • _根本类型 : _int
    
  • 引用类型：大写转小写。包装类、string ,list 、hashmap。实体类、封装的POJO类。
    
  • 多个参数时，可以通过@Param 注解实现多个参数的接收，担当的时候封装为hashmap
    
    
    • 
      
      
    
    
  
  
• 输出返回值类型：resultType:
  
  
  • 类型：_根本类型 : _int
    
  • 引用类型：大写转小写。包装类、string ,list 、map、 实体类、封装的POJO类。
    
  
  
• resultMap: 自界说的返回类型。当出现数据库的映射堕落题目。为字段名起别名。
  

1. <resultMap id="empDeptMapResultMapOne" type="Emp">
2.   <id property="eid" column="eid"></id>
3.   <result property="empName" column="emp_name"></result>
4.   <result property="age" column="age"></result>
5.   <result property="sex" column="sex"></result>
6.   <result property="email" column="email"></result>
7.   <result column="did" property="dept.did"></result>
8.   <result column="dname" property="dept.dname"></result>
10. </resultMap>
12. <select id="getEmpAndDept" resultMap="empDeptMapResultMapTwo">
13.   select emp.*,dept.* from emp left join dept on emp.did = dept.did where emp.eid = #{eid}
14. </select>

复制代码

Mapper的映射怎样设置

• 在dao接口界说方法。在mapper.xml文件中实现sql方法。在全局设置文件中映入mappper.xml路经，设置数据库。
  

Mybatis怎样实现多表中实体映射关系

• 一对一：存在两张表，将查询的字段封装为一个POJO类
  

1. <resultMap id="" type = "">
2.   <id = "" column=""  property="">
3.   <id = "" column=""  property="">
4.     <association property="" javaType="">
5.       <id column = "" property="">
6.         <result column="" property="">
7.         <result column="" property="">
8.         <result column="" property="">
9.     </association>
10. </resultMap>
11. <select id=“” RequestMap="">编写sql </select>
12. <select id=“” ResultType="">编写sql </select>

复制代码

• 一对多/多对多：存在两张表以上：
  

1. <resultMap id="" type = "">
2.   <id = "" column=""  property="">
3.   <id = "" column=""  property="">
4.     <collection property="" oftype="">
5.       <id column = "" property="">
6.         <result column="" property="">
7.         <result column="" property="">
8.         <result column="" property="">
9.     </collection>
10. </resultMap>
11. <select id=“” RequestMap="">编写sql </select>

复制代码

SpringBoot核心注解

• @SpringBootConfiguration ： 将类申明为设置类，将当前类中全部以@Bean 标志的方法的实例放到spring 容器中。
  
• @ComponentScan：自动扫形貌好的当前路径下的包使用@Component @Controller 、@Service @Repository 注解标志的类。作为 bean 加载到spring容器中。
  
• @EnableAutoConfiguration ：自动设置的入口，springBoot更据添加的 jar 包举行项目的设置。
  

SpringBoot加载Web运用步伐的流程

• @SpringBootApplication 注解的 启动类 启动时调用 SpringApplication.run() 启动应用步伐。
  
  
  • springBoot根据设置好的依靠，举行自动设置，生成web情况需要的Bean.(负责处理web的请求和相应)
    
  • springBoot 内置的TomCat会作为默认的 Servlet 容器 ，自动启动。
    
  • springBoot自动注册、初始化 前端控制器（DispatcherServlet） 类。、
    
  • Spring Boot 会扫描并初始化应用步伐中界说的 Web 控制器类(带有 <font style="color:rgb(199, 37, 78);background-color:rgb(249, 242, 244);">@Controller</font> 或 <font style="color:rgb(199, 37, 78);background-color:rgb(249, 242, 244);">@RestController</font> 注解的类)。
    
  
  
• 前端控制器（DispatcherServlet）根据控制器类的方法上的 URL 映射注解(@RequestMapping、@GetMapping 等)来处理 Web 请求
  
• 假如控制器返回的是一个逻辑视图名,DispatcherServlet 会使用设置好的 视图解析器（ViewResolver） 来解析并渲染该视图。
  
• 最终,处理完请求后的相应数据会通过 Tomcat 容器返回给客户端。
  

SpringBoot自动装配原理

• springboot 提供了一系列的相关起步依靠，内里包含了一组相关的依靠，保证满足spring Boot 的使用·
  
• 大量的自动设置类：它们包含了用于设置 Spring 容器中各种组件的逻辑。在springbootautoconfigure模块的META - INF目次下有一个spring.factories文件，这个文件中界说了一系列的自动设置类的全路径名。当 Spring Boot 启动时，会读取这个文件，找到全部需要加载的自动设置类。
  
• Spring Boot 大量使用条件注解来决定自动设置类是否应该被应用。自动判度是否需要创建自动设置类。
  
• Spring Boot 通过@AutoConfigureOrder注解来控制自动设置类的加载顺序，自动设置类是相互关联的。这个注解是一个整数，数字越小，优先级越高。
  

     SpringBoot的启动流程？

• 通过main方法使用springApplication .run()创建springApplication 对象，、
  
• 运行这个springApplication对象，会开始加载情况变量，设置文件、系统属性。将信息存放在Environment对象 中。
  
• 选择符合的上下文。annotationConfigurSpringConText（） 或XmlwebConfigurSpringContext （）。然后通过@SpringBootApplication 去扫描对应的组件，注册到上下文情况当中。
  
• 举行自动设置，@EnableAuotConfigurtion 根据设置和依靠去设置相关的组件（设置类）。
  
• 假如是web应用步伐，那么会自动去启动内置的tomcat服务器。去设置文件中设置对应的参数。
  
• 前端发送请求，springboot将请求通报到前端控制器。通过这个URL路劲找到对应的映射注解标志的控制器方法，控制器去调用service层的方法执行业务逻辑。控制器返回视图给前端控制器，前端控制器调用视图解析器，解析视图返回给服务器，服务器将数据相应到客户端。
  

springboot打成的jar包和普通项目打成的jar包有什么区别

• springBoot :
  
  
  • 内置了tomcat、jetty 的服务器，jar包可以单独运行。
    
  • 将全部的依靠都打成一个jar包，当部署项目时，只需要一个jar包就可以运行。
    
  • 简朴的运行jar包下令-java - jar .jar 便可以启动。
    
  • 在运行时，会自动根据设置文件自动设置组件。
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。