IDEA实现ssm整合快速开发CRUD——基础环境搭建
发布时间：2023-03-14 13:30
尚硅谷SSM实战演练丨IDEA实现ssm整合快速开发CRUD
- 项目说明
- 项目介绍
- 功能点
- 技术点
- 基础环境搭建
- 1. 创建一个maven工程（多图预警）
- 2. 引入项目依赖的jar包（根据项目的需要，引入相关的jar包即可）
- 3. 引入bootstrap前端框架
- 4. 编写ssm整合的关键配置文件（思路分析及代码实现）
项目说明
本项目是基于尚硅谷视频做的学习笔记文档，若有不足或者不正之处，欢迎指正批评，感激不尽！
项目介绍
根据前面已经学过的Spring、SpringMVC、MyBatis等基础框架完成一个简单的增删改查（即CRUD）系统。
（Create（创建） Retrieve（查询）Update（更新）Delete（删除））
功能点
1、分页
2、数据校验：jquery前端校验+JSR303后端校验
3、ajax请求
4、Rest风格的URI：使用HTTP协议请求方式的动词，来表示对资源的操作（GET（查询），POST（新增），PUT（修改），DELETE（删除））
技术点
• 基础框架-ssm（SpringMVC+Spring+MyBatis）
• 数据库-MySQL
• 前端框架-bootstrap快速搭建简洁美观的界面
• 项目的依赖管理-Maven
• 分页插件-pagehelper
• 逆向工程-MyBatis Generator
基础环境搭建
1. 创建一个maven工程（多图预警）
新建一个项目
选择JDK1.8
编写项目名称
修改项目结构
改为JDK1.8
新建web工程
配置web工程并且设置web.xml配置文件的位置
配置完成点击apply和ok
注意：webapp目录上必须出现蓝色圆点才表示配置web工程成功
最后在settings中设置一下字符编码 以及 在idea自动更新索引依赖
2. 引入项目依赖的jar包（根据项目的需要，引入相关的jar包即可）
可以在maven中央仓库（Maven Repositor） 中查找需要的jar包依赖
• spring：spring-jdbc、spring面向切面编程：spring-aspects
• springmvc：spring-webmvc
• mybatis：mybatis、mybatis整合spring的适配包：mybatis-spring、
代码生成器MBG：mybatis-generator-core、pageHelper分页插件：pagehelper
• 数据库连接池，驱动包：c3p0、数据库驱动：mysql-connector-java
• 其他（jstl，servlet-api，junit等）：json字符串：jackson-databind、JSR303后端数据校验：hibernate-validator、javax.servlet-api、javax.servlet.jsp-api、jstl、junit、spring-test单元测试：spring-test
一、spring-web 与 spring-webmvc 的区别：
1）、spring-web 提供了核心 HTTP 集成，包括一些便捷的 servlet 过滤器， Spring HTTP 调用，用于集成其它 web 框架的基础结构以及技术（Hessian，Burlap）。
2）、spring-webmvc 是 Spring MVC 的一个实现。spriing-webmvc 依赖于 spring-web，这样包含它就会间接地添加 spring-web，不必显示添加 spring-web。
3）、因此如果你不使用 Spring MVC ，但想要借助其它 Spring 支持的 web 相关技术的优势，那么你只需引入依赖 spring-web 。
二、servlet.jar 是servlet 3.0 版本之前的地址，javax.servlet-api.jar 是servlet 3.0 版本之后的地址
pom.xml核心配置文件代码如下：(注意打包方式为war包)
<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.0modelVersion>
<groupId>com.zuogroupId>
<artifactId>ssm-crudartifactId>
<version>1.0-SNAPSHOTversion>
<packaging>warpackaging>
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>4.3.7.RELEASEversion>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.13.1version>
dependency>
<dependency>
<groupId>org.hibernategroupId>
<artifactId>hibernate-validatorartifactId>
<version>6.0.17.Finalversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>4.3.7.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-aspectsartifactId>
<version>4.3.7.RELEASEversion>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.9version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>2.0.7version>
dependency>
<dependency>
<groupId>org.mybatis.generatorgroupId>
<artifactId>mybatis-generator-coreartifactId>
<version>1.4.0version>
dependency>
<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>5.0.0version>
dependency>
<dependency>
<groupId>com.mchangegroupId>
<artifactId>c3p0artifactId>
<version>0.9.5.5version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.28version>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>4.0.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>javax.servlet.jsp-apiartifactId>
<version>2.3.3version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>jstlartifactId>
<version>1.2version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>4.3.7.RELEASEversion>
dependency>
dependencies>
project>
3. 引入bootstrap前端框架
如何使用Bootstrap前端框架？
1、首先到Bootstrap官网下载相关的文件
2、将下载的文件复制粘贴到项目的webapp下的自定义目录中（比如：static）
3、在index.jsp页面中（或需要用到前端框架的页面）引入bootstrap样式以及 js文件
注意：在 jsp 中常常使用JSTL标签库
如：代替 代码脚本<% java语句 %>，使用EL表达式${表达式}代替 表达式脚本<%= 表达式 %>
如需使用JSTL标签库需要先导入 jstl 的 jar 包（或者在pom.xml中引入依赖），然后使用 taglib 指令引入标签库 (代码如下：)
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
pageContext.setAttribute("APP_PATH",request.getContextPath());
%>
<!-- 引入Bootstrap样式 -->
<link rel="stylesheet" href="${APP_PATH}/static/bootstrap-3.4.1-dist/css/bootstrap.min.css">
<!-- 引入jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
<script src="${APP_PATH}/static/bootstrap-3.4.1-dist/js/jquery-1.12.4.min.js"></script>
<!-- 引入js文件，加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
<script src="${APP_PATH}/static/bootstrap-3.4.1-dist/js/bootstrap.min.js"></script>
4、最后可以参照Bootstrap官方文档完成代码的编辑
4. 编写ssm整合的关键配置文件（思路分析及代码实现）
1）、web.xml
一、为什么要配置web.xml？
1、web.xml文件是web工程的一个入口配置文件，它主要是用来注册Servlet、注册过滤器、注册监听器等组件的（或者通过SpringMVC注解的方式来完成注册操作代替web.xml）
2、SpringMVC是基于原生的Servlet，为我们提供 封装了一个 处理请求过程的前端控制器：DispatcherServlet
3、所有的请求都由前端控制器进行处理，需要到web.xml中进行注册（为什么需要到web.xml中注册？）
4、因为浏览器不能直接访问到类，要想访问到Servlet，需要给Servlet设置一个匹配路径（可以通过让一个类继承 HttpServlet 类的方式实现Servlet程序）
5、当我们的访问路径与Servlet中设置的路径相匹配时，就会被Servlet（或前端控制器）进行处理
二、在web.xml中配置spring监听器ContextLoaderListener（自动装配ApplicationContext的配置信息），可以监听servletContext域对象的创建和销毁，执行一次，服务器启动执行，在项目启动的时候通过监听器去加载spring的配置文件。使用
三、在web.xml中配置springMVC的前端控制器DispatcherServlet，web容器会帮我们加载springmvc.xml配置文件，springmvc.xml中配置了只扫描controller，拦截所有请求
1、优先使用扩展配置方式配置web.xml文件（而不是默认配置方式）
默认配置方式：此配置作用下，SpringMVC的配置文件默认位于WEB-INF目录下（WEB-NF目录下一般只放页面），默认名称为—servlet.xml，文件名为springMVC—servlet.xml
扩展配置方式：可通过标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置 SpringMVC前端控制器（DispatcherServlet）的初始化时间
注意：标签中使用 / 和 /* 的区别：
/* 所匹配的请求可以是 /login 或 .html 或 .js 或 .css方式的请求路径，但是 / 不能匹配 .jsp 请求路径的请求 。
因此就可以避免在访问 jsp 页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
/* 则能够匹配所有的请求（包括.jsp请求路径的请求）。例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用 /* 的写法
四、在web.xml中配置字符编码过滤器CharacterEncodingFilter,一定要放在所有过滤器之前（可以解决springMVC中获取post请求参数的乱码问题）
1、进入CharacterEncodingFilter过滤器的源码我们发现，每一次的请求都要经过过滤器的处理，因此只需在doFilter方法中设置encoding属性为utf-8即可，通过web.xml配置文件中的
标签可以在不修改源码的基础上设置encoding（编码）为utf-8（注意：名称必须和源码中一致为encoding）
2、响应的乱码问题也是通过web.xml配置文件中的标签设置forceResponseEncoding为 true 即可
五、在web.xml中配置Rest风格的URI（过滤器）,将页面普通的get请求转为指定的delete或者put请求
六、在web.xml中配置HttpPutFormContentFilter过滤器——完成修改和删除功能时配置（适用于Spring3.0及以前的版本。Spring 5.1 之后使用FormContentFilter过滤器），默认情况下，只有POST请求的表单数据才会被解析，配置了FormContentFilter 后，PUT、PATCH和DELETE的表单数据都可以被解析
（web.xml代码如下）
<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">
<context-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath*:applicationContext.xmlparam-value>
context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>
<servlet>
<servlet-name>DispatcherServletservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath*:spring-mvc.xmlparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>DispatcherServletservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
<filter>
<filter-name>encodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>utf-8param-value>
init-param>
<init-param>
<param-name>forceResponseEncodingparam-name>
<param-value>trueparam-value>
init-param>
filter>
<filter-mapping>
<filter-name>encodingFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<filter>
<filter-name>HiddenHttpMethodFilterfilter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
<filter>
<filter-name>HttpPutFormContentFilterfilter-name>
<filter-class>org.springframework.web.filter.HttpPutFormContentFilterfilter-class>
filter>
<filter-mapping>
<filter-name>HttpPutFormContentFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
web-app>
注意：applicationContext.xml、mybatis-config.xml、spring-mvc.xml（即spring、mybatis、springmvc的配置文件）必须放在resources目录下
database.properties代码（注意修改数据库名）
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_crud?useSSL=true&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=hsp
2）、spring-mvc.xml
2.1、创建项目结构目录如下
2.2、在 WEB-INF 下创建jsp包
（spring-mvc.xml代码如下）
<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 https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<context:component-scan base-package="com.zuo" 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/jsp/"/>
<property name="suffix" value=".jsp"/>
bean>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
beans>
3）、applicationContext.xml（spring的配置文件）
a）Spring 有两个核心部分：IOC 和 Aop
（1）IOC：控制反转，把创建对象和对象之间的调用过程交给 Spring 进行管理 （降低耦合度 ）
（2）Aop：面向切面，不修改源代码进行功能增强
b）IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂（BeanFactory）
两种方式实现IOC容器：（两个接口）
（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用 ——加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用 ——加载配置文件的时候就会在配置文件中创建对象
c）ApplicationContext通常的实现类
1、FileSystemXmlApplicationContext：某个文件的路径——相对于磁盘上的路径（D：/ java / property /xxx）
2、ClassPathXmlApplicationContext：配置文件的路径——相对于src下的路径（bean1.xml）
d）IOC容器的Bean 管理的两个操作 （一般基于注解的方式实现）
（一）Spring 创建对象 （引入依赖、开启组件扫描、在类上面添加注解）
（1）@Component （普通）
（2）@Service （业务层）
（3）@Controller （控制层）
（4）@Repository （持久层）
注意：上面四个注解功能是一样的，都可以用来创建 bean 实例
（二）Spirng 注入属性
（1）@Autowired：根据属性类型进行自动装配（对象）
（2）@Qualifier（value=“userDaoImpl”）：根据名称进行注入（对象）
（3）@Resource：可以根据类型注入，也可以根据名称注入（对象）
（4）@Value（value=“tom”）：注入普通类型属性 （属性）
e）开启组件扫描细节配置
f）在resources目录下创建mapper（指定mybatis的mapper映射文件的位置）
（applicationContext.xml代码如下）
<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: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 https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop https://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.zuo">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
context:component-scan>
<context:property-placeholder location="classpath:database.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="maxPoolSize" value="30"/>
<property name="minPoolSize" value="10"/>
<property name="autoCommitOnClose" value="false"/>
<property name="checkoutTimeout" value="10000"/>
<property name="acquireRetryAttempts" value="2"/>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:mapper/*.xml"/>
bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.zuo.dao"/>
bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
<constructor-arg name="executorType" value="BATCH"/>
bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
bean>
<aop:config>
<aop:pointcut id="txPoint" expression="execution(* com.zuo.service..*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
aop:config>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*"/>
<tx:method name="get*" read-only="true"/>
tx:attributes>
tx:advice>
beans>
4）、mybatis-config.xml
<configuration>
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
settings>
<typeAliases>
<package name="com.zuo.bean"/>
typeAliases>
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
<property name="reasonable" value="true"/>
plugin>
plugins>
configuration>
5）、使用mybatis的逆向工程生成对应的bean、dao接口 以及 mapper（mapper映射文件）
a）首先通过 SQLyog 创建ssm_crud数据库 以及 tab_emp 员工表 和 tab_dept 部门表，并且建立外键关联
CREATE DATABASE ssm_crud;
USE ssm_crud;
CREATE TABLE tab_emp
(emp_id INT PRIMARY KEY AUTO_INCREMENT,
emp_name VARCHAR(255) NOT NULL DEFAULT '',
gender CHAR(1),
email VARCHAR(255),
d_id INT,
FOREIGN KEY (d_id) REFERENCES tab_dept(dept_id)
)ENGINE=INNODB DEFAULT CHARSET=utf8
SELECT * FROM tab_emp;
SELECT * FROM tab_dept;
SELECT COUNT(*) FROM tab_emp;
SELECT COUNT(*) FROM tab_dept;
CREATE TABLE tab_dept
(dept_id INT PRIMARY KEY AUTO_INCREMENT,
dept_name VARCHAR(255) NOT NULL DEFAULT ''
)ENGINE=INNODB DEFAULT CHARSET=utf8;
SELECT *
FROM tab_emp e
LEFT JOIN tab_dept d ON e.`d_id`=d.`dept_id`
WHERE emp_id = 1
b）然后在pom.xml中注册 mybatis 的代码生成器MBG（引入相关依赖）
<dependency>
<groupId>org.mybatis.generatorgroupId>
<artifactId>mybatis-generator-coreartifactId>
<version>1.4.0version>
dependency>
c）在工程路径下创建mbg.xml配置文件
mbg.xml代码内容
<generatorConfiguration>
<context id="DB2Tables" targetRuntime="MyBatis3">
<commentGenerator>
<property name="suppressAllComments" value="true" />
commentGenerator>
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/ssm_crud"
userId="root" password="hsp">
jdbcConnection>
<javaTypeResolver>
<property name="forceBigDecimals" value="false" />
javaTypeResolver>
<javaModelGenerator targetPackage="com.zuo.bean"
targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
javaModelGenerator>
<sqlMapGenerator targetPackage="mapper" targetProject=".\src\main\resources">
<property name="enableSubPackages" value="true" />
sqlMapGenerator>
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.zuo.dao" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
javaClientGenerator>
<table tableName="tab_emp" domainObjectName="Employee"/>
<table tableName="tab_dept" domainObjectName="Department"/>
context>
generatorConfiguration>
注意逆向工程生成bean、dao接口 以及 mapper 文件的位置
6）、MBGTest 测试类代码（生成对应bean、dao、以及mapper）
package com.zuo.test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class MBGTest {
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);
}
}
生成后的目录结构（内容较多，就不放代码了，运行成功会自动生成的~）
7）、EmployeeMapper.xml 配置文件中新增联合查询内容（可以将员工和部门的信息一起查询出来）
7.1、在 Employee 类中添加 Department 属性 以及 get（）、set（）方法
private Department department;
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
7.2、在 EmployeeMapper 接口中新增两个抽象方法
List<Employee> selectByExampleWithDept(EmployeeExample example);
Employee selectByPrimaryKeyWithDept(Integer empId);
（EmployeeMapper.xml代码如下）
<resultMap id="WithDeptResultMap" type="com.zuo.bean.Employee">
<id column="emp_id" jdbcType="INTEGER" property="empId" />
<result column="emp_name" jdbcType="VARCHAR" property="empName" />
<result column="gender" jdbcType="CHAR" property="gender" />
<result column="email" jdbcType="VARCHAR" property="email" />
<result column="d_id" jdbcType="INTEGER" property="dId" />
<association property="department" javaType="com.zuo.bean.Department">
<id column="dept_id" property="deptId"/>
<result column="dept_name" property="deptName"/>
association>
resultMap>
<sql id="WithDept_Column_List">
e.emp_id, e.emp_name, e.gender, e.email, e.d_id , d.dept_id, d.dept_name
sql>
<select id="selectByExampleWithDept" resultMap="WithDeptResultMap">
select
<if test="distinct">
distinct
if>
<include refid="WithDept_Column_List" />
from tab_emp e
left join tab_dept d on e.`d_id`=d.`dept_id`
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
if>
<if test="orderByClause != null">
order by ${orderByClause}
if>
select>
<select id="selectByPrimaryKeyWithDept" resultMap="WithDeptResultMap">
select
<include refid="WithDept_Column_List" />
from tab_emp e
left join tab_dept d on e.`d_id`=d.`dept_id`
where emp_id = #{empId,jdbcType=INTEGER}
select>
8）、测试mapper，搭建spring单元测试环境（看spring的容器能否自动注入bean，完成crud等测试操作）
需要在 pom.xml 中导入spring提供的单元测试模块，然后@ContextConfiguration指定spring配置文件的位置
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>4.3.7.RELEASEversion>
dependency>
MapperTest 测试类代码（注意：在Department、Employee类中需要生成有参和无参构造器）
package com.zuo.test;
import com.zuo.bean.Employee;
import com.zuo.dao.DepartmentMapper;
import com.zuo.dao.EmployeeMapper;
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 java.util.UUID;
/**
* 推荐spring的项目使用spring的单元测试，可以自动注入我们需要的组件
* 1、导入springTest模块
* 2、@ContextConfiguration指定spring配置文件的位置
* @RunWith(SpringJUnit4ClassRunner.class)：使用spring提供的单元测试模块，运行测试
* 3、直接@Autowired要使用的组件即可
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class MapperTest {
@Autowired
DepartmentMapper departmentMapper;
@Autowired
EmployeeMapper employeeMapper;
@Autowired
SqlSession sqlSession;
@Test
public void testCRUD(){
System.out.println(departmentMapper);
System.out.println(employeeMapper);
//插入部门信息
departmentMapper.insertSelective(new Department(null,"开发部"));
departmentMapper.insertSelective(new Department(null,"测试部"));
//插入员工信息
//employeeMapper.insertSelective(new Employee(null,"mary","m","mary@atguigu.com",1));
//批量插入多个员工，可以使用sqlSession
//EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
//for (int i = 0;i<1000;i++){
// String uuid = UUID.randomUUID().toString().substring(0, 5) + i;
// mapper.insertSelective(new Employee(null,uuid,"m",uuid + "@atguigu.com",1));
//}
//System.out.println("批量完成");
}
}
可以在 applicationContext.xml 配置文件中 配置一个执行批量的sqlSession（然后使用@Autowired完成自动注入sqlSession对象）
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
<constructor-arg name="executorType" value="BATCH"/>
bean>
至此，我们的基础环境搭建就完成了，下面可以开始写CRUD的代码了