mvc开发实战易混知识点总结

还没整理结束，会尽快
ssm
前端 service dao
Mvc视图层 界面崩 负责接收请求 显示结果
Spring业务层，管理 service，dao，工具类对象
M，持久层，访问数据库的。

用户发起请求，mvc接收，用spring的service，mybatos访问数据库

webapp文件映射

使用maven前：项目中需要的jar包必须手动复制、粘贴到WEB-INF/lib目录下

实现步骤：

0.使用springdb的mysql库， 表使用student（id auto_increment, name, age）
1.新建maven web项目
2.加入依赖
  springmvc，spring，mybatis三个框架的依赖，jackson依赖，mysql驱动，druid连接池
  jsp，servlet依赖

3.写web.xml
  1)注册DispatcherServlet ,目的：1.创建springmvc容器对象，才能创建Controller类对象。
                                2.创建的是Servlet，才能接受用户的请求。

  2）注册spring的监听器：ContextLoaderListener,目的： 创建spring的容器对象，才能创建service，dao等对象。

  3）注册字符集过滤器，解决post请求乱码的问题


4.创建包， Controller包， service ，dao，实体类包名创建好

5.写springmvc，spring，mybatis的配置文件
 1）springmvc配置文件
 2）spring配置文件
 3）mybatis主配置文件
 4）数据库的属性配置文件

6.写代码， dao接口和mapper文件， service和实现类，controller， 实体类。
7.写jsp页面

说明

Tomcat启动后，会创建dispatcherServlet对象实例，创建过程中会创建springmvc容器对象，读取springmvc配置文件，把这个文件中的对象都创建好。Servlet初始化会执行init方法，dispatcherServlet在init中 WebapplicationContext ctx = new ClassPathXmlApplicationContext(springmvc.xml)
然后把容器对象放到servletContext中
getServletContext().setAttribute(key,ctx)
这样在web项目中就可以用容器对象了。
为了tomcat启动后就创建，所以用load on startup值表示tomcat启动后创建对象的顺序，一般为1。默认读的xml文件就是servlet name，也可以用contextConfigLocation指定，

springmvc执行过程源代码分析
    
1. tomcat启动，创建容器的过程
   通过load-on-start标签指定的1，创建DisaptcherServlet对象， 
   DisaptcherServlet它的父类是继承HttpServlet的， 它是一个serlvet， 在被创建时，会执行init()方法。
   在init()方法中
   //创建容器，读取配置文件
    WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放入到ServletContext中
    getServletContext().setAttribute(key, ctx);

  上面创建容器作用： 创建@Controller注解所在的类的对象， 创建MyController对象，
   这个对象放入到 springmvc的容器中， 容器是map ， 类似 map.put("myController",MyController对象)


2.请求的处理过程
  1）执行servlet的service()
       protected void service(HttpServletRequest request, HttpServletResponse response)

       protected void doService(HttpServletRequest request, HttpServletResponse response)


      DispatcherServlet.doDispatch(request, response){
    
    
    
          调用MyController的.doSome()方法
      }

   doDispatch：springmvc中DispatcherServlet的核心方法， 所有的请求都在这个方法中完成的。

父子容器

使用spring的监听器ContextLoaderListener。

web.xml中

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

Spring会创建一个WebApplicationContext上下文，称为父上下文（父容器） ，保存在 ServletContext中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE的值。

可以使用Spring提供的工具类取出上下文对象：WebApplicationContextUtils.getWebApplicationContext(ServletContext);

DispatcherServlet是一个Servlet,可以同时配置多个，每个 DispatcherServlet有一个自己的上下文对象（WebApplicationContext），称为子上下文（子容器），子上下文可以访问父上下文中的内容，但父上下文不能访问子上下文中的内容。 它也保存在 ServletContext中，key是"org.springframework.web.servlet.FrameworkServlet.CONTEXT"+Servlet名称。当一个Request对象产生时，会把这个子上下文对象（WebApplicationContext）保存在Request对象中，key是DispatcherServlet.class.getName() + ".CONTEXT"

可以使用工具类取出上下文对象：RequestContextUtils.getWebApplicationContext(request);

说明 ：Spring 并没有限制我们，必须使用父子上下文。我们可以自己决定如何使用。

• Spring和SpringMVC是父子容器关系。
• Spring整体框架的核心思想是容器，用来管理bean的生命周期，而一个项目中会包含很多容器，并且它们分上下层关系，目前最常用的一个场景是在一个项目中导入Spring和SpringMVC框架，而Spring和SpringMVC其实就是两个容器，Spring是父容器，SpringMVC是子容器，Spring父容器中注册的Bean对SpringMVC子容器是可见的，SpringMVC可以访问Springbean对象，反之则不行。
• 按照官方文档推荐，根据不同的业务模块来划分不同的容器中注册不同的Bean，SpringMVC主要就是为我们构建web应用程序，那么SpringMVC子容器用来注册web组件的Bean，如控制器、处理器映射、视图解析器等。而Spring用来注册其他Bean，这些Bean通常是驱动应用后端的中间层和数据层组件。Get与post不匹配报错405
  填了空，请求到后端转不成int，报错400

注解驱动标签

没有加入注解驱动标签时的状态
org.springframework.http.converter.ByteArrayHttpMessageConverter 
org.springframework.http.converter.StringHttpMessageConverter
org.springframework.http.converter.xml.SourceHttpMessageConverter
org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter


加入注解驱动标签时的状态
org.springframework.http.converter.ByteArrayHttpMessageConverter
org.springframework.http.converter.StringHttpMessageConverter
org.springframework.http.converter.ResourceHttpMessageConverter
org.springframework.http.converter.ResourceRegionHttpMessageConverter
org.springframework.http.converter.xml.SourceHttpMessageConverter 
org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter 
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

请求由那些服务器程序处理的

发起的请求是由哪些服务器程序处理的。

*.do时

• http://localhost:8080/ch05_url_pattern/index.jsp ：tomcat（jsp会转为servlet）
• http://localhost:8080/ch05_url_pattern/js/jquery-3.4.1.js ： tomcat
• http://localhost:8080/ch05_url_pattern/images/p1.jpg ： tomcat
• http://localhost:8080/ch05_url_pattern/html/test.html： tomcat
• http://localhost:8080/ch05_url_pattern/some.do ： DispatcherServlet（springmvc框架处理的）

tomcat本身能处理静态资源的访问， 像html， 图片， js文件都是静态资源


tomcat的web.xml文件有一个servlet 名称是 default ， 在服务器启动时创建的。
 <servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

	  <servlet-mapping>
	    <servlet-name>default</servlet-name>
            <!--表示静态资源和未映射的请求都这个default处理-->
	    <url-pattern>/</url-pattern>  
	</servlet-mapping>


default这个servlet作用： 
The default servlet for all web applications, that serves static  
resources.  It processes all requests that are not mapped to other  
servlets with servlet mappings (defined either here or in your own   
web.xml file).

1.处理静态资源
2.处理未映射到其它servlet的请求。

Post需要解决乱码问题
RequestParam改名
直接用对象也能接受到。可以多个，set方法相当于都会set

视图是转发操作
Json包依赖是core和databind
单使用json的话类是ObjectMapper。
返回对象是ResponseBody，mvc用的是。需要加标签 mvc annotation driven
Java对象转json时会遍历每个实现类中的canWrite方法，然后调用write
转换器里还有编码等设置
Jq的函数$.each
字符串用text接收，编码是8859-1，乱码问题百度mapping注解里的produce。过滤器是不好用的，因为responsebody是通过网络的方式输入输出的

Jsp是tomcat处理的，是一个servlet
Js是tomcat
Jpg是tomcat，跟mvc没有关系
Html是tomcat，是用tomcat默认的servlet处理的
普通请求是dispatcherServlet处理的。

Tomcat可以处理静态资源和不归dispatcherServlet管的请求。

Tomcat是/，所以如果dispatcherServlet设置为/，那么可以做的是拦截静态和所有未映射到其他servlet的请求。他会替代tomcat的，优先级更高。

那么设置了静态资源访问路径，那么他们就可以被访问了，因为/不拦截别人映射过的。

• 解决方法1 Mvc default-servlet handler标签，会对进入dispatcherServlet的请求筛查，如果是静态资源，就将该请求转由web应用服务器默认的servlet处理。一般的服务器都有 默认的servlet，那不又交给tomcat了。又能正常访问了。细说是加注解后就注册了个DefaultServletHttpRequestHandler控制器对象。他把请求转发给tomcat的default这个servlet
  （转发的原理是获得requestDispatcher。rp接下来是转发和重定向（request,response）
  根据请求得到rd
  但是访问我们正常的controller发现访问不到，原因是这个注解和RequestMapping注解有冲突，得加强注解驱动来解决这个问题
• 第二种方式是加mvc resouces标签。。这个标签会创建ReeoucrHttpRequestHandler对象，处理静态资源的访问，不依赖tomcat服务器。也得加注解驱动
• 更好的方式是给静态资源创建static目录。放到里面就可以了。

路径问题

<url-pattern>路径问题

<url-pattern> 在这里写路径 </url-pattern>

• *.do：
• /*：jsp过来也走他的servlet。会匹配*.jsp，会出现返回jsp视图时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。
• /：jsp过来不走他的servlet。 不会匹配到*.jsp，即：*.jsp不会进入spring的 DispatcherServlet类 。首先/这个是表示默认的路径，及表示：当没有找到可以匹配的URL就用这个URL去匹配。
• /**：这个不是url中的，是拦截器中高端<mvc:mapping path="/**">

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

地址分类：
 1.绝对地址 ， 带有协议名称的是绝对地址，  http://www.baidu.com , ftp://202.122.23.1
 2.相对地址， 没有协议开头的， 例如 user/some.do  , /user/some.do
              相对地址不能独立使用，必须有一个参考地址。 通过参考地址+相对地址本身才能指定资源。

				  张三同学， 1班有张三， 2班也有张三

 3.参考地址
    1） 在你的页面中的，访问地址不加 "/"

	 访问的是： http://localhost:8080/ch06_path/index.jsp
	  路径： http://localhost:8080/ch06_path/
		资源： index.jsp
	
	在index.jsp发起 user/some.do请求，访问地址变为 http://localhost:8080/ch06_path/user/some.do
	   当你的地址 没有斜杠开头,例如 user/some.do , 当你点击链接时， 访问地址是当前页面的地址
		加上链接的地址。
	  http://localhost:8080/ch06_path/ + user/some.do


     -------------------------------------------------------------
      index.jsp  访问 user/some.do  ， 返回后现在的地址： http://localhost:8080/ch06_path/user/some.do
    
      http://localhost:8080/ch06_path/user/some.do
      路径：	  http://localhost:8080/ch06_path/user/
      资源：   some.do
    
      在index.jsp在 user/some.do ，就变为 http://localhost:8080/ch06_path/user/user/some.do
    
      解决方案：
       1.加入${pageContext.request.contextPath}
    	2.加入一个base标签， 是html语言中的标签。 表示当前页面中访问地址的基地址。
    	  你的页面中所有 没有“/”开头的地址，都是以base标签中的地址为参考地址
        使用base中的地址 + user/some.do 组成访问地址




   2）在你的页面中的，访问地址加 "/"
      访问的是： http://localhost:8080/ch06_path/index.jsp
      路径： http://localhost:8080/ch06_path/
		资源： index.jsp

		点击 /user/some.do, 访问地址变为 http://localhost:8080/user/some.do
		参考地址是 你的服务器地址， 也就是 http://localhost:8080


		如果你的资源不能访问： 加入${pageContext.request.contextPath}
		<a href="${pageContext.request.contextPath}/user/some.do">发起user/some.do的get请求</a>



index.jsp--addStudent.jsp---student/addStudent.do( service的方法，调用dao的方法)--result.jsp

请求转发和重定向

ch08-forard-redirect:转发和重定向

forward：表示转发
redirect：表示重定向
forward和redirect都是关键字， 有一个共同的特点不和视图解析器一同工作


扩展：
forward和redirect他们都可以访问 视图文件，比如某个jsp ，html
 forward:/hello.jsp  forward:/main.html

forward和redirect他们都可以访问其它的controller
 forward:/some.do , redirect:/other.do

处理器方法可以返回ModelAndView, String , void 都可以使用forward，redirect

项目模板

POM.XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.atguigu</groupId>
	<artifactId>ssm-crud</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>


	<!--引入项目依赖的jar包 -->
	<!-- SpringMVC、Spring -->
	<dependencies>

		<!--引入pageHelper分页插件 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>5.0.0</version>
		</dependency>

		<!-- MBG -->
		<dependency>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-core</artifactId>
			<version>1.3.5</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>

		<!-- 返回json字符串的支持 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.8.8</version>
		</dependency>

		<!--JSR303数据校验支持；tomcat7及以上的服务器， 
		tomcat7以下的服务器：el表达式。额外给服务器的lib包中替换新的标准的el
		-->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<version>5.4.1.Final</version>
		</dependency>


		<!-- Spring-Jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>

		<!--Spring-test -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>


		<!-- Spring面向切面编程 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>

		<!--MyBatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.2</version>
		</dependency>
		<!-- MyBatis整合Spring的适配包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.1</version>
		</dependency>

		<!-- 数据库连接池、驱动 -->
		<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
		<dependency>
		    <groupId>c3p0</groupId>
		    <artifactId>c3p0</artifactId>
		    <version>0.9.1.2</version>
		</dependency>



		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.41</version>
		</dependency>
		<!-- （jstl，servlet-api，junit） -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.0.1</version>
			<scope>provided</scope>
		</dependency>


		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>




</project>

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_4_0.xsd"
         version="4.0">


    <!--注册中央调度器dispatcherServlet springmvc.xml-->
    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:conf/springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

    <!--注册spring的监听器  ContextLoaderListener   applicationContext.xml-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:conf/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--注册字符集过滤器  CharacterEncodingFilter-->
    <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>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <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>


</web-app>

这段配置将spring框架继承集成到我们的项目中。有一个监听器和web应用的初始化参数。spring提供的监听器实现了ServletContextListener接口，只要一个类实现了这个接口，web应用对象初始化的时候就可以监听到并且执行他对应的方法。方法中调用contextInitialized方法，就会初始化spring的环境。contextInitialized初始化方法会通过sc.getIniyParameter方法得到我们的初始化参数contextConfigLocation参数。然后通过把得到的value（applicationContext.xml）通过wac.setConfigLocation，设定到属性中，刷新的时候会加载配置文件，来初始化整个环境。

Springmvc核心是一个servlet，他严格遵循mvc架构，所以在web.xml中配置springmvc的转发servlet。他也有初始化参数，也会读取配置文件。此外配置自启。

两者是监听器先执行。因为监听的是web应用的初始化。

字符编码过滤器，也可以写servlet-name标签代替url-pattern标签，只要请求被servlet连接到后，就会执行对应的filter。这只是post方式的编码，get方式的要在server.xml中设置。

applicationContext.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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明service的注解@Service所在的包名位置-->
    <context:component-scan base-package="com.bjpowernode.service" />

    <!-- 配置数据源, 整合其他框架, 事务等. -->
    <context:property-placeholder location="classpath:conf/jdbc.properties" />

    <!--声明数据源，连接数据库-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!--SqlSessionFactoryBean创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation"  value="classpath:conf/mybatis.xml" />
    </bean>
    
    <!--声明mybatis的扫描器，创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="com.bjpowernode.dao" />
    </bean>
    
    <!--事务配置：注解的配置， aspectj的配置-->
</beans>

也就是spring配置文件。扫描我们注解的类。需要指定扫描的包。并且排除controller注解的扫描。因为springmvc会扫描。

springmvc.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.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-4.0.xsd">

    <!--springmvc配置文件， 声明controller和其它web相关的对象-->
    <context:component-scan base-package="com.atguigu.springmvc"/> 
    
    <!-- 配置视图解析器 -->
    <bean id="internalResourceViewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <mvc:default-servlet-handler/> 
    <mvc:annotation-driven/> 
        <!--
      1. 响应ajax请求，返回json
      2. 解决静态资源访问问题。
    -->
</beans>

因为我们刚才没有扫描controller注解。所以我们要在这里扫描这个注解。并且不要扫描其他注解了。所以把默认的过滤去掉了。

为了让springmvc程序能处理自己的一些程序。而不进行拦截。所以增加了handler和driven。

视图解析器。如何跳转找到页面。

当不是跳转页面时候，想将结果返回给页面时返回的格式。告诉浏览器返回的是json和编码。

文件上传解析器。

mybatis.xml

需要spring通过单例方式管理SqlSessionFactory。

spring和mybatis整合生成代理对象，使用SqlSessionFactory创建SqlSession。（spring和mybatis整合自动完成）

持久层的mapper都需要由spring进行管理。

<?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：控制mybatis全局行为-->
   <!-- <settings>
        &lt;!&ndash;设置mybatis输出日志&ndash;&gt;
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>-->

    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名(不是实体类的包名也可以)-->
        <package name="com.bjpowernode.domain"/>
    </typeAliases>


    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--
          name：是包名， 这个包中的所有mapper.xml一次都能加载
          使用package的要求：
           1. mapper文件名称和dao接口名必须完全一样，包括大小写
           2. mapper文件和dao接口必须在同一目录
        -->
        <package name="com.bjpowernode.dao"/>
    </mappers>
</configuration>

jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.username=root
jdbc.password=123456

整合环境

jar包：

• mybatis3.2.7的jar包(+mysql包)
• spring3.2.0的jar包
• mybatis和spring的整合包：早期ibatis和spring整合是由spring官方提供，mybatis和spring整合由mybatis提供。下载。最新1.3.1

sqlSessionFactory

• controller的扫描是mvc负责的，所以spring扫描时候不要扫描进去。在spring配置文件，指定扫描的注解的包。排除controller注解的扫描。

然后把mybatis框架的核心对象sqlSessionFactory进行配置，并且增加对属性参数的赋值。

而dataSource因为使用了c3p0的数据库连接池类建立数据库的连接，提高数据库的访问性能，采用的是mysql数据库，默认的端口号是3306。

Bean mapperScanConfigurer。还要扫描dao接口。因为mybatis是通过dao接口和数据库进行交互的。

事务处理。要不完全成功，要不完全失败。并且使用切入点表达式将事物应用到业务中。只不过spring只支持方法连接点操作，意味着我们要增加事物管理功能只能在方法中增加。所以我们通过配置tx method对不同的方法进行不同的事务处理。比如以query开头的查询方法。我们就采用只读事务，只读事务会提升我们的访问效率。告诉数据库我们只查询不更改，你也不要做。其他方法采用的是其他的事务处理。设定了传播行为，隔离级别，default代表采用数据库自身的隔离级别，如果用mysql的话就是用mysql的。还有事务回滚策略。spring默认的是运行期异常才回滚。

问题与解决

• 页面样式不够统一：layer
• 页面会发生也能够闪烁现象：会先清空页面，再渲染新的页面。所以使用ajax
• 重新输入账号密码应该回显：也是上面的闪烁现象引起的

UI线程提交请求后会清空页面。所以需要在浏览器中创建一个新的线程。得到结果后通知UI线程显示数据。