`
projecttian
  • 浏览: 33522 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

mybatis通用DAO

mybatis通用Dao接口DAO 
阅读更多

       花了几天的时间研究了一下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());
	}
}
 
分享到：
| mybatis xpath实现
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Mybatis通用DAO设计封装（mybatis）

    Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...

    mybatis 通用DAO 简单实现

    MyBatis 通用DAO（Data Access Object）是一种设计模式，旨在提供一种标准的方式来访问数据库，减少重复代码，提高开发效率。在Java Web开发中，MyBatis作为一个优秀的持久层框架，它支持定制化SQL、存储过程以及...

    MyBatis 通用 Dao.pdf

    ### MyBatis 通用 Dao 及其分页方法详解 #### 一、概述 在 Java 领域中，MyBatis 是一个优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集...

    Mybatis通用Dao

    现在越来越多的开发者使用MyBatis作为ORM的框架，它开发迅速，上手容易，开源代码多...因此本人一直想寻找一个类似hibernate一样的通用数据库管理Dao，采用spring注入的方式即可。现在已创建项目的方式和大家一起分享。

    ssm（Spring-springMVC-Mybatis）通用Dao框架

    在"Spring-springMVC-Mybatis通用Dao框架"中，通常会包含以下组件： 1. **配置文件**：如`applicationContext.xml`（Spring配置）、`spring-mvc.xml`（SpringMVC配置）和`mybatis-config.xml`（Mybatis配置）等，...

    springboot + mybatis(通用mapper) + druid多数据源

    【标题】"SpringBoot + MyBatis(通用Mapper) + Druid多数据源"是一个常见的Java后端开发架构，用于构建高效、稳定且可扩展的Web应用程序。在这个框架中，SpringBoot简化了Spring应用的初始化和配置，MyBatis作为持久...

    Mybatis整合通用Dao，Mybatis整合通用Mapper，MyBatis3.x整合通用 Mapper3.5.x

    本文将深入探讨如何将MyBatis与通用Dao（Data Access Object）和通用Mapper进行整合，以提高开发效率和代码复用性。我们将以"Mybatis整合通用Dao，Mybatis整合通用Mapper，MyBatis3.x整合通用Mapper3.5.x"为主题，...

    mybatis基于Dao的crud操作源码

    本项目是基于Mybatis进行DAO（Data Access Object）层的CRUD（Create、Read、Update、Delete）操作的源码实现，结合了Spring框架，便于管理和集成事务。 在Mybatis中，CRUD操作主要通过Mapper接口和对应的XML配置...

    Mybatis通用增删改查

    在实际开发中，为了提高代码的复用性和减少重复工作，开发者通常会实现一套通用的增删改查模板，这就是“Mybatis通用增删改查”的概念。 1. **基础 DaoImpl 概念** Dao（Data Access Object）接口是Java中用于...

    Mybatis通用分页插件

    Mybatis通用分页插件是Java开发中广泛使用的ORM（对象关系映射）框架扩展，主要针对Mybatis进行优化，提供了高效便捷的分页功能。这个插件的目的是简化在数据库查询时的分页操作，使得开发者能够更专注于业务逻辑，...

    mybatis 通用mapper

    MyBatis通用Mapper是一个基于MyBatis框架的扩展工具，它极大地简化了针对单一表的操作，使得开发人员无需编写繁琐的XML映射文件和接口定义就能实现数据层的增删改查等基本功能。其优势在于简化了开发流程，降低了...

    mybatis生成对应的dao/model/mapper

    MyBatis Generator（MBG）是一个强大的工具，用于自动生成MyBatis的DAO层、Model层和Mapper XML文件。这个工具极大地简化了开发过程，减少了手动编写这些常见代码的工作量，提高了开发效率。下面我们将详细探讨...

    泛型通用DAO，可以很简化DAO层的代码

    泛型通用DAO是这种模式的一种优化，它利用了Java 5.0引入的泛型和反射机制，大大简化了DAO层的编码工作，提高了代码的可复用性和可维护性。 泛型是Java中的一种类型系统扩展，它允许在编译时声明参数化的类型，从而...

    Java_Mybatis通用分页插件.zip

    Java Mybatis通用分页插件是为了解决在Mybatis框架中进行数据查询时的分页问题而设计的。在大型应用中，由于数据量庞大，一次性加载所有数据不仅会消耗大量内存，还可能导致用户界面响应变慢。因此，分页查询成为了...

    Hibernate通用Dao设计。

    本篇文章将深入探讨Hibernate的通用Dao设计，帮助开发者理解如何利用Hibernate提高代码复用性和可维护性。 在传统的Java应用程序中，DAO（Data Access Object）层是用于封装数据库访问逻辑的地方，它隔离了业务逻辑...

    mybatis的基本演示项目-mybatis-generic-dao-demo-generic

    "mybatis-generic-dao-demo-generic" 是一个基于MyBatis的通用DAO项目的示例，它展示了如何利用MyBatis的插件机制来实现数据访问对象（DAO）的通用化，从而提高开发效率。 在这个项目中，重点可能包括以下几个方面...

    通用DAO

    本文将深入探讨Java语言中如何使用反射机制实现通用DAO，并通过提供的"通用DAO源码及示例"来阐述这一概念。 首先，我们需要理解什么是DAO模式。DAO模式是一种软件设计模式，它的主要目标是为应用程序提供一个抽象层...

    mybatis basedao

    MyBatis BaseDAO 的核心理念是将通用的数据库操作抽象出来，形成一套标准化的方法，如 selectById、selectList、insert、update、delete 等。这些方法通常会配合Mapper接口和XML配置文件一起使用，使得开发者可以...

    spring和mybatis整合(原始dao方式实现

    - 实现DAO接口，通常我们会创建一个BaseDao接口，包含通用的CRUD方法，然后让具体的Mapper接口继承BaseDao。 4. **原始DAO方式实现**： - 在Spring中，原始DAO方式指的是不使用MyBatis的Mapper接口，而是直接通过...

    通用数据库访问模块，通用DAO类

    此外，一些高级的 DAO 实现可能会使用 ORM 框架，如 Hibernate 或 MyBatis，它们可以自动映射数据库记录到 Java 对象，简化数据库操作。 总结来说，通用 DAO 类是软件设计中的一个重要组成部分，它简化了数据库访问...

Magicbox
Global site tag (gtag.js) - Google Analytics