diff --git a/week_06/28/Class.md b/week_06/28/Class.md new file mode 100644 index 0000000000000000000000000000000000000000..79989cda2f92934d1ad8e3052ca10b16a42d2ddc --- /dev/null +++ b/week_06/28/Class.md @@ -0,0 +1,191 @@ +# Class 源码分析 + +## 类的抽象，即对“类”做描述：比如类有修饰、字段、方法等属性，有获得该类的所有方法、所有公有方法等方法。同时，Class也是Java类型中最重要的一种，表示原始类型（引用类型）及基本类型。 +## Calss 除基本类型外，Java的其他类型全部都是class（包括interface）、JVM在第一次读取到一种class类型时，将其加载进内存。每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。 + + +### 获取类中的属性 +getFields(): 获取类中public类型的属性 +getField(String name)： 获取类特定的方法，name参数指定了属性的名称 +getDeclaredFields(): 获取类中所有的属性(public、protected、default、private),但不包括继承的属性。 +getDeclaredField(String name): 获取类特定的方法，name参数指定了属性的名称 + + +### 获取类中的构造函数: +getConstructors()：获取类中的公共方法 +getConstructor(Class[] params): 获取类的特定构造方法,params参数指定构造方法的参数类型 +getDeclaredConstructors(): 获取类中所有的构造方法(public、protected、default、private) +getDeclaredConstructor(Class[] params): 获取类的特定构造方法,params参数指定构造方法的参数类型 + + +### 获取类中的方法: +getMethods(): 获得类的public类型的方法 +getMethod(String name, Class[] params): 获得类的特定方法,name参数指定方法的名字,params参数指定方法的参数类型 +getDeclaredMethods(): 获取类中所有的方法(public、protected、default、private) +getDeclaredMethod(String name, Class[] params): 获得类的特定方法,name参数指定方法的名字,params参数指定方法的参数类型 + + +### 其它重要方法: +newInstance(): 通过类的不带参数 的构造方法创建这个类的一个对象 +forName(String className): 获取className参数指定的类的class对象 +forName(String className,boolean initialize,ClassLoader): 使用指定的类加载器获取className参数指定的类的class对象 +getClassLoader(): 获取类加载器 +getName(): 获取类名 +getPackage(): 获取类所在的包名 + + +### 获取Class对象的三种方法 +调用Class类的静态方法forName, 比如： Class.forName("java.lang.String") +使用类的.class语法, 比如：Class cls = String.class +调用对象的getClass方法, 比如：String str = "abc"; Class cls = str.getClass(); + + +## 属性 +```java +private static final int ANNOTATION= 0x00002000;//注释类型 +private static final int ENUM = 0x00004000;//枚举类型 +private static final int SYNTHETIC = 0x00001000;//合成类型，注0 +//枚举是一种类（class），注释是一种接口（interface） +private transient String name;//全限定名（包+类名） +private native String getName0();//本地方法获取name属性 +//注册本地方法 +private static native void registerNatives(); + +``` +## 构造 +```java +static { + registerNatives(); + } +private Class() {}//唯一私有构造方法，说明Class不可由用户构造实例 + +``` + + +```java +//通过类全限定名获得该类（或接口）的Class对象（加载该类） +@CallerSensitive //注1 +public static Class forName(String className) + throws ClassNotFoundException { + Class caller = Reflection.getCallerClass(); + return forName0(className, true, ClassLoader.getClassLoader(caller), caller); +} +@CallerSensitive +public static Class forName(String name, boolean initialize, + ClassLoader loader) + throws ClassNotFoundException +{ + //initialize : 是否立即初始化该类，注2 + //loader : 使用指定的类加载器加载 +} +private static native Class forName0(String name, boolean initialize, + ClassLoader loader, + Class caller) + throws ClassNotFoundException; +//反射获得该类实例对象 + @CallerSensitive +public T newInstance() throws InstantiationException, IllegalAccessException { +//JDK明言：本方法在当前Java内存模型下不一定是正确的 +//反射获取该类实例对象，实例化对象不是通过new指令，而是直接 +//通过本地方法获取类的公有构造方法（无参），然后通过Constructor的 +//newInstance();方法实例化对象 +//这个过程还要检查是否有权限反射实例化该对象 +} + +//缓存上面方法已获取的公有构造方法，供下次使用 +private volatile transient Constructor cachedConstructor; +//缓存调用本方法的最初对象的类Class对象，供安全检查使用，见注1 +private volatile transient Class newInstanceCallerCache; +//判断obj对象是否是该Class的实例 +public native boolean isInstance(Object obj); +//判断cls是否是调用者同一类型或其子类类型 +public native boolean isAssignableFrom(Class cls); +//判断该Class是否是接口类型 +public native boolean isInterface(); +//判断该Class是否是数组类型 +public native boolean isArray(); +//判断该Class是否是基本类型，注3（八大基本类型+一特殊基本类型） +public native boolean isPrimitive(); +//判断该Class是否是注释类型 +public boolean isAnnotation() { + return (getModifiers() & ANNOTATION) != 0; +} + +//判断该Class是否是合成类型 +public boolean isSynthetic() { + return (getModifiers() & SYNTHETIC) != 0; +} + +public String getName() { + String name = this.name; + if (name == null) + this.name = name = getName0();//通过本地方法获取全路径类名 + return name; +} + +//获取加载该类的类加载器 +@CallerSensitive +public ClassLoader getClassLoader() { + ClassLoader cl = getClassLoader0(); + if (cl == null) + return null; + SecurityManager sm = System.getSecurityManager();//注5 + if (sm != null) { + ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass()); + } + return cl; +} + +native ClassLoader getClassLoader0(); +//返回该类中变量字段的类型变量数组，按声明顺序排序，注4 +public TypeVariable>[] getTypeParameters() { + if (getGenericSignature() != null) + return (TypeVariable>[])getGenericInfo().getTypeParameters(); + else + return (TypeVariable>[])new TypeVariable[0]; +} + +//获得该类的直接父类的Class对象，如果该类是接口，则返回null +public native Class getSuperclass(); + +//返回带参数化类型的直接父类的类型 +public Type getGenericSuperclass() {} + +//获取该类的包路径 +public Package getPackage() { + return Package.getPackage(this); +} + +//获取该类直接实现的所有接口 +public native Class[] getInterfaces(); + +//获取所有接口，同上面的不同之处在于，若超接口是参数化类型（泛型）则返回的是其实际类型 +public Type[] getGenericInterfaces() { + if (getGenericSignature() != null) + return getGenericInfo().getSuperInterfaces(); + else + return getInterfaces(); +} + +/**返回数组类型，若该类不是数组，返回null + * 如：A[] a = new A[]; + * a.getClass().getComponentType()返回的是A类型（全路径名） + */ +public native Class getComponentType(); +//返回这个类的修饰符的对应的int值，二者可通过Modifier.toString()转换 +public native int getModifiers(); +//获取该类的所有签名（标记）列表 +public native Object[] getSigners(); +//设置该类的签名，注意方法修饰是默认，所以只有同包下类可用 +native void setSigners(Object[] signers); + +``` + +## 总结 +获取java 类型的详细描述信息，并可通过反射获取对象的内容，执行相应方法等。此类涉及内容还需进一步分析。 +过年有点犯懒了，后续继续完善。 + + + + + diff --git a/week_06/28/LeetCode_1188_028.java b/week_06/28/LeetCode_1188_028.java new file mode 100644 index 0000000000000000000000000000000000000000..9126864c2ef9729c37509f0ce8f08c8b0bb6d938 --- /dev/null +++ b/week_06/28/LeetCode_1188_028.java @@ -0,0 +1,45 @@ +package com.ufo.java.week06; + +import java.util.LinkedList; +import java.util.concurrent.Semaphore; + +/** + * + * + */ +public class LeetCode_1188_028 { + + + class BoundedBlockingQueue { + + private Semaphore consumeSemaphore; + private Semaphore produceSemaphore; + private int capacity; + private LinkedList q = new LinkedList(); + + public BoundedBlockingQueue(int capacity) { + this.capacity = capacity; + consumeSemaphore = new Semaphore(0); + produceSemaphore = new Semaphore(capacity); + } + + public void enqueue(int element) throws InterruptedException { + produceSemaphore.acquire(); + q.add(element); + consumeSemaphore.release(); + } + + public int dequeue() throws InterruptedException { + consumeSemaphore.acquire(); + int v= q.removeFirst(); + produceSemaphore.release(); + return v; + + } + + public int size() { + return q.size(); + } + } + +} \ No newline at end of file diff --git a/week_06/28/LeetCode_622_028.java b/week_06/28/LeetCode_622_028.java new file mode 100644 index 0000000000000000000000000000000000000000..5315dc2156f9a718a6a3dd90edd016a81d12a9d8 --- /dev/null +++ b/week_06/28/LeetCode_622_028.java @@ -0,0 +1,96 @@ +package com.ufo.java.week06; + +/** + * + * + */ +public class LeetCode_622_028 { + + + class MyCircularQueue { + + private int front; + private int rear; + private int capacity; + private int[] arr; + + /** + * Initialize your data structure here. Set the size of the queue to be k. + */ + public MyCircularQueue(int k) { + capacity = k + 1; + arr = new int[capacity]; + front = 0; + rear = 0; + } + + /** + * Insert an element into the circular queue. Return true if the operation is successful. + */ + public boolean enQueue(int value) { + if (isFull()) { + return false; + } + arr[rear] = value; + rear = (rear + 1) % capacity; + return true; + } + + /** + * Delete an element from the circular queue. Return true if the operation is successful. + */ + public boolean deQueue() { + if (isEmpty()) { + return false; + } + front = (front + 1) % capacity; + return true; + } + + /** + * Get the front item from the queue. + */ + public int Front() { + if (isEmpty()) { + return -1; + } + return arr[front]; + } + + /** + * Get the last item from the queue. + */ + public int Rear() { + if (isEmpty()) { + return -1; + } + return arr[(rear - 1 + capacity) % capacity]; + } + + /** + * Checks whether the circular queue is empty or not. + */ + public boolean isEmpty() { + return front == rear; + } + + /** + * Checks whether the circular queue is full or not. + */ + public boolean isFull() { + return (rear + 1) % capacity == front; + } + + } + +/** + * Your MyCircularQueue object will be instantiated and called as such: + * MyCircularQueue obj = new MyCircularQueue(k); + * boolean param_1 = obj.enQueue(value); + * boolean param_2 = obj.deQueue(); + * int param_3 = obj.Front(); + * int param_4 = obj.Rear(); + * boolean param_5 = obj.isEmpty(); + * boolean param_6 = obj.isFull(); + */ +} \ No newline at end of file diff --git a/week_06/28/LeetCode_641_028.java b/week_06/28/LeetCode_641_028.java new file mode 100644 index 0000000000000000000000000000000000000000..25ed2b2edde3929d5e7e8d8789eb1fd5c1338050 --- /dev/null +++ b/week_06/28/LeetCode_641_028.java @@ -0,0 +1,120 @@ +package com.ufo.java.week06; + +/** + * + * + */ +public class LeetCode_641_028 { + + + public class MyCircularDeque { + + private int capacity; + private int[] arr; + private int front; + private int rear; + + /** + * Initialize your data structure here. Set the size of the deque to be k. + */ + public MyCircularDeque(int k) { + capacity = k + 1; + arr = new int[capacity]; + front = 0; + rear = 0; + } + + /** + * Adds an item at the front of Deque. Return true if the operation is successful. + */ + public boolean insertFront(int value) { + if (isFull()) { + return false; + } + front = (front - 1 + capacity) % capacity; + arr[front] = value; + return true; + } + + /** + * Adds an item at the rear of Deque. Return true if the operation is successful. + */ + public boolean insertLast(int value) { + if (isFull()) { + return false; + } + arr[rear] = value; + rear = (rear + 1) % capacity; + return true; + } + + /** + * Deletes an item from the front of Deque. Return true if the operation is successful. + */ + public boolean deleteFront() { + if (isEmpty()) { + return false; + } + front = (front + 1) % capacity; + return true; + } + + /** + * Deletes an item from the rear of Deque. Return true if the operation is successful. + */ + public boolean deleteLast() { + if (isEmpty()) { + return false; + } + rear = (rear - 1 + capacity) % capacity; + return true; + } + + /** + * Get the front item from the deque. + */ + public int getFront() { + if (isEmpty()) { + return -1; + } + return arr[front]; + } + + /** + * Get the last item from the deque. + */ + public int getRear() { + if (isEmpty()) { + return -1; + } + return arr[(rear - 1 + capacity) % capacity]; + } + + /** + * Checks whether the circular deque is empty or not. + */ + public boolean isEmpty() { + return front == rear; + } + + /** + * Checks whether the circular deque is full or not. + */ + public boolean isFull() { + return (rear + 1) % capacity == front; + } + } + + /** + * Your MyCircularDeque object will be instantiated and called as such: + * MyCircularDeque obj = new MyCircularDeque(k); + * boolean param_1 = obj.insertFront(value); + * boolean param_2 = obj.insertLast(value); + * boolean param_3 = obj.deleteFront(); + * boolean param_4 = obj.deleteLast(); + * int param_5 = obj.getFront(); + * int param_6 = obj.getRear(); + * boolean param_7 = obj.isEmpty(); + * boolean param_8 = obj.isFull(); + */ +} \ No newline at end of file diff --git a/week_06/28/LeetCode_705_028.java b/week_06/28/LeetCode_705_028.java new file mode 100644 index 0000000000000000000000000000000000000000..8a35d770564c4d8d1fd3a1d53ce53cda2333a128 --- /dev/null +++ b/week_06/28/LeetCode_705_028.java @@ -0,0 +1,65 @@ +package com.ufo.java.week06; + +/** + * + * + */ +public class LeetCode_705_028 { + + + class MyHashSet { + + int[] values; + int lenght; + + public MyHashSet() { + values = new int[1000000]; + lenght = 1000000; + for (int i = 0; i < lenght; i++) { + values[i] = -1; + } + } + + public void add(int key) { + int index = Hash(key); + values[index] = 1; + } + + public void remove(int key) { + int index = Hash(key); + values[index] = -1; + } + + /** + * Returns true if this set contains the specified element + */ + + public boolean contains(int key) { + return isExisted(Hash(key)); + } + + int Hash(int key) { + int index = key % lenght; + if(isExisted(index)){ + Hash(index+1); + } + return index; + } + + boolean isExisted(int index) { + if (values[index] == -1) { + return false; + } else { + return true; + } + } + + } +/** + * Your MyHashSet object will be instantiated and called as such: + * MyHashSet obj = new MyHashSet(); + * obj.add(key); + * obj.remove(key); + * boolean param_3 = obj.contains(key); + */ +} diff --git a/week_06/28/LeetCode_706_028.java b/week_06/28/LeetCode_706_028.java new file mode 100644 index 0000000000000000000000000000000000000000..b7194f4d356feec24158314c9ca50c5503464314 --- /dev/null +++ b/week_06/28/LeetCode_706_028.java @@ -0,0 +1,43 @@ +package com.ufo.java.week06; + +import java.util.Arrays; + +/** + * + * + */ +public class LeetCode_706_028 { + + class MyHashMap { + int[] table; + /** Initialize your data structure here. */ + public MyHashMap() { + table = new int[1000000]; + Arrays.fill(table, -1); + } + + /** value will always be non-negative. */ + public void put(int key, int value) { + table[key] = value; + } + + /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */ + public int get(int key) { + return table[key]; + } + + /** Removes the mapping of the specified value key if this map contains a mapping for the key */ + public void remove(int key) { + table[key] = -1; + } + } + +/** + * Your MyHashMap object will be instantiated and called as such: + * MyHashMap obj = new MyHashMap(); + * obj.put(key,value); + * int param_2 = obj.get(key); + * obj.remove(key); + */ + +} diff --git a/week_06/28/LeetCode_707_028.java b/week_06/28/LeetCode_707_028.java new file mode 100644 index 0000000000000000000000000000000000000000..2bd3dee46b065b76ba12c26e02aa43424163e40a --- /dev/null +++ b/week_06/28/LeetCode_707_028.java @@ -0,0 +1,81 @@ +package com.ufo.java.week06; + +/** + * + * + */ +public class LeetCode_707_028 { + + + class MyLinkedList { + private class Node{ + public int val; + public Node next; + + public Node(int val){ + this.val = val; + } + } + private Node dummyHead; + int size; + + public MyLinkedList() { + dummyHead = new Node(-1); + size = 0; + } + + public int get(int index) { + if(index < 0 || index >= size) + return -1; + Node curr = dummyHead.next; + for(int i = 0; i < index; i++) + curr = curr.next; + return curr.val; + } + + public void addAtHead(int val) { + addAtIndex(0, val); + } + + public void addAtTail(int val) { + addAtIndex(size, val); + } + + public void addAtIndex(int index, int val) { + if(index > size) + return; + if(index < 0) + addAtHead(val); + Node prev = dummyHead; + for(int i = 0; i < index; i++){ + prev = prev.next; + } + Node node = new Node(val); + node.next = prev.next; + prev.next = node; + size++; + } + + public void deleteAtIndex(int index) { + if(index < 0 || index >= size) + return; + Node prev = dummyHead; + for(int i = 0; i < index; i++) + prev = prev.next; + Node reNode = prev.next; + prev.next = reNode.next; + reNode.next = null; + size--; + } + } + +/** + * Your MyLinkedList object will be instantiated and called as such: + * MyLinkedList obj = new MyLinkedList(); + * int param_1 = obj.get(index); + * obj.addAtHead(val); + * obj.addAtTail(val); + * obj.addAtIndex(index,val); + * obj.deleteAtIndex(index); + */ +} \ No newline at end of file diff --git a/week_06/28/Spring5 framework.xmind b/week_06/28/Spring5 framework.xmind new file mode 100644 index 0000000000000000000000000000000000000000..af86c0e27224fa1e83a8d3053c36fcdc57c7714d Binary files /dev/null and b/week_06/28/Spring5 framework.xmind differ diff --git a/week_06/28/SpringArchitecture.png b/week_06/28/SpringArchitecture.png new file mode 100644 index 0000000000000000000000000000000000000000..71e6911cffe853ddee650c99f5ec8ad3531f5e34 Binary files /dev/null and b/week_06/28/SpringArchitecture.png differ diff --git a/week_06/28/SpringArchitecture.uml b/week_06/28/SpringArchitecture.uml new file mode 100644 index 0000000000000000000000000000000000000000..9b2db61d720f78b7efc18626b75eacc1b2ba8186 --- /dev/null +++ b/week_06/28/SpringArchitecture.uml @@ -0,0 +1,734 @@ + + + + + + + + + + +Untitled +1 + +Model1 +afI9htz690OeBbT7ERrVuQAA +1 + +ComponentDiagram1 +wny0peM2C0issOIjNBm3hQAA + +sdotJHVPWUmHQiP65AYbXAAA +sdotJHVPWUmHQiP65AYbXAAA +22 + +clMaroon +$00B9FFFF +36 +220 +669 +509 +5tbh9dWvS06+WwnhujgTtgAA + + +1 +Spring Framework5 + + +False + + +False + + + +False +5tbh9dWvS06+WwnhujgTtgAA + + + +clMaroon +$00B9FFFF +80 +272 +277 +201 +OYVSvklRJ0aMJX6hEjI1uAAA + + +1 +Data Access Integration + + +False + + +False + + + +False +OYVSvklRJ0aMJX6hEjI1uAAA + + + +clMaroon +$00B9FFFF +380 +272 +269 +201 +bjqjgP5yPU2pviISZPmlzAAA + + +1 +WEB + + +False + + +False + + + +False +bjqjgP5yPU2pviISZPmlzAAA + + + +clMaroon +$00B9FFFF +524 +296 +106 +45 +rHE8iQjyhUKSsWSIb+d7TAAA + + +1 +WebMVC + + +False + + +False + + + +False +rHE8iQjyhUKSsWSIb+d7TAAA + + + +clMaroon +$00B9FFFF +232 +348 +100 +45 +RdFIC6yjmEOJSmNyv78zqAAA + + +1 +JMS + + +False + + +False + + + +False +RdFIC6yjmEOJSmNyv78zqAAA + + + +clMaroon +$00B9FFFF +232 +296 +100 +45 +Iul4jh0GR0y+88pfFF1utgAA + + +1 +ORM + + +False + + +False + + + +False +Iul4jh0GR0y+88pfFF1utgAA + + + +clMaroon +$00B9FFFF +112 +348 +109 +45 +WxXpNGDjOEi1BIMSFAxJXgAA + + +1 +OXM + + +False + + +False + + + +False +WxXpNGDjOEi1BIMSFAxJXgAA + + + +clMaroon +$00B9FFFF +152 +408 +117 +45 +/bjaNOqUbU2wnYlkUYQaYgAA + + +1 +Transactions + + +False + + +False + + + +False +/bjaNOqUbU2wnYlkUYQaYgAA + + + +clMaroon +$00B9FFFF +112 +296 +110 +45 +B9MbpGg0MkaVinTxCBkbjAAA + + +1 +JDBC + + +False + + +False + + + +False +B9MbpGg0MkaVinTxCBkbjAAA + + + +clMaroon +$00B9FFFF +404 +296 +106 +45 +4/VTHtDF40uZzYApSG1cIwAA + + +1 +WebSocket + + +False + + +False + + + +False +4/VTHtDF40uZzYApSG1cIwAA + + + +clMaroon +$00B9FFFF +404 +352 +106 +45 +pJA4TkZDfEKWJ07pJK09jwAA + + +1 +WEB1 + + +False + + +False + + + +False +pJA4TkZDfEKWJ07pJK09jwAA + + + +clMaroon +$00B9FFFF +524 +352 +106 +45 +bamkCtGq6EOGRvITJU58kQAA + + +1 +Web Flux + + +False + + +False + + + +False +bamkCtGq6EOGRvITJU58kQAA + + + +clMaroon +$00B9FFFF +88 +496 +100 +45 +RI+Uzm/wdESxlCMrlMMAFQAA + + +1 +Kim, Jeongil + + +False + + +False + + + +False +RI+Uzm/wdESxlCMrlMMAFQAA + + + +clMaroon +$00B9FFFF +220 +496 +106 +45 +f2KcorKMu0KRkNaXx4+ZHgAA + + +1 +Kim, Keehyun + + +False + + +False + + + +False +f2KcorKMu0KRkNaXx4+ZHgAA + + + +clMaroon +$00B9FFFF +372 +496 +111 +45 +9MVqXfHOikaDApBRBKNfiAAA + + +1 +Kum, Deukkyu + + +False + + +False + + + +False +9MVqXfHOikaDApBRBKNfiAAA + + + +clMaroon +$00B9FFFF +516 +496 +106 +45 +1s9zKqoHlkaY4xFTsueiQQAA + + +1 +Lee, Jangwoo + + +False + + +False + + + +False +1s9zKqoHlkaY4xFTsueiQQAA + + + +clMaroon +$00B9FFFF +88 +556 +561 +85 +mWh+Agqc7Uic6y207kucaQAA + + +1 +Lee, Minkyu + + +False + + +False + + + +False +mWh+Agqc7Uic6y207kucaQAA + + + +clMaroon +$00B9FFFF +116 +580 +100 +45 +V12Dt2GbT0S5R+hLg4X1ZAAA + + +1 +Beans + + +False + + +False + + + +False +V12Dt2GbT0S5R+hLg4X1ZAAA + + + +clMaroon +$00B9FFFF +236 +580 +121 +45 +kRIoIrCx80iiBiD0pUNZnwAA + + +1 +Core + + +False + + +False + + + +False +kRIoIrCx80iiBiD0pUNZnwAA + + + +clMaroon +$00B9FFFF +388 +580 +110 +45 +2RNBks0B8E+jNvuybZyn4wAA + + +1 +Context + + +False + + +False + + + +False +2RNBks0B8E+jNvuybZyn4wAA + + + +clMaroon +$00B9FFFF +528 +580 +106 +45 +PRDyuqotKEivGYJ+GkR8ywAA + + +1 +Expression + + +False + + +False + + + +False +PRDyuqotKEivGYJ+GkR8ywAA + + + +clMaroon +$00B9FFFF +88 +656 +561 +45 +RHuzE4ARvUCjznV328K52gAA + + +1 +Test + + +False + + +False + + + +False +RHuzE4ARvUCjznV328K52gAA + + + + +22 + +Spring Framework5 +wny0peM2C0issOIjNBm3hQAA +2 +/xeQiL8TK06puiuAV6+CiAAA +maw45liABkCV5lf4xBI3DwAA + + +JDBC +wny0peM2C0issOIjNBm3hQAA +2 +k5+jUi2NTU6y+ewTqMaHCAAA +bWrBuDqEQkeyt+pc7/z/MAAA + + +WebSocket +wny0peM2C0issOIjNBm3hQAA +2 +0Ed9LSBCTEC4fi7ONUR4gwAA +/8U6zhgB1kiCcbwkk551PQAA + + +Data Access Integration +wny0peM2C0issOIjNBm3hQAA +2 +4iCXqbWdxUGyTFRqsc9e1AAA +B4ootPLeqEqyjl+gc1ANugAA + + +WEB1 +wny0peM2C0issOIjNBm3hQAA +2 +QEfb8jwoTUiYXvsc/OEmMQAA +vBYoRUmFWUqvqRnr+1tqoQAA + + +WEB +wny0peM2C0issOIjNBm3hQAA +2 +JBSM8yC1O068HRZOaGSQCQAA +dpHegb1I5kOZkioOutbruAAA + + +WebMVC +wny0peM2C0issOIjNBm3hQAA +2 +u5do42J59k2J3kFz/RusugAA +tDUjBAGaPUybC1omE33EZgAA + + +JMS +wny0peM2C0issOIjNBm3hQAA +2 +js8zfXm4TUqc63shNpTk0AAA +FctRk4jSG0iBa+pv/uoNiQAA + + +ORM +wny0peM2C0issOIjNBm3hQAA +2 +7wAf01z820uYU8Jh6vOmpQAA +Dgd5J7m9PUmMSkqapbalVgAA + + +OXM +wny0peM2C0issOIjNBm3hQAA +2 +FRMB1GyG3UKr0si7wn8YlAAA +2AT7T4xX/kyCA84XRNbRpAAA + + +Transactions +wny0peM2C0issOIjNBm3hQAA +2 +B9qINED6dU2hf6T9raI3wgAA +Ijb9bacpw0Wc3AmBVl+w0gAA + + +Web Flux +wny0peM2C0issOIjNBm3hQAA +2 +XPsPK9GrxEGrbDCbflpjjAAA +wVsw79iUKE2M/r8bLw37xAAA + + +Kim, Jeongil +wny0peM2C0issOIjNBm3hQAA +2 +Cjn8Lo+5ika1p1AugZh6TgAA +6CUDK0wm20CbGA/YczHZdwAA + + +Kim, Keehyun +wny0peM2C0issOIjNBm3hQAA +2 +NBkVwEvsCUK3U4oDxAosbwAA +blklYPA7AkubkKRJAZ0V2gAA + + +Kum, Deukkyu +wny0peM2C0issOIjNBm3hQAA +2 +MEg0kjm3uUawVM/k4hNJAgAA +wznkhIJB+EySoJAhcdSq3AAA + + +Lee, Jangwoo +wny0peM2C0issOIjNBm3hQAA +2 +H/V1zNVxFUCR+HVQzPHpaQAA +/8pUZwkJtkSkXhAoJOxITQAA + + +Lee, Minkyu +wny0peM2C0issOIjNBm3hQAA +2 +U4/z89n10UujBWsUfRdongAA +HqDvZbSUuUy4OghT6WUjIwAA + + +Beans +wny0peM2C0issOIjNBm3hQAA +2 +A99kiKMGY0KVFMTTOhUqCQAA ++X4zBqA3Rk2qRjkxTmJ2OAAA + + +Core +wny0peM2C0issOIjNBm3hQAA +2 +lkchmFojlUOIOWgC7f8UYQAA +33EiU7BHUkyBaDPGGG1gjwAA + + +Context +wny0peM2C0issOIjNBm3hQAA +2 +4nupK4lzqU22+f9GQQPFkgAA +X+wLo8HLZkCz1UGJKQ/jOwAA + + +Expression +wny0peM2C0issOIjNBm3hQAA +2 +N5fAYQkXtkak+BpDTfDUsAAA +kcPr5CxNpUmS395Wfqb7BAAA + + +Test +wny0peM2C0issOIjNBm3hQAA +2 +fpgZL2iDVUCRaAkX0uLIEQAA +cZFiKkAOE0yZXSrrnKSW+gAA + + + + + diff --git a/week_06/28/mybatis.xmind b/week_06/28/mybatis.xmind new file mode 100644 index 0000000000000000000000000000000000000000..20dfb60c0f5965f68ab0d2e47c4a21fb1a274f53 Binary files /dev/null and b/week_06/28/mybatis.xmind differ