mybatis 將sql寫在java程式碼中

阿新 • • 發佈：2019-02-17

第一部分：Common.xml (mybatis sql執行檔案這裡通過java傳參形成sql語句)

下面包含各種傳參查詢和傳入sql語句進行查詢（注入問題在java中進行處理）
新增和批量新增
批量刪除
修改在CommonDao中

第二部分：CommonMapper.java (介面類)

第三部分：CommonDao.java 基於CommonMapper實現sql語句實現方法呼叫引數化（具體方法檢視CommonDao類中有註釋）

第四部分：Params.java，ParamCondition.java (引數接受傳遞類，具體引數檢視此類)

第五部分：Mybatis.xml (mybatis與mysql之間的資料連線配置)

第六部分：jdbc.properties （資料來源配置）

第七部分：pom.xml （maven包引用配置）

第八部分： CommonDaoTest （測試類）

Common.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.beijingserver.mapper.CommonMapper">
	<insert id="executeAction" parameterType="String">
		${value}
	</insert>


	<select id="findOneData" parameterType="String" resultType="java.util.Map">
		${value}
	</select>


	<select id="findManyData" parameterType="String" resultType="java.util.Map">
		${value}
	</select>


	<select id="findCount" parameterType="String" resultType="long">
		${value}
	</select>


	<insert id="addEntity" parameterType="com.beijingserver.pojo.Params"
		useGeneratedKeys="true" keyProperty="id">
		insert into ${tables}
		<foreach collection="insertMap.keys" item="k" index="index" open="(" separator="," close=")">
			${k}
		</foreach>
		values
		<foreach collection="insertMap.values" item="v" index="index"
			open="(" separator="," close=")">
			#{v}
		</foreach>
	</insert>


	<insert id="batchAdd" parameterType="com.beijingserver.pojo.Params">
		insert into ${tables}
		<foreach collection="insertMap.keys" item="k" open="("
			separator="," close=")">
			<if test="null != insertMap[k]">${k}</if>
		</foreach>
		values
		<foreach collection="bacthInsertMap" item="item" index="index" separator=",">
			<foreach collection="item.values" item="v" open="("
				separator="," close=")">
				#{v}
			</foreach>
		</foreach>
	</insert>
	
	<delete id="batchDelete" parameterType="com.beijingserver.pojo.Params">
		DELETE FROM ${tables} WHERE ${deleteCoulumnName}
		<foreach collection="deleteList" item="id" index="index"
           open="IN(" close=")" separator=",">
           #{id}
        </foreach>
	</delete>
	
</mapper>

CommonMapper.java

package com.beijingserver.mapper;

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

import com.beijingserver.pojo.Params;

public interface CommonMapper {
	/**
	 * 執行增刪改sql語句
	 * 
	 * @author zhy
	 * @param sql sql語句
	 * @return
	 */
	public long executeAction(String sql);
	
	/**
	 * 根據sql語句查詢單調資料
	 * 
	 * @author zhy
	 * @param sql sql語句
	 * @return
	 */
	public Map<String, Object> findOneData(String sql);
	
	/**
	 * 根據sql語句查詢多調資料
	 * 
	 * @author zhy
	 * @param sql sql語句
	 * @return
	 */
	public List<Map<String, Object>> findManyData(String sql);
	
	/**
	 * 新增實體資料
	 * 
	 * @author zhy
	 * @param params 新增引數類
	 * @return
	 */
	public int addEntity(Params params);
	
	/**
	 * 根據sql語句查詢條數
	 * 
	 * @author zhy
	 * @param sql sql語句
	 * @return
	 */
	public long findCount(String sql);
	
	/**
	 * 批量新增
	 * 
	 * @author zhy
	 * @param params 新增引數
	 * @return
	 */
	public int batchAdd(Params params);
	
	/**
	 * 批量刪除
	 * 
	 * @author zhy
	 * @param params 引數類
	 * @return
	 */
	public int batchDelete(Params params);
	
	/**
	 * 根據sql語句查詢單個值
	 * 
	 * @author zhy
	 * @param sql sql語句
	 * @return
	 */
	public Object findOneValue(String sql);
}

CommonDao.java

package com.beijingserver.dao;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.beijingserver.mapper.CommonMapper;
import com.beijingserver.pojo.Params;

/**
 * 類名稱：通用DAO實現層 描述：通用資料處理層 建立人：周化益 建立時間：2015-08-05
 */
@Repository("commonDao")
public class CommonDao<T> {

	@Autowired
	private CommonMapper commonMapper;

	/**
	 * 增刪改SQL操作
	 * 
	 * @param sql 操作的sql語句
	 * @return
	 */
	public long executeAction(String sql) {
		return commonMapper.executeAction(sql);
	}

	/**
	 * 查詢單條語句
	 * 
	 * @param sql 操作的sql語句
	 * @return
	 */
	public Map<String, Object> findOneData(String sql) {
		return commonMapper.findOneData(sql);
	}

	/**
	 * 查詢多條語句
	 * 
	 * @param sql 操作的sql語句
	 * @return
	 */
	public List<Map<String, Object>> findManyData(String sql) {
		return commonMapper.findManyData(sql);
	}

	/**
	 * 查詢數量
	 * 
	 * @author zhy
	 * @param sql 查詢的sql 語句
	 * @return
	 */
	public long findCount(String sql) {
		return commonMapper.findCount(sql);
	}
	
	/**
	 * 查詢單個
	 * 
	 * @author zhy
	 * @param sql 查詢的sql 語句
	 * @return
	 */
	public Object findOneValue(String sql) {
		return commonMapper.findOneValue(sql);
	}
	
	/**
	 * 拼接SQL實現預處理語句
	 * 
	 * @author zhy
	 * @param sql 預處理的語句
	 * @param param 拼接的引數
	 * @return
	 */
	protected String sqlAppend(String sql, Map<String, Object> searchParams) {
		for (String key : searchParams.keySet()) {
			sql = sql.replaceAll(':' + key, '\'' + searchParams.get(key).toString().replaceAll("'", "") + '\'');
		}
		return sql;
	}
	
	/**
	 * 驗證字串防止sql注入
	 * 
	 * @author zhy
	 * @param value 要過濾的值
	 * @return
	 */
	protected String validateValue(String value) {
		return '\'' + value.replaceAll("'", "") + '\'';
	}
	
	/**
	 * 去掉所有單引號
	 * 
	 * @author zhy
	 * @param value 傳入的字串
	 * @return
	 */
	protected String deleteSpoit(String value) {
		return value.replaceAll("'", "");
	}
	
	/**
	 * 直接拼接引數
	 * 
	 * @author zhy
	 * @param searchParams 查詢引數
	 * @return
	 */
	protected StringBuffer appendWhereSql(Map<String, Object> searchParams) {
		StringBuffer sqlBuffer = new StringBuffer("");
		if(searchParams != null && searchParams.size() > 0) {
			sqlBuffer.append(" where ");
			for (String key : searchParams.keySet()) {
				sqlBuffer.append(key).append(" = ").append('\'').append(searchParams.get(key).toString().replaceAll("'", "")).append("' or ");
			}
			int length = sqlBuffer.length();
			return sqlBuffer.delete(length - 3, length);
		} else {
			return sqlBuffer;
		}
	}
	
	/**
	 * 得到實體名
	 * 
	 * @author 周化益
	 * @param entityName 實體Class
	 * @return 實體名
	 */
	private String getTableName(Class<? extends Object> entityName) {
		return entityName.getSimpleName().toUpperCase();
	}
	
	/**
	 * 新增實體
	 * 
	 * @author 周化益
	 * @param entityName 實體Class
	 * @param addData 新增的資料
	 * @return 主鍵ID
	 */
	public long addClass(Class<T> entityName, Map<String, Object> addData) {
		Params params = new Params();
		params.setTables(getTableName(entityName));
		params.setInsertMap(addData);
		commonMapper.addEntity(params);
		return params.getId();
	}
	
	/**
	 * 批量新增資料
	 * 
	 * @author zhy
	 * @param entityName 實體Class
	 * @param listMap	批量資料集合
	 * @return
	 */
	public int batchAdd(Class<T> entityName, List<Map<String, Object>> listMap) {
		Params params = new Params();
		params.setTables(getTableName(entityName));
		params.setInsertMap(listMap.get(0));
		params.setBacthInsertMap(listMap);
		return commonMapper.batchAdd(params);
	}
	
	/**
	 * 通過條件修改實體
	 * 
	 * @author 周化益
	 * @param entityName 實體Class
	 * @param updataData 修改資料
	 * @param whereSql 條件語句
	 * @return 成功或失敗
	 */
	public boolean updateByWhere(Class<T> entityName, Map<String , Object> updateData, String whereSql){
		boolean bool = false;
		try {
			StringBuffer sb = new StringBuffer("update ");
			sb.append(getTableName(entityName)).append(" set ");
			Iterator<String> it = updateData.keySet().iterator();
			StringBuffer updateBuffer = new StringBuffer();
			
			while (it.hasNext()) {
				String key = it.next();
				if(updateData.get(key) == null) {
					updateBuffer.append(key).append('=').append("null").append(',');
				} else{
					updateBuffer.append(key).append('=').append(':'+key).append(',');
				}
			}
			
			sb.append(updateBuffer.substring(0, updateBuffer.length() - 1)).append(whereSql);
			bool = commonMapper.executeAction(sqlAppend(sb.toString(), updateData)) > 0;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return bool;
	}
	
	public long deleteById(Class<T> entityName, Object id) {
		String sql = "delete from " + getTableName(entityName) + " where id = " + id;
		return commonMapper.executeAction(sql);
	}
	
	/**
	 * 獲取實體欄位列表
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @return
	 */
	public static String getClassColumns(Class<?> clazz) {
		String columns = "";
		// 定義實體資訊物件
		BeanInfo beanInfo;
		try {
			// 獲取實體詳細資訊
			beanInfo = Introspector.getBeanInfo(clazz);

			// 獲取實體屬性描述集合
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (int i = 0; i < propertyDescriptors.length; i++) {
				// 獲取屬性描述
				PropertyDescriptor descriptor = propertyDescriptors[i];

				// 獲取屬性名
				String propertyName = descriptor.getName();
				if (!propertyName.equals("class")) {
					columns += propertyName + ",";
				}
			}
		} catch (IntrospectionException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
		return columns.substring(0, columns.length() - 1);
	}
	
	/**
	 * 通過實體class獲取實體列表資料（無條件）
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體資料（無條件）
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @return
	 */
	public Map<String, Object> getByBean(Class<?> clazz) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		
		return commonMapper.findOneData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param whereSql 查詢條件
	 * @return
	 */
	public Map<String, Object> getBean(Class<?> clazz, String whereSql) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//條件
		sql.append(' ').append(whereSql);
		
		return commonMapper.findOneData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param whereSql 查詢條件
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz, String whereSql) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//條件
		sql.append(' ').append(whereSql);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz, String whereSql, int page, int rows) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//條件
		sql.append(' ').append(whereSql);
		//分頁
		sql.append(" limit ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @param sortColumn 排序欄位
	 * @param sort 排序方式
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz, String whereSql, int page, int rows, String sortColumn, String sort) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//條件
		sql.append(' ').append(whereSql);
		//排序
		sql.append(" ORDER BY ").append(sortColumn).append(' ').append(sort);
		//分頁
		sql.append(" LIMIT ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz, int page, int rows) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//分頁
		sql.append(" limit ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @param sortColumn 排序欄位
	 * @param sort 排序方式
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(Class<?> clazz, int page, int rows, String sortColumn, String sort) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append("SELECT ").append(getClassColumns(clazz)).append(" FROM ").append(getTableName(clazz));
		//排序
		sql.append(" ORDER BY ").append(sortColumn).append(' ').append(sort);
		//分頁
		sql.append(" LIMIT ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param sqlStr 自己寫的SQL語句
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(String sqlStr, String whereSql, int page, int rows) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append(sqlStr);
		//條件
		sql.append(' ').append(whereSql);
		//分頁
		sql.append(" limit ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param sqlStr 自己寫的SQL語句
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @param sortColumn 排序欄位
	 * @param sort 排序方式
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(String sqlStr, String whereSql, int page, int rows, String sortColumn, String sort) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append(sqlStr);
		//條件
		sql.append(' ').append(whereSql);
		//排序
		sql.append(" ORDER BY ").append(sortColumn).append(' ').append(sort);
		//分頁
		sql.append(" LIMIT ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 通過實體class獲取實體列表資料
	 * 
	 * @author zhy
	 * @param sqlStr 自己寫的SQL語句
	 * @param whereSql 查詢條件
	 * @param page 開始頁
	 * @param rows 查詢的條數
	 * @return
	 */
	public List<Map<String, Object>> getListByBean(String sqlStr, int page, int rows) {
		StringBuffer sql = new StringBuffer();
		//查詢部分
		sql.append(sqlStr);
		//分頁
		sql.append(" limit ").append((page - 1) * rows).append(',').append(rows);
		
		return commonMapper.findManyData(sql.toString());
	}
	
	/**
	 * 批量刪除
	 * 
	 * @author zhy
	 * @param clazz 實體Class
	 * @param deleteList 刪除的集合
	 * @param deleteColumnName 批量刪除條件欄位
	 * @return
	 */
	public int batchDelete(Class<?> clazz, List<?> deleteList, String deleteColumnName) {
		Params params = new Params();
		params.setDeleteCoulumnName(deleteColumnName);
		params.setDeleteList(deleteList);
		params.setTables(getTableName(clazz));
		
		return commonMapper.batchDelete(params);
	}
}

Params.java

package com.beijingserver.pojo;


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


public class Params {
	/**查詢的列*/
	private String[] columns;
	
	/**查詢的實體*/
	private String tables;
	
	/**查詢的條件*/
	private String whereSql;
	
	/**查詢引數拼接*/
	private List<ParamCondition> paramList;
	
	/**起始位置*/
	private Integer start;
	
	/**結束位置*/
	private Integer end;
	
	/**排序欄位*/
	private String sortColumn;
	
	/**升序或倒序*/
	private String sort;
	
	/**新增引數*/
	private Map<String, Object> insertMap;
	
	/**批量新增引數*/
	private List<Map<String, Object>> bacthInsertMap;
	
	/**接受返回的主鍵ID*/
	private Long id;
	
	/**刪除欄位集合*/
	private List<?> deleteList;
	
	/** 刪除的欄位名 */
	private String deleteCoulumnName;


	public Long getId() {
		return id;
	}


	public void setId(Long id) {
		this.id = id;
	}


	public String[] getColumns() {
		return columns;
	}


	public void setColumns(String[] columns) {
		this.columns = columns;
	}


	public String getTables() {
		return tables;
	}


	public void setTables(String tables) {
		this.tables = tables;
	}


	public String getWhereSql() {
		return whereSql;
	}


	public void setWhereSql(String whereSql) {
		this.whereSql = whereSql;
	}


	public List<ParamCondition> getParamList() {
		return paramList;
	}


	public void setParamList(List<ParamCondition> paramList) {
		this.paramList = paramList;
	}


	public Integer getStart() {
		return start;
	}


	public void setStart(Integer start) {
		this.start = start;
	}


	public Integer getEnd() {
		return end;
	}


	public void setEnd(Integer end) {
		this.end = end;
	}


	public String getSortColumn() {
		return sortColumn;
	}


	public void setSortColumn(String sortColumn) {
		this.sortColumn = sortColumn;
	}


	public String getSort() {
		return sort;
	}


	public void setSort(String sort) {
		this.sort = sort;
	}


	public Map<String, Object> getInsertMap() {
		return insertMap;
	}


	public void setInsertMap(Map<String, Object> insertMap) {
		this.insertMap = insertMap;
	}


	public List<Map<String, Object>> getBacthInsertMap() {
		return bacthInsertMap;
	}


	public void setBacthInsertMap(List<Map<String, Object>> bacthInsertMap) {
		this.bacthInsertMap = bacthInsertMap;
	}


	public List<?> getDeleteList() {
		return deleteList;
	}


	public void setDeleteList(List<?> deleteList) {
		this.deleteList = deleteList;
	}


	public String getDeleteCoulumnName() {
		return deleteCoulumnName;
	}


	public void setDeleteCoulumnName(String deleteCoulumnName) {
		this.deleteCoulumnName = deleteCoulumnName;
	}
	
}

ParamCondition.java

package com.beijingserver.pojo;

public class ParamCondition {
	/**連線符號*/
	private String connSymbol;
	
	/**欄位名*/
	private String column;
	
	/**判斷符號*/
	private String judgeSymbol;
	
	/**欄位等於的值*/
	private Object value;
	
	/**結束符號*/
	private String symbolEnd;
	
	public String getConnSymbol() {
		return connSymbol;
	}

	public void setConnSymbol(String connSymbol) {
		this.connSymbol = connSymbol;
	}

	public String getColumn() {
		return column;
	}

	public void setColumn(String column) {
		this.column = column;
	}

	public String getJudgeSymbol() {
		return judgeSymbol;
	}

	public void setJudgeSymbol(String judgeSymbol) {
		this.judgeSymbol = judgeSymbol;
	}

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}

	public String getSymbolEnd() {
		return symbolEnd;
	}

	public void setSymbolEnd(String symbolEnd) {
		this.symbolEnd = symbolEnd;
	}
	
}

Mybatis配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
">
	<!-- 自動掃描(自動注入) -->
	<context:component-scan base-package="com.beijingserver.*" />
	<!-- 引入屬性檔案 -->
  	<bean id="configProperties"
		class="org.springframework.beans.factory.config.PropertiesFactoryBean">
		<property name="locations">
			<list>
				<value>classpath:jdbc.properties</value>
			</list>
		</property>
	</bean>
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="properties" ref="configProperties" />
	</bean>
  	
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close" >  
        <property name="url" value="${jdbc.url}" />  
        <property name="username" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" />  
        <property name="initialSize" value="${jdbc.initialSize}" />  
        <property name="minIdle" value="${jdbc.minIdle}" />  
        <property name="maxActive" value="${jdbc.maxActive}" />  
          
        <!-- 配置獲取連線等待超時的時間 -->  
        <property name="maxWait" value="60000" />  
        <!-- 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連線，單位是毫秒 -->  
        <property name="timeBetweenEvictionRunsMillis" value="60000" />  
        <!-- 配置一個連線在池中最小生存的時間，單位是毫秒 -->  
        <property name="minEvictableIdleTimeMillis" value="300000" />  
        <property name="validationQuery" value="SELECT 'x'" />  
        <property name="testWhileIdle" value="true" />  
        <property name="testOnBorrow" value="false" />  
        <property name="testOnReturn" value="false" />  
        <!-- 配置監控統計攔截的filters -->  
        <property name="filters" value="stat" />   
	</bean>
	
	<!-- myBatis檔案 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<!-- 自動掃描entity目錄, 省掉Configuration.xml裡的手工配置 -->
		<property name="mapperLocations" value="classpath*:com/beijingserver/mapping/*.xml" />
	</bean>
	
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.beijingserver.mapper" />
	</bean>
</beans>

jdbc配置

#hibernate.dialect=com.bky.util.Oracle10gDialect
#driverClassName=oracle.jdbc.driver.OracleDriver
#validationQuery=SELECT 1 FROM DUAL
#jdbc_url=jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=Baikeyang)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=orcl)))
#jdbc_username=sshe
#jdbc_password=1234

#hibernate.dialect=org.hibernate.dialect.Oracle9Dialect
#driverClassName=oracle.jdbc.driver.OracleDriver
#validationQuery=SELECT 1 FROM DUAL
#jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
#jdbc_username=sshe
#jdbc_password=1234

#hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#------------此處定義資料庫連線------------#
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://192.168.0.40\:3306/XINLANDETESTDB?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull
jdbc.username=devuser
jdbc.dbType=mysql
jdbc.password=devpassword
jdbc.filters=stat
jdbc.maxActive=10000
jdbc.initialSize=3
jdbc.maxWait=60000
jdbc.minIdle=2
jdbc.timeBetweenEvictionRunsMillis=60000
jdbc.minEvictableIdleTimeMillis=300000
jdbc.validationQuery=SELECT 1
jdbc.testWhileIdle=true
jdbc.testOnBorrow=false
jdbc.testOnReturn=false
jdbc.poolPreparedStatements=false
jdbc.maxOpenPreparedStatements=20
jdbc.removeAbandoned=true
jdbc.removeAbandonedTimeout=1800
jdbc.logAbandoned=true

#hibernate.dialect=org.hibernate.dialect.SQLServer2008Dialect
#driverClassName=net.sourceforge.jtds.jdbc.Driver
#validationQuery=SELECT 1
#jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/dbName
#jdbc_username=sa
#jdbc_password=123456

#jndiName=java:comp/env/BenDiShuJuYuan

#hibernate.hbm2ddl.auto=update
#hibernate.show_sql=true
#hibernate.format_sql=true
#hibernate.use_sql_comments=true

#sessionInfoName=sessionInfo

#uploadPath=/ssheUpupLoadPath

pom.xml 檔案

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>priv.zhouhuayi.packing</groupId>
		<artifactId>parent</artifactId>
		<version>1.0</version>
	</parent>
	<artifactId>commondao</artifactId>

	<dependencies>
		<!-- 引入實體pojo類 -->
		<dependency>
			<groupId>priv.zhouhuayi.packing</groupId>
			<artifactId>pojo</artifactId>
			<version>${project.version}</version>
		</dependency>
		<!-- mybatis jar包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<!-- 匯入Mysql資料庫連結jar包 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>
		<!-- druid資料來源 jar包 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>${druid.version}</version>
		</dependency>
		<!-- spring和心jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring物件對映jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring jdbc資料 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring核心擴充套件jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- spring測試jar -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- mybatis/spring 整合包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis-spring.version}</version>
		</dependency>
	</dependencies>
</project>

測試類

import javax.annotation.Resource;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import priv.zhouhuayi.packing.mapper.common.CommonMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:Mybatis.xml"})
public class CommonDaoTest {
	
	@Resource
	private CommonMapper commonMapper;
	
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		
	}

	@Test
	public void test() {
		System.out.println(commonMapper);
		String sql = "select * from manager";
		System.out.println(commonMapper.findManyData(sql));
	}

}

mybatis 將sql寫在java程式碼中

第一部分：Common.xml (mybatis sql執行檔案這裡通過java傳參形成sql語句) 下面包含各種傳參查詢和傳入sql語句進行查詢（注入問題在java中進行處理）新增和批量新增批量刪除修改在CommonDao中第二部分：CommonMapper.ja

jsp檔案中寫Java程式碼報錯

今天學習Java web的時候寫了個簡單的jsp檔案，裡面寫了兩句Java程式碼，沒想到居然報錯了：報的錯誤是：然後百度了一下，發現很多的原因都和我不一樣的，最後還是從以前的一本舊書JA

如何將JSP中的java程式碼中的值，傳入JS程式碼中去

經過大半天的研究摸索，終於弄明白怎麼把JSP中的java程式碼中的值，傳入JS程式碼中去。由於自己才剛剛開始接觸javaWEB 開發，今天在那兒做使用者登入功能，使用者在未登入時顯示“登入”連結，登入後在原來“登入”的地方，改變為使用者的暱稱！由於自己一點經驗也沒有，以為就一個session就夠了，在

Idea 將新寫的專案中的一個java檔案搞成jar包方法

啥都不說，come on！先新建一個java專案，這邊不做介紹然後在src下面自己建使用的方法吧然後開始打包：在File->Project Structure->Ar

帆軟將cpt檔案的報表嵌入到java程式碼中的jsp檔案中

將FineReport 整合到自己的web專案中，生成報表，可以方便快捷的和自己的專案融合在一起。簡化了利用poi的匯出遇到的問題。 1、首先在FR中建立好一個模板例如：我的這張模板是連線的自己的資料庫 2、將FR軟體下的jar包新增到自己的專案中

springboot整合mybatis將sql打印到日誌(轉)

如何配置 ocl trac color ble tools 使用 logs lai 在前臺請求數據的時候，sql語句一直都是打印到控制臺的，有一個想法就是想讓它打印到日誌

URLParser:很實用的URL引數解析器（JAVA程式碼中方便獲取QueryString中的get引數）

很實用的URL引數解析器（JAVA程式碼中方便獲取QueryString中的get引數） package com.kaishustory.quick.commons.text; import java.io.UnsupportedEncodingException; import

Java基礎 - java程式碼中會用到的語句結構

一. 條件選擇語句 if...else 結構 1、基礎格式: A.單if語句

2018.10.11在Java程式碼中控制UI介面（桌面檯球）

MainActivity : package com.example.mcq; import android.app.AlertDialog; import android.content.DialogInterface; import android.graphics.Color; impo

Java程式碼中的try ..finally返回值問題

首先明確一點，finally 塊中的 return 返回後方法結束執行，不會再執行 try 塊中的 return 語句。那麼如果finally修改某個變數會影響try中的返回值嗎？程式碼如下： private static Map<String, String> fin

notepad++編輯器寫Java程式碼，無法編譯出現錯誤：編碼GBK的不可對映字元

所報錯誤:編碼GBK的不可對映字元解決方案：　 1.英文版notepad++ 　　選單：Configure --> Options --> JDK Tools --> Compiler

寫Java程式碼分別使堆溢位,棧溢位

原文連結：https://www.cnblogs.com/tv151579/p/3647238.html 轉自：http://fxlzs2000.iteye.com/blog/1786407 轉自：http://my.oschina.net/sdrkyj/blog/143410 前言 primitiv

Android-廣播發送與接收(Java程式碼中訂閱)

Android四大元件之一廣播，使用的也比較多，廣播可大致分為兩種，一種是Android系統區域的廣播，是由系統指令發出，例如：點亮螢幕廣播，開機過程中的一些廣播省略…, 然而還有一種廣播就是我們自己定義，自己來控制發出的廣播，以下就簡單介紹以下，在程式碼中傳送廣播和接收廣播：第一步

android 在java程式碼中動態設定控制元件的位置和設定片大小

需要動態改變佈局裡面控制元件的相對位置如： 1.改變RelativeLayout佈局裡面某個控制元件的layout_toLeftOf 的屬性 RelativeLayout.Layoutparams params = (RelativeLayout.LayoutParams)view

redis的哨兵和cluster在java程式碼中的配置

1.哨兵： applicationContext.xml:  <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig

mongodb命令列group分組和java程式碼中group分組

group分組統計是資料庫比較常用的功能，mongodb也不例外。不過相對於普通的增刪改查，group操作就略微麻煩一些，這裡對group在shell中的操作、使用java原生程式碼操作以及整合spri

java程式碼中操作Redis：單機redis、叢集redis（spring+redis整合）

一、準備關於redis的一些安裝，可以檢視我的幾篇文章自行安裝：Redis目錄。匯入java的Redis客戶端依賴包Jedis:<dependency> <groupId>redis.clients</groupId

寫java程式碼的時候的優化策略

1.儘量採用Clone()方式來建立物件 2.儘量避免對boolean型別的判斷：如if（a==true） 3.多采用條件操作符（為了程式碼簡潔） 4.多用靜態方法代替例項方法，減少耗時 5.慎用fi

如何在Java程式碼中檢查字串中是否包含中文？

今天和同事在討論一個問題，需要檢查“輸入的字串中是否包含中文”，剛開始想到是用正則表示式，正則表示式中是以[u4e00-u9fa5]來全匹配字元是否是中文，但現在面臨的問題是這個字串中還可能包含英文字元、數字、特殊字元，一時也沒想出能匹配該場景的正則表示式，後來在網上搜了下，可以使用Matcher類

java程式碼中得到本地ip地址。獲取客戶端請求IP（終端使用者的網際網路或內網IP地址）

private static String getLocalIP() throws Exception{ String localIP = ""; InetAddress addr = (InetAddress) InetAddress.getLocalHos

mybatis 將sql寫在java程式碼中

第一部分：Common.xml (mybatis sql執行檔案 這裡通過java傳參形成sql語句)

第二部分：CommonMapper.java (介面類)

第三部分：CommonDao.java 基於CommonMapper實現sql語句實現方法呼叫引數化（具體方法檢視CommonDao類中有註釋）

第四部分：Params.java，ParamCondition.java (引數接受傳遞類，具體引數檢視此類)

第五部分：Mybatis.xml (mybatis與mysql之間的資料連線配置)

第六部分：jdbc.properties （資料來源配置）

第七部分：pom.xml （maven包引用配置）

第八部分： CommonDaoTest （測試類）

Common.xml

CommonMapper.java

CommonDao.java

Params.java

Mybatis配置

jdbc配置

pom.xml 檔案

測試類

相關推薦

第一部分：Common.xml (mybatis sql執行檔案這裡通過java傳參形成sql語句)