SSM知识点集合

阅读数: 次 2020-10-15

1.spring整合mybatis

步骤：
1.新建maven项目
2.加入maven的依赖
  1）spring依赖
  2）mybatis依赖
  3）mysql驱动
  4）spring的事务的依赖
  5）mybatis和spring集成的依赖： mybatis官方体用的，用来在spring项目中创建mybatis
     的SqlSesissonFactory，dao对象的
3.创建实体类
4.创建dao接口和mapper文件
5.创建mybatis主配置文件
6.创建Service接口和实现类，属性是dao。
7.创建spring的配置文件：声明mybatis的对象交给spring创建
 1）数据源DataSource
 2）SqlSessionFactory
 3) Dao对象
 4）声明自定义的service

8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问

applicationContext.xml:

spring和mybatis整合在一起使用，事务是自动提交的。无需执行SqlSession.commit();

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
       把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
       spring知道jdbc.properties文件的位置
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--声明数据源DataSource, 作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息 -->
        <!--    使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" /><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}" />
        <property name="maxActive" value="${jdbc.max}" />
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
        SqlSessionFactory  sqlSessionFactory = new ..
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
           configLocation属性是Resource类型，读取配置文件
           它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。

    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名， 包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
            一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
        -->
        <property name="basePackage" value="com.bjpowernode.dao"/>
    </bean>

    <!--声明service-->
    <bean id="studentService" class="com.bjpowernode.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao" />
    </bean>
	<!--这里需要在StudentServiceImpl的studentDao设置set方法,方便赋值-->
</beans>

使用:

String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //获取spring容器中的dao对象
        StudentService service = (StudentService) ctx.getBean("studentService");

1.spring事务:

使用@Transactional的步骤：
  1.需要声明事务管理器对象
    <bean id="xx" class="DataSourceTransactionManager">

  2.开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务。
    spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
    spring给业务方法加入事务：
	    在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知
       
		 @Around("你要增加的事务功能的业务方法名称")
		 Object myAround(){
           开启事务，spring给你开启
			  try{
			     buy(1001,10);
				  spring的事务管理器.commit();
			  }catch(Exception e){
             spring的事务管理器.rollback();
			  }
			 
		 }

  3.在你的方法的上面加入@Trancational

==注意==:

transaction-manager:事务管理器的id

第二部开启事务注解驱动中,下面代码选择的类是:

http://www.springframework.org/schema/tx

1	<tx:annotation-driven transaction-manager="transactionManager" />

使用:

/**
     *
     * rollbackFor:表示发生指定的异常一定回滚.
     *   处理逻辑是：
     *     1) spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性值中
     *         如果异常在rollbackFor列表中，不管是什么类型的异常，一定回滚。
     *     2) 如果你的抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException,
     *         如果是一定回滚。
     *
     */
   /* @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class,  NotEnoughException.class
            }
    )*/

    //使用的是事务控制的默认值， 默认的传播行为是REQUIRED，默认的隔离级别DEFAULT
    //默认抛出运行时异常，回滚事务。
    @Transactional

2.AspectJ事务

注意:tx:advice这里也需要用末尾是tx的类

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--
       把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
       spring知道jdbc.properties文件的位置
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--声明数据源DataSource, 作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息 -->
        <!--    使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" /><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}" />
        <property name="maxActive" value="${jdbc.max}" />
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
        SqlSessionFactory  sqlSessionFactory = new ..
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
           configLocation属性是Resource类型，读取配置文件
           它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。

    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名， 包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
            一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
        -->
        <property name="basePackage" value="com.bjpowernode.dao"/>
    </bean>

    <!--声明service-->
    <bean id="buyService" class="com.bjpowernode.service.impl.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao" />
        <property name="saleDao" ref="saleDao" />
    </bean>

    <!--声明式事务处理：和源代码完全分离的-->
    <!--1.声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource" />
    </bean>

    <!--2.声明业务方法它的事务属性（隔离级别，传播行为，超时时间）
          id:自定义名称，表示 <tx:advice> 和 </tx:advice>之间的配置内容的
          transaction-manager:事务管理器对象的id
    -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!--tx:attributes：配置事务属性-->
        <tx:attributes>
            <!--tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
                name:方法名称，1）完整的方法名称，不带有包和类。
                              2）方法可以使用通配符,* 表示任意字符
                propagation：传播行为，枚举值
                isolation：隔离级别
                rollback-for：你指定的异常类名，全限定类名。 发生异常一定回滚
            -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.bjpowernode.excep.NotEnoughException"/>

            <!--使用通配符，指定很多的方法-->
            <tx:method name="add*" propagation="REQUIRES_NEW" />
            <!--指定修改方法-->
            <tx:method name="modify*" />
            <!--删除方法-->
            <tx:method name="remove*" />
            <!--查询方法，query，search，find-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <!--配置aop-->
    <aop:config>
        <!--配置切入点表达式：指定哪些包中类，要使用事务
            id:切入点表达式的名称，唯一值
            expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象

            com.bjpowernode.service
            com.crm.service
            com.service
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

        <!--配置增强器：关联adivce和pointcut
           advice-ref:通知，上面tx:advice哪里的配置
           pointcut-ref：切入点表达式的id
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
    </aop:config>


</beans>

3.监听器

web.xml:

<!--注册监听器ContextLoaderListener
        监听器被创建对象后，会读取/WEB-INF/spring.xml
        为什么要读取文件：因为在监听器中要创建ApplicationContext对象，需要加载配置文件。
        /WEB-INF/applicationContext.xml就是监听器默认读取的spring配置文件路径

        可以修改默认的文件位置，使用context-param重新指定文件的位置


        配置监听器：目的是创建容器对象，创建了容器对象， 就能把spring.xml配置文件中的所有对象都创建好。
        用户发起请求就可以直接使用对象了。
    -->
    <context-param>
        <!-- contextConfigLocation:表示配置文件的路径  -->
        <param-name>contextConfigLocation</param-name>
        <!--自定义配置文件的路径-->
        <param-value>classpath:spring.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

二:SpringMVC

M: model(数据)

V: view

C:DispatcherServlet:(前端控制器)

Controller(后端控制器 back controller)

1.web.xml配置中央调度器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <!--注册springmvc框架的核心对象DispatcherServlet(中央调度器)-->

    <!--
       在服务器启动的时候，会找/WEB-INF/myweb-servlet.xml ，/WEB-INF/springmvc-servlet.xml
       找的文件命名是： 目录是WEB-INF， 文件名称是： <servlet-name>-servlet.xml

       为什么要找这个文件？
         在DispatcherServlet这个Servlet的init()方法中，会创建springmvc的容器对象WebApplicationContext,
         在创建容器对象时，会加载读取springmvc需要的配置文件，默认查找位置就是/WEB-INF/<servlet-name>-servlet.xml
       springmvc需要的配置文件，可以单独指定的，需要配置参数contextConfigLocation.

    -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <!--前端控制器（front controller）-->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--指定springmvc配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--
            在服务器启动的时候，创建Servlet对象
            load-on-startup:表示Tomcat启动后出创建对象的顺序,它的值是整数,数值越小
            表示创建的时间越早,是一个大于等于0的整数
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
           <url-pattern> ： 表示把请求交给指定的Servlet对象。只有把请求交给DispatcherServlet，
           这样的请求才能使用springmvc框架处理。 使用DispatcherServlet接收用户的请求。
           在框架中url-pattern:
           1.扩展名： *.xxxx , xxxx 就是自定义的扩展名。 例如 *.do , *.action,*.mvc等等，不能使用*.jsp
           2.使用斜杠"/"

        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

2.spring.xml

组件扫描器
视图解析器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="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">

    <!--springmvc的配置文件： 声明的web相关的对象，例如处理器对象，视图对象等-->
    <!--声明组件扫描器-->
    <context:component-scan base-package="com.bjpowernode.controller" />


    <!--声明视图解析器：springmvc中的一个对象，处理视图的。能指定视图的路径和扩展名
       InternalResourceViewResolver:内部资源视图解析器，处理jsp，jstl等视图文件
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--指定前缀：视图文件目录-->
        <property name="prefix" value="/WEB-INF/view/" />
        <!--指定后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

**
 * Author: 动力节点
 * 2019/5/14
 *
 * @Controller: 创建处理器对象。默认是单例对象
 *  处理器对象能接收用户的请求。指定方法处理请求
 *
 *  位置：在类定义的上面
 *
 * @Controller等同于
 * <bean id="myController" class="com.bjpowernode.controller.MyController"/>
 *
 * @RequestMapping:
 *     value: 请求地址的公共部分， 这个公共部分也叫做模块名称
 *     位置： 放到类的上面
 */
     @RequestMapping(value = "/test")

3.springMVC请求的流程

1.发起some。do

2.tomcat（根据web.xml的—url–pattern知道 *.do的请求给DispatcherServlet）

3.DispatcherServlet （根据springmvc。xml配置知道 some.do—dosome（））

4.DispatcherServlet把some.do转发给MyController.dosome()方法

5.框架执行dosome（）把得到ModeAndView进行处理，转发到show.jsp

4.中央调度器执行流程

![img](file:///C:\Users\12070\Documents\Tencent Files\1207071819\Image\C2C\2R0JMSY30AHCP4%UM]`QR.png)

5.RequestMapping指定方法

==注意==：value的参数必须带”/“ 比如”/some.do”

1
2
3

//指定some.do只能使用get请求
    //
    @RequestMapping(value = {"/some.do","/first.do"},method = RequestMethod.GET)

1
2
3

//指定other.do使用post方式
    //HTTP Status 405 - Request method 'GET' not supported
    @RequestMapping(value = {"/other.do","/second.do"},method = RequestMethod.POST)

1 2	//third.do不指定请求方式，请求方式就没有限制 @RequestMapping(value = "/third.do")

6.接收请求参数

1.请求头里面的参数

HttpServletRequest HttpServletResponse HttpSession

public ModelAndView doThird(HttpServletRequest request, 
                            HttpServletResponse response,
                            HttpSession session){
        String name = request.getParameter("name");
        System.out.println("处理third.do的请求，执行doThird" + name);
        ModelAndView mv = new ModelAndView();

        //request.setCharacterEncoding("utf-8");
        //response.setCharacterEncoding("utf-8");
        //调用Service处理请求。
        mv.addObject("msg","dothird  Hello SpringMVC注解开发 name:" + name);
        mv.setViewName("show");
        return mv;
    }

2.用户提交的数据

400状态码是客户端错误,表示提价请求参数过程中发生了问题

1.逐个接收

/**
     * 逐个接收请求的参数：
     *  要求是： 处理器方法的形参名和请求中参数名一样。按名称一一赋值
     *
     * 框架的处理方式：
     *   1.使用request接收请求中的所有参数
     *     String strName = request.getParameter("name");
     *      *     String strAge = request.getParameter("age");
     *
     *   2.适配器对象调用doSome()时，按名称传递参数
     *     doSome(strName,  Integer.parseInt(strAge) )
     *
     *     框架提供了请求参数String到基本类型的转换， String - int , String- float
     *
     *		400状态码是客户端错误,表示提价请求参数过程中发生了问题
     
     *     当参数类型是int， 请求参数值是“”, 发生NumberFormatException， TypeMismatchException
     *     框架不能把“”转为一个有效的int。 页面报出 400
     *
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(Integer age,String name){
        System.out.println("处理some.do的请求，执行name:" + name + "|age:"+age);
        ModelAndView mv = new ModelAndView();

        //调用Service处理请求。
        mv.addObject("myname",name);
        mv.addObject("myage", age);
        mv.setViewName("show");
        return mv;
    }

2.参数名和形参名不一样


/**
 * 接收请求中参数名和处理器方法的形参名不一样的问题：
 * 在处理器方法的形参前面加入@RequestParam
 * @RequestParam的属性
 *      1. value:请求中参数名
 *      2. required : 默认是true
 *          true:请求中有这个参数
 *          false:请求中可以没有此参数
 *
 *
 * 当请求中没有参数时，
 * 报错：HTTP Status 400 - Required Integer parameter 'rage' is not present
 */
@RequestMapping(value = "/other.do")
public ModelAndView doOther(@RequestParam(value = "rage",required = false) Integer age,
                            @RequestParam(value = "rname",required = false) String name){
    System.out.println("处理other.do的请求，执行name:" + name + "|age:"+age);
    ModelAndView mv = new ModelAndView();

    //调用Service处理请求。
    mv.addObject("myname",name);
    mv.addObject("myage", age);
    mv.setViewName("show");
    return mv;
}

3.对象接收

/**
     * 使用java对象接收请求的参数。 java对象的属性存储请求参数值
     * 要求：java对象的属性名和请求中参数名一样。
     *
     *
     * 调用doWithObjectParam();
     *
     * 适配器对象，调用处理器方法
     *
     * Student student = new Student();
     * student.setName();
     * student.setAge();
     *
     * Order order = new Order();
     * order.setXXX();
     *
     * School school = new School();
     * school.setXXX();
     *
     * 适配器对象.doWithObjectParam(student,order,school);
     *
     * 适配器对象.doWithObjectParam(student,"zs",20);
     *
     * 不能使用@RequestParam
     *
     */
    @RequestMapping("/paramobject.do")
    public ModelAndView doWithObjectParam(Student student){
        System.out.println("处理器方法接收请求参数："+student);
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname", student.getName());
        mv.addObject("myage", student.getAge());
        mv.addObject("mystudent", student);

        mv.setViewName("show");
        return mv;
    }

7.过滤器CharacterEncodingFilter

<!--注册字符集的过滤器，解决post请求乱码的问题-->
   <filter>
       <filter-name>characterEncodingFilter</filter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
           <!--设置项目的编码方式-->
           <param-name>encoding</param-name>
           <param-value>utf-8</param-value>
       </init-param>
       <init-param>
           <!--true强制请求对象request，使用encoding的编码-->
           <param-name>forceRequestEncoding</param-name>
           <param-value>true</param-value>
       </init-param>
       <init-param>
           <!--true强制应答对象response，使用encoding的编码-->
           <param-name>forceResponseEncoding</param-name>
           <param-value>true</param-value>
       </init-param>
   </filter>

<!--/* 表示所有的请求必须先经过这个过滤器处理-->
   <filter-mapping>
       <filter-name>characterEncodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

8.void返回json

1.加入依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId> 
    <version>2.9.0</version>
</dependency>

2.引入jQurey库

1	<script type="text/javascript" src="js/jquery-1.11.1-min.js"></script>

3.使用


/**
 *  处理器方法返回void: void没有数据，也没有视图。可以响应ajax的请求。
 *  通过HttpServletResponse输出json数据，响应ajax的请求
 */
@RequestMapping("/myajax.do")
public void doAjax(String name,Integer age,HttpServletResponse rep) throws IOException {
    System.out.println("ajax接收请求的参数"+name+"|"+age);
    //调用Service处理请求，把结果转为json输出。
    Student student = new Student();
    student.setName(name);
    student.setAge(age);

    //使用jackson，把Student--Json
    ObjectMapper mapper = new ObjectMapper();
    String json  = mapper.writeValueAsString(student);

    //通过HttpServletResponse输出json
    //rep.getWriter().println(json);
    PrintWriter pout = rep.getWriter();
    pout.println(json);
    pout.flush();//清空输出的缓存，让数据马上输出。
    pout.close();


}

9.框架响应json

返回对象Object响应json:

步骤

==注意==: 注解驱动中mvc:annotation-driven使用的类是http://www.springframework.org/schema/mvc

ch04-return:处理器方法的返回值

处理ajax
1.加入支持ajax的jQuery库文件
2.加入jackson工具库， 目的是完成java对象到json的转换。


步骤：
1.新建maven web
2.加入maven的依赖（坐标）
3.在springmvc配置文件加入 <mvc:annotation-driven>注解驱动
	json = om.writeValueAsString();
4.在处理器方法上面加入@ResponseBody注解
	response.setContentType("application/json;charest=utf-8");
	PrintWriter pw = response.getWriter();
	pw.println(json);

返回对象使用:

/**
    *     总结:springmvc中方法返回是对象，使用json输出，需要哪些步骤
    *      1.加入maven关于jackson的坐标。
    *      2.在springmvc的配置文件  <mvc:annotation-driven />
    *      3.在处理器方法的上面加入 @ResponseBody
    *
    *	@ResponseBody
    *		作用:把处理器方法返回对象转为json后,通过HttpServletResponse输出给浏览器
    *		位置:方法的定义上面,和其他注解没有顺序的关系
    */

   /**
    * 例1：处理器方法返回Student-- Json
    * 框架的处理流程：
    *  1.框架根据返回值的数据类型Student,遍历HttpMessageConverter接口的实现类对象，
    *  找能够处理Student类型的实现类对象， Student - MappingJackson2HttpMessageConverter
    *
    *  2.框架会调用实现类对象的， write()方法，把Student转为json（JSONObject）
    *    MappingJackson2HttpMessageConverter的wirte(),
    *    MappingJackson2HttpMessageConverter默认的数据处理格式“application/json;charset=UTF-8”
    *
    *
    *  3.框架使用@ResponseBody，把2的结果数据通过HttpServletResponse输出到浏览器
    */
   @RequestMapping("/returnObject-student.do")
   @ResponseBody
   public Student ajaxToJson(String name,Integer age){
       //调用Service处理业务逻辑
       Student student = new Student();
       student.setName("同学：" + name);
       student.setAge(age);
       return student;
   }

返回list使用

/**
    * 处理器方法返回List集合： JSONArray
    * 框架的处理流程：
    *  1.框架根据返回值的数据类型Student,遍历HttpMessageConverter接口的实现类对象，
    *  找能够处理Student类型的实现类对象， Student - MappingJackson2HttpMessageConverter
    *
    *  2.框架会调用实现类对象的， write()方法，把Student转为json（JSONArray）
    *    MappingJackson2HttpMessageConverter的wirte(),
    *    MappingJackson2HttpMessageConverter默认的数据处理格式“application/json;charset=UTF-8”
    *
    *
    *  3.框架使用@ResponseBody，把2的结果数据通过HttpServletResponse输出到浏览器
    */
   @RequestMapping("/returnObject-list.do")
   @ResponseBody
   public List<Student> ajaxToJsonArray(String name, Integer age){
       //调用Service处理业务逻辑
       Student student = new Student();
       student.setName("同学张三");
       student.setAge(20);

       Student student1 = new Student();
       student1.setName("同学李四");
       student1.setAge(22);

       List<Student> list = new ArrayList<>();
       list.add(student1);//李四
       list.add(student);//张三
       return list;
   }

返回string

/**
     * 处理器方法返回String -- String表示数据
     *
     * 怎么判断String返回值是视图还是数据
     * 如果处理器方法上面有@ResponseBody注解， 返回String就是数据， 其他就是视图。
     *
     * 有中文的数据有乱码，因为输出的数据默认是：text/plain;charset=ISO-8859-1
     * 解决乱码的问题， 使用@RequestMapping的produces属性
     * produces：输出的内容类型和编码
     *
     * 框架的处理流程：
     *  1.框架根据返回值的数据类型String,遍历HttpMessageConverter接口的实现类对象，
     *  找能够处理String类型的实现类对象， String - StringHttpMessageConverter
     *
     *  2.框架会调用实现类对象的， write()方法，把Student转为json（JSONArray）
     *    StringHttpMessageConverter的wirte(),
     *    StringHttpMessageConverter默认的数据处理格式“text/plain;charset=ISO-8859-1”
     *
     *
     *  3.框架使用@ResponseBody，把2的结果数据通过HttpServletResponse输出到浏览器
     */
    @RequestMapping(value="/returnString-data.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String ajaxToString(String name,Integer age){
        return "Hello HttpMessageConverter 返回String作为数据";
    }

}

10.静态资源访问

1.第一种

1. 加入注解驱动
<mvc:annotation-driven/>
2.加入
<mvc:default-servlet-handler/>

2.第二种

<!--第二种方式处理静态资源： 框架自己处理静态资源的请求，框架会创建处理器对象。
       mvc:resources , 加入后框架创建ResourceHttpRequestHandler对象。 处理静态资源的访问
       mapping: 请求静态资源的uri地址。
       location:静态资源在web应用中的目录位置，最后不用WEB-INF

   -->

   <mvc:resources mapping="/html/**" location="/html/" />
   <mvc:resources mapping="/images/**" location="/images/" />

   <!-- <mvc:resources mapping="/static/**" location="/static/" />-->

   <!--
     resources 和 @RequestMapping有冲突，加入注解驱动解决冲突问题
   -->
   <mvc:annotation-driven />

11.相对地址和绝对地址

在jsp, html种使用的地址,都是在前端页面中的地址,都是相对地址

地址分类

1.绝对地址: 带有协议名称的是绝对地址,例如: http://www.baidu.com

2.相对地址: 没有协议开头,例如 user/some.do 相对地址不能独立使用,必须有一个参考地址,通过参考地址,相对地址本身才能指定资源

3.参考地址:

在你的页面中,访问地址不加”/“

例如 user/some.do , 当你点击链接时,访问的地址是当前页面的地址加上链接的地址

http://localhost:8080/myWeb/ + user/some.do

解决方案:

1.加入${pageContext.request.contextPath}

2.加入一个base标签,是html语言中的标签,表示当前页面中访问地址的基地址

你的页面中所有没有”/“开头的地址,都是以base标签中的地址为参考地址

使用base中的地址+ user/some.do 组成访问地址

最常用的方案:

<%
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + "/";
%>

<html>
<head>
    <base href="<%=basePath%>">
    <title>发起请求的jsp</title>
</head>

在你的页面中,访问地址加上了”/“

参考地址是你的服务器地址,也就是 http://localhost:8080,当需要访问地址时,需要在jsp路径中加入项目的路径,这种比较麻烦,不可取,所以可以采用el表达式${pageContext.request.contextPath}

例如:

三:ssm整合开发

步骤

ch10-ssm: SSM整合开发
SSM:SpringMVC + Spring + MyBatis

SSM:一个项目中需要有多个框架， 是使用框架解决不同方面的问题。
SpringMVC解决什么问题？ 接收用户的请求， 调用Service ,显示处理结果的。 是视图层的框架
Spring解决问题？使用IoC管理对象， Service ，Dao,工具类等
MyBatis作用? 访问数据库。

SpringMVC是容器：管理web相关的对象，主要是Controller, 视图等对象。 数据来自Service。
Spring容器：管理Service ，Dao,工具类等对象。

用户的请求处理是：
  用户发起请求---> SpringMVC的Controller ---> Service ---> Dao ----> DB数据库


SpringMVC容器和Spring容器的关系： SpringMVC看做是Spring的子容器，从继承的角度看
SpringMVC子容器能够访问父容器中的对象， 也就是Controller能访问Service。反过来Service不能访问Controller.

SpringMVC容器对象是WebApplicationContext
Spring容器对象是WebApplicationContext

SpringMVC容器对象有一个属性 parent ，parent的值是Spring容器对象
SpringMVC -- parent --- Spring

SSM步骤：
1.使用之前的springdb库， 表student
2.新建maven web
3.加入maven的坐标，依赖
4.修改web.xml
  1)注册springmvc的DispatcherServlet(中央调度器)， 读取springmvc配置文件创建springnvc容器对象，创建文件中的处理器对象
  2)注册spring的监听器:ContextLOaderListener，读取spring的配置文件，创建容器对象service，dao等对象
  3)注册字符集过滤器，解决post请求乱码。

5.把程序中的包建立好，实体类包名， dao， service， controller包名

6.编写多个配置文件
  1）springmvc的配置文件
  2）spring的配置文件
  3）mybatis的主配置文件
  4）数据库的属性配置文件

7.编写代码 实体类定义， Dao接口和sql映射文件， Service接口和实现类， Controller类

8.定义视图部分， 各种jsp

1.转发和重定向

转发:

处理器方法返回ModelAndView,实现转发forward
    语法:setViewName("forward:视图文件完整路径")
 特点:不和视图解析器一同使用,就当没有视图解析器
      mv.setViewName("show");
	  mv.setViewName("forward:/WEB-INF/view/show.jsp");
这两种都是转发,第二种是显式转发,当要转发的jsp不在视图解析器目录下时,使用显式转发

重定向:

/**
     * 处理器方法返回ModelAndView,执行重定向到视图
     * 语法: mv.setViewName("redirect:视图完整路径")
     * redirect:不和视图解析器一同工作，就当项目中没有视图解析器
     *
     *
     * 重定向总结：
     *  1.重定向不能访问受保护的 /WEB-INF下面的资源
     *  2.重定向会把Model中的简单类型的数据转为String, 并把String的数据作为
     *    get请求的参数附件到 目标地址的后面。
     *
     *    对象类型的数据不能转为String，不能作为参数传递的。
     *  3.请求参数是通过param对象获取， 语法 ${param.参数名}
     */
    @RequestMapping("/other.do")
    public ModelAndView doOther(String name, Integer age){
        System.out.println("执行redirect other.do");
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname", name);
        mv.addObject("myage", age);

        //创建Student,放入到Model
        Student student = new Student();
        student.setName("zhouli");
        student.setAge(30);
        mv.addObject("mystudent", student);

        mv.setViewName("redirect:/list.jsp");

        //不能访问WEB-INF下面的资源的
        //mv.setViewName("redirect:/WEB-INF/view/show.jsp");
        /**
         * http://localhost:8080/ch06/list.jsp?myname=zhangsan&myage=22
         */
        return mv;
    }

重定向到其他处理器:

 /**
     * 重定向到其他的处理器方法
     * 语法：mv.setViewName("redirect:xxx.do")
     */
    @RequestMapping("/redirect.do")
    public ModelAndView doRedirect(String name,Integer age){
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname", name);
        mv.addObject("myage", age);
        //指定重定向到其他的处理器
        mv.setViewName("redirect:process2.do");
        // http://localhost:8080/ch06/process.do?myname=zs&myage=20
        return mv;

}
    //处理重定向过来的请求
    @RequestMapping("/process2.do")
    public String doProcess2(String myname,Integer myage){
        System.out.println("======doProcess=========" + myname + " | "+ myage);
        //转发到show.jsp
        return "show";
    }

2.异常处理

注解驱动要加入mvc的类

ch07-exception-handler:异常处理

框架异常处理模式：
 处理器中把异常抛出给框架，框架捕获异常，把捕获的异常交给异常处理器对象。
 异常处理器是框架中的特定的一些类，可以处理异常。

 异常处理器必须实现HandlerExceptionResolver接口：
   异常处理器有框架自己实现的，也可以开发人员自定义实现。

异常处理步骤:
1.新建maven web项目
2.加入依赖
3.新建一个自定义的异常类 MyUserException,再定义它的子类NameException,AgeException
4.在controller抛出NameException,AgeException
5.创建一个普通类,作用全局异常处理类
	1) 在类的上面加入一个@ControllerAdvice
	2) 在类中定义方法,方法的上面加入@ExceptionHandler
6.创建异常处理类的视图页面
7.创建springmvc的配置文件
	1)组件扫描器,扫描@Controller注解
	2) 组件扫描器,扫描@ControllerAdvice所在的包
	3)声明注解驱动

3.拦截器

1.拦截器时spirngmvc中的一种,需要实现HandlerInterceptor接口
2.拦截器和过滤器类似,功能方向侧重点不同,过滤器是哟用来过滤请求参数,设置地府编码集等工作
	拦截器是拦截用户的请求,做请求的判断处理
3.拦截器是全局的,可以对多个COntroller做拦截
	一个项目中可以有0个或多个拦截器,他们在一起拦截用户的请求
	拦截器常用在:用户登录处理,权限检查,记录日志
	
拦截器使用步骤:
	1.定义类实现HandlerInterceptor接口(实现接口中的三个方法)
	2.在spirngmvc配置文件中,生命拦截器,让框架指代拦截器的存在
		(声明拦截器,并指定拦截器的请求uri地址)
拦截器的执行时间
	1.在请求处理之前,也就是controller类中的方法执行之前先被拦截
	2.在控制器方法执行之后也会执行拦截器
	3.在请求处理完成功后也会执行拦截器

springmvc配置文件

<!--
	声明拦截器:拦截器可以有0个或者多个
	在框架中保存多个拦截器是ArrayList
按照声明的先后顺序放入到ArrayList
-->
<!--声明自定义的拦截器-->
    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <!--拦截的请求uri地址-->
            <mvc:mapping path="/**"/>
            <!--指定拦截器对象，class:拦截器类的全权限名称-->
            <bean class="com.bjpowernode.interceptor.MyInterceptor" />
        </mvc:interceptor>
        <!--声明第二个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.bjpowernode.interceptor.CheckLoginInterceptor" />
        </mvc:interceptor>
    </mvc:interceptors>

Myinterceptor三个方法:

package com.bjpowernode.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;

/**
 * Author: 动力节点
 * 2019/5/17
 *
 * 实现HandlerInterceptor接口的类是拦截器
 */
public class MyInterceptor implements HandlerInterceptor {

    private long btime = 0;

    /**
     * preHandle:预处理方法，用户的请求首先到达此方法
     *           可以请求做处理，验证登录，用户的权限处理，记录日志等
     *
     * 返回值boolean
     *  true: 拦截器和处理器方法都执行了， 也就是请求可以通过拦截器
     *  ####执行拦截器MyInterceptor的preHandle####
     *  ===执行处理器MyController的doSome===
     *  ####执行拦截器MyInterceptor的postHandle####
     *  ####执行拦截器MyInterceptor的afterCompletion####
     *
     *  false:拦截器截断了请求， 不会被处理器处理。
     *  ####执行拦截器MyInterceptor的preHandle####
     *
     * @param request 请求
     * @param response 应答
     * @param handler 被拦截的处理器对象（MyController）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime = System.currentTimeMillis();
        System.out.println("####11111执行拦截器MyInterceptor的preHandle####");
        //request.getRequestDispatcher("/result.jsp").forward(request, response);

        //RequestDispatcher rd = request.getRequestDispatcher("/result.jsp");
        //rd.forward(request, response);
        return false;
    }

    /**
     * postHandle:后处理方法，在处理器方法执行后执行的。
     *            作用是能够获取到处理器方法的执行结果ModelAndView，
     *            可以修改执行结果的数据和视图。对请求做二次的处理。
     * @param request 请求
     * @param response 应答
     * @param handler 被拦截器的处理器对象
     * @param mv 处理器方法的执行结果，方法的返回值
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("####11111执行拦截器MyInterceptor的postHandle####");
        //可以做二次的请求处理
        if(mv !=null){
            //修改数据
            mv.addObject("mydate", new Date());
            //修改视图
            mv.setViewName("other");
        }
    }

    /**
     * afterCompletion:最后执行的方法，在视图View处理完成后执行的，视图处理完成意味请求完成。
     *                 相当于程序最后执行的一个方法，可以在方法中执行资源回收，内存释放等最后要执行的工作。
     *                 afterCompletion只有在当前的拦截器preHandle()返回true时才有机会执行。
     *
     * @param request 请求
     * @param response 应答
     * @param handler 被拦截器的处理器对象
     * @param ex 程序中发生的异常
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        System.out.println("####11111执行拦截器MyInterceptor的afterCompletion####");

        long etime = System.currentTimeMillis();
        //System.out.println("请求的处理时长："+(etime - btime));
    }
}