SSM整合再回顾

一.spring

前言：提起spring就不得不说到它的IOC和AOP的概念。IOC就是一个对象容器，程序员可以将对象的创建交给spring的IOC容器来创建，不再使用传统的new对象方式，从而极大程度了降低了程序间的耦合性。IOC内部是怎么存储对象的呢？通过Map键值对的方式！每个对象都有它的id名字和class全类名，通过名字来获取对象。AOP就是面向切面编程，可以减少编写可重用代码，提取出公用的代码块，从而在不改变源代码的情况下增强原方法。原理就是动态代理。

IOC

1.创建bean对象的三种方式

1 <!--    1.通过构造方法创建bean对象-->
2 <!--  <bean id="UserService" class="cn.hongyuan.service.UserService" scope="prototype"></bean>-->
3
4 <!--  2.通过工厂来创建bean对象-->
5 <!--  <bean id="instanceFactory" class="cn.hongyuan.utils.InstanceFactory"></bean>-->
6 <!--  <bean id="UserService" factory-bean="instanceFactory" factory-method="getUserService"></bean>-->
7
8 <!--  3.通过静态方法来创建对象-->
9 <!--      <bean id="UserService" class="cn.hongyuan.utils.InstanceFactory" factory-method="getUserService"></bean>-->

2.DI依赖注入

有三种注入的方式

 1 <!--  依赖注入的三种方式-->
 2 <!--      1.通过构造方法注入-->
 3 <!--      2.通过set方法注入-->
 4 <!--      3.注入集合数据-->
 5     <bean id="UserService" class="cn.hongyuan.service.UserService">
 6 <!--       <constructor-arg name="age" value="23"></constructor-arg>-->
 7 <!--      <constructor-arg name="name" value="zhangsan"></constructor-arg>-->
 8       <property name="age" value="25"></property>
 9       <property name="name" value="lvjianyou"></property>
10       <property name="a">
11         <array>
12           <value>1</value>
13           <value>2</value>
14           <value>3</value>
15         </array>
16       </property>
17       <property name="lits">
18         <list>
19           <value>4</value>
20           <value>5</value>
21           <value>6</value>
22         </list>
23       </property>
24
25       <property name="map">
26         <map>
27           <entry key="zhangsan" value="13"></entry>
28           <entry key="lisi" value="24"></entry>
29         </map>
30       </property>

AOP

1.专用术语

1.target：目标类，需要被代理的类。例如：UserService
2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
3.PointCut 切入点：已经被增强的连接点。例如：addUser()
4.advice 通知/增强，增强代码。例如：after、before
5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
6.proxy 代理类
7. Aspect(切面): 是切入点pointcut和通知advice的结合

2.配置方式

    <!-- 1 创建目标类 -->
    <bean id="userServiceId" class="com.itheima.c_spring_aop.UserServiceImpl"></bean>
    <!-- 2 创建切面类（通知） -->
    <bean id="myAspectId" class="com.itheima.c_spring_aop.MyAspect"></bean>
    <!-- 3 aop编程
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
            <aop:pointcut> 切入点 ，从目标对象获得具体方法
            <aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.itheima.c_spring_aop.*.*(..))
            选择方法         返回值任意   包             类名任意   方法名任意   参数任意

 1 2.2.2.1 第一步：把通知类用 bean 标签配置起来
 2 <!-- 配置通知 -->
 3 <bean id="txManager" class="com.itheima.utils.TransactionManager">
 4 <property name="dbAssit" ref="dbAssit"></property>
 5 </bean>
 6 2.2.2.2 第二步：使用 aop:config 声明 aop 配置
 7 aop:config:
 8 作用： 用于声明开始 aop 的配置
 9 <aop:config>
11 <!-- 配置的代码都写在此处 -->
12 </aop:config>
13 2.2.2.3 第三步：使用 aop:aspect 配置切面
14 aop:aspect:
15 作用：
16 用于配置切面。
17 属性：
18 id： 给切面提供一个唯一标识。
19 ref： 引用配置好的通知类 bean 的 id。
20 <aop:aspect id="txAdvice" ref="txManager">
21 <!--配置通知的类型要写在此处-->
22 </aop:aspect>
23 2.2.2.4 第四步：使用 aop:pointcut 配置切入点表达式
24 aop:pointcut：
25 作用：
26 用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
27 属性：
28 expression：用于定义切入点表达式。
29 id： 用于给切入点表达式提供一个唯一标识
30 <aop:pointcut expression="execution(
31 public void com.itheima.service.impl.AccountServiceImpl.transfer(
32 java.lang.String, java.lang.String, java.lang.Float)
33 )" id="pt1"/>
34 2.2.2.5 第五步：使用 aop:xxx 配置对应的通知类型
35 aop:before
36 作用：
37 用于配置前置通知。 指定增强的方法在切入点方法之前执行
38 属性：
39 method:用于指定通知类中的增强方法名称
40 ponitcut-ref：用于指定切入点的表达式的引用
41 poinitcut：用于指定切入点表达式
42 执行时间点：
43 切入点方法执行之前执行
44 <aop:before method="beginTransaction" pointcut-ref="pt1"/>
45 aop:after-returning

Mybatis

动态SQL

1. 根据不同的条件需要执行不同的 SQL 命令.称为动态 SQL
2. MyBatis 中动态 SQL 在 mapper.xml 中添加逻辑判断等.
3. If 使用

 1 <select id="selByAccinAccout" resultType="log">
 2 select * from log where 1=1
 3 <!-- OGNL 表达式,直接写 key 或对象的属性.不需要添加任
 4 何特字符号 -->
 5 <if test="accin!=null and accin!=''">
 6 and accin=#{accin}
 7 </if>
 8 <if test="accout!=null and accout!=''">
 9 and accout=#{accout}
10 </if>
11 </select>

4. <where>
4.1 当编写 where 标签时,如果内容中第一个是 and 去掉第一个
and
4.2 如果<where>中有内容会生成 where 关键字,如果没有内容不
生成 where 关键
4.3 使用示例
4.3.1 比直接使用<if>少写 where 1=1

 1 <select id="selByAccinAccout" resultType="log">
 2 select * from log
 3 <where>
 4 <if test="accin!=null and accin!=''">
 5 and accin=#{accin}
 6 </if>
 7 <if test="accout!=null and accout!=''">
 8 and accout=#{accout}
 9 </if>
10 </where>
11 </select>

5. <choose> <when> <otherwise>

5.1 只有有一个成立,其他都不执行.
5.2 代码示例
5.2.1 如果 accin 和 accout 都不是 null 或不是””生成的 sql 中只
有 where accin=?

 1 <select id="selByAccinAccout" resultType="log">
 2 select * from log
 3 <where>
 4 <choose>
 5 <when test="accin!=null and accin!=''">
 6 and accin=#{accin}
 7 </when>
 8 <when test="accout!=null and accout!=''">
 9 and accout=#{accout}
10 </when>
11 </choose>
12 </where>
13 </select>

6. <set>用在修改 SQL 中 set 从句
6.1 作用:去掉最后一个逗号
6.2 作用:如果<set>里面有内容生成 set 关键字,没有就不生成
6.3 示例
6.3.1 id=#{id} 目的防止<set>中没有内容,mybatis 不生成 set 关
键字,如果修改中没有 set 从句 SQL 语法错误.

 1 <update id="upd" parameterType="log" >
 2 update log
 3 <set>
 4 id=#{id},
 5 <if test="accIn!=null and accIn!=''">
 6 accin=#{accIn},
 7 </if>
 8 <if test="accOut!=null and accOut!=''">
 9 accout=#{accOut},
10 </if>
11 </set>
12 where id=#{id}
13 </update>

7. Trim

7.1 prefix 在前面添加内容
7.2 prefixOverrides 去掉前面内容
7.3 suffix 在后面添加内容
7.4 suffixOverrieds 去掉后面内容
7.5 执行顺序去掉内容后添加内容
7.6 代码示例

1 <update id="upd" parameterType="log">
2 update log
3 <trim prefix="set" suffixOverrides=",">
4 a=a,
5 </trim>
6 where id=100
7 </update>

8. <bind>

8.1 作用:给参数重新赋值
8.2 场景:
8.2.1 模糊查询
8.2.2 在原内容前或后添加内容
8.3 示例
 1 <select id="selByLog" parameterType="log" 2 resultType="log"> 3 <bind name="accin" value="'%'+accin+'%'"/> 4 #{money} 5 </select> 
9. <foreach>标签

9.1 循环参数内容,还具备在内容的前后添加内容,还具备添加分
隔符功能.
9.2 适用场景:in 查询中.批量新增中(mybatis 中 foreach 效率比较
低)
9.2.1 如果希望批量新增,SQL 命令
insert into log VALUES
(default,1,2,3),(default,2,3,4),(default,3,4,5)
9.2.2 openSession()必须指定
9.2.2.1 底层 JDBC 的 PreparedStatement.addBatch();
factory.openSession(ExecutorType.BATCH);
9.3 示例
9.3.1 collectino=”” 要遍历的集合
9.3.2 item 迭代变量, #{迭代变量名}获取内容
9.3.3 open 循环后左侧添加的内容
9.3.4 close 循环后右侧添加的内容
9.3.5 separator 每次循环时,元素之间的分隔符

1 <select id="selIn" parameterType="list"
2 resultType="log">
3 select * from log where id in
4 <foreach collection="list" item="abc" open="("
5 close=")" separator=",">
6 #{abc}
7 </foreach>
8 </select>

缓存，延迟加载

配置方式

①配置主配置文件mybatis.xml

②配置映射文件xxxmapper.xml

③加载主配置文件，创建出SqlSessionFactory核心对象，获取代理对象调用方法。

三.springmvc

前言：是一个组件化的结构，每一个功能被分为不同的组件安装在其中。访问流程是：用户通过浏览器访问服务器，所有请求先经过前端控制器DispaterServlet，再访问Controller，Service，Dao。

配置方式

1.web.xml 配置前端控制器DispaterServlet，配置中文字符乱码过滤器CharacterEncodingFilter，配置连接spring的监听器。

2.springmvc.xml中配置开启注解，视图解析器，静态资源过滤，映射器等。

参数传递

1.表单中的表单项名字必须和controller方法中的参数名称相同，否则会出现匹配错误！

2.若controller方法的参数是一个对象，那么页面中表单项的名字

方法返回值

1.void方法不返回任何值，可以在参数列表中加入原生的request和response从而通过请求转发跳转页面。

2.String方法，直接返回页面的名字。会经过视图解析器寻找对应的后缀（jsp或者html等）

两种特殊写法

*  "forword:WEB-INF/pages/success.jsp"

* "redirect:success.jsp"

3.ModelAndView，直接在方法中new一个ModelAndView对象，并且在对象中存入值，存入想要跳转的页面，返回即可。

文件上传

自定义类型转换器

概述：

1. 表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，说明
Spring框架内部会默认进行数据类型转换。
2. 如果想自定义数据类型转换，可以实现Converter的接口

1.自定义类型转换器

 1 package cn.itcast.utils;
 2 import java.text.DateFormat;
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 import org.springframework.core.convert.converter.Converter;
 6 /**
 7 * 把字符串转换成日期的转换器
 8 * @author rt
 9 */
10 public class StringToDateConverter implements Converter<String, Date>{
11 /**
12 * 进行类型转换的方法
13 */
14 public Date convert(String source) {
15 // 判断
16 if(source == null) {
17 throw new RuntimeException("参数不能为空");
18 }28 try {
29 DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
30 // 解析字符串
31 Date date = df.parse(source);
32 return date;
33 } catch (Exception e) {
34 throw new RuntimeException("类型转换错误");
35 }
36 }
37 }

2.注册自定义类型转换器，在springmvc.xml的配置文件中编写配置

 1 <!-- 注册自定义类型转换器 -->
 2 <bean id="conversionService"
 3 class="org.springframework.context.support.ConversionServiceFactoryBean">
 4 <property name="converters">
 5 <set>
 6 <bean class="cn.itcast.utils.StringToDateConverter"/>
 7 </set>
 8 </property>
 9 </bean>
10 <!-- 开启Spring对MVC注解的支持 -->
11 <mvc:annotation-driven conversion-service="conversionService"/>

自定义拦截器

拦截器概述：

1. SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
2. 可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链
中的拦截器会按着定义的顺序执行。
3. 拦截器和过滤器的功能比较类似，有区别
1. 过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。
2. 拦截器是SpringMVC框架独有的。
3. 过滤器配置了/*，可以拦截任何资源。
4. 拦截器只会对控制器中的方法进行拦截。
4. 拦截器也是AOP思想的一种实现方式
5. 想要自定义拦截器，需要实现HandlerInterceptor接口。

自定义拦截器的步骤

1.创建类，实现Handlerintcepter接口，重写需要的方法

 1 package cn.itcast.demo1;
 2 import javax.servlet.http.HttpServletRequest;
 3 import javax.servlet.http.HttpServletResponse;
 4 import org.springframework.web.servlet.HandlerInterceptor;
 5 /**
 6 * 自定义拦截器1
 7 * @author rt
 8 */
 9 public class MyInterceptor1 implements HandlerInterceptor{
10 /**
11 * controller方法执行前，进行拦截的方法
12 * return true放行
13 * return false拦截
14 * 可以使用转发或者重定向直接跳转到指定的页面。
15 */
16 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
17 Object handler)
18 throws Exception {
19 System.out.println("拦截器执行了...");
20 return true;
21 }
22 }

2.在springmvc.xml中配置拦截器类

 1 <!-- 配置拦截器 -->
 2 <mvc:interceptors>
 3 <mvc:interceptor>
 4 <!-- 哪些方法进行拦截 -->
 5 <mvc:mapping path="/user/*"/>
 6 <!-- 哪些方法不进行拦截
 7 <mvc:exclude-mapping path=""/>
 8 -->
 9 <!-- 注册拦截器对象 -->
10 <bean class="cn.itcast.demo1.MyInterceptor1"/>
11 </mvc:interceptor>
12 </mvc:interceptors>

3. HandlerInterceptor接口中的方法
1. preHandle方法是controller方法执行前拦截的方法
1. 可以使用request或者response跳转到指定的页面
2. return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。
3. return false不放行，不会执行controller中的方法。
2. postHandle是controller方法执行后执行的方法，在JSP视图执行前。
1. 可以使用request或者response跳转到指定的页面
2. 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
3. postHandle方法是在JSP执行后执行
1. request或者response不能再跳转页面了

自定义异常处理器

思路：Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进
行异常的处理。

1.自定义异常类

 1 package cn.itcast.exception;
 2 public class SysException extends Exception{
 3 private static final long serialVersionUID = 4055945147128016300L;
 4 // 异常提示信息
 5 private String message;
 6 public String getMessage() {
 7 return message;
 8 } p
 9 ublic void setMessage(String message) {
10 this.message = message;
11 } p
12 ublic SysException(String message) {
13 this.message = message;
14 }
15 }

2.编写异常处理器

 1 p
 2 ackage cn.itcast.exception;
 3 import javax.servlet.http.HttpServletRequest;
 4 import javax.servlet.http.HttpServletResponse;
 5 import org.springframework.web.servlet.HandlerExceptionResolver;
 6 import org.springframework.web.servlet.ModelAndView;
 7 /**
 8 * 异常处理器
 9 * @author rt
10 */
11 public class SysExceptionResolver implements HandlerExceptionResolver{
12 /**
13 * 跳转到具体的错误页面的方法
14 */
15 public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse
16 response, Object handler,
17 Exception ex) {
18 ex.printStackTrace();
19 SysException e = null;
20 // 获取到异常对象
21 if(ex instanceof SysException) {
22 e = (SysException) ex;
23 }else {
24 e = new SysException("请联系管理员");
25 } M
26 odelAndView mv = new ModelAndView();
27 // 存入错误的提示信息
28 mv.addObject("message", e.getMessage());
29 // 跳转的Jsp页面
30 mv.setViewName("error");
31 return mv;
32 }
33 }

3.配置异常处理器

1 < 2 !-- 配置异常处理器 --> 3 <bean id="sysExceptionResolver" class="cn.itcast.exception.SysExceptionResolver"/>