简单说说SpringMVC

距离上一次开发SpringMVC项目已经过去了大半年，有些细节已经开始遗忘，今天复习一下

先从标签说起：

和struts有各种配置文件不同，spring用标签开发。

1.@Controller
在SpringMVC中，控制器Controller负责处理由DispatcherServlet分发的请求
他把用户请求的数据经过业务处理层处理之后封装成一个model，然后再把该model
返回给对应的view进行展示。在SpringMVC中提供一个非常简便的定义Controller
的方法，你无需继承特定的类或实现特定的接口，
只需要使用@Controller标记一个类是controller，然后使用@RequestMapping，@RequestParam
等一些注解用以定义URL请求和Controller方法之间的映射，这样Controller就能被外界访问到
此外，Controller不会直接依赖于 HttpServletRequest 和 HttpServlet对象，他们可以通过Controller的 方法参数灵活的获取到。

@Controller用于标记一个类上，使用他标记的类就是一个Spring'MVC Controller对象
分发处理器将会扫描用了该注解的类的方法，并检测该方法是否使用了@RequestMapping注解
@Controller只是定义了一个控制器类，而使用@RequestMapping注解的方法才是真正处理请求的
处理器，单单使用@Controller标记在一个类上还不能真正意义上说他就是SpringMVC的一个控制类
因为这个时候Spring还不认识他，那么要如何做Spring才能认识她呢？
这个时候就需要我们把这个控制器类交给Spring来管理，有两种方式
（1）在SpringMVC配置文件中定义MyController的bean对象
（2）在SpringMVC配置文件中告诉Spring该到哪里去找标记为@Controller的Controller控制器
<!--方式一-->
<bean class="com.host.app.web.controller.MyController"/>
<!--方式二-->
<context:component-scan base-package="com.host.app.web">
//路径写到controller的上一层（扫描包详见下面解析）

2.＠RequestMapping
RequestMapping是一个用来处理请求地址映射的注解，可用于类和方法上。
用于子类上表示类中的所有响应请求的方法都是以该地址作为父路径

RequestMapping注解有六个属性，下面我们把他分成三类进行说明（下面有相应实例）
1.value,method
value:指定请求的实际地址，指定的地址可以是URL Temple模式（后面将会说明）
method：指定请求的method类型，GET，POST，PUT，DELETE等
@RequestMapping（value="",method={"",""},header={},param={"",""}）
参数：
value：设置访问地址
method：设置访问方式，常用的method=RequestMethod.POST和
method=RequestMethod.GET
headers：头域，可以设置浏览器支持的格式
params：访问参数设置
注解作用：
用来定义访问url，可以是方法级别的，也可以是类级别的，两者可以协同工作，缩小选择范围
也可以隐藏代码的真实路径，更加具有安全性和可读性

3.@Autowired
注解作用：
可以对成员变量，方法和构造函数进行标注，来完成自动装配工作，可以消除get/set方法
action里get/set注入

5.@PathVariable
用于将请求URL中的模板变量映射到功能处理方法的参数上，即将取出url模板中的变量作为参数
@PathVariable
注解作用：
用于方法中的参数，表示方法参数绑定到地址URL的模板

6.@RequestParam
@RequestParam主要用于在SpringMVC后台控制层获取参数，
类似一种是request.getParameter("name"),他有三个常用参数，
defaultValue="0" ; required=false , value="isApp" ; defaultValue表示设置默认值，
required通过boolean设置是否必须要传入的参数，value值表示接受的传入的参数类型

@RequestParam（required= , value="",defaultValue=""）
参数：
required：参数是否必须，boolean类型：默认为true
value：传递的参数名称。String类型，可选项，有值则对应方法的参数
defaultValue：参数没有传递时为参数默认指定的值

7.@ResponseBody
作用：该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter
转换为适当格式后，写入到Response对象的body数据区
使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json，xml等）、

8.@ResponseBody注解作用：
直接放在方法上，表示返回类型将会直接作为http响应字节流输出，可以用于Ajax

9.@Service-表示业务处理层（一般在serviceImpl）
说明：@Service负责注册一个bean到spring上下文中，bean的ID默认为类名称开头字母小写

10.@Transactional
事务管理模式
spring支持编程式事务管理和声明式事务管理两种方式
编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager
对于编程式事务管理，spring推荐使用TransactionTemple

声明式事务管理建立在AOP之上，，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事物，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需要在配置文件中做相关的事务规则声明（或通过基于@Transaction注解的方式），便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理，这正式spring倡导的非侵入式的开发方式，声明式事务管理使业务代码不受到污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务3唯一不足的地方是后者最细粒度只能作用到方法级别，无法做到编程式事务那样可以做到代码块级别，但是即便有这样的需求，也存在很多变通的方法如可以将需要进行事务管理的代码块独立为方法等等

声明式事务管理也有两种常用的方式，一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解，显然基于注解的方式更简单易用，更清爽

TransactionDefinition.PROPAGATION_REQUIRED:如果当前存在事务，则加入该事事务，如果当前没有事务，则创建一个新的事务，这是默认值。
TransactionDefinition.PROPAGATION_REQUIRES_NEW:创建一个新的事务，如果当前存在事务，则把当前事务挂起
TransactionDefinition.PROPAGATION_SUPPORTS:如果当前存在事务，则加入该事务，如果没有则以非事务的方式继续运行
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，把当前事务挂起
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果存在当前事务，则抛出异常
TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事事务，没有事务则抛出异常
TransactionDefinition.PROPAGATION_NESTED如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行，
如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED

属性：
Propagation可选的事务传播行为设置
ReadOnly：读写或只读事务，默认读写（boolean）
readOnly=true 只读，不能更新，删除

//设置超时时间
@Transactional（propagation=Propagation.REQUIRED,timeout=30）
注：
@Transactional注解应该只被应用到public方法上，这是由SpringAOP的本质决定的，
如果你在protected，private或者默认可见性的方法上使用@Transactional注解将被忽略
也不会抛出任何异常

在Service类前加上@Transactional，声明这个service所有方法需要事务管理
每一个业务方法开始时都会打开一个事务

11.@SelectProvider
@SelectProvider注解用于生成查询用的sql语句，有别于@Select注解，@SelectProvider指定一个Class及其方法，并且通过调用Class上的这个方法来获得sql语句，在我们这个例子中，获取查询sql方法是SqlProvider selectUser

@SelectProvider中type参数指定的class类，必须要能够通过无参数的构造函数来初始化，

@SelectProvider中method参数指定的方法必须是public的，返回值必须为String，可以为static
注：如果在getUser方法中，对userId方法使用了@Param注解，那么相应selectUser方法必须
接受Map<String,Object>作为参数
如果参数使用了@Param注解，那么参数在Map中以@Param的值为key

ps：很多人（包括我）在刚开始开发spring时，对那些xxxAction.class都报有一丝敬畏之心，但实际上，只有你在这个class里添加了@Controller标签，他才会成为真正意义上的action，可以控制页面跳转和与前台交互数据，接下来放一一个登录demo的栗子帮助理解springMV西

action：登录功能代码丢了，这个我日后补上

然后！controller 和 jsp 的地址一定要能对上，controller要记得初始化你想要跳转到页面（就像下面的22~24行、52~55行），否则会出现空页面情况

package com.javen.modules.Test.web;

import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.javen.common.controller.BaseController;
import com.javen.common.utils.MessageUtils;
import com.javen.modules.Test.dao.model.Table;
import com.javen.modules.Test.service.TestService;

@Controller
@RequestMapping("/wf/test")
public class TestController extends BaseController{

    @Autowired
    private TestService service;

    @RequestMapping("")
    public String log(){
        return "test/testLog";
    }

    @RequestMapping("/list")
    public String list(Model model,
            @RequestParam(value="name",required=false,defaultValue="") String name,
            @RequestParam(value="sex",required=false,defaultValue="") String sex,
            @RequestParam(value="cp", required=false, defaultValue="1") int currPage){
        List<Map<String,String>> list = service.getList(name, sex, currPage,2);
        int cnt =service.getCnt(name,sex);
        model.addAttribute("cnt",cnt);
        if(cnt < 1){
            alertInfo(MessageUtils.getMessage("INF0003", "鎶辨瓑锛岃�閲嶆柊杈撳叆"), model);
        }else {
            if("".equals(sex)){
                sex = "3";
                        model.addAttribute("sex", sex);
            }
            model.addAttribute("offset", (currPage-1)*2);
            model.addAttribute("currPage", currPage);
            model.addAttribute("name", name);
            model.addAttribute("list", list);
        }

        return "test/testList";

    }

    @RequestMapping("/add")
    public String add(){

        return "test/testAdd";
    }

    @RequestMapping(value = "/add/exec")
    public String a (Table table,Model model){
            int b = service.get(table);
            if(b > 0){
                alertError(MessageUtils.getMessage("ERR0016", "閲嶅�"), model);
                return "forward:/wf/test/add";
            }
         table.setDegree("纭曞＋");
         table.setGradUni("鍝堝皵婊ㄧ悊宸ュぇ瀛�");
         table.setMail("1225165@qq.com");
         table.setTelNumber("13055465421");

         boolean add = service.addTable(table);
         if (add) {
             alertSuccess(MessageUtils.getMessage("INF0001", "鎴愬姛"), model);
             alertSucc(model, 2);
         } else {
             alertError(MessageUtils.getMessage("ERR0016", "澶辫触"), model);

         }


         return "forward:/wf/test/add";


    }
}

 乱码是我把文件乱保存出现了解码错误吧，都是些自己设定的报错或者提示信息，不影响功能

service：

package com.javen.modules.Test.service;

import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.javen.common.service.BaseService;
import com.javen.modules.Test.dao.mapper.TableMapper;
import com.javen.modules.Test.dao.model.Table;
import com.javen.modules.Test.dao.model.TableExample;
import com.javen.modules.Test.dao.model.TableExample.Criteria;


@Service
@Transactional(readOnly=true)
public class TestService extends BaseService{

    @Transactional(propagation = Propagation.SUPPORTS)
    public int getCnt(String name ,String sex){
        TableMapper mapper = readonlySQLSession.getMapper(TableMapper.class);
        TableExample example = new TableExample();
        Criteria criteria = example.createCriteria();
        if(!"".equals(name)){
            criteria.andNameLike(name);
        }if(!"".equals(sex)){
            criteria.andSexEqualTo(sex);
        }
        return mapper.countByExample(example);

    }

    @Transactional(propagation=Propagation.SUPPORTS)
    public List<Map<String, String>> getList(String name, String sex,
            int currPage, int size) {
        TableMapper mapper = readonlySQLSession.getMapper(TableMapper.class);
        int offset=(currPage-1)*size;
        return mapper.getList(name,sex,offset,size);
    }

    @Transactional(propagation=Propagation.SUPPORTS)
    public int get(Table table) {
        TableMapper mapper = readonlySQLSession.getMapper(TableMapper.class);
        return mapper.getmapper(table);
    }


    @Transactional(propagation=Propagation.SUPPORTS)
    public boolean addTable(Table table) {
        TableMapper mapper = writableSQLSession.getMapper(TableMapper.class);
        return mapper.insertSelective(table)>0;
    }

}

 连db部分是自动生成的文件，这里我挑有用的复制了

package com.javen.modules.Test.dao.mapper;

import com.javen.modules.Test.dao.model.Table;
import com.javen.modules.Test.dao.model.TableExample;

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

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.UpdateProvider;
import org.apache.ibatis.type.JdbcType;

public interface TableMapper {
    @SelectProvider(type=TableSqlProvider.class, method="countByExample")
    int countByExample(TableExample example);

    @DeleteProvider(type=TableSqlProvider.class, method="deleteByExample")
    int deleteByExample(TableExample example);

    @Delete({
        "delete from table",
        "where id = #{id,jdbcType=INTEGER}"
    })
    int deleteByPrimaryKey(Integer id);

    @Insert({
        "insert into table (id, name, ",
        "tel_number, degree, ",
        "sex, grad_uni, mail, ",
        "password)",
        "values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, ",
        "#{telNumber,jdbcType=VARCHAR}, #{degree,jdbcType=VARCHAR}, ",
        "#{sex,jdbcType=CHAR}, #{gradUni,jdbcType=VARCHAR}, #{mail,jdbcType=VARCHAR}, ",
        "#{password,jdbcType=VARCHAR})"
    })
    int insert(Table record);

    @InsertProvider(type=TableSqlProvider.class, method="insertSelective")
    int insertSelective(Table record);

    @SelectProvider(type=TableSqlProvider.class, method="selectByExample")
    @Results({
        @Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
        @Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
        @Result(column="tel_number", property="telNumber", jdbcType=JdbcType.VARCHAR),
        @Result(column="degree", property="degree", jdbcType=JdbcType.VARCHAR),
        @Result(column="sex", property="sex", jdbcType=JdbcType.CHAR),
        @Result(column="grad_uni", property="gradUni", jdbcType=JdbcType.VARCHAR),
        @Result(column="mail", property="mail", jdbcType=JdbcType.VARCHAR),
        @Result(column="password", property="password", jdbcType=JdbcType.VARCHAR)
    })
    List<Table> selectByExample(TableExample example);

    @Select({
        "select",
        "id, name, tel_number, degree, sex, grad_uni, mail, password",
        "from table",
        "where id = #{id,jdbcType=INTEGER}"
    })
    @Results({
        @Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
        @Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
        @Result(column="tel_number", property="telNumber", jdbcType=JdbcType.VARCHAR),
        @Result(column="degree", property="degree", jdbcType=JdbcType.VARCHAR),
        @Result(column="sex", property="sex", jdbcType=JdbcType.CHAR),
        @Result(column="grad_uni", property="gradUni", jdbcType=JdbcType.VARCHAR),
        @Result(column="mail", property="mail", jdbcType=JdbcType.VARCHAR),
        @Result(column="password", property="password", jdbcType=JdbcType.VARCHAR)
    })
    Table selectByPrimaryKey(Integer id);

    @UpdateProvider(type=TableSqlProvider.class, method="updateByExampleSelective")
    int updateByExampleSelective(@Param("record") Table record, @Param("example") TableExample example);

    @UpdateProvider(type=TableSqlProvider.class, method="updateByExample")
    int updateByExample(@Param("record") Table record, @Param("example") TableExample example);

    @UpdateProvider(type=TableSqlProvider.class, method="updateByPrimaryKeySelective")
    int updateByPrimaryKeySelective(Table record);

    @Update({
        "update table",
        "set name = #{name,jdbcType=VARCHAR},",
          "tel_number = #{telNumber,jdbcType=VARCHAR},",
          "degree = #{degree,jdbcType=VARCHAR},",
          "sex = #{sex,jdbcType=CHAR},",
          "grad_uni = #{gradUni,jdbcType=VARCHAR},",
          "mail = #{mail,jdbcType=VARCHAR},",
          "password = #{password,jdbcType=VARCHAR}",
        "where id = #{id,jdbcType=INTEGER}"
    })
    int updateByPrimaryKey(Table record);



    @SelectProvider(type=TableSqlProvider.class, method="getCntsql")
    int getCnt(String name, String sex);

    @SelectProvider(type=TableSqlProvider.class, method="getListsql")
    List<Map<String, String>> getList(
            @Param("name") String name,
            @Param("sex") String sex,
            @Param("offset") int offset,
            @Param("size") int size);


    @SelectProvider(type=TableSqlProvider.class, method="getmappersql")
    int getmapper(Table table);
}

 还有

package com.javen.modules.Test.dao.mapper;

import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;
import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;
import static org.apache.ibatis.jdbc.SqlBuilder.FROM;
import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;
import static org.apache.ibatis.jdbc.SqlBuilder.ORDER_BY;
import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;
import static org.apache.ibatis.jdbc.SqlBuilder.SELECT_DISTINCT;
import static org.apache.ibatis.jdbc.SqlBuilder.SET;
import static org.apache.ibatis.jdbc.SqlBuilder.SQL;
import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;
import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;
import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;

import com.javen.modules.Test.dao.model.Table;
import com.javen.modules.Test.dao.model.TableExample.Criteria;
import com.javen.modules.Test.dao.model.TableExample.Criterion;
import com.javen.modules.Test.dao.model.TableExample;

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

import org.springframework.util.StringUtils;

public class TableSqlProvider {

    public String countByExample(TableExample example) {
        BEGIN();
        SELECT("count(*)");
        FROM("table");
        applyWhere(example, false);
        return SQL();
    }

    public String deleteByExample(TableExample example) {
        BEGIN();
        DELETE_FROM("table");
        applyWhere(example, false);
        return SQL();
    }

    public String insertSelective(Table record) {
        BEGIN();
        INSERT_INTO("table");

        if (record.getId() != null) {
            VALUES("id", "#{id,jdbcType=INTEGER}");
        }

        if (record.getName() != null) {
            VALUES("name", "#{name,jdbcType=VARCHAR}");
        }

        if (record.getTelNumber() != null) {
            VALUES("tel_number", "#{telNumber,jdbcType=VARCHAR}");
        }

        if (record.getDegree() != null) {
            VALUES("degree", "#{degree,jdbcType=VARCHAR}");
        }

        if (record.getSex() != null) {
            VALUES("sex", "#{sex,jdbcType=CHAR}");
        }

        if (record.getGradUni() != null) {
            VALUES("grad_uni", "#{gradUni,jdbcType=VARCHAR}");
        }

        if (record.getMail() != null) {
            VALUES("mail", "#{mail,jdbcType=VARCHAR}");
        }

        if (record.getPassword() != null) {
            VALUES("password", "#{password,jdbcType=VARCHAR}");
        }

        return SQL();
    }

    public String selectByExample(TableExample example) {
        BEGIN();
        if (example != null && example.isDistinct()) {
            SELECT_DISTINCT("id");
        } else {
            SELECT("id");
        }
        SELECT("name");
        SELECT("tel_number");
        SELECT("degree");
        SELECT("sex");
        SELECT("grad_uni");
        SELECT("mail");
        SELECT("password");
        FROM("table");
        applyWhere(example, false);

        if (example != null && example.getOrderByClause() != null) {
            ORDER_BY(example.getOrderByClause());
        }

        return SQL();
    }

    public String updateByExampleSelective(Map<String, Object> parameter) {
        Table record = (Table) parameter.get("record");
        TableExample example = (TableExample) parameter.get("example");

        BEGIN();
        UPDATE("table");

        if (record.getId() != null) {
            SET("id = #{record.id,jdbcType=INTEGER}");
        }

        if (record.getName() != null) {
            SET("name = #{record.name,jdbcType=VARCHAR}");
        }

        if (record.getTelNumber() != null) {
            SET("tel_number = #{record.telNumber,jdbcType=VARCHAR}");
        }

        if (record.getDegree() != null) {
            SET("degree = #{record.degree,jdbcType=VARCHAR}");
        }

        if (record.getSex() != null) {
            SET("sex = #{record.sex,jdbcType=CHAR}");
        }

        if (record.getGradUni() != null) {
            SET("grad_uni = #{record.gradUni,jdbcType=VARCHAR}");
        }

        if (record.getMail() != null) {
            SET("mail = #{record.mail,jdbcType=VARCHAR}");
        }

        if (record.getPassword() != null) {
            SET("password = #{record.password,jdbcType=VARCHAR}");
        }

        applyWhere(example, true);
        return SQL();
    }

    public String updateByExample(Map<String, Object> parameter) {
        BEGIN();
        UPDATE("table");

        SET("id = #{record.id,jdbcType=INTEGER}");
        SET("name = #{record.name,jdbcType=VARCHAR}");
        SET("tel_number = #{record.telNumber,jdbcType=VARCHAR}");
        SET("degree = #{record.degree,jdbcType=VARCHAR}");
        SET("sex = #{record.sex,jdbcType=CHAR}");
        SET("grad_uni = #{record.gradUni,jdbcType=VARCHAR}");
        SET("mail = #{record.mail,jdbcType=VARCHAR}");
        SET("password = #{record.password,jdbcType=VARCHAR}");

        TableExample example = (TableExample) parameter.get("example");
        applyWhere(example, true);
        return SQL();
    }

    public String updateByPrimaryKeySelective(Table record) {
        BEGIN();
        UPDATE("table");

        if (record.getName() != null) {
            SET("name = #{name,jdbcType=VARCHAR}");
        }

        if (record.getTelNumber() != null) {
            SET("tel_number = #{telNumber,jdbcType=VARCHAR}");
        }

        if (record.getDegree() != null) {
            SET("degree = #{degree,jdbcType=VARCHAR}");
        }

        if (record.getSex() != null) {
            SET("sex = #{sex,jdbcType=CHAR}");
        }

        if (record.getGradUni() != null) {
            SET("grad_uni = #{gradUni,jdbcType=VARCHAR}");
        }

        if (record.getMail() != null) {
            SET("mail = #{mail,jdbcType=VARCHAR}");
        }

        if (record.getPassword() != null) {
            SET("password = #{password,jdbcType=VARCHAR}");
        }

        WHERE("id = #{id,jdbcType=INTEGER}");

        return SQL();
    }

    protected void applyWhere(TableExample example, boolean includeExamplePhrase) {
        if (example == null) {
            return;
        }

        String parmPhrase1;
        String parmPhrase1_th;
        String parmPhrase2;
        String parmPhrase2_th;
        String parmPhrase3;
        String parmPhrase3_th;
        if (includeExamplePhrase) {
            parmPhrase1 = "%s #{example.oredCriteria[%d].allCriteria[%d].value}";
            parmPhrase1_th = "%s #{example.oredCriteria[%d].allCriteria[%d].value,typeHandler=%s}";
            parmPhrase2 = "%s #{example.oredCriteria[%d].allCriteria[%d].value} and #{example.oredCriteria[%d].criteria[%d].secondValue}";
            parmPhrase2_th = "%s #{example.oredCriteria[%d].allCriteria[%d].value,typeHandler=%s} and #{example.oredCriteria[%d].criteria[%d].secondValue,typeHandler=%s}";
            parmPhrase3 = "#{example.oredCriteria[%d].allCriteria[%d].value[%d]}";
            parmPhrase3_th = "#{example.oredCriteria[%d].allCriteria[%d].value[%d],typeHandler=%s}";
        } else {
            parmPhrase1 = "%s #{oredCriteria[%d].allCriteria[%d].value}";
            parmPhrase1_th = "%s #{oredCriteria[%d].allCriteria[%d].value,typeHandler=%s}";
            parmPhrase2 = "%s #{oredCriteria[%d].allCriteria[%d].value} and #{oredCriteria[%d].criteria[%d].secondValue}";
            parmPhrase2_th = "%s #{oredCriteria[%d].allCriteria[%d].value,typeHandler=%s} and #{oredCriteria[%d].criteria[%d].secondValue,typeHandler=%s}";
            parmPhrase3 = "#{oredCriteria[%d].allCriteria[%d].value[%d]}";
            parmPhrase3_th = "#{oredCriteria[%d].allCriteria[%d].value[%d],typeHandler=%s}";
        }

        StringBuilder sb = new StringBuilder();
        List<Criteria> oredCriteria = example.getOredCriteria();
        boolean firstCriteria = true;
        for (int i = 0; i < oredCriteria.size(); i++) {
            Criteria criteria = oredCriteria.get(i);
            if (criteria.isValid()) {
                if (firstCriteria) {
                    firstCriteria = false;
                } else {
                    sb.append(" or ");
                }

                sb.append('(');
                List<Criterion> criterions = criteria.getAllCriteria();
                boolean firstCriterion = true;
                for (int j = 0; j < criterions.size(); j++) {
                    Criterion criterion = criterions.get(j);
                    if (firstCriterion) {
                        firstCriterion = false;
                    } else {
                        sb.append(" and ");
                    }

                    if (criterion.isNoValue()) {
                        sb.append(criterion.getCondition());
                    } else if (criterion.isSingleValue()) {
                        if (criterion.getTypeHandler() == null) {
                            sb.append(String.format(parmPhrase1, criterion.getCondition(), i, j));
                        } else {
                            sb.append(String.format(parmPhrase1_th, criterion.getCondition(), i, j,criterion.getTypeHandler()));
                        }
                    } else if (criterion.isBetweenValue()) {
                        if (criterion.getTypeHandler() == null) {
                            sb.append(String.format(parmPhrase2, criterion.getCondition(), i, j, i, j));
                        } else {
                            sb.append(String.format(parmPhrase2_th, criterion.getCondition(), i, j, criterion.getTypeHandler(), i, j, criterion.getTypeHandler()));
                        }
                    } else if (criterion.isListValue()) {
                        sb.append(criterion.getCondition());
                        sb.append(" (");
                        List<?> listItems = (List<?>) criterion.getValue();
                        boolean comma = false;
                        for (int k = 0; k < listItems.size(); k++) {
                            if (comma) {
                                sb.append(", ");
                            } else {
                                comma = true;
                            }
                            if (criterion.getTypeHandler() == null) {
                                sb.append(String.format(parmPhrase3, i, j, k));
                            } else {
                                sb.append(String.format(parmPhrase3_th, i, j, k, criterion.getTypeHandler()));
                            }
                        }
                        sb.append(')');
                    }
                }
                sb.append(')');
            }
        }

        if (sb.length() > 0) {
            WHERE(sb.toString());
        }
    }

    public String getCntsql(String name,String sex){
        StringBuilder str = new StringBuilder();
        str.append("select count(*) from table where name = #{name}");
        return str.toString();
    }

    public String getListsql(Map<String, String> map){
        StringBuilder str = new StringBuilder();
        str.append("select name,");
        str.append("sex,");
        str.append("tel_number,");
        str.append("degree,");
        str.append("grad_uni,");
        str.append("mail from table where 1 = 1");

        String name = map.get("name");
        if(!StringUtils.isEmpty(name)){
            str.append(" and name like '%");
            str.append(name);
            str.append("%'");
        }

        String sex = map.get("sex");
        if(!StringUtils.isEmpty(sex)){
            str.append(" and sex = ");
            str.append(sex);
        }

        str.append(" limit #{offset},#{size}");
        return str.toString();
    }

    public String getmappersql(Table table){
        StringBuilder str = new StringBuilder();
        str.append("select count(*) from table where name = #{name}");
        return str.toString();
    }
}

页面有两个，登录注册/页面和显示页面，由于是demo，所以没加任何样式，大家凑合看吧。

登录/注册：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ include file="/WEB-INF/views/include/global.jsp"%>
<%@ page import="com.javen.common.constant.UrlConst" %>
<c:set target="${self.content}" property="main">
<form action="${base}/wf/test" method="post">
<table style="250px;height:100px" border="1" align="center">
<tbody>
    <tr>
        <th width="80px" height="80px" >请输入用户名</th>
        <td width="80px" height="80px" >
            <input type="text" width="200px" placeholder="用户名" pattern="^[A-Za-z0-9_u4e00-u9fa5/]+$" title="请输入字母,数字或中文！">
        </td>
    </tr>
    <tr>
        <th width="80px" height="80px" align="center">请输入密码</th>
        <td width="80px" height="80px">
            <input type="password" width="200px" placeholder="密码" pattern="^[A-Za-z0-9]+$" title="请输入字母,数字！">
        </td>
    </tr>
    <tr>
        <th width="80px" height="80px"></th>
        <td width="80px" height="80px">
         <a href="javascript:void(0);" onclick="layer_show('登录','${base}/wf/test/list','750','600')" class="btn radius btn-secondary size-MINI ml-5">登录</a>
        </td>
    </tr>
</tbody>
</table>


</form>
</c:set>
<%@ include file="/WEB-INF/views/include/main.jsp"%>

显示：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ include file="/WEB-INF/views/include/global.jsp"%>
<%@ page import="com.javen.common.constant.UrlConst" %>
<c:set target="${self.content}" property="main">
    <form action="${base}/wf/test/list" method="post" >
        <div class="text-l">
            <label>用户名：</label>
            <input id="name" name="name" value="${name}" type="tel" class="input-text" style="250px; " placeholder="用户名">
            <label>性别：</label>
          <c:choose>
           <c:when test="${sex == 0}">
                <input id="sex1" name="sex" value="0" type="radio" checked/>男
                <input id="sex2" name="sex" value="1" type="radio"/>女
           </c:when>
           <c:when test="${sex == 1}">
                <input id="sex3" name="sex" value="0" type="radio"/>男
                <input id="sex4" name="sex" value="1" type="radio"checked/>女
           </c:when>
           <c:otherwise >
               <input id="sex5" name="sex" value="0" type="radio"/>男
                <input id="sex6" name="sex" value="1" type="radio"/>女
           </c:otherwise>
         </c:choose>

            <button type="submit" > 查找</button>
        </div>
<div>
    <span>
    <a class="btn btn-primary radius" href="javascript:void(0);" onclick="layer_show('添加数据','${base}/','750','600')"><i class="Hui-iconfont">&#xe600;</i> 添加数据</a>
    </span>
    <span class="r">共有数据：<strong>${cnt}</strong> 条</span>
</div>
<table class="table table-border table-bordered table-hover table-bg">
    <thead>
    <tr class="text-c">
        <th width="20">序号</th>
        <th width="200">用户名</th>
        <th width="200">密码</th>
        <th width="200">电话</th>
        <th width="200">学位</th>
        <th width="200">性别</th>
        <th width="200">毕业院校</th>
        <th width="200">邮箱</th>
    </tr>
    </thead>
    <tbody>
    <c:forEach var="data" items="${list}" varStatus="status">
    <tr>
        <td class="text-c">${offset + status.index + 1}</td>
        <td class="text-c">${data.name}</td>
        <td class="text-c">${data.password}</td>
        <td class="text-c">${data.tel_number}</td>
        <td class="text-c">${data.degree}</td>
        <td class="text-c">${data.grad_uni}</td>
        <td class="text-c">${data.mail}</td>
                <td class="text-c">${data.sex}</td>
<%--         <input id="type_id" type="hidden" name="type_id" value="${data.type_id}"> --%>
        <td class="text-c f-14">
         <a href="javascript:void(0);" onclick="layer_show('修改数据','${base}/','750','600')" class="btn radius btn-secondary size-MINI ml-5">修改</a>
         <a href="javascript:void(0);" onclick="layer_show('删除数据','${base}/','750','600')" class="btn radius btn-danger size-MINI ml-5">删除</a>

        </td>
    </tr>
    </c:forEach>
    </tbody>
</table>

<!-- <script type="text/javascript" src="jquery/1.9.1/jquery.min.js"></script> -->


<script>

   $(document).ready(function () {
       $("#btnClear").click(function () {
           $("input").val("");
//            $("select") .val("");
       });

   });



// $(document).ready(function(){
//      alert("第一种方法。");
// });
</script>
<%-- <%@ include file="/WEB-INF/views/bussiness/wfActivity/activityPage.jsp"%> --%>
<%@ include file="/WEB-INF/views/include/pagination.jsp"%>
</form>
</c:set>
<%@ include file="/WEB-INF/views/include/main.jsp"%>

 下面是我总结的增删改查思想，工作中或是其他场景做各种框架服务基本都是这么个流程（话说问我什么时候能入门架构。。。）

查询：
获取结果集合，
判断是否有数据（模糊查询）
如果有，
model.addAttribute()传值
返页面，
如果没有，报错

添加：
先判断是否有输入
在判断输入的值是否与与已有数据重复
创建日期 修改日期balabala
如果插入了 返回成功
如果没有，报错

修改:(删除中的逻辑删除也算是一种修改，写法类似)
判断是否输入
在判断修改的对象是否正确
如果修改返回成功
如果没有，报错

以上就是SpringMVC简单的增删改查功能的实现，希望对大家有帮助~