JavaEE应用开发---期末复习题

选择题

上课练习题

1、下面关于映射文件中的< mapper >元素的属性，说法正确的是（B）。
A. parameterType属性的值表示的是返回的实体类对象
B. namespace属性的值通常设置为对应实体类的全限定类名
C. resultType属性的值表示传入的参数类型
D. 以上说法都不正确

A. parameterType属性的值表示的是返回的实体类对象。这个说法是错误的，parameterType属性的值表示传入的参数类型，不是返回的实体类对象。
B. namespace属性的值通常设置为对应实体类的全限定类名。这个说法是正确的，namespace属性的值可以用来区分不同的映射文件，通常设置为对应实体类的全限定类名，也可以设置为其他唯一标识。
C. resultType属性的值表示传入的参数类型。这个说法是错误的，resultType属性的值表示返回的实体类对象，不是传入的参数类型。

2、下面关于MyBatis框架的说法，正确的是（A）
A. MyBatis是一个半自动映射的框架，这里所谓的“半自动”是相对于Hibernate全表映射而言的
B. MyBatis是一个业务逻辑层的框架
C. MyBatis的封装性要比Hibernate高
D. MyBatis是一个全表映射的框架

MyBatis是一款基于Java语言的持久层框架，它支持自定义SQL语句、存储过程以及高级映射。MyBatis采用半自动映射的方式，即将Java对象和SQL语句的映射关系通过XML文件进行配置，从而实现对象的持久化和查询。相对于Hibernate的全自动映射，MyBatis更加灵活，可以更加细粒度地控制SQL语句的执行，也更加适合对于已经存在的数据库进行开发。

选项B错误，MyBatis并不是一个业务逻辑层的框架，而是专注于数据访问层的框架。

选项C和选项D也是错误的。MyBatis和Hibernate一样，都是为了简化数据持久化的框架，但MyBatis的封装性不高于Hibernate，并且MyBatis也不是全表映射的框架，它可以通过SQL语句实现更为灵活的数据访问。

3、有关MyBatis工作原理说法错误的是（C）
A. MyBatis的全局配置文件配置了MyBatis的运行环境等信息，其中主要内容是获取数据库连接
B. MyBatis映射文件中配置了操作数据库的SQL语句，需要在MyBatis的全局配置文件中加载才能执行
C. 可以通过MyBatis的环境等配置信息构建会话对象SqISession
D. SqlSession对象，该对象中包含了执行SQL的所有方法

可以通过MyBatis的环境等配置信息构建会话工厂对象SqlSessionFactory，而不是构建会话对象SqlSession。SqlSession是通过SqlSessionFactory创建的，用于执行SQL语句并管理事务。

4、SqlSession对象是线程不安全的。（√）

SqlSession对象是非线程安全的，因为它的实现类都是基于JDBC的Connection对象，而JDBC的Connection对象也是非线程安全的。所以在多线程的情况下，不同的线程应该使用不同的SqlSession对象来避免数据混乱或者线程安全问题。在多线程环境下，可以通过连接池来提供线程安全的SqlSession对象。

5、MyBatis映射文件主要用于实现SQL语句和Java对象之间的映射，使SQL语句查询出来的关系型数据能够被封装成Java对象。（√）

MyBatis映射文件是MyBatis框架中最重要的组成部分之一，主要用于实现SQL语句和Java对象之间的映射关系。通过映射文件，可以将SQL语句查询出来的关系型数据封装成Java对象，使得Java应用程序可以方便地操作和处理数据库中的数据。

映射文件中的主要元素包括：命名空间（namespace）、参数映射（parameterType）、结果映射（resultType）、SQL语句等。其中，参数映射用于描述输入参数的类型和名称，结果映射用于描述SQL语句查询出来的结果集与Java对象之间的映射关系，而SQL语句则用于描述具体的数据操作行为。

1、下列属性中，不属于@Results注解的是（C）。
A、column
B、property
C、size
D、one

@Results注解是用于配置映射关系的注解，可以用于类级别或方法级别，通过配置映射关系可以将数据库查询的结果集封装成Java对象。其中，@Result注解用于配置单个属性的映射关系，而@Results注解用于配置多个属性的映射关系。

@Results注解的属性包括：id、value、result、@Result等。其中，id属性用于指定映射关系的唯一标识符，value属性等同于result属性，用于指定一个或多个映射关系，@Result注解用于指定单个属性的映射关系。在@Result注解中，column属性表示数据库查询结果集中的列名，property属性表示Java对象中的属性名，而one属性用于配置一对一的关联关系。而选项C中的size属性不属于@Results注解的属性。

2、下列属性中，不属于< association >元素属性的是（C）。
A、property
B、select
C、ofType
D、autoMapping

< association >元素是用于描述实体类之间关联关系的元素，在MyBatis框架中使用。它可以用于表示一对一、一对多等关联关系。< association >元素的常用属性包括：

• property：指定实体类中与关联对象对应的属性名称。
• select：指定查询关联对象的 SQL 语句或 Mapper 方法。
• javaType：指定关联对象的类型。
• fetchType：指定关联对象的加载方式，有立即加载和延迟加载两种方式可选。
• autoMapping：指定是否自动映射

3、要求根据员工的id查找员工信息，下列使用@Select注解的代码书写正确的是（D）。
A、@Select(’ select * from tb_ worker where id = ?“)
B、@Select( 'select * from tb_ worker where id = #id”)
C、@Select(’ select * from tb_ worker where id = {id}")
D、@Select(“select * from tb_ _worker where id = #{id}”)

@Select 注解用于配置查询语句，其中 #{} 占位符会被 MyBatis 自动替换成对应参数的值。在该题目的代码中，D 选项使用了 #{id} 占位符，正确地将员工id作为参数传入 SQL 语句中。而其他选项中使用了不正确的占位符或语法，无法正确获取员工信息。

4、< association >元素只有一种配置方式，即嵌套结果方式。（×）

在 MyBatis 中，< association > 元素可以通过两种方式配置：

1. 嵌套结果方式：在 SQL 查询中使用关键字 AS 或别名给查询字段取别名，然后使用 < association > 元素来映射查询结果和实体类中的关联对象。
2. 嵌套查询方式：在 < association > 元素的 select 属性中指定一个查询关联对象的 SQL 语句或 Mapper 方法，使用 MyBatis 执行查询并获取结果。

5、MyBatis的@Insert注解就是将SQL语句直接写在接口上，使得代码书写更加简单，减少了大量的XML文件的配置。（√）

@Insert 注解可以用来简化 MyBatis 的配置

1、Spring的常用注解中，用于指定要自动装配的对象的注解是（A）。
A、@Autowired
B、@Repository
C、@Service
D、@Controller

当 Spring 容器创建对象时，会自动扫描标记了 @Autowired 注解的属性或构造函数参数，并尝试将匹配的 Bean 对象自动注入到属性或参数中。

2、Spring容器默认的作用域是（D）。
A、prototype
B、request
C、session
D、singleton

在 Spring 容器中，Bean 的作用域用来定义 Bean 对象的生命周期以及在应用程序中的可见范围。Spring 容器提供了以下 5 种标准的作用域：

• singleton：在整个应用程序中，只创建一个 Bean 实例，所有对该 Bean 的请求都将返回同一个实例。这是 Spring 容器的默认作用域。
• prototype：每次请求都会创建一个新的 Bean 实例。
• request：在 Web 应用程序中，每个 HTTP 请求都会创建一个新的 Bean 实例，该 Bean 实例仅在当前 HTTP 请求内有效。
• session：在 Web 应用程序中，每个 HTTP Session 都会创建一个新的 Bean 实例，该 Bean 实例仅在当前 HTTP Session 内有效。
• global session：仅在基于 Portlet 的 Web 应用程序中使用，每个全局 HTTP Session 都会创建一个新的 Bean 实例，该 Bean 实例仅在当前 Portlet 应用程序内有效。

默认情况下，Spring 容器中的 Bean 都是单例模式。也就是说，Spring 容器只创建一个 Bean 实例，并在需要时将其返回。如果需要创建多个实例，则需要将 Bean 的作用域设置为 prototype。

3、在ApplicationContext接口实现类中从类路径加载配置文件，实例化ApplicationContext接口的类方法是（C）。
A、WebApplicationContext
B、AnnotationConfigApplicationContext
C、ClassPathXmIApplicationContext
D、FileSystemXmlAplicationContext

这个方法是从类路径下加载 XML 配置文件并且实例化ApplicationContext 的类方法。ClassPathXmlApplicationContext 是 ApplicationContext 接口的一个实现类，用于从 XML 配置文件中加载 Bean 定义并实例化 Bean。它会在类路径下寻找指定名称的 XML 配置文件，并将其解析为 Spring 容器中的 Bean 定义。当 Spring 容器被初始化时，它会自动创建并实例化所有在配置文件中定义的 Bean，这些 Bean 可以通过 getBean() 方法获取。

4、Spring的元素中包含一个autowire属性，可以通过设置autowire属性的值实现Bean的自动装配。（√）

Spring 的 < bean > 元素中包含一个 autowire 属性，用于指定该 Bean 是否自动装配。设置 autowire 属性的值，可以控制 Spring 在装配 Bean 时采取的自动装配方式，其可选值包括 byName、byType、constructor、no 等，这些值的含义如下：

• byName：按照 Bean 的名称进行自动装配，要求 Bean 的名称和依赖的属性名称一致。
• byType：按照 Bean 的类型进行自动装配，要求 Bean 的类型和依赖的属性类型一致。
• constructor：通过构造器进行自动装配。
• no：不进行自动装配。

通过设置 autowire 属性，可以减少手动配置的代码量，提高开发效率。

5、基于注解的装配可以较大程度上解决基于XML方式装配导致的配置文件臃肿和难以维护等问题。（√）

基于注解的装配可以大大简化Spring配置文件的编写，减少配置文件的臃肿，提高可读性和可维护性。在基于注解的装配中，只需使用少量的注解，即可完成对象的装配，代码简洁清晰。同时，注解可以更直观地表达对象之间的依赖关系，降低了出错的概率，提高了开发效率和代码质量。因此，基于注解的装配是Spring中常用的一种装配方式。

1、下列选项中，用于配置切点的注解是（B）
A、@Aspect
B、@Pointcut
C、@Before
D、@Around

选项 B、@Pointcut 用于配置切点，表示一个表达式，用于匹配需要被拦截的方法或者类。选项 A、@Aspect 用于声明一个切面类，选项 C、@Before 用于在切点方法执行之前执行通知，选项 D、@Around 用于在切点方法执行前后执行通知，并且可以控制是否执行切点方法。

2、下列选项中，用于配置异常通知的注解是（D）
A、@After
B、@Around
C、@AfterReturning
D、@AfterThrowing

选项 D、@AfterThrowing 用于配置异常通知，表示在切点方法抛出异常时执行的通知。选项 A、@After 表示在切点方法执行之后执行通知，选项 B、@Around 表示在切点方法执行前后执行通知，并且可以控制是否执行切点方法，选项 C、@AfterReturning 表示在切点方法正常返回后执行通知。

3、在Spring的配置文件中，配置切面使用的元素是（B）。
A、 < aop:config >
B、< aop:aspect >
C、< aop:advisor >
D、< aop:pointcut >

在Spring的配置文件中，用于配置切面的元素是 < aop:aspect >。在 < aop:aspect > 元素中可以定义切面的各个通知类型，如前置通知、后置通知、异常通知、环绕通知等。< aop:config > 是配置AOP的容器元素，< aop:advisor > 是配置切面通知和切点的结合体，而< aop:pointcut > 是用于定义切点表达式的元素。

4、JDK动态代理可以实现无侵入式的代码扩展，并且可以在不修改源代码的情况下，增强某些方法。（√）

JDK动态代理可以在运行时生成代理对象，代理对象会实现与目标对象相同的接口，并且可以在代理对象中添加额外的功能，例如日志记录、性能统计等，从而实现无侵入式的代码扩展。同时，由于代理对象实现了目标对象相同的接口，因此调用代理对象的方法时不需要修改源代码，就可以实现方法的增强。

5、在AOP专业术语中，切面是指要对哪些Joinpoint进行拦截。（√）

在 AOP 中，切面是一个横跨多个核心关注点的功能，用于将横切关注点模块化。切面定义了在何处以及何时执行这些行为。切面可以包含一个或多个通知和一个切点，通知定义了在何时执行行为，而切点定义了在哪些连接点执行通知。因此，切面用于指定要对哪些 Joinpoint 进行拦截。

1、下列选项中，对方法queryForList ( String sql, Object[] args, class elementType )分析描述错误的是（C）。
A、args参数是sql语句中的参数
B、elementType参数返回的是List数据类型
C、不能返回多行数据的结果
D、返回结果是列表

选项C描述错误，因为该方法可以返回多行数据的结果，它返回一个列表，其中包含指定元素类型的所有行数据。该方法使用传递的SQL语句和参数数组执行查询，然后将结果映射到指定类型的对象列表中。参数args是sql语句中的占位符参数，它们在执行查询时会被替换成实际的值。选项A、B、D描述正确。

2、下列选项中，关于事务管理方式相关说法错误的是（B）。
A、Spring中的事务管理分为两种方式：一种是传统的编程式事务管理，另一种是声明式事务管理
B、编程式事务管理：是通过AOP技术实现的事务管理，就是通过编写代码实现的事务管理，包括定义事务的开始、正常执行后的事务提交和异常时的事务回滚
C、声明式事务管理：其主要思想是将事务管理作为一个“切面”代码单独编写，然后通过AOP技术将事务管理的“切面”代码植入到业务目标类中
D、声明式事务管理最大的优点在于开发者无需通过编程的方式来管理事务，只需在配置文件中进行相关的事务规则声明，就可以将事务规则应用到业务逻辑中

选项B描述错误。编程式事务管理是通过编写代码实现的事务管理，而不是通过AOP技术实现的事务管理。它需要开发人员手动控制事务的开始、提交和回滚，通常需要使用try-catch-finally语句块来保证事务的正确性。其他选项描述正确。选项A中提到了Spring中的两种事务管理方式；选项C中提到了声明式事务管理的主要思想；选项D中强调了声明式事务管理的优点。

3、下列选项中，不是< tx:method >元素的常用属性的是（D）
A、name
B、propagation
C、isolation
D、transaction-manager

选项D不是< tx:method >元素的常用属性。在Spring的声明式事务管理中，< tx:method >元素用于指定事务管理的规则。其中，name属性用于指定目标方法名，propagation属性用于指定事务的传播行为，isolation属性用于指定事务的隔离级别，而transaction-manager属性用于指定使用的事务管理器。因此，选项D描述错误。

4、JdbcTemplate类中的update()方法可以完成查询、插入、更新和删除数据的操作。（×）

JdbcTemplate类中的update()方法可以完成插入、更新和删除数据的操作，但不适用于查询操作。update()方法返回受影响的行数，表示成功更新、插入或删除的记录数。如果要执行查询操作，则需要使用query()方法。

5、Spring中的事务管理分为两种方式，一种是传统的编程式事务管理，另一种是声明式事务管理。（√）

Spring中的事务管理分为传统的编程式事务管理和声明式事务管理两种方式。编程式事务管理需要在代码中显式地开启、提交和回滚事务，使用起来较为繁琐。而声明式事务管理则是通过在XML配置文件或注解中声明事务规则，由Spring框架自动地管理事务，使用起来更加方便。两种方式各有优缺点，具体应用要根据实际情况而定。

1、用户通过浏览器向服务器发送请求时，负责拦截用户请求的是（C）。
A、处理器
B、处理器映射器
C、前端控制器
D、处理器适配器

C、前端控制器负责拦截用户请求。在Spring MVC中，DispatcherServlet就是前端控制器，它接收所有的客户端请求，并根据请求中的URL信息，将请求分发给相应的处理器映射器、处理器适配器和处理器进行处理。选项A中的处理器是用于处理具体业务逻辑的组件；选项B中的处理器映射器是用于将请求映射到相应的处理器的组件；选项D中的处理器适配器是用于将不同类型的处理器适配到前端控制器上的组件。

2、下列选项中对@RequestMapping注解的属性说法错误的是（C）。
A、value是@RequestMapping注解的默认属性，用于指定请求的URL
B、method用于指定该方法可以处理哪种类型的请求方式
C、name用于接收指定名称的请求参数的值
D、params用于指定客户端请求中参数的值，必须包含哪些参数的值，才可以通过其标注的方法处理

C、name用于指定请求参数的名称，而不是接收指定名称的请求参数的值，因此选项C描述错误。RequestMapping注解是Spring MVC中用于处理客户端请求的注解，可以用于类或方法上。其中value属性是RequestMapping注解的默认属性，用于指定请求的URL；method属性用于指定该方法可以处理哪种类型的请求方式，包括GET、POST、PUT、DELETE等；params属性用于指定客户端请求中参数的值，必须包含哪些参数的值，才可以通过其标注的方法处理。

3、下列选项中，哪个是Spring MVC的后端控制器（D）。
A、HandlerMapping
B、HandlerAdapter
C、DispatcherServlet
D、Handler

Spring MVC执行流程详细介绍

• （1）用户通过浏览器向服务器发送请求，请求会被Spring MVC的前端控制器DispatcherServlet拦截。
• （2）DispatcherServelt拦截到请求后，会调用HandlerMapping（处理器映射器）。
• （3）处理器映射器根据请求URL找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet。
• （4）DispatcherServlet会通过返回信息选择合适的HandlerAdapter（处理器适配器）。
• （5）HandlerAdapter会调用并执行Handler（处理器），这里的处理器指的就是程序中编写的Controller类，也被称之为后端控制器。
• （6）Controller执行完成后，会返回一个ModelAndView对象，该对象中会包含视图名或包含模型和视图名。
• （7）HandlerAdapter将ModelAndView对象返回给DispatcherServlet。
• （8）前端控制器请求视图解析器根据逻辑视图名解析真正的视图。
• （9）ViewResolver解析后，会向DispatcherServlet中返回具体的视图（View）对象。
• （10）DispatcherServlet对View进行渲染（即将模型数据填充至视图中）。
• （11）前端控制器向用户响应结果。

4、在Spring 4.0版本后，配置文件内必须要配置处理器映射器、处理器适配器和视图解析器。（×）

在Spring 4.0版本后，配置文件中并不需要显式地配置处理器映射器、处理器适配器和视图解析器。Spring MVC提供了默认的处理器映射器、处理器适配器和视图解析器，因此在配置文件中不必进行额外的配置，直接声明业务处理组件的bean即可。

5、在Spring MVC的执行过程中，前端控制器、处理器映射器、处理器适配器和视图解析器对象的工作都是在框架的内部执行的。（√）

在 Spring MVC 的执行过程中，前端控制器（DispatcherServlet）作为中央控制器，负责接收 HTTP 请求并委托其他组件处理该请求。处理器映射器（HandlerMapping）负责根据请求的 URL 映射到对应的处理器（Handler），处理器适配器（HandlerAdapter）则根据处理器的类型和接口将请求转发给对应的处理器方法。视图解析器（ViewResolver）负责根据处理器方法的返回值，解析出对应的视图（View）并渲染返回给客户端。

这些组件都是在 Spring MVC 框架的内部执行的，对开发者来说，只需要配置和使用它们即可，无需关心其具体实现细节。

1、下列注解中，可以与JSON格式转换器结合将JSON格式数据绑定到方法形参中的是（A）。
A、@RequestBody
B、@RequestMapping
C、@RequestParam
D、@Controller

@RequestBody 注解表示将 HTTP 请求正文中的数据绑定到方法的参数上，并且可以结合消息转换器（包括 JSON 格式转换器）将请求正文中的数据转换成 Java 对象。因此，当请求的数据是 JSON 格式时，可以使用 @RequestBody 注解和 JSON 格式转换器将请求正文中的 JSON 数据转换为 Java 对象，从而实现 JSON 数据绑定到方法形参中。

@RequestMapping 注解用于映射 HTTP 请求，@RequestParam 注解用于获取请求参数的值，@Controller 注解用于声明控制器类，这些注解与 JSON 格式转换器结合使用时，并不直接将 JSON 数据绑定到方法形参中。

2、下列选项，不是HandlerInterceptor接口中的方法的是（D）。
A、preHandler()
B、postHandle()
C、afterCompletion()
D、handler()

HandlerInterceptor 接口是 Spring MVC 框架中提供的一个拦截器接口，用于在请求被处理前、处理时和视图渲染之后拦截请求和响应。该接口包含三个方法：

• preHandle() 方法在请求被处理之前调用，可以在该方法中进行一些前置处理操作，如身份认证、日志记录等，如果该方法返回 false，则请求不会被继续处理。
• postHandle() 方法在请求处理之后、视图渲染之前调用，可以在该方法中进行一些后置处理操作，如修改 ModelAndView 中的数据、添加公共模型信息等。
• afterCompletion() 方法在整个请求处理完成后、视图渲染后调用，可以在该方法中进行一些资源清理操作，如释放资源、记录日志等。

而 handler() 方法不是 HandlerInterceptor 接口中的方法，可能是选项中的一个错误选项。

3、下列选项，对注解@ControllerAdvice的描述错误的是（D）。
A、注解作用在类上时可以增强Controller
B、该注解是Spring3.2中新增加的
C、该注解需要结合注解@ExceptionHandler才可以捕获Controller中抛出的指定类型的异常，从而实现不同类型的异常统一处理
D、该注解不需要结合注解@ExceptionHandler，同样可以捕获Controller中抛出的指定类型的异常，从而实现异常处理

@ControllerAdvice 是 Spring MVC 框架中提供的一个注解，可以用于定义一个全局的异常处理器或者数据绑定器。当该注解作用在类上时，可以增强 Controller 的功能，例如添加全局数据模型、全局异常处理等。该注解从 Spring 3.2 版本开始引入。

要实现异常处理，通常需要结合 @ExceptionHandler 注解一起使用。@ExceptionHandler 注解用于指定处理特定异常类型的方法，当 Controller 中抛出指定类型的异常时，会调用对应的 @ExceptionHandler 方法进行异常处理。

4、如果SpringMVC的配置文件中没有视图解析器，则不会进行请求转发。（×）

即使在 Spring MVC 的配置文件中没有视图解析器，请求也会进行转发。但是如果没有配置视图解析器，需要在代码中手动指定转发的视图路径。如果配置了视图解析器，则可以直接使用逻辑视图名，视图解析器会自动将其解析成实际的视图路径。

5、如果对Spring MVC中所有异常进行统一处理，可以使用Spring MVC提供的异常处理器HandlerExceptionResolver。（√）

在 Spring MVC 中，可以通过实现 HandlerExceptionResolver 接口来实现对所有异常的统一处理。HandlerExceptionResolver 接口定义了一组用于处理异常的方法，包括 resolveException() 方法，该方法会在控制器抛出异常后被调用，可以在该方法中对异常进行处理并返回 ModelAndView 对象，从而实现对所有异常的统一处理。通过在 Spring MVC 的配置文件中配置一个实现了 HandlerExceptionResolver 接口的 Bean，可以将其注册为全局的异常处理器，从而实现对所有异常的统一处理。

MyBatis

1、关于 MyBatis 配置文件 typeAliases 元素说法错误的是（C）。

A. 可以通过在MyBaits中配置< typeAliases >元素来定义别名

B. 可以通过在类名上使用@Aliases(value =”user”)的形式定义别名

C. MyBaits配置文件< typeAliases >元素的子元素< typeAliases >需要配置type和属性alias属性

D. 同时在MyBaits中配置了< typeAliases >元素以及@Alias(value=”user”)注解定义别名后，会以注解形式的别名为准

答案是C，MyBaits配置文件typeAliases元素的子元素不是typeAliases，而是typeAlias。typeAlias元素需要配置type和alias属性，用于指定类型和别名。因此，说法C是错误的。其他说法都是正确的：

A. 可以通过在MyBaits中配置<typeAliases>元素来定义别名。在<typeAliases>元素中，可以使用<typeAlias>子元素来指定类型和别名，也可以使用<package>子元素来扫描指定包中的所有类并自动注册类型别名。

B. 可以通过在类名上使用@Alias(value="user")的形式定义别名。这种方式可以在不修改配置文件的情况下为类指定别名。

D. 如果同时在MyBaits中配置了<typeAliases>元素以及@Alias(value="user")注解定义别名，会以注解形式的别名为准。如果注解和配置文件中都指定了同一个类的别名，会以注解中的别名为准。

2、下面关于映射文件中的<mapper>元素的属性，说法正确的是（D）。

A. parameterType 性的值表示的是返回的实体类对象

B. namespace属性的值通设置为对应实体类的全限定类名

C. resultType属性的值表示传入的参数类型

D. 以上说法都不正确

A. parameterType属性用于指定SQL语句的参数类型，而不是返回的实体类对象。

B. namespace属性用于指定映射文件对应的Mapper接口的全限定类名，而不是对应实体类的全限定类名。

C. resultType属性用于指定SQL语句返回结果集的类型，而不是传入的参数类型。

3、Mybatis动态SQL元素中的（C）用于单条件分支判断。

A. bind

B. when

C. if

D. set

A. bind用于将一个Ognl表达式的值绑定到一个变量上，以便后续引用。

B. when用于配合choose元素实现多条件分支判断。

C. if用于单条件分支判断。

D. set用于更新语句中设置某些列的值。

4、下面关于 MyBatis 框架的说法，正确的是（A）。

A. MyBatis是一个半自动映射的框架，这里所谓的“半自动”是相对于Hibernates全表映射而言的

B. MyBatis是一个业务逻辑层的框架

C. MyBatis是一个全表映射的框架

D. MyBatis的封装性要比Hibernate高

A. MyBatis是一个半自动映射的框架，它将数据库操作抽象为Mapper接口中的方法，通过XML映射文件来配置SQL语句和实体类之间的映射关系。这里所谓的“半自动”是相对于Hibernate的全表映射而言的。

B. MyBatis并不是一个业务逻辑层的框架，它更多地是专注于数据访问层的框架。

C. MyBatis并不是一个全表映射的框架，它采用的是按需映射的方式，可以映射部分或全部属性，以及一些复杂的关联关系。

D. MyBatis和Hibernate在封装性方面没有可比性，因为它们面向的领域和设计思想不同。MyBatis更加灵活和可配置，而Hibernate则更加注重ORM的完整性和自动化程度。

5、有关 MyBatis 工作原理说法错误的是（B）。

A. MyBatis映射文件中配置了操作数据库的SQL句，需要在MyBatis的全配置文件中加载才能执行

B. 可以通过MyBatis的环境等配置信息构建会话对象SqlSession

C. MyBatis的配置文件配置了MyBatis的运行环境等信息，其中主要内容是获取数据库连接

D. SqiSession对象，该对象中包含了执行SQL的所有方法

A. MyBatis映射文件中定义了SQL语句和结果映射，需要在MyBatis的全局配置文件中注册才能使用。

B. 不能直接通过MyBatis的环境等配置信息构建SqlSession，需要先通过SqlSessionFactoryBuilder根据配置信息创建SqlSessionFactory，然后再通过SqlSessionFactory获取SqlSession。

C. MyBatis的配置文件中包含了数据源、事务管理器、类型别名、类型处理器、插件等信息，其中数据源是用来获取数据库连接的。

D. SqlSession对象是MyBatis的核心接口，它提供了执行SQL语句、获取Mapper接口代理对象、管理事务等方法。

6、当多个选样的情是，值需要从多个选项中选择一个执行时，可以使用的动态SQL元素是（D）。

A. < when >

B. < if >

C. < set >

D. < choose >、< when >、< otherwise >

A. <when>元素是用于在<choose>元素内部指定每个选项的条件的。

B. <if>元素是用于判断一个条件表达式的真假，从而动态生成SQL语句的。

C. <set>元素是用于动态设置更新语句的属性值的。

D. <choose>、<when>、<otherwise>组合可以实现从多个选项中选择一个执行的逻辑，类似于Java中的switch语句。<choose>元素包含多个<when>元素和一个可选的<otherwise>元素，每个<when>元素都包含一个条件表达式和一个SQL语句块，<otherwise>元素则表示当所有条件都不满足时的默认操作。

7、在传统DBC编程中，SOL变动需要改变Java代码，违反了开闭原则，下面哪个方法可以解决这个问题？（C）

A. 以上说法都不正确

B. MyBatis自动将Java对象映射至SQL语句，通过Statement中的parameterType定义输入参数的类型

C. MyBatis将SQL语句配置在MyBatis的映射文件中，实现了与Java代码的分离

D. MyBatis自动将SQL执行结果映射至Java对象，通过Statement中的parameterType定义输出参数的类型

在传统JDBC编程中，将SQL语句硬编码到Java代码中，这意味着每当SQL语句发生变化时，都需要修改Java代码。这种方法违反了开闭原则，因为每次更改都会导致系统的重新编译和部署。

MyBatis通过将SQL语句配置在映射文件中来解决这个问题，这使得SQL语句与Java代码分离。这样，在SQL语句发生变化时，只需要更新映射文件，而不需要修改Java代码。这种方法有助于提高系统的可维护性和灵活性。

8、下列选项中，关于MyBatis的配置说法正确的是（A）。

A. 配置文件主要配置了MyBatis的运行环境等信息

B. 通过MyBatis的环境等配置信息可以直接构建会话工厂SqlSession

C. MyBatis可以加载多个映射文件，每个映射文件对应数据库中的一张表

D. mybatis-config中配置了操作数据库的SQL语句

A. MyBatis的配置文件中包含了数据源、事务管理器、类型别名、类型处理器、插件、环境、映射器等信息，这些信息都是影响MyBatis运行时行为的重要设置。

B. 不能直接通过MyBatis的环境等配置信息构建SqlSession，需要先通过SqlSessionFactoryBuilder根据配置信息创建SqlSessionFactory，然后再通过SqlSessionFactory获取SqlSession。

C. MyBatis可以加载多个映射文件，但每个映射文件不一定对应数据库中的一张表，也可以对应一个接口或一个类，映射文件中定义了SQL语句和结果映射。

D. mybatis-config中不配置操作数据库的SQL语句，而是在映射文件中配置SQL语句和参数、返回值等信息。

9、下面属性中不属于<association>元素属性的是（A）

A. ofType

B. columnn

C. javaType

D. property

在 MyBatis 的 <association> 元素中，常用的属性有：

• property：关联对象的属性名；
• column：关联对象的外键列名；
• javaType：关联对象的类型；
• select：用于指定关联查询的映射语句；
• resultMap：用于指定关联查询的结果集映射。

ofType 属性并不属于 <association> 元素属性，它是 <collection> 元素中的一个属性，用于指定集合元素的类型。

10、下面关于MyBatis提供的用于解决JDBC编程劣势的方案，说法错误的是（C）。

A. MyBatis自动将SQL执行结果映射至Java对象，通过Statement中的resultType定义输出结果的类型

B. MyBatis自动将Java对象映射至SQL语句，通过Statement中的parameterType定义输入参数的类型

C. MyBatis将SQL语句配置在MyBatis的映射文件中，未与Java代码的分离

D. 在SqlMapConfig.xml中配置数据链接池，使用连接管理数据库链接

C. MyBatis将SQL语句配置在MyBatis的映射文件中，未与Java代码的分离。这个说法是错误的。实际上，MyBatis的映射文件（Mapper.xml）是用于将 SQL 语句与 Java 代码进行分离的。在映射文件中，可以定义 SQL 语句以及与之对应的结果集映射关系，从而实现 SQL 与 Java 代码的分离，提高代码的可维护性和灵活性。

A. MyBatis自动将SQL执行结果映射至Java对象，通过Statement中的resultType定义输出结果的类型。这个说法是正确的，MyBatis可以通过配置映射关系，将 SQL 查询结果自动映射到指定的 Java 对象。

B. MyBatis自动将Java对象映射至SQL语句，通过Statement中的parameterType定义输入参数的类型。这个说法也是正确的，MyBatis可以通过配置映射关系，将 Java 对象自动映射到 SQL 语句的参数中。

D. 在SqlMapConfig.xml中配置数据链接池，使用连接管理数据库链接。这个说法也是正确的，MyBatis提供了配置数据连接池的功能，可以在配置文件中指定数据库连接池的相关参数，以便更好地管理和复用数据库连接。

1、使用ORM框架后，应用程序不再直接访问底层数据库，而是以（C）的方式来操作持久化对象（PO，即Persisent Object）。

A、面向业务 B、Hibernate C、面向对象 D、MyBatis

ORM（Object-Relational Mapping）框架是一种将关系型数据库的数据映射到面向对象编程语言中的技术。使用 ORM 框架后，应用程序不再直接访问底层数据库，而是以面向对象的方式来操作持久化对象（PO，即 Persisent Object）。

Hibernate 和 MyBatis 都是常用的 ORM 框架。Hibernate 是一种全自动ORM框架，它可以自动将数据库中的数据映射到 Java 对象中，而开发人员只需要关注领域模型的设计，不需要编写 SQL 语句。而 MyBatis 是一种半自动ORM框架，它需要开发人员手动编写 SQL 语句，并将 SQL 语句与 Java 对象进行映射。

2、下面关于MyBatis提供的用于解决JDBC编程劣势的方案，说法错误的是（B）。

A、在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接

B、MyBatis将SQL语句配置在MyBatis的映射文件中，未与Java代码的分离

C、MyBatis自动将Java对象映射至SQL语句，通过Statement中的parameterType定义输入参数的类型

D、MyBatis自动将SQL执行结果映射至Java对象，通过Statement中的resultType定义输出结果的类型

这个说法是错误的。实际上，MyBatis的映射文件（Mapper.xml）是用于将 SQL 语句与 Java 代码进行分离的。在映射文件中，可以定义 SQL 语句以及与之对应的结果集映射关系，从而实现 SQL 与 Java 代码的分离，提高代码的可维护性和灵活性。

A、在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。这个说法是正确的，MyBatis提供了配置数据连接池的功能，可以在配置文件中指定数据库连接池的相关参数，以便更好地管理和复用数据库连接。

C、MyBatis自动将Java对象映射至SQL语句，通过Statement中的parameterType定义输入参数的类型。这个说法也是正确的，MyBatis可以通过配置映射关系，将 Java 对象自动映射到 SQL 语句的参数中。

D、MyBatis自动将SQL执行结果映射至Java对象，通过Statement中的resultType定义输出结果的类型。这个说法也是正确的，MyBatis可以通过配置映射关系，将 SQL 查询结果自动映射到指定的 Java 对象。

3、有关MyBatis工作原理说法错误的是（C）。

A、MyBatis的全局配置文件配置了MyBatis的运行环境等信息，其中主要内容是获取数据库连接

B、MyBatis映射文件中配置了操作数据库的SQL语句，需要在MyBatis的全局配置文件中加载才能执行

C、可以通过MyBatis的环境等配置信息构建会话对象SqlSession

D、SqlSession对象，该对象中包含了执行SQL的所有方法

MyBatis 的工作原理是先封装 SQL，接着调用 JDBC 操作数据库，最后把数据库返回的表结果封装成 Java 类。所以 C 选项说法是错误的，因为 MyBatis 的环境等配置信息是用于构建会话工厂 SqlSessionFactory，而不是会话对象 SqlSession。

4、下面关于映射文件中的元素的属性，说法正确的是（B）。

A、parameterType属性的值表示的是返回的实体类对象

B、namespace属性的值通常设置为对应实体类的全限定类名

C、resultType属性的值表示传入的参数类型

D、以上说法都不正确

元素是映射文件的根元素，其他元素都是它的子元素。它包含一个 namespace 属性，该属性为这个指定了唯一的命名空间，通常设置为对应实体类的全限定类名。所以 B 选项说法是正确的。

5、下面关于MyBatis框架的说法，正确的是（A）。

A、MyBatis是一个半自动映射的框架，这里所谓的“半自动”是相对于Hibernate全表映射而言的

B、MyBatis 是一个业务逻辑层的框架

C、MyBatis的封装性要比Hibernate高

D、MyBatis是一个全表映射的框架

MyBatis 是一个半自动映射的框架，它内部封装了 JDBC，开发时只需要关注 SQL 语句本身，不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。程序员直接编写原生态 sql，可以严格控制 sql 执行性能，灵活度高。这里所谓的“半自动”是相对于 Hibernate 全表映射而言的。所以 A 选项说法是正确的。

6、以下关于元素及其属性说法错误的是（C）。

A、元素用来映射查询语句，它可以帮助我们从数据库中读取出数据，并组装数据给业务开发人员

B、parameterType属性表示传入SQL语句的参数类的全限定名或者别名

C、resultMap表示外部resultMap的命名引用，返回时可以同时使用resultType和resultMap

D、在同一个映射文件中可以配置多个< select >元素

parameterType 属性表示传入 SQL 语句的参数类的全限定名或者别名。resultMap 属性表示外部 resultMap 的命名引用，用来将查询结果映射为目标对象。resultType 属性表示返回的结果类型，可以是类的全限定名或者别名。在同一个映射文件中可以配置多个< select >元素。所以 C 选项说法是错误的，因为返回时不能同时使用 resultType 和 resultMap，只能二选一。

7、下列元素中，可以为POJO实体类设置别名的是（A）。

A、 < typeAliases >元素

B、 < settings >元素

C、 < mappers >元素

D、 < properties >元素

在 MyBatis 中，可以使用 < typeAliases > 元素为 POJO 实体类设置别名。该元素用于定义别名与类之间的映射关系，可以简化配置文件中的类名引用。

B、< settings >元素用于配置 MyBatis 的全局设置，例如开启二级缓存、设置超时时间等，并不用于设置别名。

C、< mappers >元素用于配置映射器（Mapper）的位置，告诉 MyBatis 在哪里寻找映射器配置文件，也不用于设置别名。

D、< properties >元素用于定义属性配置，例如数据库连接信息等，并不用于设置别名。

8、关于SqlSession对象的查询方法返回的结果类型，正确的是（B）。

A、泛型对象的Set集合

B、泛型对象的List集合

C、泛型对象的Map集合

D、以上都对

SqlSession对象的查询方法通常返回泛型对象的List集合作为查询结果。这是因为查询方法通常返回多条记录，使用List集合可以容纳多个对象。

A、泛型对象的Set集合是不正确的。尽管在某些情况下可以使用Set集合作为查询结果类型，但通常情况下，SqlSession对象的查询方法返回的是List集合。

C、泛型对象的Map集合也是不正确的。虽然可以通过配置返回Map集合的查询结果，但通常情况下，SqlSession对象的查询方法返回的是List集合。

因此，正确答案是 B、泛型对象的List集合。

9、以下有关MyBatis映射文件中元素说法正确的是（C）。

A、< insert >元素用于映射插入语句，在执行完元素中定义的SQL语句后，没有返回结果

B、< insert >元素的属性与< select >元素的属性相同

C、keyColumn属性用于设置第几列是主键，当主键列不是表中的第一列时需要设置

D、useGeneratedKeys（仅对insert有用）此属性会使MyBatis使用JDBC的getGeneratedKeys()方法来获取由数据库内部生成的主键

< insert >元素用于映射插入语句，在执行完元素中定义的 SQL 语句后，返回一个表示插入记录数的整数。< insert >元素的属性与< select >元素的属性大部分相同，但还包含了三个特有属性：useGeneratedKeys、keyProperty 和 keyColumn。useGeneratedKeys 属性表示是否使用 JDBC 的 getGeneratedKeys() 方法来获取由数据库内部生成的主键，仅对 insert 有用。keyProperty 属性表示将主键值赋值给 POJO 类的哪个属性，通常会设置为 id 对应的属性。keyColumn 属性表示第几列是主键，当主键列不是表中的第一列时需要设置。所以 C 选项说法是正确的，其他选项都是错误的

10、有关MyBatis配置文件中< settings >元素的说法错误的是（C）。

A、< settings >元素中可以开启二级缓存

B、< settings >元素中可以开启延迟加载

C、< settings >元素中延迟加载的全局开关的参数lazyLoadingEnabled默认开启

D、< settings >元素中可以开启关联对象属性的延迟加载

< settings > 元素中可以开启二级缓存、延迟加载、关联对象属性的延迟加载等功能。元素中延迟加载的全局开关的参数 lazyLoadingEnabled 默认是关闭的，需要手动设置为 true 才能开启。所以 C 选项说法是错误的，其他选项都是正确的。

11、假设有一个名称为UserMapper的XML文件，下列关于使用类路径引入映射文件的示例代码正确的是（A）。

A、<mappers><mapper resource="com/itheima/mapper/UserMapper.xml"/></mappers>

B、<mappers><mapper resource="com/itheima/mapper/UserMapper"/></mappers>

C、<mapper resource="com/itheima/mapper/UserMapper.xml"/>

D、以上说法都不正确

在 MyBatis 中，可以使用 <mappers> 元素来配置映射器（Mapper）的位置。其中，<mapper> 元素用于指定映射文件的位置。

选项 A 中的示例代码使用了类路径引入映射文件的方式，指定了映射文件的资源路径为 com/itheima/mapper/UserMapper.xml。这样配置后，MyBatis 将会从类路径下寻找该映射文件并加载。

选项 B 的示例代码中省略了 .xml 后缀，这是不正确的，MyBatis 默认会寻找 .xml 后缀的映射文件。

选项 C 中缺少了 <mappers> 元素，因此也是不正确的。

12、下面关于Java对象之间的关联关系描述正确的是（B）。

A、一对一的关系就是在本类和对方类中定义同一个类型的对象

B、一对多的关系：就是一个A类类型对应多个B类类型的情况

C、多对多的关系只需要在一方的类中引入另一方类型的集合

D、多对多关联关系需要在本类中引入本类的集合

A、一对一的关系就是在本类和对方类中定义同一个类型的对象。这个说法是不正确的。一对一的关系是指一个对象与另一个对象之间存在唯一的关联关系，而不是本类和对方类中定义相同类型的对象。

B、一对多的关系：就是一个A类类型对应多个B类类型的情况。这个说法是正确的。一对多的关系是指一个对象与多个对象之间存在关联关系，一个对象可以对应多个相关对象。

C、多对多的关系只需要在一方的类中引入另一方类型的集合。这个说法是不正确的。多对多的关系是指多个对象之间相互关联的情况，需要在两个相关类中都引入对方类型的集合来表示彼此的关联关系。

D、多对多关联关系需要在本类中引入本类的集合。这个说法是不正确的。多对多关联关系需要在两个相关类中都引入对方类型的集合，而不是在本类中引入本类的集合。

13、下列关于MyBatis映射文件中加载关联关系对象的方式说法正确的是（B）。

A、嵌套结果是指通过执行另外一条SQL映射语句来返回预期的复杂类型

B、嵌套结果是使用嵌套结果映射来处理重复的联合结果的子集

C、嵌套查询是使用嵌套结果映射来处理重复的联合结果的子集

D、以上说法都正确

MyBatis 映射文件中加载关联关系对象的方式主要有两种，分别是嵌套查询和嵌套结果。其中，嵌套查询是指在当前查询语句中嵌套另外一条查询语句，从而获取关联对象的信息，而嵌套结果则是通过嵌套结果映射来处理重复的联合结果的子集，这样就能够避免产生重复对象的问题，提高查询效率。因此，选项 B 描述正确。

14、在Java中，以下有关类的关联关系描述错误的是（A）。

A、在Java中，通过对象也可以进行关系描述，他们分别为一对一、一对多、多对一和多对多

B、一对一的关系就是在本类中定义对方类型的对象

C、一对多的关系就是一个A类类型对应多个B类类型的情况，需要在A类中以集合的方式引入B类类型的对象，在B类中定义A类类型的属性a

D、多对多的关系：在A类中定义B类类型的集合，在B类中定义A类类型的集合。

A、在Java中，通过对象也可以进行关系描述，他们分别为一对一、一对多、多对一和多对多 这句话描述错误。在Java中，通过对象进行关系描述时，常用的关系类型包括一对一、一对多、多对一，而多对多通常需要通过中间表来实现。

1、如果一个项目有多个映射文件，则mybatis-config.xml核心配置文件中需要在<mappers>元素下配置多个<mapper>元素指定映射文件的路径。（√）

如果一个项目有多个映射文件，那么在 MyBatis 的核心配置文件 mybatis-config.xml 中，可以在 <mappers> 元素下配置多个 <mapper> 元素来指定映射文件的路径。每个 <mapper> 元素都会引入一个映射文件，并将其加入到 MyBatis 的映射器中。这样，MyBatis 就能够找到并加载这些映射文件中定义的映射语句和映射器接口。

2、MyBatis映射文件中<mappers>元素是配置文件的根元素，它包含一个namespace属性，该属性为这个<mappers>指定了唯一的命名空间。（×）

MyBatis映射文件中的 <mappers> 元素并不是配置文件的根元素，而是作为配置文件的子元素存在。

在 MyBatis 的映射文件中，根元素通常是 <mapper> 元素。而 <mappers> 元素是用于组织多个映射文件的容器元素。它可以包含多个 <mapper> 元素，每个 <mapper> 元素对应一个映射文件。

<mappers> 元素没有 namespace 属性来指定命名空间，它的主要作用是用于配置多个映射文件的路径。每个 <mapper> 元素可以有一个 resource 属性或者 url 属性来指定映射文件的位置。

所以，正确的说法是：MyBatis映射文件中的 <mappers> 元素不是配置文件的根元素，它用于组织多个映射文件，而不包含 namespace 属性来指定命名空间。

3、在传统JDBC编程中，SQL变动需要改变Java代码，违反了开闭原则。（√）

在传统的 JDBC 编程中，SQL 的变动通常需要修改 Java 代码，将新的 SQL 语句硬编码到代码中。这导致了 SQL 和 Java 代码的强耦合性，一旦 SQL 发生变动，就需要修改 Java 代码，违反了开闭原则（Open-Closed Principle）。

开闭原则是面向对象设计中的一个重要原则，它要求软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。也就是说，应该通过扩展来实现新功能，而不是通过修改已有的代码。

ORM 框架（如 MyBatis）的出现就是为了解决传统 JDBC 编程中 SQL 变动需要修改 Java 代码的问题。ORM 框架将 SQL 语句配置在映射文件中，通过配置和映射的方式来实现 SQL 和 Java 代码的解耦，从而遵循了开闭原则。这样，在 SQL 发生变动时，只需要修改映射文件，而不需要修改 Java 代码，提高了代码的可维护性和扩展性。

4、软件框架是一种通用的、可复用的软件环境，它提供特定的功能，促进软件应用、产品和解决方案的开发工作。（√）

软件框架是一种通用的、可复用的软件环境，它提供了特定的功能和结构，以促进软件应用、产品和解决方案的开发工作。框架通常包含了一组已经实现的通用功能模块、设计模式、规范和约定，开发人员可以基于框架进行开发，从而提高开发效率、降低开发复杂度。

框架通过提供预定义的结构、组织和约束，引导开发人员按照一定的规范进行开发，并提供了一些常见功能的实现，如数据库访问、用户认证、日志记录等，从而减少了重复劳动，加快了开发速度。开发人员可以在框架的基础上进行定制和扩展，以满足具体的业务需求。

因此，软件框架确实是提供特定功能、促进软件开发的重要工具和环境。

5、软件框架会包含支撑程序、编译器、代码、库、工具集以及API，它把所有这些部件汇集在一起，以支持项目或系统的开发。（√）

软件框架确实可以包含一些支撑程序、编译器、库、工具集以及 API，但这并不是框架的必备组成部分。框架的核心目标是提供特定的功能和结构，而这些组成部分可能只是框架的一部分，用于辅助开发过程。

6、SqlSessionFactory对象的openSession()方法的参数为boolean值时，默认为false。（×）

SqlSessionFactory对象的openSession()方法可以接受一个boolean类型的参数，用于指定是否自动提交事务。当该参数为true时，表示自动提交事务；当该参数为false时，表示不自动提交事务。

默认情况下，openSession()方法的参数为false，即不自动提交事务。如果希望在打开会话时自动提交事务，可以显式地将参数设置为true。

7、元素的flushCache属性可以指定是否需要MyBatis清空本地缓存和二级缓存，默认值为false。（√）

元素的flushCache属性用于指定是否需要清空缓存，默认情况下，其取值为false。当flushCache属性设置为true时，表示需要清空本地缓存和二级缓存；当flushCache属性设置为false时，表示不清空缓存。

需要注意的是，默认情况下，元素的flushCache属性并不会清空二级缓存，只会清空本地缓存。如果希望同时清空本地缓存和二级缓存，需要设置元素的flushCache属性为true。

8、SqlSessionFactory对象是线程安全的，一旦被创建，在整个应用程序执行期间都存在。（√）

SqlSessionFactory对象是线程安全的，它的创建是一个开销较大的操作，一旦创建完成后，可以被多个线程共享使用。在整个应用程序的执行期间，只需要创建一个SqlSessionFactory对象即可，然后通过该对象创建SqlSession实例。

由于SqlSessionFactory对象的创建是线程安全的，因此多个线程可以并发地共享同一个SqlSessionFactory对象，而不需要每个线程都创建一个新的对象。这样可以减少资源消耗，并提高性能。

需要注意的是，虽然SqlSessionFactory对象是线程安全的，但是SqlSession对象是非线程安全的，每个线程都应该拥有自己的SqlSession实例。

9、与<insert>元素一样，<update>和<delete>元素在执行完之后，也会返回一个表示影响记录条数的整数。（√）

与<insert>元素类似，<update>元素和<delete>元素在执行完毕后，也会返回一个表示影响记录条数的整数。这个整数表示执行更新或删除操作后所影响的数据库记录的数量。

这个整数可以通过调用相应的MyBatis方法来获取，比如调用update()方法或delete()方法执行相应的SQL语句后，可以通过返回的整数来判断执行操作的结果和影响的记录数。

10、当表中的列名与对应对象的属性名称完全一致时，在查询映射文件中可以不使用resultMap属性。（√）

在MyBatis的查询映射文件中，当表中的列名与对应对象的属性名称完全一致时，可以省略使用resultMap属性，但并非必须。

如果表中的列名与对象的属性名称完全一致，MyBatis会自动将查询结果映射到对象的对应属性上，无需显式定义resultMap。这是因为MyBatis采用了自动映射的机制，会根据列名和属性名的对应关系进行自动映射。

然而，如果存在一些特殊情况，比如表中的列名与对象的属性名称不完全一致，或者需要进行一些特殊的映射处理，就需要使用resultMap属性来定义映射规则。

Spring

1、下列有关Spring框架的描述，错误的是（D）。

A、Spring是一个提供了一站式服务的框架

B、Spring是轻量级框架

C、Spring是开源框架

D、Spring是持久层框架

Spring框架并不仅仅是一个持久层框架，它是一个综合性的框架，提供了包括依赖注入、面向切面编程、事务管理、Web开发等多个模块。其中，持久层框架是Spring框架的一部分，例如Spring Data JPA、Spring JDBC等，但它并不是Spring框架的唯一功能。

2、以下哪个选项不属于Spring的核心容器的组成模块（D）。

A、 Beans模块 B、 Core模块 C、 Context模块 D、 AOP模块

Spring的核心容器由以下几个模块组成： A. Beans模块：提供了IoC（控制反转）容器，用于管理和配置应用程序中的对象。 B. Core模块：提供了Spring框架的基本组件，包括依赖注入和依赖查找。 C. Context模块：建立在Beans和Core模块之上，提供了更高级的上下文支持，包括国际化、事件传播、资源加载等功能。

AOP模块（面向切面编程）不属于Spring的核心容器的组成模块，它是Spring框架的一个附加功能模块，用于实现横切关注点的模块化和重用。

3、下列选项中，用于给构造方法的参数注入值的是（C）。

A、<bean>

B、<property>

C、<constructor-arg>

D、<dependency>

在Spring配置文件中，可以使用"<constructor-arg>"标签来为Bean的构造方法参数注入值。该标签可以在<bean>标签内部使用，用于指定构造方法参数的值或引用。通过指定参数的值或引用，Spring容器会在实例化Bean时将相应的值传递给构造方法。

选项中的其他标签说明如下： A. "<bean>"标签用于定义一个Bean对象。 B. "<property>"标签用于设置Bean对象的属性值。 D. "<dependency>"标签不是Spring中的有效标签，它可能是一个错误的选项。

4、Spring容器默认的作用域是（D）。

A、prototype B、request C、session D、singleton

在Spring框架中，Bean的作用域定义了Bean实例的生命周期以及在应用程序中的可见性范围。默认情况下，Spring容器会将Bean的作用域设置为"singleton"，这意味着在整个应用程序的生命周期中，只会创建一个Bean的实例，并且该实例将被共享和重用。

其他选项的作用域说明如下： A. "prototype"作用域表示每次请求获取Bean时都会创建一个新的实例。 B. "request"作用域表示在每个HTTP请求中都会创建一个新的实例，在同一次请求内共享该实例。 C. "session"作用域表示在每个HTTP会话中都会创建一个新的实例，在同一个会话内共享该实例。

5、Spring的常用注解中，用于指定要自动装配的对象的注解是（A）。

A、@Autowired B、@Repository C、@Service D、@Controller

@Autowired注解用于自动装配Bean之间的依赖关系。当Spring容器遇到@Autowired注解时，它会尝试在容器中查找匹配的Bean，并将其自动注入到相应的字段、构造方法或Setter方法中。

其他选项的注解说明如下： B. "@Repository"注解用于标识持久层（DAO）组件。 C. "@Service"注解用于标识服务层（Service）组件。 D. "@Controller"注解用于标识控制器层（Controller）组件。

6、Spring容器中用于监控Bean对象初始化节点的注解是（A）。

A、@PostConstruct

B、@PreDestroy

C、@GetConstruct

D、@Destroy

“@PostConstruct"注解用于标记一个方法，在Bean对象初始化完成后执行。该注解可以用于初始化相关的操作，例如初始化资源、建立连接等。被”@PostConstruct"注解标记的方法将在依赖注入完成后，属性设置之后被自动调用。

选项中的其他注解说明如下： B. "@PreDestroy"注解用于标记一个方法，在Bean对象销毁之前执行。该注解可以用于释放资源、断开连接等操作。 C. "@GetConstruct"不是Spring容器中的有效注解。 D. "@Destroy"不是Spring容器中的有效注解。

7、在ApplicationContext接口实现类中从类路径加载配置文件,实例化ApplicationContext接口的类方法是（C）。

A、WebApplicationContext

B、AnnotationConfigApplicationContext

C、ClassPathXmlApplicationContext

D、FileSystemXmlApplicationContext

ClassPathXmlApplicationContext是一个实现了ApplicationContext接口的类，它可以从类路径加载XML格式的配置文件来创建和管理Spring容器。通过指定配置文件的路径，ClassPathXmlApplicationContext会在类路径中查找并加载相应的配置文件，并将其解析为Spring容器所需的Bean定义。

其他选项的说明如下： A. WebApplicationContext是用于在Web应用程序中创建和管理Spring容器的接口，与从类路径加载配置文件无关。 B. AnnotationConfigApplicationContext是通过注解配置来创建和管理Spring容器的实现类，也与从类路径加载配置文件无关。 D. FileSystemXmlApplicationContext是通过文件系统路径加载XML格式的配置文件来创建和管理Spring容器的实现类，不是从类路径加载配置文件。

8、在Spring的配置文件中，配置切面使用的元素是（B）。

A、< aop:config >

B、< aop:aspect >

C、< aop:advisor >

D、< aop:pointcut >

< aop:aspect >元素用于定义切面，它是配置Spring AOP切面的主要元素。切面定义了切点和通知（advice）的结合，它包含了一系列切点和与之关联的通知。

其他选项的说明如下： A. < aop:config >元素是用于配置全局的AOP设置和声明其他AOP相关的元素的容器。 C. < aop:advisor >元素用于配置通知和切点的组合，它可以将通知直接关联到切点。 D. < aop:pointcut >元素用于定义切点，它指定在哪些方法或连接点上应用通知。

9、下列选项中，用于配置异常通知的注解是（D）。

A、@After

B、@Around

C、@AfterReturning

D、@AfterThrowing

“@AfterThrowing"注解用于在方法抛出异常时执行的通知。它可以与其他通知注解（如@Before、@After、@Around）组合使用，用于在方法抛出异常时执行相应的逻辑。通过在方法上使用”@AfterThrowing"注解，可以捕获方法执行过程中抛出的异常并进行相应的处理。

其他选项的注解说明如下： A. "@After"注解用于配置最终通知，在方法执行后无论是否抛出异常都会执行。 B. "@Around"注解用于配置环绕通知，在方法执行前后都会执行，并可以控制方法的执行过程。 C. "@AfterReturning"注解用于配置返回通知，在方法执行后返回结果时执行

10、下列选项中，对CGLIB动态代理的说法错误的是（C）。

A、CGLIB动态代理采用底层的字节码技术，通过继承的方式动态创建代理对象

B、当需要为类创建代理对象时，就需要使用CGLib动态代理

C、CGLIB是一个高性能开源的代码生成包，在使用时需要另外导入CGLIB所需要的包

D、Spring AOP的实现机制分两种，一种是JDK动态代理，一种是CGLib动态代理

实际上，CGLIB是一个开源的代码生成库，不需要另外导入CGLIB所需要的包。它通过生成目标类的子类来实现代理，因此代理对象不需要实现特定的接口。

其他选项的说明如下： A. 正确。CGLIB动态代理通过继承的方式动态创建代理对象，采用底层的字节码技术生成代理类。 B. 部分正确。当需要为没有实现接口的类创建代理对象时，可以使用CGLIB动态代理。对于已实现接口的类，可以选择使用JDK动态代理。 D. 正确。Spring AOP的实现机制包括JDK动态代理和CGLIB动态代理两种方式。在目标类实现接口时，Spring使用JDK动态代理；在目标类没有实现接口时，Spring使用CGLIB动态代理。

11、下列选项中对JDK动态代理的描述，错误的是（A）。

A、JDK动态代理是通过java.lang.reflect.InvocationHandler 接口来实现的

B、使用JDK动态代理的对象必须实现接口

C、Spring中的AOP代理，可以是JDK动态代理，也可以是CGLIB代理

D、对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP

实际上，JDK动态代理是通过java.lang.reflect.Proxy类来实现的，而不是InvocationHandler接口。

其他选项的描述如下： B. 部分正确。使用JDK动态代理的对象必须实现接口，因为JDK动态代理是基于接口的代理机制。 C. 正确。Spring中的AOP代理既可以使用JDK动态代理，也可以使用CGLIB代理。具体使用哪种代理取决于被代理对象是否实现了接口。 D. 正确。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。

12、下列选项的Spring AOP的XML元素，用于在目标方法执行前实施增强，可以应用于权限管理等功能的是（A）。

A、< aop:before >

B、< aop:after >

C、< aop:around >

D、< aop:after-returning >

< aop:before >元素用于在目标方法执行前应用增强，它可以配置切点和通知，用于在目标方法执行前执行特定的逻辑。这可以用于实现诸如权限管理等功能，在方法执行前进行验证或授权操作。

其他选项的说明如下： B. < aop:after >元素用于在目标方法执行后应用增强。 C. < aop:around >元素用于在目标方法执行前后都可以应用增强，并具有更细粒度的控制能力。 D. < aop:after-returning >元素用于在目标方法执行后，并且方法成功返回后应用增强。

13、下列选项中，对基于注解方式的声明式事务描述错误的有（D）。

A、可以简化Spring配置文件中的代码

B、使用的是Spring提供的@Transactional注解

C、@Transactional可以标注在接口、接口方法、类或类方法上

D、@Transactional标注类时，该类的所有方法都将具有同样类型的事务属性

注解@Transactional可以标注在类或者方法上，但是只有标注在方法上才会生效，如果标注在类上，其效果将会被忽略。

14、下列选项中，关于事务管理方式相关说法错误的是（B）。

A、Spring中的事务管理分为两种方式：一种是传统的编程式事务管理，另一种是声明式事务管理

B、编程式事务管理：是通过AOP技术实现的事务管理，就是通过编写代码实现的事务管理，包括定义事务的开始、正常执行后的事务提交和异常时的事务回滚

C、声明式事务管理：其主要思想是将事务管理作为一个“切面”代码单独编写，然后通过AOP技术将事务管理的“切面”代码植入到业务目标类中

D、声明式事务管理最大的优点在于开发者无需通过编程的方式来管理事务，只需在配置文件中进行相关的事务规则声明，就可以将事务规则应用到业务逻辑中

编程式事务管理并不是通过AOP技术实现的事务管理，而是通过编写代码来实现的事务管理。它涉及到事务的开始、提交和回滚等操作，开发者需要显式地在代码中编写事务管理的逻辑。

1、控制反转（Inversion of Control，缩写为IoC）用来降低程序代码之间的耦合度。（√）

控制反转（Inversion of Control，缩写为IoC）是一种软件设计原则，用于降低程序代码之间的耦合度。它将对象的创建、依赖关系的管理和调用控制从应用程序代码中转移到框架或容器中。通过IoC，程序代码不再直接负责对象的创建和管理，而是由框架或容器负责创建和管理对象，并在需要时将它们注入到代码中。这样可以提高代码的可维护性、可测试性和灵活性，同时降低代码之间的耦合度。

2、Spring配置文件的名称可以自定义，通常在实际开发中，都会将配置文件命名为applicationContext.properties。（×）

通常情况下，Spring配置文件的名称是可以自定义的，没有强制要求使用特定的名称。虽然在实际开发中，我们经常将Spring配置文件命名为"applicationContext.xml"或者"applicationContext.yml"，但也可以选择其他名称，只要在使用时能够正确指定配置文件的路径即可。另外，文件扩展名也可以是其他支持的格式，如.properties、.json等，取决于使用的配置文件格式和Spring配置的方式。

3、依赖注入（DI）与控制反转（IoC）的含义不同，描述的不是同一个概念。（×）

依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IoC）是相关且紧密关联的概念，它们描述的是同一个概念的不同方面。

控制反转（IoC）是一种软件设计原则，它指的是将对象的创建、依赖关系的管理和调用控制从应用程序代码中转移到框架或容器中。框架或容器负责创建和管理对象，并在需要时将它们注入到代码中。这样做的目的是降低代码之间的耦合度，提高代码的可维护性和灵活性。

依赖注入（DI）是控制反转的一种具体实现方式。它指的是将一个对象所依赖的其他对象（即它的依赖）通过构造函数、属性或者方法参数的形式注入到对象中，而不是由对象自己负责创建或查找依赖的对象。通过依赖注入，对象的依赖关系由外部管理，对象只需要声明自己所需要的依赖，并由容器负责注入。

4、基于注解的装配可以较大程度上解决基于XML方式装配导致的配置文件臃肿和难以维护等问题。（√）

基于注解的装配可以使用更少的代码实现Bean的配置，减少了XML配置文件的臃肿程度，同时也可以更方便地理解和维护。

5、Spring容器支持XML和Properties两种格式的配置文件，在实际开发中，最常使用的就是Properties格式的配置方式。（×）

在实际开发中，最常用的是XML格式的配置文件，而不是Properties格式的配置文件。尽管Spring容器支持XML和Properties两种格式的配置文件，但XML格式更为灵活和强大，可以更好地表达复杂的配置结构和依赖关系。XML配置文件可以定义Bean的属性、依赖关系、切面配置等，并且提供了更多的扩展性和可读性。Properties格式的配置文件主要用于简单的键值对配置，通常用于一些简单的属性配置而不涉及复杂的依赖关系。因此，XML格式的配置文件是在实际开发中更常见和广泛使用的方式。

6、构造方法实例化是通过Bean对应类中默认的无参构造方法来实例化Bean。（√）

构造方法实例化是通过Bean对应类中默认的无参构造方法来实例化Bean。当使用构造方法实例化Bean时，Spring容器会调用Bean对应类的无参构造方法来创建实例。如果类中没有定义无参构造方法或者无参构造方法是私有的，那么实例化过程将会失败。需要注意的是，如果类中同时存在有参构造方法和无参构造方法，且没有进行额外配置，Spring容器将使用无参构造方法进行实例化。

7、JDK动态代理存在缺陷，它只能为接口创建代理对象，当需要为类创建代理对象时，就需要使用CGLib（Code Generation Library）动态代理。（√）

JDK动态代理只能为接口创建代理，不能为类创建代理。 另一方面，CGLib 使用字节码生成来为类和接口创建代理。

8、在AOP专业术语中，切面是指要对哪些Joinpoint进行拦截。（×）

在AOP专业术语中，切面（Aspect）是横切关注点的模块化，它包含了一个或多个通知（Advice），并且可以将通知应用到特定的Joinpoint上，来实现某种特定的功能。因此，切面不仅包括了要对哪些Joinpoint进行拦截，还包括了拦截后要执行的操作，即通知。

9、Spring声明式事务管理的两种实现方式中，基于注解的实现方式可以简化Spring配置文件中的代码避免冗余，要优于基于XML的实现方式。（√）

基于注解的声明式事务管理方式可以简化Spring配置文件中的代码，并避免了冗余的XML配置。通过在需要进行事务管理的方法或类上使用@Transactional注解，可以直接声明事务的属性，而无需在XML配置文件中为每个方法或类单独配置事务。这种方式更加简洁和便利，可以减少配置文件的复杂性和冗余，提高代码的可读性和维护性。相比之下，基于XML的实现方式需要在配置文件中明确指定每个方法或类的事务配置，相对来说更为繁琐。

10、TransactionStatus接口主要用于界定事务的状态，通常情况下，声明式事务中使用该接口较多。（×）

TransactionStatus接口并不是用于界定事务的状态，而是Spring框架中用于操作事务的接口。它提供了一系列方法，如判断事务是否完成、提交事务、回滚事务等。

在声明式事务中，通常不会直接使用TransactionStatus接口，而是通过事务管理器（如PlatformTransactionManager）来控制和管理事务。事务管理器会负责创建和操作TransactionStatus对象，并在事务方法的执行过程中处理事务的提交和回滚操作。

因此，TransactionStatus接口主要是在编程式事务管理中使用，用于手动控制和操作事务的状态。在声明式事务中，我们更多地关注事务管理器的配置和使用，而不是直接使用TransactionStatus接口。

Spring MVC

1、下列关于Spring MVC的执行流程，说法错误的是（D）。

A、用户通过浏览器向服务器发送请求，该请求会被DispatcherServlet前端控制器拦截

B、处理器映射器会生成处理器对象以及处理器拦截器返回给DispatcherServlet前端控制器

C、处理器适配器会调用并执行Controller类中的代码

D、Controller类中的代码执行完成后，会返回ModelAndView对象，该对象中只包含视图名

D、Controller类中的代码执行完成后，会返回ModelAndView对象，该对象不仅包含视图名，还包含数据模型。

2、下列元素中，可以在Spring MVC的配置文件中配置要扫描的包的是（C）。

A、< load-on-startup >元素

B、< url-pattern >元素

C、< context:component-scan >元素

D、< servlet-mapping >元素

C、< context:component-scan >元素可以在Spring MVC的配置文件中配置要扫描的包。该元素用于指定要扫描的包路径，使Spring容器能够自动扫描并注册带有特定注解的组件，如@Controller、@Service、@Repository等。通过配置< context:component-scan >元素，可以方便地将包中的组件纳入到Spring MVC的上下文中，以便进行请求处理和依赖注入等操作。

3、关于Spring MVC支持的RESTful风格描述错误的是（C）。

A、RESTful不是架构，只是另一种风格请求的URL

B、RESTful风格在HTTP请求中，通过GET 、POST 、PUT和DELETE 4个动词对应四种基本请求操作

C、RESTful风格也是一种规范，不可以打破

D、使用RESTful风格书写的路径，可以隐藏资源的访问行为。

REST（Representational State Transfer）是一种软件架构风格，强调以资源为中心，通过URL和HTTP方法来进行资源的访问和操作。RESTful风格并没有严格的规范要求，而是一种设计原则和最佳实践的集合。因此，开发人员可以根据实际需求和业务场景，自由地使用RESTful风格进行API的设计和实现。虽然有一些共识和约定，但并没有固定不可变的规范。

4、下列选项中，对于RequestMapping注解的作用说法正确的是（A）。

A、用于映射一个请求或一个方法

B、用于映射一个控制器类

C、用于映射请求参数

D、用于映射请求类型

RequestMapping注解用于映射一个请求或一个方法。RequestMapping注解可以应用于Controller类的方法上，用于指定处理请求的URL路径。通过在RequestMapping注解中指定的路径，可以将请求映射到相应的Controller方法进行处理。该注解还可以设置请求的HTTP方法、请求参数、请求头等属性，以更精确地匹配请求。因此，RequestMapping注解在Spring MVC中用于定义URL与方法的映射关系，实现请求的路由和处理。

5、下列选项中对Ant风格的通配符的说法错误的是（C）。

A、?可以匹配任何单字符。

B、*可以匹配0或者任意数量的字符。

C、/*/ant3可以匹配到路径/findAll/a/ant3

D、**：匹配0或者多级目录。

在Ant风格的通配符中，* 表示匹配任意字符（不包括路径分隔符），** 表示匹配任意路径（包括路径分隔符）。所以，/ * /ant3的意思是匹配一级路径下的任意字符，然后是/ant3，而不是匹配多级路径。因此，路径/findAll/a/ant3不能被/*/ant3所匹配。

6、下列选项中，对DispatcherServlet说法错误的是（B）。

A、DispatcherServlet是Spring MVC的流程控制中心，也称为Spring MVC的前端控制器

B、DispatcherServlet的本质是一个过滤器

C、DispatcherServlet拦截客户端的请求后会将请求转发到Spring MVC的其他组件

D、DispatcherServlet降低了Spring MVC组件之间的耦合性

DispatcherServlet是Spring MVC的流程控制中心，也称为Spring MVC的前端控制器。它是一个特殊的Servlet，负责拦截客户端的请求，并将请求转发到Spring MVC的其他组件，如处理器映射器、处理器适配器和控制器等。DispatcherServlet负责协调和控制整个请求处理流程，并将结果返回给客户端。

DispatcherServlet并不是一个过滤器，它是一个Servlet，通过Servlet容器进行管理和调用。与过滤器不同，DispatcherServlet具有更多的功能和责任，包括请求映射、处理器适配、视图解析、异常处理等。它是Spring MVC框架的核心组件之一，用于处理Web请求并提供灵活的请求处理机制。

7、下列选项中对Sping MVC的组合注解说法错误的是（D）。

A、组合注解简化了常用的HTTP请求方式的映射，并且更好的表达了被注解方法的语义

B、@GetMapping用于匹配GET方式的请求

C、@PostMapping用于匹配POST方式的请求

D、使用@GetMapping和使用@RequestMapping(method = RequestMethod.GET)限定请求方式的效果不一样

使用@GetMapping和使用@RequestMapping(method = RequestMethod.GET)是等效的，它们都用于匹配GET方式的请求。@GetMapping是Spring MVC 4.3版本及以上引入的组合注解，用于简化常用的HTTP GET请求的映射。而@RequestMapping(method = RequestMethod.GET)是更早版本的用法，也可以用于限定GET方式的请求。

两者的效果是一样的，都可以将方法映射到处理GET请求的路径上，并且限定了请求方式为GET。因此，它们的作用是相同的，只是使用方式上的差异，都可以用来实现相同的功能。

8、当Spring MVC方法的返回值为void类型，方法执行后会跳转到默认的页面。默认页面的路径拼接格式是（C）。

A、前缀+方法映射路径

B、方法映射路径+后缀

C、前缀+方法映射路径+后缀

D、方法映射路径

当Spring MVC方法的返回值为void类型时，方法执行后会根据默认的视图解析器进行视图解析，生成跳转页面的路径。默认的页面路径拼接格式是前缀+方法映射路径+后缀。具体的前缀和后缀可以通过配置视图解析器进行自定义，但通常情况下，前缀是"/WEB-INF/views/“，后缀是”.jsp"，因此最终的路径会是前缀+方法映射路径+后缀的形式。

例如，如果方法映射路径是"/home"，那么默认页面的路径将是"/WEB-INF/views/home.jsp"。这样的命名约定可以使视图解析器根据方法的映射路径自动寻找对应的视图页面，实现页面跳转。

9、下列关于Spring MVC数据绑定流程说法错误的是（C）。

A、Spring MVC将ServletRequest对象传递给DataBinder

B、Spring会将处理方法的入参对象传递给DataBinder

C、DataBinder调用BindingResult组件进行数据类型转换、数据格式化等工作

D、调用Validator组件对已经绑定了请求消息数据的参数对象进行数据合法性校验

在Spring MVC数据绑定流程中，数据绑定的核心是由DataBinder负责完成的。DataBinder负责将请求参数绑定到处理方法的入参对象上。它会根据入参对象的类型、字段的注解等信息，进行数据类型转换、数据格式化等操作。

BindingResult是用于封装数据绑定过程中的错误信息的组件，它通常与DataBinder配合使用。当数据绑定过程中发生错误时，BindingResult会记录错误信息，并返回给调用方进行处理。

Validator组件用于对已经绑定了请求消息数据的参数对象进行数据合法性校验。它可以根据自定义的校验规则对参数对象进行验证，并将验证结果存储到BindingResult中。

所以，正确的说法是DataBinder负责数据绑定，BindingResult负责错误信息的封装，Validator负责数据校验。

10、下列注解中，可以与JSON格式转换器结合将JSON格式数据绑定到方法形参中的是（A）。

A、@RequestBody

B、@RequestMapping

C、@RequestParam

D、@Controller

注解@RequestParam用于将请求中的参数值绑定到方法的形参上，适用于普通的请求参数绑定。

而注解@RequestBody用于将请求的JSON格式数据绑定到方法的形参上，适用于接收JSON格式的请求体数据。

11、下列关于Spring MVC常用的默认参数类型及说法错误的是（D）。

A、HttpServletRequest通过request对象获取请求信息

B、HttpServletResponse通过response处理响应信息

C、HttpSession通过session对象得到session中存放的对象

D、Model或ModelMap是一个接口，作用是将model数据填充到request域

Model和ModelMap接口的作用是用于向视图传递数据，而不是将model数据填充到request域。

正确的说法是Model和ModelMap接口用于在处理方法中设置数据，这些数据最终会被添加到视图中，用于呈现给用户。

12、下列选项，不是HandlerInterceptor接口中的方法的是（D）。

A、preHandler()

B、postHandle()

C、afterCompletion()

D、handler()

在HandlerInterceptor接口中，包含以下三个方法：

1. preHandle(HttpServletRequest request, HttpServletResponse response, Object handler): 在请求处理器执行之前调用，返回值决定是否继续执行后续的拦截器或请求处理器。可以用于进行权限验证、日志记录等操作。
2. postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView): 在请求处理器执行之后、视图渲染之前调用。可以修改视图层的模型数据或视图信息。
3. afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex): 在整个请求完成后调用，包括视图渲染完成和异常处理。通常用于进行资源清理或日志记录等收尾工作。

这三个方法提供了在请求处理过程中进行拦截和处理的机会，可以用于添加公共的处理逻辑、拦截非法请求等操作。

13、下列选项，对注解@ControllerAdvice的描述错误的是（D）。

A、注解作用在类上时可以增强Controller

B、该注解是Spring3.2中新增加的

C、该注解需要结合注解@ExceptionHandler才可以捕获Controller中抛出的指定类型的异常，从而实现不同类型的异常统一处理

D、该注解不需要结合注解@ExceptionHandler，同样可以捕获Controller中抛出的指定类型的异常，从而实现异常处理

@ControllerAdvice注解需要结合@ExceptionHandler注解使用，才能捕获Controller中抛出的指定类型的异常，实现统一的异常处理。

1、web.xml文件中，<load-on-startup>元素中的1表示在项目启动时会立即加载DispatcherServlet前端控制器。（√）

在 web.xml 文件中，<load-on-startup> 元素指定应用程序启动时应加载 servlet 的顺序。 通过将该值设置为 1，表示应在应用程序启动时立即加载和初始化 servlet（在本例中为 DispatcherServlet）。

2、在IDEA中使用插件运行Maven项目时，除了需要在pom.xml文件中配置对应的插件外，还需要在IDEA中进行项目运行的相关配置。（√）

使用插件在 IntelliJ IDEA 中运行 Maven 项目时，需要在 pom.xml 文件中配置相应的插件来定义构建和执行任务。 此外，您还需要在 IntelliJ IDEA 中配置项目运行配置，以指定 Maven 目标、命令行选项和其他项目特定设置，以便在 IDE 中运行 Maven 项目。

3、Spring MVC提供了对MVC模式的全面支持，它可以将表现层进行解耦，同时，Spring MVC是基于请求-响应处理模型的请求驱动框架，简化了表现层的实现。（√）

Spring MVC 提供了对 MVC（Model-View-Controller）模式的全面支持，它可以将应用程序的表现层进行解耦，使得开发者可以更好地管理和组织代码。Spring MVC 是一个基于请求-响应处理模型的请求驱动框架，它通过前端控制器（DispatcherServlet）来接收和分发请求，并将请求与相应的处理器（Controller）进行匹配，最终生成响应结果。Spring MVC 的设计思想和功能使得开发者可以相对轻松地实现和管理应用程序的表现层。

4、元素的子元素内容为“/”，表示项目在运行时，Spring MVC的前端控制器会拦截所有的请求URL，并交由DispatcherServlet处理。（√）

在 <servlet-mapping> 元素中，通过 <url-pattern> 子元素可以配置 DispatcherServlet 的拦截路径。当 <url-pattern> 的内容为 “/” 时，表示 DispatcherServlet 会拦截所有的请求 URL，包括根路径和子路径，然后将其交由 DispatcherServlet 进行处理。这样配置可以确保所有请求都经过 DispatcherServlet 的处理。

5、使用Maven的Tomcat插件运行Maven Web项目时，仍然需要将项目部署到本地Tomcat中。（×）

使用 Maven 的 Tomcat 插件可以方便地在 Maven 项目中进行 Tomcat 服务器的集成和部署，无需手动将项目部署到本地 Tomcat。通过配置 Maven 的 Tomcat 插件，可以直接在开发环境中运行和调试 Maven Web 项目，插件会自动将项目部署到内置的 Tomcat 服务器中。这样可以简化开发过程并提高效率。

6、只需要将@Controller注解标注在普通Java类上，然后通过Spring的扫描机制找到标注了该注解的Java类，该Java类就成为了Spring MVC的处理器类。（√）

将 @Controller 注解标注在普通 Java 类上只是定义了该类作为控制器类的角色，但它并不是直接成为 Spring MVC 的处理器类。要使得该类成为 Spring MVC 的处理器类，还需要满足以下条件：

1. 需要将该类纳入 Spring 的容器管理，可以通过 @ComponentScan 或 @Component 等注解来实现。
2. 需要定义处理器方法，即将请求映射到具体的方法上，可以使用 @RequestMapping 或其他的注解进行映射。
3. 处理器类的方法需要返回视图名称或视图对象。

7、@RequestMapping注解只能标注在方法上。（×）

@RequestMapping注解可以标注在类级别和方法级别上。当在类级别上标注时，它将为该类中的所有处理器方法指定基本的请求映射路径，并且可以在方法级别上进一步细化映射路径。

8、@RequestMapping的value属性中，可以指定映射单个的请求URL，也可以将多个请求映射到一个方法上。（√）

@RequestMapping注解的value属性用于指定请求映射的URL。我们可以指定单个的请求URL，还可以指定多个请求URL，将它们映射到同一个方法上。

9、在复杂POJO数据绑定时，如果数据需要绑定到POJO属性对象的属性中，客户端请求的参数名格式必须为“属性对象名称.属性”。（√）

在复杂的POJO数据绑定过程中，如果数据需要绑定到POJO属性对象的属性中，客户端请求的参数名格式必须符合"属性对象名称.属性"的格式。

10、@RequestParam注解的required属性用于指定参数是否必须，它的默认值为false。（×）

@RequestParam注解的required属性用于指定请求参数是否为必需的，默认情况下，它的值是true，表示请求参数必须存在。如果将required属性设置为false，表示请求参数是可选的，如果请求中没有提供该参数，Spring MVC 会将参数值设置为null。

11、当程序中配置了多个拦截器时，拦截器中的postHandle()方法和afterCompletion()方法按照拦截器的配置顺序执行。（√）

在Spring MVC中，多个拦截器可以通过配置实现，每个拦截器都可以有自己的preHandle()、postHandle()和afterCompletion()方法。当请求到达处理器方法之前，会按照配置的拦截器顺序调用每个拦截器的preHandle()方法。处理器方法执行完成后，会按照拦截器配置的逆序调用每个拦截器的postHandle()方法。最后，会按照拦截器配置的逆序调用每个拦截器的afterCompletion()方法。

这样的执行顺序保证了在请求前、请求后和视图渲染完成后可以进行相应的处理和清理工作。

简答题

MyBatis

1、MyBatis框架是一个ORM即（对象关系映射）框架。

2、JDBC中使用（preparedStatement）向占位符传参数时存在硬编码。

3、元素包含的（namespace）属性为这个<mapper>指定了唯一的命名空间。

4、通常每一个数据库都只创建一个SqlSessionFactory对象，因此在构建SqlSessionFactory对象时，建议使用（单例）模式。

5、在MyBatis中，通过（<association>）元素可以处理一对一关联关系。

6、默认状态下的（二级缓存）是可读/可写的缓存，这意味着对象检索不是共享的。

7、在关系型数据库中，表与表之间存在着三种关联映射关系，分别为一对一、一对多和（多对多）。

1、请列举5个MyBaits配置文件中的主要元素。

<properties>、<settings>、<typeAliases>、<environments>、<mappers>等元素。

2、请简述<properties>元素的使用方法。

1.先添加一个全名为db.properties的配置文件； 2.在MyBatis配置文件mybatis-config.xml中配置<properties… />元素，引入db.properties的配置文件； 3.在需要修改配置文件中通过${}的形式替换常量。

Spring

1、（构造方法）注入是指Spring容器调用构造方法注入被依赖的实例，构造方法可以是有参的或者是无参的。

2、（依赖注入）就是由IoC容器在运行期间动态地将某种依赖资源注入对象之中。

3、ClassPathXmlApplicationContext 从（类路径）加载配置文件，实例化 ApplicationContext 接口。

4、静态工厂实例化Bean需要使用factory-method属性来指定所创建的（静态工厂方法）。

5、（BeanFactory）是Spring容器最基本的接口，它的实现机制采用的是Java经典的工厂模式。

6、Spring AOP的常用实现方法有两种，分别是基于XML文件的实现和基于（注解）的实现。

7、JDBC连接数据库时需要4个基本属性，包括有（driverClassName）、url、username和password。

8、在具体的数据库操作中，DataSource还可以提供对数据库连接的缓冲池和（分布式事务）的支持。

1、请简述依赖注入和控制反转的概念。

在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转，这就是Spring的控制反转。 从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

2、请说出Spring 支持的 3 种作用域，及作用域作用的范围。

1.singleton（单例模式）：在单例模式下，Spring 容器中只会存在一个共享的 Bean 实例，所有对 Bean 的请求，只要请求的 id（或 name）与 Bean 的定义相匹配，就会返回 Bean 的同一个实例； 2.prototype（原型模式）：每次从容器中请求 Bean 时，都会产生一个新的实例；3.request：每一个 HTTP 请求都会有自己的 Bean 实例，该作用域只能在基于Web的Spring ApplicationContext中使用；4.session：每一个HttpSession请求都会有自己的 Bean 实例，该作用域只能在基于Web的Spring ApplicationContext中使用；global session：限定一个Bean 的作用域为Web应用（HttpSession）的生命周期，只有在Web应用中使用Spring时，该作用域才有效。

3、请说出4个AOP的专业术语，并进行解释。

1.切面（Aspect）：切面是指关注点形成的类，通常是指封装的、用于横向插入系统的功能类。 2.连接点（Joinpoint）：连接点是程序执行过程中某个特定的节点，在Spring AOP中，一个连接点通常是一个方法的执行。 3.切入点（Pointcut）：当某个连接点满足预先指定的条件时，AOP就能够定位到这个连接点，在连接点处插入切面，该连接点也就变成了切入点。 4.通知/增强处理（Advice）：通知/增强处理就是插入的切面程序代码。可以将通知/增强处理理解为切面中的方法，它是切面的具体实现。 5.目标对象（Target）：目标对象是指被插入切面的方法。 6.织入（Weaving）：将切面代码插入到目标对象上，从而生成代理对象的过程。 7.代理（Proxy）：将通知应用到目标对象之后，程序动态创建的通知对象，就称为代理。 8.引介（Introduction）：引介是一种特殊的通知，它为目标对象添加一些属性和方法。

4、简述Spring中事务管理的两种方式。

Spring中的事务管理分为两种方式：一种是传统的编程式事务管理，另一种是声明式事务管理。其中，编程式事务管理是通过编写代码实现的事务管理，包括定义事务的开始、正常执行后的事务提交和异常时的事务回滚。声明式事务管理是通过AOP技术实现的事务管理，其主要思想是将事务管理作为一个“切面”代码单独编写，然后通过AOP技术将事务管理的“切面”代码植入到业务目标类中。

Spring MVC

1、Spring MVC的三大组件分别是处理器映射器、（处理适配器）和视图解析器。

2、Spring MVC作用于三层架构中的（表现层），用于接收客户端的请求并进行响应。

3、在Spring MVC的执行过程中，Controller类的代码执行后，会返回一个（ModelAndView）对象。

4、组合注解（@GetMapping）用于匹配GET方式的请求。

5、当请求的映射方式是REST风格时，Spring MVC提供了（@PathVariable）注解进行简单类型数据绑定。

6、当发生客户端请求需要传递多个同名参数到服务器端的情况，可以使用（数组绑定）的方式来接收客户端的请求参数。

7、Spring MVC的响应方式可以分为页面跳转和（数据回写）两种。

8、根据请求参数类型和参数个数等数据信息的复杂程度，可以将Spring MVC中的数据绑定分为简单数据绑定和（复杂数据绑定）两类。

9、使用（@RestController）注解相当于@Controller和@ResponseBody这两个注解的结合。

1、请简述RequestMapping注解类型的作用及用法。

@RequestMapping 注解可以为 Handler 提供必要的映射信息，将请求的URL映射到具体的处理方法。该注解可以标注在方法和类上。 标注在方法上：该方法就成了一个可以处理客户端请求的Handler（处理器），它会在Spring MVC接收到对应的URL请求时被执行。 标注在类上：@RequestMapping的value属性值相当于本处理器类的命名空间，即访问该处理器类下的任意处理器都需要带上这个命名空间。

2、简述Spring MVC数据绑定的过程。

Spring MVC 数据绑定的过程： ① Spring MVC 将 ServletRequest 对象传递给 DataBinder（数据绑定组件）。 ② 将处理方法的入参对象传递给 DataBinder。 ③ DataBinder 调用 ConversionService 组件进行数据类型转换、数据格式化等工作，并将 ServletRequest 对象中的消息填充到参数对象中。 ④ 调用 Validator 组件对已经绑定了请求消息数据的参数对象进行数据合法性校验。 ⑤ 校验完成后会生成数据绑定结果 BindingResult 对象，Spring MVC 会将 BindingResult 对象中的内容赋给处理方法的相应参数。

3、简述拦截器HandlerInterceptor接口中的方法并做说明。

HandlerInterceptor接口中有3个方法： 1、preHandler()方法：该方法会在控制器方法前执行，其返回值表示是否中断后续操作。当其返回值为true时，表示继续向下执行；当其返回值为false时，会中断后续的所有操作。 2、postHandle()方法：该方法会在控制器方法调用之后，且解析视图之前执行。可以通过此方法对请求域中的模型和视图做出进一步的修改。 3、afterCompletion()方法：该方法会在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作

教材思考题

1、请简述什么是MyBatis。

MyBatis 是一个开源、轻量级的数据持久化框架，是 JDBC 和 Hibernate 的替代方案。 MyBatis 内部封装了 JDBC，简化了加载驱动、创建连接、创建 statement 等繁杂的过程，开发者只需要关注 SQL 语句本身。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

2、请简要介绍MyBatis的工作原理。

MyBatis的工作原理大致如下：

• MyBatis读取配置文件和映射文件，创建Configuration对象，存储配置信息和SQL语句。
• MyBatis通过Configuration对象创建SqlSessionFactory对象，用于生成SqlSession对象。
• SqlSession对象是MyBatis的核心接口，用于执行SQL语句和获取结果。
• SqlSession对象委托Executor接口执行SQL语句，Executor接口有两个实现类：BaseExecutor和CachingExecutor。
• Executor接口根据MappedStatement对象动态生成SQL语句，MappedStatement对象封装了SQL语句的id、参数、结果映射等信息。
• Executor接口利用StatementHandler、ParameterHandler、ResultSetHandler等组件完成SQL语句的预编译、参数设置、结果集处理等操作。
• Executor接口还负责管理一级缓存和二级缓存，提高查询效率。

1、请简述元素引入映射文件的4种方式。

<mappers>元素是MyBatis配置文件中用于指定映射文件的位置的元素，它有四种方式来引入映射文件，分别是：

• 使用<mapper>子元素的resource属性，指定映射文件的类路径相对资源，例如：

<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
</mappers>

• 使用子元素的url属性，指定映射文件的网络资源或本地磁盘资源，例如：

<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
</mappers>

• 使用<mapper>子元素的class属性，指定映射文件对应的Mapper接口的全限定类名，此时映射文件必须与接口位于同一路径下，并且名称相同，例如：

<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
</mappers>

• 使用子元素的name属性，指定映射文件对应的Mapper接口所在的包名，此时映射文件必须与接口位于同一路径下，并且名称相同，例如：

<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

2、请简述MyBatis映射文件中常用元素及其作用。

MyBatis映射文件中常用元素及其作用如下¹²：

• <mapper>：映射文件的根元素，用于定义命名空间和其他配置。
• <select>：用于定义查询语句，可以使用SQL语句，也可以使用自定义的标签。
• <insert>：用于定义插入语句，可以返回插入记录数或主键值。
• <update>：用于定义更新语句，可以返回更新记录数。
• <delete>：用于定义删除语句，可以返回删除记录数。
• <sql>：用于定义可重用的SQL代码片段，然后在其他语句中引用这一代码片段。
• <cache>：用于定义当前命名空间的缓存配置，可以设置缓存的类型、大小、清除策略等。
• <cache-ref>：用于引用其他命名空间的缓存配置，实现缓存的共享。
• <resultMap>：用于定义结果集映射，可以设置结果集的类型、属性、关联、集合等。

1、请简述MyBatis动态SQL中的常用元素及其作用。

MyBatis动态SQL中的常用元素及其作用如下：

• <if>：用于根据条件判断是否执行某个SQL片段，可以实现单条件分支判断。
• <choose>、<when>、<otherwise>：相当于Java中的switch…case…default语句，用于多条件分支判断，其中<choose>是容器元素，<when>是条件元素，<otherwise>是默认元素。
• <trim>、<where>、<set>：辅助元素，用于处理一些SQL拼装、特殊字符问题。<trim>可以自定义前缀、后缀和要忽略的内容；<where>可以在子元素返回内容时插入WHERE子句，并去除多余的AND或OR；<set>可以在子元素返回内容时插入SET子句，并去除多余的逗号。
• <foreach>：用于对集合进行遍历，可以实现批量插入、更新、删除等操作，也可以实现IN条件查询等功能。
• <bind>：用于创建一个变量，并将其绑定到当前的上下文中，可以用于OGNL表达式以外的地方。

2、请简述在使用< foreach >时，collection属性需要注意的几点。

在使用<foreach>时，collection属性需要注意的几点如下：

• collection属性是必须指定的，它表示要遍历的集合对象。
• collection属性的值根据传入参数的类型而不同，主要有以下三种情况：
  • 如果传入的是单参数且参数类型是一个List的时候，collection属性值为list。
  • 如果传入的是单参数且参数类型是一个array数组的时候，collection属性值为array。
  • 如果传入的参数是多个的时候，或者是单参数但封装成了Map的时候，collection属性值就是传入的List或array对象在Map里面的key。
• collection属性可以使用OGNL表达式来指定集合对象，例如collection="user.books"表示遍历user对象的books属性。

1、请简述< collection >子元素的常用属性及其作用。

<collection>子元素是<resultMap>元素的子元素，用于映射集合类型的属性，例如List或Set。<collection>子元素的常用属性及其作用如下：

• property：指定集合类型的属性名，必须与实体类中的属性名一致。
• ofType：指定集合中元素的类型，可以是基本类型或自定义类型。
• column：指定集合中元素的列名，如果是基本类型，可以直接使用该属性；如果是自定义类型，需要配合select或resultMap属性使用。
• select：指定一个查询语句的id，用于加载集合中的元素，该查询语句必须有一个参数，即column属性指定的列名。
• resultMap：指定一个结果映射的id，用于加载集合中的元素，该结果映射必须有一个构造器参数，即column属性指定的列名。

2、请简述MyBatis关联查询映射的两种处理方式。

MyBatis关联查询映射的两种处理方式如下：

• 嵌套查询：通过执行另一个SQL映射语句来返回关联数据，例如使用<association>或<collection>元素的select属性指定一个查询语句的id，该查询语句需要有一个参数，即关联列的值。这种方式会产生多次查询，可能影响性能。
• 嵌套结果：通过执行一个表关联查询SQL，然后将查询结果映射成关联对象，例如使用<association>或<collection>元素的resultMap属性指定一个结果映射的id，该结果映射需要有一个构造器参数，即关联列的值。这种方式只需要一次查询，但可能返回重复的数据。

1、请简述MyBatis的常用注解及其作用。

MyBatis的常用注解及其作用如下：

• @Mapper：用于标识一个接口是一个MyBatis的映射接口，可以被Spring扫描和管理。
• @MapperScan：用于扫描指定包下的MyBatis映射接口，可以指定多个包名或使用通配符。
• @Select：用于指定一个查询语句，可以直接写SQL或引用一个XML中的SQL。
• @Insert：用于指定一个插入语句，可以直接写SQL或引用一个XML中的SQL。
• @Update：用于指定一个更新语句，可以直接写SQL或引用一个XML中的SQL。
• @Delete：用于指定一个删除语句，可以直接写SQL或引用一个XML中的SQL。
• @SelectKey：用于指定一个查询语句来返回插入后的主键值，可以设置在插入前或插入后执行。
• @Options：用于设置一些操作选项，例如是否使用自动生成的主键，主键的属性名和列名等。
• @Result：用于指定一个字段与属性的映射关系，可以设置字段名，属性名，类型，是否是主键等。
• @Results：用于指定一个结果集与实体类的映射关系，可以包含多个@Result元素，可以设置一个唯一标识符。
• @ResultMap：用于引用一个已经定义的结果集映射关系，可以省略value属性。

2、请简述@Result注解中的常用属性及其作用。

@Result注解中的常用属性及其作用如下¹：

• column：用于指定数据库中的列名，可以作为参数传递给关联查询的方法。
• property：用于指定实体类中的属性名，可以与列名进行映射。
• javaType：用于指定属性的数据类型，可以省略如果与列名类型一致。
• jdbcType：用于指定列名的JDBC类型，可以省略如果与Java类型一致。
• id：用于标识是否是主键，可以设置为true或false，默认为false。
• one：用于指定一对一的关联查询，可以设置一个@One注解，其中包含一个select属性指定查询方法的id，以及一个fetchType属性指定加载策略（默认、立即或延迟）。
• many：用于指定一对多的关联查询，可以设置一个@Many注解，其中包含一个select属性指定查询方法的id，以及一个fetchType属性指定加载策略（默认、立即或延迟）。

1、请简述Spring框架的优点。

Spring框架的优点如下：

• 它可以方便地解耦，简化开发，使用基本的JavaBean代替EJB，并提供了更多的企业级功能。
• 它可以方便地集成各种优秀的框架，如Struts2、Hibernate、MyBatis等，并提供了对这些框架的直接支持。
• 它可以降低Java EE API的使用难度，对一些复杂的API如JDBC、JavaMail、远程调用等提供了封装，使得开发更加简单和高效。
• 它可以方便地进行程序的测试，支持JUnit4，并可以通过注解方便地测试Spring程序。
• 它可以提供AOP编程的支持，可以方便地实现对程序进行权限拦截、运行监控等功能。
• 它可以提供声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。

2、请简述控制反转的概念和依赖注入的概念。

控制反转和依赖注入的概念如下：

• 控制反转（IoC，Inversion of Control）是一种设计原则，它将对象的创建和管理交给了容器，而不是由程序员手动创建和管理。这样可以实现对象之间的解耦，降低代码的复杂性和耦合度。
• 依赖注入（DI，Dependency Injection）是一种实现控制反转的方式，它通过将依赖关系注入到对象中，来实现对象之间的解耦。依赖注入可以通过构造器、Setter方法或接口来实现，它不需要对象自己去查找或创建依赖的对象，而是由容器负责提供和维护。

1、请简述XML配置文件中的根元素<beans>中的常用元素及其作用。

XML配置文件中的根元素<beans>中的常用元素及其作用如下：

• <description>：用于放置一些描述信息，一般情况下，该元素是省略的。
• <import>：用于引入其他的XML配置文件，可以把配置文件按一定的规则拆分成几个文件，方便管理和复用。
• <alias>：用于给<bean>设置别名，为了减少输入或提高可读性。
• <bean>：用于定义一个Bean对象，是XML配置文件中最基本和重要的元素。它有多个属性，如id、name、class、scope等，用于指定Bean的唯一标识、名称、实现类和作用域等。
• <constructor-arg>：<bean>元素的子元素，用于通过构造器注入Bean的依赖对象或属性。它有多个属性，如index、type、value、ref等，用于指定构造器参数的序号、类型、值或引用等。
• <property>：<bean>元素的子元素，用于通过Setter方法注入Bean的依赖对象或属性。它有两个属性，name和value或ref，用于指定Bean实例中相应的属性名称和值或引用。
• <list>：<property>元素的子元素，用于封装List或数组类型的依赖注入。
• <map>：<property>元素的子元素，用于封装Map类型的依赖注入。
• <set>：<property>元素的子元素，用于封装Set类型的依赖注入。
• <entry>：<map>元素的子元素，用于设置一个键值对。

2、请简述Bean的几种装配方式的基本用法。

Bean的几种装配方式的基本用法如下：

• 基于XML的装配：Spring提供了两种基于XML的装配方式：设值注入（Setter Injection）和构造器注入（Constructor Injection）。设值注入要求Bean类必须提供一个无参构造方法和属性的setter方法，在配置文件中使用<property>元素为每个属性注入值。构造器注入要求Bean类必须提供有参构造方法，在配置文件中使用<constructor-arg>元素为参数注入值。
• 基于注解的装配：Spring提供了一些注解来标识Bean的作用域和依赖关系，如@Component, @Repository, @Service, @Controller, @Autowired, @Resource等。使用这些注解时，需要在配置文件中开启注解扫描< context:component-scan >或< context:annotation-config >，并指定要扫描的包路径。
• 自动装配：Spring可以根据Bean的类型或名称自动匹配依赖关系，无需显式配置。使用自动装配时，需要在配置文件中指定<bean>元素的autowire属性为byType或byName，或者使用@Autowired或@Resource注解。

1、请列举Spring AOP的术语并解释。

Spring AOP的术语有以下几个：

• 连接点（Joinpoint）：程序执行的某个特定位置，如类初始化前后，方法调用前后，方法抛出异常后等。Spring AOP只支持方法的连接点。
• 切点（Pointcut）：用于匹配连接点的条件，可以是类名，方法名，参数类型等。一个切点可以匹配多个连接点，一个连接点也可以被多个切点匹配。
• 通知（Advice）：织入到目标类连接点上的一段程序代码，可以在连接点之前，之后，之中或抛出异常时执行。Spring AOP有五种类型的通知：前置通知（Before），后置通知（After），返回通知（After-returning），异常通知（After-throwing）和环绕通知（Around）。
• 目标对象（Target）：被通知的对象，也就是被AOP代理的对象。目标对象只实现核心业务逻辑，而横切逻辑由AOP代理添加。
• 引介（Introduction）：一种特殊的通知，可以为目标对象添加一些属性和方法，让目标对象实现一些接口。
• 织入（Weaving）：将通知添加到目标对象的连接点上的过程。根据不同的实现技术，织入可以在编译期，类加载期或运行期进行。Spring AOP采用运行期织入，使用动态代理技术生成代理对象。
• 代理（Proxy）：一个类被AOP织入通知后产生的结果类，它是原类和通知逻辑的结合体。代理类可以是原类的子类，也可以是原类实现的接口的实现类。
• 切面（Aspect）：切面由切点和通知组成，它定义了在哪些连接点上执行哪些通知。Spring AOP就是负责实施切面的框架。

2、请列举AOP实现中Spring提供的注解并解释其作用。

AOP实现中Spring提供的注解有以下几个：

• @Aspect：用于标识一个类是切面类，包含切点和通知。
• @Pointcut：用于定义切点，可以使用表达式或模式指定匹配的连接点。
• @Before：用于定义前置通知，表示在目标方法执行前执行的增强逻辑。
• @After：用于定义后置通知，表示在目标方法执行后执行的增强逻辑，无论目标方法是否成功返回或抛出异常。
• @AfterReturning：用于定义返回通知，表示在目标方法成功返回后执行的增强逻辑。
• @AfterThrowing：用于定义异常通知，表示在目标方法抛出指定异常后执行的增强逻辑。
• @Around：用于定义环绕通知，表示在目标方法执行前后执行的增强逻辑，可以控制目标方法的执行和返回值。
• @EnableAspectJAutoProxy：用于开启AOP注解支持，可以在配置类上使用，也可以在XML配置文件中使用< aop:aspectj-autoproxy />元素。

1、请简述抽象类JdbcAccessor提供的一些访问数据库时使用的公共属性。

抽象类JdbcAccessor提供的一些访问数据库时使用的公共属性有以下几个：

• DataSource：其主要功能是获取数据库连接，具体实现时可以引入对数据库连接的缓冲池和分布事务的支持，可以作为访问数据库资源的标准接口。
• SQLExceptionTranslator：负责对SQLException进行转译工作，通过必要的设置或者获取SQLExceptionTranslator中的方法，可以使JdbcTemplate在需要处理SQLException时，委托SQLExceptionTranslator的实现类来完成相关的转译工作。

2、请简述Spring JDBC是如何进行配置的。

Spring JDBC是如何进行配置的有以下几个步骤：

• 引入相关的依赖，如spring-jdbc, spring-tx, mysql-connector-java等。
• 在配置文件中定义数据源Bean，指定数据库的驱动，url，用户名和密码等属性。
• 在配置文件中定义JdbcTemplate Bean，并注入数据源Bean。
• 在配置文件中定义需要使用JdbcTemplate的Bean，如Dao层的Bean，并注入JdbcTemplate Bean。
• 在Dao层的类中，使用JdbcTemplate提供的方法来执行SQL语句，如query, update, execute等。

1、请简述Controller注解的使用步骤。

Controller注解的使用步骤有以下几个：

• 在类上标注@Controller注解，表示该类是一个控制器类，可以处理多个请求。
• 在方法上标注@RequestMapping注解，指定请求的路径和方法，以及其他参数。
• 在Spring MVC的配置文件中开启注解扫描，指定要扫描的包名，如<context:component-scan base-package="com.example.controller"/>。
• 在方法中可以使用其他注解来绑定请求参数，如@RequestParam, @PathVariable, @RequestBody等。
• 在方法中可以返回ModelAndView对象，或者视图名，或者@ResponseBody注解的对象等。

2、请列举@RequestMapping注解的属性（至少3个）。

@RequestMapping注解的属性有以下几个：

• value：指定请求的URL路径，可以使用通配符或者占位符，也可以是一个数组。
• method：指定请求的方法，如GET, POST, PUT, DELETE等，也可以是一个数组。
• params：指定请求中必须包含或者不包含的参数，可以使用表达式，如params=“name”, params=“!age”, params="age=18"等。
• headers：指定请求中必须包含或者不包含的头信息，可以使用表达式，如headers=“Accept=text/html”, headers="!Referer"等。
• consumes：指定处理请求的提交内容类型（Content-Type），如consumes=“application/json”, consumes={“text/html”,“application/*”}等。
• produces：指定返回的内容类型，必须是请求头（Accept）中所包含的类型，如produces=“application/json”, produces={“text/plain”,“application/*”}等。

1、请简述简单数据类型中的@RequestParam注解及其属性的作用。

@RequestParam注解是Spring MVC中用来处理HTTP请求参数的注解之一。它可以绑定HTTP请求中的参数值到方法的参数上。当使用@RequestParam注解时，Spring MVC将会根据请求参数的名字和方法参数的名字进行自动匹配，并将请求参数的值转换成方法参数的类型。

@RequestParam注解可以指定以下属性：

1. value：用于指定请求参数的名字。如果请求参数名和方法参数名相同，可以省略这个属性。
2. required：用于指定是否必须提供请求参数。默认值为true，表示必须提供请求参数。如果设置为false，表示请求参数可选。
3. defaultValue：用于指定请求参数的默认值。如果请求参数不存在或者值为空，就会使用默认值。

2、请简述复杂POJO类型绑定时的注意事项。

1. 属性匹配：Spring MVC会根据请求参数的名称和POJO对象的属性名称进行自动匹配，然后将请求参数的值绑定到对应的属性上。确保请求参数的名称和POJO对象的属性名称一致，或者使用@RequestParam注解显式指定参数名。
2. 构造函数或Setter方法：确保POJO对象有一个无参的构造函数或者提供相应的Setter方法，以便Spring MVC可以实例化对象并设置属性值。
3. Getter和Setter方法：确保POJO对象的属性具有正确的Getter和Setter方法，以便Spring MVC可以获取和设置属性的值。这些方法的命名和命名约定需要符合JavaBean规范。
4. 嵌套对象：如果POJO对象中包含其他嵌套对象，需要确保嵌套对象也满足上述注意事项，并且能够正确地进行属性匹配和数据绑定。
5. 数据格式转换：如果请求参数的数据类型与POJO对象的属性类型不匹配，需要进行数据格式转换。Spring MVC会自动尝试将请求参数的值转换为属性的类型，但可能会出现转换失败的情况。在这种情况下，可以使用自定义的类型转换器或格式化器来处理特定的数据转换需求。
6. 数据校验：对于复杂POJO对象，可能需要进行数据校验以确保数据的有效性和完整性。可以使用JSR 303规范的注解（例如@NotBlank、@NotNull等）或自定义的校验器来验证POJO对象的属性。
7. 异常处理：在数据绑定过程中，如果出现错误或异常，例如请求参数缺失、类型转换失败等，Spring MVC会抛出相应的异常。可以通过全局异常处理或局部异常处理来捕获和处理这些异常，以提供更好的用户体验和错误提示信息。

3、请简述@RequsetBody注解的作用。

@RequestBody注解是Spring MVC中的一个注解，用于指示方法参数应该绑定到HTTP请求的请求体上。它通常用于处理POST请求中的请求体数据，例如JSON或XML格式的数据。

当使用@RequestBody注解时，Spring MVC会将HTTP请求的请求体中的数据解析并转换成方法参数所需的类型，然后将其绑定到方法参数上。

@RequestBody注解的主要作用是将请求体中的数据转换为方法参数所需的对象或类型。它可以与各种类型一起使用，包括简单数据类型、自定义对象以及集合类型。

4、请简述包装POJO类型绑定时的注意事项。

1. 构造函数或Setter方法：包装POJO通常是一个具有单个属性的简单包装类，因此确保包装类有一个无参构造函数或提供相应的Setter方法，以便Spring MVC可以实例化对象并设置属性值。
2. Getter和Setter方法：确保包装POJO类的属性具有正确的Getter和Setter方法，以便Spring MVC可以获取和设置属性的值。这些方法的命名和命名约定需要符合JavaBean规范。
3. 数据格式转换：如果请求参数的数据类型与包装POJO对象的属性类型不匹配，需要进行数据格式转换。Spring MVC会自动尝试将请求参数的值转换为属性的类型，但可能会出现转换失败的情况。在这种情况下，可以使用自定义的类型转换器或格式化器来处理特定的数据转换需求。
4. 数据校验：对于包装POJO对象，可能需要进行数据校验以确保数据的有效性和完整性。可以使用JSR 303规范的注解（例如@NotBlank、@NotNull等）或自定义的校验器来验证包装POJO对象的属性。
5. 异常处理：在数据绑定过程中，如果出现错误或异常，例如请求参数缺失、类型转换失败等，Spring MVC会抛出相应的异常。可以通过全局异常处理或局部异常处理来捕获和处理这些异常，以提供更好的用户体验和错误提示信息。

5、请简述3种不同类型的Spring MVC方法返回值的区别。

在Spring MVC中，有三种不同类型的方法返回值，它们分别是：

1. 视图名称（String）：当方法返回一个String类型的值时，它被解释为视图的名称。Spring MVC会根据这个名称解析对应的视图，并将其渲染并返回给客户端。这种方式适用于传统的基于服务器端渲染的应用程序。
2. ModelAndView对象：当方法返回一个ModelAndView对象时，它表示包含视图名称和模型数据的对象。ModelAndView允许同时设置视图名称和模型数据，以便将数据传递给视图进行渲染。
3. 对象或集合类型（如JSON/XML）：当方法返回一个对象或集合类型时，Spring MVC会根据配置的消息转换器将其转换为相应的格式（如JSON或XML），并将其作为响应的主体返回给客户端。这种方式适用于基于客户端的前后端分离应用程序，使用RESTful风格的API。

6、请简述@ResponseBody注解的作用。

@ResponseBody注解的作用是：

• 将控制器方法的返回值，通过适当的转换器转换为指定的格式，如JSON或XML，然后写入到响应对象的body区域，返回给客户端。
• 该注解可以用在方法上或类上。如果用在类上，表示该类中的所有方法都会返回JSON或XML格式的数据。
• 该注解可以配合@RequestMapping注解的produces属性来指定返回的内容类型，如produces=“application/json”。
• 该注解可以省略视图解析器的步骤，直接将数据写入到输出流中。

1、请简述Spring MVC统一处理异常的3种方式。

Spring MVC统一处理异常的3种方式有：

• 使用@ExceptionHandler注解：该注解可以用在控制器方法上，用于处理同一个控制器中的指定异常或其子类。该注解可以指定要处理的异常类型，以及返回的视图名或响应体。
• 使用HandlerExceptionResolver接口：该接口可以用于自定义异常处理器，需要实现resolveException方法，该方法可以根据异常类型，请求和响应对象，返回一个ModelAndView对象。Spring MVC提供了一些实现类，如SimpleMappingExceptionResolver, DefaultHandlerExceptionResolver等。
• 使用@ControllerAdvice注解：该注解可以用在类上，表示该类是一个控制器通知类，可以定义一些全局的异常处理方法，使用@ExceptionHandler注解标注。该类需要被Spring扫描到，并且需要开启@EnableWebMvc注解或< mvc:annotation-driven />元素。

2、请简述单个拦截器和多个拦截器的执行流程。

单个拦截器的执行流程：

1. 在请求到达控制器方法之前，单个拦截器的preHandle方法会被调用。该方法可以进行一些前置处理，例如身份验证、日志记录等。如果该方法返回true，请求会继续向下执行；如果返回false，请求处理流程将被中断，不会继续执行控制器方法。

2. 如果存在视图返回，单个拦截器的postHandle方法会在控制器方法执行后、视图渲染前被调用。该方法可以对模型数据进行修改或添加额外的数据。它对视图的修改不会影响控制器方法的执行结果。

3. 视图渲染完成后，单个拦截器的afterCompletion方法会被调用。该方法可以进行一些后置处理，例如清理资源、记录日志等。它在整个请求处理流程完成后被调用，无论控制器方法的执行结果如何。

多个拦截器的执行流程：

1. 在请求到达控制器方法之前，按照配置的顺序依次调用每个拦截器的preHandle方法。如果有多个拦截器，它们的执行顺序是根据配置的顺序决定的。

2. 如果每个拦截器的preHandle方法都返回true，则请求会继续向下执行；如果有任何一个拦截器的preHandle方法返回false，请求处理流程将被中断，不会继续执行控制器方法。

3. 在控制器方法执行后、视图渲染前，按照相反的顺序依次调用每个拦截器的postHandle方法。即先调用最后一个拦截器的postHandle方法，然后依次向前调用。

4. 视图渲染完成后，按照相反的顺序依次调用每个拦截器的afterCompletion方法。即先调用最后一个拦截器的afterCompletion方法，然后依次向前调用。

总结起来，无论是单个拦截器还是多个拦截器，它们的执行流程都是在请求前、请求后和视图渲染完成后分别调用对应的方法。对于多个拦截器，它们的执行顺序由配置的顺序决定。拦截器可以在请求处理过程中进行前置处理、后置处理和资源清理等操作，以实现一些共享的、横切关注点的处理逻辑。

3、请简述上传表单需要满足的3个条件。

上传表单需要满足的3个条件有：

• form表单的method属性设置为post，表示使用POST方式提交数据；
• form表单的enctype属性设置为multipart/form-data，表示使用多部分的形式来编码表单数据；
• form表单中提供一个< input type=“file” name=“file” />的文件上传输入框，用于选择要上传的文件。

4、请简述如何解决中文文件名称下载时的乱码问题。

如何解决中文文件名称下载时的乱码问题有以下几个方法：

• 使用URLEncoder.encode方法对文件名进行编码，然后在响应头中设置Content-Disposition为attachment;filename=编码后的文件名。
• 使用new String(fileName.getBytes(“gbk”), “iso8859-1”)方法对文件名进行转码，然后在响应头中设置Content-Disposition为attachment;filename=转码后的文件名。
• 根据不同的系统和浏览器，选择合适的编码方式，如Windows系统下使用GBK编码，macOS系统下使用UTF-8-Mac编码等。

1、请简述SSM框架整合思路。

SSM框架整合思路是将Spring、Spring MVC和MyBatis这三个框架整合在一起，形成一个完整的Java Web开发框架。下面是SSM框架整合的主要思路：

1. 配置Spring：首先，配置Spring框架，包括创建Spring的配置文件（如applicationContext.xml）和配置Spring相关的依赖项。在配置文件中，可以定义数据源、事务管理器、扫描组件等。

2. 配置MyBatis：配置MyBatis框架，包括创建MyBatis的配置文件（如mybatis-config.xml）和映射文件（如Mapper.xml）。在配置文件中，可以定义数据库连接信息、映射器扫描器、插件等。

3. 整合Spring和MyBatis：在Spring配置文件中，引入MyBatis的配置文件，并配置MyBatis的SqlSessionFactory和MapperScannerConfigurer。通过配置SqlSessionFactory，将数据库连接、事务管理器和MyBatis的配置文件关联起来。通过配置MapperScannerConfigurer，指定Mapper接口的扫描路径。

4. 配置Spring MVC：配置Spring MVC框架，包括创建Spring MVC的配置文件（如spring-mvc.xml）和配置Spring MVC相关的依赖项。在配置文件中，可以定义视图解析器、处理器映射器、拦截器等。

5. 整合Spring和Spring MVC：在Spring配置文件中，引入Spring MVC的配置文件，并配置DispatcherServlet。通过配置DispatcherServlet，将Spring MVC的配置文件和Spring的配置文件整合在一起，使其能够协同工作。

6. 编写Controller和Service：在Spring MVC中编写Controller类，处理请求并调用Service层的方法。在Service层编写业务逻辑的实现。

7. 编写Mapper和实体类：编写Mapper接口，定义数据库操作的方法。编写实体类，映射数据库表的结构。

8. 配置数据源和事务管理器：在Spring配置文件中配置数据源，定义数据库连接信息。配置事务管理器，以支持事务操作。

9. 部署和运行：将整合后的项目部署到Web容器（如Tomcat）中，并启动容器运行项目。

通过以上的整合思路，SSM框架能够实现Spring作为容器管理对象、Spring MVC作为控制器处理请求、MyBatis作为持久层框架进行数据库操作的完整开发框架。每个框架都有自己的职责，通过整合能够发挥各自的优势，提高开发效率和代码的可维护性。

2、请简述SSM框架整合时，Spring整合MyBatis的配置文件中的配置信息（无须写代码，只简单描述所要配置的内容即可）。

在SSM框架整合时，Spring整合MyBatis的配置文件中需要配置以下信息：

1. 数据源配置：配置数据库连接的相关信息，包括数据库驱动类、数据库连接URL、用户名和密码等。

2. 事务管理器配置：配置事务管理器，用于管理数据库事务。可以选择适合的事务管理器，如Spring提供的DataSourceTransactionManager。

3. MyBatis的SqlSessionFactory配置：配置MyBatis的SqlSessionFactory，用于创建和管理SqlSession。需要指定数据源、MyBatis的配置文件位置（如mybatis-config.xml）以及Mapper接口所在的包路径。

4. MapperScannerConfigurer配置：配置Mapper接口的扫描器，用于自动扫描Mapper接口，并将其注册为Spring的Bean。需要指定Mapper接口所在的包路径。

5. MyBatis的配置文件配置：引入MyBatis的配置文件（如mybatis-config.xml），并进行相关的配置。在该配置文件中可以定义映射器扫描器、插件、缓存策略等。

6. Spring与MyBatis的整合配置：配置Spring和MyBatis的整合，将Spring的事务管理器和MyBatis的SqlSessionFactory关联起来。可以通过事务的Advice和AOP来实现事务的控制。

以上配置信息的目的是将Spring和MyBatis进行整合，使得Spring能够管理MyBatis的SqlSessionFactory和Mapper接口，并通过Spring的事务管理器实现对数据库事务的控制。这样可以在使用MyBatis进行数据库操作时，充分利用Spring的依赖注入、事务管理等功能，提高开发效率和代码的可维护性。