mybatis通用DAO

最新推荐文章于 2024-03-22 11:45:34 发布
最新推荐文章于 2024-03-22 11:45:34 发布
阅读量1.1w 收藏 10
点赞数 1
分类专栏： MyBatis 文章标签： orm mybatis 分页 数据库 扩展

扫扫关注“茶爸爸”微信公众号
坚持最初的执着，从不曾有半点懈怠，为优秀而努力，为证明自己而活。
回复：茶爸爸了解他这个人！！

花了几天的时间研究了一下mybatis的源代码，觉得这个框架还是很不错的。但是有一些缺陷的地方。

先来说说它和别的框架比起来我认为的好处：

          （1）sql外置，把sql文件写在配置文件中加上强大的动态sql支持。

          （2）利用cjk动态代理，实现配置文件映射接口。

这样我们在使用这套orm框架的时候就可以不再写那个拼接sql语句的dao实现类（dao-impl class），把dao实现类的工作都移交给那些*mapper.xml文件，如果数据库查询业务需要修改sql的话，那么只需要修改xml文件中的sql语句。

需要扩展的地方：

          （1）没有内置物理分页的实现。

我们一般的习惯都是返回我们自己的分页实现类，网上大多的mybatis分页实现都是先返回分页列表，再查下返回总页数，然后处理成我们自己的分页类。我自己也写了一个分页，把这部分工作交给mybatis来处理，以后会把代码贴出来。

           （2）公用范型接口dao

公用范型接口dao类几乎成为我们开发中最长使用的，把一些长操作的方法封装一下，供我们的业务dao调用，但是在mybatis中，我现在不想再写dao的实现类，只有接口类，取缔他的是mapper-xml文件，这样如何才能封装我们的公用方法呢。

幸好mybatis提供了插件拦截器，我们可以在不修改mybatis源码的基础上来扩展它的功能。

 

好忙啊，花了些时间写了一个范型接口dao，还没有经过验证，先贴上代码。

使用方法很简单，只要你使用MappInterceptor这个拦截器，在你的Mapper接口中继承这个IGenericDao这样 公用的方法就可以使用了，这样的好处是在一般业务的类中不用再写Dao的实现，直接使用 IGenericDao中提供的方法就ok

 

 

公用dao，你的接口只要继承这个dao就可以使用里面的方法。

 

package org.cf.guott.mybatis;

import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.cf.guott.mybatis.pagination.PageMyBatis;

public interface IGenericDao<T,PK> {
  
  @Select("MapperGD.find.entityById")
  public T findEntityById(PK id);
  
  @Select("MapperGD.find.entitys")
  public List<T> findEntity(Object... obj);
  
  @Select("MapperGD.find.ListByLike")
  public List<T> findLikeEntity(Object... obj);
  
  @Insert("MapperGD.insert.entity")
  public void insertEntity(T t);
  
  @Update("MapperGD.update.entity")
  public void updateEntityById(T entity);
  
  @Delete("MapperGD.delete.id")
  public void deleteById(PK id);
  
  @Delete("MapperGD.delete.condition")
  public void deleteByCondition(Object param);
  
  @Select("MapperGD.find.entity.queryByVo")
  public PageMyBatis<T> queryByVo(int i,int c,Object... obj);
  
  @Select("MapperGD.find.entity.queryByVoLike")
  public PageMyBatis<T> LikequeryByVo(int i,int c,Object... obj);
  
  
}
 

 

 

 这个一个拦截器，来处理你的公用dao中的方法

package org.cf.guott.mybatis.dbmapper.interceptor;

import java.util.Map;
import java.util.Properties;

import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.cf.guott.mybatis.helpers.MapperSqlHelper;
import org.cf.guott.mybatis.pagination.MappedStatmentHelper;

  @Intercepts({
    @Signature(
          type = Executor.class,
          method = "query",
          args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
      ,@Signature(
          type = Executor.class,
          method = "update",
          args = {MappedStatement.class, Object.class})
  })
  
  public class MappInterceptor implements Interceptor{
    private final static String _sql_regex = ".*MapperGD.*";
    
    @SuppressWarnings("unchecked")
    private void processIntercept(final Object[] queryArgs) {
      final MappedStatement ms = (MappedStatement) queryArgs[0];
      final Object parameter = queryArgs[1];
      String mapperSQL = ms.getBoundSql(parameter).getSql();
      BoundSql boundSQL = ms.getBoundSql(parameter);
      
      Class<?> entityclazz = MappedStatmentHelper.getEntityClazz(ms.getResource());
      queryArgs[0] = MappedStatmentHelper.setMSReturnSetMap(ms, entityclazz);
      
      boolean interceptor = mapperSQL.matches(_sql_regex);
      if(!interceptor){
        return;
      }
      if(entityclazz == null){
        throw new RuntimeException("使用公共dao必須給mapper接口的@MyBatisRepository(User.class) 注解設置值.");
      }
      
      String new_sql = MapperSqlHelper.getExecuSQL(entityclazz,mapperSQL,parameter);
      
      BoundSql newBoundSql = MappedStatmentHelper.copyFromBoundSql(ms,
          boundSQL, new_sql);
      MappedStatement newMs = MappedStatmentHelper
          .copyFromMappedStatement(ms, newBoundSql);
      queryArgs[0] = newMs;
      
    }
    public Object intercept(Invocation invocation) throws Throwable {
      
      processIntercept(invocation.getArgs());
      
      return invocation.proceed();
    }
    public Object plugin(Object o) {
          return Plugin.wrap(o, this);
    }
    public void setProperties(Properties arg0) {
    }
  }
  这个类来处理你的sql语句 
package org.cf.guott.mybatis.helpers;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;

import org.apache.commons.lang3.reflect.FieldUtils;
import org.cf.guott.mybatis.annotation.MyBatisColumn;
import org.cf.guott.mybatis.annotation.MyBatisRepository;
import org.cf.guott.mybatis.annotation.MybatisID;
import org.cf.guott.mybatis.annotation.MybatisTable;
import org.cf.guott.mybatis.entity.User;

public class MapperSqlHelper{

  public static final Class<? extends Annotation> MYBATISREPOSITORY = MyBatisRepository.class;
  public static final Class<? extends Annotation> MYBATISTABLE = MybatisTable.class;
  public static final Class<? extends Annotation> MYBATISCOLUMN = MyBatisColumn.class;
  public static final Class<? extends Annotation> MYBATISID = MybatisID.class;
  
  
  public  String getUpdateSQL(){
    return null;
  }
  /**
   * 传入mapper接口class
   * @param mapperclazz
   * @return
   */
  private String insertEntity(Class<?> clazz){
    StringBuilder sql = new StringBuilder();
    StringBuilder intosql = new StringBuilder();
    StringBuilder valuessql = new StringBuilder();
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("INSERT INTO "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("INSERT INTO "+clazz.getName());
      }else{
        sql.append("INSERT INTO "+antable.value());
      }
    }
    Field[] files = clazz.getDeclaredFields();
    intosql.append("(");
    for(Field file : files){
      file.setAccessible(true);
      if(file.isAnnotationPresent(MYBATISCOLUMN)){
        MyBatisColumn anColumn = (MyBatisColumn)file.getAnnotation(MYBATISCOLUMN);
        if(!anColumn.isAutoKey()){
          if(anColumn.value().equals("")){
            intosql.append(file.getName()+",");
          }else{
            intosql.append(anColumn.value()+",");
          }
        }
      }else{
        intosql.append(file.getName()+",");
      }
    }
    valuessql.append(" values (");
    for(Field file : files){
      file.setAccessible(true);
      if(file.isAnnotationPresent(MYBATISCOLUMN)){
        MyBatisColumn anColumn = (MyBatisColumn)file.getAnnotation(MYBATISCOLUMN);
        if(!anColumn.isAutoKey()){
          if(anColumn.value().equals("")){
            valuessql.append("#{"+file.getName()+"},");
          }else{
            valuessql.append("#{"+file.getName()+"},");
          }
        }
      }else{
        valuessql.append("#{"+file.getName()+"},");
      }
      
    }
    return sql.append(intosql.substring(0, intosql.length()-1)).append(") ").append(valuessql.substring(0, valuessql.length()-1)).append(")").toString();
  }
  
  /**
   * 传入mapper接口class
   * @param mapperclazz
   * @return
   */
  private  String updateEntityById(Class<?> clazz){
    StringBuilder sql = new StringBuilder();
    StringBuilder set = new StringBuilder();
    StringBuilder wheresql = new StringBuilder();
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("UPDATE  "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("UPDATE  "+clazz.getName());
      }else{
        sql.append("UPDATE  "+antable.value());
      }
    }
    Field[] files = clazz.getDeclaredFields();
    set.append(" set ");
    wheresql.append(" where 1=1 ");
    for(Field file : files){
      file.setAccessible(true);
      if(file.isAnnotationPresent(MYBATISCOLUMN)){
        MyBatisColumn anColumn = (MyBatisColumn)file.getAnnotation(MYBATISCOLUMN);
        if(!anColumn.isID()){//判断字段不为主键
          if(anColumn.value().equals("")){
            set.append(file.getName()+" = #{"+file.getName()+"} ,");
          }else{
            set.append(anColumn.value()+" = #{"+file.getName()+"} ,");
          }
        }else{
          if(anColumn.value().equals("")){
            wheresql.append(" and "+file.getName()+" = #{"+file.getName()+"},");
          }else{
            wheresql.append(" and "+anColumn.value()+" = #{"+anColumn.value()+"},");
          }
        }
      }else{
        set.append(file.getName()+" = #{"+file.getName()+"} ,");
      }
    }
    if(wheresql.equals(" where 1=1 ")){
      throw new RuntimeException("实体变量没有设置ID字段值");
    }
    sql.append(set.substring(0, set.length()-1)).append(wheresql.substring(0, wheresql.length()-1));
    return sql.toString();
  }
  private String findEntityAll(Class<?> clazz,Object args,boolean islike){
    StringBuilder sql = new StringBuilder();
    StringBuilder whereSQL = new StringBuilder(" where 1=1 ");
    StringBuffer orderby = new StringBuffer();
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("select * from  "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("select * from  "+clazz.getSimpleName());
      }else{
        sql.append("select * from  "+antable.value());
      }
    }
    Object[] paramObjs = (Object[]) ((Map)args).get("array");
    if(paramObjs != null && paramObjs.length>0){
      Object param = paramObjs[0];
      if(param != null ){
        if(param instanceof Map){
          Map<String,Object> map = (Map)param;
          if(map.containsKey("orderby")){
            orderby.append(" order by "+map.get("orderby"));
          }
          if(map.containsKey("sortby")){
            orderby.append(" "+map.get("sortby")+" ");
          }
          for(String key : map.keySet())
          {
            if(islike)
            whereSQL.append(" and "+key + " like '%" + map.get(key)+"%',");
            else whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
          }
          sql.append(whereSQL.subSequence(0,whereSQL.length()-1)).append(orderby);
        }else if(param instanceof Conditions){
          Conditions<String,Object> map = (Conditions)param;
          if(map.containsKey("orderby")){
            orderby.append(" order by "+map.get("orderby"));
          }
          if(map.containsKey("sortby")){
            orderby.append(" "+map.get("sortby")+" ");
          }
          for(String key : map.keySet())
          {
            if(key.equals("orderby") || key.equals("sortby")){
              continue;
            }
            if(islike)
            whereSQL.append(" and "+key + " like '%" + map.get(key)+"%',");
            else whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
          }
          sql.append(whereSQL.subSequence(0,whereSQL.length()-1)).append(orderby);
        }
      }
    }
    return sql.toString();
  }
  private String findEntityById(Class<?> clazz){
    StringBuilder sql = new StringBuilder();
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("select * from  "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("select * from  "+clazz.getSimpleName());
      }else{
        sql.append("select * from  "+antable.value());
      }
    }
    sql.append("  where 1=1 ");
    Field[] files = clazz.getDeclaredFields();
    boolean falg = false;
    for(Field file : files){
      file.setAccessible(true);
      if(file.isAnnotationPresent(MyBatisColumn.class)){
        MyBatisColumn anColumn = (MyBatisColumn)file.getAnnotation(MYBATISCOLUMN);
        if(anColumn.isID()){//判断字段不为主键
          falg = true;
          if(anColumn.value().equals("")){
            sql.append(" and "+file.getName()+" = #{"+file.getName()+"},");
          }else{
            sql.append(" and "+file.getName()+" = #{"+file.getName()+"},");
          }
        }
      }
    }
    if(!falg){
      throw new RuntimeException("不能通過id查詢實體,實體中沒有定義@mybatisID");
    }
    
    return sql.subSequence(0, sql.length()-1).toString();
  }
  public String deleteById(Class<?> clazz){
    StringBuilder sql = new StringBuilder();
    StringBuilder wheresql = new StringBuilder(" where 1=1 ");
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("delete  "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("delete  "+clazz.getName());
      }else{
        sql.append("delete  "+antable.value());
      }
    }
    Field[] files = clazz.getDeclaredFields();
    for(Field file : files){
      file.setAccessible(true);
      if(file.isAnnotationPresent(MYBATISCOLUMN)){
        MyBatisColumn anColumn = (MyBatisColumn)file.getAnnotation(MYBATISCOLUMN);
        if(anColumn.isID()){//判断字段不为主键
          if(anColumn.value().equals("")){
            wheresql.append(" and "+file.getName()+" = #{"+file.getName()+"},");
          }else{
            wheresql.append(" and "+anColumn.value()+" = #{"+anColumn.value()+"},");
          }
        }
      }
    }
    if(wheresql.equals(" where 1=1 ")){
      throw new RuntimeException("实体变量没有设置ID字段值");
    }
    sql.append(wheresql.substring(0,wheresql.length()-1));
    return sql.toString();
  }
  public String queryByVo(Class<?> clazz,Object args,boolean islike){
    StringBuilder sql = new StringBuilder();
    StringBuilder whereSQL = new StringBuilder(" where 1=1 ");
    StringBuilder orderbySQL = new StringBuilder("");
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("select *  from "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("select * from "+clazz.getName());
      }else{
        sql.append("select * from "+antable.value());
      }
    }
    if(args instanceof Map){
      Map map = (Map)args;
      Object[] arr = (Object[])map.get("param3");
      if(arr.length>0){
        Map<String,Object> params = (Map)arr[0];
        if(params.containsKey("orderby")){
          orderbySQL.append(" order by "+params.get("orderby"));
        }
        if(params.containsKey("sortby")){
          orderbySQL.append(" "+params.get("sortby")+" ");
        }
        for(String key:params.keySet()){
          if(key.equals("orderby") || key.equals("sortby")){
            continue;
          }
          if(islike)
            whereSQL.append(" and "+key + " like '%" + params.get(key)+"%',");
            else whereSQL.append(" and "+key + " = '" + params.get(key)+"',");
        }
      }
    }
    
    return sql.append(whereSQL.substring(0, whereSQL.length()-1)).append(orderbySQL).toString();
  }
  public String count(Class<?> clazz,Object args){
    StringBuilder sql = new StringBuilder();
    StringBuilder whereSQL = new StringBuilder(" where 1=1 ");
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("select count(*)  from "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("select count(*) from "+clazz.getName());
      }else{
        sql.append("select count(*) from "+antable.value());
      }
    }
    Object[] paramObjs = (Object[]) ((Map)args).get("array");
    if(paramObjs != null && paramObjs.length>0){
      Object param = paramObjs[0];
      if(param != null ){
        if(param instanceof Map){
          Map<String,Object> map = (Map)param;
          for(String key : map.keySet())
          {
            whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
          }
          sql.append(whereSQL.subSequence(0,whereSQL.length()-1));
        }else if(param instanceof Conditions){
          Conditions<String,Object> map = (Conditions)param;
          for(String key : map.keySet())
          {
            whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
          }
          sql.append(whereSQL.subSequence(0,whereSQL.length()-1));
        }
      }
    }
    return sql.toString();
  }
  public String deleteByCondition(Class<?> clazz,Object param){
    StringBuilder sql = new StringBuilder();
    StringBuilder whereSQL = new StringBuilder(" where 1=1 ");
    if(!clazz.isAnnotationPresent(MYBATISTABLE)){
      sql.append("delete  "+clazz.getName());
    }else{
      MybatisTable antable = (MybatisTable)clazz.getAnnotation(MYBATISTABLE);
      if(antable.value() == ""){
        sql.append("delete  "+clazz.getName());
      }else{
        sql.append("delete  "+antable.value());
      }
    }
    if(param != null ){
      if(param instanceof Map){
        Map<String,Object> map = (Map)param;
        for(String key : map.keySet())
        {
          whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
        }
        sql.append(whereSQL.subSequence(0,whereSQL.length()-1));
      }else if(param instanceof Conditions){
        Conditions<String,Object> map = (Conditions)param;
        for(String key : map.keySet())
        {
          whereSQL.append(" and "+key + " = '" + map.get(key)+"',");
        }
        sql.append(whereSQL.subSequence(0,whereSQL.length()-1));
      }
    }
    if(whereSQL.equals(" where 1=1 ")){
      throw new RuntimeException("实体变量没有设置ID字段值");
    }
    return sql.toString();
  }
  private static MapperSqlHelper App(){
    return new MapperSqlHelper();
  }
  public static String getExecuSQL(Class<?> clazz, String mapperDBsql,Object param) {
    if(mapperDBsql.equals("MapperGD.find.entitys")){
      return MapperSqlHelper.App().findEntityAll(clazz,param,false);//条件查询实体列表
    }else if(mapperDBsql.equals("MapperGD.find.entityById")){
      return MapperSqlHelper.App().findEntityById(clazz);//id查询实体
    }else if(mapperDBsql.equals("MapperGD.find.ListByLike")){
      return MapperSqlHelper.App().findEntityAll(clazz,param,true);//条件查询实体列表
    }else if(mapperDBsql.equals("MapperGD.insert.entity")){
      return MapperSqlHelper.App().insertEntity(clazz);//保存单一实体
    }else if(mapperDBsql.equals("MapperGD.update.entity")){
      return MapperSqlHelper.App().updateEntityById(clazz);//保存单一实体
    }else if(mapperDBsql.equals("MapperGD.update.entity.condistion")){
      return mapperDBsql;
    }else if(mapperDBsql.equals("MapperGD.delete.id")){
      return MapperSqlHelper.App().deleteById(clazz);
    }else if(mapperDBsql.equals("MapperGD.delete.condition")){
      return MapperSqlHelper.App().deleteByCondition(clazz,param);
    }else if(mapperDBsql.equals("MapperGD.count.condition")){
      return MapperSqlHelper.App().count(clazz,param);
    }else if(mapperDBsql.equals("MapperGD.find.entity.queryByVo")){
      return MapperSqlHelper.App().queryByVo(clazz,param,false);
    }else if(mapperDBsql.equals("MapperGD.find.entity.queryByVoLike")){
      return MapperSqlHelper.App().queryByVo(clazz,param,true);
    }
    return null;
  }
  //预留接口
  private  String updateEntityByConditions(Class<?> clazz,Object param){
    
    return null;
  }
  public void getParam(Object param){
    StringBuffer bf = new StringBuffer();
    if (isPrimitiveType(param.getClass())) {
      bf.append(param);
        } else if (param instanceof Map) {
        	Map<String,Object> map = (Map)param;
        } 
  }
  
  public static boolean isPrimitiveType(Class clazz) {
        return clazz != null && (clazz.isPrimitive() || clazz.equals(Long.class) || clazz.equals(Integer.class)
                || clazz.equals(Short.class) || clazz.equals(Byte.class) || clazz.equals(Double.class)
                || clazz.equals(Float.class) || clazz.equals(Boolean.class) || clazz.equals(Character.class) || clazz.equals(String.class));
    }
  public static void main(String[] args) {
//		Object object = null;
//		if (isPrimitiveType(object.getClass())) {
//        } else if (object instanceof Map) {
//        } 
    Field[] files = User.class.getDeclaredFields();
    User u = new User();
    try {
      System.out.println(FieldUtils.readDeclaredField(u, "id",true));
    } catch (IllegalAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}
 测试用例：

 

业务dao,这个接口继承自 IGenericDao

package org.cf.guott.mybatis.mapper;

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

import org.apache.ibatis.annotations.Select;
import org.cf.guott.mybatis.ITestGDAO;
import org.cf.guott.mybatis.annotation.MyBatisRepository;
import org.cf.guott.mybatis.entity.User;
import org.cf.guott.mybatis.pagination.PageMyBatis;

@MyBatisRepository(User.class)
public interface UserMapper extends IGenericDao<User,Integer>{

}
 main运行方法 
package org.cf.guott.mybatis.main;

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

import org.apache.ibatis.session.RowBounds;
import org.cf.guott.mybatis.entity.User;
import org.cf.guott.mybatis.helpers.Conditions;
import org.cf.guott.mybatis.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class Main {
  @Autowired
  UserMapper userMapper;
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-mybatis.xml");
    Main main = context.getBean(Main.class);
    Map map = new HashMap();
    map.put("name", "ccc");
    List<User> users = main.userMapper.LikequeryByVo(0,2,new Conditions<String, Object>().add("name", "guotiantdddian").addOrderBy("id").setSortByDesc());
    System.out.println(users.size());
  }
}

阿奇XS
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Mybatis通用Dao
12-05
现在越来越多的开发者使用MyBatis作为ORM的框架，它开发迅速，上手容易，开源代码多...因此本人一直想寻找一个类似hibernate一样的通用数据库管理Dao，采用spring注入的方式即可。现在已创建项目的方式和大家一起分享。
完美的mybatis通用dao实现（转载）
简单点，编程的方式简单点
03-04 546
场景： 项目中用到mybatis(版本3.3.2)。对于单表操作，我们一开始是手写各个sql。但是这样接口非常不一致，而且有太多的小接口，不方便将相似功能合并。而且由于实现不一致，不能只根据接...
MyBatis-Plus 实用工具：SqlHelper 让你的数据库操作更得心应手
最新发布
Hi_alan的博客
03-22 278
SqlHelper 是MyBatis-Plus的一款SQL 辅助工具类，提供了一些常用的方法，简便我们的操作，提高开发效率。
Mybatis传统方式实现Dao层与接口代理方式实现dao
weixin_61611746的博客
10-05 521
分层思想：控制层(controller)、业务层(service)、持久层(dao)。调用流程：控制层→业务层→持久层→DB。
Mybatis 中的 @Repository 与 @Mapper
ONESTARの博客
03-27 2568
1 - @Mapper @Mapper 是 Mybatis 的注解，和 Spring 没有关系，@Repository 是 Spring 的注解，用于声明一个 Bean。（重要） 使用 Mybatis 有 XML 文件或者注解的两种使用方式，如果是使用 XML 文件的方式，我们需要在配置文件中指定 XML 的位置，这里只研究注解开发的方式。 在 Spring 程序中，Mybatis 需要找到对应...
MyBatis通用dao和通用service
弹指天下
08-27 1万+
更新于2015/01/29，增加了第三种方法 ##更新于2015/02/09，第三种方法方法改进，service实现上不需要加泛型 概述： 使用通用dao和通用service可以减少代码的开发。可以将常用的增删改查放到通用dao中。对不同的or框架，基本上都有自己的实现如SpringJPA的Repository就提供了常用的增删改查方法。而MyBatis借助代码生成工具也可以生成
Mybatis通用DAO设计封装（mybatis）
08-05
NULL 博文链接：https://zhaoshijie.iteye.com/blog/2003209
mybatis 通用DAO 简单实现
06-06
mybatis 通用dao的简单实现 简单的增 删 改 查 复杂功能未实现
MyBatis 通用 Dao.pdf
12-31
MyBatis通用Dao,包含分页方法
ssm（Spring-springMVC-Mybatis）通用Dao框架
05-10
Spring-springMVC-Mybatis通用Dao框架,附带sql文件，下载导入开发工具可直接运行查看效果
springMvc+Mybatis 最新版+Dao 层封装
07-29
springMvc+Mybatis 最新版+Dao 层封装; 使用了 2016-07-28 maven 上下载的当前最新版本jar包 4.3.2 搭建的 springMVC + Mybatis +DAO 层封装..仅供参考学习...
SpringMVC关于MyBatis通用公共Dao的实现
chentian610的博客
01-29 3236
现在越来越多的开发者使用MyBatis作为ORM的框架，它开发迅速，上手容易，开源代码多。但是在进行数据库操作的时候的独自生成的DaoMaper业务太多，在相互调用的业务之间，容易产生这样那样的事务问题。因此本人一直想寻找一个类似Hibernate一样的通用数据库管理Dao，采用Spring注入的方式即可。     MyBatis已经改成了SqlSessionTemplate来连接数据库，话不多
springboot 整合mybatis 实现通用dao
h_wfeng的博客
12-15 1703
1、版本 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mave...
spring+mybatis通用dao层、service层的一些个人理解与实现
热门推荐
acweilisky0825的专栏
07-26 2万+
首先声明，本文所述只是鉴于本人在开发一些应用时的心得，仅供参考。 1、现在的绝大多数web应用，通常都以action、service、dao三层去组织代码，这样划分结构很清晰，分工明确 2、一般情况下，我们会把事务控制在service层。 3、action和dao层，会使用一些框架技术。比如action层可能选择有springmvc、struts等，dao层有hibernate、my
06Mybatis的Dao层实现
痞子王的博客
10-11 262
1.1 传统开发方式 1.1.1编写UserDao接口 public interface UserDao { List<User> findAll() throws IOException; } 1.1.2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao { public List<User...
【MyBatis】Dao层的实现
懂得一千零一种,赋予你失败的方法！
05-04 1118
文章目录一、 查询所有1.Dao层接口2.Dao层实现类3.测试二、 插入用户1.Dao层接口2.Dao层实现类3.测试三、 刪除用户1.Dao层接口2.Dao层实现类3.测试四、 更新用户1.Dao层接口2.Dao层实现类3.测试五、 查询一个用户1.Dao层接口2.Dao层实现类3.测试六、 根据名称模糊查询1.Dao层接口2.Dao层实现类3.测试七、 聚合函数查询总数1.Dao层接口2.Dao层实现类3.测试八、流程分析 一、 查询所有 1.Dao层接口 package com.zyx.cor.
完美的mybatis通用dao实现
coooooding
06-29 8306
场景： 项目中用到mybatis(版本3.3.2)。对于单表操作，我们一开始是手写各个sql。但是这样接口非常不一致，而且有太多的小接口，不方便将相似功能合并。而且由于实现不一致，不能只根据接口名判断具体执行的sql，而且不能保证没有bug。后来我们用mybatis-generator插件，自动生成model、example、mapper.xml、mapper.java。但是又引入了新的问题。表...
使用mybatis完成通用dao和通用service
夜-feng的专栏
03-31 9715
原文  http://liuyiyou.cn/2015/01/25/base-mybatis-dao/ 主题 MyBatis 概述： 使用通用dao和通用service可以减少代码的开发。可以将常用的增删改查放到通用dao中。对不同的or框架，基本上都有自己的实现如SpringJPA的Repository就提供了常用的增删改查方法。而MyBatis借助代码生成工具也可以生
mybatis通用dao层封装
06-01
MyBatis通用DAO层封装是一种将DAO层的增删改查操作进行抽象和封装的技术，使得我们可以用更少的代码实现更多的功能。通用DAO层封装的主要目的是为了减少重复代码，提高开发效率，使得我们的代码更加简洁易懂。 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值