SSM综合复习

SSM综合复习

 

SSM综合复习    1
1.    mybatis    3
1.1.    mybatis第一天    3
1.1.1.    MyBatis  框架概述    3
1.1.2.    Mybatis  框架快速入门    3
1.2.    mybatis第二天    4
1.2.1.    mapper代理方式实现 CRUD    4
1.2.2.    核心配置文件中的标签设置    5
1.3.    mybatis第三天    6
1.3.1.    mybatis中的动态sql（重点）    6
1.3.2.    能够掌握一对多，多对多的配置（重点）    7
1.4.    mybatis第四天    9
1.4.1.    mybatis的延迟加载    9
1.4.2.    mybatis的一级缓存二级缓存    10
1.4.3.    mybatis中的注解开发    11
2.    spring    13
2.1.    spring第一天    13
2.1.1.    spring的概述    13
2.1.2.    程序的耦合及解耦    14
2.1.3.    IOC概念和spring中的IOC的XML配置    14
2.1.4.    依赖注入（Dependency Injection）    16
2.2.    spring第二天    17
2.2.1.    ioc的常用注解    17
2.2.2.    纯注解的ioc案例    18
2.2.3.    spring和Junit整合    18
2.3.    spring第三天    19
2.3.1.    动态代理    19
2.3.2.    AOP    20
2.4.    spring第四天    22
2.4.1.    jdbcTemplate    23
2.4.2.    基于xml配置声明式事务管理    23
2.4.3.    基于annotation声明式事务管理    24
3.    springmvc    25
3.1.    springmvc第一天    25
3.1.1.    springmvc概述    25
3.1.2.    springmvc入门案例    25
3.1.3.    springmvc执行流程    25
3.1.4.    请求参数的 绑定    26
3.1.5.    常用注解    26
3.2.    springmvc第二天    27
3.2.1.    响应数据和结果视图    27
3.2.2.    SpringMVC实现文件上传    28
3.2.3.    springmvc的异常处理    29
3.2.4.    SpringMVC框架中的拦截器    29
3.3.    springmvc第三天    30
3.3.1.    SSM整合    30

 
1.    mybatis
1.1.    mybatis第一天
1.1.1.    MyBatis  框架概述
mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程
笔试题：orm思想
对象关系映射
1.1.2.    Mybatis  框架快速入门
步骤
1.创建maven工程，添加依赖
2.编写实体类和接口
3.编写映射配置文件（同包同名）
4.编写核心配置文件
5.编写测试类
    加载配置文件
    创建sqlSessionFactory
    创建sqlSession
    获取代理对象
    代理对象调用方法
    释放资源
测试类中设计的设计模式
构建者模式
工厂模式
代理模式
1.2.    mybatis第二天
1.2.1.    mapper代理方式实现 CRUD  
mapper代理开发要求：
1.接口和映射文件要同包同名
2.持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名
3.SQL 语句的配置标签<select>,<insert>,<delete>,<update>的 id 属性必须和持久层接口的
方法名相同
4.parameterType要和接口中的传入参数类型相同
5.resultType要和接口中的返回结果类型相同
查询所有
添加
获取添加成功记录的id值

更新
删除
聚合函数
模糊查询
#{}和${}的区别：
#{}表示一个占位符
#{}可以实现prepareStatment向占位符中设置值，自动进行JDBC和java类型转换，防止ql注入
 #{}可以接收简单类型值或pojo属性值，如果parameterType传输基本数据类型，值随便写
-----------------------------------------------------------------------------------------------
${}表示拼接sql串
${}是将传入的参数原样拼接在sql中，不进行jdbc类型转换
${}可以接收简单类型值或pojo属性值，如果parameterType传输基本数据类型，${}括号中只能是value
实体属性映射和表字段不匹配
别名
resultMap
1.2.2.    核心配置文件中的标签设置
properties:属性配置
resource属性：用于指定 properties 配置文件的位置，要求配置文件必须在类路径下
resource="jdbcConfig.properties"
url 属性：统一资源定位符
http://localhost:8080/mystroe/CategoryServlet
typeAliases：自定义别名
<!-- 单个别名定义 -->
<typeAlias alias="user" type="com.itheima.domain.User"/>
<!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->
<package name="com.itheima.domain"/>
mappers：映射器
方式一：
<mapper resource=" " />
使用相对于类路径的资源
如：<mapper resource="com/itheima/dao/IUserDao.xml" />
方式二：
<mapper class=" " />
使用 mapper 接口类路径
如：<mapper class="com.itheima.dao.UserDao"/>
注意：此种方法要求 r mapper  接口名称和 r mapper  映射文件名称相同，且放在同一个目录中
方式三：
<package name=""/>
注册指定包下的所有 mapper 接口
如：<package name="cn.itcast.mybatis.mapper"/>
注意：此种方法要求  mar pper  接口名称和 r mapper  映射文件名称相同，且放在同一个目录中
1.3.    mybatis第三天
1.3.1.    mybatis中的动态sql（重点）
<if test=条件判断></if>
注意问题：1.条件判断中不能使用&&，要使用and
       2.<if>标签的 test 属性中写的是对象的属性
<where></where>
简化 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发,会自动删去
第一个and
<foreach> </foreach>
<foreach>标签用于遍历集合
collection: 代表要遍历的集合元素，注意编写时不要写#{}
open: 代表语句的开始部分
close: 代表结束部分
item: 代表遍历集合的每个元素，生成的变量名
separator: 代表分隔符
<select>
抽取重复的语句代码片段
<sql id="defaultSql">
          select * from user
</sql>
使用
include refid="defaultSql"></include>
1.3.2.    能够掌握一对多，多对多的配置（重点）
表关系
一对一 ：人和身份证
一对多 ：用户和订单
多对多 ：学生和课程
实体中表示关系
一对多
    一方实体中添加集合表示多方
    多方实体中声明实体对象表示一方
多对多
    双方实体中都添加集合表示对方
一对一查询中对返回结果集的封装
方式一
定义专门的 pojo 类作为输出类型，其中定义了 sql 查询结果集所有的字段
方式二
使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
    <association property="user" javaType="cn.itheima.domain.user">
一对多查询对返回结果集的封装
使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
 <collection property="accounts" ofType="account">
多对多查询中对返回结果集的封装
使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
 两方使用的标签都是 <collection property="user" ofType="user">
1.4.    mybatis第四天
1.4.1.    mybatis的延迟加载
什么是立即加载
加载实体类数据时，关联数据也会立即加载
什么是延迟加载
加载实体类数据时，关联数据不会立即加载，当需要关联数据时才会被加载
一对一延迟加载配置
使用 assocation  实现延迟加载
1.编写持久层 DAO接口
2.持久层映射文件

3.开启 Mybatis 的延迟加载策略
<settings>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
一对多延迟加载配置
使用 Collection  实现延迟加载
1.编写持久层 DAO接口
2.持久层映射文件

3.开启 Mybatis 的延迟加载策略
<settings>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
1.4.2.    mybatis的一级缓存二级缓存
缓存概念
存储在内存中的临时数据，使用缓存，可以减少与数据库的交互次数
一级缓存
1.默认开启
2.sqlSession范围
3.清空一级缓存的触发条件
增删改
sqlsession.close
sqlsession.clearCache
sqlSession.commit
二级缓存
1.默认不开启
2.二级缓存是 mapper 映射级别的缓存：
二级缓存是跨 SqlSession 的
二级缓存的开启

第一步：在 SqlMapConfig.xml  文件开启二级缓存
<setting name="cacheEnabled" value="true"/>

第二步：配置相关的 Mapper  映射文件
<cache></cache>

第三步：置 配置 statement  上面的 useCache  属性
useCache="true"
1.4.3.    mybatis中的注解开发
常用注解
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用，封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@CacheNamespace:实现注解二级缓存的使用
注解开发案例步骤
1.编写实体类
2.使用注解方式开发 持久层 接口@select
3.编写 SqlMapConfig  配置文件
4.编写测试方法
复杂关系映射的注解说明
@Results  注解
代替的是标签<resultMap>
@Resutl 注解
代替了 <id> 标签和<result> 标签
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解（@Result（one=@One）（）））
many 需要使用的@Many 注解（@Result（many=@many）（））
@One  注解（一对一）
代替了<assocation> 标签，是多表查询的关键，在注解中用来指定子查询返回单一对象
select 指定用的 来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled
取值：    eager
             lazy
             default
@Many  注解（多对一）
代替了<assocation> 标签，是多表查询的关键，在注解中用来指定子查询返回单一对象
一对一映射注解配置

一对多注解映射配置

2.    spring
2.1.    spring第一天
2.1.1.    spring的概述
概述
spring是一个一栈式的轻量级开源框架
核心
IOC
控制反转：将对象的创建交给spring
DI：依赖注入
AOP
面向切面编程
优势
方便解耦，简化开发 
AOP 编程的支持
方便集成各种优秀框架
体系结构
1.核心部分
2.AOP部分
3.数据访问部分
4.web部分
2.1.2.    程序的耦合及解耦
耦合
程序间的依赖关系，应力争做到高内聚，低耦合
解耦
通过对代码的优化来降低耦合，杜绝编译期依赖关系
解决耦合的思路
反射+XML
2.1.3.    IOC概念和spring中的IOC的XML配置
准备工作
1.创建工程，导入依赖
2.创建业务层接口和实现类
3.创建持久层接口和实现类
入门案例
1.在类的根路径下创建的 一个任意名称的 xml 
2.让 让 spring  管理 资源置 ，在配置文件中配置 service 和 和 dao
<bean id=""  class="">
3.测试 配置是否成功
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService aService = (IAccountService) ac.getBean("accountService");
System.out.println(aService);
bean标签：用于配置对象让 spring 来创建
属性
id：给对象在容器中提供一个唯一标识。用于获取对象。
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
       singleton :默认值，单例的.
       prototype :多例的.
实例化 Bean  的三种方式
默认无参构造函数
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>
静态工厂的方法创建对象
<bean id="accountService"
class="com.itheima.factory.StaticFactory"
factory-method="createAccountService"></bean>
实例工厂的方法创建对象
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService"
factory-bean="instancFactory"
factory-method="createAccountService"></bean>
2.1.4.    依赖注入（Dependency Injection）
概念
XML中对类之间的依赖关系进行维护
二种注入方式
构造函数注入
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
     <constructor-arg name="name" value=" 张三 "></constructor-arg>
     <constructor-arg name="age" value="18"></constructor-arg>
      <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
Set方法注入
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
 注入集合属性
注入集合数据
List 结构的：
array,list,set
Map 结构的
map,entry,props,prop
2.2.    spring第二天
2.2.1.    ioc的常用注解
创建对象
1.@component
2.@controller
3.@service
4.@repository
相当于<bean id="" class="">
依赖注入
@Autowired：自动按照类型注入
@Qualifier：在自动按照类型注入的基础之上，再按照 Bean 的 id 注入（不能独立使用）
@Resource：根据bean的id进行注入
@value:注入基本数据类型和 String 类型数据的
范围：单例多例
@Scope
singleton
phototype
生命周期
@PostConstruct:用于指定初始化方法。
@PreDestroy:用于指定销毁方法。
2.2.2.    纯注解的ioc案例
@Configuration
指定当前类是一个配置类
@ComponentScan("com.itheima")
用于通过注解指定spring在创建容器时要扫描的包
@Bean
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
测试：ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
@Import()
作用：用于导入其他的配置类
@PropertySource
作用：用于指定properties文件的位置
2.2.3.    spring和Junit整合
@RunWith(SpringJUnit4ClassRunner.class)：替换运行器
@ContextConfiguration(locations= {"classpath:bean.xml"})：指定配置文件路径
2.3.    spring第三天
2.3.1.    动态代理
JDK动态代理：基于接口的动态代理
Proxy.newProxyInstance(参数1，参数2，参数3)
参数1：classloarder:类加载器
参数2：class[]:被代理类实现的全部接口
参数3：new invocationHandler:增强逻辑

public Object  invork(参数1，参数2，参数3)
参数1：代理对象
参数2：当前执行的方法
参数3：当前执行的方法所需要的参数

***代理对象调用任何方法都会执行invork方法
CGLIB：基于子类的动态代理
Enhancer.create（参数1，参数2,）
参数1：class:被代理对象的字节码
参数2：Callback：用于提供增强的代码


public Object intercept（参数1，参数2，参数3）
参数1：代理对象
参数2：当前执行的方法
参数3：当前执行的方法所需要的参数

***代理对象调用任何方法都会执行intercept方法
2.3.2.    AOP
概念
AOP：面向切面编程
作用
不修改源码的基础上，对已有方法进行增强
好处
减少重复代码
提高开发效率
维护方便
底层
动态代理
术语
Joinpoint( 连接点)：所有可以被增强的方法
Pointcut( 切入点)：真正被增强的方法
Advice( 通知/ 增强)：增强的逻辑
Target( 目标对象)：被代理对象
Weaving(织入）：创建代理对象的过程
Proxy （代理）：代理对象
Aspect(切面）：切入点和通知结合的过程
切入点表达式说明
execution:匹配方法的执行(常用)
execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

execution(* com.itheima.service.impl.*.*(..))
XML配置AOP步骤
第一步：创建代理类和被代理类的IOC配置
第二步：使用 aop:config  声明 aop  配置
第三步：使用 aop:aspect  配置切面
属性：id：给切面提供一个唯一标识。
          ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="txAdvice" ref="txManager">
</aop:aspect>
第四步：使用 aop:pointcut  配置切入点表达式
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution(
public void com.itheima.service.impl.AccountServiceImpl.transfer(
java.lang.String, java.lang.String, java.lang.Float)
)" id="pt1"/>
第五步：使用 aop:xxx  配置 对应的通知类型
aop:before：前置通知
aop:after-returning：后置通知
aop:after-throwing：异常通知
aop:after：最终通知
aop:around：环绕通知
基于注解的 AOP 
第一步：把通知类使用 注解配置@Component("txManager")
第二步：在通知类上使用@Aspect  注解声明为切面
第三步：在增强的方法上使用注解配置通知@Before
第四步：在 spring  配置文件中开启 spring  对注解 AOP  的支持
<aop:aspectj-autoproxy/>
切入点表达式注解
@Pointcut
不使用 XML  的配置方式
@EnableAspectJAutoProxy
2.4.    spring第四天
2.4.1.    jdbcTemplate
概念
 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装
作用
对数据库表进行crud
API
增删改：update(sql,可变参数)
查询多个:query(sql,new beanProperyRowMapper,参数)
查询一个:queryForObject(sql,new beanProperyRowMapper,参数)
2.4.2.    基于xml配置声明式事务管理
步骤
第一步： 配置事务管理器
第二步：配置事务的通知引用事务管理器
<tx:advice id="txAdvice" transaction-manager="transactionManager">
</tx:advice>
第三步：配置事务的属性
<tx:method name="*" read-only="false" propagation="REQUIRED"/>
<tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
  第四步：配置 AOP  切入点表达式
<!-- 配置 aop -->
<aop:config>
<!-- 配置切入点表达式 -->
<aop:pointcut  expression="execution(*  com.itheima.service.impl.*.*(..))"
id="pt1"/>
</aop:config>
第五步：配置切入点表达式和事务通知的对应关系
<!-- 在 在 aop:config  标签内部：建立事务的通知和切入点表达式的关系 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/
2.4.3.    基于annotation声明式事务管理
步骤
第一步：配置事务管理器 并注入数据源
<!-- 配置事务管理器 -->
<bean  id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
第二步：在业务层使用@Transactional  注解
@Transactional
 第 三步：在配置文件中开启 spring  对注解事务的支持
<tx:annotation-driven transaction-manager="transactionManager"/>
不使用 xml  的配置方式
@EnableTransactionManagement
3.    springmvc
3.1.    springmvc第一天
3.1.1.    springmvc概述
SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架
3.1.2.    springmvc入门案例
1. 创建工程，导入依赖
2. web.mxl中配置核心控制器-  Servlet
3. 创建 spring mvc 的配置文件
4. 编写控制器并使用注解配置
5.测试
3.1.3.    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响应用户
3.1.4.    请求参数的 绑定
基本类型参数
要求我们的参数名称必须和控制器中方法的形参名称保持一致
POJO  类型参数
要求表单中参数名称和 POJO 类的属性名称保持一致。并且控制器方法的参数类型是 POJO 类型
数组和集合类型参数
给 List 集合中的元素赋值，使用下标
给 Map 集合中的元素赋值，使用键值对
3.1.5.    常用注解
 RequestMapping
用于建立请求 URL 和处理请求方法之间的对应关系
RequestParam
把请求中指定名称的参数给控制器中的形参赋值
RequestBody
用于获取请求体内容
PathVaribale
用于绑定 url 中的占位符，例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符
CookieValue
用于把指定 cookie 名称的值传入控制器方法参数
ModelAttribute
可以用于修饰方法和参数
方法：出现在方法上，表示当前方法会在控制器的方法执行之前，先执行
参数：出现在参数上，获取指定的数据给参数赋值
SessionAttribute
用于多次执行控制器方法间的参数共享
3.2.    springmvc第二天
3.2.1.    响应数据和结果视图
返回值分类
返回字符串
Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址
返回值是void
如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到
返回值是ModelAndView对象
ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图
SpringMVC框架提供的转发和重定向
forward请求转发
return "forward:/user/findAll";
redirect重定向
return "redirect:/user/findAll";
springmvc实现异步
ResponseBody响应json数据
@ResponseBody
3.2.2.    SpringMVC实现文件上传
文件上传三要素
1.表单提交方式必须是post
2.必须有文件上传项，且有name值
3.enctype="multipart/form-data"
springmvc方式实现文件上传
SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的
name属性名称相同
配置文件解析器 multipartResolver
SpringMVC跨服务器方式文件上传
1.搭建图片服务器
2.实现SpringMVC跨服务器方式文件上传
3.2.3.    springmvc的异常处理
异常处理思路
 Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进行异常的处理。
SpringMVC的异常处理
1.自定义异常类
2.自定义异常处理器
3. 配置异常处理器
3.2.4.    SpringMVC框架中的拦截器
拦截器的概述
SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术
拦截器和过滤器的区别
过滤器配置了可以拦截任何资源
拦截器只会对控制器中的方法进行拦截
自定义拦截器步骤
1.创建类，实现HandlerInterceptor接口，重写需要的方法
2.在springmvc.xml中配置拦截器类
3.3.    springmvc第三天
3.3.1.    SSM整合
思路
Springmvc与spring整合
配置spring的监听器
mybatis与spring整合
将mybatis的配置交给spring编写
 数据源
 sessionFactroy
 mapper映射
 事务