mybatis封装过程

最新推荐文章于 2022-03-18 15:22:56 发布
最新推荐文章于 2022-03-18 15:22:56 发布
阅读量122 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/u/1458864/blog/315251
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png


实例：

可考虑做两部封装，

1.对从数据库连接池中获取的sqlSession封装成sqlSessionTemplate对象，是的用户不需要关心数据连接的获取过程

2.对mybatis获取mapp.xml的过程进行封装，即用户只需要关心传入表名称和sql语句,另外对sqlSession提供的原始方法封装，如crud，selectOne,selectList


  1. 首先对sqlSession进行封装，封装出一个可用的SqlSessionTemplate

package com.lvmama.vst.comm.mybatis;

import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * sqlSession基类
 * 
 * @author wenzhengtao
 *
 */
public class SqlSessionTemplateDaoSupport {

	protected SqlSessionTemplate sqlSession;
	protected boolean externalSqlSession;
		
	public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
		this.sqlSession = sqlSessionTemplate;
		this.externalSqlSession = true;
	}

	public final SqlSession getBatchSqlSession() {
		return new SqlSessionTemplate(this.sqlSession.getSqlSessionFactory(), ExecutorType.BATCH);
	}

	public SqlSession getSqlSession() {
		return this.sqlSession;
	}

	@Autowired(required = false)
	public final void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
		if (!this.externalSqlSession) {
			this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
		}
	}
}

2.对mapp.xml中的可操作表进行封装

package com.lvmama.vst.comm.mybatis;

import java.io.Serializable;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.session.RowBounds;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Repository;

/**
 * MyBatis的Dao基类
 * 
 * @author wenzhengtao
 */
@Repository
public class MyBatisDao extends SqlSessionTemplateDaoSupport {

	private static final Log LOG = LogFactory.getLog(MyBatisDao.class);

	private int maxRows = 1001;
	private int maxRowsForReport = 50000;
	private String namespaceName;

	public MyBatisDao(String namespaceName) {
		super();
		this.namespaceName = namespaceName;
	}

	private String createStatementName(String id) {
		return namespaceName + "." + id;
	}

	protected int insert(String key, Object object) {
		if (object != null) {
			return getSqlSession().insert(createStatementName(key), object);
		}
		return 0;
	}

	protected int update(String key, Object object) {
		if (object != null) {
			return getSqlSession().update(createStatementName(key), object);
		}
		return 0;
	}

	protected int delete(String key, Serializable id) {
		if (id != null) {
			return getSqlSession().delete(createStatementName(key), id);
		}
		return 0;
	}

	protected int delete(String key, Object object) {
		if (object != null) {
			return getSqlSession().delete(createStatementName(key), object);
		}
		return 0;
	}

	@SuppressWarnings({ "unchecked" })
	protected <T> T get(String key, Object params) {
		if (params != null) {
			return (T) getSqlSession().selectOne(createStatementName(key), params);
		} else {
			return null;
		}
	}
	
	/**
	 * 重载一个无参数的get方法，供vst_search使用
	 * @author wenzhengtao
	 * @param key
	 * @return
	 */
	@SuppressWarnings({ "unchecked" })
	protected <T> T get(String key) {
		return (T) getSqlSession().selectOne(createStatementName(key));
	}

	protected <T> List<T> getList(String key) {
		return getSqlSession().selectList(createStatementName(key));
	}

	protected <T> List<T> getList(String key, Object params) {
		if (params != null) {
			return getSqlSession().selectList(createStatementName(key), params);
		} else {
			return null;
		}
	}

	protected <T> List<T> queryForList(String statementName) throws DataAccessException {
		return queryForList(statementName, null);
	}

	protected <T> List<T> queryForList(final String statementName, final Object parameterObject) throws DataAccessException {
		if (parameterObject != null) {
			List<T> result = getSqlSession().selectList(createStatementName(statementName), parameterObject, new RowBounds(0, maxRows));
			if ((result != null) && (result.size() == maxRows)) {
				LOG.warn("SQL Exception: result size is greater than the max rows, " + namespaceName + "." + statementName);
			}
			return result;
		} else {
			return null;
		}
	}

	protected <T> List<T> queryForList(String statementName, int skipResults, int maxResults) throws DataAccessException {

		if ((maxResults - skipResults) >= maxRows) {
			maxResults = skipResults + maxRows;
			LOG.warn("SQL Exception: result size is greater than the max rows, " + createStatementName(statementName));
		}

		return queryForList(statementName, null, skipResults, maxResults);
	}

	protected <T> List<T> queryForList(final String statementName, final Object parameterObject, final int skipResults, final int maxResults) throws DataAccessException {

		int tempMaxResults = maxResults;
		if ((maxResults - skipResults) >= maxRows) {
			tempMaxResults = skipResults + maxRows;
			LOG.warn("SQL Exception: result size is greater than the max rows, " + createStatementName(statementName));
		}
		return getSqlSession().selectList(createStatementName(statementName), parameterObject, new RowBounds(skipResults, tempMaxResults));
	}

	// 数据量比较大的报表导出请用这个接口
	protected <T> List<T> queryForListForReport(String statementName) throws DataAccessException {
		return queryForListForReport(statementName, null);
	}

	// 数据量比较大的报表导出请用这个接口
	protected <T> List<T> queryForListForReport(final String statementName, final Object parameterObject) throws DataAccessException {

		List<T> result = getSqlSession().selectList(createStatementName(statementName), parameterObject, new RowBounds(0, maxRowsForReport));

		if ((result != null) && (result.size() == maxRowsForReport)) {
			LOG.warn("SQL Exception: result size is greater than the max rows, " + statementName);
		}
		return result;
	}

	// 数据量比较大的报表导出请用这个接口
	protected <T> List<T> queryForList(final String statementName, final Object parameterObject, final boolean isForReportExport) throws DataAccessException {

		int maxRowsTemp = maxRows;
		if (isForReportExport) {
			maxRowsTemp = maxRowsForReport;
		}

		List<T> result = getSqlSession().selectList(createStatementName(statementName), parameterObject, new RowBounds(0, maxRowsTemp));
		if ((result != null) && (result.size() == maxRowsTemp)) {
			LOG.warn("SQL Exception: result size is greater than the max rows, " + statementName);
		}
		return result;
	}

}
package com.lvmama.vst.comm.dao;

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

import org.springframework.stereotype.Repository;

import com.lvmama.vst.comm.mybatis.MyBatisDao;
import com.lvmama.vst.comm.po.ComFileMap;

@Repository
public class ComFileMapDAO extends MyBatisDao{

    public ComFileMapDAO() {
		super("COM_FILE_MAP");
	}

	public int deleteByPrimaryKey(Long comFileId) {
    	return super.delete("deleteByPrimaryKey", comFileId);
    }

    public int insert(ComFileMap record) {
    	return super.insert("insert", record);
    }

    public int insertSelective(ComFileMap record) {
    	return super.insert("insertSelective", record);
    }

    public ComFileMap selectByPrimaryKey(Long comFileId) {
    	return super.get("selectByPrimaryKey", comFileId);
    }

    public int updateByPrimaryKeySelective(ComFileMap record) {
    	return super.update("updateByPrimaryKeySelective", record);
    }

    public int updateByPrimaryKey(ComFileMap record) {
    	return super.update("updateByPrimaryKeySelective", record);
    }
    
    public List<ComFileMap> selectByParams(Map<String, Object> params) {
    	return super.queryForList("selectByParams", params);
    }
    
    public ComFileMap getByFileName(String fileName) {
    	Map<String, Object> params =new HashMap<String, Object>();
    	params.put("fileName", fileName);
    	return super.get("selectByParams", params);
    }
    
    public ComFileMap getByFileId(Long fileId) {
    	Map<String, Object> params =new HashMap<String, Object>();
    	params.put("fileId", fileId);
    	return super.get("selectByParams", params);
    }
}

Spring配置样本

<!-- 数据源配置,使用应用内的DBCP数据库连接池  -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName">
            <value>${jdbc.driverClassName}</value>
        </property>
        <property name="url">
            <value>${jdbc.url}</value>
        </property>
        <property name="username">
            <value>${jdbc.username}</value>
        </property>
        <property name="password">
            <value>${jdbc.password}</value>
        </property>
        <property name="maxActive">
            <value>${jdbc.maxActive}</value>
        </property>
        <property name="maxWait">
            <value>${jdbc.maxWait}</value>
        </property>
        <property name="maxIdle">
            <value>${jdbc.maxIdle}</value>
        </property>
        <property name="initialSize">
            <value>${jdbc.initSize}</value>
        </property>
        <property name="removeAbandoned">
            <value>true</value>
        </property>
        <property name="testWhileIdle">
            <value>true</value>
        </property>
        <property name="testOnBorrow">
            <value>false</value>
        </property>
        <property name="validationQuery">
            <value>SELECT 1 FROM SYS.DUAL</value>
        </property>
    </bean>

    <!-- mysql数据源配置,使用应用内的DBCP数据库连接池  -->
    <bean id="dataSourceMysql" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName">
            <value>${jdbc.mysql.driverClassName}</value>
        </property>
        <property name="url">
            <value>${jdbc.mysql.url}</value>
        </property>
        <property name="username">
            <value>${jdbc.mysql.username}</value>
        </property>
        <property name="password">
            <value>${jdbc.mysql.password}</value>
        </property>
        <property name="maxActive">
            <value>${jdbc.mysql.maxActive}</value>
        </property>
        <property name="maxWait">
            <value>${jdbc.mysql.maxWait}</value>
        </property>
        <property name="maxIdle">
            <value>${jdbc.mysql.maxIdle}</value>
        </property>
        <property name="initialSize">
            <value>${jdbc.mysql.initSize}</value>
        </property>
        <property name="removeAbandoned">
            <value>true</value>
        </property>
    </bean>

    <!-- Transaction manager for a single JDBC DataSource -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:sqlmap-config.xml"/>
        <property name="mapperLocations">
            <value>classpath*:com/lvmama/vst/interfacePlatform/map/oracle/*.xml</value>
        </property>
    </bean> 
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
     <!-- 连接事务的注解配置
    <tx:annotation-driven transaction-manager="transactionManager"/>
    -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="*" propagation="REQUIRED" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="allManagerMethod" expression="execution(* com.lvmama..*.*ServiceImpl.*(..))" />
	   <aop:advisor advice-ref="txAdvice" pointcut-ref="allManagerMethod"/>
    </aop:config>


转载于:https://my.oschina.net/u/1458864/blog/315251

weixin_34275734
关注
使用Mybatis封装返回多层级数据
include_hcj的博客
08-13 1586
实际开发中，我们从数据库查询返回得到的数据可能需要二次封装成前端想要处理的数据，而不只是简单的返回pojo/entity类。
JDBC+ 泛型DAO+Mybatis +存储过程+注解的数据层封装
tonysong111073的专栏
02-05 219
通过传统的JDBC进行数据操作比较繁琐，但是无论hibernate也好，Mybatis也好底层都是对JDBC的调用，那么我们可不可以对JDBC（包括存储过程的操作）进行封装（并且打包为jar）从而简化我们的开发呢？答案是肯定的。 首先封装分页工具类： package bw.song.jdbc.util; import java.util.List; /** * 分页工具类 * @aut...
mybaties封装
zhou920786312的博客
10-16 432
mybaties封装 一、 流程图 二、 好处 方便接口功能扩展 减少开发代码写sql语句的麻烦 代码整洁清晰且易于维护 三、 案例（已一个复杂的查询为案例，代码只给出所需要的代码） 3.1 代码入口 package com.apiserver.producer.system; import com.apiserver.data.mybatis.util.SortConstant...
Mybatis的封装
weixin_45290168的博客
09-02 280
Mybatis的封装 a) SqlSession对象要使用同一个factory对象创建 b) 一次请求内共享同一个SqlSession对象 c) 需要注意：用到ThreadLocal对象来存储SqlSession对象 i. ThreadLocal对象中存储的数据只能在同一个线程中获取 ii. 在某个线程中存储的，必须在该线程中获取，就算另一个线程中获取到了同一个ThreadLocal对象，也无法获取到其中存储的其他线程的数据
mybatis封装mysql_JDBC到持久层框架mybatis简单封装思路
weixin_42526484的博客
02-03 329
public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {// 加载数据库驱动Class.forName("com.mysql.jdbc.Driver");// 驱动管理...
MyBatis 封装底层原理图。
lyfGeek的博客
03-04 468
MyBatis 封装底层原理图。
springboot+mybatis封装第二版
06-21
现在我们将深入探讨"springboot+mybatis封装第二版"这一主题。 首先，"最小侵入性"是现代软件开发的一个重要原则。在SpringBoot与MyBatis的集成中，这意味着开发者无需大量修改原有代码结构就能引入这两个框架。在...
mybatis:使用mybatis封装一些数据库操作
06-01
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。在实际开发中，MyBatis常被用来封装数据库操作，以实现更灵活、高效的数据库访问。本文将深入探讨如何使用MyBatis进行SQLite和MySQL...
Mybatis通用DAO设计封装（mybatis）
08-05
Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...
SpringMVC+Mybatis封装实例
12-06
在封装过程中，我们可以创建一个BaseMapper接口，定义通用的CRUD方法，然后让具体业务的Mapper接口继承它。Mapper XML文件可以统一模板化，减少重复代码。Service层则可以使用Spring的@Autowired注解来注入Mapper，...
mybatis 对jdbc封装
qq_46015410的博客
03-18 3236
基于maven结构的mybatis数据库封装
Mybatis数据封装过程原理解析
一木一草一枯荣
04-21 1908
mybatis封装数据过程：mybatis中大量使用了装饰设计模式。 1、最简单的一种情况：xml中没有配置resultMap也就是查询出来直接封装到javabean中。 mybatis源码： DefaultResultSetHandler.class [code="java"]//从resultSet的包装类ResultSetWrapper中查询出sql中写的所有column. fin...
Mybatis通用封装—基于泛型
07-29 3367
在java后台架构，数据库的访问，我们一般都会选择一种映射机制，主流的也就是Hibernate跟Mybatis(ibatis)。Hibernate比较方便的实现了映射关系（特别是Hibernate4采用注解的方式，显得更加简单），但是Hibernate不够灵活，当遇到复杂的SQL语句的时候Hibernate显得力不从心。Mybatis可以支撑任何的SQL语句。但是对于Mybatis我们看到大部分人
mybatis调用存储过程实例及经验（springboot+mybatis+oracl）
热门推荐
我来杀ai的博客
07-11 1万+
上次的项目，要求我用java代码调用存储过程，折腾了好久。最后总算成功了。发片帖子纪念下，也给不懂存储过程的但是要调用的人一些提示首先介绍下存储过程（本人是不会写的，但是目前能看懂）create or replace procedure P_DAP_UNI_CUBE_INFO(V_CUBE_NAME IN VARCHAR2, --每个参数都有三部分 形参 in/out 类型， in是入参...
Mybatis通用封装
Lovnx
02-14 6390
本文针对Spring+SpringMVC+Mybatis基础框架。 在进行开发的时候，没有必要对每个增删改查进行实现，写接口写sql太麻烦了，严重影响开发效率，所以这里对其进行了通用基本方法的封装。1、spring-application<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.o
Mybatis数据源结构解析之连接池
srs1995的博客
12-01 3317
对于 ORM 框架而言，数据源的组织是一个非常重要的一部分，这直接影响到框架的性能问题。本文将通过对 MyBatis 框架的数据源结构进行详尽的分析，找出什么时候创建 Connection ,并且深入解析 MyBatis 的连接池。 本章的组织结构： 零、什么是连接池和线程池 一、MyBatis 数据源 DataSource 分类 二、数据源 DataSource 的创建过程 三、 DataSource 什么时候创建 Connection 对象 四、不使用连接池的 UnpooledDataSource
MyBatisPlus封装SQL语句
weixin_46704406的博客
12-01 1910
最近对MyBatisPlus的学习有推进了一些，打算对MyBatisPlus对SQL语句的封装进行一个大概的总结。 1.selectList(null) mapper.selectList(null); SQL运行结果： SELECT id,name AS title,age,create_time,update_time,version,status,deleted FROM user 这是从user数据表中查找全部数据，并且还有一个知识点就是name AS title这个其实用到了注解：
Spring-mybatis中的 sqlsessionTemplate 如何处理封装的处理Sql
weixin_43689953的博客
11-18 422
/** * 防止sql注入 改造成直接用prepareStatement 预处理sql * * @param sql * @param params * @return */ @Override public List<Map<String, Object>> executeSql(String sql, Object[] params) { log.debug("----【querySer.
MyBatis数据封装
qq_43514659的博客
07-20 788
MyBatis数据封装 xml语法挺多的，如果用的不勤快的话，可能过一会就全忘记了，还是注解方便呀，记得快，用的快，但是xml还是要好好学的哦 当我们需要实现动态sql语句实现的时候，我们就需要使用到其他的标签了，比如，条件选择，还有一次性选多种条件的那种。 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://myb
MyBatis封装持久层有哪两种方式
最新发布
07-14
MyBatis封装持久层通常有两种方式： 1. XML配置方式：这种方式是MyBatis最常用的方式，通过编写XML文件来配置SQL语句和映射关系。XML文件中定义了SQL语句、参数映射和结果映射等信息，通过加载和解析XML文件，MyBatis可以执行对应的SQL操作。 2. 注解方式：这种方式是通过在Java代码中使用注解来配置SQL语句和映射关系。通过在DAO接口的方法上添加注解，可以直接指定SQL语句和参数映射，省去了编写XML文件的过程。注解方式相对于XML配置方式更为简洁，适合一些简单的CRUD操作。 这两种方式都可以实现持久层的封装，选择哪种方式主要根据个人习惯和项目需求来决定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值