簡單說說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("[e-mail]");
         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="width: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="width: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簡單的增刪改查功能的實現，希望對大家有幫助~