SSM框架
1）ssm和ssh
SSM是什么：Spring Springmvc MyBatis
SSH是什么：Spring Struts2 HiBenate
2）在项目开发中，ssm中各个框架的作用
Spring：对象的传递，不用去new，通过di注入；相当于主板，整合其他框架；
MyBatis：相当于JDBC的工具类；对数据库进行操作。
SpringMVC:相当于Servlet 的工具类；对Servlet 的各种操作进行了整合；
3）搭建ssm框架
先根据数据库进行pojo与mapper接口。（逆向工程手写）
然后导入MyBatis相关;
配置Mapper映射配置
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.user.mapper.UserMapper">
<resultMap type="org.user.pojo.User" id="ddd">
<result column="user_num" property="num"/>
<result column="user_name" property="name"/>
</resultMap>
<select id="login" parameterType="org.user.pojo.User" resultMap="ddd">
SELECT t_user.user_num,t_user.user_name FROM t_user WHERE t_user.user_num=#{num} AND t_user.user_password=#{password};
</select>
</mapper>
MyBtais的配置文件。
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
</configuration>
搭建Spring 通关数据源（C3P0）连接数据库。进行单元测试；
然后通过Mybatis-spring
对Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config></context:annotation-config>
<context:component-scan base-package="org.user.service"></context:component-scan>
<context:property-placeholder location="classpath:DB.properties" />
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 中间件 -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactoryBean">
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
<property name="dataSource" ref="comboPooledDataSource"></property>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
id="mapperScannerConfigurer">
<property name="basePackage" value="org.user.mapper"></property>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"></property>
</bean>
事务相关配置
<tx:annotation-driven transaction-manager="txManager"/>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="comboPooledDataSource"/>
</bean>
</beans>
在配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>user_role</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc/springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
配置SpringMVC
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config></context:annotation-config>
<context:component-scan base-package="org.user"></context:component-scan>
<mvc:annotation-driven></mvc:annotation-driven>
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="defaultEncoding" value="gbk"></property>
</bean>
<bean id="jspViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
最后通过页面测试；
4）Spring框架
Spring框架里的核心内容
IOC（控制反转）
把创建对象的事情由程序员控制变成由框架控制。
DI（依赖注入）
通过框架对对象的属性进行赋值。
2、IOC
构造函数
静态工厂方法（单例设计模式）
实例工厂方法
3、DI
构造参数依赖注入
注意：
JavaBean必须拥有与<constructor-arg>标签个数相对应的参数个数的构造函数
<constructor-arg>标签有两个属性：
如果构造函数里，参数的类型没有重复的，可以通过属性type去定位。
参数的类型有重复的，只能通过index去定位。
2）配置内容
set依赖注入：
注意：
JavaBean必须有无参构造函数
属性必须有get和set方法
2）配置内容
接口依赖注入：
Service层：有关于dao层的接口引用
Servelt层：有关于server层的接口引用
1）注意：
Service和Servlet必须有无参构造函数
必须有关于接口属性的get和set方法。
2）配置内容：
原理是反射机制；
AOP（面向切面）
静态代理
目标类和代理类需要具有相同的接口，
同时代理类里需要有关于目标类的引用。
动态代理（proxy）
上述方法的主要作用是创建代理类，前两个参数表示的是目标类的信息，最后一个参数表示的代理类的执行功能。
缺陷：目标类必须要实现接口。
3、CGLib关于生成代理类的一个框架。通过CGLib实现的动态代理。
|
proxy |
动态生成的代理类与目标类具有共同的接口。 |
|
cglib |
动态生成的代理类与目录类具有父子关系。 |
怎么去理解Spring框架的Ioc和DI
ioc就是控制翻转或是依赖注入。通俗的讲就是如果在什么地方需要一个对象，你自己不用去通过new 生成你需要的对象，而是通过spring的bean工厂为你长生这样一个对象。
aop就是面向切面的编程。比如说你每做一次对数据库操作，都要生成一句日志。如果，你对数据库的操作有很多类，那你每一类中都要写关于日志的方法。但是如果你用aop，那么你可以写一个方法，在这个方法中有关于数据库操作的方法，每一次调用这个方法的时候，就加上生成日志的操作。
说的不是很清晰，多写多看就能明白了。
通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。
Ioc和DI的底层原理
IOC是控制反转,所谓反转是指应用本身并不负责依赖对象的创建和维护,而把这个任务交给第三方即Spring去处理,这是将创建对象的权利交给第三方,控制反转就是控制权的转移
DI是依赖注入.依赖注入,是指运行期间,Spring动态的将依赖对象注入到组件中。
当IOC容器启动时，容器负责创建容器内的所有对象;
根据配置信息形成对象之间的依赖关系；
也就是说让别人(ioc)为你服务。这是核心。
反射机制；
如何去理解Spring框架的AOP
AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。
二.AOP核心概念
1、横切关注点
对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
2、切面（aspect）
类是对物体特征的抽象，切面就是对横切关注点的抽象
3、连接点（joinpoint）
被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
4、切入点（pointcut）
对连接点进行拦截的定义
5、通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类
6、目标对象
代理的目标对象
7、织入（weave）
将切面应用到目标对象并导致代理对象创建的过程
8、引入（introduction）
在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段
三.Spring对AOP的支持
Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。
Spring创建代理的规则为：
1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了
2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB
AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：
1、定义普通业务组件
2、定义切入点，一个切入点可能横切多个业务组件
3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作
所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。
前置通知[Before advice]：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。
正常返回通知[After returning advice]：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。
异常返回通知[After throwing advice]：在连接点抛出异常后执行。
返回通知[After (finally) advice]：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。
环绕通知[Around advice]：环绕通知围绕在连接点前后，比如一个方法调用的前后。这是最强大的通知类型，能在方法调用前后自定义一些操作。环绕通知还需要负责决定是继续处理join point(调用ProceedingJoinPoint的proceed方法)还是中断执行。
接下来通过编写示例程序来测试一下五种通知类型：
Aop涉及到的概念
spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。
现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。
1.实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。
这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。
顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我
2.生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗，当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。
这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。
前一种兄弟模式，spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。
后一种父子模式，spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。
相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。
Aop的底层原理
动态代理
动态代理，照我的理解就是，在不修改原有类对象方法的源代码基础上，通过代理对象实现原有类对象方法的增强，也就是拓展原有类对象的功能。
项目开发中，什么地方用到AOP
日志。事务。统计代码性能；
5）MyBatis框架
如何去理解MyBatis框架
相当于JDBC的工具类；对数据库操作进行了集成；
学习过的持久层框架有哪些？Orm(Object Relation Mapper)
MyBatis
$ #的区别 模糊查询和排序
$是字符串拼接。用在模糊查询。排序
#是带有自动类型转换；
如何来编写Dao层接口的实现类 【自动 动态代理】
手写，通过Spring自动生成实现。
编写映射文件时，最复杂的sql是什么
用户角色权限 把csv文件导入到数据库表 批量插入
ssm在项目中，该框架需要进行哪些配置
配置日志，配置JavaBean；
查询缓存和二级缓存
缓存概念
MyBatis框架支持两种缓存：一级缓存和二级缓存。缓存只针对于查询语句。
为什么要出现缓存？
提升查询语句的性能。从数据库里（磁盘）查询数据，要慢于从内容中查询数据。
项目支持缓存？
所有的查询语句执行时：
第一步骤：去缓存中去查找，是否有该sql的查询结果。
第二步骤：如果有，则返回结果。
如果没有，则去数据库中去查找。
4、缓存最简单的实现 Map<String,Object>
二、MyBatis框架的一级缓存
1、缓存针对于MyBatis框架里那个对象创建？
SqlSession（Connection）
只要在代码中创建一个SqlSession对象，就会在内存中分配空间给该SqlSession。如果该SqlSession执行了查询语句，就会把查询结果保存到分配的空间。
缓存的空间的内部结构？
Map<String,Obejct> key是xml映射中 命名空间+id+入参
缓存里的数据什么时候清空
关闭或者是清空sqlSession
该SqlSession执行了更新
注意：MyBatis框架默认开启一级缓存。
三、MyBaits的二级缓存
1、缓存针对于MyBatis框架里那个对象创建？
接口类 映射文件 命名空间
当项目第一次启动时，会为开启二级缓存的映射文件分配缓存空间。如果执行了该映射文件中查询语句，还会把数据保存二级缓存。
2、缓存的空间的内部结构？
Map<String,Obejct> key是xml映射中 命名空间+id+入参
3、缓存里的数据什么时候清空
执行了映射文件中更新语句 ，也可以设置不清空缓存（不推荐）。
设置查询语句不使用二级缓存（不推荐）。
如何开启映射文件的二级缓存
MyBatis 框架默认是禁用二级缓存。
只有SqlSession关闭后，才会把查询结果保存二级缓存里。
使用第三方的二级缓存
EhCache 是一个纯Java的进程内缓存框架，比较主流的如ehcache、memcache、redis等。
下载二级缓存组件，添加到项目中
编写二级缓存的配置文件
开启映射文件的二级缓存
入参 出参的类型
入参可以是基本类型和引用类型；
出参是基本类型和引用类型
结果类型，结果map
6）Spring MVC框架
Spring MVC 框架的运行原理或者是运行过程？
在进行ssm整合开发中，最常用的注解有哪些？
@Repository
@Service
@Resource
@Transactional
@Controller
@Component
@RequestMapping
@Param
@ResponseBody
@RequestBody
前台通过ajax技术传送json数据给后台
具有和JavaBean相同的属性名可以直接通过JavaBean获取；
或者是基本类型；集合。数组；
后台如何把数据传送给前台
返回值是@ResponseBodyJavaBean
或者是EL表达式；
处理方法（参数有几种形式）
基本类型，引用类型，请求，响应，sessio，modelandview 文件上传 model file 等
拦截器
一、拦截器
1、拦截器的概念
Servlet里的过滤器一致。
创建拦截器的步骤
步骤一：创建拦截器类
步骤二：把拦截器类配置到处理器映射器上。
创建拦截器
HandlerInterceptor （接口）
HandlerInterceptorAdapter（继承）
适配器设计模式
配置拦截器
针对于一种处理器映射器。
针对于当前项目所有的处理器映射器 局部拦截器
单和多个拦截器的执行顺序
访问的是一个处理器
访问的是多个处理器
Interceptor01的preHandle方法
执行顺序： 注册的位置
执行规则：该方法返回true 返回false 后面代码就不执行。
处理器方法（return xxxx之前的代码）
Interceptor01的postHandle方法
执行顺序： 注册的位置的逆序
执行规则： 该方法之前的所有preHandle方法都返回true ,执行；只要有一个返回false就不执行。
处理器方法（return xxx） 视图处理器执行
Interceptor01的afterCompletion
执行顺序： 注册的位置的逆序
执行规则： 该拦截器的preHandle方法返回true，它就会执行。
请求处理结束。