在上一篇文章中，我们提到了让mybatis直接执行sql语句。
http://xiabin1235910-qq-com.iteye.com/blog/1748886
接下来介绍在上一篇文章的基础上，我们如何使用mybatis，以及在编程时，应该注意的事项：
1. 命名规约：
配置文件的namespace和Box类的路径要一致，我们稍后将会用反射的方式，将Box和BoxMapper串接起来。
在项目中采用的普遍做法是，在dao层建立一个泛型基类，这个泛型基类提供一个公用方法，将实体和xml文件对应起来。如图：
好的，介绍一下DaoBase泛型类，首先要将实体和xml串联起来。
public interface DaoSupport<T> {
/**
* 添加对象
* @param t
*/
public abstract void add(T t);
}
public class DaoBase<T> implements DaoSupport<T> {
@Override
public void add(T o) {
try {
SessionManage.dealSession(SessionMethod.INSERT,
getDealMethod(SessionMethod.INSERT).toString(), o);
} catch (SQLException e) {
System.out.println("事务异常");
e.printStackTrace();
}
}
private StringBuilder getDealMethod(SessionMethod sm) {
Class<T> c = getDetailClass();
StringBuilder queryMapper = new StringBuilder(c.getName());
queryMapper.append(".");
if (sm.equals(SessionMethod.DELETE)) {
queryMapper.append(SessionMethod.DELETE.getName());
} else if (sm.equals(SessionMethod.UPDATE)) {
queryMapper.append(SessionMethod.UPDATE.getName());
} else {
queryMapper.append(SessionMethod.INSERT.getName());
}
queryMapper.append(c.getSimpleName());
return queryMapper;
}
private Class<T> getDetailClass() {
Class<T> en;
Class c = this.getClass();
// System.out.println(c.getName());
ParameterizedType ptype = null;
do { // 遍历所有超类，直到找泛型定义
try {
ptype = (ParameterizedType) c.getGenericSuperclass();
} catch (Exception e) {
}
c = c.getSuperclass();
// System.out.println("super class:" + ptype);
} while (ptype == null && c != null);
if (ptype == null) {
System.out.println("子类中没有定义泛型的具体类型");
}
en = (Class<T>) ptype.getActualTypeArguments()[0];
// System.out.println(en.getSimpleName());
return en;
}
}
其核心思想，就是在泛型类中通过查找出<T> 的 T 的类型，取得T 类的路径， 在sessionManage中将T和 T对应的xml 关联起来，以便完成添加对象的方法。sessionManage的代码，如下：
public class SessionManage {
static TransactionFactory transactionFactory = new JdbcTransactionFactory();
public static void dealSession(SessionMethod sm, String queryMethod, Object param) throws SQLException {
SqlSession session = MyBatisUtil.getSqlSessionFactory().openSession();
Transaction transaction = transactionFactory.newTransaction(
session.getConnection(), false);
try {
Method m = null;
m = session.getClass().getDeclaredMethod(sm.getName(), String.class ,Object.class);
if(param instanceof List) {
for(Object o : (List)param) {
m.invoke(session, queryMethod, o);
}
} else {
m.invoke(session, queryMethod, param);
}
// int a = 45/0; //生成错误判断是否回滚
//事务提交
transaction.commit();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (Exception e) {
//事务回滚
transaction.rollback();
System.out.println("事务回滚");
e.printStackTrace();
} finally {
transaction.close();
session.close();
}
}
}
其核心思想，就是通过反射，将mybatis的session.insert() session.update() session.delete() 等方法抽象成一个方法。
附：枚举类sessionMethod代码：
public enum SessionMethod {
INSERT {
@Override
public String getName() {
return "insert";
}
},
UPDATE {
@Override
public String getName() {
return "update";
}
},
DELETE {
@Override
public String getName() {
return "delete";
}
};
public abstract String getName();
}
获取sessionFactory方法：
public class MyBatisUtil {
private static SqlSessionFactory sqlSessionFactory = null;
public synchronized static SqlSessionFactory getSqlSessionFactory() {
if(sqlSessionFactory == null) {
String resource = "mybatis-configuration.xml";
Reader reader = null;
try {
reader = Resources.getResourceAsReader(resource);
} catch (IOException e) {
e.printStackTrace();
}
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
}
return sqlSessionFactory;
}
}
以上，仅仅完成了万里长征的第一步，还有更加复杂的查询逻辑等着我们去处理。
这才是我们需要处理的核心内容，也是难点。
--------------------------------------------------------------------------------------------------------------------------------------------------
相信有了上面的基础，对于我们理解下面的内容有很大帮助。
我们在用自己编写的分页框架，查询语句时，往往需要我们自己去维护这段代码，这就需要我们让mybatis直接执行sql语句。 配置的话 在开头我已经讲过，下面着重讲解使用方式：
首先，在做项目时，我们会碰到各种各样的需求，使用软删除，复杂的sql查询语句，表间级联关系查询等等，
所以有必要采用抽象的方式，整合它们。 我们先从DaoBase这个基类入手。
public class DaoBase<T> implements DaoSupport<T> {
@Override
public QueryResult<T> getScrollData(long startIndex, long maxResult,
String whereSql, Object[] params,
LinkedHashMap<String, String> orderBy) {
return getAbstractScrollData(startIndex, maxResult, whereSql, params,
orderBy, false);
}
protected QueryResult<T> getAbstractScrollData(long firstIndex,
long maxResult, String whereSql, Object[] params,
LinkedHashMap<String, String> orderBy, boolean delete) {
return getManyToManyScrollData(firstIndex, maxResult, null, whereSql,
params, orderBy, delete);
}
@Override
public QueryResult<T> getScrollData(long startIndex, long maxResult,
String tableMapping, String whereSql, Object[] params) {
return getManyToManyScrollData(startIndex, maxResult, tableMapping,
whereSql, params, null, false);
}
protected QueryResult<T> getManyToManyScrollData(long firstIndex,
long maxResult, String tableMapping, String whereSql,
Object[] params, LinkedHashMap<String, String> orderBy,
boolean delete) {
Class<T> c = getDetailClass();
String classNameAll = c.getName();
String className = c.getSimpleName();
StringBuilder sql = getSQL(tableMapping, whereSql, params, orderBy, className, delete);
StringBuilder sqlCounts = getCountsSql(tableMapping, whereSql, params, className, delete);
sql.append(" ").append("limit ").append(firstIndex).append(", ").append(maxResult);
return getQuertResult(classNameAll, sql.toString(), sqlCounts.toString());
}
private StringBuilder getSQL(String tableMapping, String whereSql,
Object[] params, LinkedHashMap<String, String> orderBy,
String className, boolean delete) {
StringBuilder sql = new StringBuilder("select n.* from ");
sql.append(className.toLowerCase()).append(" n ")
.append(tableMapping == null ? "" : tableMapping + " ")
.append("where n.deleteflag=").append(delete ? "1" : "0");
if (whereSql != null) {
sql.append(buildWhere(whereSql, params));
}
if (orderBy != null) {
sql.append(" ").append(buildOrderBy(orderBy));
}
return sql;
}
private QueryResult<T> getQuertResult(String classNameAll, String sql,
String sqlCounts) {
QueryResult<T> queryResult = new QueryResult<T>();
if (sql != null) {
List<T> tlist = SessionManage.getRecordsBySQL(classNameAll, sql);
queryResult.setResultList(tlist);
}
// 分页的结果集需要统计总记录数，否则，不统计
if (sqlCounts != null) {
List<String> counts = new ArrayList<String>();
counts = SessionManage.getRecordsOfColumnBySQL(classNameAll,
sqlCounts);
if (counts != null && counts.size() > 0) {
queryResult.setTotalRecord(Long.valueOf(counts.get(0)));
} else {
queryResult.setTotalRecord(0L);
}
}
return queryResult;
}
}
这里的Daobase基类，主要完成了向上层暴露查询分页方法的底层实现。 QueryResult是我们实现的一个分页器，里面存放主要的内容就是 查询集合和总共的集合数量。
这里介绍一下两个暴露的方法：
getScrollData(long startIndex, long maxResult, String whereSql, Object[] params, LinkedHashMap<String, String> orderBy)
getScrollData(long startIndex, long maxResult, String tableMapping, String whereSql, Object[] params)
稍加比较，就会发现，第二个方法加入了一个tablemapping参数， 这个参数主要是为了实现表间级联查询所设计的。
两个方法公用的参数whereSql和params 是为了拼凑where语句使用的。
最后拼凑出来的整体效果如下: select n.* from box n where n.boxtype='xxx' orderby boxid ASC;
介绍一下，我们如何使用这个这两个方法，我们在servlet中使用，代码如下：
private void getBoxList(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
String pageOfString = request.getParameter("page");
int page;
if(pageOfString == null || "".equals(pageOfString)) {
page = 1;
} else {
page = Integer.valueOf(pageOfString);
}
int maxResult = 10;
String selectName = request.getParameter("selectName");
String shiptypeid = request.getParameter("shiptypeid");
QueryResult<Box> qr = new QueryResult<Box>();
StringBuilder wheresql = new StringBuilder("1=1");
List<Object> olist = new ArrayList<Object>();
LinkedHashMap<String, String> orderby = new LinkedHashMap<String,String>();
orderby.put("boxid", "ASC");
if (selectName != null && !selectName.equals("")) {
wheresql.append(" and n.boxtype like ?");
olist.add("%" + selectName + "%");
request.setAttribute("selectName", selectName);
}
if(shiptypeid != null && !"".equals(shiptypeid)) {
wheresql.append(" and n.shiptypeid=?");
olist.add(shiptypeid);
request.setAttribute("shiptypeid", shiptypeid);
}
PageView<Box> pageView = new PageView<Box>(maxResult, page);
qr = bs.getScrollData(pageView.getFirstResult(),
pageView.getMaxresult(), wheresql.toString(),
olist.toArray(), orderby);
pageView.setQueryResult(qr);
request.setAttribute("pageView", pageView);
doBrowse(request, response, PageManage.addOtherPrefixAddress("boxList.jsp"));
}
没错，我们采用了很像hibernate的where语句写法，完整的sql语句 ：
1=1 and n.boxtype like ? and n.shiptypeid=? 在olist加入参数的顺序必须和问号的顺序一致
底层包装后的显示 select n.* from box n where 1=1 and n.boxtype like ? and n.shiptypeid=? orderby boxid ASC
下面我们的考虑就是，如何将问号替换成参数，而且字符串和数字作为参数的形式还不一样，一个加' ' ， 一个不加。
我们把这项职责还是交给DaoBase，代码如下：
private StringBuilder buildWhere(String whereSql, Object[] params) {
StringBuilder where = new StringBuilder();
where.append(" and ");
int temp = whereSql.lastIndexOf("?");
// 表达式中不含等号
if (temp == -1) {
where.append(whereSql);
} else {
if (whereSql != null && params.length > 0) {
String[] a = whereSql.split("[?]");
int para = a.length - 1;
// "?"不是最后一个字符
if (temp < whereSql.length() - 1) {
para = para - 1;
}
for (int i = 0; i < a.length; i++) {
where.append(a[i]);
if (i <= para) {
if (params[i] instanceof String
|| params[i] instanceof Timestamp
|| params[i] instanceof Date) {
where.append("'").append(params[i]).append("'");
} else {
where.append(params[i]);
}
}
}
}
}
return where;
}
相信大家应该明白了，这是怎么一回事儿了。 对于刚接触mybatis的朋友也没关系，我在此上传例子工程，供大家学习。由于个人精力有限，肯定多有设计不足之处，欢迎大家指正。
相关推荐
主要介绍了MyBatis直接执行SQL查询及数据批量插入的相关知识，需要的朋友一起学习吧
适用于springboot（整合过mybatis的）和常规SSM项目，可以获取完整的mybatis执行的sql语句，用于直观的看到执行sql是否异常
Mybatis执行SQL语句的方式
大家对mybatis执行任意sql语句都了解，那么MyBatis执行动态SQL语句呢？下面脚本之家小编给大家解答下mybatis执行动态sql语句的方法，非常不错，感兴趣的朋友参考下吧
if 、where、set、trim、choose 、foreach等在mybatis中的具体用法，有具体实例可供参考，玩转mybatis
mybatis+spring 框架中配置日志中显示sql语句
1.网上搜索了很多，几乎都是能修改sql, 但是修改后的sql不生效,还是执行原来的sql. 2.这个版本亲测可以生效。 3.支持分页查询
mybatis动态插入sql语句的编写（csdn）————程序
把 mybatis 输出的sql日志还原成完整的sql语句。 将日志输出的sql语句中的问号 ? 替换成真正的参数值。 通过 "Tools -> MyBatis Log Plugin" 菜单或快捷键 "Ctrl+Shift+Alt+O" 启用。 点击窗口左边的 "Filter" ...
拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL语句即可在数据库工具中执行。 使用方法： 找到你springboot项目中的配置文件，增加如下配置即可 application.yml 配置如下： sql: slow...
MyBatis动态拼接SQL
Mybatis中执行String类型的自己拼写的sql，不执行配置文件中的sql mybatis sql connection mybatis中使用sql，不实用配置文件中的sql实例
在实际开发过程中，我们往往需要编写复杂的SQL语句,拼接稍有不注意就会导致错误，Mybatis给开发者提供了动态SQL，大大降低了拼接SQL导致的错误。 动态标签 if标签 if标签通常用那个胡where语句,update语句,insert...
用于mybatis打印出sql语句。内含log4j-1.2.16.jar 和 配置好的log4j.properties文件
Mybatis案例一所用建表语句Mybatis案例一所用建表语句Mybatis案例一所用建表语句
1.匿名内部类风格 2.Builder/Fluent 风格 3.动态条件（参数需要使用 final 修饰，以便返回值中的匿名内部类使用）
该工具可以将mybatis输出的sql日志提取出来，并将其格式化为可以直接执行的sql语句，节约开发人员时间
mybatis如何防止SQL注入