Mybatis实现数据的增删改查(CRUD)(精)

合集下载

如何在IDEA中使用mybatis创建项目并进行增删改查操作

如何在IDEA中使⽤mybatis创建项⽬并进⾏增删改查操作1、新建⼀个项⽬；2、导⼊相关的依赖包；3、配置mybatis主配置⽂件，连接信息和mapper位置等；①mybatis主配置⽂件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><properties resource="jdbc.properties"></properties><settings><setting name="logImpl" value="STDOUT_LOGGING" /><setting name="cacheEnabled" value="true"/><setting name="lazyLoadingEnabled" value="true"/><setting name="aggressiveLazyLoading" value="false"/></settings><typeAliases><package name="com.seecen.mybatis3.pojo"/></typeAliases><environments default="oracledb"><environment id="oracledb"><transactionManager type="jdbc"></transactionManager><dataSource type="pooled"><property name="driver" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></dataSource></environment></environments><mappers><package name="com.seecen.mybatis3.mapper"/></mappers></configuration>②连接信息jdbc:properties;jdbc.driver=oracle.jdbc.driver.OracleDriverjdbc.url=jdbc:oracle:thin:@localhost:1521:xeername=sc2001jdbc.password=sun#\u9A71\u52A8jar\u5305\u7684\u4F4D\u7F6E,\u5177\u4F53\u7684\u8DEF\u5F84\u3002\u9006\u5411\u751F\u6210\u4EE3\u7801\u65F6\u4F7F\u7528 driverClassPath=C:\\Users\\Administrator\\.m2\\repository\\com\\oracle\\ojdbc6\\11.2.0.3.0\\ojdbc6-11.2.0.3.0.jar③配置配置⽂件generatorConfig.xml；<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE generatorConfiguration PUBLIC "-////DTD MyBatis Generator Configuration 1.0//EN""/dtd/mybatis-generator-config_1_0.dtd" > <generatorConfiguration><properties resource="jdbc.properties" /><classPathEntry location="${driverClassPath}" /><context id="context1" targetRuntime="MyBatis3"><plugin type="org.mybatis.generator.plugins.ToStringPlugin"/><plugin type="org.mybatis.generator.plugins.SerializablePlugin"/><commentGenerator><property name="suppressAllComments" value="true" /></commentGenerator><jdbcConnection driverClass="${jdbc.driver}"connectionURL="${jdbc.url}" userId="${ername}" password="${jdbc.password}" /><javaModelGenerator targetPackage="com.seecen.mybatis.pojo"targetProject="src/main/java"><property name="trimStrings" value="true" /></javaModelGenerator><sqlMapGenerator targetPackage="com.seecen.mybatis.mapper"targetProject="src/main/java"></sqlMapGenerator><javaClientGenerator targetPackage="com.seecen.mybatis.mapper"targetProject="src/main/java" type="XMLMAPPER" /><table tableName="t_course" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false"enableSelectByExample="false" selectByExampleQueryId="false"></table></context></generatorConfiguration>这三个⽂件放⼊资源⽬录下⾯；我的⽬录是这样的，仅供参考：4、在pojo中创建⼀个Product.java的实体类⽂件；package com.seecen.mybatis3.pojo;import java.io.Serializable;public class Product implements Serializable {private Integer id;private String name;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic String toString() {return"Product{" +"id=" + id +", name='" + name + '\'' +'}';}}4、编写Mapper对应的mapper.xml⽂件和接⼝，定义接⼝⽅法对应的sql语句；ProductMapper⽂件和ProductMapper.xml⽂件：package com.seecen.mybatis3.mapper;import com.seecen.mybatis3.pojo.Product;import java.util.List;public interface ProductMapper {int insert(Product product);int deleteById(Integer id);int update(Product product);Product selectById(Integer id);List<Product> selectAll();}<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.seecen.mybatis3.mapper.ProductMapper"><insert id="insert" parameterType="Product"><selectKey keyProperty="id" order="BEFORE" resultType="integer">select p_pro.nextval from dual</selectKey>insert into Product(id,name) values(#{id},#{name})</insert><update id="update" parameterType="Product">update Product set name = #{name} where id=#{id}</update><delete id="deleteById">delete from Product where id=#{id}</delete><select id="selectById" parameterType="integer" resultType="Product">select * from Product where id=#{id}</select><select id="selectAll" resultType="Product">select * from Product</select></mapper>5、编写dao层访问接⼝Mapper，⽤来定义数据库操作⽅法；import com.seecen.mybatis3.mapper.ProductMapper;import com.seecen.mybatis3.pojo.Product;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;import org.junit.Test;import java.io.IOException;import java.io.InputStream;import java.util.List;public class ProductTest {@Testpublic void Test() throws IOException {InputStream is= Resources.getResourceAsStream("mybatis.xml");SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(is);SqlSession sqlSession=sqlSessionFactory.openSession();ProductMapper mapper=sqlSession.getMapper(ProductMapper.class);//插⼊⼀条数据Product product=new Product();product.setName("三只松⿏");int count=mapper.insert(product);System.out.println("插⼊记录数："+count);System.out.println(product);//删除⼀条记录int count1=mapper.deleteById(1);System.out.println(count1);//查询⼀条记录Product product1=mapper.selectById(2);System.out.println(product1);//修改⼀条记录product1.setName("⼀包薯⽚");int i=mapper.update(product1);System.out.println("修改记录数："+i);//查询所有的信息List<Product> products=mapper.selectAll();for (Product product2:products){System.out.println(product2);}mit();sqlSession.close();is.close();}}最后，⼀定要多注意⼀些语法的规范或者要试着去查看错误信息，以便更好的修改错误。

Mybatis中的update动态SQL语句

Mybatis中的update动态SQL语句Mybatis中的CRUD操作（增删改查）中，简单的SQL操作⽐较直观，如查找操作：<select id="findBySrcId" resultMap="entityRelationResultMap">SELECT * FROM ENTITY_RELATION WHERE SRC_ID=#{srcId}</select>其中id对应同名java⽂件中的⽅法，resultMap对应的⾃定义的数据类型（当使⽤java⾃带类型就更容易了，⽐如ng.String之类的）。

但是涉及到更新操作时，可能不需要对所有字段更新，这时不需要更新的字段需要保持原字段信息，当使⽤以下信息就会报错：<update id="updateOne" parameterType="com.inspur.search.data.EntityRelation">update ENTITY_RELATION SET SRC_ID=#{srcId},SRC_TYPE=#{srcType},DEST_ID=#{destId},DEST_TYPE=#{destType},REL_TYPE=#{relType},STATUS=#{status},SN_ID=#{snId}where id=#{id}</update>因为不更新的字段，会被传递null到SQL中，引起异常。

这时就需要进⾏动态SQL拼接，如下，使⽤trim就是为了删掉最后字段的“,”。

主要不⽤单独写SET了，因为set被包含在trim中了：<update id="updateOne" parameterType="com.inspur.search.data.EntityRelation">UPDATE ENTITY_RELATION<trim prefix="set" suffixOverrides=","><if test="srcId!=null">SRC_ID=#{srcId},</if><if test="srcType!=null">SRC_TYPE=#{srcType},</if><if test="destId!=null">DEST_ID=#{destId},</if><if test="destType!=null">DEST_TYPE=#{destType},</if><if test="relType!=null">REL_TYPE=#{relType},</if><if test="status!=null">STATUS=#{status},</if><if test="snId!=null">SN_ID=#{snId},</if></trim>WHERE id=#{id}</update>。

总结一下mybatis对多对多查询与增删改查的心得

总结一下mybatis对多对多查询与增删改查的心得引言在实际的开发中，多对多关联关系是经常遇到的问题，而m yba t is作为一款高效的持久层框架，为我们提供了便捷的解决方案。

本文将总结一下通过m yb at is对多对多关系进行查询和增删改查的心得。

查询多对多关系在m yb at is中，查询多对多关系可以通过嵌套查询和关联表查询来实现。

嵌套查询嵌套查询是通过在映射文件中定义多个查询语句，并通过r esu l tM ap来关联结果，从而实现多对多关系的查询。

具体步骤如下：1.在映射文件中定义多个s el ec t语句，分别查询两个关联表的数据。

2.使用\<re su lt Map>标签定义一个结果映射，包括两个关联表的字段。

3.在主查询语句中使用\<co ll ec ti on>标签来引用结果映射和关联查询语句。

4.使用联合结果映射来获取最终查询结果。

关联表查询关联表查询是通过多表联查来实现多对多关系的查询。

具体步骤如下：1.在映射文件中编写多表联查的SQ L语句，使用J OI N语句关联两个关联表。

2.在\<s el ec t>标签中使用\<re su lt Ma p>定义结果映射，包括两个关联表的字段。

3.在J av a代码中编写相应的Ma pp er接口和Ma pp er.x ml文件。

4.调用Ma pp er接口中的方法来执行查询操作。

增删改查多对多关系m y ba ti s对多对多关系的增删改查操作也是通过多表关联来实现的。

增加记录要增加多对多关系的记录，需要进行以下操作：1.在映射文件中定义插入操作的SQ L语句，插入关联表的数据。

2.在J av a代码中编写相应的Ma pp er接口和Ma pp er.x ml文件。

3.调用Ma pp er接口中的方法来执行插入操作。

删除记录要删除多对多关系的记录，需要进行以下操作：1.在映射文件中定义删除操作的SQ L语句，删除关联表的数据。

SpringBoot+MyBatis中自动根据@Table注解和@Column注解生成增删改查逻辑

SpringBoot+MyBatis中⾃动根据@Table注解和@Column注解⽣成增删改查逻辑习惯使⽤jpa操作对象的⽅式，现在⽤mybatis有点不习惯。

其实是懒得写SQL，增删改查那么简单的事情你帮我做了呗，mybatis：NO。

没办法，⾃⼰搞喽！这⾥主要是实现了通过代码⾃动⽣成mybatis的增删改查语句，并注册到SqlSessionFactory中，并没有⽣成xml⽂件，不⽣成mapper⽂件。

只是在项⽬启动的时候⾃动⽣成，配置到SqlSessionFactory中，下⼀次启动后⾃动根据model⾃动⽣成相关逻辑。

所以不必担⼼表结构修改需要改⼀⼤堆⽂件。

使⽤了此⽅法只需要改model⽂件就可以了。

注意：model必须添加@Table注解，对应的列也必须添加@Column注解（javax）。

思路：在项⽬启动时mybatis默认配置运⾏结束后添加⾃定义配置@Configuration@AutoConfigureAfter(MybatisAutoConfiguration.class)public class MyBatisTypeMapScannerConfig {private Logger log = Logger.getLogger(MyBatisTypeMapScannerConfig.class);public MyBatisTypeMapScannerConfig(ApplicationContext applicationContext, SqlSessionFactory sqlSessionFactory) {在配置中可以获取SqlSessionFactory，看到这⾥，已经结束了。

剩下的都是不重要细节。

1.读取项⽬下的model（包含@table注解的类）List<Class<?>> list = ClassUtil.getClassesWithAnnotation(Table.class);2.读取model下的字段（根据@Column注解）Map<String, Map<String, Object>> cols = ClassUtil.getColumnRelation(clas);3.根据table和column信息配置resultmap，mapperEnd；代码： MyBatisTypeMapScannerConfigimport java.io.ByteArrayInputStream;import java.io.InputStream;import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.Set;import javax.persistence.Table;import mons.logging.Log;import mons.logging.LogFactory;import org.apache.ibatis.builder.xml.XMLMapperBuilder;import org.apache.ibatis.mapping.ResultMap;import org.apache.ibatis.mapping.ResultMapping;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.tomcat.util.buf.StringUtils;import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration;import org.springframework.boot.autoconfigure.AutoConfigureAfter;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Configuration;import com.esri.rest.util.ClassUtil;/*** ⾃动根据@Table注解和@Column注解添加mybatis中的resultmap配置，* 此配置⽣效后不需要在mapper.xml中⼿动添加resultmap，⾃动添加的resultmap的ID为类的全路径名* <p>* Title: MyBatisTypeMapScannerConfig.java* </p>* <p>* Description:* </p>** @author lichao1* @date 2018年12⽉4⽇* @version 1.0*/@Configuration@AutoConfigureAfter(MybatisAutoConfiguration.class)public class MyBatisTypeMapScannerConfig {protected final Log log = LogFactory.getLog(getClass());public MyBatisTypeMapScannerConfig(ApplicationContext applicationContext, SqlSessionFactory sqlSessionFactory) {log.debug("⾃动添加resultMap");org.apache.ibatis.session.Configuration configuration = sqlSessionFactory.getConfiguration();// ResultMap rm = new ResultMap.Builder(configuration, id, type,// null).build();// configuration.addResultMap(rm);// 获取默认包下的所有包含@Table注解的类List<Class<?>> list = ClassUtil.getClassesWithAnnotation(Table.class);for (Class<?> clas : list) {System.out.println(clas);Map<String, Map<String, Object>> cols = ClassUtil.getColumnRelation(clas);ResultMap rm = new ResultMap.Builder(configuration, clas.getName(), clas,getResultMapping(configuration, cols)).build();configuration.addResultMap(rm);List<ResultMap> resultMaps = new ArrayList<ResultMap>();resultMaps.add(rm);Table table = clas.getAnnotation(Table.class);String tableName = ();String allColum = getColumListString(cols);// select// String sql = " select " + allColum + " from " + tableName;// SqlSource sqlSource = new RawSqlSource(configuration, sql, clas);// Builder builder = new MappedStatement.Builder(configuration,// clas.getName() + ".select", sqlSource,// SqlCommandType.SELECT);// builder.resultMaps(resultMaps);// MappedStatement ms = builder.build();// configuration.addMappedStatement(ms);InputStream inputStream = createXml(clas, cols);XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, clas.getName() + ".auto",configuration.getSqlFragments());mapperParser.parse();}log.debug("⾃动添加resultMap");}private InputStream createXml(Class<?> clas, Map<String, Map<String, Object>> cols) {StringBuilder builder = new StringBuilder();String name = clas.getName();Table table = clas.getAnnotation(Table.class);String tableName = ();String allColum = getColumListString(cols);builder.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");builder.append("<!DOCTYPE mapper PUBLIC \"-////DTD Mapper 3.0//EN\" \"/dtd/mybatis-3-mapper.dtd\" >"); builder.append("<mapper namespace=\"" + name + "\" >");Set<String> keys = cols.keySet();String[] keyArr = new String[keys.size()];keys.toArray(keyArr);/****************** 查询 start ***************/builder.append("<select id=\"" + name + ".select\" resultMap=\"" + name + "\" >");builder.append("SELECT " + allColum + " FROM " + tableName + " WHERE 1=1 ");// builder.append(" <if test=\"id != null\"> and id like #{id} </if>");// 查询条件builder.append(createLikelySql(keyArr, clas, cols));// 排序builder.append(" <if test=\"ORDERBY != null\"> order by ${ORDERBY} </if>");// 分页builder.append(" <if test=\"pagestart != null\"> limit #{pagesize} OFFSET #{pagestart} </if>"); builder.append("</select>");/****************** 查询 end ***************//****************** 计数 start ***************/builder.append("<select id=\"" + name + ".count\" resultType=\"long\" >");builder.append("SELECT count(*) count FROM " + tableName + " WHERE 1=1 ");builder.append(createLikelySql(keyArr, clas, cols));builder.append("</select>");/****************** 计数 end ***************//****************** 精确查询 start ***************/builder.append("<select id=\"" + name + ".selectexactly\" resultMap=\"" + name + "\" >");builder.append("SELECT " + allColum + " FROM " + tableName + " WHERE 1=1 ");// builder.append(" <if test=\"id != null\"> and id like #{id} </if>");// 查询条件builder.append(createExactlySql(keyArr, clas, cols));// 排序builder.append(" <if test=\"ORDERBY != null\"> order by ${ORDERBY} </if>");// 分页builder.append(" <if test=\"pagestart != null\"> limit #{pagesize} OFFSET #{pagestart} </if>"); builder.append("</select>");/****************** 精确查询 end ***************//****************** 精确计数 start ***************/builder.append("<select id=\"" + name + ".countexactly\" resultType=\"long\" >");builder.append("SELECT count(*) count FROM " + tableName + " WHERE 1=1 ");builder.append(createExactlySql(keyArr, clas, cols));builder.append("</select>");/****************** 精确计数 end ***************//****************** ⾃定义条件语句查询 start ***************/builder.append("<select id=\"" + name + ".selectwhere\" resultMap=\"" + name + "\" >");builder.append("SELECT " + allColum + " FROM " + tableName + " ");// 查询条件builder.append(" <if test=\"WHERESTR != null\"> WHERE ${WHERESTR} </if>");// 排序builder.append(" <if test=\"ORDERBY != null\"> order by ${ORDERBY} </if>");// 分页builder.append(" <if test=\"pagestart != null\"> limit #{pagesize} OFFSET #{pagestart} </if>"); builder.append("</select>");/****************** ⾃定义条件语句查询 end ***************//****************** ⾃定义条件语句计数 start ***************/builder.append("<select id=\"" + name + ".countwhere\" resultType=\"long\" >");builder.append("SELECT count(*) count FROM " + tableName + " ");// 查询条件builder.append(" <if test=\"WHERESTR != null\"> WHERE ${WHERESTR} </if>");builder.append("</select>");/****************** ⾃定义条件语句计数 end ***************//****************** 删除 start ***************/builder.append("<delete id=\"" + name + ".delete\" parameterType=\"ng.String\" >");builder.append(" DELETE FROM " + tableName + " WHERE id =#{id} ");builder.append("</delete>");/****************** 删除 end ***************//****************** 批量删除 start ***************/builder.append("<delete id=\"" + name + ".deletebatch\" >");builder.append(" DELETE FROM " + tableName + " WHERE 1=1 ");builder.append(createExactlySql(keyArr, clas, cols));builder.append("</delete>");/****************** 批量删除 end ***************//****************** 更新 start ***************/builder.append("<update id=\"" + name + ".update\" parameterType=\"" + name + "\" >");builder.append("UPDATE " + tableName + " SET ");for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];Map<String, Object> obj = cols.get(key);builder.append(" " + (String) obj.get("dbname") + " = #{" + key + "}");if (i < (keyArr.length - 1)) {builder.append(",");}}builder.append(" WHERE id =#{id} ");builder.append("</update>");/****************** 更新 end ***************//****************** 按需更新 start ***************/builder.append("<update id=\"" + name + ".updatesection\" parameterType=\"" + name + "\" >");builder.append("UPDATE " + tableName + " SET ");for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];Map<String, Object> obj = cols.get(key);// builder.append(" " + (String) obj.get("dbname") + " = #{" + key +// "}");if (!"id".equals(key)) {builder.append(" <if test=\"_parameter.containsKey('" + key + "')\">" + (String) obj.get("dbname") + " = #{" + key + "} , </if>");// builder.append(" " + (String) obj.get("dbname") + " = #{" + key + "} , ");}}builder.append(" id = #{id} ");builder.append(" WHERE id =#{id} ");builder.append("</update>");/****************** 按需更新 end ***************//****************** 插⼊ start ***************/builder.append("<insert id=\"" + name + ".insert\" parameterType=\"" + name + "\" >");builder.append("insert INTO " + tableName + " (" + allColum + ") VALUES");builder.append("(" + getColumListString2(cols, "#{", "}") + ") ");builder.append("</insert>");/****************** 插⼊ end ***************/builder.append("</mapper>");InputStream is = new ByteArrayInputStream(builder.toString().getBytes());return is;}private String createListXml() {StringBuilder builder = new StringBuilder();return builder.toString();}/*** ⽣成查询条件语句** @param keyArr* @param clas* @param cols* @return*/private String createLikelySql(String[] keyArr, Class<?> clas, Map<String, Map<String, Object>> cols) {StringBuilder builder = new StringBuilder();for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];Map<String, Object> obj = cols.get(key);try {Class t = (Class) obj.get("type");if (t == String.class) {// String 类型⾃动⽀持like '%' || #name# || '%'builder.append(" <if test=\"" + key + " != null\"> and " + (String) obj.get("dbname")+ " like '%'||#{" + key + "}|| '%' </if>");} else {builder.append(" <if test=\"" + key + " != null\"> and " + (String) obj.get("dbname") + " = #{"+ key + "} </if>");}} catch (Exception e) {(obj);(key);(clas.getName());}}return builder.toString();}private String createExactlySql(String[] keyArr, Class<?> clas, Map<String, Map<String, Object>> cols) { StringBuilder builder = new StringBuilder();for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];Map<String, Object> obj = cols.get(key);builder.append(" <if test=\"" + key + " != null\"> and " + (String) obj.get("dbname") + " = #{" + key + "} </if>"); }return builder.toString();}/*** 获取表内字段** @param cols* @return*/private String getColumListString(Map<String, Map<String, Object>> cols) {return getColumListString(cols, "", "");}private String getColumListString(Map<String, Map<String, Object>> cols, String pre, String end) {pre = pre == null ? "" : pre;end = end == null ? "" : end;Set<String> keys = cols.keySet();String[] keyArr = new String[keys.size()];String[] nameArr = new String[keys.size()];keys.toArray(keyArr);for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];Map<String, Object> obj = cols.get(key);if (((String) obj.get("dbname")).equals("update_date")) {("key");}nameArr[i] = pre + (String) obj.get("dbname") + end;}return StringUtils.join(nameArr);}private String getColumListString2(Map<String, Map<String, Object>> cols) {return getColumListString2(cols, "", "");}private String getColumListString2(Map<String, Map<String, Object>> cols, String pre, String end) {pre = pre == null ? "" : pre;end = end == null ? "" : end;Set<String> keys = cols.keySet();String[] keyArr = new String[keys.size()];String[] nameArr = new String[keys.size()];keys.toArray(keyArr);for (int i = 0; i < keyArr.length; i++) {String key = keyArr[i];nameArr[i] = pre + key + end;}return StringUtils.join(nameArr);}/*** 根据@Column注解⽣成字段映射关系** @param configuration* @param Map<String,* Map<String, Object>> cols* @return*/private List<ResultMapping> getResultMapping(org.apache.ibatis.session.Configuration configuration,Map<String, Map<String, Object>> cols) {List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();System.out.println(cols);Set<String> keys = cols.keySet();String[] keyArr = new String[keys.size()];keys.toArray(keyArr);for (String key : keyArr) {String property;String column;Object javaType;Map<String, Object> map = cols.get(key);property = key;column = (String) map.get("dbname");javaType = map.get("type");ResultMapping mapping = new ResultMapping.Builder(configuration, property, column, (Class<?>) javaType) .build();resultMappings.add(mapping);}return resultMappings;}}应⽤CommonDaoimpl/*** CommonDaoimpl* <p>* Title: CommonDaoimpl.java* </p>* <p>* Description:* </p>** @author lichao1* @date 2018年11⽉19⽇* @version 1.0* @param <T>* @param <ID>*/@Repositorypublic class CommonDaoimpl<T, ID extends Serializable> implements ICommonDao<T, ID> {@PersistenceContextprivate EntityManager entityManager;@Autowiredpublic SqlSessionFactory sqlSessionFactory;protected <T> String getStatement(Class<T> clazz, String prefix) {String entityName = clazz.getSimpleName();if (entityName.endsWith("Model")) {entityName = entityName.substring(0, entityName.length() - 5);}if (entityName.endsWith("Entity")) {entityName = entityName.substring(0, entityName.length() - 6);}entityName = prefix + entityName;return entityName;}// Mybatis 查询⽅法，只需要输⼊mapper的命名空间名称和⽅法名就可以实现数据库操作/*** 执⾏删除语句* @param statement* @param parameter* @return*/public int deleteByMyBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().delete(statement, parameter);}/*** 执⾏删除语句* @param t* @param funName* @param parameter* @return*/public int deleteByMyBatis(Class<T> t, String funName, Object parameter) {String statement = t.getName() + "." + funName;return deleteByMyBatis(statement, parameter);}public int deleteByMyBatis(Class<T> t, Object parameter) {String statement = t.getName() + "." + "delete";return deleteByMyBatis(statement, parameter);}/*** 执⾏查询列表* @param statement* @param parameter* @return*/public List<T> listByMyBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().selectList(statement, parameter); }/*** 执⾏查询列表语句* @param t* @param funName* @param parameter* @return*/public List<T> listByMyBatis(Class<T> t, String funName, Object parameter) { String statement = t.getName() + "." + funName;return listByMyBatis(statement, parameter);}public List<T> ListByMyBatis(Class<T> t, Object parameter){String statement = t.getName() + "." + "select";return listByMyBatis(statement, parameter);}/*** 执⾏插⼊语句* @param statement* @param parameter* @return*/public int insertByMyBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().insert(statement, parameter);}/*** 执⾏插⼊语句* @param t* @param funName* @param parameter* @return*/public int insertByMyBatis(Class<T> t, String funName, Object parameter) {String statement = t.getName() + "." + funName;return insertByMyBatis(statement, parameter);}/*** 执⾏选择⼀条记录语句* @param statement* @param parameter* @return*/public T selectOneByMyBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().selectOne(statement, parameter); }/*** 执⾏选择⼀条记录语句* @param t* @param funName* @param parameter* @return*/public T selectOneByMyBatis(Class<T> t, String funName, Object parameter) { String statement = t.getName() + "." + funName;return selectOneByMyBatis(statement, parameter);}/*** 计数* @param t* @param parameter* @return*/public long countByMyBatis(String statement, Object parameter) {return (long)this.sqlSessionFactory.openSession().selectOne(statement, parameter); }public long countByMyBatis(Class<?> t, Object parameter){String statement = t.getName() + ".count";return countByMyBatis(statement, parameter);}/*** 更新数据* @param statement* @param parameter* @return*/public int updateByMyBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().update(statement, parameter);}/*** 更新数据* @param t* @param funName* @param parameter* @return*/public int updateByMyBatis(Class<T> t, String funName, Object parameter) {String statement = t.getName() + "." + funName;return updateByMyBatis(statement, parameter);}public int updateByMyBatis(Class<T> t, Object parameter) {String statement = t.getName() + ".update";return updateByMyBatis(statement, parameter);}/*** 插⼊数据* @param statement* @param parameter* @return*/public int insertByMayBatis(String statement, Object parameter) {return this.sqlSessionFactory.openSession().insert(statement, parameter);}public int insertByMayBatis(Class<T> t, String funName, Object parameter) {String statement = t.getName() + "." + funName;return this.sqlSessionFactory.openSession().insert(statement, parameter);}public int insertByMayBatis(Class<T> t, Object parameter) {return insertByMayBatis(t,"insert", parameter);}。

增删改查思路及步骤

增删改查思路及步骤1.引言1.1 概述在编写本文时，我们将介绍增删改查（CRUD）操作的思路和步骤。

增删改查是指对数据进行新增、删除、修改和查询的一系列操作。

这些操作在软件开发和数据管理中非常常见，是许多应用程序和系统的重要组成部分。

增加数据的操作是指向数据库或其他数据存储系统添加新的数据记录。

在进行增加数据操作时，我们需要明确所需添加的数据内容，并确保该数据满足预设的数据模型和结构。

删除数据的操作是指从数据库或其他数据存储系统中移除已有的数据记录。

在执行删除数据操作时，我们需要明确要删除的数据的标识或位置，并确保该删除操作不会对其他相关数据产生意外影响。

修改数据的操作是指对数据库或其他数据存储系统中的既有数据进行更新或修改。

在进行修改数据操作时，我们需要明确要修改的数据的标识和要进行的修改内容，并确保该修改操作不会破坏现有的数据完整性和一致性。

查询数据的操作是指根据特定条件从数据库或其他数据存储系统中获取所需的数据记录。

在进行查询数据操作时，我们需要明确所需数据的条件和查询方式，并确保查询结果的准确性和完整性。

通过本文我们将详细介绍每种操作的思路和步骤，并提供相关示例和实践经验。

我们希望读者在阅读本文后能够全面了解增删改查操作，并能够在实际应用中灵活运用这些操作。

最后，我们还将总结增删改查操作的思路和步骤，并提出未来进一步研究的方向，以推动这一领域的发展和创新。

1.2 文章结构本文将以增删改查（CRUD）的思路和步骤为主线，探讨在数据处理中的重要性和具体实施方法。

文章将分为以下几个主要部分：（1）引言：介绍本文的主题和背景，包括增删改查的概念和在实际应用中的重要性。

同时，对文章的结构和目的进行简要说明。

（2）正文：本部分将重点讨论增加数据、删除数据、修改数据和查询数据的思路和步骤。

对于每个操作，我们将阐述其背后的原理和方法，并提供具体的实例和步骤说明。

这将有助于读者全面理解和掌握增删改查的基本操作。

Mybatis实现数据的增删改查(CRUD)+++

Mybatis实现数据的增删改查（CRUD）什么是MyBatis？MyBatis 是支持普通SQL 查询，存储过程和高级映射的优秀持久层框架。

MyBatis 消除了几乎所有的JDBC 代码和参数的手工设置以及对结果集的检索。

MyBatis 可以使用简单的XML 或注解用于配置和原始映射，将接口和Java 的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

MyBatis下载：https:///mybatis/mybatis-3/releasesMybatis实例对一个User表的CRUD操作：User表：-- ------------------------------ Table structure for `user`-- ----------------------------DROP TABLE IF EXISTS `user`;CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`userName` varchar(50) DEFAULT NULL,`userAge` int(11) DEFAULT NULL,`userAddress` varchar(200) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=6DEFAULT CHARSET=utf8;-- ------------------------------ Records of user-- ----------------------------INSERT INTO `user` VALUES ('1', 'summer', '30', 'shanghai');INSERT INTO `user` VALUES ('2', 'test2', '22', 'suzhou');INSERT INTO `user` VALUES ('3', 'test1', '29', 'some place');INSERT INTO `user` VALUES ('4', 'lu', '28', 'some place');INSERT INTO `user` VALUES ('5', 'xiaoxun', '27', 'nanjing');在Src目录下建一个mybatis的xml配置文件Configuration.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><typeAliases><typeAlias alias="User" type="er"/></typeAliases><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis"/><property name="username" value="root"/><property name="password" value="admin"/></dataSource></environment></environments><mappers><mapper resource="com/mybatis/test/User.xml"/></mappers></configuration>定义User mappers的User.xml配置文件<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.mybatis.test.IUserOperation"><select id="selectUserByID" parameterType="int" resultType="User">select * from `user` where user.id = #{id}</select><select id="selectUsersByName" parameterType="string" resultType="User">select * from user where erName = #{userName}</select><!--执行增加操作的SQL语句。

mybatis删除方法编写

mybatis删除方法编写MyBatis 是一个开源的持久层框架，用于简化数据库操作。

在 MyBatis 中，删除操作可以通过 SQL 语句或者注解方式实现。

下面分别介绍这两种方式的删除方法。

1. SQL 语句方式使用 SQL 语句方式实现删除操作，需要编写相应的 SQL 语句，并将其传递给 MyBatis。

具体步骤如下:```// 创建 SQL 语句String sql = "DELETE FROM table_name WHERE condition";// 将 SQL 语句传递给 MyBatisMapper mapper = new Mapper();Result result = mapper.执行 SQL 语句 (sql);```在上面的代码中，“table_name”是要删除的表名，“condition”是删除条件，可以根据实际需要进行修改。

MyBatis 会根据 SQL 语句中的条件进行筛选，并执行相应的操作。

2. 注解方式使用注解方式实现删除操作，需要在相应的映射文件中进行注解，并将注解传递给 MyBatis。

具体步骤如下:```// 定义注解@Delete("DELETE FROM table_name WHERE condition")public void deleteItem(@Param("condition") String condition);```在上面的代码中，“@Delete”是注解的名称，“table_name”是要删除的表名，“condition”是删除条件。

MyBatis 会根据注解中的参数进行筛选，并执行相应的操作。

使用注解方式实现删除操作，可以更加灵活地定义 SQL 语句，并且可以减少代码的编写量。

无论是使用 SQL 语句方式还是注解方式，都需要根据实际需求进行选择。

在实际开发中，应该根据具体情况进行选择，并不断优化代码，以提高代码的可读性和可维护性。

mybatis语法

mybatis语法MyBatis是一种优秀的持久层框架，是基于Java的持久层框架。

它的最大特点就是采用XML文件或注解的形式来配置数据库操作，使用MyBatis以后可以进行SQL语句的操作，这使得工作更加简单快捷。

本文就MyBatis语法相关知识来进行介绍。

MyBatis语法框架中使用了4种不同类型的语句，分别是：Select，Insert，Update和Delete。

这4种语句是数据库操作的4大基本操作，只要通过这4种基本操作可以完成90%以上的数据库操作，这就是MyBatis语法框架的核心所在。

首先来看看Select语句，它的作用是从数据库中查询满足条件的数据，它的语法格式如下：Select * from TableName where Condition;其中，TableName表示数据表的名称，Condition是查询条件，比如可以指定查询某个字段的值等等。

接下来看看Insert语句，它的作用是向数据库中插入一行新数据，它的语法格式如下：Insert into TableName(Column1, Column2,…values(Value1, Value2,…);其中，TableName表示数据表的名称，Column1和Column2表示需要插入的字段，Value1和Value2表示插入字段的值。

接下来看看Update语句，它的作用是更新数据库中的数据，它的语法格式如下：Update TableName set Column1=Value1,Column2=Value2 where Condition;其中，TableName表示数据表的名称，Column1和Column2表示需要更新的字段，Value1和Value2表示更新字段的值，Condition 是查询条件，表示需要更新哪些数据。

最后看看Delete语句，它的作用是删除数据库中的数据，它的语法格式如下：Delete from TableName where Condition;其中，TableName表示数据表的名称，Condition是查询条件，表示需要删除哪些数据。

mybatis saveorupdate 自定义条件

mybatis saveorupdate 自定义条件全文共四篇示例，供读者参考第一篇示例：MyBatis是一个非常流行的Java持久化框架，它使用简单的XML 文件或注解配置来映射Java对象和数据库表。

在使用MyBatis进行增删改查操作时，最常见的就是保存或更新数据的操作。

通常我们会使用insert和update两个SQL语句来实现保存或更新数据的功能。

但是有时候我们希望在保存或更新数据时，可以自定义一些条件来决定是执行保存操作还是更新操作。

比如我们希望在执行保存操作时，如果数据库中已经存在相同主键的数据，则执行更新操作，如果不存在则执行保存操作。

这样就可以避免出现主键冲突的情况。

在MyBatis中，可以通过自定义条件来实现这样的功能。

一般来说，在MyBatis中实现saveOrUpdate的功能有两种常见的方式：第一种方式是使用<selectKey>和<if>标签来实现。

在执行insert 操作时，使用<selectKey>标签获取数据库生成的主键值，然后通过<if>标签判断主键值是否存在，如果存在则执行更新操作，如果不存在则执行保存操作。

```xml<insert id="saveOrUpdate"parameterType="er"><selectKey keyProperty="id"resultType="ng.Long" order="BEFORE">SELECT IFNULL(MAX(id), 0) + 1 FROM user</selectKey>INSERT INTO user(id, name) VALUES (#{id}, #{name})ON DUPLICATE KEY UPDATE name = #{name}</insert>```在上面的示例中，<selectKey>标签会获取数据库中最大的主键值，并将其赋给参数对象中的id属性。

mybatis plus saveorupdate实现原理

mybatis plus saveorupdate实现原理MyBatisPlus是一款基于MyBatis的增强工具，提供了许多方便的CRUD操作。

其中，SaveOrUpdate方法是一个非常常用的功能，用于实现数据的增删改操作。

本文将介绍MyBatisPlusSaveOrUpdate实现原理，帮助读者更好地理解和使用该方法。

一、SaveOrUpdate方法简介SaveOrUpdate方法是MyBatisPlus提供的一个便捷方法，用于将一条数据插入或更新到数据库中。

该方法接收一个参数，即待插入或更新的数据对象。

如果该数据对象已经存在于数据库中，则更新该数据；如果不存在，则将其插入到数据库中。

二、实现原理1.判断数据对象是否为空在SaveOrUpdate方法中，首先需要判断传入的数据对象是否为空。

如果为空，则直接抛出异常；如果不为空，则进行下一步操作。

2.解析SQL语句MyBatisPlus通过XML或注解的方式配置SQL语句，SaveOrUpdate方法会根据传入的数据对象自动生成对应的SQL语句。

具体来说，会根据数据对象的字段和数据库表结构，生成对应的INSERT或UPDATE语句。

3.执行SQL语句生成SQL语句后，MyBatisPlus会通过MyBatis的执行机制，将SQL语句发送到数据库执行。

具体来说，会通过SqlSession执行器执行该SQL语句，并将结果返回给调用者。

4.事务处理在执行SQL语句的过程中，可能会涉及到多个数据库操作，因此需要使用事务进行处理。

MyBatisPlus会自动开启事务，并在操作完成后提交事务，以保证数据的一致性。

三、注意事项1.数据库表结构匹配为了保证SaveOrUpdate方法的正确性，需要确保数据库表结构和数据对象的字段匹配。

否则，可能会出现插入失败或更新错误的情况。

2.数据对象唯一性约束如果数据对象的某个字段具有唯一性约束（如主键），则需要在SQL语句中添加相应的约束条件，以确保插入或更新操作的正确性。

mybatis cursor的用法

mybatis cursor的用法MyBatis的cursor是用于处理大量数据查询的一种机制，当查询结果集很大时，使用cursor可以避免一次性将所有数据加载到内存中，而是通过游标进行逐条处理。

使用cursor时，首先需要在Mapper中定义一个返回类型为Cursor的方法。

例如：```javaCursor<User> getUsers();```然后，在对应的Mapper XML中编写相应的SQL语句，使用OPEN和CLOSE命令打开和关闭cursor。

例如：```xml<select id="getUsers" resultType="er" statementType="CALLABLE">{call get_users(#{result, jdbcType=CURSOR, mode=OUT, javaType=java.sql.ResultSet})}</select>```在Java代码中调用该方法时，可以通过循环不断地从Cursor中获取数据，直到无法获取到数据为止。

例如：```javatry (SqlSession sqlSession =sqlSessionFactory.openSession()) {Cursor<User> cursor = sqlSession.selectCursor("getUsers");while (cursor.hasNext()) {User user = cursor.next();//处理每条数据}cursor.close();}```使用cursor的好处是，可以大大减少内存的占用，特别适用于处理大批量数据的情况。

不过，需要注意的是，因为使用了游标，数据库连接会一直保持打开状态，所以需要在代码中显式地关闭cursor。

mybatis-plus 原理

mybatis-plus 原理MyBatis-Plus 是 MyBatis 的增强工具库，它简化了 MyBatis 的开发，提供了一系列增强功能和便捷的 API，使得数据访问层的开发更加高效和易用。

MyBatis-Plus 的原理主要包括以下几个方面：1. 代码生成器：MyBatis-Plus 提供了一个代码生成器，能够根据数据库表结构自动生成 Java 实体类、Mapper 接口以及 XML 映射文件。

代码生成器大大减少了手动编写重复代码的工作量，提高了开发效率。

2. CRUD 方法封装：MyBatis-Plus 封装了常用的 CRUD（增删改查）操作，如`selectById`、`selectList`、`insert`、`updateById`、`deleteById` 等。

这些方法不仅简化了代码，还通过泛型支持了通用的 CRUD 操作，无需手动编写 SQL。

3. 条件构造器：MyBatis-Plus 引入了 `Wrapper` 条件构造器的概念，用于构建动态SQL 查询条件。

通过 `Wrapper`，可以更加灵活地拼接查询条件，支持链式调用和各种逻辑操作。

4. 分页插件：MyBatis-Plus 提供了分页插件，支持多种数据库的分页查询。

开发者只需简单配置分页参数，MyBatis-Plus 就能自动处理分页查询，并返回分页结果。

5. 主键策略：MyBatis-Plus 支持多种主键策略，可以通过注解或全局配置来指定主键生成方式，包括自增主键、UUID、雪花算法等。

6. 元对象和元注解：MyBatis-Plus 引入了元对象的概念，用于在运行时记录实体对象的元信息。

同时，它还提供了元注解，用于更加灵活地配置实体对象与数据库表之间的映射关系。

7. 性能优化：MyBatis-Plus 在某些情况下能够对 SQL 进行改写和优化，以提升数据库查询性能。

MyBatis-Plus 并不是替代 MyBatis，而是在 MyBatis 的基础上提供了更多便捷和增强功能。

mybatis-enhance-actable用法

mybatis-enhance-actable用法MyBatis-Enhance-Actable是一个用于增强MyBatis的插件，用于实现支持动态创建和操作数据库表的功能。

它可以让你在应用程序中动态地创建表，并且可以使用MyBatis进行增删改查操作。

本文将详细介绍MyBatis-Enhance-Actable的用法。

1.导入依赖首先，你需要在你的项目中导入MyBatis-Enhance-Actable的依赖。

可以使用Maven或者Gradle来管理依赖关系。

以下是Maven的示例依赖配置：```xml<dependency><artifactId>mybatis-enhance-actable</artifactId><version>2.1.2</version></dependency>```2.配置数据源接下来，你需要配置好你的数据源。

在MyBatis-Enhance-Actable中，你可以使用任何MyBatis支持的数据库作为数据源，比如MySQL、PostgreSQL等。

你可以在你的项目配置文件中添加以下配置项：```properties#数据源配置spring.datasource.url=jdbc:mysql://localhost:3306/testername=rootspring.datasource.password=root```3.创建实体类接下来，你需要创建一个普通的Java类作为你要创建的表的实体类。

这个实体类需要使用MyBatis的注解来描述表的结构。

例如，你可以定义一个名为`User`的实体类，表示一个用户：```javapublic class User//主键IDprivate Long id;//用户名private String username;//年龄private Integer age;// getter和setter方法```4.创建数据库表一旦你定义了实体类，你可以使用MyBatis-Enhance-Actable的`ActableSchemaScanner` 类来创建表。

mybatis cursor的用法

MyBatis Cursor的用法1. 什么是MyBatis CursorMyBatis是一个开源的持久层框架，它提供了许多便捷的功能用于简化数据库操作。

其中之一就是MyBatis Cursor。

Cursor（游标）是一种数据库操作方式，它允许我们逐行地从数据库中读取数据，而不是一次性将所有数据加载到内存中。

这种方式适用于处理大量数据时，可以减少内存的占用。

在MyBatis中，Cursor可以通过配置文件或者注解的方式来使用。

它提供了两种类型的Cursor：普通Cursor和批量Cursor。

普通Cursor适用于处理较小的结果集，而批量Cursor适用于处理大结果集。

2. MyBatis Cursor的配置2.1 普通Cursor的配置在MyBatis的配置文件中，我们可以通过设置fetchType属性为FORWARD_ONLY来使用普通Cursor。

示例如下：<select id="getUserList" resultType="User" fetchType="FORWARD_ONLY">SELECT * FROM user</select>2.2 批量Cursor的配置批量Cursor需要使用MyBatis的fetchSize属性来配置。

fetchSize表示每次从数据库中获取的数据量。

示例如下：<select id="getUserList" resultType="User" fetchSize="100">SELECT * FROM user</select>3. 使用MyBatis Cursor3.1 使用普通Cursor使用普通Cursor时，MyBatis会将查询结果逐行地从数据库中读取，并将每行数据映射到指定的实体类中。

mybatis insert or update xml写法

mybatis insert or update xml写法MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

MyBatis消除了几乎所有的JDBC代码和参数的手动设置以及结果集的检索。

在使用MyBatis时，我们可以通过XML文件来配置和映射数据库操作。

下面，我将向您展示如何使用MyBatis进行插入或更新操作。

一、准备数据源首先，您需要将数据库的相关信息配置到数据源中，包括数据库URL、用户名和密码等。

确保这些信息正确无误，以便后续的数据库操作。

二、创建XML文件创建一个XML文件，用于配置数据库操作的SQL语句和映射关系。

通常，MyBatis的XML文件由三部分组成：映射（Mapper）、插件（Interceptor）和SQL语句。

1. 映射（Mapper）在MyBatis中，映射文件用于指定数据库操作的方法。

您可以在映射文件中定义一个或多个插入或更新方法。

```xml<mapper namespace="erMapper"><insert id="insertOrUpdateUser"parameterType="er"></insert></mapper>```2. 插件（Interceptor）您可以在XML文件中使用插件来对SQL语句进行拦截和处理。

例如，可以使用插件对SQL语句进行日志记录、性能监控等操作。

```xml<plugins><log type="org.mybatis.plugin.DefaultLog"></log></plugins>```3. SQL语句（INSERT 或 UPDATE）在XML文件中，使用<insert>标签包裹SQL语句，用于插入数据；使用<update>标签包裹SQL语句，用于更新数据。

mybatis plus baseservice原理

Mybatis-Plus 是一个Mybatis 的扩展工具包，提供了许多便捷的方法和功能，可以使得Mybatis 的使用更加简单和高效。

其中，BaseService 是Mybatis-Plus 提供的一个基础服务类，提供了常用的增删改查操作，简化了开发人员对数据库的操作。

BaseService 的原理是封装了Mybatis 的CRUD 操作，实现了通用的数据访问方法。

在BaseService 中，通过反射机制获取泛型类型，进而获取对应的Mapper 接口，并调用Mapper 接口中的相应方法来完成数据的增删改查操作。

例如，在BaseService 中，我们可以使用以下方法进行数据插入操作：
Copy Code
public boolean save(T entity) {
return baseMapper.insert(entity) > 0;
}
这里的baseMapper 可以看作是一个通用的Mapper 对象，其类型是根据BaseService 的泛型参数进行自动注入的。

在这个方法中，我们直接调用了baseMapper 对象的insert 方法，将实体对象插入到数据库中。

类似的，BaseService 还封装了许多其他的常用方法，比如updateById、deleteById、selectById 等，这些方法都是通过反射机制调用Mapper 接口中相应的方法实现的。

总之，BaseService 的原理就是通过反射机制获取Mapper 接口，并封装了常用的数据访问方法，使得开发人员可以更加方便地进行数据库操作。

MybatisPlus基本增删改查和条件构造器删改查

MybatisPlus基本增删改查和条件构造器删改查数据库：依赖：<dependencies><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus</artifactId><version>2.3</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.9</version></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency><dependency><groupId>com.mchange</groupId><artifactId>c3p0</artifactId><version>0.9.5.2</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.37</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>4.3.10.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>4.3.10.RELEASE</version></dependency></dependencies>相关配置⽂件：mybatis-config.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration></configuration>log4j.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"><log4j:configuration ><appender name="STDOUT" class="org.apache.log4j.ConsoleAppender"><param name="Encoding" value="UTF-8"/><layout class="org.apache.log4j.PatternLayout"><param name="ConversionPattern" value="%-5p %d{MM-ddHH:mm:ss,SSS} %m (%F:%L) \n"/></layout></appender><logger name="java.sql"><level value="debug"/></logger><logger name="org.apache.ibatis"><level value="info"/></logger><root><level value="debug"/><appender-ref ref="STDOUT"/></root></log4j:configuration>db.properties：jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://xxx.xx.xxx.xxx:3306/mp?useUnicode=true&characterEncoding=UTF8 ername=rootjdbc.password=123456applicationContext.xml:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:mybatis-spring="/schema/mybatis-spring"xsi:schemaLocation="/schema/mybatis-spring/schema/mybatis-spring-1.2.xsd/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><context:property-placeholder location="classpath:db.properties"/><bean id="dataSource"class="boPooledDataSource"><property name="driverClass" value="${jdbc.driver}"></property><property name="jdbcUrl" value="${jdbc.url}"></property><property name="user" value="${ername}"></property><property name="password" value="${jdbc.password}"></property></bean><bean id="dataSourceTransactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property></bean><tx:annotation-driventransaction-manager="dataSourceTransactionManager"/><bean id="sqlSessionFactoryBean"class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property><property name="configLocation"value="classpath:mybatis-config.xml"></property><property name="typeAliasesPackage"value="com.ytkj.mybatisplus.entity"></property><property name="globalConfig" ref="globalConfiguration"></property></bean><bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage"value="com.ytkj.mybatisplus.mapper"></property></bean><bean id="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration"> <property name="dbColumnUnderline" value="true"></property><property name="idType" value="0"></property><property name="tablePrefix" value="tbl_"></property></bean></beans>entity：package com.ytkj.mybatisplus.entity;import com.baomidou.mybatisplus.annotations.TableField;import com.baomidou.mybatisplus.annotations.TableId;import com.baomidou.mybatisplus.annotations.TableName;import com.baomidou.mybatisplus.enums.IdType;/*** javaBean* 定义javaBean中成员变量时所使⽤的类型*//*** @TableName：* value:数据库表名**/@TableName(value ="tbl_employee" )public class Employee {/*id INT(11) PRIMARY KEY AUTO_INCREMENT,last_name VARCHAR(50),email VARCHAR(50),gender CHAR(1),age INT*//*** @TableId：* value：指定表中的主键列的列名，如果实体属性名与列名⼀致可以省略 * type:指定主键策略**/@TableId(value = "id",type = IdType.AUTO)@TableField( value = "id",exist = true)private Integer id;@TableField(value = "last_name",exist = true)private String lastName;@TableField(value = "email",exist = true)private String email;@TableField(value = "gender",exist =true)private Integer gender;@TableField(value ="age",exist = true)private Integer age;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getLastName() {return lastName;}public void setLastName(String lastName) {stName = lastName;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public Integer getGender() {return gender;}public void setGender(Integer gender) {this.gender = gender;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Employee{" +"id=" + id +", lastName='" + lastName + '\'' +", email='" + email + '\'' +", gender=" + gender +", age=" + age +'}';}}Mapper:package com.ytkj.mybatisplus.mapper;import com.baomidou.mybatisplus.mapper.BaseMapper;import com.ytkj.mybatisplus.entity.Employee;/*** mapper接⼝* ：基于mybatis：在Mapper接⼝中编写CRUD相关⽅法，提供Mapper接⼝所对应的SQL映射⽂件⼀级⽅法对应的SQL语句 * ：基于mybatisplus：让xxxMapper接⼝继承baseMapper<T>即可,T指定的就是当前mapper接⼝所操作的实体类类型*/public interface EmployeeMapper extends BaseMapper<Employee> {}Test:基本增删改查package junit.test;import com.baomidou.mybatisplus.plugins.Page;import com.ytkj.mybatisplus.entity.Employee;import com.ytkj.mybatisplus.mapper.EmployeeMapper;import org.apache.ibatis.session.RowBounds;import org.junit.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.sql.DataSource;import java.sql.Connection;import java.sql.SQLException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class TestMybatisPlus {private ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");@Testpublic void testDataSource() throws SQLException {DataSource dataSource=ioc.getBean("dataSource",DataSource.class);System.out.println(dataSource);Connection connection = dataSource.getConnection();System.out.println(connection);}/*** 从容器中获取employeeMapper*/private EmployeeMapper employeeMapper=ioc.getBean("employeeMapper",EmployeeMapper.class);/*** 通⽤插⼊操作插⼊实体类设置值的字段,只有⾮空的属性对应的字段才会出现到SQL语句中* INSERT INTO tbl_employee ( last_name, age ) VALUES ( ?, ? )*/@Testpublic void testInsert(){Employee employee=new Employee();employee.setLastName("zhechaochao");employee.setAge(18);Integer row = employeeMapper.insert(employee);System.out.println("row="+row);//获取数据库中的主键值Integer id = employee.getId();System.out.println(id);}/*** 通⽤插⼊操作插⼊时不管属性是否⾮空，属性所对应的字段都会出现到SQL语句中* INSERT INTO tbl_employee ( last_name,email,gender,age ) VALUES ( ?,?,?,? )*/@Testpublic void testInsertAllColumn(){Employee employee=new Employee();employee.setLastName("zhechaochao");employee.setAge(18);Integer row = employeeMapper.insertAllColumn(employee);System.out.println("row="+row);//获取数据库中的主键值Integer id = employee.getId();System.out.println(id);}/*** 根据id更新* UPDATE tbl_employee SET gender=?, age=? WHERE id=?*/@Testpublic void testUpdateById(){Employee employee=new Employee();employee.setId(7);employee.setGender(1);employee.setAge(25);Integer row = employeeMapper.updateById(employee);System.out.println("row="+row);}/*** 根据id更新* 慎⽤，更新所有字段其他字段原本有值会被设置为null* UPDATE tbl_employee SET last_name=?,email=?,gender=?,age=? WHERE id=?*/@Testpublic void testUpdateAllColumnById(){Employee employee=new Employee();employee.setId(7);employee.setGender(1);employee.setAge(25);Integer row = employeeMapper.updateAllColumnById(employee);System.out.println("row="+row);}/*** 更具id查询* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE id=?*/@Testpublic void testSelectById(){Employee employee = employeeMapper.selectById(1);System.out.println(employee);}/***通过多列进⾏查询 id+lastName* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE id=? AND last_name=? */@Testpublic void testSelectOne(){Employee employee=new Employee();employee.setId(6);employee.setLastName("zhechaochao");Employee employee1 = employeeMapper.selectOne(employee);System.out.println(employee1);}/***根据id批量查询* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE id IN ( ? , ? , ? )*/@Testpublic void testSelectBatchIds(){List<Integer> list=new ArrayList<>();list.add(1);list.add(2);list.add(6);List<Employee> employees = employeeMapper.selectBatchIds(list);System.out.println(employees);}/***通过map封装查询条件* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE gender = ? AND last_name = ? AND id = ? */@Testpublic void testSelectByMap(){Employee employee=new Employee();Map<String,Object> map=new HashMap<>();/*** put时是数据库中的列名⽽不是实体类的属性名*/map.put("id",1);//map.put("lastName","Tom");报错map.put("last_name","Tom");map.put("gender",1);List<Employee> employees = employeeMapper.selectByMap(map);System.out.println(employees);}/***不根据条件分页查询* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee*/@Testpublic void testSelectPage(){RowBounds rowBounds=new RowBounds(0,2);List<Employee> employees = employeeMapper.selectPage(rowBounds, null);System.out.println("employees"+employees);Page<Employee> page=new Page<>(0,2);List<Employee> employees1 = employeeMapper.selectPage(page, null);System.out.println("employees1"+employees1);}/***根据id删除* DELETE FROM tbl_employee WHERE id=?*/@Testpublic void testDeleteById(){Integer row = employeeMapper.deleteById(7);System.out.println("row"+row);}/***根据id批量删除* DELETE FROM tbl_employee WHERE id IN ( ? , ? )*/@Testpublic void testDeleteBatchIds(){List<Integer> list=new ArrayList<>();list.add(8);list.add(9);Integer row = employeeMapper.deleteBatchIds(list);System.out.println("row"+row);}/***通过map封装删除条件* DELETE FROM tbl_employee WHERE last_name = ? AND id = ? AND age = ?*/@Testpublic void testDeleteByMap(){Map<String,Object> map=new HashMap<>();map.put("id",6);map.put("last_name","zhechaochao");map.put("age",18);Integer row = employeeMapper.deleteByMap(map);System.out.println("row"+row);}}条件构造器删改查package junit.test;import com.baomidou.mybatisplus.mapper.EntityWrapper;import com.baomidou.mybatisplus.plugins.Page;import com.ytkj.mybatisplus.entity.Employee;import com.ytkj.mybatisplus.mapper.EmployeeMapper;import org.apache.ibatis.session.RowBounds;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.sql.DataSource;import java.sql.Connection;import java.sql.SQLException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class TestMybatisPlusConditionalQuery {private ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");@Testpublic void testDataSource() throws SQLException {DataSource dataSource=ioc.getBean("dataSource",DataSource.class);System.out.println(dataSource);Connection connection = dataSource.getConnection();System.out.println(connection);}/*** 从容器中获取employeeMapper*/private EmployeeMapper employeeMapper=ioc.getBean("employeeMapper",EmployeeMapper.class);/*** 条件构造器查询操作* 年龄在 18~50 之间性别为男且姓名为 xx 的所有⽤户*SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE (age BETWEEN ? AND ? AND gender = ? AND last_name = ?)*/@Testpublic void testSelectPage(){Page<Employee> page=new Page<>(0,2);EntityWrapper<Employee> entityWrapper=new EntityWrapper<>();entityWrapper.between("age",18,50).eq("gender",1).eq("last_name","Tom");List<Employee> list = employeeMapper.selectPage(page, entityWrapper);System.out.println(list);}/*** 条件构造器查询操作* 性别为⼥并且名字中带有laoshi或者邮箱中带有a*or()===>SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE (gender = ? AND last_name LIKE ? OR email LIKE ?)* orNew()===>SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE (gender = ? AND last_name LIKE ?) OR (email LIKE ?) **/@Testpublic void testSelectList(){EntityWrapper<Employee> entityWrapper=new EntityWrapper<>();//entityWrapper.eq("gender",0).like("last_name","laoshi").or().like("email","a");entityWrapper.eq("gender",0).like("last_name","laoshi").orNew().like("email","a");List<Employee> employees = employeeMapper.selectList(entityWrapper);System.out.println(employees);}/*** 条件构造器查询操作* 名字为Tom性别为男根据年龄排序* SELECT id AS id,last_name AS lastName,email,gender,age FROM tbl_employee WHERE (gender = ? AND last_name = ?) ORDER BY age DESC**/@Testpublic void testSelectList2(){EntityWrapper<Employee> entityWrapper=new EntityWrapper<>();entityWrapper.eq("gender",1).eq("last_name","Tom").orderBy("age",false);List<Employee> employees = employeeMapper.selectList(entityWrapper);System.out.println(employees);}/*** 条件构造器查询操作* 根据名字长度⼤于10分组* 更具性别分组，查询每组的平均年龄，最⼤年龄，最⼩年龄。

MybatisPlus使用条件构造器增删改查功能的实现方法

MybatisPlus使⽤条件构造器增删改查功能的实现⽅法java后端层级结构Controller 接⼝层接⼝层⽐较好理解，它是⾯向web⽹络的接⼝，使⽤http格式去调⽤/*** 图⽂课程管理Controller*/@RestController@RequestMapping("/driver/imageCourse")public class TImageCourseController extends BaseController {@Autowiredprivate ITImageCourseService tImageCourseService;@Autowiredprivate TImageCourseMapper tImageCourseMapper;// 具体接⼝...}Service 业务层在实际应⽤中，更复杂的逻辑应该写在Service业务层⽅法中，在业务⽅法中再调⽤数据层⽅法，实现从接⼝层-业务层-数据层的链路调⽤关系，提⾼代码的可读性/*** 图⽂课程管理Service接⼝*/public interface ITImageCourseService extends IService<TImageCourse> {}业务层实现/*** 图⽂课程管理Service业务层处理*/@Servicepublic class TImageCourseServiceImpl extends ServiceImpl<TImageCourseMapper, TImageCourse> implements ITImageCourseService {@Autowiredprivate TImageCourseMapper tImageCourseMapper;}ServiceImpl类实现了IService接⼝中的⽅法；ServiceImpl中的⽅法，本质上是对BaseMapper⽅法的封装，同时也增加了⼀些BaseMapper类中没有的特性，例如常⽤的list()、count()⽅法// Service⽅法调⽤了Mapper⽅法只是将insert()返回转换成了布尔值@Overridepublic boolean save(T entity) {return retBool(baseMapper.insert(entity));}Mapper 数据层继承BaseMapper接⼝后，⽆需编写 mapper.xml ⽂件，即可获得CRUD功能；例如，insert()、deleteById()、updateById()、selectById()等⽅法如果⼿动编写数据层的sql，BaseMapper实现者即对应xml中的sql⽅法/*** 图⽂课程管理Mapper接⼝*/public interface TImageCourseMapper extends BaseMapper<TImageCourse> {}**mapper.xml **xml内容例⼦，该例⼦⾃定义了⼀个根据id的查询⽅法，⽆视了删除标志<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.ruoyi.mapper.TRuralInfoMapper"><resultMap type="TRuralInfo" id="RuralInfoResult"><id property="id" column="id" /><result property="cityName" column="city_name" /><result property="countyName" column="county_name" /><result property="townName" column="town_name" /><result property="villageName" column="village_name" /><result property="checkCode" column="check_code" /><result property="parentLevel" column="parent_level" /><result property="parentId" column="parent_id" /><result property="delFlag" column="del_flag" /><result property="createBy" column="create_by" /><result property="createTime" column="create_time" /><result property="updateBy" column="update_by" /><result property="updateTime" column="update_time" /></resultMap><sql id="selectRuralInfoVo">select t_rural_info.id, city_name, county_name, town_name, village_name, check_code, parent_level, parent_id,t_rural_info.del_flag, t_rural_info.create_by, t_rural_info.create_time, t_rural_info.update_by, t_rural_info.update_timefrom t_rural_info</sql><select id="getRuralInfoById" parameterType="Long" resultMap="RuralInfoResult"><include refid="selectRuralInfoVo"/>where id = #{id}</select></mapper>增删改查新增（C）使⽤mapper对象的insert()⽅法新增⼀条记录，成果后会将数据库的id返回给实体/*** 新增图⽂课程管理*/@PostMappingpublic AjaxResult add(@RequestBody TImageCourse tImageCourse){...return toAjax(tImageCourseMapper.insert(tImageCourse));}saveBatchservice类中提供了saveBatch()⽅法，可实现批量插⼊，该⽅法是⽀持事务saveOrUpdateservice类中提供了saveOrUpdate()⽅法，如果id为空则调⽤save()⽅法保存，反之则调⽤updateById()⽅法更新查询（R）查询多数要借助条件构造器使⽤才有意义，实现更灵活的查询；查询实体常⽤的⽅法有.getOne()，getById() ;.getOne()接收⼀个条件构造器作为参数getById()根据id进⾏查询实体查询集合常⽤的查询⽅法包括.list()，.list()⽅法也可以接收⼀个条件构造器作为参数构造器的使⽤条件构造器包含QueryWrapper和LambdaQueryWrapper两个类。

mybatis抽取基类BaseMapper增删改查的实现

mybatis抽取基类BaseMapper增删改查的实现⽬录准备⼯作:1:数据库表2:准备实体类步骤1:编写⼯具类Tools:作⽤:⽤于驼峰和数据库字段的转换步骤2:⾃定义两个注解,分别⽤于类字段的排除和字义主键步骤3:⾃定义动态sql⽣成类BaseSqlProvider<T>步骤4:编写BaseMapper基类接⼝举例:⽬前项⽬当中使⽤mapper.xml⽂件⽅式对数据库进⾏操作,但是每个⾥边都有增/删/改/查,为了⽅便开发,把这些公共的代码提取出来,不⽤当做基类,不⽤每个Mapper⽂件都写了准备⼯作:1:数据库表CREATE TABLE `t_permission` (`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '权限ID',`type` int(11) NOT NULL COMMENT '权限类型',`name` varchar(255) NOT NULL COMMENT '权限名称',PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=24 DEFAULT CHARSET=utf8 COMMENT='权限表';2:准备实体类public class TPermissionEntity {@PrimaryKey //下⾯步骤2中⾃定义注解private Integer id;//权限IDprivate Integer type;//权限类型private String name;//权限名称//省略了get,set⽅法....}步骤1:编写⼯具类Tools:作⽤:⽤于驼峰和数据库字段的转换因为类的名称⽤的是驼峰命名,所以这⾥需要转换⼀下import java.util.regex.Matcher;import java.util.regex.Pattern;/** 驼峰名称和下划线名称的相互转换*/public class Tool {private static Pattern linePattern = pile("_(\\w)");/** 下划线转驼峰 */public static String lineToHump(String str) {str = str.toLowerCase();Matcher matcher = linePattern.matcher(str);StringBuffer sb = new StringBuffer();while (matcher.find()) {matcher.appendReplacement(sb, matcher.group(1).toUpperCase());}matcher.appendTail(sb);return sb.toString();}private static Pattern humpPattern = pile("[A-Z]");/** 驼峰转下划线,效率⽐上⾯⾼ */public static String humpToLine(String str) {Matcher matcher = humpPattern.matcher(str);StringBuffer sb = new StringBuffer();while (matcher.find()) {matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());}matcher.appendTail(sb);return sb.toString();}}步骤2:⾃定义两个注解,分别⽤于类字段的排除和字义主键@Target({ElementType.FIELD})@Retention(RetentionPolicy.RUNTIME)public @interface Exclude {}@Target({ElementType.FIELD})@Retention(RetentionPolicy.RUNTIME)public @interface PrimaryKey {String value() default "";}步骤3:⾃定义动态sql⽣成类BaseSqlProvider<T>作⽤:根据传⼊的对象动态获取表名和字段名⽣成动态的sql语句,再执⾏@Insert,@Select,@update,@Delete是直接配置SQL语句，⽽@InsertProvider,@UpdateProvider,@SelectProvider,@DeleteProvider则是通过SQL⼯⼚类及对应的⽅法⽣产SQL语句import ng.reflect.Field;import java.util.ArrayList;import java.util.List;import org.apache.ibatis.annotations.Options;import org.apache.ibatis.jdbc.SQL;import mon.utils.Tool;public class BaseSqlProvider<T> {@Optionspublic String add(T bean) {SQL sql = new SQL();Class clazz = bean.getClass();String tableName = clazz.getSimpleName();String realTableName = Tool.humpToLine(tableName).replaceAll("_entity", "").substring(1);sql.INSERT_INTO(realTableName);List<Field> fields = getFields(clazz);for (Field field : fields) {field.setAccessible(true);String column = field.getName();System.out.println("column:" + Tool.humpToLine(column));sql.VALUES(Tool.humpToLine(column), String.format("#{" + column + ",jdbcType=VARCHAR}"));}return sql.toString();}public String delete(T bean) {SQL sql = new SQL();Class clazz = bean.getClass();String tableName = clazz.getSimpleName();String realTableName = Tool.humpToLine(tableName).replaceAll("_entity", "").substring(1); sql.DELETE_FROM(realTableName);List<Field> primaryKeyField = getPrimarkKeyFields(clazz);if (!primaryKeyField.isEmpty()) {for (Field pkField : primaryKeyField) {pkField.setAccessible(true);sql.WHERE(pkField.getName() + "=" + String.format("#{" + pkField.getName() + "}"));}} else {sql.WHERE(" 1= 2");throw new RuntimeException("对象中未包含PrimaryKey属性");}return sql.toString();}private List<Field> getPrimarkKeyFields(Class clazz) {List<Field> primaryKeyField = new ArrayList<>();List<Field> fields = getFields(clazz);for (Field field : fields) {field.setAccessible(true);PrimaryKey key = field.getAnnotation(PrimaryKey.class);if (key != null) {primaryKeyField.add(field);}}return primaryKeyField;}private List<Field> getFields(Class clazz) {List<Field> fieldList = new ArrayList<>();Field[] fields = clazz.getDeclaredFields();for (Field field : fields) {field.setAccessible(true);Exclude key = field.getAnnotation(Exclude.class);if (key == null) {fieldList.add(field);}}return fieldList;}public String get(T bean) {SQL sql = new SQL();Class clazz = bean.getClass();String tableName = clazz.getSimpleName();String realTableName = Tool.humpToLine(tableName).replaceAll("_entity", "").substring(1); sql.SELECT("*").FROM(realTableName);List<Field> primaryKeyField = getPrimarkKeyFields(clazz);if (!primaryKeyField.isEmpty()) {for (Field pkField : primaryKeyField) {pkField.setAccessible(true);sql.WHERE(pkField.getName() + "=" + String.format("#{" + pkField.getName() + "}"));}} else {sql.WHERE(" 1= 2");throw new RuntimeException("对象中未包含PrimaryKey属性");}System.out.println("getSql:"+sql.toString());return sql.toString();}public String update(T bean) {SQL sql = new SQL();Class clazz = bean.getClass();String tableName = clazz.getSimpleName();String realTableName = Tool.humpToLine(tableName).replaceAll("_entity", "").substring(1);sql.UPDATE(realTableName);List<Field> fields = getFields(clazz);for (Field field : fields) {field.setAccessible(true);String column = field.getName();if (column.equals("id")) {continue;}System.out.println(Tool.humpToLine(column));sql.SET(Tool.humpToLine(column) + "=" + String.format("#{" + column + ",jdbcType=VARCHAR}")); }List<Field> primaryKeyField = getPrimarkKeyFields(clazz);if (!primaryKeyField.isEmpty()) {for (Field pkField : primaryKeyField) {pkField.setAccessible(true);sql.WHERE(pkField.getName() + "=" + String.format("#{" + pkField.getName() + "}"));}} else {sql.WHERE(" 1= 2");throw new RuntimeException("对象中未包含PrimaryKey属性");}System.out.println("updateSql:"+sql.toString());return sql.toString();}}步骤4:编写BaseMapper基类接⼝public interface BaseMapper<T> {//新增⼀条数据@InsertProvider(method = "add",type=BaseSqlProvider.class)@Options(useGeneratedKeys=true)public int add(T bean);//根据主键删除⼀条数据@DeleteProvider(method = "delete",type=BaseSqlProvider.class)public int delete(T bean);//根据主键获取⼀条数据@SelectProvider(method = "get",type=BaseSqlProvider.class)public T get(T bean);//修改⼀条数据@UpdateProvider(method = "update",type=BaseSqlProvider.class)public int update(T bean);}说明：@InsertProvider注解中的type指明⾃定义的SQL⼯⼚类，method是⼯⼚类⾥对应的⽅法,⽅法返回的是对⽅的sql语句到这⾥基类以及它的配置就完成了,接下来,可以使⽤了举例:编写⼀个TPermissionMapper接⼝,实现BaseMapper类,并传⼊⼀个泛型参数,此时这个TPermissionMapper接⼝已经具备了,BaseMapper中基本的增/删/改/查功能.同时TPermissionMapper还可以再写⾃⼰独有的⽅法和mapper.xml⽂件对功能进⾏扩展public interface TPermissionMapper extends BaseMapper<TPermissionEntity>{//List<TPermissionEntity> queryByPage();}在controller当中的应⽤:@Controllerpublic class LoginController {@Autowiredprivate TPermissionMapper tPermissionMapper;//新增@ResponseBody@RequestMapping(value = "/add")public Integer add() {TPermissionEntity permissionEntiry = new TPermissionEntity();permissionEntiry.setName("test");permissionEntiry.setType(3);Integer num = tPermissionMapper.add(permissionEntiry);return num;}//修改@ResponseBody@RequestMapping(value = "/update")public Integer update() {TPermissionEntity permissionEntiry = new TPermissionEntity();permissionEntiry.setId(23);permissionEntiry.setName("test");permissionEntiry.setType(3);Integer num = tPermissionMapper.update(permissionEntiry);return num;}//查询@ResponseBody@RequestMapping(value = "/query")public TPermissionEntity query() {TPermissionEntity tPermissionEntity = new TPermissionEntity();tPermissionEntity.setId(23);tPermissionEntity= (TPermissionEntity) tPermissionMapper.get(tPermissionEntity);return tPermissionEntity;}//删除@ResponseBody@RequestMapping(value = "/delete")public Integer delete() {TPermissionEntity permissionEntiry = new TPermissionEntity();permissionEntiry.setId(22);Integer num = tPermissionMapper.delete(permissionEntiry);return num;}}到此这篇关于mybatis抽取基类BaseMapper增删改查的实现的⽂章就介绍到这了,更多相关mybatis BaseMapper增删改查内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

Mybatis-Plus通用MapperCRUD之update

Mybatis-Plus通⽤MapperCRUD之update mybatis-plus框架提供了两个更新⽅法：/*** 根据 ID 修改** @param entity 实体对象*/int updateById(@Param(Constants.ENTITY) T entity);/*** 根据 whereEntity 条件，更新记录** @param entity 实体对象 (set 条件值,可以为 null)* @param updateWrapper 实体对象封装操作类（可以为 null,⾥⾯的 entity ⽤于⽣成 where 语句）*/int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);我们先讲这个updateById，update⽅法后⾯讲条件构造器再讲；实例：@Testpublic void updateById(){Department department=new Department();department.setId(10);department.setName("总经理办公室");department.setRemark("⽼⼤");int affectRows = departmentMapper.updateById(department);if(affectRows>0){System.out.println("更新成功");}else{System.out.println("更新失败");}}------------------------------------------------------------------------------------------------------------------------------作者：ava1234_⼩锋出处：版权：本站使⽤「」创作共享协议，转载请在⽂章明显位置注明作者及出处。