1、Mybatis

1.1 概念

  1. MyBatis 是一个持久层框架，实现了对JDBC操作的封装，主要用于简化JDBC<br />操作中的一些相对繁琐的步骤，例如参数的映射，结果集的映射等。可以简单快速地连接和操作数据库，同时把操作数据库的结果集封装为Java对象返回

1.2 Mybatis优点

Mybatis的优点：
(1)Mybatis对JDBC进行封装，在实际开发中不用花费时间和精力去处理对数据库连接等的处理；
(2)Mybatis自身支持连接池，也可以配置其他的连接池，如c3p0、druid，提高了程序的效率；
(3)Mybatis是将SQL配置在mapper.xml文件中，当需求发生变更时只修改xml配置文件就可以了，类不需要重新编译。
(4)执行SQL后返回的ResultSet结果对象，Mybatis会帮我们处理，转换成Java对象，方便我们对结果的处理。

1.3 Mybatis架构

3--SSM基础重难点 - 图1

(1)sqlMapConfig.xml是Mybatis的核心配置文件，通过其中的配置可以生成SqlSessionFactory,也就是SqlSession工厂
(2)基于SqlSessionFactory可以生成SqlSession对象
(3)SqlSession是一个既可以发送SQL去执行，并返回结果，类似于JDBC中的Connection对象，也是Mybatis中至关重要的一个对象。
(4)Executor是SqlSession底层的对象，用于执行SQL语句
(5)MapperStatement对象也是SqlSession底层的对象，用于接收输入映射（SQL语句中的参数），以及做输出映射（即将SQL查询的结果映射成相应的结果）

1.4 底层原理

1、工作原理图
3--SSM基础重难点 - 图2

工作原理解析
mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（也可以用Java文件配置（注解）的方式，需要添加@Configuration）中构建出SqlSessionFactory（SqlSessionFactory是线程安全的）；
然后，SqlSessionFactory的实例直接开启一个SqlSession，再通过SqlSession实例获得Mapper对象并运行Mapper映射的SQL语句，完成对数据库的CRUD和事务提交，之后关闭SqlSession。
说明：SqlSession是单线程对象，因为它是非线程安全的，是持久化操作的独享对象，类似jdbc中的Connection，底层就封装了jdbc连接。

详细流程如下：
1、加载mybatis全局配置文件（数据源、mapper映射文件等），解析配置文件，MyBatis基于XML配置文件生成Configuration，和一个个MappedStatement（包括了参数映射配置、动态SQL语句、结果映射配置），其对应着、、、标签，都会被解析为一个MapperStatement对象。
Mapper接口里的方法，是不能重载的，因为是使用 全限名+方法名 的保存和寻找策略。Mapper 接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Mapper接口生成代理对象proxy，代理对象会拦截接口方法，转而执行MapperStatement所代表的sql，然后将sql执行结果返回。

10、Mybatis是如何进行分页的？分页插件的原理是什么？
Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。
分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。

11、Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？
第一种是使用标签，逐一定义数据库列名和对象属性名之间的映射关系。
第二种是使用sql列的别名功能，将列的别名书写为对象属性名。
有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

12、如何执行批量插入? 例子说明
首先,创建一个简单的insert语句:

insert into names (name) values (#{value})

然后在java代码中像下面这样执行批处理插入:
list names = new arraylist();
names.add(“fred”);
names.add(“barney”);
names.add(“betty”);
names.add(“wilma”);

13、如何获取自动生成的(主)键值?
insert 方法总是返回一个int值 ，这个值代表的是插入的行数。
如果采用自增长策略，自动生成的键值在 insert 方法执行完后可以被设置到传入的参数对象中。
示例：

insert into names (name) values (#{name})

name name = new name();
name.setname(“fred”);
int rows = mapper.insertname(name);
// 完成后,id已经被设置到对象中
system.out.println(“rows inserted = ” + rows);
system.out.println(“generated key value = ” + name.getid());

14、在mapper中如何传递多个参数?
（1）第一种：
Public UserselectUser(String name,String area);


（2）第二种： 使用 @param 注解:
public interface usermapper {
user selectuser(@param(“username”) string username,@param(“hashedpassword”) string hashedpassword);
}
然后,就可以在xml像下面这样使用(推荐封装为一个map,作为单个参数传递给mapper):


（3）第三种：多个参数封装成map
try{
//映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
//由于我们的参数超过了两个，而方法中只有一个Object参数收集，因此我们使用Map集合来装载我们的参数
Map map = new HashMap();
map.put(“start”, start);
map.put(“end”, end);
return sqlSession.selectList(“StudentID.pagination”, map);
}catch(Exception e){
e.printStackTrace();
sqlSession.rollback();
throw e; }
finally{
MybatisUtil.closeSqlSession();
}

15、Mybatis动态sql有什么用？执行原理？有哪些动态sql？
Mybatis动态sql可以在Xml映射文件内，以标签的形式编写动态sql，执行原理是根据表达式的值完成逻辑判断并动态拼接sql的功能。
Mybatis提供了9种动态sql标签：trim | where | set | foreach | if | choose | when | otherwise | bind。

16、Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？
答：、、、、，加上动态sql的9个标签，其中为sql片段标签，通过标签引入sql片段，为不支持自增的主键生成策略标签。

17、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？
不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；
原因就是namespace+id是作为Map的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

18、为什么说Mybatis是半自动ORM（对象映射模型）映射工具？它与全自动的区别在哪里？
Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

19、 一对一、一对多的关联查询 ？ 

  1. <mapper namespace="com.lcb.mapping.userMapper"> 
  2.     <!--association  一对一关联查询 --> 
  3.     <select id="getClass" parameterType="int" resultMap="ClassesResultMap"> 
  4.         select * from class c,teacher t where c.teacher_id=t.t_id and c.c_id=#{id} 
  5.     </select> 
  6.     <resultMap type="com.lcb.user.Classes" id="ClassesResultMap"> 
  7.         <!-- 实体类的字段名和数据表的字段名映射 --> 
  8.         <id property="id" column="c_id"/> 
  9.         <result property="name" column="c_name"/> 
  10.         <association property="teacher" javaType="com.lcb.user.Teacher"> 
  11.             <id property="id" column="t_id"/> 
  12.             <result property="name" column="t_name"/> 
  13.         </association> 
  14.     </resultMap> 
  16.     <!--collection  一对多关联查询 --> 
  17.     <select id="getClass2" parameterType="int" resultMap="ClassesResultMap2"> 
  18.         select * from class c,teacher t,student s where c.teacher_id=t.t_id and  c.c_id=s.class_id and c.c_id=#{id} 
  19.     </select> 
  20.     <resultMap type="com.lcb.user.Classes" id="ClassesResultMap2"> 
  21.         <id property="id" column="c_id"/> 
  22.         <result property="name" column="c_name"/> 
  23.         <association property="teacher" javaType="com.lcb.user.Teacher"> 
  24.             <id property="id" column="t_id"/> 
  25.             <result property="name" column="t_name"/> 
  26.         </association> 
  28.         <collection property="student" ofType="com.lcb.user.Student"> 
  29.             <id property="id" column="s_id"/> 
  30.             <result property="name" column="s_name"/> 
  31.         </collection> 
  32.     </resultMap> 
  33. </mapper>


20、MyBatis实现一对一有几种方式?具体怎么操作的？
有联合查询和嵌套查询,联合查询是几个表联合查询,只查询一次,通过在resultMap里面配置association节点配置一对一的类就可以完成；
嵌套查询是先查一个表，根据这个表里面的结果的 外键id，去再另外一个表里面查询数据,也是通过association配置，但另外一个表的查询通过select属性配置。

22、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，支持延迟加载的原理都是一样的。

23、Mybatis的一级、二级缓存:
一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存。
二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap 存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置 ；

24、什么是MyBatis的接口绑定？有哪些实现方式？
接口绑定，就是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定, 我们直接调用接口方法就可以,这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。
接口绑定有两种实现方式,一种是通过注解绑定，就是在接口的方法上面加上 @Select、@Update等注解，里面包含Sql语句来绑定；另外一种就是通过xml里面写SQL来绑定, 在这种情况下,要指定xml映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候,用注解绑定, 当SQL语句比较复杂时候,用xml绑定,一般用xml绑定的比较多。

25、使用MyBatis的mapper接口调用时有哪些要求？
①Mapper接口方法名和mapper.xml中定义的每个sql的id相同；
②apper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同；
③Mapper.xml文件中的namespace即是mapper接口的类路径。

27、简述Mybatis的插件运行原理，以及如何编写一个插件。
答：Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是InvocationHandler的invoke()方法，当然，只会拦截那些你指定需要拦截的方法。
编写插件：实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

1.7 个人经验总结

（1） foreach标签的使用（实现批量更新）

  1. <update id="updateClztByList">
  2.   update jyz_sjcs_bc
  3.   <set>
  4.     clzt = '2'
  5.   </set>
  6.   <where>
  7.     shxydm = #{shxydm} and bcrq in
  8.     <foreach collection="tenDates" item="item" open="(" close=")" separator=",">
  9.       #{item}
  10.     </foreach>
  11.   </where>
  12. </update>
  14. tenDates: @Param指定的list别名 item为list的每一个元素

2、Spring（★）

简述AOP、IOC
AOP面向切面：统一的给一些类似的方法加上同样的功能，比如日志、事务。是使用JDK动态代理来实现的。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。AOP作用：提供声明式事务、允许用户自定义切面。
IOC控制反转：控制反转是一种设计思想，DI(依赖注入)是实现IoC的一种方法，将对象的创建转移给SpringIOC容器控制，也就是说就是对象的创建，依赖都由Spring及配置文件控制。

2.1 Spring优点

1).方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。
2).AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，如性能监测、事务管理、日志记录等。
3).声明式事务的支持
4).方便集成各种优秀框架
5).降低Java EE API的使用难度，如对JDBC，JavaMail，远程调用等提供了简便封装

2.2 Spring架构

Spring 最初的目标就是要整合一切优秀资源,然后对外提供一个统一的服务。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：
3--SSM基础重难点 - 图3

1. 核心容器Spring Core 核心容器，提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式，将应用程序的配置和依赖性规范与实际的应用程序代码分开。
2. Spring Context Spring上下文，是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
3. Spring AOP 通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。可以很容易地使 Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring 的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，就可以将声明性事务管理集成到应用程序中。
4. Spring DAO JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
5. Spring ORM Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
6. Spring Web Web上下文模块建立在应用程序上下文模块之上，为基于Web 的应用程序提供了上下文。所以Spring 框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
7. Spring MVC框架 MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。


2.3 控制反转（IOC）

控制反转，就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。（spring容器是spring中的一个核心模块，用于管理对象）
只需要将类提前配置在spring配置文件中，就可以将对象的创建交给spring容器，当需要对象时，不需要自己创建，而是直接通过spring获取即可，省去了new对象，可以降低代码之间的耦合性。
IOC如何实例化对象？

Spring容器执行过程:
当tomcat服务器启动时会加载Spring容器的配置文件.当程序解析到Bean标签时.通过反射机制实例化对象.对象最终保存到了Spring容器自身维护的Map
知识点:反射机制调用对象的无参构造实例化对象.

2.4 DI依赖注入

依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。
简单来说，所谓的依赖注入其实就是，在创建对象的同时或之后，如何给对象的属性赋值。
set方式注入：
1、创建User类，声明name和age属性，并添加对应的setter和getter方法，以及toString方法
2、在applicationContext.xml中声明User类的bean实例
3、修改applicationContext.xml中User实例的声明，为User实例注入属性（或者在applicationContext.xml中，将UserInfo对象作为值，赋值给User对象的userInfo属性）

构造方法注入：
1、为User类声明构造函数
2、修改applicationContext.xml文件，将set方式修改为构造方法注入。

2.5 底层原理(常见面试题)**


5、BeanFactory 和 ApplicationContext 有什么区别？
BeanFactory 可以理解为含有 bean 集合的工厂类。BeanFactory 包含了种 bean 的定义，以便在接收到客户端请求时将对应的 bean 实例化。BeanFactory 还能在实例化对象时生成协作类之间的关系。此举将 bean 自身与 bean 客户端的配置中解放出来。BeanFactory 还包含了 bean 生命周期的控制，调用客户端的初始化方法（initialization methods）和销毁方法（destruction methods）。从表面上看，application context 如同 bean factory 一样具有 bean 定义、bean 关联关系的设置，根据请求分发 bean 的功能。但 application context 在此基础上还提供了其他的功能。
1.提供了支持国际化的文本消息
2.统一的资源文件读取方式
3.已在监听器中注册的 bean 的事件
以下是三种较常见的 ApplicationContext 实现方式：
1、ClassPathXmlApplicationContext：从 classpath 的 XML 配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。
ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);
2、FileSystemXmlApplicationContext ：由文件系统中的 XML 配置文件读取上下文。
ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);
3、XmlWebApplicationContext：由 Web 应用的 XML 文件读取上下文。

6、Spring 提供几种配置方式来设置元数据？
将 Spring 配置到应用开发中有以下三种方式：
1.基于 XML 的配置
2.基于注解的配置
3.基于 Java 的配置



8、如何用基于 Java 配置的方式配置 Spring？
Spring 对 Java 配置的支持是由@Configuration 注解和@Bean 注解来实现的。由@Bean注解的方法将会实例化、配置和初始化一个新对象，这个对象将由 Spring 的 IOC 容器来管理。@Bean 声明所起到的作用与 元素类似。被@Configuration 所注解的类则表示这个类的主要目的是作为 bean 定义的资源。被@Configuration 声明的类可以通过在同一个类的内部调用@bean 方法来设置嵌入 bean 的依赖关系。
9、怎样用注解的方式配置 Spring？
Spring 在 2.5 版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代 XML方式的 bean 描述，可以将 bean 描述转移到组件类的内部，只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在 XML 注入之前被处理，所以后者会覆盖掉前者对于同一个属性的处理结果。
注解装配在 Spring 中是默认关闭的。所以需要在 Spring 文件中配置一下才能使用基于注解的装配模式。如果你想要在你的应用程序中使用关于注解的方法的话，请参考如下的配置。




在标签配置完成以后，就可以用注解的方式在 Spring 中向属性、方法和构造方法中自动装配变量。
下面是几种比较重要的注解类型：
1.@Required：该注解应用于设值方法。
2.@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。
3.@Qualifier：该注解和@Autowired 注解搭配使用，用于消除特定 bean 自动装配的歧义。
4.JSR-250 Annotations ：Spring 支持 基于 JSR-250 注解 的以下 注解 ，@Resource、
@PostConstruct 和 @PreDestroy。

10**、**重点：Bean的生命周期

  1. 实例化bean对象(通过构造方法或者工厂方法)
  2. 设置对象属性(setter等)（依赖注入）
  3. 如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。
  4. 如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
  5. 将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法
  6. 调用Bean的初始化方法
  7. 将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法
  8. 使用Bean
  9. 容器关闭之前，调用Bean的销毁方法

注意：Spring默认机制是单例的


11、Spring Bean 作用域之间的区别？
Spring 容器中的 bean 可以分为 5 个范围。所有范围的名称都是自说明的，但是为了避免混淆，
还是让我们来解释一下：
1.singleton：这种 bean 范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个 bean 的实例，单例的模式由 bean factory 自身来维护。
2.prototype：原形范围与单例范围相反，为每一个 bean 请求提供一个实例。
3.request：在请求 bean 范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean 会失效并被垃圾回收器回收。
4.Session：与请求范围类似，确保每个 session 中有一个 bean 的实例，在 session 过期后，bean 会随之失效。
5.global-session：global-session 和 Portlet 应用相关。当你的应用部署在 Portlet 容器中工作时，它包含很多 portlet。如果你想要声明让所有的 portlet 共用全局的存储变量的话，那么这全局变量需要存储在 global-session 中。全局作用域与 Servlet 中的 session 作用域效果相同。


13、Spring 框架中的单例 Beans 是线程安全的么？
Spring 框架并没有对单例 bean 进行任何多线程的封装处理。关于单例 bean 的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的 Spring bean 并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。
最浅显的解决办法就是将多态 bean 的作用域由“singleton”变更为“prototype”。


14、请举例说明如何在 Spring 中注入一个 Java 集合？**
Spring 提供了以下四种集合类的配置元素：
1、该标签用来装配可重复的 list 值。
2、该标签用来装配没有重复的 set 值。
3、该标签可用来注入键和值可以为任何类型的键值对。
4、该标签支持注入键和值都是字符串类型的键值对。
下面看一下具体的例子：

  1. <beans>
  2.   <!-- Definition for javaCollection -->
  3.   <bean id="javaCollection" class="com.gupaoedu.JavaCollection">
  5.     <!-- java.util.List -->
  6.     <property name="customList">
  7.       <list>
  8.         <value>INDIA</value>
  9.         <value>Pakistan</value>
  10.         <value>USA</value>
  11.         <value>UK</value>
  12.       </list>
  13.     </property>
  15.     <!-- java.util.Set -->
  16.     <property name="customSet">
  17.       <set>
  18.         <value>INDIA</value>
  19.         <value>Pakistan</value>
  20.         <value>USA</value>
  21.         <value>UK</value>
  22.       </set>
  23.     </property>
  25.     <!-- java.util.Map -->
  26.     <property name="customMap">
  27.       <map>
  28.         <entry key="1" value="INDIA"/>
  29.         <entry key="2" value="Pakistan"/>
  30.         <entry key="3" value="USA"/>
  31.         <entry key="4" value="UK"/>
  32.       </map>
  33.     </property>
  34.     <!-- java.util.Properties -->
  35.     <property name="customProperies">
  36.       <props>
  37.         <prop key="admin">admin@gupaoedu.com</prop>
  38.         <prop key="support">support@gupaoedu.com</prop>
  39.       </props>
  40.     </property>
  41.  </bean>
  42. </beans>




17、请解释各种自动装配模式的区别？
在 Spring 框架中共有 5 种自动装配，让我们逐一分析。
1.no：这是 Spring 框架的默认设置，在该设置下自动装配是关闭的，开发者需要自行在 bean定义中用标签明确的设置依赖关系。
2.byName：该选项可以根据 bean 名称设置依赖关系。当向一个 bean 中自动装配一个属性时，容器将根据 bean 的名称自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这个属性，如果没找到的话就报错。
3.byType：该选项可以根据 bean 类型设置依赖关系。当向一个 bean 中自动装配一个属性时，容器将根据 bean 的类型自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这个属性，如果没找到的话就报错。
4.constructor：构造器的自动装配和 byType 模式类似，但是仅仅适用于与有构造器相同参数的bean，如果在容器中没有找到与构造器参数类型一致的 bean，那么将会抛出异常。
5.autodetect：该模式自动探测使用构造器自动装配或者 byType 自动装配。首先，首先会尝试
找合适的带参数的构造器，如果找到的话就是用构造器自动装配，如果在 bean 内部没有找到相
应的构造器或者是无参构造器，容器就会自动选择 byTpe 的自动装配方式。


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

20、在 Spring 中可以注入 null 或空字符串吗？
完全可以。


22、请举例解释@Autowired 注解？
@Autowired 注解对自动装配何时何处被实现提供了更多细粒度的控制。@Autowired 注解可
以像@Required 注解、构造器一样被用于在 bean 的设值方法上自动装配 bean 的属性，一个参数或者带有任意名称或带有多个参数的方法。
比如，可以在设值方法上使用@Autowired 注解来替代配置文件中的 元素。当 Spring 容器在setter 方法上找到@Autowired 注解时，会尝试用 byType 自动装配。
当然我们也可以在构造方法上使用@Autowired 注解。带有@Autowired 注解的构造方法意味着在创建一个 bean 时将会被自动装配，即便在配置文件中使用 元素。

23、请举例说明@Qualifier 注解？
@Qualifier 注解意味着可以在被标注 bean 的字段上可以自动装配。Qualifier 注解可以用来取消 Spring 不能取消的 bean 应用。
27**、Spring 框架中都用到了哪些设计模式？
Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：
1、代理模式—在 AOP 和 remoting 中被用的比较多。
2、单例模式：在 spring 配置文件中定义的 bean 默认为单例模式。
3、模板模式：用来解决代码重复的问题。
比如. RestTemplate, JmsTemplate, JpaTemplate。
4、委派模式：Spring 提供了 DispatcherServlet 来对请求进行分发。
5、工厂模式：BeanFactory 用来创建对象的实例，贯穿于 BeanFactory / ApplicationContext
接口的核心理念。
6、代理模式：AOP 思想的底层实现技术，Spring 中采用 JDK Proxy 和 CgLib 类库。

2.7 Spring事务管理

  1. 事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。这样可以防止出现脏数据，防止数据库数据出现问题。<br />    开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管 理，可以通过Spring的注入来完成此功能。<br />Spring支持如下两种方式的事务管理：<br />    编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，但很难维护。<br />    声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或者XML配置管理事务。<br />一般选择声明式事务管理，因为这种方式和应用程序的关联较少<br />（事务的注解为@Transactional）

2.8 AOP

2.8.1 概念

  1. AOP 是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少模块，一个模块有哪些对象，对象有哪些属性)，面向切面中包含一个一个动态过程（在对象运行时动态织入一些功能。）<br />AOP就是要在基于OCP(开闭原则)在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以控制对象的执行(例如添加日志、权限控制等)。

2.8.2 实现AOP

@Aspect 注解用于标识此类为一个AOP横切面对象
@Pointcut 注解用于定义本类中的切入点，本案例中切入点表达式用的是bean表达式，这个表达式以bean开头，bean括号中的内容为一个spring管理的某个bean对象的id。
@Around用于定义一个环绕通知（满足切入点表达式的核心业务方法执行之前和之后执行的一个操作）

在AOP编程中有五种类型的通知：
1） 前置通知 (@Before) 方法执行之前执行
2） 返回通知 (@AfterReturning) 方法return之后执行
3） 异常通知 (@AfterThrowing) 方法出现异常之后执行
4） 后置通知 (@After) : 又称之为最终通知(finally)
5） 环绕通知 (@Around) :重点掌握(优先级最高)

3--SSM基础重难点 - 图4

AOP总结：
1. AOP中环绕通知使用是最多.因为可以控制目标方法是否执行.
2. 除了环绕通知，另外四大通知类型 只做记录.不做修改.

2.9 单例模式和多例模式

什么是单例多例:
所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action;

如何产生单例多例:
在通用的SSH中，单例在spring中是默认的，如果要产生多例，则在配置文件的bean中添加scope=“prototype”;

为什么用单例多例：
之所以用单例，是因为没必要每个请求都新·建一个对象，这样子既浪费CPU又浪费内存；
之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；
用单例和多例的标准只有一个：
当对象含有可改变的状态时（更精确的说就是在实际应用中该状态会改变），则多例，否则单例；

何时用单例？何时用多例？
对于struts2来说，action必须用多例，因为action本身含有请求参数的值，即可改变的状态；
而对于STRUTS1来说，action则可用单例，因为请求参数的值是放在actionForm中，而非action中的；
另外要说一下，并不是说service或dao一定是单例，标准同第3点所讲的，就曾见过有的service中也包含了可改变的状态，同时执行方法也依赖该状态，但一样用的单例，这样就会出现隐藏的BUG,而并发的BUG通常很难重现和查找；

3、SpringMVC

3.1 概念

Springmvc是spring框架的一个模块，spring和springmvc无需中间整合层整合，
Springmvc是一个基于mvc的web框架

3.2 MVC设计模式

MVC设计模式是一种通用的软件编程思想
在MVC设计模式中认为, 任何软件都可以分为三部分组成：
(1)控制程序流转的控制器（Controller）
(2)封装数据处理数据的模型（Model）
(3)负责展示数据的视图（view）
并且在MVC设计思想中要求一个符合MVC设计思想的软件应该保证上面这三部分相互独立，互不干扰，每一个部分只负责自己擅长的部分。
如果某一个模块发生变化，应该尽量做到不影响其他两个模块。这样做的好处是，软件的结构会变得更加的清晰，可读性强。有利于后期的扩展和维护，并且代码可以实现复用。
3--SSM基础重难点 - 图5

3.3 SpringMVC执行原理（★）

3--SSM基础重难点 - 图6

(1).用户发送请求 至 前端控制器(DispatcherServlet)；
提示：DispatcherServlet的作用：接收请求，调用其它组件处理请求，响应结果，相当于转发器、中央处理器，是整个流程控制的中心
(2).前端控制器(DispatcherServlet)收到请求后调用处理器映射器(HandlerMapping)
处理器映射器(HandlerMapping)找到具体的Controller(可以根据xml配置、注解进行查找)，并将Controller返回给DispatcherServlet；
(3).前端控制器(DispatcherServlet)调用处理器适配器(HandlerAdapter)。处理器适配器经过适配调用具体的Controller；(Controller—> service —> Dao —> 数据库)
Controller执行完成后返回ModelAndView，
提示：Model(模型数据，即Controller处理的结果，Map) View(逻辑视图名，即负责展示结果的JSP页面的名字)
处理器适配器(HandlerAdapter)将controller执行的结果(ModelAndView)返回给前端控制器(DispatcherServlet)；
(4).前端控制器(DispatcherServlet)将执行的结果(ModelAndView)传给视图解析器(ViewReslover)
视图解析器(ViewReslover)根据View(逻辑视图名)解析后返回具体JSP页面
(5).前端控制器(DispatcherServlet)根据Model对View进行渲染（即将模型数据填充至视图中）；
(6).前端控制器(DispatcherServlet)将填充了数据的网页响应给用户。

其中整个过程中需要开发人员编写的部分有 Controller、Service、Dao、View；

3.4 常见面试题

1、什么是Spring MVC ？简单介绍下你对springMVC的理解?
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

2、SpringMVC的流程？（★）
（1）用户发送请求至前端控制器DispatcherServlet；
（2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
（3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
（4）DispatcherServlet 调用 HandlerAdapter处理器适配器；
（5）HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
（6）Handler执行完成返回ModelAndView；
（7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
（8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
（9）ViewResolver解析后返回具体View；
（10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
（11）DispatcherServlet响应用户。

3、Springmvc的优点:
（1）可以支持各种视图技术,而不仅仅局限于JSP；
（2）与Spring框架集成（如IoC容器、AOP等）；
（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。
（4）支持各种请求资源的映射策略。

4、Spring MVC的主要组件？
（1）前端控制器 DispatcherServlet（不需要程序员开发）
作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。
（2）处理器映射器HandlerMapping（不需要程序员开发）
作用：根据请求的URL来查找Handler
（3）处理器适配器HandlerAdapter
注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。
（4）处理器Handler（需要程序员开发）
（5）视图解析器 ViewResolver（不需要程序员开发）
作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）
（6）视图View（需要程序员开发jsp）
View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）


5、springMVC和struts2的区别有哪些?
（1）springmvc的入口是一个servlet即前端控制器（DispatchServlet），而struts2入口是一个filter过虑器（StrutsPrepareAndExecuteFilter）。
（2）springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
（3）Struts采用值栈存储请求和响应的数据，通过OGNL存取数据，springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl。

6、SpringMVC怎么样设定重定向和转发的？
（1）转发：在返回值前面加”forward:”，譬如”forward:user.do?name=method4”
（2）重定向：在返回值前面加”redirect:”，譬如”redirect:http://www.baidu.com“

7、SpringMvc怎么和AJAX相互调用的？
通过Jackson框架就可以把Java里面的对象直接转化成Js可以识别的Json对象。具体步骤如下 ：（springmvc底层会将结果封装成json格式返回）
（1）加入Jackson.jar
（2）在配置文件中配置json的映射
（3） 在接受Ajax方法里面可以直接返回Object,List等,但方法前面要加上@ResponseBody注解。


8、如何解决POST请求中文乱码问题，GET的又如何处理呢？
（1）解决post请求乱码问题：
在web.xml中配置一个CharacterEncodingFilter过滤器，设置成utf-8；
（2）get请求中文参数出现乱码解决方法有两个：
①修改tomcat配置文件添加编码与工程编码一致，如下：

②另外一种方法对参数进行重新编码：
String userName = new String(request.getParamter(“userName”).getBytes(“ISO8859-1”),”utf-8”)
ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。

9、Spring MVC的异常处理 ？
答：可以将异常抛给Spring框架，由Spring框架来处理；我们只需要配置简单的异常处理器，在异常处理器中添视图页面即可。

10、SpringMvc的控制器是不是单例模式,如果是,有什么问题,怎么解决？
答：是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。

11、 SpringMVC常用的注解有哪些？
@RequestMapping：用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都是以该地址作为父路径。
@RequestBody：注解实现接收http请求的json数据，将json转换为java对象。
@ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户。

12、SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代？
答：一般用@Conntroller注解,表示是表现层,不能用别的注解代替。

13、如果在拦截请求中，我想拦截get方式提交的方法,怎么配置？
答：可以在@RequestMapping注解里面加上method=RequestMethod.GET。

14、怎样在方法里面得到Request,或者Session？
答：直接在方法的形参中声明request,SpringMvc就自动把request对象传入。

15、如果想在拦截的方法里面得到从前台传入的参数,怎么得到？
答：直接在形参里面声明这个参数就可以,但必须名字和传过来的参数一样。

16、如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？
答：直接在方法中声明这个对象,SpringMvc就自动会把属性赋值到这个对象里面。

17、SpringMvc中函数的返回值是什么？
答：返回值可以有很多类型,有String, ModelAndView。ModelAndView类把视图和数据都合并的一起的，但一般用String比较好。

18、SpringMvc用什么对象从后台向前台传递数据的？
答：通过ModelMap对象,可以在这个对象里面调用put方法,把对象加到里面,前台就可以通过el表达式拿到。

19、怎么样把ModelMap里面的数据放入Session里面？
答：可以在类上面加上@SessionAttributes注解,里面包含的字符串就是要放入session里面的key。

20、SpringMvc里面拦截器是怎么写的：
有两种写法,一种是实现HandlerInterceptor接口，另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑；然后在SpringMvc的配置文件中配置拦截器即可：











21、注解原理：
注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象。通过代理对象调用自定义注解的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池。

4 SSM常见面试题

1、SpringMVC与Struts2的主要区别？
①springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
②springmvc是基于方法开发，传递参数是通过方法形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
③Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request对象内容进行解析成方法形参，将响应数据和页面封装成ModelAndView对象，最后又将模型数据通过request对象传输到页面。 Jsp视图解析器默认使用jstl。

2、Spring中用到哪些设计模式？
1.工厂模式（BeanFactory中）
2.单例模式（Spring中默认bean为单例）
3.适配器模式（HandlerAdater）
4.装饰者模式
5.代理模式（AOP中用到JDK动态代理）
6.观察者模式（listener的实现，例如ApplicationListener）
7.策略模式（定义一系列的算法，把它们一个个的封装起来，并且使它们可以相互替换。在实例化对象时用到）
8.模板模式（jdbcTemplate）

1.SpringMVC的工作流程?
1. 用户发送请求至前端控制器DispatcherServlet
2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4. DispatcherServlet通过HandlerAdapter处理器适配器调用处理器
5. 执行处理器(Controller，也叫后端控制器)。
6. Controller执行完成返回ModelAndView
7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9. ViewReslover解析后返回具体View
10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
11. DispatcherServlet响应用户

2.Spring在SSM起什么作用?
Spring是一个轻量级框架，也是一个容器，Spring实质上讲就是一个Bean工厂，主要用来管理Bean的生命周期和框架集成。有IOC控制反转，DI依赖注入，控制反转是把dao依赖注入到servic层，然后service层反转给action层，Spring的顶层容器为BeanFactory，常用的ApplicationContext为它的子接口，实现了工厂模式，Spring还提供了AOP的支持，方便在切面级开发，

3. 怎么样理解IOC和DI
在使用Spring框架的过程中、一定会用到控制反转、但是往往所需要的资源还需要其他资源的支持、这个过程就需要依赖注入的支持

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

5.Spring的IOC你在项目中是怎么使用的？
IOC主要来解决对象之间的依赖问题,把所有的bean的依赖关系通过配置文件或者注解关联起来,降低了耦合度

6.Spring的配置文件有哪些内容？
开启事务注解驱动
事务管理器
开启注解功能，并配置扫描包
配置数据源
配置SQL会话工厂、别名、映射文件
不用编写DAO层的实现类（代理模式）



8.Spring DI的几种方式?
(1)构造器注入：通过构造方法初始化

(2)setter注入：通过setter方法初始化注入

注意：在实际开发中常用setter注入。

9.@RequestMapping注解用在类上面有什么作用?
该注解是用来映射一个URL到一个类或一个特定的方处理方法上。

10.SpringMVC怎么样设定重定向和转发的
在返回值前面加”forward:”就可以让结果转发,譬如”forward:user.do?name=method4” 在返回值前面加”redirect:”就可以让返回值重定向,譬如”redirect:http://www.uu456.com”
11. MyBatis怎么配置一对多？
一对多的关系 ：property: 指的是集合属性的值, ofType：指的是集合中元素的类型

12. MyBatis怎样配置多对一？
多对一的关系：property: 指的是属性的值, javaType：指的是属性的类型

13.简单介绍下你对mybatis的理解？
1. mybatis配置
2. SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。
3. mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。
4. 通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂
5. 由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。
6. mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。
7. Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。
8. Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。
9. Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

14、springmvc是线程安全的吗**
springmvc是单例模式的框架,但它是线程安全的,因为springmvc没有成员变量,所有参数的封装都是基于方法的,属于当前线程的私有变量. 因此是线程安全的框架