基于MyBatis注解扩展,实现无需配置就可拥有增删改

简介: 一、使用篇      如果项目本身基于SpringMVC+Mybatis构建,不需添加任何配置Mapper类只需继承BaseMapper,即拥有增删改方法操作,无需任何配置文件   package com.

一、使用篇

      如果项目本身基于SpringMVC+Mybatis构建,不需添加任何配置Mapper类只需继承

BaseMapper,即拥有增删改方法操作,无需任何配置文件

  1.    

    package com.springmvc.mapper;
    
    import org.springframework.stereotype.Repository;
    
    import com.nmtx.mybatis.ext.mapper.BaseMapper;
    import com.springmvc.model.User;
    @Repository
    public interface UserMapper extends BaseMapper<User>{
    
    }
    
  2. package com.springmvc.service.impl;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Service;
    
    import com.springmvc.mapper.UserMapper;
    import com.springmvc.model.User;
    import com.springmvc.service.UserService;
    
    
    @Service
    public class UserServiceImpl implements UserService{
        
        @Resource
        private UserMapper userMapper;
        
        public int insertUser(User user) {
            return userMapper.insert(user);
        }
    
        @Override
        public int updateUser(User user) {
            return userMapper.update(user);
        }
    
        @Override
        public int deleteUser(User user) {
            return userMapper.delete(user);
        }
    
        @Override
        public User findUser(User user) {
            return userMapper.findFirst(user);
        }
    }
  3. user.xml无需任何配置<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.springmvc.mapper.UserMapper">
             
    </mapper>

二、扩展原理基于Mybatis中 @InsertProvider,@DeleteProvider,@UpdateProvider,@SelectProvider注解,具体实现代码如下

  1. package com.nmtx.mybatis.ext.mapper;
    
    import org.apache.ibatis.annotations.DeleteProvider;
    import org.apache.ibatis.annotations.InsertProvider;
    import org.apache.ibatis.annotations.Options;
    import org.apache.ibatis.annotations.SelectProvider;
    import org.apache.ibatis.annotations.UpdateProvider;
    
    import com.nmtx.mybatis.ext.common.SqlProvider;
    
    public interface BaseMapper<T> {
    
        @InsertProvider(type = SqlProvider.class, method = "insert")
        @Options(useGeneratedKeys=true)
        public int insert(T bean);
    
        @DeleteProvider(type = SqlProvider.class, method = "delete")
        public int delete(T bean);
    
        @UpdateProvider(type = SqlProvider.class, method = "update")
        public int update(T bean);
    
        @SelectProvider(type = SqlProvider.class, method = "findFirst")
        public T findFirst(T bean);
    }

     

  2. package com.nmtx.mybatis.ext.common;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.apache.commons.lang3.ArrayUtils;
    import org.springframework.util.StringUtils;
    
    import com.nmtx.mybatis.ext.common.table.TableFormat;
    import com.nmtx.mybatis.ext.common.table.annotation.Column;
    import com.nmtx.mybatis.ext.common.table.annotation.Table;
    import com.nmtx.mybatis.ext.common.table.impl.HumpToUnderLineFormat;
    
    public class SqlProvider {
        
        
        private TableFormat tableFormat = new HumpToUnderLineFormat();
    
        public String insert(Object bean) {
            Class<?> beanClass = bean.getClass();
            String tableName = getTableName(beanClass);
            Field[] fields = getFields(beanClass);
            StringBuilder insertSql = new StringBuilder();
            List<String> insertParas = new ArrayList<String>();
            List<String> insertParaNames = new ArrayList<String>();
            insertSql.append("INSERT INTO ").append(tableName).append("(");
            try {
                for (int i = 0; i < fields.length; i++) {
                    Field field = fields[i];
                    Column column = field.getAnnotation(Column.class);
                    String columnName = "";
                    if (column != null) {
                        if (!column.required())
                            continue;
                        columnName = column.value();
                    }
                    if (StringUtils.isEmpty(columnName)) {
                        columnName = tableFormat.getColumnName(field.getName());
                    }
                    field.setAccessible(true);
                    Object object = field.get(bean);
                    if (object != null) {
                        insertParaNames.add(columnName);
                        insertParas.add("#{" + field.getName() + "}");
                    }
                }
            } catch (Exception e) {
                new RuntimeException("get insert sql is exceptoin:" + e);
            }
            for (int i = 0; i < insertParaNames.size(); i++) {
                insertSql.append(insertParaNames.get(i));
                if (i != insertParaNames.size() - 1)
                    insertSql.append(",");
            }
            insertSql.append(")").append(" VALUES(");
            for (int i = 0; i < insertParas.size(); i++) {
                insertSql.append(insertParas.get(i));
                if (i != insertParas.size() - 1)
                    insertSql.append(",");
            }
            insertSql.append(")");
            return insertSql.toString();
        }
    
        public String update(Object bean) {
            Class<?> beanClass = bean.getClass();
            String tableName = getTableName(beanClass);
            Field[] fields = getFields(beanClass);
            StringBuilder updateSql = new StringBuilder();
            updateSql.append(" update ").append(tableName).append(" set ");
            try {
                for (int i = 0; i < fields.length; i++) {
                    Field field = fields[i];
                    Column column = field.getAnnotation(Column.class);
                    String columnName = "";
                    if (column != null) {
                        if (!column.required())
                            continue;
                        columnName = column.value();
                    }
                    if (StringUtils.isEmpty(columnName)) {
                        columnName = tableFormat.getColumnName(field.getName());
                    }
                    field.setAccessible(true);
                    Object beanValue = field.get(bean);
                    if (beanValue != null) {
                        updateSql.append(columnName).append("=#{").append(field.getName()).append("}");
                        if (i != fields.length - 1) {
                            updateSql.append(",");
                        }
                    }
                }
            } catch (Exception e) {
                new RuntimeException("get update sql is exceptoin:" + e);
            }
            updateSql.append(" where ").append(tableFormat.getId()+" =#{id}");
            return updateSql.toString();
        }
    
        public String delete(Object bean) {
            Class<?> beanClass = bean.getClass();
            String tableName = getTableName(beanClass);
            Field[] fields = getFields(beanClass);
            StringBuilder deleteSql = new StringBuilder();
            deleteSql.append(" delete from ").append(tableName).append(" where  ");
            try {
                for (int i = 0; i < fields.length; i++) {
                    Field field = fields[i];
                    Column column = field.getAnnotation(Column.class);
                    String columnName = "";
                    if (column != null) {
                        if (!column.required())
                            continue;
                        columnName = column.value();
                    }
                    if (StringUtils.isEmpty(columnName)) {
                        columnName = tableFormat.getColumnName(field.getName());
                    }
                    field.setAccessible(true);
                    Object beanValue = field.get(bean);
                    if (beanValue != null) {
                        deleteSql.append(columnName).append("=#{").append(field.getName()).append("}");
                        if (i != fields.length - 1) {
                            deleteSql.append(" and ");
                        }
                    }
                }
            } catch (Exception e) {
                new RuntimeException("get delete sql is exceptoin:" + e);
            }
            return deleteSql.toString();
        }
    
        public String findFirst(Object bean) {
            Class<?> beanClass = bean.getClass();
            String tableName = getTableName(beanClass);
            Field[] fields = getFields(beanClass);
            StringBuilder selectSql = new StringBuilder();
            List<String> selectParaNames = new ArrayList<String>();
            List<String> selectParas = new ArrayList<String>();
            selectSql.append("select ");
            try {
                for (int i = 0; i < fields.length; i++) {
                    Field field = fields[i];
                    Column column = field.getAnnotation(Column.class);
                    String columnName = "";
                    if (column != null) {
                        if (!column.required())
                            continue;
                        columnName = column.value();
                    }
                    if (StringUtils.isEmpty(columnName)) {
                        columnName = tableFormat.getColumnName(field.getName());
                    }
                    field.setAccessible(true);
                    Object object = field.get(bean);
                    selectSql.append(field.getName());
                    if (object != null) {
                        selectParaNames.add(columnName);
                        selectParas.add("#{" + field.getName() + "}");
                    }
                    if (i != fields.length - 1)
                        selectSql.append(",");
                }
            } catch (Exception e) {
                new RuntimeException("get select sql is exceptoin:" + e);
            }
            selectSql.append(" from ").append(tableName).append(" where ");
            for (int i = 0; i < selectParaNames.size(); i++) {
                selectSql.append(selectParaNames.get(i)).append("=").append(selectParas.get(i));
                if (i != selectParaNames.size() - 1)
                    selectSql.append(" and ");
            }
            return selectSql.toString();
        }
    
        private String getTableName(Class<?> beanClass) {
            String tableName = "";
            Table table = beanClass.getAnnotation(Table.class);
            if (table != null) {
                tableName = table.value();
            } else {
                tableName = tableFormat.getTableName(beanClass.getSimpleName());
            }
            return tableName;
        }
    
        private Field[] getFields(Class<?> beanClass) {
            Field[] beanFields = beanClass.getDeclaredFields();
            Class<?> beanSuperClass = beanClass.getSuperclass();
            Field[] beanSuperFields = beanSuperClass.getDeclaredFields();
            return ArrayUtils.addAll(beanFields, beanSuperFields);
        }
    }
相关文章
|
8天前
|
SQL Java 数据库连接
【MyBatisPlus·最新教程】包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段
MyBatis-Plus是一个MyBatis的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。本文讲解了最新版MP的使用教程,包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段等核心功能。
【MyBatisPlus·最新教程】包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段
|
18天前
|
SQL 缓存 Java
MyBatis如何关闭一级缓存(分注解和xml两种方式)
MyBatis如何关闭一级缓存(分注解和xml两种方式)
52 5
|
18天前
|
Java 数据库连接 mybatis
Mybatis使用注解方式实现批量更新、批量新增
Mybatis使用注解方式实现批量更新、批量新增
39 3
|
24天前
|
SQL 存储 数据库
深入理解@TableField注解的使用-MybatisPlus教程
`@TableField`注解在MyBatis-Plus中是一个非常灵活和强大的工具,能够帮助开发者精细控制实体类与数据库表字段之间的映射关系。通过合理使用 `@TableField`注解,可以实现字段名称映射、自动填充、条件查询以及自定义类型处理等高级功能。这些功能在实际开发中,可以显著提高代码的可读性和维护性。如果需要进一步优化和管理你的MyBatis-Plus应用程
105 3
|
23天前
|
Java 数据库连接 mybatis
Mybatis使用注解方式实现批量更新、批量新增
Mybatis使用注解方式实现批量更新、批量新增
41 1
|
2月前
|
SQL XML Java
mybatis复习02,简单的增删改查,@Param注解多个参数,resultType与resultMap的区别,#{}预编译参数
文章介绍了MyBatis的简单增删改查操作,包括创建数据表、实体类、配置文件、Mapper接口及其XML文件,并解释了`#{}`预编译参数和`@Param`注解的使用。同时,还涵盖了resultType与resultMap的区别,并提供了完整的代码实例和测试用例。
mybatis复习02,简单的增删改查,@Param注解多个参数,resultType与resultMap的区别,#{}预编译参数
|
2月前
|
SQL XML Java
mybatis复习01,简单配置让mybatis跑起来
文章介绍了MyBatis的基本概念、历史和特点,并详细指导了如何配置MyBatis环境,包括创建Maven项目、添加依赖、编写核心配置文件、创建数据表和实体类、编写Mapper接口和XML配置文件,以及如何编写工具类和测试用例。
mybatis复习01,简单配置让mybatis跑起来
|
2月前
|
Java 数据库连接 数据格式
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
IOC/DI配置管理DruidDataSource和properties、核心容器的创建、获取bean的方式、spring注解开发、注解开发管理第三方bean、Spring整合Mybatis和Junit
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
|
3月前
|
安全 Java 数据库连接
后端框架的学习----mybatis框架(3、配置解析)
这篇文章详细介绍了MyBatis框架的核心配置文件解析,包括环境配置、属性配置、类型别名设置、映射器注册以及SqlSessionFactory和SqlSession的生命周期和作用域管理。
后端框架的学习----mybatis框架(3、配置解析)
|
2月前
|
SQL XML Java
mybatis :sqlmapconfig.xml配置 ++++Mapper XML 文件(sql/insert/delete/update/select)(增删改查)用法
当然,这些仅是MyBatis功能的初步介绍。MyBatis还提供了高级特性,如动态SQL、类型处理器、插件等,可以进一步提供对数据库交互的强大支持和灵活性。希望上述内容对您理解MyBatis的基本操作有所帮助。在实际使用中,您可能还需要根据具体的业务要求调整和优化SQL语句和配置。
45 1