参考：https://study.163.com/course/courseMain.htm?courseId=1003862031&trace_c_p_k2=c11914dcdc8e419bab84089c3b25916c

参考：https://www.yuque.com/hangnang/wpmwsb/wzdqyt#d75008f1

一、ssm框架原理及基本概念

1、原理介绍

SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层
使用spring MVC负责请求的转发和视图管理
spring实现业务对象管理，mybatis作为数据对象的持久化引擎

原理：

SpringMVC：
1.客户端发送请求到DispacherServlet（分发器）
2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller
3.Controller调用业务逻辑处理后，返回ModelAndView
4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图
5.视图负责将结果显示到客户端

Spring：
我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们Java中的类，当然也包括service dao里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字new。另外spring的aop，事务管理等等都是我们经常用到的。

Mybatis：
mybatis是对jdbc的封装，它让数据库底层操作变的透明。mybatis的操作都是围绕一个sqlSessionFactory实例展开的。mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库所需进行的sql语句映射。在每次与数据库交互时，通过sqlSessionFactory拿到一个sqlSession，再执行sql命令。

====================================================================================================================================
Spring MVC 拥有控制器，作用跟Struts类似，接收外部请求，解析参数传给服务层
Spring 容器属于协调上下文，管理对象间的依赖，提供事务机制
mybatis 属于orm持久层框架，将业务实体 与数据表联合 起来

Spring MVC 控制层，想当与 Struts的作用
Spring 控制反转和依赖注入 创建对象交由容器管理，达到了解耦的作用
mybatis 主要用来操作数据库（数据库的增删改查）

IOC:控制反转，是一种降低对象之间耦合关系的设计思想，面试的时候最好能说出来个例子，加深理解。例子：租房子，以前租房子需要一个房子一个房子找，费时费力，然后现在加入一个房屋中介，把你需要的房型告诉中介，就可以直接选到需要的房子，中介就相当于spring容器。

AOP:面向切面编程，是面向对象开发的一种补充，它允许开发人员在不改变原来模型的基础上动态的修改模型以满足新的需求，如：动态的增加日志、安全或异常处理等。AOP使业务逻辑各部分间的耦合度降低，提高程序可重用性，提高开发效率。

持久层：DAO层（mapper）

• DAO层：DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，

  • DAO层的设计首先是设计DAO的接口，
  • 然后在Spring的配置文件中定义此接口的实现类，
  • 然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，
  • DAO层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。

    业务层：Service层

• Service层：Service层主要负责业务模块的逻辑应用设计。

  • 首先设计接口，再设计其实现的类
  • 接着再在Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用Service接口来进行业务处理。
  • Service层的业务实现，具体要调用到已定义的DAO层的接口，
  • 封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。

    表现层：Controller层（Handler层）

• Controller层:Controller层负责具体的业务模块流程的控制，

  • 在此层里面要调用Service层的接口来控制业务流程，
  • 控制的配置也同样是在Spring的配置文件里面进行，针对具体的业务流程，会有不同的控制器，我们具体的设计过程中可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块，这样不仅使程序结构变得清晰，也大大减少了代码量。

    View层

• View层 此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的表示.

各层联系

• DAO层，Service层这两个层次都可以单独开发，互相的耦合度很低，完全可以独立进行，这样的一种模式在开发大项目的过程中尤其有优势
• Controller，View层因为耦合度比较高，因而要结合在一起开发，但是也可以看作一个整体独立于前两个层进行开发。这样，在层与层之前我们只需要知道接口的定义，调用接口即可完成所需要的逻辑单元应用，一切显得非常清晰简单。
• Service逻辑层设计
  • Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层之下的，因而Service层应该既调用DAO层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。

表现层Contorller —> 业务层Service—> 持久层Dao
====================================================================================================================================

2、基本概念

Spring

    Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。<br /> 

SpringMVC

    Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。<br /> 

MyBatis

   MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。MyBatis是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录

二、开发环境搭建

参考：http://www.cnblogs.com/zyw-205520/p/4767633.html

1、安装jdk

2、安装Eclipse

3、安装Tomcat

下载地址：http://tomcat.apache.org

用tomcat在本地搭建服务器

3.1、eclipse环境下配置tomcat

**
1.下载并成功安装Eclipse和Tomcat

2.打开Eclipse，单击“window”菜单，选择下方的“Preferences” 。


3. 点击 Add 添加Tomcat。


4. 选中自己安装的tomcat路径。



5. 选择jdk 版本。


6. 选择自己的jdk版本。



7. 点击 add添加。



8. 选择jdk 安装路径。


9. 选择完成。自动添加，然后点击完成按钮。




10. 选中刚刚我们安装的jre。


11. 完成。

3.2、 把项目部署到Tomcat服务器上

1、 让Tomcat服务器显示在控制台上。






2. 选择Tomcat版本 。


3. 右击Tomcat服务器 —> Add and Remove

4、选中点击add，或是双击都可以添加到右边

8. 点击启动。

4、Maven安装配置

1、 将maven包解压缩，选择压缩包中的文件

要的是最里面的包，这个文件夹里面就是maven的东西了

2、 将这个文件夹整体复制到你自己的目录，自行选择 即可
修改maven的配置文件 ，选择conf文件夹

在该文件夹下面有个settings的文件，双击打开，以记事本的形式打开 ，或者是下载notepad++，用notepad++打开，该软件更好用

3、 打开该文件后，找到如下地方，修改路径，该路径是maven下载依赖jar包的路径，下载后的文件将保存在这个地方。

4、 打开eclipse软件，点击window下的preferences

5、 打开如下界面后，选择maven选项下 的user settings选项卡

6、 在打开的选项卡 中进行maven配置，选择刚才修改的seting文件

设置完seting文件后，点击下方的update settings按钮

5、新建mysql数据库

数据库名：ssm_demo
表名：tb_dept

表名：tb_emp

三、ssm搭建流程和配置内容

功能点：
1、分页
2、jquery前端校验+JSR303后端校验
3、ajax
4、Rest风格的URI;使用HTTP协议请求方式的动词，来表示对资源的操作（GET查询，POST新增，PUT修改，DELETE删除）

技术点：
基础框架-ssm
数据库-MySQL
前端框架-bootstrap 快速搭建页面
分页插件-pagehelper
逆向工程-MyBatis Generator

1、创建Maven工程

配置web.xml位置

右击 ssmcrud项目名—>properpies—>Project Facets

2、引入项目依赖的jar包

Maven的中央仓库网址：https://mvnrepository.com/
pom.xml主要存放项目依赖的jar包

2.1、引入方法：

打开pom.xml文件—>去Maven仓库搜索需要的jar包—>点击进入选择需要的版本—>复制xml代码，粘贴到pom.xml文件中

2.2、pom.xml配置

    <dependencies>

            <!--mybatis.generator mybatis逆向工程 -->
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-core</artifactId>
                <version>1.3.5</version>
            </dependency> 
            <!--spring mvc jar  -->
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>4.3.7.RELEASE</version>
            </dependency>
            <!--spring jdbc jar  -->
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>4.3.7.RELEASE</version>
            </dependency>
            <!--  spring的单元测试-->
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>4.3.7.RELEASE</version>
                <scope>test</scope>
            </dependency>
            <!--spring 面向切面编程  -->
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>4.3.7.RELEASE</version>
            </dependency>
            <!--mybatis jar  -->
            <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.2</version>
            </dependency>
            <!-- mybatis spring 整合jar包 -->
            <!-- https://mvnrepository.com/artifact/org.mybatis/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>
            <!-- jdbc驱动连接包 -->
            <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.41</version>
            </dependency>


            <!-- jstl，servlet，junit -->
            <!-- https://mvnrepository.com/artifact/jstl/jstl -->
            <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>
            <!-- https://mvnrepository.com/artifact/junit/junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>

      <!-- 下面是在后面需要的时候添加的配置内容 -->

            <!-- pageHelper插件，用于分页 -->
            <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>5.0.0</version>
            </dependency>
            <!-- jackson  返回json字符串的  -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.8.8</version>
            </dependency>
            <!-- JSR303数据校验  (tomcat7及以下的服务器，el表达式 额外给服务器的lib包中替换新的标准的el)-->
            <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>5.4.1.Final</version>
            </dependency>

3、引入Bootstrap前端框架和jquery

Bootstrap官网链接：http://www.bootcss.com/

新建index.jsp

在webapp下新建index.jsp文件，引入Bootstrap和jquery，验证Bootstrap前端框架是否可以使用

<%@ page language="java" contentType="text/html; charset=UTF-8"
   pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<!-- 引入jquery  -->
<script src="static/jquery/jquery-3.3.1.min.js"></script>
<!-- 引入样式 -->
<link href="static/bootstrap-3.3.7-dist/css/bootstrap.min.css" rel="stylesheet">
<script src="static/bootstrap-3.3.7-dist/js/bootstrap.min.js"></script>
</head>
<body>
<button type="button" class="btn btn-success">（成功）Success</button>
</body>
</html>

4、配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

  <!-- 1、启动Spring的容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>  
  <!-- 2、spring-mvc的前端拦截器，拦截所有请求 -->
   <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <!-- 3、字符编码过滤器 ，一定要放在所有过滤器之前-->
  <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>
  <!-- 4、请求过滤器 ，使用Rest风格的URL，将页面普通的post请求转为指定的delete或put请求-->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- 解决PUT请求引发的血案：如下配置即可直接发PUT请求,避免后端接收不到数据 -->
  <filter>
      <filter-name>HttpPutFormContentFilter</filter-name>
      <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>HttpPutFormContentFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>


</web-app>

5、配置Spring MVC

在下图位置新建 dispatcherServlet-servlet.xml 文件，用来配置Spring MVC

<?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/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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

         <!-- spring mvc的配置文件 包含网站跳转逻辑的空值，配置 -->
        <context:component-scan base-package="com.atguigu" use-default-filters="false">
                <!--  只扫描控制器-->
                <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

        <!--  配置视图解析器，方便页面返回-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                 <property name="prefix" value="/WEB-INF/views/"/>
                 <property name="suffix" value=".jsp"/>
        </bean>

        <!--  两个标准配置-->
        <!-- 将springmvc不能处理的请求交给tomcat -->
        <mvc:default-servlet-handler />
        <!-- 能支持springmvc跟高级的一些功能，比如：JSR303校验，快捷的ajax ，映射动态请求 -->
        <mvc:annotation-driven />
</beans>

6、配置Spring

在src/main/resource中新建applicationContext.xml文件，用来配置Spring

<?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"
    xmlns:spring="http://www.springframework.org/schema/spring"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

        <context:component-scan base-package="com.atguigu">
                <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

         <!-- spring的配置文件这里主要配置和逻辑业务有关的 -->
        <!-- 数据源，事务控制........ -->
        <context:property-placeholder location="classpath:dbconfig.properties"/>
        <bean id="pooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
                <property name="driverClass" value="${jdbc.driverClass}"></property>
                <property name="user" value="${jdbc.user}"></property>
                <property name="password" value="${jdbc.password}"></property>
        </bean>

        <!-- 配置和mybatis的整合 -->
        <bean id="SqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!--指定mybatis全局配置文件  -->
            <property name="configLocation" value="classpath:mybaties-config.xml"></property>
            <property name="dataSource" ref="pooledDataSource"></property>
            <!-- 指定mybatis.mapper文件位置 -->
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        </bean>

        <!-- 配置扫描器，将mybatis接口的实现加入到ioc容器中 -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
                <!--扫描所有的dao接口实现，加入ico容器中  -->
                <property name="basePackage" value="com.atguigu.ctud.dao"></property>
        </bean>

        <!-- 事务控制 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!-- 控制数据源 -->
            <property name="dataSource" ref="pooledDataSource"></property>
        </bean>

        <!-- 开启基于 注解的事务，使用xml配置形式的事务： 必要主要的都是使用配置式的-->
        <aop:config>
            <!-- 切入点表达式 -->
            <aop:pointcut expression="execution(* com.atguigu.crud.service..*(..))" id="txPoint"></aop:pointcut>
            <!-- 配置事务增强 -->
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
        </aop:config>

        <!-- 配置事务增强（事务如何切入） -->
        <tx:advice id="txAdvice">
                <tx:attributes>
                    <!-- *代表 所有方法都是事务方法 -->
                    <tx:method name="*"/>
                    <!-- get开头的所有方法都是事务方法 -->
                    <tx:method name="get*" read-only="true"/>
                </tx:attributes>
        </tx:advice>


        <!-- 配置一个可以批量的sqlSession -->
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <constructor-arg name="sqlSessionFactory" ref="SqlSessionFactoryBean"></constructor-arg>
            <constructor-arg name="executorType" value="BATCH"></constructor-arg>
        </bean>
</beans>

7、配置mybatis

在src/main/resource中新建mybaties-config.xml文件，用来配置mybatis

mybatis 链接：https://github.com/mybatis/mybatis-3

<?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>
                <setting name="mapUnderscoreToCamelCase" value="true"/>
                 <!-- 运行打印查询语句（增）-->
                <setting name="logImpl" value="STDOUT_LOGGING" /> 
        </settings>

        <typeAliases>
                <package name="com.atguigu.ctud.bean"/>
        </typeAliases>

        <!-- 分页插件 -->
        <plugins>
            <plugin interceptor="com.github.pagehelper.PageInterceptor">
                <!-- 分页参数合理化 -->
                <property name="reasonable" value="true"/>
            </plugin>
        </plugins>
        <!-- 
            reasonable：
                分页合理化参数，默认值为false。当该参数设置为 true 时，pageNum<=0 时会查询第一页，
                 pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。
         -->


</configuration>

8、配置逆向工程

新建/ssm-demo/mbg.xml文件，配置逆向工程文件
mybatis逆向工程 链接：https://github.com/mybatis/generator

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="DB2Tables" targetRuntime="MyBatis3">
    <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/ssm_demo" userId="root"
            password="123456">
        </jdbcConnection>

        <!-- 指定javaBean生成的位置 -->
        <javaModelGenerator 
            targetPackage="com.atguigu.ctud.bean"
            targetProject=".\src\main\java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="true" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!-- sql映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="mapper" 
            targetProject=".\src\main\resources">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>


        <!-- dao接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="com.atguigu.ctud.dao" 
            targetProject=".\src\main\java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>


        <!-- 指定数据库表 -->
        <table schema="" tableName="tbl_emp" domainObjectName="Employee"></table>
        <table schema="" tableName="tbl_dept" domainObjectName="Department"></table>


    </context>
</generatorConfiguration>

新建MBGTest.java文件

package com.atguigu.ctud.test;

/**
 * 测试mybatis逆向工程（生成bean，dao，mapper）
 */
import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.internal.DefaultShellCallback;


/**
 * 测试mybatis逆向工程（生成bean，dao，mapper）
 */
public class MBFGTest {
    public static void main(String[] args) throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("mbg.xml"); 
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);
    }
}

运行MBGTest.java

将mbg.xml的配置规则逆向工程生成bean,dao,mapper

9、引入Spring单元测试模块，测试dao层

引入9，10步骤的单元测试模块之前，视频中需要修改mapper数据库查询内容，这里没写

新建/ssm-demo/src/main/java/com/atguigu/ctud/test/MapperTest.java

向数据库插入数据，测试dao层

package com.atguigu.ctud.test;

import java.util.UUID;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.atguigu.ctud.bean.Department;
import com.atguigu.ctud.bean.Employee;
import com.atguigu.ctud.dao.DepartmentMapper;
import com.atguigu.ctud.dao.EmployeeMapper;


/**
 * 测试dao层功能
 * 使用Spring 单元测试环境模块
 * @author administer
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class MapperTest {

        @Autowired
        DepartmentMapper departmentMapper;

        @Autowired
        EmployeeMapper employeeMapper;

        @Autowired
        SqlSession sqlSession;
        /**
         * 测试DepartmentMapper
         */
        @Test
        public void testCRUD(){
//            System.out.println(departmentMapper);

            //1.插入几个部门
//            departmentMapper.insertSelective(new Department(null,"开发部"));
//            departmentMapper.insertSelective(new Department(null,"测试部"));

            //2.生成员工数据
//            employeeMapper.insertSelective(new Employee(null,"123456789","W","123456789@qq.com",2));
            //3.批量插入多个员工
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
            for(int i=0;i<1000;i++){
                String Name=UUID.randomUUID().toString().substring(0,5)+i;
                mapper.insertSelective(new Employee(null,Name,"M",Name+"@qq.com",1));
            }
        }
}

10、使用Spring测试模块，测试分页请求

新建/ssm-demo/src/main/java/com/atguigu/ctud/test/MvcTest.java

package com.atguigu.ctud.test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.atguigu.ctud.bean.Employee;
import com.github.pagehelper.PageInfo;

/**
 * 使用Spring测试模块提供的测试请求功能，测试crud请求的正确性
 * @author wanzhaocheng
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations={"classpath:applicationContext.xml","file:src/main/webapp/WEB-INF/dispatcherServlet-servlet.xml"})
public class MvcTest {
    //传入SpringMVC的ioc
    @Autowired
    WebApplicationContext context;
    //虚拟mvc请求，获取到处理结果
    MockMvc mockMvc;

    @Before
    public void initMockMvc(){
        mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
    }
    @Test
    public void testPage() throws Exception{
        //模拟请求拿到返回值
        MvcResult result = mockMvc.perform(MockMvcRequestBuilders.get("/emps").param("pn", "1")).andReturn();

        //请求成功之后，请求域中会有pagaInfo,我们可以取出pagaInfo进行验证
        MockHttpServletRequest request = result.getRequest();
        PageInfo pi = (PageInfo) request.getAttribute("pageInfo");
        System.out.println("当前页码："+pi.getPageNum());
        System.out.println("总页码："+pi.getPages());
        System.out.println("总记录数："+pi.getTotal());
        System.out.println("在页面需要连续显示的页码");
        int[] nums = pi.getNavigatepageNums();
        for(int i : nums){
            System.out.println(" "+i);
        }

        //获取员工数据
        List<Employee> list = pi.getList();
        for(Employee employee : list){
            System.out.println("ID:"+employee.getEmpId()+"==>Name:"+employee.getEmpName());
        }
    }
}

在9，10 spring单元测试环节 之前还改了mapper文件，没有说明。

最终的文件列表：

===》》基础框架搭建完成！！
**
以上配置的源码及资源链接：https://pan.baidu.com/s/1mO-zrSo57F-PxJGkInA9Kg
提取码：u40y

四、ssm整合shiro登录验证

https://www.cnblogs.com/longLifeFrog/articles/8612736.html

shiro

shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；
Realm：域，Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

功能:
Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
Web Support：Web支持，可以非常容易的集成到Web环境；
Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
Testing：提供测试支持；
Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

ehcahe

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展，缓存异常处理程序，一个gzip缓存servlet过滤器，支持REST和SOAP api等特点。

优点：
1. 快速
2. 简单
3. 多种缓存策略
4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题
5. 缓存数据会在虚拟机重启的过程中写入磁盘
6. 可以通过RMI、可插入API等方式进行分布式缓存
7. 具有缓存和缓存管理器的侦听接口
8. 支持多缓存管理器实例，以及一个实例的多个缓存区域
9. 提供Hibernate的缓存实现

缺点：
1. 使用磁盘Cache的时候非常占用磁盘空间：这是因为DiskCache的算法简单，该算法简单也导致Cache的效率非常高。它只是对元素直接追加存储。因此搜索元素的时候非常的快。如果使用DiskCache的，在很频繁的应用中，很快磁盘会满。
2. 不能保证数据的安全：当突然kill掉java的时候，可能会产生冲突，EhCache的解决方法是如果文件冲突了，则重建cache。这对于Cache 数据需要保存的时候可能不利。

shiro整合ehcache缓存框架的作用：
缓存可以提高查询数据性能，对同一批数据进行多次查询时， 第一次查询走数据库，查询数据后，将数据保存在内存中，
第二次以后查询可以直接从内存获取数据，而不需要和数据库进行交互。
每次访问一个需要被权限控制资源时，调用Realm的授权方法，根据当前用户查询角色（role）和权限（permission）信息，
每次调用 都会查询一次数据库。
问题： 为什么使用ehcache而不使用redis缓存？
1、Shiro 默认对ehcache的支持
2、在后台管理系统中 ehcache使用非常普遍 ，因为spring可以集成ehcache。

**

1、shiro的介绍

Apache Shiro是一款强大、灵活的开源安全管理框架，以十分优雅的方式处理authentication（身份验证）、authorization（授权）、enterprise session（企业会话）和cryptography（加密）。
Apache Shiro的首要目标就是易于上手和容易理解。在软件中，安全管理有时会非常复杂、痛苦，但Apache Shiro会让它变得非常简单。下面是Apache Shiro可以做的事：

• 鉴别用户身份
• 管理用户权限，例如：判断用户是否有某一角色或用户是否被允许做某一操作
• 即使没有web或EJB容器，也可以使用session API
• 在鉴别用户身份时、权限管理时或session生命周期内进行一些操作
• 可以聚合一个或多个用户权限数据源并且以用户视图的形式统一表现出来
• 实现了单点登录功能（SSO）
• 无需登录便可实现“记住我”这一功能

shiro的四大核心部分：Authentication（身份验证）、Authorization（授权）、Session Management(会话管理)、cryptography（加密）
shiro的三个核心组件：　　　　　
　　　　　　Subject ：正与系统进行交互的人，或某一个第三方服务。所有 Subject 实例都被绑定到（且这是必须的）一个SecurityManager 上。
　　　　　　SecurityManager：Shiro 架构的心脏，用来协调内部各安全组件，管理内部组件实例，并通过它来提供安全管理的各种服务。当 Shiro 与一个 Subject 进行交互时，实质上是幕后的 SecurityManager 处理所有繁重的 Subject 安全操作。
　　　　　　Realms ：本质上是一个特定安全的 DAO。当配置 Shiro 时，必须指定至少一个 Realm 用来进行身份验证和/或授权。Shiro 提供了多种可用的 Realms 来获取安全相关的数据。如关系数据库(JDBC)，INI 及属性文件等。可以定义自己 Realm 实现来代表自定义的数据源。

2、整合流程

2.1、添加Shiro相关jar包

在pom.xml添加以下配置。

<!-- shiro -->
                <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-core</artifactId>
              <version>1.2.4</version>
            </dependency>
            <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-ehcache</artifactId>
              <version>1.2.4</version>
            </dependency>
            <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-web</artifactId>
              <version>1.2.4</version>
            </dependency>
            <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-spring</artifactId>
              <version>1.2.4</version>
            </dependency>

2.2、添加Shiro过滤器

在web.xml添加以下配置。
需要注意filter-name必须和之后applicationContext中配置保持一致！！

 <filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

2.3、整合spring-shiro

新建spring-shiro.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置緩存管理器 -->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <!-- 指定 ehcache 的配置文件，下面会给到 -->
        <property name="cacheManagerConfigFile" value="classpath:ehcache-shiro.xml"/>
    </bean>

    <!-- 配置进行授权和认证的 Realm，要新增一个java类来实现，下面会有，class=包名.类名，init-methood是初始化的方法 -->
    <bean id="myRealm"
        class="com.atguigu.shiro.MyRealm"
        init-method="setCredentialMatcher"></bean>

    <!-- 配置 Shiro 的 SecurityManager Bean. -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
          <property name="realm" ref="myRealm"/>
        <property name="cacheManager" ref="cacheManager"/>
    </bean>



        <!-- 启用shrio授权注解拦截方式 -->

    <!-- 配置 Bean 后置处理器: 会自动的调用和 Spring 整合后各个组件的生命周期方法. -->
    <bean id="lifecycleBeanPostProcessor" 
        class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- 配置 ShiroFilter bean: 该 bean 的 id 必须和 web.xml 文件中配置的 shiro filter 的 name 一致  -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- 装配 securityManager -->
        <property name="securityManager" ref="securityManager"/>
        <!-- 配置登陆页面 -->
        <property name="loginUrl" value="/login"/>
        <!-- 登陆成功后的一面 -->
        <property name="successUrl" value="/index2"/>
        <property name="unauthorizedUrl" value="/index.jsp"/>
        <!-- 具体配置需要拦截哪些 URL, 以及访问对应的 URL 时使用 Shiro 的什么 Filter 进行拦截.  -->
        <property name="filterChainDefinitions">
            <value>
                <!-- 配置登出: 使用 logout 过滤器 -->
                <!-- anon是不需要验证
                                         authc是需要验证才能使用 -->
                /logout = logout
                /static/**=anon
                /common/**=anon
                /check**=anon
                /permission/**=anon
                /role/**=anon
                /roleAndPermission**=anon
                 /user/checkuserName**=anon
                 /user/AddUser1**=anon
                 /index**=anon
                /insertCode**=anon
                /ChangPwd**=anon

                /pages/administrator/**=roles[admin]
                /user/**=roles[admin]

                /pages/teacher/**=roles[teacher]  
                /teacher/**=roles[teacher]

                /pages/student/**=roles[student]  
                /student/**=roles[student]

                /pages/dean/**=roles[dean]  
                /dean/**=roles[dean]

                /pages/leader/**=roles[leader]  
                /leader/**=roles[leader]

                 /pages/Arealeader/**=roles[Arealeader]  
                /Arealeader/**=roles[Arealeader] 
                 <!-- perms[user:query]表示访问此连接需要权限为user:query的用户 -->  
                <!-- /user=perms[user:query]   -->
                <!-- roles[manager]表示访问此连接需要用户的角色为manager -->  
                <!-- /user/add=roles[manager]  
                /user/del/**=roles[admin]  
                /user/edit/**=roles[manager]
                /toLogin = authc authc 表示需要认证才能访问的页面  
                /home = authc, perms[/home]  --> <!-- perms 表示需要该权限才能访问的页面 -->  
                <!--所有的请求(除去配置的静态资源请求或请求地址为anon的请求)都要通过登录验证,如果未登录则跳到/login-->    
                   /** = authc  
            </value>

        </property>

    </bean>


</beans>

在spring的配置文件头部加入spring-shiro.xml的路径索引

2.4、配置ehcache-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" name="shirocache">

     <defaultCache 
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="3600"
        timeToLiveSeconds="0"
        overflowToDisk="false"/>
</ehcache>

   <!-- maxelementsinmemory-设置将在内存中创建的最大对象数
            eternal-设置元素是否是永恒的。如果是永恒的，超时将被忽略元素永不过期。
            timeToIdleSeconds-设置元素在过期之前的空闲时间。
                            即在元素过期之前访问之间的最长时间间隔
                            仅在元素不是永恒的情况下使用。
                            可选属性。值为0表示元素可以无限空闲。
                            默认值为0。
            timeToLiveSeconds-设置元素在过期之前的生存时间。
                            即从创建时间到元素过期的最长时间。
                            仅在元素不是永恒的情况下使用。
                            可选属性。值为0表示和元素可以无穷大。
                            默认值为0。
            overflowToDisk-x`设置当内存缓存中已达到最大内存限制     
    -->

2.5、新建MyRealm.java

package com.atguigu.shiro;


import java.util.HashMap;

import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpSession;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;

import com.atguigu.ctud.bean.User;
import com.atguigu.ctud.bean.UserExample;
import com.atguigu.ctud.bean.UserExample.Criteria;
import com.atguigu.ctud.dao.UserMapper;

/**
 * 用户登录验证和授权
 */
public class MyRealm extends AuthorizingRealm {
    @Autowired
    private UserMapper userMapper;    
    String pass;

    /**
     * 授权:
     * 
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();        
        Object principal = principalCollection.getPrimaryPrincipal();//获取登录的用户名 
        Map<String, String> param=new HashMap<>();
        param.put("username", principal.toString());
        List<Map<String, String>> user = userMapper.getRole(param);//根据用户名查找用户角色
        for (int i = 0; i < user.size(); i++) {
            info.addRole(user.get(i).get("role"));//给用户赋对应角色的权限
        }
        return info;
    }

    /*
     * 用户验证
     * 
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {   
        //1. token 中获取登录的 username! 注意不需要获取password.
        Object principal = token.getPrincipal();

        //2. 利用 username 查询数据库得到用户的信息.
        UserExample example=new UserExample();
        Criteria createCriteria = example.createCriteria();
        createCriteria.andCbUserNameEqualTo((String) principal);
        List<User> selectByExample = userMapper.selectByExample(example);
        User user=selectByExample.get(0);
        if(user!=null){
            pass=user.getCbUserPwd();
        }
        String credentials = pass;
        //3.设置盐值 ，（加密的调料，让加密出来的东西更具安全性，一般是通过数据库查询出来的。 简单的说，就是把密码根据特定的东西而进行动态加密，如果别人不知道你的盐值，就解不出你的密码）


        //当前 Realm 的name
        String realmName = getName();
        //返回值实例化
        AuthenticationInfo info = 
                new SimpleAuthenticationInfo(principal, credentials, 
                         realmName);

        return info;
    }

    //init-method 配置. 
    public void setCredentialMatcher(){
        HashedCredentialsMatcher  credentialsMatcher = new HashedCredentialsMatcher();    
        credentialsMatcher.setHashAlgorithmName("MD5");//MD5算法加密
        credentialsMatcher.setHashIterations(1024);//1024次循环加密      
        setCredentialsMatcher(credentialsMatcher);
    }


    //用来测试的算出密码password盐值加密后的结果，下面方法用于新增用户添加到数据库操作的，我这里就直接用main获得，直接数据库添加了，省时间
  public static void main(String[] args) {
      String hashAlgorithmName = "MD5";
      String credentials = "admin123";
      int hashIterations = 1024;            
      Object result = new SimpleHash(hashAlgorithmName, credentials,null, hashIterations);
}

}

五、所有配置文件内容

最终配置文件如下：

1、pom.xml

4.0.0 com.atguigu ssm-crud 0.0.1-SNAPSHOT war org.springframework spring-webmvc 4.3.7.RELEASE org.springframework spring-jdbc 4.3.7.RELEASE org.springframework spring-test 4.3.7.RELEASE test com.github.pagehelper pagehelper 5.0.0 org.springframework spring-aspects 4.3.7.RELEASE org.mybatis mybatis 3.4.2 org.mybatis mybatis-spring 1.3.1 c3p0 c3p0 0.9.1.2 mysql mysql-connector-java 5.1.46 jstl jstl 1.2 javax.servlet javax.servlet-api 3.0.1 provided junit junit 4.12 test org.mybatis.generator mybatis-generator-core 1.3.5 com.fasterxml.jackson.core jackson-databind 2.8.8 org.apache.shiro shiro-core 1.2.4 org.apache.shiro shiro-ehcache 1.2.4 org.apache.shiro shiro-web 1.2.4 org.apache.shiro shiro-spring 1.2.4 log4j log4j 1.2.16 commons-io commons-io 2.4 commons-fileupload commons-fileupload 1.3.1 commons-io commons-io commons-beanutils commons-beanutils 1.7.0 commons-collections commons-collections 3.2.1 commons-lang commons-lang 2.5 commons-logging commons-logging 1.0.4 net.sf.ezmorph ezmorph 1.0.6

2、web.xml

<?xml version=”1.0” encoding=”UTF-8”?>

contextConfigLocation classpath:spring.xml org.springframework.web.context.ContextLoaderListener

shiroFilter org.springframework.web.filter.DelegatingFilterProxy targetFilterLifecycle true shiroFilter /
imageFilter com.atguigu.ctud.utli.ImageCacheFilter imageFilter /static/images/
springmvc org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:spring-mvc.xml 1 springmvc / CharacterEncodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding utf-8 forceRequestEncoding true forceResponseEncoding true CharacterEncodingFilter / HiddenHttpMethodFilter org.springframework.web.filter.HiddenHttpMethodFilter HiddenHttpMethodFilter /

3、spring.xml

<?xml version=”1.0” encoding=”UTF-8”?>

4、spring-mvc.xml

<?xml version=”1.0” encoding=”UTF-8”?>

5、mybaties-config.xml

<?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">

6、spring-mybatis.xml

<?xml version=”1.0” encoding=”UTF-8”?> <!DOCTYPE generatorConfiguration PUBLIC “-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN” “http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

7、dbconfig.properties

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm_crud?useUnicode=true&characterEncoding=utf-8 jdbc.driverClass=com.mysql.jdbc.Driver jdbc.user=root jdbc.password=123456

jdbc.jdbcUrl=jdbc:mysql://211.64.243.225:3306/ssm

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.user=root

jdbc.password=lyu123456

8、spring-shiro.xml

<?xml version=”1.0” encoding=”UTF-8”?>

/logout = logout /static/=anon /common/=anon /check=anon /permission/=anon /role/=anon /roleAndPermission=anon /user/checkuserName=anon /user/AddUser1=anon /index=anon /insertCode=anon /ChangPwd=anon /pages/administrator/=roles[admin] /user/=roles[admin] /pages/teacher/=roles[teacher]
/teacher/=roles[teacher] /pages/student/=roles[student]
/student/=roles[student] /pages/dean/=roles[dean]
/dean/=roles[dean] /pages/leader/=roles[leader]
/leader/=roles[leader] /pages/Arealeader/=roles[Arealeader]
/Arealeader/=roles[Arealeader]


<!— /user/add=roles[manager]
/user/del/=roles[admin]
/user/edit/=roles[manager] /toLogin = authc authc 表示需要认证才能访问的页面
/home = authc, perms[/home] —>

/ = authc

9、ehcache-shiro.xml

<?xml version=”1.0” encoding=”UTF-8”?>

10、log4j.properties

log4j.rootLogger=INFO,Console,file log4j.appender.Console=org.apache.log4j.ConsoleAppender log4j.appender.Console.Target=System.out log4j.appender.Console.layout=org.apache.log4j.PatternLayout log4j.appender.Console.layout.ConversionPattern=[%c]%m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender

log4j.appender.file.MaxFileSize=10MB

log4j.appender.file.Threshold=ALL

log4j.appender.file.layout=org.apache.log4j.HTMLLayout

log4j.appender.file.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH\:mm\:ss,SSS}][%c]%m%n

log4j.appender.file.File=d:/log.html

log4j.logger.com.atguigu=DEBUG

mybatis

log4j.logger.com.ibatis=DEBUG log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG

\u4E0Esql\u76F8\u5173

log4j.logger.java.sql.Connection=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG

最终文件和之前搭建的框架无关，是重新搭建的项目文件
_
最终文件源码和资源链接：