介面層-和資料庫互動的方式

MyBatis和資料庫的互動有兩種方式：

使用傳統的MyBatis提供的API；

使用Mapper介面；

使用Mapper介面

MyBatis 將配置檔案中的每一個<mapper> 節點抽象為一個 Mapper 介面：

這個介面中宣告的方法和<mapper> 節點中的<select|update|delete|insert> 節點項對應，即<select|update|delete|insert> 節點的id值為Mapper 介面中的方法名稱，parameterType 值表示Mapper 對應方法的入參型別，而resultMap 值則對應了Mapper 介面表示的返回值型別或者返回結果集的元素型別。

根據MyBatis 的配置規範配置好後，通過SqlSession.getMapper(XXXMapper.class)方法，MyBatis 會根據相應的介面宣告的方法資訊，通過動態代理機制生成一個Mapper 例項，我們使用Mapper介面的某一個方法時，MyBatis會根據這個方法的方法名和引數型別，確定Statement Id，底層還是通過SqlSession.select("statementId",parameterObject);或者SqlSession.update("statementId",parameterObject); 等等來實現對資料庫的操作，MyBatis引用Mapper 介面這種呼叫方式，純粹是為了滿足面向介面程式設計的需要。（其實還有一個原因是在於，面向介面的程式設計，使得使用者在介面上可以使用註解來配置SQL語句，這樣就可以脫離XML配置檔案，實現“0配置”）。

資料處理層

資料處理層可以說是MyBatis的核心，從大的方面上講，它要完成兩個功能：

通過傳入引數構建動態SQL語句；

SQL語句的執行以及封裝查詢結果整合List<E>；

框架支撐層

事務管理機制

事務管理機制對於ORM框架而言是不可缺少的一部分，事務管理機制的質量也是考量一個ORM框架是否優秀的一個標準。

連線池管理機制

由於建立一個數據庫連線所佔用的資源比較大，對於資料吞吐量大和訪問量非常大的應用而言，連線池的設計就顯得非常重要。

快取機制

為了提高資料利用率和減小伺服器和資料庫的壓力，MyBatis 會對於一些查詢提供會話級別的資料快取，會將對某一次查詢，放置到SqlSession 中，在允許的時間間隔內，對於完全相同的查詢，MyBatis會直接將快取結果返回給使用者，而不用再到資料庫中查詢。

SQL語句的配置方式

傳統的MyBatis 配置SQL語句方式就是使用XML檔案進行配置的，但是這種方式不能很好地支援面向介面程式設計的理念，為了支援面向介面的程式設計，MyBatis 引入了Mapper介面的概念，面向介面的引入，對使用註解來配置SQL語句成為可能，使用者只需要在介面上新增必要的註解即可，不用再去配置XML檔案了，但是，目前的MyBatis 只是對註解配置SQL語句提供了有限的支援，某些高階功能還是要依賴XML配置檔案配置SQL 語句。

引導層

引導層是配置和啟動MyBatis配置資訊的方式。MyBatis 提供兩種方式來引導MyBatis ：基於XML配置檔案的方式和基於Java API 的方式。

主要構件及其相互關係

從MyBatis程式碼實現的角度來看，MyBatis的主要的核心部件有以下幾個：

SqlSession：作為MyBatis工作的主要頂層API，表示和資料庫互動的會話，完成必要資料庫增刪改查功能；

Executor：MyBatis執行器，是MyBatis 排程的核心，負責SQL語句的生成和查詢快取的維護；

StatementHandler：封裝了JDBC Statement操作，負責對JDBC statement 的操作，如設定引數、將Statement結果集轉換成List集合。

ParameterHandler：負責對使用者傳遞的引數轉換成JDBC Statement 所需要的引數；

ResultSetHandler：負責將JDBC返回的ResultSet結果集物件轉換成List型別的集合；

TypeHandler：負責java資料型別和jdbc資料型別之間的對映和轉換；

MappedStatement：MappedStatement維護了一條<select|update|delete|insert>節點的封裝；

SqlSource：負責根據使用者傳遞的parameterObject，動態地生成SQL語句，將資訊封裝到BoundSql物件中，並返回；

BoundSql：表示動態生成的SQL語句以及相應的引數資訊；

Configuration：MyBatis所有的配置資訊都維持在Configuration物件之中；

純手寫Mybatis程式碼

定義JDBCUtils

public final class JDBCUtils {

	private static String connect;
	private static String driverClassName;
	private static String URL;
	private static String username;
	private static String password;
	private static boolean autoCommit;

	/** 宣告一個 Connection型別的靜態屬性，用來快取一個已經存在的連線物件 */
	private static Connection conn;

	static {
		config();
	}

	/**
	 * 開頭配置自己的資料庫資訊
	 */
	private static void config() {
		/*
		 * 獲取驅動
		 */
		driverClassName = "com.mysql.jdbc.Driver";
		/*
		 * 獲取URL
		 */
		URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
		/*
		 * 獲取使用者名稱
		 */
		username = "root";
		/*
		 * 獲取密碼
		 */
		password = "mysql";
		/*
		 * 設定是否自動提交，一般為false不用改
		 */
		autoCommit = false;

	}

	/**
	 * 載入資料庫驅動類
	 */
	private static boolean load() {
		try {
			Class.forName(driverClassName);
			return true;
		} catch (ClassNotFoundException e) {
			System.out.println("驅動類 " + driverClassName + " 載入失敗");
		}

		return false;
	}

	/**
	 * 專門檢查快取的連線是否不可以被使用 ，不可以被使用的話，就返回 true
	 */
	private static boolean invalid() {
		if (conn != null) {
			try {
				if (conn.isClosed() || !conn.isValid(3)) {
					return true;
					/*
					 * isValid方法是判斷Connection是否有效,如果連線尚未關閉並且仍然有效，則返回 true
					 */
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			/*
			 * conn 既不是 null 且也沒有關閉 ，且 isValid 返回 true，說明是可以使用的 ( 返回 false )
			 */
			return false;
		} else {
			return true;
		}
	}

	/**
	 * 建立資料庫連線
	 */
	public static Connection connect() {
		if (invalid()) { /* invalid為true時，說明連線是失敗的 */
			/* 載入驅動 */
			load();
			try {
				/* 建立連線 */
				conn = DriverManager.getConnection(URL, username, password);
			} catch (SQLException e) {
				System.out.println("建立 " + connect + " 資料庫連線失敗 , " + e.getMessage());
			}
		}
		return conn;
	}

	/**
	 * 設定是否自動提交事務
	 **/
	public static void transaction() {

		try {
			conn.setAutoCommit(autoCommit);
		} catch (SQLException e) {
			System.out.println("設定事務的提交方式為 : " + (autoCommit ? "自動提交" : "手動提交") + " 時失敗: " + e.getMessage());
		}

	}

	/**
	 * 建立 Statement 物件
	 */
	public static Statement statement() {
		Statement st = null;
		connect();
		/* 如果連線是無效的就重新連線 */
		transaction();
		/* 設定事務的提交方式 */
		try {
			st = conn.createStatement();
		} catch (SQLException e) {
			System.out.println("建立 Statement 物件失敗: " + e.getMessage());
		}

		return st;
	}

	/**
	 * 根據給定的帶引數佔位符的SQL語句，建立 PreparedStatement 物件
	 * 
	 * @param SQL
	 *            帶引數佔位符的SQL語句
	 * @return 返回相應的 PreparedStatement 物件
	 */
	private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {

		PreparedStatement ps = null;
		connect();
		/* 如果連線是無效的就重新連線 */
		transaction();
		/* 設定事務的提交方式 */
		try {
			if (autoGeneratedKeys) {
				ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
			} else {
				ps = conn.prepareStatement(SQL);
			}
		} catch (SQLException e) {
			System.out.println("建立 PreparedStatement 物件失敗: " + e.getMessage());
		}

		return ps;

	}

	public static ResultSet query(String SQL, List<Object> params) {

		if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
			throw new RuntimeException("你的SQL語句為空或不是查詢語句");
		}
		ResultSet rs = null;
		if (params.size() > 0) {
			/* 說明 有引數 傳入，就需要處理引數 */
			PreparedStatement ps = prepare(SQL, false);
			try {
				for (int i = 0; i < params.size(); i++) {
					ps.setObject(i + 1, params.get(i));
				}
				rs = ps.executeQuery();
			} catch (SQLException e) {
				System.out.println("執行SQL失敗: " + e.getMessage());
			}
		} else {
			/* 說明沒有傳入任何引數 */
			Statement st = statement();
			try {
				rs = st.executeQuery(SQL); // 直接執行不帶引數的 SQL 語句
			} catch (SQLException e) {
				System.out.println("執行SQL失敗: " + e.getMessage());
			}
		}

		return rs;

	}

	private static Object typeof(Object o) {
		Object r = o;

		if (o instanceof java.sql.Timestamp) {
			return r;
		}
		// 將 java.util.Date 轉成 java.sql.Date
		if (o instanceof java.util.Date) {
			java.util.Date d = (java.util.Date) o;
			r = new java.sql.Date(d.getTime());
			return r;
		}
		// 將 Character 或 char 變成 String
		if (o instanceof Character || o.getClass() == char.class) {
			r = String.valueOf(o);
			return r;
		}
		return r;
	}

	public static boolean execute(String SQL, Object... params) {
		if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
			throw new RuntimeException("你的SQL語句為空或有錯");
		}
		boolean r = false;
		/* 表示 執行 DDL 或 DML 操作是否成功的一個標識變數 */

		/* 獲得 被執行的 SQL 語句的 字首 */
		SQL = SQL.trim();
		SQL = SQL.toLowerCase();
		String prefix = SQL.substring(0, SQL.indexOf(" "));
		String operation = ""; // 用來儲存操作型別的 變數
		// 根據字首 確定操作
		switch (prefix) {
		case "create":
			operation = "create table";
			break;
		case "alter":
			operation = "update table";
			break;
		case "drop":
			operation = "drop table";
			break;
		case "truncate":
			operation = "truncate table";
			break;
		case "insert":
			operation = "insert :";
			break;
		case "update":
			operation = "update :";
			break;
		case "delete":
			operation = "delete :";
			break;
		}
		if (params.length > 0) { // 說明有引數
			PreparedStatement ps = prepare(SQL, false);
			Connection c = null;
			try {
				c = ps.getConnection();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				for (int i = 0; i < params.length; i++) {
					Object p = params[i];
					p = typeof(p);
					ps.setObject(i + 1, p);
				}
				ps.executeUpdate();
				commit(c);
				r = true;
			} catch (SQLException e) {
				System.out.println(operation + " 失敗: " + e.getMessage());
				rollback(c);
			}

		} else { // 說明沒有引數

			Statement st = statement();
			Connection c = null;
			try {
				c = st.getConnection();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			// 執行 DDL 或 DML 語句，並返回執行結果
			try {
				st.executeUpdate(SQL);
				commit(c); // 提交事務
				r = true;
			} catch (SQLException e) {
				System.out.println(operation + " 失敗: " + e.getMessage());
				rollback(c); // 回滾事務
			}
		}
		return r;
	}

	/*
	 * 
	 * @param SQL 需要執行的 INSERT 語句
	 * 
	 * @param autoGeneratedKeys 指示是否需要返回由資料庫產生的鍵
	 * 
	 * @param params 將要執行的SQL語句中包含的引數佔位符的 引數值
	 * 
	 * @return 如果指定 autoGeneratedKeys 為 true 則返回由資料庫產生的鍵； 如果指定 autoGeneratedKeys
	 * 為 false 則返回受當前SQL影響的記錄數目
	 */
	public static int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) {
		int var = -1;
		if (SQL == null || SQL.trim().isEmpty()) {
			throw new RuntimeException("你沒有指定SQL語句，請檢查是否指定了需要執行的SQL語句");
		}
		// 如果不是 insert 開頭開頭的語句
		if (!SQL.trim().toLowerCase().startsWith("insert")) {
			System.out.println(SQL.toLowerCase());
			throw new RuntimeException("你指定的SQL語句不是插入語句，請檢查你的SQL語句");
		}
		// 獲得 被執行的 SQL 語句的 字首 ( 第一個單詞 )
		SQL = SQL.trim();
		SQL = SQL.toLowerCase();
		if (params.size() > 0) { // 說明有引數
			PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
			Connection c = null;
			try {
				c = ps.getConnection(); // 從 PreparedStatement 物件中獲得 它對應的連線物件
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				for (int i = 0; i < params.size(); i++) {
					Object p = params.get(i);
					p = typeof(p);
					ps.setObject(i + 1, p);
				}
				int count = ps.executeUpdate();
				if (autoGeneratedKeys) { // 如果希望獲得資料庫產生的鍵
					ResultSet rs = ps.getGeneratedKeys(); // 獲得資料庫產生的鍵集
					if (rs.next()) { // 因為是儲存的是單條記錄，因此至多返回一個鍵
						var = rs.getInt(1); // 獲得值並賦值給 var 變數
					}
				} else {
					var = count; // 如果不需要獲得，則將受SQL影像的記錄數賦值給 var 變數
				}
				commit(c);
			} catch (SQLException e) {
				System.out.println("資料儲存失敗: " + e.getMessage());
				rollback(c);
			}
		} else { // 說明沒有引數
			Statement st = statement();
			Connection c = null;
			try {
				c = st.getConnection(); // 從 Statement 物件中獲得 它對應的連線物件
			} catch (SQLException e) {
				e.printStackTrace();
			}
			// 執行 DDL 或 DML 語句，並返回執行結果
			try {
				int count = st.executeUpdate(SQL);
				if (autoGeneratedKeys) { // 如果企望獲得資料庫產生的鍵
					ResultSet rs = st.getGeneratedKeys(); // 獲得資料庫產生的鍵集
					if (rs.next()) { // 因為是儲存的是單條記錄，因此至多返回一個鍵
						var = rs.getInt(1); // 獲得值並賦值給 var 變數
					}
				} else {
					var = count; // 如果不需要獲得，則將受SQL影像的記錄數賦值給 var 變數
				}
				commit(c); // 提交事務
			} catch (SQLException e) {
				System.out.println("資料儲存失敗: " + e.getMessage());
				rollback(c); // 回滾事務
			}
		}
		return var;
	}

	/** 提交事務 */
	private static void commit(Connection c) {
		if (c != null && !autoCommit) {
			try {
				c.commit();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/** 回滾事務 */
	private static void rollback(Connection c) {
		if (c != null && !autoCommit) {
			try {
				c.rollback();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 釋放資源
	 **/
	public static void release(Object cloaseable) {

		if (cloaseable != null) {

			if (cloaseable instanceof ResultSet) {
				ResultSet rs = (ResultSet) cloaseable;
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (cloaseable instanceof Statement) {
				Statement st = (Statement) cloaseable;
				try {
					st.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (cloaseable instanceof Connection) {
				Connection c = (Connection) cloaseable;
				try {
					c.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}

定義MyInvocationHandlerMbatis

/**
 * 功能說明:手寫mybatis框架註解版本 <br>
 * 1.使用動態代理技術,獲取介面方法上的sql語句<br>
 * 2.根據不同的SQL語句<br>
 */
public class MyInvocationHandlerMbatis implements InvocationHandler {

	/**
	 * 這個就是我們要代理的真實物件
	 */
	private Object subject;

	/**
	 * 構造方法，給我們要代理的真實物件賦初值
	 * 
	 * @param subject
	 */
	public MyInvocationHandlerMbatis(Object subject) {
		this.subject = subject;
	}

	/**
	 * 該方法負責集中處理動態代理類上的所有方法呼叫。 呼叫處理器根據這三個引數進行預處理或分派到委託類例項上反射執行
	 * 
	 * @param proxy
	 *            代理類例項
	 * @param method
	 *            被呼叫的方法物件
	 * @param args
	 *            呼叫引數
	 * @return
	 * @throws Throwable
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 判斷方法上是否有ExtInsert註解
		ExtInsert extInsert = method.getAnnotation(ExtInsert.class);
		if (extInsert != null) {
			return insertSQL(extInsert, method, args);
		}
		// 判斷方法上註解型別
		ExtSelect extSelect = method.getAnnotation(ExtSelect.class);
		if (extSelect != null) {
			return selectMybatis(extSelect, method, args);
		}

		return null;
	}

	public int insertSQL(ExtInsert extInsert, Method method, Object[] args) {
		// 獲取註解上的sql
		String insertSql = extInsert.value();
		System.out.println("sql:" + insertSql);
		// 獲取方法上的引數
		Parameter[] parameters = method.getParameters();
		// 將方法上的引數存放在Map集合中
		ConcurrentHashMap<Object, Object> parameterMap = getExtParams(parameters, args);
		// 獲取SQL語句上需要傳遞的引數
		String[] sqlParameter = SQLUtils.sqlInsertParameter(insertSql);
		List<Object> parameValues = new ArrayList<>();
		for (int i = 0; i < sqlParameter.length; i++) {
			String str = sqlParameter[i];
			Object object = parameterMap.get(str);
			parameValues.add(object);
		}
		// 將SQL語句替換為？號
		String newSql = SQLUtils.parameQuestion(insertSql, sqlParameter);
		System.out.println("newSql:" + newSql);
		// 呼叫jdbc程式碼執行
		int insertResult = JDBCUtils.insert(newSql, false, parameValues);
		return insertResult;
	}

	public Object selectMybatis(ExtSelect extInsert, Method method, Object[] args) throws SQLException {
		try {
			// 獲取查詢SQL語句
			String selectSQL = extInsert.value();
			// 將方法上的引數存放在Map集合中
			Parameter[] parameters = method.getParameters();
			// 獲取方法上引數集合
			ConcurrentHashMap<Object, Object> parameterMap = getExtParams(parameters, args);
			// 獲取SQL傳遞引數
			List<String> sqlSelectParameter = SQLUtils.sqlSelectParameter(selectSQL);
			// 排序引數
			List<Object> parameValues = new ArrayList<>();
			for (int i = 0; i < sqlSelectParameter.size(); i++) {
				String parameterName = sqlSelectParameter.get(i);
				Object object = parameterMap.get(parameterName);
				parameValues.add(object.toString());
			}
			// 變為?號
			String newSql = SQLUtils.parameQuestion(selectSQL, sqlSelectParameter);
			System.out.println("執行SQL:" + newSql + "引數資訊:" + parameValues.toString());
			// 呼叫JDBC程式碼查詢
			ResultSet rs = JDBCUtils.query(newSql, parameValues);
			// 獲取返回型別
			Class<?> returnType = method.getReturnType();
			if (!rs.next()) {
				// 沒有查詢資料
				return null;
			}
			// 向上移動
			rs.previous();
			// 例項化物件
			Object newInstance = returnType.newInstance();
			while (rs.next()) {
				for (String parameterName : sqlSelectParameter) {
					// 獲取集合中資料
					Object value = rs.getObject(parameterName);
					// 查詢對應屬性
					Field field = returnType.getDeclaredField(parameterName);
					// 設定允許私有訪問
					field.setAccessible(true);
					// 賦值引數
					field.set(newInstance, value);
				}

			}
			return newInstance;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	private ConcurrentHashMap<Object, Object> getExtParams(Parameter[] parameters, Object[] args) {
		// 獲取方法上引數集合
		ConcurrentHashMap<Object, Object> parameterMap = new ConcurrentHashMap<>();
		for (int i = 0; i < parameters.length; i++) {
			// 引數資訊
			Parameter parameter = parameters[i];
			ExtParam extParam = parameter.getDeclaredAnnotation(ExtParam.class);
			// 引數名稱
			String paramValue = extParam.value();
			// 引數值
			Object oj = args[i];
			parameterMap.put(paramValue, oj);
		}
		return parameterMap;
	}
}

定義SqlSession

/**
 * 獲取SqlSession物件<br>
 */
public class SqlSession {

	// 獲取getMapper
	public static <T> T getMapper(Class<T> clas)
			throws IllegalArgumentException, InstantiationException, IllegalAccessException {
		return (T) Proxy.newProxyInstance(clas.getClassLoader(), new Class[] { clas },
				new MyInvocationHandlerMbatis(clas));
	}

}

定義SQLUtils

/**
 * SQL拼接<br>
 */
public class SQLUtils {
	/**
	 * 
	 * 獲取Insert語句後面values 引數資訊<br>
	 * @param sql
	 * @return
	 */
	public static String[] sqlInsertParameter(String sql) {
		int startIndex = sql.indexOf("values");
		int endIndex = sql.length();
		String substring = sql.substring(startIndex + 6, endIndex).replace("(", "").replace(")", "").replace("#{", "")
				.replace("}", "");
		String[] split = substring.split(",");
		return split;
	}

	/**
	 * 
	 * 獲取select 後面where語句<br>
	 * @param sql
	 * @return
	 */
	public static List<String> sqlSelectParameter(String sql) {
		int startIndex = sql.indexOf("where");
		int endIndex = sql.length();
		String substring = sql.substring(startIndex + 5, endIndex);
		String[] split = substring.split("and");
		List<String> listArr = new ArrayList<>();
		for (String string : split) {
			String[] sp2 = string.split("=");
			listArr.add(sp2[0].trim());
		}
		return listArr;
	}

	/**
	 * 將SQL語句的引數替換變為?<br>
	 * @param sql
	 * @param parameterName
	 * @return
	 */
	public static String parameQuestion(String sql, String[] parameterName) {
		for (int i = 0; i < parameterName.length; i++) {
			String string = parameterName[i];
			sql = sql.replace("#{" + string + "}", "?");
		}
		return sql;
	}

	public static String parameQuestion(String sql, List<String> parameterName) {
		for (int i = 0; i < parameterName.size(); i++) {
			String string = parameterName.get(i);
			sql = sql.replace("#{" + string + "}", "?");
		}
		return sql;
	}

	public static void main(String[] args) {
		// String sql = "insert into user(userName,userAge)
		// values(#{userName},#{userAge})";
		// String[] sqlParameter = sqlInsertParameter(sql);
		// for (String string : sqlParameter) {
		// System.out.println(string);
		// }
		List<String> sqlSelectParameter = SQLUtils
				.sqlSelectParameter("select * from User where userName=#{userName} and userAge=#{userAge} ");
		for (String string : sqlSelectParameter) {
			System.out.println(string);
		}
	}
}

執行效果

UserDao mapper = SqlSession.getMapper(UserDao.class);
		int insertUser = mapper.insertUser(22, "小盒子");
		System.out.println("影響行數:" + insertUser);
		User user = mapper.selectUser("Xiaoxin", 21);
		System.out.println("查詢結果:" + user.getUserName() + "," + user.getUserAge());