ssm框架整合

首先明确一点就是，web项目的入库是在web.xml下的，所有的配置文件无论怎么注入都要最终到这个配置文件里面（日志文件除外）

首先配置

pom.xml

（springframework整合spring框架，整合mybatis框架，mysql驱动，druid连接池，整合log4j，ackson Json处理工具包，Servlet/JSP/JSTL，单元测试，Spring对JDBC数据访问进行封装的所有类）

  1. <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">
  2.   <modelVersion>4.0.0</modelVersion>
  3.   <groupId>com.zxl</groupId>
  4.   <artifactId>test</artifactId>
  5.   <version>0.0.1-SNAPSHOT</version>
  6.   <packaging>war</packaging>
  8.   <!-- 集中定义依赖版本号 -->
  9.   <properties>
  10.     <junit.version>4.10</junit.version>
  11.     <spring.version>4.1.3.RELEASE</spring.version>
  12.     <mybatis.version>3.2.8</mybatis.version>
  13.     <mybatis.spring.version>1.2.2</mybatis.spring.version>
  14.     <mysql.version>5.1.32</mysql.version>
  15.     <druid.version>1.1.6</druid.version>
  16.     <slf4j.version>1.6.4</slf4j.version>
  17.     <jstl.version>1.2</jstl.version>
  18.     <servlet-api.version>2.5</servlet-api.version>
  19.     <jsp-api.version>2.0</jsp-api.version>
  20.     <jackson.version>2.4.2</jackson.version>
  21.   </properties>
  23.   <dependencies>
  24.     <!-- 单元测试 -->
  25.     <dependency>
  26.       <groupId>junit</groupId>
  27.       <artifactId>junit</artifactId>
  28.       <version>${junit.version}</version>
  29.       <scope>test</scope>
  30.     </dependency>
  31.     <!-- 整合spring框架（包含springmvc） 这个jar文件包含springmvc开发时的核心类, 同时也会将依赖的相关jar文件引入进来(spring的核心jar文件也包含在内) -->
  32.     <dependency>
  33.       <groupId>org.springframework</groupId>
  34.       <artifactId>spring-webmvc</artifactId>
  35.       <version>${spring.version}</version>
  36.     </dependency>
  38.     <!--这个jar文件包含对Spring对JDBC数据访问进行封装的所有类 -->
  39.     <dependency>
  40.       <groupId>org.springframework</groupId>
  41.       <artifactId>spring-jdbc</artifactId>
  42.       <version>${spring.version}</version>
  43.     </dependency>
  44.     <dependency>
  45.       <groupId>org.springframework</groupId>
  46.       <artifactId>spring-aspects</artifactId>
  47.       <version>${spring.version}</version>
  48.     </dependency>
  50.     <!-- 整合mybatis框架 -->
  51.     <dependency>
  52.       <groupId>org.mybatis</groupId>
  53.       <artifactId>mybatis</artifactId>
  54.       <version>${mybatis.version}</version>
  55.     </dependency>
  56.     <dependency>
  57.       <groupId>org.mybatis</groupId>
  58.       <artifactId>mybatis-spring</artifactId>
  59.       <version>${mybatis.spring.version}</version>
  60.     </dependency>
  61.     <!-- mysql驱动 -->
  62.     <dependency>
  63.       <groupId>mysql</groupId>
  64.       <artifactId>mysql-connector-java</artifactId>
  65.       <version>${mysql.version}</version>
  66.     </dependency>
  67.     <!-- druid连接池 -->
  68.     <dependency>
  69.       <groupId>com.alibaba</groupId>
  70.       <artifactId>druid</artifactId>
  71.       <version>${druid.version}</version>
  72.     </dependency>
  74.     <!-- 整合log4j -->
  75.     <dependency>
  76.       <groupId>org.slf4j</groupId>
  77.       <artifactId>slf4j-log4j12</artifactId>
  78.       <version>${slf4j.version}</version>
  79.     </dependency>
  80.     <!-- Jackson Json处理工具包 -->
  82.     <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
  83.     <dependency>
  84.       <groupId>com.fasterxml.jackson.core</groupId>
  85.       <artifactId>jackson-databind</artifactId>
  86.       <version>2.10.0.pr1</version>
  87.     </dependency>
  90.     <!-- Servlet/JSP/JSTL -->
  91.     <dependency>
  92.       <groupId>javax.servlet</groupId>
  93.       <artifactId>servlet-api</artifactId>
  94.       <version>${servlet-api.version}</version>
  95.       <scope>provided</scope>
  96.     </dependency>
  97.     <dependency>
  98.       <groupId>javax.servlet</groupId>
  99.       <artifactId>jsp-api</artifactId>
  100.       <version>${jsp-api.version}</version>
  101.       <scope>provided</scope>
  102.     </dependency>
  103.     <dependency>
  104.       <groupId>jstl</groupId>
  105.       <artifactId>jstl</artifactId>
  106.       <version>${jstl.version}</version>
  107.     </dependency>
  109.   </dependencies>
  110. </project>

web.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xmlns="http://java.sun.com/xml/ns/javaee"
  4.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5.          version="2.5">
  6.   <!--项目名字-->
  7.   <display-name>SSMDemo</display-name>
  8.   <!--项目主页寻找地址-->
  9.   <welcome-file-list>
  10.     <welcome-file>index.html</welcome-file>
  11.     <welcome-file>index.htm</welcome-file>
  12.     <welcome-file>index.jsp</welcome-file>
  13.     <welcome-file>default.html</welcome-file>
  14.     <welcome-file>default.htm</welcome-file>
  15.     <welcome-file>default.jsp</welcome-file>
  16.   </welcome-file-list>
  18.   <!-- 配置前端控制器 -->
  19.   <servlet>
  20.     <servlet-name>springmvc</servlet-name>
  21.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  22.     <!--使用通配符加载spring容器这里不仅仅加载了springmvc也加载了applicationContext.xml等什么的-->
  23.     <init-param>
  24.       <param-name>contextConfigLocation</param-name>
  25.       <param-value>classpath:spring/*.xml</param-value>
  26.     </init-param>
  28.   </servlet>
  29.   <!--拦截所有的请求-->
  30.   <servlet-mapping>
  31.     <servlet-name>springmvc</servlet-name>
  32.     <url-pattern>/</url-pattern>
  33.   </servlet-mapping>

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  4.        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  8.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
  9.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
  11.     <!-- 1.加载jdbc.properties文件的位置 -->
  12.     <context:property-placeholder location="classpath:db.properties" />
  14.     <!-- 2.配置durid连接池, id是固定值, class是druid连接池类的全路径 -->
  15.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  16.         <!-- 配置连接数据库的基本信息 -->
  17.         <property name="driverClassName" value="${db.driverClassName}"></property>
  18.         <property name="url" value="${db.url}"></property>
  19.         <property name="username" value="${db.username}"></property>
  20.          <property name="password" value="${db.password}"></property>
  21.     </bean>
  23. <!--    &lt;!&ndash;事务管理器，对mybatis操作数据库事务控制，spring使用jdbc的事务控制类&ndash;&gt;-->
  24. <!--    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">-->
  25. <!--        &lt;!&ndash;数据源&ndash;&gt;-->
  26. <!--        <property name="dataSource" ref="dataSource"/>-->
  28. <!--    </bean>-->
  32. <!--    &lt;!&ndash;通知也叫传播行为  transaction-manager通知给事务管理器&ndash;&gt;-->
  33. <!--    <tx:advice id="txAdvice" transaction-manager="transactionManager">-->
  34. <!--        <tx:attributes>-->
  35. <!--            <tx:method name="save*" propagation="REQUIRED"/>-->
  36. <!--            <tx:method name="delete*" propagation="REQUIRED"/>-->
  37. <!--            <tx:method name="insert*" propagation="REQUIRED"/>-->
  38. <!--            <tx:method name="update*" propagation="REQUIRED"/>-->
  39. <!--            &lt;!&ndash;支持事务。码晕就算了，这个是只读&ndash;&gt;-->
  40. <!--            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>-->
  41. <!--            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>-->
  42. <!--            <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>-->
  43. <!--        </tx:attributes>-->
  45. <!--    </tx:advice>-->
  46. <!--&lt;!&ndash;aop事务控制&ndash;&gt;-->
  47. <!--    <aop:config>-->
  48. <!--        &lt;!&ndash;切点，切om.wtu.下的service下的impl下的*（所有类的）*（所有方法）（..）不管什么参数  和下面的pointcut一一对应&ndash;&gt;-->
  49. <!--        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wtu.service.impl.*.*(..))"/>-->
  50. <!--    </aop:config>-->
  53.     <!-- 3.整合Spring和mybatis框架 将SqlSession等对象的创建交给Spring容器 id值(sqlSessionFactory)是固定值 -->
  54.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  55.         <!-- 3.1 指定mybatis核心配置文件的位置 -->
  56.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
  57.         <!-- 3.2 配置连接池(数据源) ref指向连接池bean对象的id值 -->
  58.         <property name="dataSource" ref="dataSource" />
  59.         <!-- 3.3 扫描所有的XxxMapper.xml映射文件, 读取其中配置的SQl语句 -->
  60.         <property name="mapperLocations" value="classpath:mybatis/mapper/*.xml" />
  61.     </bean>
  64.     <!-- 4. 定义mapper接口扫描器 配置所有mapper接口所在的包路径, 将来由Spring + myBatis框架来为接口 提供实现类,
  65.         以及实现类的实例也有Spring框架来创建 -->
  66.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  67.         <!-- 扫描所有XxxMapper接口, 将接口实例的创建交给Spring容器 -->
  68.         <property name="basePackage" value="com.wtu.dao" />
  69.         <!--猜测加上之后，可以通过XxxMappe.xml和XxxMapper.java自动匹配，要在同一个目录下-->
  70. <!--        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>-->
  71.     </bean>
  73.     <!-- 5.配置需要扫描的包(server层): Spring自动去扫描base-package下的类 如果扫描到的类上有@Controller,@Service,@Component等注解,
  74.         将会自动 将类注册为bean(即由Spring创建实例) -->
  75.     <context:component-scan base-package="com.wtu.service">
  76.     </context:component-scan>
  78. </beans>

springmvc-config.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/mvc
  6.                         http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
  7.                         http://www.springframework.org/schema/beans
  8.                         http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  9.                         http://www.springframework.org/schema/context
  10.                           http://www.springframework.org/schema/context/spring-context-4.0.xsd">
  12.     <!-- 1.配置前端控制器访问静态资源(html/css/js等,否则静态资源将无法访问) -->
  13.     <mvc:default-servlet-handler />
  15.     <!-- 2.配置注解驱动,用于识别注解(比如@Controller) -->
  16.     <mvc:annotation-driven></mvc:annotation-driven>
  18.             <!-- 3.配置需要扫描的包: Spring自动去扫描base-package 下的类, 如果扫描到的类上有@Controller,@Service,@Component等注解
  19.                 将会自动将类注册为bean -->
  20.     <context:component-scan base-package="com.wtu.controller">
  21.     </context:component-scan>
  23.     <!-- 4.配置内部资源视图解析器 prefix: 配置路径前缀 suffix: 配置文件后缀 -->
  24.     <bean
  25.             class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  26.         <property name="prefix" value="/WEB-INF/pages/" />
  27.         <property name="suffix" value=".jsp" />
  28.     </bean>
  29.     <!-- 对静态资源的访问 -->
  30.     <mvc:resources location="/static/" mapping="/static/**" />
  32. </beans>

mybatis-config.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  6. <!-- MyBatis的全局配置文件 -->
  7. <configuration >
  8.     <!-- 整合mybatis和Spring框架, 需要将mybatis的相关配置
  9.         在Spring的配置文件中进行配置
  10.      -->
  11. </configuration>

db.properties

  1. db.driverClassName=com.mysql.jdbc.Driver
  2. db.url=jdbc:mysql://localhost:3306/myweb?characterEncoding=utf-8
  3. db.username=root
  4. db.password=123456

总结：

1.pom.xml配置如下

（springframework整合spring框架，整合mybatis框架，mysql驱动，druid连接池，整合log4j，ackson Json处理工具包，Servlet/JSP/JSTL，单元测试，Spring对JDBC数据访问进行封装的所有类）

2.web.xml配置如下

项目名字 项目主页寻找地址 前端控制器（加载spring容器，在这个同时也加载springmvc）前端控制器就是用的DispatcherServlet 然后加载spring容器，我把spring所有的文件全部放在看spring下面，所有我用通配符就行可以了

  1. <!-- 配置前端控制器 -->
  2. <servlet>
  3. <servlet-name>springmvc</servlet-name>
  4. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5. <!--使用通配符加载spring容器这里不仅仅加载了springmvc也加载了applicationContext.xml等什么的-->
  6. <init-param>
  7. <param-name>contextConfigLocation</param-name>
  8. <param-value>classpath:spring/*.xml</param-value>
  9. </init-param>

拦截所有请求

  1. <!--拦截所有的请求-->
  2. <servlet-mapping>
  3. <servlet-name>springmvc</servlet-name>
  4. <url-pattern>/</url-pattern>
  5. </servlet-mapping>

applicationContext.xml配置如下

配置jdbc，先加载jdbc连接配置文件的位置

  1. <!-- 1.加载jdbc.properties文件的位置 -->
  2.  <context:property-placeholder location="classpath:db.properties" />

配置连接池durid，和c3p0等都可以

  1.  <!-- 2.配置durid连接池, id是固定值, class是druid连接池类的全路径 -->
  2.  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  3.      <!-- 配置连接数据库的基本信息 -->
  4.      <property name="driverClassName" value="${db.driverClassName}"></property>
  5.      <property name="url" value="${db.url}"></property>
  6.      <property name="username" value="${db.username}"></property>
  7.       <property name="password" value="${db.password}"></property>
  8.  </bean>

（配置事务管理，对mybatis操作数据库事务控制，spring使用jdbc的事务控制类）（此项目前不清楚是做什么的，不配置也可以）

  1. <!--事务管理器，对mybatis操作数据库事务控制，spring使用jdbc的事务控制类-->
  2.  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  3.      <!--数据源-->
  4.      <property name="dataSource" ref="dataSource"/>
  6.  </bean>

（传播行为 transaction-manager通知给事务管理器）此项目前不清楚是做什么的，不配置也可以）猜测是用来规范编码，的在接口方法命名上要符合这个的规则

  1. <!--通知也叫传播行为  transaction-manager通知给事务管理器-->
  2.  <tx:advice id="txAdvice" transaction-manager="transactionManager">
  3.      <tx:attributes>
  4.          <tx:method name="save*" propagation="REQUIRED"/>
  5.          <tx:method name="delete*" propagation="REQUIRED"/>
  6.          <tx:method name="insert*" propagation="REQUIRED"/>
  7.          <tx:method name="update*" propagation="REQUIRED"/>
  8.          <!--支持事务。码晕就算了，这个是只读-->
  9.          <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
  10.          <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
  11.          <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
  12.      </tx:attributes>
  14.  </tx:advice>

（事务控制）

  1. <!--aop事务控制-->
  2.  <aop:config>
  3.      <!--切点，切om.wtu.下的service下的impl下的*（所有类的）*（所有方法）（..）不管什么参数  和下面的pointcut一一对应-->
  4.  <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.wtu.service.impl.*.*(..))"/>
  5.  </aop:config>

整合spring和mybatis框架，将SqlSessionFactory交个spring容器，读取xml中的sql语句，然后交个spring来管理

  1. <!-- 3.整合Spring和mybatis框架 将SqlSession等对象的创建交给Spring容器 id值(sqlSessionFactory)是固定值 -->
  2.  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  3.      <!-- 3.1 指定mybatis核心配置文件的位置 -->
  4.      <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
  5.      <!-- 3.2 配置连接池(数据源) ref指向连接池bean对象的id值 -->
  6.      <property name="dataSource" ref="dataSource" />
  7.      <!-- 3.3 扫描所有的XxxMapper.xml映射文件, 读取其中配置的SQl语句 -->
  8.      <property name="mapperLocations" value="classpath:mybatis/mapper/*.xml" />
  9.  </bean>

定义mapper接口扫描器，配置所有mapper的包路径，将来由spring+mybatis框架为接口来提供服务(扫描dao层)

  1. <!-- 4. 定义mapper接口扫描器 配置所有mapper接口所在的包路径, 将来由Spring + myBatis框架来为接口 提供实现类,
  2.      以及实现类的实例也有Spring框架来创建 -->
  3.  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  4.      <!-- 扫描所有XxxMapper接口, 将接口实例的创建交给Spring容器 -->
  5.      <property name="basePackage" value="com.wtu.dao" />
  6.      <!--猜测加上之后，可以通过XxxMappe.xml和XxxMapper.java自动匹配，要在同一个目录下-->
  7. <!--   <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>-->
  8.  </bean>

配置要扫描的service层的包，spring去自动扫描类，扫描注解（扫描service层）

  1. <!-- 5.配置需要扫描的包(server层): Spring自动去扫描base-package下的类 如果扫描到的类上有@Controller,@Service,@Component等注解,
  2.      将会自动 将类注册为bean(即由Spring创建实例) -->
  3.  <context:component-scan base-package="com.wtu.service">
  4.  </context:component-scan>

springmvc-config.xml

配置注解驱动，用于识别注解，比如@controller@RequestMapping等

  1. <mvc:annotation-driven></mvc:annotation-driven>
  2. <!--这个就相当于做完了处理器映射器和处理器适配器-->

配置需要去自动扫描的包，sprig就会去自动扫描对应下面的注解

  1. <context:component-scan base-package="com.wtu.controller">
  2.  </context:component-scan>

视图解析器prefix配置路径前缀，suffix配置文件后缀

  1. <bean
  2.          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  3.      <property name="prefix" value="/WEB-INF/pages/" />
  4.      <property name="suffix" value=".jsp" />
  5.  </bean>

配置静态资源扫描。对于访问这个文件夹下面的资源就放行

  1. <mvc:resources location="/static/" mapping="/static/**" />

mybatis-config.xml

此文件已经被spring整合了里面本来应该配置数据链接信息，和数据连接池。然后包这个文件注入spring中，现在我直接放到了applicationContext中所有这个文件暂时没有用

ssm请求流程

SSM框架整合 - 图1

首先，1用户发起请求, 用户的请求到中央控制器DispatcherServlet，拦截所有请求， 2调用处理器映射器找到处理器annotation-driven（这里通过注解扫描扫描到RequestMapper，通过这个知道请求路径） 3.返回HandlerExecutionChan（处理器拦截器）看这个请求是否拦截，这个返回到终于控制器 然后返回了一个执行链之后对于这个链条去执行 4.通过处理器适配器调用具体方法（因为对于请求的参数问题，参数自己匹配啊什么的，可能还是因为web开发要调用到service接口，这个没有继承任然可以做到，就是要去适配一下，通过扫描到controller接口然后在去适配的） 5.调用具体的Handler（处理器也叫controller控制器） 5.1处理器简单的分三层架构，controller，service和dao 5.2 Controller（上面所有的请求都是到这一层，然后控制层去调用service，服务层，服务层去调用dao层） 5.3 controller调service的接口，接口实现类里面调用dao层的接口，dao层通过mybatis去调用到对应的xml文件 里面的sql语句，然后操作的结果（查询结果，增删改等操作成功或失败等）返回到service 5.4 service这一层如果要对数据进行处理，那么处理之后就返回给controller 6.controller层最好通过ModelAndView去返回页面地址和数据给处理器适配器 7.处理器适配器把这个ModelAndView返回到中央控制器DispatcherServlet 8.中央控制器DispatcherServlet把这个View给ViewResolver（视图解析器） 9.ViewResolver（视图解析器）返回数据给中央控制器DispatcherServlet 10，进行视图渲染，填充Model等，得到一个完整的View视图 11.返回把这个视图返回给用户

mybatis

放在resource下面，然后可以自动扫描到

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--xml在头标签中配置与mybatis层的连接-->
  3. <!DOCTYPE configuration
  4.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  6. <configuration>
  7.     <environments default="dev">
  8.         <environment id="dev">
  9.             <transactionManager type="JDBC"></transactionManager>
  10.             <!--链接属性数据-->
  11.             <dataSource type="POOLED">
  12.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  13.                 <property name="url" value="jdbc:mysql://localhost:3306/myweb?characterEncoding=utf-8"/>
  14.                 <property name="username" value="root"/>
  15.                 <property name="password" value="123456"/>
  16.             </dataSource>
  17.         </environment>
  18.     </environments>
  19.     <!--配置映射文件位置-->
  20.     <mappers>
  21.         <mapper resource="mapper/user.xml"></mapper>
  22.     </mappers>
  23. </configuration>

工具类，创建工厂的，返回session

  1.     public SqlSession openMyBatis(){
  2.         /*确定指令连接对象*/
  3.         SqlSessionFactory sqlSessionFactory;
  4.         /*sqlsession为指令执行对象*/
  5.         SqlSession session=null;
  6.         String resources= "mybatis.xml";
  7.         try {
  8.             InputStream inputStream = Resources.getResourceAsStream(resources);
  9.             /*如果配置文件正常加载，就开始连接数据库*/
  10.             sqlSessionFactory =new SqlSessionFactoryBuilder().build(inputStream);
  11.             /*sql指令执行环节session调用工具方法，实例化成功
  12.              * 获取到dao层接口，并实例化*/
  13.             session= sqlSessionFactory.openSession();
  15.         }catch (Exception e){
  16.             e.printStackTrace();
  17.             System.out.println("mybatis实例化失败");
  18.         }
  19.         return session;
  20.     }
  21.     public static void closeMybatis(SqlSession sqlSession){
  22.         if (sqlSession!=null){
  23.             sqlSession.close();
  24.         }
  25.     }

具体实现类

  1.    public void LoginServlet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  2.         String name = request.getParameter("fAccount");
  3.         String password =request.getParameter("fPassword");
  4.         MybatisConfig mybatisConfig = new MybatisConfig();
  5.         SqlSession session=mybatisConfig.openMyBatis();
  6.         UserDao userDao =session.getMapper(UserDao.class);
  8.         List<Map<String, Object>> list = userDao.selectUserAll();
  10.         for (Map<String, Object> map : list) {
  11.             if (map.get("name").equals(name)&&map.get("password").equals(password)){
  12.                 request.setAttribute("msg","看见我就是登录成功");
  13.                 request.getRequestDispatcher("/WEB-INF/success.jsp").forward(request,response);
  14.                 break;
  15.             }
  16.         }
  17.         request.setAttribute("msg","看见我就是登录失败，失败，失败，重要的事说三遍，滚回去改代码去");
  18.         request.getRequestDispatcher("/WEB-INF/failure.jsp").forward(request,response);
  20.     }

调用工具类返回session，然后通过session去调用getMapper（传递接口的字节码）所以这个就是调用的这个接口的实例化对象

然后在根据这个对象调用相应的sql语句，执行sql语句，只需要关注两点，传入参数和返回对象

在web项目中，java代表了web的后端开发区域

com.stu.ssm代表了项目的主题包，所有的自保都要在主题包中简历

1.base：项目的前端板块，客户浏览板块，给网页浏览者查看的区域板块，一般不需要账户登录，可直接查看

2.basemanage：项目的后端板块，管理员运营板块，有相关盈利机构组织负责人员进行账号登陆权限管理，对base客户浏览页面板块进行及时的数据文字报道，视频，音频，图像，消费品广告信息进行上下架更新管理

3.filter：web项目的过滤器，对整套系统安全性方木啊的数据过滤，请求过滤，(后端控制层的)

4.interceptor web项目的拦截器，对访问jsp及整套html的请求，在访问到页面之后，进行结果反弹，重定向登陆页面

—注意，一般过滤器和拦截器都设定在basemanage后端中—

5.resource，是对整个web项目的spring框架配置xml文件存储的空间

6.util自定义工具包