JDK常用核心原理
概述
在 Mybatis 中，常用的作用就是講資料庫中的表的欄位對映為物件的屬性，在進入Mybatis之前，原生的 JDBC 有幾個步驟：匯入 JDBC 驅動包，通過 DriverManager 註冊驅動，建立連線，建立 Statement，增刪改查，操作結果集，關閉連線
過程詳解
首先進行類的載入，通過 DriverManager 註冊驅動
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("");
為什麼在這裡可以直接註冊進去，com.mysql.jdbc.Driver 被載入到 Driver.class ，在 DriverManager 中，首先有一個靜態程式碼塊來進行初始化載入 Driver
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
通過 loadInitialDrivers()，來載入 Driver，拿出 jdbc.drivers，通過 ServiceLoader 讀取 Driver.class，讀取拿出 driver 和 所有迭代器，一直迭代
private static void loadInitialDrivers() {
String drivers;
// 訪問修飾符，在這裡把 jdbc.drivers 拿出來
try {
drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = null;
}
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 讀取拿出 driver 和 所有迭代器
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
// 一直進行迭代
try{
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});
println("DriverManager.initialize: jdbc.drivers = " + drivers);
if (drivers == null || drivers.equals("")) {
return;
}
String[] driversList = drivers.split(":");
println("number of Drivers:" + driversList.length);
for (String aDriver : driversList) {
try {
println("DriverManager.Initialize: loading " + aDriver);
Class.forName(aDriver, true,
ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
}
}
從 Driver 載入完後，就可以得到一個和資料庫的連線 connection ，connection 就可以建立一個 Statement，Statement 就可以進行執行 sql 語句，將結果返回一個結果集，獲取出來的結果集遍歷放進一個 List 集合中
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("select * from mybatis.user");
while (resultSet.next()) {
int id = resultSet.getInt(1);
String username = resultSet.getString(2);
list.add(new User(id,username));
}
在原生的 JDBC 直接操作中，繁雜的步驟在業務程式碼中不會使用，而 Mybatis 可以在更好的便利度上使用
JDK動態代理
sql語句解析替換
在 JDK 動態代理中，利用了 Proxy 這個類來實現，在 Proxy 中，有著 newProxyInstance() 方法，建立一個動態代理例項
interface UserMapper {
@Select("select * from mybatis.user where id =#{id}")
List<User> selectUserList();
}
public static void main(String[] args) {
UserMapper userMapper = (UserMapper) Proxy.newProxyInstance(
JDKMybatis.class.getClassLoader(),
new Class<?>[]{UserMapper.class},
new InvocationHandler() {
/**
* 在 invoke() 方法中就可以進行查詢 method，args
* @param proxy 動態代理
* @param method 方法
* @param args 引數
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 把註解類獲取，可以查出註解的值等多種其他值
Select annotation = method.getAnnotation(Select.class);
if (annotation != null) {
String[] value = annotation.value();
System.out.println(Arrays.toString(value));
}
return null;
}
});
userMapper.selectUserList(1);
}
newProxyInstance() 的建立需要三個引數，檢視原始碼，可以知道需要 ClassLoader 類載入器，interfaces 介面（Mapper 介面），InvocationHandler 處理器，來進行處理
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
把 sql 語句中的引數取出來放進 args，這時需要一個 Map 來進行傳值
問題
當在通過反射獲取方法的引數名，method.getParameters() 獲取出來的引數都是 arg0，arg1...無意義引數
在Java8之前，程式碼編譯為class檔案後，方法引數的型別是固定的，但引數名稱卻丟失了，在編譯的時候，需要有編譯的選項，javac -parameters 預設是關閉的，需要在 idea 中設定開啟，開啟完成後，重新編譯原始檔
這種方式只能臨時解決當前環境設定，在其他人執行程式碼時還是要重新設定
另一種解決方式，在pom檔案中新增編譯引數：
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<compilerArgument>-parameters</compilerArgument>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
編譯完成後，重新執行，再次通過method.getParameters()獲取引數：
解析原來的 sql ，就要把 #{} 給替換掉，這時候可以使用 StringBuffer 類來實現替換
private static String parseSql(String sql, Map<String, Object> argsNameMap) {
// 定義為常量陣列
char[] str = {'#', '{'};
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < sql.length(); i++) {
char aloneParseSql = sql.charAt(i);
if (str[0] == aloneParseSql) {
int nextIndex = i + 1;
char nextChar = sql.charAt(nextIndex);
// # 後應該是 { ，不匹配直接丟擲異常
if (str[1] != nextChar) {
throw new RuntimeException(String.format(
"此處應該是：#{\n sql：%s\n index：%d",
stringBuilder.toString(), nextIndex));
}
/*
1 已經解析完的下標
2 解析完的 #{} 內的引數名
3 把對應的 argsName 的值 argsValue 取出來
4 追加到原來的 stringBuilder 中的 sql 語句後面
*/
StringBuilder partStringBuilder = new StringBuilder();
i = partParseSql(partStringBuilder, sql, nextIndex);
String argsName = partStringBuilder.toString();
Object argsValue = argsNameMap.get(argsName);
stringBuilder.append(argsValue.toString());
}
// 如果沒有條件，直接追加
stringBuilder.append(aloneParseSql);
}
return stringBuilder.toString();
}
在其中需要把需要替換的值，再用 StringBuffer 類來實現
private static int partParseSql(StringBuilder partStringBuilder, String sql, int nextIndex) {
// 由於 nextIndex 當前指標指向的是 { 所以要加一位，把後面內容解析
nextIndex++;
char[] str = {'}'};
for (; nextIndex < sql.length(); nextIndex++) {
char indexSql = sql.charAt(nextIndex);
if (str[0] != indexSql) {
partStringBuilder.append(indexSql);
}
if (str[0] == indexSql) {
return nextIndex;
}
}
throw new RuntimeException(String.format(
"缺少：}\n index：%d",
nextIndex));
}
再重新在 invoke 方法中進行呼叫，完成 sql 語句的動態拼裝
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 把註解類獲取，可以查出註解的值等多種其他值
Select annotation = method.getAnnotation(Select.class);
Map<String, Object> argsNameMap = MapBuildArgsName(method, args);
if (annotation != null) {
String[] value = annotation.value();
String sql = value[0];
sql = parseSql(sql, argsNameMap);
System.out.println(sql);
}
return null;
}
