MyBatis SQL 生成方法 增删改查

最新推荐文章于 2024-09-08 10:40:56 发布
最新推荐文章于 2024-09-08 10:40:56 发布
阅读量70 收藏
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/zwcry/p/8268377.html
版权

此类根据JAVA实体BEAN生成MYBATIS的接口SQL（mapper）

 

package com.sicdt.sicsign.bill.service.hessian;

import java.lang.reflect.Field;

import com.sicdt.sicsign.bill.service.entity.InvoiceEntity;

public class MyBatisSqlUtils {
    public static void main(String[] args) {
        String tableName = "T_INVOICE";
        Class<?> clazz = InvoiceEntity.class;
        
        System.out.println("主键查询SQL：======================================");
        String idSql = MyBatisSqlUtils.selectSQLById(clazz, tableName);
        System.out.println("主键查询SQL：    " + idSql);
        String idSqlHump = MyBatisSqlUtils.selectSQLByIdForHump(clazz, tableName);
        System.out.println("主键查询SQL：    " + idSqlHump);
        
        System.out.println("主键集合查询SQL：======================================");
        String idsSql = MyBatisSqlUtils.selectSQLByIds(clazz, tableName);
        System.out.println("主键集合查询SQL：    " + idsSql);
        String idsSqlHump = MyBatisSqlUtils.selectSQLByIdsForHump(clazz, tableName);
        System.out.println("主键集合查询SQL：    " + idsSqlHump);
        
        System.out.println("查询SQL：======================================");
        String selectSql = MyBatisSqlUtils.selectSQL(clazz,tableName);
        System.out.println("查询SQL：    " + selectSql);
        String selectSqlHump = MyBatisSqlUtils.selectSQLForHump(clazz,tableName);
        System.out.println("查询SQL：    " + selectSqlHump);
        
        System.out.println("插入SQL：======================================");
        String insertSql = MyBatisSqlUtils.insertSql(clazz, tableName);
        System.out.println("插入SQL：    "+insertSql);
        String insertSqlHump = MyBatisSqlUtils.insertSqlForHump(clazz, tableName);
        System.out.println("插入SQL：    "+insertSqlHump);
        
        System.out.println("删除SQL：======================================");
        String deleteSql = MyBatisSqlUtils.deleteSqlById(clazz, tableName);
        System.out.println("删除SQL：    "+deleteSql);
        String deleteSqlHump = MyBatisSqlUtils.deleteSqlByIdForHump(clazz, tableName);
        System.out.println("删除SQL：    "+deleteSqlHump);
        
        System.out.println("修改SQL：======================================");
        String updateSql = MyBatisSqlUtils.updateSql(clazz, tableName);
        System.out.println("修改SQL：    "+updateSql);
        String updateSqlHump = MyBatisSqlUtils.updateSqlForHump(clazz, tableName);
        System.out.println("修改SQL：    "+updateSqlHump);
        
        System.out.println("批量插入SQL：======================================");
        String batchInsertSql = MyBatisSqlUtils.batchInsertSql(clazz, tableName);
        System.out.println("批量插入SQL："+batchInsertSql);
        String batchInsertSqlHump = MyBatisSqlUtils.batchInsertSqlForHump(clazz, tableName);
        System.out.println("批量插入SQL："+batchInsertSqlHump);
        
        System.out.println("批量更新SQL：======================================");
        String batchUpdateSql = MyBatisSqlUtils.batchUpdateSql(clazz, tableName);
        System.out.println("批量更新SQL："+batchUpdateSql);
        String batchUpdateSqlHump = MyBatisSqlUtils.batchUpdateSqlForHump(clazz, tableName);
        System.out.println("批量更新SQL："+batchUpdateSqlHump);
        
        System.out.println("批量删除SQL（主键）：======================================");
        String batchDeleteSqlByIds = MyBatisSqlUtils.batchDeleteSqlByIds(clazz, tableName);
        System.out.println("批量删除SQL（主键）："+batchDeleteSqlByIds);
        String batchDeleteSqlHumpByIds = MyBatisSqlUtils.batchDeleteSqlByIdsForHump(clazz, tableName);
        System.out.println("批量删除SQL（主键）："+batchDeleteSqlHumpByIds);
        
        System.out.println("批量删除SQL（实体）：======================================");
        String batchDeleteSql = MyBatisSqlUtils.batchDeleteSql(clazz, tableName);
        System.out.println("批量删除SQL（实体）："+batchDeleteSql);
        String batchDeleteSqlHump = MyBatisSqlUtils.batchDeleteSqlForHump(clazz, tableName);
        System.out.println("批量删除SQL（实体）："+batchDeleteSqlHump);
    }
    
    /**
     * <br>描 述: 生成查询SQL（实体属性与数据库一致）主键查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQLById(Class<?> clazz,String tableName){
        return selectSQLById(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成查询SQL（实体属性为驼峰）主键查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQLByIdForHump(Class<?> clazz,String tableName){
        return selectSQLById(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成查询SQL（实体属性与数据库一致）主键集合查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQLByIds(Class<?> clazz,String tableName){
        return selectSQLByIds(clazz, tableName, false);
    }
    
    
    /**
     * <br>描 述: 生成查询SQL（实体属性为驼峰）主键集合查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQLByIdsForHump(Class<?> clazz,String tableName){
        return selectSQLByIds(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成查询SQL（实体属性与数据库一致）条件查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQL(Class<?> clazz,String tableName){
        return selectSQL(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成查询SQL（实体属性为驼峰）条件查询
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String selectSQLForHump(Class<?> clazz,String tableName){
        return selectSQL(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成插入SQL（实体属性与数据库一致）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String  insertSql(Class<?> clazz,String tableName){
        return insertSql(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成插入SQL（实体属性为驼峰）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String  insertSqlForHump(Class<?> clazz,String tableName){
        return insertSql(clazz, tableName, true);
    }

    /**
     * <br>描 述: 生成更新Sql（实体属性与数据库一致）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String updateSql(Class<?> clazz,String tableName){
        return updateSql(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成更新SQL（实体属性为驼峰）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String updateSqlForHump(Class<?> clazz,String tableName){
        return updateSql(clazz, tableName, true);
    }
    
    
    /**
     * <br>描 述: 生成删除SQL（实体属性与数据库一致）主键删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String deleteSqlById(Class<?> clazz,String tableName){
        return deleteSqlById(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成删除SQL（实体属性为驼峰）主键删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String deleteSqlByIdForHump(Class<?> clazz,String tableName){
        return deleteSqlById(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成删除SQL（实体属性与数据库一致）实体删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String deleteSql(Class<?> clazz,String tableName){
        return deleteSqlById(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成删除SQL（实体属性为驼峰）实体删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String deleteSqlForHump(Class<?> clazz,String tableName){
        return deleteSqlById(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成批量插入SQL（实体属性与数据库一致）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchInsertSql(Class<?> clazz,String tableName){
        return batchInsertSql(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成批量插入SQL（实体属性为驼峰）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchInsertSqlForHump(Class<?> clazz,String tableName){
        return batchInsertSql(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成批量更新SQL（实体属性与数据库一致）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchUpdateSql(Class<?> clazz,String tableName){
        return batchUpdateSql(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成批量更新SQL（实体属性为驼峰）
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchUpdateSqlForHump(Class<?> clazz,String tableName){
        return batchUpdateSql(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成批量删除SQL（实体属性与数据库一致）主键删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchDeleteSqlByIds(Class<?> clazz,String tableName){
        return batchDeleteSqlByIds(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成批量删除SQL（实体属性为驼峰）实体删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchDeleteSqlByIdsForHump(Class<?> clazz,String tableName){
        return batchDeleteSqlByIds(clazz, tableName, true);
    }
    
    /**
     * <br>描 述: 生成批量删除SQL（实体属性与数据库一致）主键删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchDeleteSql(Class<?> clazz,String tableName){
        return batchDeleteSql(clazz, tableName, false);
    }
    
    /**
     * <br>描 述: 生成批量删除SQL（实体属性为驼峰）实体删除
     * <br>作 者: shizhenwei 
     * @param clazz Object.class
     * @param tableName 表名称
     * @return
     */
    public static String batchDeleteSqlForHump(Class<?> clazz,String tableName){
        return batchDeleteSql(clazz, tableName, true);
    }
    
    
    /*
     * 生成查询SQL 主键查询
     */
    private static String selectSQLById(Class<?> clazz,String tableName,boolean isHump){
        String select = "@Select(\"SELECT";
        Field[] fields = clazz.getDeclaredFields();
        select += getSelectColumns(fields,isHump)
                +" FROM "+tableName
                +" WHERE "+getSelectColumn(fields[0],isHump)+" = "+getValueColumn(fields[0])+"\")";
        return select;
    }
    
    /*
     * 生成查询SQL主键集合查询
     */
    private static String selectSQLByIds(Class<?> clazz,String tableName,boolean isHump){
        String select = "@Select(\"<script>\""
                    +"\r+\"SELECT";
        Field[] fields = clazz.getDeclaredFields();
        select += getSelectColumns(fields,isHump)
                +" FROM "+tableName
                +" WHERE "+getSelectColumn(fields[0],isHump)+" IN \""
                +"\r+\"<foreach collection='primaryKeys' item='"+fields[0].getName()+"' index='index' open='(' close=')' separator=','>\""
                +"\r+\""+getValueColumn(fields[0])+"\""
                +"\r+\"</foreach>\""
                +"\r+\"</script>\")";
        return select;
    }
    
    /*
     * 生成查询SQL 条件查询
     */
    private static String selectSQL(Class<?> clazz,String tableName,boolean isHump){
        //接口引用加\" 生成双引号
        String select = "@Select(\"<script>\""
                +"\r+\"SELECT";
        Field[] fields = clazz.getDeclaredFields();
        select += getSelectColumns(fields,isHump)
                +" FROM "+tableName+"\""
                +"\r+\"<trim prefix='WHERE' prefixOverrides='and|or'>\"";
        for(Field field : fields){
            if(isHump){
                select += "\r+\"<if test='"+field.getName()+" != null'> AND "+getSelectColumn(field,isHump)+" = "+getValueColumn(field)+"</if>\"";
            }else{
                select += "\r+\"<if test='"+field.getName()+" != null'> AND "+field.getName()+" = "+getValueColumn(field)+"</if>\"";
            }
        }
        select += "\r+\"</trim>\""
                +"\r+\"</script>\")";
        return select;
    }
    
    
    /*
     * 生成插入SQL
     */
    private static String  insertSql(Class<?> clazz,String tableName,boolean isHump){
        String insert = "@Insert(\"INSERT INTO "+tableName;
        Field[] fields = clazz.getDeclaredFields();
        insert += " ("+getInsertColumns(fields,isHump)+")"
                +" VALUES ("+getValueColumns(fields,false)+")"
                +"\")";
        return insert;
    }
    
    /*
     * 生成更新SQL
     */
    private static String updateSql(Class<?> clazz,String tableName,boolean isHump){
        Field[] fields = clazz.getDeclaredFields();
        String idColumn;
        if(isHump){
            idColumn = getSelectColumn(fields[0],isHump);
        }else{
            idColumn = fields[0].getName();
        }
        String idVal = getValueColumn(fields[0]);
        String update = "@Update(\"<script>\""
                        +"\r+\"UPDATE "+tableName+"\""
                        +"\r+\"<trim prefix='set' suffixOverrides=',' suffix='WHERE "+idColumn+"="+idVal+"'>\"";
        for(int i=1; i<fields.length; i++){
            Field field = fields[i];
            if(isHump){
                update += "\r+\"<if test='"+field.getName()+"!=null'>"+getSelectColumn(field,isHump)+"="+getValueColumn(field)+",</if>\"";
            }else{
                update += "\r+\"<if test='"+field.getName()+"!=null'>"+field.getName()+"="+getValueColumn(field)+",</if>\"";
            }
        }
        update += "\r+\"</trim>\""
                +"\r+\"</script>\")";
        return update;
    }
    
    /*
     * 生成删除SQL
     */
    private static String deleteSqlById(Class<?> clazz,String tableName,boolean isHump){
        String delete = "@Delete(\"DELETE FROM "+tableName+" WHERE ";
        Field field = clazz.getDeclaredFields()[0];
        String column = getSelectColumn(field,isHump);
        delete += column+" = "+getValueColumn(field)+"\")";
        return delete;
    }
    
    
    /*
     * 生成批量插入SQL
     */
    private static String  batchInsertSql(Class<?> clazz,String tableName,boolean isHump){
        String insert = "@Insert(\"<script>\""
                +"\r+\"INSERT INTO "+tableName+"\"";
        Field[] fields = clazz.getDeclaredFields();
        insert += "\r+\"("+getInsertColumns(fields,isHump)+")\""
                +"\r+\"VALUES \""
                +"\r+\"<foreach collection='list' item='item' index='index' separator=','>\""
                +"\r+\"("+getValueColumns(fields,true)+")\""
                +"\r+\"</foreach>\""
                +"\r+\"</script>\")";
        return insert;
    }
    
    /*
     * 生成批量更新SQL
     */
    private static String batchUpdateSql(Class<?> clazz,String tableName,boolean isHump){
        Field[] fields = clazz.getDeclaredFields();
        String idColumn;
        if(isHump){
            idColumn = getSelectColumn(fields[0],isHump);
        }else{
            idColumn = fields[0].getName();
        }
        String idVal = getValueColumn(fields[0],true);
        String update = "@Update(\"<script>\""
                        +"\r+\"<foreach collection='list' item='item' index='index' open='' close='' separator=';'>\""
                        +"\r+\"UPDATE "+tableName+"\""
                        +"\r+\"<trim prefix='set' suffixOverrides=',' suffix='WHERE "+idColumn+"="+idVal+"'>\"";
        for(int i=1; i<fields.length; i++){
            Field field = fields[i];
            if(isHump){
                update += "\r+\"<if test='item."+field.getName()+"!=null'>"+getSelectColumn(field,isHump)+"="+getValueColumn(field,true)+",</if>\"";
            }else{
                update += "\r+\"<if test='item."+field.getName()+"!=null'>"+field.getName()+"="+getValueColumn(field,true)+",</if>\"";
            }
        }
        update += "\r+\"</trim>\""
                +"\r+\"</foreach>\""
                +"\r+\"</script>\")";

        return update;
    }
    
    /*
     * 生成批量删除SQL 主键删除
     */
    private static String batchDeleteSqlByIds(Class<?> clazz,String tableName,boolean isHump){
        String delete = "@Delete(\"<script>\""
                +"\r+\"DELETE FROM "+tableName+" WHERE ";
        Field field = clazz.getDeclaredFields()[0];
        String column = getSelectColumn(field,isHump);
        delete += column+" IN \""
                +"\r+\"<foreach collection='primaryKeys' item='"+field.getName()+"' index='index' open='(' close=')' separator=','>\""
                +"\r+\""+getValueColumn(field)+"\""
                +"\r+\"</foreach>\""
                +"\r+\"</script>\")";
        return delete;
    }
    
    /*
     * 生成批量删除SQL 实体删除
     */
    private static String batchDeleteSql(Class<?> clazz,String tableName,boolean isHump){
        String delete = "@Delete(\"<script>\""
                +"\r+\"DELETE FROM "+tableName+" WHERE ";
        Field field = clazz.getDeclaredFields()[0];
        String column = getSelectColumn(field,isHump);
        delete += column+" in \""
                +"\r+\"<foreach collection='list' item='item' index='index' open='(' close=')' separator=','>\""
                +"\r+\""+getValueColumn(field,true)+"\""
                +"\r+\"</foreach>\""
                +"\r+\"</script>\")";
        return delete;
    }
    
    /*
     * 获SELECT取列
     */
    private static String getSelectColumns(Field[] fields,boolean isHump){
        String  columns = "";
        if(isHump){
            for(Field field : fields){
                columns += " "+getSelectColumn(field, isHump) +" AS "+field.getName()+",";
            }
        }else{
            for(Field field : fields){
                columns+=" "+getSelectColumn(field, isHump)+" AS "+field.getName()+",";
            }
        }
        return columns.substring(0,columns.length()-1);
    }
    
    /*
     * 获INSERT列
     */
    private static String getInsertColumns(Field[] fields,boolean isHump){
        String  columns = "";
        if(isHump){
            for(Field field : fields){
                columns += " "+getSelectColumn(field, isHump)+",";
            }
        }else{
            for(Field field : fields){
                columns+=" "+getSelectColumn(field, isHump)+",";
            }
        }
        return columns.substring(0,columns.length()-1).toUpperCase();
    }
    
    /*
     * 获insert取列
     */
    private static String getValueColumns(Field[] fields,boolean isBatch){
        String columns = "";
        for(Field field : fields){
            columns+=" "+getValueColumn(field,isBatch)+",";
        }
        return columns.substring(0, columns.length()-1);
    }
    
    
    /*
     * 获取单列
     */
    private static String getSelectColumn(Field field,boolean isHump){
        String fieldName = field.getName();
        String column = "";
        if(isHump){
            for(int i=0; i<fieldName.length(); i++){
                char ch = fieldName.charAt(i);
                if(Character.isUpperCase(ch)){
                    column += "_"+ch;
                }else{
                    column += ch;
                }
            }
        }else{
            column = fieldName;
        }
        return column.toUpperCase();
    }
    
    /*
     * 获取单值列
     */
    private static String getValueColumn(Field field,boolean isBatch){
        if(isBatch){
            return "#{item."+field.getName()+"}";
        }else{
            return "#{"+field.getName()+"}";
        }
    }
    
    /*
     * 获取单值列
     */
    private static String getValueColumn(Field field){
        return getValueColumn(field,false);
    }
}

 

转载于:https://www.cnblogs.com/zwcry/p/8268377.html

weixin_30664539
关注
MyBatis实现SQL增删改查
weixin_67286174的博客
04-17 133
2.2在resources下创建db.properties。2.4添加log4j文件（log4j.xml）添加 Employee类。4.2创建Util实体。
mybatis实现SQL增删改查
m0_69530989的博客
04-16 100
2.2在resources下创建jdbc.properties。2.3创建mybatis核心配置文件。5.2创建Empoloyee接口文件。2.1引入依赖（pom.xml）四、创建Employee实体类。用户名及密码根据实际情况填写。5.1创建mapper实体。4.2创建Util实体。添加Employee类。
mybatis-sql生成器
12-25
mybatis-sql生成器，文件编码格式，请勿改变，否则将导致无法使用。
深入浅出Mybatis-sql自动生成
热门推荐
追求极致的人
07-13 4万+
本文提供了一种自动生成sql语句的方法，它针对的对象是有主键或唯一索引的单表，提供的操作有增、删、改、查4种。理解本文和本文的提供的代码需要有java注解的知识，因为本文是基于注解生成sql的。本文适配的mybatis版本是3.2.2。
mybatis自动sql生成插件源码
07-13
提供了一种自动生成sql语句的方法，它针对的对象是有主键或唯一索引的单表，提供的操作有增、删、改、查4种。适配的mybatis版本是3.2.2。
MyBatis基础（增、删、改、查以及动态SQL）
weixin_45689945的博客
09-27 534
MyBatis基础
Springboot 整合Mybatis +thymeleaf 实现增删改查，包含前端HTML页面
09-21
Mybatis则是一个轻量级的持久层框架，允许开发者通过SQL语句直接操作数据库。而Thymeleaf是一个服务器端的HTML模板引擎，能够与Spring Boot无缝集成，用于生成动态网页内容。 **整合步骤：** 1. **创建Spring Boot...
GeneratorJavaTools反向工程工具生成mybatis增删改查方法
04-20
GeneratorJavaTools是一款基于Java的反向工程工具，它能够帮助开发者自动生成MyBatis的增删改查（CRUD）方法，极大地提高了开发效率，减少了手动编写SQL和DAO层代码的工作量。 反向工程，又称为逆向工程，是一种将...
SpringBoot整合MyBatis Plus实现增删改查教程
02-05
SpringBoot整合MyBatis Plus实现增删改查教程 本文将详细介绍如何使用 Spring Boot 框架和 MyBatis Plus 实现增删改查（CRUD）操作的教程。MyBatis Plus 是一个基于 MyBatis 的 ORM 框架，它提供了许多实用的功能来...
MyBaties根据JavaBean自动生成表结构
04-09
MyBaties根据JavaBean自动生成表结构
Mybatis通用增删改查
05-26
在实际开发中，为了提高代码的复用性和减少重复工作，开发者通常会实现一套通用的增删改查模板，这就是“Mybatis通用增删改查”的概念。 1. **基础 DaoImpl 概念** Dao（Data Access Object）接口是Java中用于...
mybatis使用xml进行增删改查代码解析
08-28
MyBatis使用XML进行增删改查代码解析 MyBatis是一种 популяр的持久层框架，它支持普通SQL查询、存储过程和高级映射。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以...
使用Mybatis相关类生成sql语句
web18536560468的博客
08-28 1186
sql语句中可以使用mybatis的各种标签，注意等符号的转义，最后会根据输入的参数生成最终的sql，需要引入mybatis.jar。
mybatis自动生成SQL，外部终端生成
盗墓者
10-03 484
jar准备，连接驱动与生成jar   只需要这两个jar的原因很简单，MySQL驱动直接去探测库，生成jar直接拼接生成对应的SQL即可。一个是探测一个去生成。就2个jar就够了   外部生成不同于maven配置，需要手动指定MySQL驱动jar在哪里   generatorConfig.xml   &lt;?xml version="1.0" encoding="UTF-8"...
Mybatis原理--动态生成SQL
bingguang1993的博客
12-31 1561
本文将带你分析Mybatis是如何动态生成SQL。 首先，会根据源码分析框架初始化时xml文件的加载、解析、缓存过程。着重介绍 xml的解析过程 和 使用解析的结果，最后列举实例和对照源码DeBug分析：当DAO接口调用时标签的解析、参数的创建、SQL的生成过程，并总结整个流程。 数据的处理 Mybatis对数据的处理可以分为 用入参动态的拼装sql 和 对sql执行的结果封装成 Ja...
自动生成Sql--基于Mybatis的单表Sql
lp506954774的专栏
12-08 926
前言： 有时候，项目里没有引入mybatis-plus，仅使用了mybatis，假如碰到一些大的实体类，可能有四十多个字段，单表CRUD的时候，写sql很麻烦。为了解决这个，我特意使用mybatis-plus，配合Beetl模板语言，写了一套工具类。有了它，妈妈再也不用担心我写那些没有营养的代码了！ 实现思想： 使用mybatis-plus的generator的逆向功能，再配合Beetl模板，把insert，批量insert，update，select的sql通过模板制作出来。这样生成的sql就可直接
Mybatis动态sql语句的生成
不说话装高手
02-04 2509
在XMLLanguageDriver的createSQLSource()方法中，可以将已经经过解析的xml节点传入，并且传入相应的参数类型，开始动态sql语句的生成。 @Override public SqlSource createSqlSource(Configuration configuration, XNode script, Class&lt;?&gt; parameterType...
spring事务详细讲解-深入浅出
最新发布
小电玩
09-08 540
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Mybatis：轻松实现增删改查与分页教程
本文将详细介绍如何使用MyBatis实现增删改查（CRUD）操作以及分页查询。 首先，了解MyBatis的基本概念。它是iBatis的继承者，主要关注简化JDBC编程，减少手动设置参数和结果集的繁琐工作。MyBatis的核心思想是利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值