IntelliJ IDEA建立SSM论文基本增删改查管理系统

1、启动IntelliJ IDEA程序

2、点击File----->New ------>Project建立项目

3、在弹出的对话框中，左边点击”maven”建立maven项目，右边的选择框不要选择，选择maven-archetype-webapp不能立web程序，建立的web程序不能启动。需要直接点击“Next”即可。

4、点击“Next”进入下一步，输入goupId和artifactId，类似于pom.xml中dependecy中的groupId和artifactId的意义。

这里，关于groupId和artifactId的解释:

groupid和artifactId都统称为“坐标”，是为了保证项目唯一性而提出的，如果你要把你的项目弄到maven仓库去，你想要找到你的项目就必须根据这两个id去查找。groupId是项目组织唯一的标识符，实际对应java包的结构，是main目录里java的目录结构。artifactId就是项目唯一的标识符，实际项目的名称。

groupId一般分为多个段，这里只说两段，第一段为域，第二段为公司名称。域又分为org、com、cn等等许多，其中org为非盈利阻止，com为商业阻止。比如apache公司的tomcat项目，groupId为org.apache，它的域为org，公司名称为apache，artifactId为tomcat。

如下图所示，对artifactId和groupId的解释。

5、在对话框中输入groupId和artifactId名称如下图。

6、点击next进入下一步，直接“finish”确认即可。

7、在出现的Pom.xml文件中，基本上没有任何配置，把maven开发的依赖包放在dependency的标签中，专业词汇讲在dependency中输入相关依赖。

8、把相关依赖输入完毕后，点击maven提示出来的import changes来更新pom.xml文件。

8、右键左侧项目栏中的项目名称，选择“Add Framework Support”。

9、在出现的对话框中，左侧选择“Web Application”，右侧会使用默认的4.0。

10、展开左侧的文件夹结构，能够看到web文件夹。

11、在java目录下建立com.myweb的groupId包，再建立pojo的Package,在于pojo下建立论文的模型文件Paper.java。结构如下图。

在模型文件paper.java中写入私有属性名。

在此类中，右键，选择“Generate...”,如下图。

在出现的菜单中选择“Getter And Setter”。

接下来在出现的对话框中选择所有的属性，使用shift键配合。

这样，就产生的所有属性的getter和setter方法。

接下来，在类中右键，仍然选择“Generate....”。

在出现的对话框中选择“to String......”，使得在程序中，将类实例化后，打印其实例化的变量，不会输出地址，会输出相关属性的值。

在出现的对话框中，默认所有的属性都被选择，直接点击“OK”即可。

接下来，继续在文件的首部右键。选择“Generate....”。

在出现的对话框中选择“Constructor”。

在出现的对话框中，配合shift点击所有的属性，再点击：OK，产生所有属性为参数的构造函数。

这样，产生全部属性为参数的构造方法。如下图。

再继续点击右键，选择“Generate.....”，其目的产生无参构造方法。

在产生的对话框中选择“Constructor”，如下图。

在出现的对话框中选择最上面的Paper类名，不选择其下面的属性，建立一个无参构造方法，使代码中直接实例化时不用传入参数，点击后OK关闭对话框。

这样，Paper论文类就建立成功了，代码如下 。

package com.myweb.pojo;

public class Paper {
    private long paperId;
    private String paperName;
    private long paperNum;
    private String paperDetail;

    public Paper() {
    }

    public Paper(long paperId, String paperName, long paperNum, String paperDetail) {
        this.paperId = paperId;
        this.paperName = paperName;
        this.paperNum = paperNum;
        this.paperDetail = paperDetail;
    }

    public long getPaperId() {
        return paperId;
    }

    public void setPaperId(long paperId) {
        this.paperId = paperId;
    }

    public String getPaperName() {
        return paperName;
    }

    public void setPaperName(String paperName) {
        this.paperName = paperName;
    }

    public long getPaperNum() {
        return paperNum;
    }

    public void setPaperNum(long paperNum) {
        this.paperNum = paperNum;
    }

    public String getPaperDetail() {
        return paperDetail;
    }

    public void setPaperDetail(String paperDetail) {
        this.paperDetail = paperDetail;
    }

    @Override
    public String toString() {
        return "Paper{" +
                "paperId=" + paperId +
                ", paperName='" + paperName + '\'' +
                ", paperNum=" + paperNum +
                ", paperDetail='" + paperDetail + '\'' +
                '}';
    }
}

接下来在com.myweb中建立dao的Package，建立Dao类，进行数据库中增删改查方法的定义。目录结构如下。

在dao的package下建立PaperDao接口类，注意在建立java class时选择Interface ,如下图。

在PaperDao的接口中定义增/删/改/根据id查找/全部查找的方法。如下图。

PaperDao类完整代码如下。

package com.myweb.dao;
import com.myweb.pojo.Paper;
import java.util.List;
public interface PaperDao {
    int addPaper(Paper paper);
    int delPaper(long id);
    int updatePaper(Paper paper);
    Paper getPaperById(long id);
    List<Paper> getAllPaper();
}

定义完Dao层后，定义Service层，也是定义基本的增/删/改/根据id查找/全部查找的接口。在com.myweb的package下建立services的Package，结构如下。

在services的package下，首先建立一个接口类PaperSerivce，注意建立Java class时选择的是Interface，如下图。

点击OK后，在PaperService中实现“增/删/改/根据id查/全部查”的接口定义方法。

PaperService类完整代码如下：

package com.myweb.services;

import com.myweb.pojo.Paper;
import java.util.List;
public interface PaperService {
    int addPaper(Paper paper);
    int delPaper(long id);
    int updatePaper(Paper paper);
    Paper getPaperById(long id);
    List<Paper> getAllPaper();
}

定义方法后，需要定义service 的实现，其实现在services包下建立impl实现包package,再定义service的实现方法类，目录结构如下图。

接下来，在PaperService中实现代码，代码中需要为PaperServiceImpl添加Service服务标签，还需要为Service中的dao对象定义私有变量，这个变量需要有Autowired标签，其中的每个增/删/改/根据id查/全部查都是通过dao对象的接口来实现的。代码如下。

PaperServiceImpl实现类完整代码如下：

package com.myweb.services.impl;
import com.myweb.pojo.Paper;
import com.myweb.services.PaperService;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import com.myweb.dao.PaperDao;
import java.util.List;
@Service
public class PaperServiceImpl implements PaperService{
    @Autowired
    private PaperDao paperdao;
    public int addPaper(Paper paper) {
        return paperdao.addPaper(paper);
    }

    public int delPaper(long id) {
        return paperdao.delPaper(id);
    }

    public int updatePaper(Paper paper) {
        return paperdao.updatePaper(paper);
    }

    public Paper getPaperById(long id) {
        return paperdao.getPaperById(id);
    }

    public List<Paper> getAllPaper() {
        return paperdao.getAllPaper();
    }
}

接下来定义Controller实现类，先在com.myweb下定义controller包package，再定义PaperController实现类，目录结构如下。

在controller类中，首先需要在controller类上部定义注解Controller，再通过注解RequestMapping设定其访问的根部地址。在类中需要使用service的对象，这里也需要service的对象添加上Autowired注解。

接下来在Controller类中定义第一个列出全部数据库内容的方法，需要通过ReqestMapping添加注解，来解决访问地址的问题。因为需要返回前台数据库中所有的查询数据，需要使用到spring框架中的Model，Model可以携带参数内容到前端模板显示。代码最后返回一个字符串，字符串代表前端的jsp页面名称。具体代码逻辑如下图。

继续实现第二个方法，添加数据，添加数据也需要注解RequestMapping来定义前端浏览器访问的位置，因为添加需要一个页面，页面中有一个form表单，最终用户填写数据后，提交form表单，这里对应两个方法，一个方法逻辑是返回页面的名称，一个方法逻辑是调用service中的添加实现，再跳转到全部论文列表页面，也就是重定向到论文列表页面。如下图所示。

接下来实现删除的方法，删除需要传入一个参数，也就是论文的id，这个id在地址栏后面以”/”分隔，因为在地址中，需要PathVariable注解的协助处理。同时RequesMapping实现注释的访问地址。代码逻辑上执行paperService的删除逻辑实现，删除后重定向到论文列表页面。如下图。

接下来实现Controller类的更新方法，更新方法也是需要RequestMapping注解定义访问地址，需要两个方法实现，一个方法返回数据更改的页面，一个方法中对form表单的数据修改后提交修改内容。在数据更改页面中，由于需要提供更改的id名，需要spring的Model携带id传送到前端页面中，第二个方法中实现表单的提交后，重定向到所有论文列表。Service中定义的根据id取数据，只是协助于数据更新的一个辅助方法。代码下图所示。

这样，PaperController具体代码如下：

package com.myweb.controller;

import com.myweb.pojo.Paper;
import com.myweb.services.PaperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/paper")
public class PaperController {
    @Autowired
    private PaperService paperservice;
    @RequestMapping("/allPaper")
    public String allPaper(Model model){
        List<Paper> lists=paperservice.getAllPaper();
        model.addAttribute("lists",lists);
        return "allPaper";
    }
    @RequestMapping("toAddPaper")
    public String toAddPaper(){
        return "addPaper";
    }
    @RequestMapping("/addPaper")
    public String addPaper(Paper paper){
        paperservice.addPaper(paper);
        return "redirect:/paper/allPaper";
    }
    @RequestMapping("/del/{paperId}")
    public String delPaper(@PathVariable("paperId")Long id){
        paperservice.delPaper(id);
        return "redirect:/paper/allPaper";
    }
}

Pojo层、 dao层、service层、controller层定义成功后，进入到配置文件，首先配置jdbc连接数据库的参数，需要在resources目录下建立jdbc.properties的配置文件，结构如下图。

建立的jdbc.properties 的文件内容需要定义驱动，数据库连接地址，用户名和密码。具体文件内容如下图。

具体配置内容如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/myuser?characterEncoding=utf8
jdbc.username=root
jdbc.password=admin

接下来定义mybatis 的配置文件，也是在resources的目录下建立mybatis-config.xml文件。结构如下图。

Mybatis-config配置文件中需要添加configuration的约束，在约束下只能使用约定的标签。这里定义setting中的name名称为logImpo，其value值为“STDOUT_LOGGING”,其目的是检查mybatis编译时输出的sql语句及输出结果。如下图。

具体配置内容如下：

<?xml version="1.0" encoding="utf8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Configuration 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"></setting>
    </settings>
</configuration>

接下来，在resources资源目录下建立spring文件夹，建立spring-dao的配置文件，配置文件首先定义spring的相关约束，如下图。

注意约束时，xsi:schemaLocation后面每一句后有一个空格。

然后dao文件需要引入jdbc.properties文件的配置，<context:property-placeholder>的作用是向Spring容器中注入一个属性占位解析器，用来处理BeanDefinition中的各种占位符，用配置文件的信息替换占位符。这是个自定义标签，Spring会使用PropertyPlaceholderBeanDefinitionParser解析它。

PropertyPlaceholderConfigurer实现了BeanFactoryPostProcessor接口，它能够对中的属性值进行外在化管理。开发者可以提供单独的属性文件来管理相关属性。如下图所示。

定义外在化管理后，定义c3p0的数据库连接池。在连接池中需要在bean标签中指明c3p0的bean对应class管理类，其面的属性driverClass指明驱动类，jdbcUrl指示jdbc的连接地址，user指明jdbc连接用户名，password指明jdbc连接密码，还有一些其它的属性和值，解释如下 。

连接池中保留的最大连接数。默认值: 15 
<property name="maxPoolSize" value="20"/>  
连接池中保留的最小连接数，默认为：3
<property name="minPoolSize" value="2"/>  
当连接池连接耗尽时，客户端调用getConnection()后等待获取新连接的时间，超时后将抛出SQLException，如设为0则无限期等待。单位毫秒。默认: 0  
<property name="checkoutTimeout" value="3000"/>  
定义在从数据库获取新连接失败后重复尝试的次数。默认值: 30 ；小于等于0表示无限次
<property name="acquireRetryAttempts" value="0"/>  
关闭连接时，是否提交未提交的事务，默认为false，即关闭连接，回滚未提交的事务 
<property name="autoCommitOnClose">false</property>

C3p0具体参数设置如下图。

由于mybatis的工程过程中，要对主配置文件和映射配置文件进行读取，读取之后构建一个和数据库之间的会话。那这个过程呢，主要是由SqlSessionFactoryBuilder来进行处理的，SqlSessionFactoryBuilder结合配置文件构造出了一个SqlSessionFactory工厂类，这个工厂我们在整个应用程序中只需要构建一次就可以了。

通过SqlSessionFactoryBean我们可以通过对其指定一些属性来提供Mybatis的一些配置信息。

在定义SqlSessionFactoryBean的时候，dataSource属性是必须指定的，它表示用于连接数据库的数据源。

mapperLocations：它表示我们的Mapper文件存放的位置，当我们的Mapper文件跟对应的Mapper接口处于同一位置的时候可以不用指定该属性的值

configLocation：用于指定Mybatis的配置文件位置。如果指定了该属性，那么会以该配置文件的内容作为配置信息构建对应的SqlSessionFactoryBuilder，但是后续属性指定的内容会覆盖该配置文件里面指定的对应内容

typeAliasesPackage：它一般对应我们的实体类所在的包，这个时候会自动取对应包中不包括包名的简单类名作为包括包名的别名。多个package之间可以用逗号或者分号等来进行分隔（value的值一定要是包的全称）

具体配置如下图。

Mybatis需要整合到spring中，spring中定义了很多的dao方法，需要与mapper文件中配置文件中的方法进行对应，通过MapperScannerConfigurer来扫描Dao包里面的mapper接口，动态的将mapper接口进行实例化,配置mapper扫描器时需要把sqlSessionFactory注入到mapper扫描器中。具体配置如下图。

这样，spring-dao的文件内容如下：

<?xml version="1.0" encoding="utf8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                          http://www.springframework.org/schema/context
                          http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="minPoolSize" value="10"></property>
        <property  name="maxPoolSize" value="30"></property>
        <property name="autoCommitOnClose" value="false"></property>
        <property name="acquireRetryAttempts" value="2"></property>
        <property name="checkoutTimeout" value="10000"></property>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="typeAliasesPackage" value="com.myweb.pojo"></property>
        <property name="mapperLocations" value="classpath:mapper/PaperMapper.xml"></property>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <property name="basePackage" value="com.myweb.dao"></property>
    </bean>
</beans>

配置后注意右上有，出现一个提示。

点击这个提示，会出现create applicatio context 的提示。继续点击。

在出现的对话框中，可以改名，也可以默认，直接点击OK即可，这样spring的application context就建立了，后面的spring配置文件都需要点击。

接下来定义spring-service文件，也就是在spring目录下建立spring-service文件，目录结构如下。

在文件中首先需要扫描services包下的service的接口类，然后对数据库中的内容进行事务的处理，在任务失败时进行回滚操作，需要使用bean定义spring的DataSourceTransManage数据源的事务管理类，其中的属性指向于dataSource，最后通过tx标签的annotation-driven指明spring开发里支持注解，支持事务注解的如@Transactional。@Transactional 可用于声明式事务管理，只被应用到 public 方法上.其实质是使用了 JDBC 的事务来进行事务控制的。这里没有用到事务的注释，在这里也声明了一下事务的注解管理。

Spring-service的内容如下。

文件内容产生后，编辑器右上角也会出现提示，建立spring application context。

点击后会有上次定义的spring application context,直接点击上次的application context的名字即可。如下图。

Spring-service的文件具体内容如下：

<?xml version="1.0" encoding="utf8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
                          http://www.springframework.org/schema/context
                          http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/tx
                          http://www.springframework.org/schema/tx/spring-tx.xsd ">
    <context:component-scan base-package="com.myweb.services"></context:component-scan>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

接下来，继续定义spring-mvc的配置文件，在spring目录下建立spring-mvc.xml文件，目录结构如下图。

在spring-mvc.xml文件中，首先也是声明spring mvc的相关约束，然后调用mvc的annotation-driven，表示支持注解式开发，其与<context:component-scan/>有区别，<context:component-scan/>标签是告诉Spring 来扫描指定包下的类，并注册被@Component，@Controller，@Service，@Repository等注解标记的组件。<mvc:annotation-driven/>是告知Spring，我们启用注解驱动。然后Spring会自动为我们注册上面说到的几个Bean到工厂中，来处理我们的请求。接下来配置<mvc:default-servlet-handler />后，会在Spring MVC上下⽂中定义⼀个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler，它会像⼀个检查员，对进⼊DispatcherServlet的URL进⾏筛查，如果发现是静态资源的请求，就将该请求转由Web应⽤服务器默认的Servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理。

关于<mvc:annotation-driven/>和<mvc:default-servlet-handler/>配置如下图。

Spring 视图解析器是 Spring MVC 中的重要组成部分，用户可以在配置文件中定义 Spring MVC 的一个视图解析器（ViewResolver）InternalResourceViewResolver就是视图解析器的类，帮助mvc显示前端页面的内容，也是spring mvc的前端控制器， InternalResourceViewResolver返回InternalResourceView （即Servlet和JSP），但是可以使用viewClass属性将其配置为返回JstlView ，这里配置中就使用了JstlView的viewClass属性，配置prefix前缀和suffix后缀，这样，视图解析器控制器类的视图路径仅需提供文件名，视图解析器将会自动添加前缀和后缀。如下图所示。

最后需要定义<context:component-scan/>组件扫描。对controller中的类进行扫描。具体配置如下。

这样。Spring-mvc.xml的具体内容如下。

<?xml version="1.0" encoding="utf8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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
                          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">
    <mvc:annotation-driven />
    <mvc:default-servlet-handler />
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <context:component-scan base-package="com.myweb.controller"></context:component-scan>
</beans>

点击后，会出现前面配置过的spring application context的名字，点击这个名字即可。如下图所示。

接下来需要配置mybatis 中的mapper文件，其实现了spring中dao操作的接口。是与spring中dao操作的方法进行对应的，实质将spring中dao操作的接口对应了mybatis中mapper文件的sql语句执行。

首先在resource目录下建立文件夹mapper，在mapper文件夹下建立PaperMapper.xml文件，目录结构如下图所示。

文件内容首先定义mapper文件的约束，然后使用mapper标签，需要注意，mapper标签后需要一个namespace域名属性，在Mybatis中，映射文件中的namespace是用于绑定Dao接口的，即面向接口编程。当你的namespace绑定接口后，就可以不用写接口实现类，Mybatis会通过该绑定自动找到对应要执行的SQL语句，这样直接在下面对应id名称的dao接口方法下写入执行的sql语句即可。内容如下。

接下来，可以实现具体的方法，定义添加方法，可认使用insert标签，insert标签中有相关属性，id是命名空间中的唯一标识符，可被用来代表这条语句.，其往往与dao方法实现类的方法名一致。parameterType参数决定将要传入语句的参数的完全限定类名或别名。flushCache设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，基默认为true。statementType其值可以取STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。防止sql注入。useGeneratedKeys这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键，可用于处理关系数据库管理系统的自动递增字段。基本配置需要配置id和parameterType，这里使用这两个属性来配置插入一篇论文的sql语句实现，如下图所示。

同样的方法操作delete方法，也定义id与parameterType，同样注意id与parameterType的类型/方法与PaperDao中的类型/方法保持一致。

继续实现update更新操作的sql语句与PaperDao中的方法对应。同样的道理设置id与parameterType属性，也是注意id与parameterType的类型/方法与PaperDao中的类型/方法保持一致。

继续实现通过id取内容。这里需要用到select标签，由于select操作会返回一个数据或多个数据，需要说明resultType或者resultMap，根据id取数据只返回一个数据，使用resultType即可。再定义id与parameterType属性。具体设置内容如下图。

继续实现取出数据库全部内容。这里需要用到select标签，由于select操作会返回多个数据，需要使用resultMap，resultMap本身具备id属性，属于resultMap标签的标识。还有type属性 ，返回值的全限定类名，或类型别名。属性autoMapping ，值范围true（默认值）|false, 设置是否启动自动映射功能，自动映射功能就是自动查找与字段名小写同名的属性名，并调用setter方法。而设置为false后，则需要在resultMap内明确注明映射关系才会调用对应的setter方法。这里没有使用。在resultMap中可以定义id和result两个标签，id标签用于设置主键字段与领域模型属性的映射关系，result标签用于用于设置普通字段与领域模型属性的映射关系。在id和result标签中可以定义property，其值对应了JavaBean 的属性名称。Column属性对应了数据库中列的名称，javaType属性标记一个完整的类名，或者是一个类型别名。如果你匹配的是一个JavaBean，那MyBatis 通常会自行检测到。如下面的例子。

<select id="getStudent" resultMap="getStudentRM">
    SELECT ID, Name, Age
    FROM TStudent
</select>
<resultMap id="getStudentRM" type="EStudnet">
    <constructor>
        <idArg column="ID" javaType="_long"/>
        <arg column="Name" javaType="String"/>
        <arg column="Age" javaType="_int"/>
    </constructor>
</resultMap>

这里的constructor元素标签 ，指定使用指定参数列表的构造函数来实例化领域模型。注意：其子元素顺序必须与参数列表顺序对应。还有idArg子元素标签 ，标记该入参为主键，还有arg子元素 ，标记该入参为普通字段(主键使用该子元素设置也是可以的)。

在resultMap下也可以定义一对一，一对多的关系。通过association联合

标签。如下例。

<resultMap type="ClassEntity" id="classResultMap">  
    <id property="classID" column="CLASS_ID" />  
    <result property="className" column="CLASS_NAME" />  
    <result property="classYear" column="CLASS_YEAR" />  
    <association property="teacherEntity" column="TEACHER_ID" select="getTeacher"/>  
</resultMap>  
<select id="getClassByID" parameterType="String" resultMap="classResultMap">  
    SELECT * FROM CLASS_TBL CT  
     WHERE CT.CLASS_ID = #{classID}; 
</select> 

这样可以直接复用在TeacherMapper.xml文件中定义好的查询teacher根据其ID的select语句。也就是在TeacherMapper.xml中也有一个查询语句，指出Teacher的查询结果

<resultMap type="TeacherEntity" id="teacherResultMap">  
    <id property="teacherID" column="TEACHER_ID" />
    <result property="teacherName" column="TEACHER_NAME" />
    <result property="teacherSex" column="TEACHER_SEX" />
    <result property="teacherBirthday" column="TEACHER_BIRTHDAY"/>
    <result property="workDate" column="WORK_DATE"/> 
    <result property="professional" column="PROFESSIONAL"/> 
</resultMap> 
    <select id="getTeacher" parameterType="String"  resultMap="teacherResultMap">
     SELECT *  
     FROM TEACHER_TBL TT  
    WHERE TT.TEACHER_ID = #{teacherID}  
</select>

注意上面两个配置文件中type，id及property/column值的对应关系。

collection聚集也可以实现ResultMap之间的一对多的聚集。所以这里需要定义javaType为ArrayList，还需要定义列表中对象的类型ofType，以及必须设置的select的语句名称（需要注意的是，这里的查询student的select语句条件必须是外键classID）。

如下例：

<resultMap type="ClassEntity" id="classResultMap">  
  <id property="classID" column="CLASS_ID" />  
  <result property="className" column="CLASS_NAME" /> 
  <result property="classYear" column="CLASS_YEAR" />  
  <association property="teacherEntity" column="TEACHER_ID"  select="getTeacher"/>  
  <collection property="studentList" column="CLASS_ID" javaType="ArrayList" ofType="StudentEntity" select="getStudentByClassID"/>  
</resultMap>  
<select id="getClassByID" parameterType="String" resultMap="classResultMap">  
    SELECT * FROM CLASS_TBL CT  
</select> 

文件中对应了一个studentList的property属性，对应studentList的实现配置如下。

<!-- java属性，数据库表字段之间的映射定义 -->  
<resultMap type="StudentEntity" id="studentResultMap">  
    <id property="studentID" column="STUDENT_ID" />  
    <result property="studentName" column="STUDENT_NAME" />  
    <result property="studentSex" column="STUDENT_SEX" />  
    <result property="studentBirthday" column="STUDENT_BIRTHDAY" />
</resultMap>  
<!-- 查询学生list，根据班级id -->  
<select id="getStudentByClassID" parameterType="String" resultMap="studentResultMap">  
    <include refid="selectStudentAll" />  
    WHERE ST.CLASS_ID = #{classID}  
</select>  

针对于Paper论文的案例，select方法以全部选择所有数据，需要返回resultMap,基于的resultMap需要设置id，其id与select标签中的resultMap属性一致，resultMap的type属性指向于spring框架中pojo的Paper模型，在resultMap中包含id和result，id是主键，result指向的不是主键，column指向数据库的名称，property中的字段指向spring框架中pojo的Paper字段名称。最后注意select方法的id名称需要和PaperDao中的接口名称一致。如下图所示。

这样，PaperMapper文件的配置内容如下：

<?xml version="1.0" encoding="utf8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.myweb.dao.PaperDao">
    <insert id="addPaper" parameterType="Paper">
        insert into paper(id,name,number,detail) values(#{paperId},#{paperName},#{paperNum},#{paperDetail})
    </insert>
    <delete id="delPaper" parameterType="long">
        delete from paper where id=#{paperId}
    </delete>
    <update id="updatePaper" parameterType="Paper">
        update paper set name=#{paperName},number=#{paperNum},detail=#{paperDetail} where id=#{paperId}
    </update>
    <select id="getPaperById" parameterType="long" resultType="Paper">
        select id,name,number,detail from paper where id=#{paperId}
    </select>
    <resultMap id="paperResultMap" type="Paper">
        <id property="paperId" column="id"></id>
        <result property="paperName" column="name"></result>
        <result property="paperNum" column="number"></result>
        <result property="paperDetail" column="detail"></result>
    </resultMap>
    <select id="getAllPaper" resultMap="paperResultMap">
        select id,name,number,detail from paper
    </select>
</mapper>

最后编辑web.xml文件，在文件中需要dispacherServlet和encodingFIlter,一个servlet和一个中文的过滤器。

DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。

DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下：

1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；

2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；

3、  通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；

4、通过ViewResolver解析逻辑视图名到具体视图实现；

5、本地化解析；

6、渲染具体的视图等；

7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。

其流程图如下：

web.xml中的dispatcherServlet与ContextLoaderListener的关系如下图。

Web.xml中的具体配置如下图所示。

这样，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">
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/spring-*.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

接下来实现三个前端jsp页面，在WEB-INF文件夹下建立jsp文件夹，这是与前面spring-mvc中配置前端视图控制器的prefix前缀属性值有关系，然后在jsp文件夹下建立3个文件，名称为allPaper.jsp，addPaper.jsp，updatePaper.jsp，其目录结构如下。

这里面allPaper.jsp代码如下。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    String path=request.getContextPath();
    String basePath=request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title>Title</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    基于SSM架构的简单增删改查
                </h1>
            </div>
        </div>
    </div>
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <div class="page-header">
                    <h1>
                        <small>
                            全部论文列表
                        </small>
                    </h1>
                </div>
            </div>
        </div>
    </div>
    <div class="row clearfix">
        <div class="col-md-12 column">
            <table class="table table-hover table-stripped">
                <thead>
                    <th>
                        <td>论文编号</td>
                        <td>论文名称</td>
                        <td>论文数量</td>
                        <td>论文详情</td>
                        <td>相关操作</td>
                    </th>
                </thead>
                <tbody>
                    <c:forEach var="paper" items="${requestScope.get('lists')}">
                        <tr>
                            <td>${paper.paperId}</td>
                            <td>${paper.paperName}</td>
                            <td>${paper.paperNum}</td>
                            <td>${paper.paperDetail}</td>
                            <td>
                                <a href="<%=basePath%>paper/del/${paper.paperId}">删除</a>
                                <a href="<%=basePath%>paper/toUpdatePaper?id=${paper.paperId}">更新</a>
                            </td>
                        </tr>
                    </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>
</html>

这里addPaper.jsp的文件内容如下。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    String path=request.getContextPath();
    String basePath=request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title>Title</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    基于SSM框架的增删改查操作
                </h1>
            </div>
        </div>
    </div>
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>
                        新增论文
                    </small>
                </h1>
            </div>
        </div>
    </div>
    <form action="">
        <input type="text" name="paperId"/><br/>
        <input type="text" name="paperName"/><br/>
        <input type="text" name="paperNum"/><br/>
        <input type="text" name="paperDetail"/><br/>
        <input type="button" value="添加" onclick="addPaper()"/>
    </form>
</div>
</body>
<script>
    function addPaper(){
        myform=document.forms[0]
        myform.action="<%=basePath%>paper/addPaper"
        myform.method="post"
        myform.submit()
    }
</script>
</html>

这里updatePaper.jsp文件内容如下。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    String path=request.getContextPath();
    String basePath=request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title>Title</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    基于SSM框架的增删改查操作
                </h1>
            </div>
        </div>
    </div>
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>
                        更新论文
                    </small>
                </h1>
            </div>
        </div>
    </div>
    <form action="">
        <input type="text" value="${paper.paperId}" name="paperId"/><br/>
        <input type="text" value="${paper.paperName}" name="paperName"/><br/>
        <input type="text" value="${paper.paperNum}"name="paperNum"/><br/>
        <input type="text" value="${paper.paperDetail}" name="paperDetail"/><br/>
        <input type="button" value="更新" onclick="updatePaper()"/>
    </form>
</div>
</body>
<script>
    function updatePaper(){
        myform=document.forms[0]
        myform.action="<%=basePath%>paper/updatePaper"
        myform.method="post"
        myform.submit()
    }
</script>
</html>

19、点击File菜单中的Project Strcuture选项。

20、点击Project Structure之后，点击左侧的Modules，然后看中侧的Web，再看右侧的两栏。

21、再点击Project Structure之后。点击左侧的Artifacts，然后看右侧的WEB-INF下是否有lib目录，如果有，则正常。

22、如果最右侧没有lib，则在最右侧的mydemomvc1的项目中点击右键，选择“Put into Output Root”选项。

23、最后建立tomcat环境，在右侧点击Edit Configurations，如下图所示。

24、在弹出的对话框中选择加号。

25、在左栏中找到Apache Server，在右栏中找到Local，如下图。

26、在弹出的对话框中点击“Deployment”。如下图。

27、在弹出的对话框中点击右侧加号，出现的选择框中选择Artifacts。如下图。

28、点击后的结果如下图。

29、点击“OK”确定后，即可运行该程序。

30、在浏览器中访问的结果如下。

上面的页面是http://localhost:8080/paper/allPaper的地址页面，添加论文的地址页面如下。

上面的页面是http://localhost:8080/paper/addPaper的地址页面，更新论文的地址页面如下。

至此，基于SSM框架博文增删改查项目完整过程结束。