Colazi's nest rhythm is just a click away 2022-10-09T14:34:40.052Z https://colazii.github.io/ Colazi Hexo 从零开始学MySQL https://colazii.github.io/posts/dd97.html 2022-09-29T19:25:20.000Z 2022-10-09T14:34:40.052Z 事务的四大特性

原子性（Atomicity）

原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，操作如果成功就必须要完全应用到数据库，操作失败则不能对数据库有任何影响。

一致性（Consistency）

一致性是指事务使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。以转账为例假设A和B的各有100元，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来还是200，这就是事务的一致性。

隔离性（Isolation）

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。即要达到一种每个事务都互不影响，不能感对方的并发地执行。

持久性（Durability）

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

存储引擎

数据库存储引擎是数据库底层软件组织，数据库管理系统（DBMS）使用数据引擎进行创建、查询、更新和删除数据。不同的存储引擎提供不同的存储机制、索引技巧、锁定水平等功能，使用不同的存储引擎，还可以 获得特定的功能。现在许多不同的数据库管理系统都支持多种不同的数据引擎。MySql的核心就是存储引擎。

存储引擎查看

MySQL给开发者提供了查询存储引擎的功能，我这里使用的是MySQL8.1，可以使用：

SHOW ENGINES;

看到MySQL给用户提供了这么多存储引擎，包括处理事务安全表的引擎和出来了非事物安全表的引擎。

在MySQL中，不需要在整个服务器中使用同一种存储引擎，针对具体的要求，可以对每一个表使用不同的存储引擎。Support列的值表示某种引擎是否能使用：YES表示可以使用、NO表示不能使用、DEFAULT表示该引擎为当前默认的存储引擎 。下面来看一下其中几种常用的引擎。

InnoDB存储引擎

InnoDB是事务型数据库的首选引擎，支持事务安全表（ACID），支持行锁定和外键，上图也看到了，InnoDB是默认的MySQL引擎。InnoDB主要特性有：

1、InnoDB给MySQL提供了具有提交、回滚和崩溃恢复能力的事物安全（ACID兼容）存储引擎。InnoDB锁定在行级并且也在SELECT语句中提供一个类似Oracle的非锁定读。这些功能增加了多用户部署和性能。在SQL查询中，可以自由地将InnoDB类型的表和其他MySQL的表类型混合起来，甚至在同一个查询中也可以混合

2、InnoDB是为处理巨大数据量的最大性能设计。它的CPU效率可能是任何其他基于磁盘的关系型数据库引擎锁不能匹敌的

3、InnoDB存储引擎完全与MySQL服务器整合，InnoDB存储引擎为在主内存中缓存数据和索引而维持它自己的缓冲池。InnoDB将它的表和索引在一个逻辑表空间中，表空间可以包含数个文件（或原始磁盘文件）。这与MyISAM表不同，比如在MyISAM表中每个表被存放在分离的文件中。InnoDB表可以是任何尺寸，即使在文件尺寸被限制为2GB的操作系统上

4、InnoDB支持外键完整性约束，存储表中的数据时，每张表的存储都按主键顺序存放，如果没有显示在表定义时指定主键，InnoDB会为每一行生成一个6字节的ROWID，并以此作为主键

5、InnoDB被用在众多需要高性能的大型数据库站点上

InnoDB不创建目录，使用InnoDB时，MySQL将在MySQL数据目录下创建一个名为ibdata1的10MB大小的自动扩展数据文件，以及两个名为ib_logfile0和ib_logfile1的5MB大小的日志文件

MyISAM存储引擎

MyISAM基于ISAM存储引擎，并对其进行扩展。它是在Web、数据仓储和其他应用环境下最常使用的存储引擎之一。MyISAM拥有较高的插入、查询速度，但不支持事物。MyISAM主要特性有：

1、大文件（达到63位文件长度）在支持大文件的文件系统和操作系统上被支持

2、当把删除和更新及插入操作混合使用的时候，动态尺寸的行产生更少碎片。这要通过合并相邻被删除的块，以及若下一个块被删除，就扩展到下一块自动完成

3、每个MyISAM表最大索引数是64，这可以通过重新编译来改变。每个索引最大的列数是16

4、最大的键长度是1000字节，这也可以通过编译来改变，对于键长度超过250字节的情况，一个超过1024字节的键将被用上

5、BLOB和TEXT列可以被索引

6、NULL被允许在索引的列中，这个值占每个键的0~1个字节

7、所有数字键值以高字节优先被存储以允许一个更高的索引压缩

8、每个MyISAM类型的表都有一个AUTO_INCREMENT的内部列，当INSERT和UPDATE操作的时候该列被更新，同时AUTO_INCREMENT列将被刷新。所以说，MyISAM类型表的AUTO_INCREMENT列更新比InnoDB类型的AUTO_INCREMENT更快

9、可以把数据文件和索引文件放在不同目录

10、每个字符列可以有不同的字符集

11、有VARCHAR的表可以固定或动态记录长度

12、VARCHAR和CHAR列可以多达64KB

使用MyISAM引擎创建数据库，将产生3个文件。文件的名字以表名字开始，扩展名之处文件类型：frm文件存储表定义、数据文件的扩展名为.MYD（MYData）、索引文件的扩展名时.MYI（MYIndex）

MEMORY存储引擎

MEMORY存储引擎将表中的数据存储到内存中，未查询和引用其他表数据提供快速访问。MEMORY主要特性有：

1、MEMORY表的每个表可以有多达32个索引，每个索引16列，以及500字节的最大键长度

2、MEMORY存储引擎执行HASH和BTREE缩影

3、可以在一个MEMORY表中有非唯一键值

4、MEMORY表使用一个固定的记录长度格式

5、MEMORY不支持BLOB或TEXT列

6、MEMORY支持AUTO_INCREMENT列和对可包含NULL值的列的索引

7、MEMORY表在所由客户端之间共享（就像其他任何非TEMPORARY表）

8、MEMORY表内存被存储在内存中，内存是MEMORY表和服务器在查询处理时的空闲中，创建的内部表共享

9、当不再需要MEMORY表的内容时，要释放被MEMORY表使用的内存，应该执行DELETE FROM或TRUNCATE TABLE，或者删除整个表（使用DROP TABLE）

存储引擎的选择

不同的存储引擎都有各自的特点，以适应不同的需求，如下表所示：

image.png
如果要提供提交、回滚、崩溃恢复能力的事物安全（ACID兼容）能力，并要求实现并发控制，InnoDB是一个好的选择

如果数据表主要用来插入和查询记录，则MyISAM引擎能提供较高的处理效率

如果只是临时存放数据，数据量不大，并且不需要较高的数据安全性，可以选择将数据保存在内存中的Memory引擎，MySQL中使用该引擎作为临时表，存放查询的中间结果

如果只有INSERT和SELECT操作，可以选择Archive，Archive支持高并发的插入操作，但是本身不是事务安全的。Archive非常适合存储归档数据，如记录日志信息可以使用Archive

使用哪一种引擎需要灵活选择，一个数据库中多个表可以使用不同引擎以满足各种性能和实际需求，使用合适的存储引擎，将会提高整个数据库的性能

]]> <h1 id="事务的四大特性"><a href="#事务的四大特性" class="headerlink" title="事务的四大特性"></a>事务的四大特性</h1><h2 id="原子性（Atomicity）"><a href="#原子性（Atomicity）" cla 从零开始的算法练习3 https://colazii.github.io/posts/cefb.html 2022-09-25T15:05:49.000Z 2022-10-09T14:34:40.052Z 二叉树层序遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class levelOrder {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null){
            return new ArrayList<>();
        }
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int count = queue.size();
            List<Integer> list = new ArrayList<>();
            while (count > 0) {
                TreeNode remove = queue.remove();
                list.add(remove.val);
                if(remove.left!=null){
                    queue.add(remove.left);
                }
                if(remove.right!=null){
                    queue.add(remove.right);
                }
                count--;
            }
            result.add(list);
        }
        return result;
    }
}

环形链表

1
2
3
4
5
6
7
8
9
10
11
12
13
public class hasCycle {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}

相交链表

1
2
3
4
5
6
7
8
9
10
11
public class getIntersectionNode {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null && headB == null) return null;
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

约瑟夫环

https://leetcode.cn/problems/find-the-winner-of-the-circular-game/

每叫到k号移出一个人，就相当于胜者的位置向前移了k位，假设我们知道胜者的位置，用逆推思想得到递归公式。

1
2
3
4
5
6
7
8
9
public class findTheWinner {
    public int findTheWinner(int n, int k) {//逆推法
        int p = 0;                          //最终只剩下胜者时，胜者的位置为0
        for (int i = 2; i <= n; i++) {       //最后一次游戏时，序列中只剩两人，i=2
            p = (p + k) % i;                //计算出上一次p所在序列的位置
        }                                   //也就是p向前移动k位，余i是因为最后序列不够k长
        return p + 1;
    }
}

多数元素

https://leetcode.cn/problems/majority-element/?favorite=2cktkvj

1
2
3
4
5
6
public class majorityElement {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

反转链表

1
2
3
4
5
6
7
8
9
10
11
12
13
public class reverseList {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
}

翻转二叉树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class invertTree {
    public TreeNode invertTree(TreeNode root) {
        invert(root);
        return root;
    }

    public static void invert(TreeNode root) {
        if (root == null) return;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        if (root.left != null) invert(root.left);
        if (root.right != null) invert(root.right);
    }
}

回文链表

转换成数组用双指针法不写了

反转后半部分链表并与前半链表比较。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class isPalindrome {
    public boolean isPalindrome(ListNode head) {
        if (head == null) return true;
        ListNode p1 = head;
        ListNode p2 = reverseList(endOfFirstHalf(head).next);
        boolean result = true;
        while (result && p2 != null) {
            if (p1.val != p2.val) return false;
            p1 = p1.next;
            p2 = p2.next;
        }
        return result;
    }

    public static ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }

    public static ListNode endOfFirstHalf(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

判断子序列

https://leetcode.cn/problems/is-subsequence/

双指针法不写

dp方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class isSubsequence {
    public boolean isSubsequence(String s, String t) {
        int n = s.length();
        int m = t.length();

        //创建二维dp数组
        int[][] dp = new int[m + 1][26];
        for (int i = 0; i < 26; i++) {
            dp[m][i] = m;
        }
        for (int i = m - 1; i >= 0; i--) {
            for (int j = 0; j < 26; j++) {
                if (t.charAt(i) == 'a' + j)
                    dp[i][j] = i;
                else
                    dp[i][j] = dp[i + 1][j];

            }
        }

        int add = 0;
        for (int i = 0; i < n; i++) {
            if (dp[add][s.charAt(i) - 'a'] == m)      //m说明这个数不存在
                return false;
            add = dp[add][s.charAt(i) - 'a'] + 1;
        }
        return true;
    }
}

移动零

https://leetcode.cn/problems/move-zeroes/

暴力解

1
2
3
4
5
6
7
8
9
10
11
12
13
public class moveZeroes {
    public void moveZeroes(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            for (int j = i; j > 0; j--) {
                if (nums[j - 1] == 0) {
                    int temp = nums[j];
                    nums[j] = nums[j - 1];
                    nums[j - 1] = temp;
                }
            }
        }
    }
}

双指针一次遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class moveZeroes {
    public void moveZeroes(int[] nums) {
        if (nums == null) return;
        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                j++;
            }
        }
    }
}

比特位计数

https://leetcode.cn/problems/counting-bits/

暴力解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class countBits {
    public int[] countBits(int n) {
        int[] result = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            int count = 0;
            int j = i;
            while (j != 0) {
                if (j % 2 == 1)
                    count++;
                j /= 2;
            }
            result[i] = count;
        }
        return result;
    }
}

万物皆可dp。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class countBits {
    public int[] countBits(int n) {
        int[] result = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            if (i % 2 == 0) {
                result[i] = result[i / 2];
            }
            if (i % 2 == 1) {
                result[i] = result[i - 1] + 1;
            }
        }
        return result;
    }
}

找到所有数组中消失的数字

https://leetcode.cn/problems/find-all-numbers-disappeared-in-an-array/

1
2
3
4
5
6
7
8
9
10
11
12
13
public class findDisappearedNumbers {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            nums[Math.abs(nums[i]) - 1] = -Math.abs(nums[Math.abs(nums[i]) - 1]);
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0)
                result.add(i + 1);
        }
        return result;
    }
}

汉明距离

https://leetcode.cn/problems/hamming-distance/?favorite=2cktkvj

1
2
3
4
5
public class hammingDistance {
    public int hammingDistance(int x, int y) {
        return Integer.bitCount(x ^ y);
    }
}

两数相加

https://leetcode.cn/problems/add-two-numbers/?favorite=2cktkvj

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class addTwoNumbers {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = null, tail = null;
        int carry = 0;
        while (l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            if (head == null) {
                head = tail = new ListNode(sum % 10);
            } else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            carry = sum / 10;
            if (l1 != null)
                l1 = l1.next;
            if (l2 != null)
                l2 = l2.next;
        }
        if (carry > 0)
            tail.next = new ListNode(carry);
        return head;
    }
}

无重复字符的最长子串

https://leetcode.cn/problems/longest-substring-without-repeating-characters/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class lengthOfLongestSubstring {
    public int lengthOfLongestSubstring(String s) {
        int max = 0;
        int left = 0;
        HashMap<Character, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {     // 滑动窗口，left为左指针，i为右指针
            if (hashMap.containsKey(s.charAt(i))) {
                left = Math.max(left, hashMap.get(s.charAt(i)) + 1);
            }
            hashMap.put(s.charAt(i), i);
            max = Math.max(max, i - left + 1);
        }
        return max;
    }
}
]]> <h1 id="二叉树层序遍历"><a href="#二叉树层序遍历" class="headerlink" title="二叉树层序遍历"></a>二叉树层序遍历</h1><figure class="highlight java"><table><tr><td class=" 从零开始的算法练习2 https://colazii.github.io/posts/e3a.html 2022-09-21T21:23:22.000Z 2022-10-09T14:34:40.052Z 冒泡排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        for (int i = arr.length; i > 1; i--) {
            boolean ifSwap = false;
            for (int j = 1; j < i; j++) {
                if (arr[j - 1] > arr[j]) {
                    swap(arr, j - 1, j);
                    ifSwap = true;
                }
            }
            System.out.println(ifSwap);
            System.out.println(Arrays.toString(arr));
            if(!ifSwap) break;
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {15, 4, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 4, 4, 4, 10};
        bubbleSort(arr);
    }
}

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class SelectionSort {

    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j]<arr[min]){
                    min = j;
                }
            }
            swap(arr, i, min);
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {15, 4, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 4, 4, 4, 10};
        selectionSort(arr);
    }
}

插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class InsertionSort {
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                swap(arr, j, j - 1);
            }
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {15, 4, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 4, 4, 4, 10};
        insertionSort(arr);
    }
}

计数排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class CountingSort {                             //计数排序，如果数据是离散的？
    public static void countingSort(int[] arr) {
        if (arr.length < 1) {
            return;
        }
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        int[] count = new int[max + 1];             //创建计数数组
        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }
        System.out.println(Arrays.toString(count));
        for (int i = 1; i < count.length; i++) {    //将计数数组转成累加数组，为了稳定性
            count[i] += count[i - 1];
        }
        System.out.println(Arrays.toString(count));
        int[] temp = new int[arr.length];           //创建临时数组存放数据
        for (int i = arr.length - 1; i >= 0; i--) {
            temp[count[arr[i]] - 1] = arr[i];       //temp[count[arr[i]] - 1]不会数组越界，因为如果arr[i]=0时count[arr[i]]肯定不为0
            count[arr[i]]--;
        }
        for (int i = 0; i < arr.length; i++) {      //把临时数组赋值给原数组
            arr[i] = temp[i];
        }
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 8, 1, 4, 9, 0, 7, 16, 14};
        countingSort(arr);
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
}

堆排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class HeapSort {                                        //堆排序 升序使用大顶堆
    //维护堆的性质
    public static void heapify(int[] arr, int n, int i) {      // n为数组长度，i为当前维护节点下标
        int largest = i;
        int lson = i * 2 + 1;
        int rson = i * 2 + 2;
        if (lson < n && arr[largest] < arr[lson]) {             //找到左右子节点中最大的那个
            largest = lson;
        }
        if (rson < n && arr[largest] < arr[rson]) {
            largest = rson;
        }
        if (largest != i) {                                     //交换让父节点最大
            swap(arr, largest, i);
            heapify(arr, n, largest);                           //递归调用维护大顶堆性质
        }
    }

    public static void heapsort(int[] arr, int n) {
        //建堆
        for (int i = n / 2 - 1; i >= 0; i--) {              //从最后一个节点开始向上，对每个父节点使用heapify
            heapify(arr, n, i);                             //n/2-1是找到最后一个节点的父节点
        }
        //排序
        for (int i = n - 1; i > 0; i--) {
            swap(arr, i, 0);                            //交换堆顶堆底元素，因为堆顶元素绝对是最大的
            heapify(arr, i, 0);                         //从堆顶开始维护大顶堆性质，使堆顶元素变为最大的
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }


    public static void main(String[] args) {
        int[] arr = {2, 3, 8, 1, 4, 9, 10, 7, 16, 14};
        heapsort(arr, arr.length);
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
}

归并排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {3, 2, 7, 11, 5, 8, 10, 1, 4};
        int[] tempArr = new int[arr.length];
        mergesort(arr, tempArr, 0, arr.length - 1);
        String s = Arrays.toString(arr);
        System.out.println(s);
    }

    public static void mergesort(int[] arr, int[] tempArr, int left, int right) {
        if (left < right) {
            int middle = (right - left) / 2 + left;
            mergesort(arr, tempArr, left, middle);
            mergesort(arr, tempArr, middle + 1, right);
            merge(arr, tempArr, left, middle, right);
        }
    }

    public static void merge(int[] arr, int[] tempArr, int left, int middle, int right) {
        int l_pos = left;            // 左半区第一个未排序元素
        int r_pos = middle + 1;        // 右半区第一个未排序元素
        int pos = left;              // 临时数组元素下标

        // 合并
        while (l_pos <= middle && r_pos <= right) {
            if (arr[l_pos] < arr[r_pos]) {
                tempArr[pos++] = arr[l_pos++];
            } else {
                tempArr[pos++] = arr[r_pos++];
            }
        }
        while (l_pos <= middle) {
            tempArr[pos++] = arr[l_pos++];
        }
        while (r_pos <= right) {
            tempArr[pos++] = arr[r_pos++];
        }
        while (left <= right) {
            arr[left] = tempArr[left];
            left++;
        }
        System.out.println("    排序中：" + Arrays.toString(arr));
    }
}

快速排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class QuickSort {
    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];                                  //将最后一个数作为pivot，比pivot大的放在右边，小的放在左边
        int i = low - 1;
        for (int j = low; j < high; j++) {                      //为了比较第一个数，i需要是low-1而非low
            if (arr[j] < pivot) {
                swap(arr, j, ++i);
            }
        }
        // 此时i+1指向的元素一定大于pivot
        swap(arr, high, i + 1);
        return i + 1;
    }

    public static void quicksort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = partition(arr, low, high);
            quicksort(arr, low, mid - 1);
            quicksort(arr, mid + 1, high);
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {1,4,3,9,8};
        quicksort(arr, 0, arr.length - 1);
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
}

希尔排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class ShellSort {

    public static void shellSort(int[] arr) {
        System.out.println(arr.length);
        for (int inc = arr.length / 2; inc > 0; inc /= 2) {          //初始增量length/2
            System.out.println(inc);
            for (int i = inc; i < arr.length; i++) {                 //从这个增量序列的第二个数开始遍历
                //arr[i] < arr[i - inc]：如果在此增量序列前一个数大于后一个数，交换这两个数的位置
                //i >= inc是保证数组不越界
                //i-=inc是为了比较这个增量序列中的每一个数
                while (i >= inc && arr[i] < arr[i - inc]) {
                    swap(arr, i, i - inc);
                    i -= inc;
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {15, 4, 5, 2, 7, 12, 6, 1, 4, 3, 9, 8, 4, 4, 4, 10};
        shellSort(arr);
    }
}

二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class BinarySearch {
    public static int binarySearch(int[] arr, int key) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (key > arr[mid]) {
                left = mid + 1;
            } else if (key < arr[mid]) {
                right = mid - 1;
            } else return mid;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 4, 5, 8, 9, 11, 12, 13, 14, 17, 19, 20, 21, 23};
        int i = binarySearch(arr, 1);
        System.out.println(i + 1);
    }
}
]]> <h1 id="冒泡排序"><a href="#冒泡排序" class="headerlink" title="冒泡排序"></a>冒泡排序</h1><figure class="highlight java"><table><tr><td class="gutter"><pre 从零开始的算法练习 https://colazii.github.io/posts/7a25.html 2022-09-12T19:08:11.000Z 2022-10-09T14:34:40.052Z 合并两个有序链表

https://leetcode.cn/problems/merge-two-sorted-lists/?favorite=2cktkvj

要注意链表需要构造一个节点指针来遍历，，，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class mergeTwoLists {
    class Solution {
        public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
            ListNode myListHead = new ListNode(0);
            ListNode myList = myListHead;
            if (list1 == null) {
                return list2;
            }
            if (list2 == null) {
                return list1;
            }
            while (list1 != null && list2 != null) {
                if (list1.val < list2.val) {
                    myList.next = list1;
                    myList = myList.next;
                    list1 = list1.next;
                } else {
                    myList.next = list2;
                    myList = myList.next;
                    list2 = list2.next;
                }
            }
            myList.next = list1 == null ? list2 : list1;
            return myListHead.next;
        }
    }
}

爬楼梯

https://leetcode.cn/problems/climbing-stairs/?favorite=2cktkvj

由于总方案数=最后走一步的方案数+最后走两步的方案数。

所以这题就是个求斐波那契数列第n项的值，使用滚动数组。0 0 1 1 2 3 5 8

1
2
3
4
5
6
7
8
9
10
11
class Solution {
    public int climbStairs(int n) {
        int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; i++) {
            p = q;
            q = r;
            r = p + q;
        }
        return r;
    }
}

二叉树的中序遍历

基础递归，就这还写了半天，重开吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        TreeNode treeNode = root;
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        traversal(list,treeNode);
        return list;
    }

    public void traversal(List<Integer> list, TreeNode treeNode) {
        if (treeNode.left != null) {
            traversal(list, treeNode.left);
        }
        list.add(treeNode.val);
        if (treeNode.right != null) {
            traversal(list, treeNode.right);
        }
    }
}

还可以用栈迭代，，，不会

对称二叉树

不会，，多写多练多看吧，，

需要复习一下有关null的各种知识了，如何比较，空指针异常之类的，，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return treeSymmetric(root, root);
    }

    public boolean treeSymmetric(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        }
        if (p == null || q == null) {
            return false;
        }
        return p.val == q.val && treeSymmetric(p.left, q.right) && treeSymmetric(p.right, q.left);
    }
}

二叉树的直径

https://leetcode.cn/problems/diameter-of-binary-tree/

递归+DFS

这里的depth求的是每个节点子树的最大深度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
    int max = 0;

    public int diameterOfBinaryTree(TreeNode root) {
        depth(root);
        return max;
    }

    public int depth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = depth(root.left);
        int right = depth(root.right);
        max = Math.max(max, left + right);
        return Math.max(left, right) + 1;
    }
}

合并二叉树

https://leetcode.cn/problems/merge-two-binary-trees/

也是递归+DFS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        TreeNode treeNode = new TreeNode(root1.val + root2.val);
        treeNode.left = mergeTrees(root1.left, root2.left);
        treeNode.right = mergeTrees(root1.right, root2.right);
        return treeNode;
    }
}

二叉树的最大深度

https://leetcode.cn/problems/maximum-depth-of-binary-tree/

很简单，我都会

1
2
3
4
5
6
7
8
9
10
11
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        int max = Math.max(left, right);
        return max + 1;
    }
}

买卖股票的最佳时机

https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/

暴力解法，直接被巨量数据狂暴轰入，宕机了，不行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int maxProfit(int[] prices) {
        int maxProfit = 0;
        for (int i = 0; i < prices.length; i++) {
            int buy = prices[i];
            for (int j = prices.length - 1; j > i; j--) {
                int profit = prices[j] - buy;
                if (profit > maxProfit) {
                    maxProfit = profit;
                }
            }
        }
        return maxProfit;
    }
}

其实只需要找到最小价格，再用之后每一天的价格减去最小价格，找到最大利润即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution1 {
    public int maxProfit1(int[] prices) {
        int maxProfit = 0;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i] < min) {
                min = prices[i];
            }
            if (prices[i] - min > maxProfit) {
                maxProfit = prices[i] - min;
            }
        }
        return maxProfit;
    }
}

只出现一次的数字

https://leetcode.cn/problems/single-number/?favorite=2cktkvj

很简单，我都会

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int singleNumber(int[] nums) {
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(nums[0]);
        for (int i = 1; i < nums.length; i++) {
            if (hashSet.contains(nums[i])) {
                hashSet.remove(nums[i]);
            } else {
                hashSet.add(nums[i]);
            }
        }
        Iterator<Integer> iterator = hashSet.iterator();
        return iterator.next();
    }
}

如何才能做到线性时间复杂度和常数空间复杂度呢？

详见答案，，我跪了。

]]> <h1 id="合并两个有序链表"><a href="#合并两个有序链表" class="headerlink" title="合并两个有序链表"></a>合并两个有序链表</h1><p><a href="https://leetcode.cn/problems/merge-tw MyBatisPlus https://colazii.github.io/posts/b3dd.html 2022-09-09T12:39:38.000Z 2022-10-09T14:34:40.052Z image.png

好几把炫酷

入门案例

导入坐标

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

yml配置

1
2
3
4
5
6
7
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql:///db1?serverTimezone=UTC
    type: com.alibaba.druid.pool.DruidDataSource

数据层接口

接口继承一个mybatisplus写好的mapper。

1
2
3
@Mapper
public interface BookDao extends BaseMapper<Book> {
}

注意，这里搜索的数据库表是按泛型中的类名来搜索的，比如这里就是连接的db1下的book表，如果要更改，要到实体类上添加注解。

1
2
@TableName("tb_book")
public class Book {

完成

mybatisplus会自动写好一些sql语句

1
2
3
4
5
6
7
8
9
10
11
12
@SpringBootTest
class MybatisPlusApplicationTests {
    @Autowired
    private BookDao bookDao;

    @Test
    void contextLoads() {
        List<Book> books = bookDao.selectList(null);
        System.out.println(books);
    }

}

标准CRUD制作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@SpringBootTest
class MybatisPlusApplicationTests {
    @Autowired
    private BookDao bookDao;

    @Test
    void testSave(){
        Book book = new Book("111","aaa","ddd");
        bookDao.insert(book);
    }

    @Test
    void testDelete(){
        bookDao.deleteById(5);
    }

    @Test
    void testUpdate(){
        Book book = new Book();
        book.setId(1);
        book.setName("999999");
        bookDao.updateById(book);
    }

    @Test
    void testGetById(){
        Book book = bookDao.selectById(1);
        System.out.println(book);
    }

注意，改操作是一个动态sql语句，可以随意更改。

分页查找

1
2
3
4
5
6
7
8
9
10
@Test
void testGetByPage() {
    IPage page = new Page(1, 2);
    bookDao.selectPage(page, null);
    System.out.println("当前页码值" + page.getCurrent());
    System.out.println("每页显示数: " + page.getSize());
    System.out.println("一共多少页: " + page.getPages());
    System.out.println("一共多少条数据: " + page.getTotal());
    System.out.println("数据: " + page.getRecords());
}

需要配置mybatisplus拦截器

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
//        创建mp拦截器
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
//        在mp拦截器中添加分页拦截器
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

DQL编程控制

条件查询

需要封装wrapper对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    @Test
    void testByCondition(){
//        按条件查询
//        QueryWrapper queryWrapper = new QueryWrapper();
//        queryWrapper.lt("id",3);
//        List books = bookDao.selectList(queryWrapper);
//        System.out.println(books);

//        lambda格式
//        QueryWrapper<Book> queryWrapper = new QueryWrapper();
//        queryWrapper.lambda().lt(Book::getId,3);
//        List books = bookDao.selectList(queryWrapper);
//        System.out.println(books);

//        lambda格式
//        LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        lambdaQueryWrapper.lt(Book::getId,3);
//        List books = bookDao.selectList(lambdaQueryWrapper);
//        System.out.println(books);

//        多条件查询
      LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
      lambdaQueryWrapper.lt(Book::getId,2).or().gt(Book::getId,3);
      List books = bookDao.selectList(lambdaQueryWrapper);
      System.out.println(books);
    }

条件查询NULL判定

可在lt，gt方法中添加condition变量，，略过，，

查询投影

1
2
3
4
5
QueryWrapper<Book> queryWrapper = new QueryWrapper<Book>();
queryWrapper.select("count(*) as count,description");
queryWrapper.groupBy("description");
List<Map<String, Object>> maps = bookDao.selectMaps(queryWrapper);
System.out.println(maps);

查询条件设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//        等同
//        LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        lambdaQueryWrapper.eq(Book::getName,"444");
//        Book book = bookDao.selectOne(lambdaQueryWrapper);
//        System.out.println(book);

//        范围查询
//        LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        lambdaQueryWrapper.between(Book::getId,1,4);
//        List<Book> books = bookDao.selectList(lambdaQueryWrapper);
//        System.out.println(books);

//        模糊匹配
        LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(Book::getType,"2");
        List<Book> books = bookDao.selectList(lambdaQueryWrapper);
        System.out.println(books);

字段映射和表名映射

在实体类中用@TableField注解中的属性Value来映射。列名和表名都可以。

属性exist可以去除数据库中实际没有的属性。

属性select可以使该属性不参与查询，例如密码。

DML编程控制

id生成策略

使用@TableId注解定义里面的type属性。

还可以在配置文件yml中全局配置。

多记录删除

传入一个list集合即可。

逻辑删除

在数据库（要有默认值）和实体类中添加一个状态字段，表示数据是否可用。

在实体类状态属性上添加一个注解@TableLogic，其中的value属性表示可用，delval表示不可用。

也可以在配置文件中全局配置 logic-delete-field, logic-delete-value。

之后所有的数据库操作都会带上and deleted=0这个条件。

乐观锁

在配置中添加一个拦截器。

1
mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

在实体类中version属性添加注解@version。

]]> <p><img src="https://s2.loli.net/2022/09/09/X3h8Zu9Kfmvnid7.png" alt="image.png"></p> <p>好几把炫酷</p> <h1 id="入门案例"><a href="#入门案例" class="head SringBoot整合SSM https://colazii.github.io/posts/86cd.html 2022-09-09T09:53:37.000Z 2022-10-09T14:34:40.052Z SpringBoot已经整合了Spring和SpringMVC

SpringBoot整合MyBatis

image.png

提供实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;

    public Book() {
    }

    public Book(Integer id, String name, String type, String description) {
        this.id = id;
        this.name = name;
        this.type = type;
        this.description = description;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

数据层接口

注意需要添加@Mapper注解

1
2
3
4
5
@Mapper
public interface BookDao {
    @Select("select * from tb_book where id = #{id}")
    public Book getById(Integer id);
}

配置yml文件

1
2
3
4
5
6
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///db1
    username: root
    password: root

整合SSM案例

参见之前的Spring整合SSM，添加依赖坐标，数据层接口添加@Mapper注解，配置yml文件，即可完成。

静态页面需要放在resources/static目录下。

]]> <p>SpringBoot已经整合了Spring和SpringMVC</p> <h1 id="SpringBoot整合MyBatis"><a href="#SpringBoot整合MyBatis" class="headerlink" title="SpringBoot整合MyB SpringBoot之全部白学 https://colazii.github.io/posts/6797.html 2022-09-08T14:28:38.000Z 2022-10-09T14:34:40.052Z 简化Spring开发

入门案例

创建工程

image.png

image.png

创建Controller类

1
2
3
4
5
6
7
8
9
@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(id);
        return "hello world SpringBoot";
    }
}

完成

启动app程序，用postman发请求即可看到功能已实现。

起步依赖

切换功能

配置文件格式

读取数据

例如在yml中有如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
lesson: SpringBoot

server:
  port: 80

enterprise:
  name: 111
  age: 11
  tel: 123
  subject:
    - aa
    - 22
    - cc

读取数据有如下几种方式

用变量加入@Value注解，或者创建environment变量进行自动装配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@RestController
@RequestMapping("/books")
public class BookController {

    @Value("${lesson}")
    private String lesson;

    @Autowired
    private Environment environment;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(id);
        System.out.println(lesson);
        System.out.println(environment.getProperty("enterprise.subject[0]"));
        return "hello world SpringBoot";
    }
}

或者创建实体类并添加注解

1
2
@Component
@ConfigurationProperties(prefix = "enterprise")

然后直接自动装配即可使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@RestController
@RequestMapping("/books")
public class BookController {

    @Value("${lesson}")
    private String lesson;

    @Autowired
    private Environment environment;

    @Autowired
    private EnterPrise enterPrise;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(id);
        System.out.println(lesson);
        System.out.println(environment.getProperty("enterprise.subject[0]"));
        System.out.println(enterPrise);
        return "hello world SpringBoot";
    }
}

环境更改

按如下方式写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
spring:
  profiles:
    active: dev

---

spring:
  config:
    activate:
      on-profile: dev

server:
  port: 9001

---

spring:
  config:
    activate:
      on-profile: pro

server:
  port: 9002

---

spring:
  config:
    activate:
      on-profile: test

server:
  port: 9003

带参数启动

1
java -jar springboot.jar --spring.profiles.active=dev
]]> <p>简化Spring开发</p> <h1 id="入门案例"><a href="#入门案例" class="headerlink" title="入门案例"></a>入门案例</h1><h2 id="创建工程"><a href="#创建工程" class="headerlink Spring学习：拦截器 https://colazii.github.io/posts/2662.html 2022-09-07T17:08:45.000Z 2022-10-09T14:34:40.052Z 拦截器和过滤器有点像，只不过过滤器是servlet的技术，拦截器是SpringMVC的。

image.png

入门案例

制作拦截器功能类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Component
public class ProjectInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

在配置类中添加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Configuration
@ComponentScan({"cola.controller","cola.config"})
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer{
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

控制台输出

可以看出三个方法执行的顺序。

1
2
3
4
preHandle
[INFO] {dataSource-1} inited
postHandle
afterCompletion

注意，若preHandle方法返回的是false，则会在该方法执行完成后停止。

拦截器参数

拦截器链工作流程

]]> <p>拦截器和过滤器有点像，只不过过滤器是servlet的技术，拦截器是SpringMVC的。</p> <p><img src="https://s2.loli.net/2022/09/07/564HzFyBaAbde2N.png" alt="image.png"></p> <h SSM整合 https://colazii.github.io/posts/45ba.html 2022-09-06T19:29:11.000Z 2022-10-09T14:34:40.052Z 创建工程

image.png

image.png

导入坐标

注意：servlet-api包与tomcat7的依赖包servlet-api冲突，需要添加provided。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.12</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <port>
                    80
                </port>
            </configuration>
        </plugin>
    </plugins>
</build>

创建配置文件

SpringConfig

1
2
3
4
5
6
@Configuration
@ComponentScan("cola.service")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MyBatisConfig.class})
public class SpringConfig {
}

JdbcConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

jdbc.properties

1
2
3
4
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///db1
jdbc.username=root
jdbc.password=root

MyBatisConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("cola.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("cola.dao");
        return msc;
    }
}

ServletConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        return new Filter[]{filter};
    }
}

SpringMvcConfig

1
2
3
4
5
@Configuration
@ComponentScan("cola.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

数据层接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface BookDao {
    @Insert("insert into tb_book values (null, #{type}, #{name}, #{description})")
    public void save(Book book);

    @Update("update tb_book set type=#{type}, name=#{name}, description=#{description} where id=#{id}")
    public void update(Book book);

    @Delete("delete from tb_book where id=#{id}")
    public void delete(Integer id);

    @Select("select * from tb_book where id=#{id}")
    public Book getById(Integer id);

    @Select("select * from tb_book;")
    public List<Book> getAll();
}

业务层接口及实现类

1
2
3
4
5
6
7
8
9
10
11
public interface BookService {
    public boolean save(Book book);

    public boolean update(Book book);

    public boolean delete(Integer id);

    public Book getById(Integer id);

    public List<Book> getAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    public boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    public boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
        Book book = bookDao.getById(id);
        return book;
    }

    public List<Book> getAll() {
        List<Book> books = bookDao.getAll();
        return books;
    }
}

表现层 REST风格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book) {
        bookService.save(book);
        return true;
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
        bookService.update(book);
        return true;
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
        bookService.delete(id);
        return true;
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        return book;
    }

    @GetMapping
    public List<Book> getAll() {
        List<Book> books = bookService.getAll();
        return books;
    }
}

事务处理

在SpringConfig中开启事务管理

@EnableTransactionManagement

1
2
3
4
5
6
7
@Configuration
@ComponentScan("cola.service")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MyBatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

在JdbcConfig中创建事务管理Bean

注意这里的DataSource要通过形参传递进入，直接通过方法调用就不是Spring管理的Bean了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Configuration
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

在事务层接口开启事务管理

@Transactional

1
2
3
4
5
6
7
8
9
10
11
12
@Transactional
public interface BookService {
    public boolean save(Book book);

    public boolean update(Book book);

    public boolean delete(Integer id);

    public Book getById(Integer id);

    public List<Book> getAll();
}

表现层数据封装

封装数据到data中，封装操作结果到code属性中，封装特殊信息到message属性中。

由于是用在表现层，故放在controller中。

Result类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class Result {
    private Object data;
    private Integer code;
    private String msg;

    public Result() {
    }

    public Result(Integer code, Object data) {
        this.data = data;
        this.code = code;
    }

    public Result(Integer code, Object data, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

Code类

1
2
3
4
5
6
7
8
9
10
11
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

更改表现层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK : Code.SAVE_ERR, flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK : Code.UPDATE_ERR, flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK : Code.DELETE_ERR, flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "查询失败";
        return new Result(code, book, msg);
    }

    @GetMapping
    public Result getAll() {
        List<Book> books = bookService.getAll();
        Integer code = books != null ? Code.GET_OK : Code.GET_ERR;
        String msg = books != null ? "" : "查询失败";
        return new Result(code, books, msg);
    }
}

异常处理器

所有异常均抛到表现层处理。分类处理，利用AOP思想。

在表现层创建异常处理类

1
2
3
4
5
6
7
8
@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler({Exception.class})
    public Result doException(Exception ex){
        System.out.println("出异常了");
        return new Result(50000,null,"出异常了");
    }
}

创建数据层异常类和业务层异常类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class SystemException extends RuntimeException {
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class BusinessException extends RuntimeException {
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}

在异常处理类中添加处理方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler({SystemException.class})
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员
        return  new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler({BusinessException.class})
    public Result doBusinessException(BusinessException ex){
        return  new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler({Exception.class})
    public Result doException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员
        return new Result(50000,null,"出异常了");
    }
}

修改数据层及业务层以实现异常处理

数据层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface BookDao {
    @Insert("insert into tb_book values (null, #{type}, #{name}, #{description})")
    public int save(Book book);

    @Update("update tb_book set type=#{type}, name=#{name}, description=#{description} where id=#{id}")
    public int update(Book book);

    @Delete("delete from tb_book where id=#{id}")
    public int delete(Integer id);

    @Select("select * from tb_book where id=#{id}")
    public Book getById(Integer id);

    @Select("select * from tb_book;")
    public List<Book> getAll();
}

业务层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
        return bookDao.save(book) > 0;
    }

    public boolean update(Book book) {
        return bookDao.update(book) > 0;
    }

    public boolean delete(Integer id) {
        return bookDao.delete(id) > 0;
    }

    public Book getById(Integer id) {
        Book book = bookDao.getById(id);
        return book;
    }

    public List<Book> getAll() {
        List<Book> books = bookDao.getAll();
        return books;
    }
}

放行静态资源

添加支持设置

1
2
3
4
5
6
7
8
9
10
@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

这个支持设置可以直接并入SpringMvcConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Configuration
@ComponentScan({"cola.controller","cola.config"})
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer{
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

加入扫描路径

1
2
3
4
5
@Configuration
@ComponentScan({"cola.controller","cola.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

前端部分

参见之前的BrandFinal项目，用element创建静态页面，用vue绑定模型，用axios发送ajax异步请求。

里面还实现了添加表单回显，如何设置表单恢复默认等等，，，，，，，懒得写了

需要注意的是要以REST风格写axios请求，复习一下template slot-scope=”scope”， scope.$index,，scope.row，response箭头函数也得复习一下，，

对了还要学一下Vue里函数方法怎么简化写，

]]> <h1 id="创建工程"><a href="#创建工程" class="headerlink" title="创建工程"></a>创建工程</h1><p><img src="https://s2.loli.net/2022/09/06/Bkpyrt3Pj2Dfsnd.png" Spring学习：SpringMVC https://colazii.github.io/posts/12ac.html 2022-09-05T19:33:27.000Z 2022-10-09T14:34:40.052Z SpringMVC入门案例

基于java实现MVC模型的轻量web框架，替换servlet技术完成表现层开发。

导入坐标

1
2
3
4
5
6
7
8
9
10
11
12
13
<dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <port>
                    80
                </port>
            </configuration>
        </plugin>
    </plugins>
</build>

定义Controller bean

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(){
        System.out.println("user save...");
        return "{'module':'springmvc'}";
    }
}

创建SpringMvcConfig类

1
2
3
4
@Configuration
@ComponentScan("cola")
public class SpringMvcConfig {
}

定义Servlet容器启动配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    /*加载SpringMVC容器配置*/
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    /*设置哪些请求归SpringMVC处理*/
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /*加载Spring容器配置*/
    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

在SpringConfig中排除Controller类

1
2
3
4
@Configuration
@ComponentScan(value = "cola", excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Controller.class))
public class SpringConfig {
}

Servlet容器启动配置类简化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Configuration
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

请求响应

普通参数

get和post不区分，直接添加形参都可以接受。

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(String name, int age) {
        System.out.println("user save..." + name + age);
        return "{'module':'springmvc'}";
    }
}

中文乱码

在ServletContainersInitConfig中加入Filter。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Configuration
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /*乱码处理*/
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        return new Filter[]{filter};
    }
}

pojo参数

直接接受对象形参，框架会自动将请求中的参数填入对象中。

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(User user) {
        System.out.println("user save..." + user);
        return "{'module':'springmvc'}";
    }
}

如果对象里嵌套有对象参数，例如user对象中有address对象参数，address对象中有name参数，在发送请求时，加入address.name参数即可。

数组参数

改变形参，发送请求时使用相同key名。

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(String[] likes) {
        System.out.println("user save..." + Arrays.toString(likes));
        return "{'module':'springmvc'}";
    }
}

集合参数

同上，但需要添加注解@RequestParam，因为框架默认认为形参是需要一个pojo对象，而例如List不能创建对象。

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(@RequestParam List<String> likes) {
        System.out.println("user save..." + likes);
        return "{'module':'springmvc'}";
    }
}

传递json数据

导包

1
2
3
4
5
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

添加配置

在SpringMVC Config中加入注解@EnableWebMvc

1
2
3
4
5
@Configuration
@ComponentScan("cola")
@EnableWebMvc
public class SpringMvcConfig {
}

在形参中加入注解@RequestBody

1
2
3
4
5
6
7
8
9
10
11
@Controller
public class UserController {
    /*设置请求路径*/
    @RequestMapping("/save")
    /*定义返回体*/
    @ResponseBody
    public String save(@RequestBody List<String> likes) {
        System.out.println("user save..." + likes);
        return "{'module':'springmvc'}";
    }
}
]]> <h1 id="SpringMVC入门案例"><a href="#SpringMVC入门案例" class="headerlink" title="SpringMVC入门案例"></a>SpringMVC入门案例</h1><p>基于java实现MVC模型的轻量web框架，替换se Spring学习：AOP https://colazii.github.io/posts/39e0.html 2022-09-05T11:16:49.000Z 2022-10-09T14:34:40.052Z AOP 面向切面编程

在不改变原始设计的基础上进行功能增强，

image.png

image.png

导入坐标

1
2
3
4
5
6
7
8
9
10
11
12
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.22</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.9.1</version>
    </dependency>
</dependencies>

AOP案例

在BookDao里有共性方法

1
2
3
4
5
6
7
8
9
10
11
12
13
@Repository
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");
    }

    @Override
    public void update() {
        System.out.println("book dao update...");
    }
}

抽取出来建立advice类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Component
@Aspect
public class MyAdvice {
    /*定义切入点*/
    @Pointcut("execution(void cola.dao.BookDao.update())")
    private void pt() {
    }

    /*定义共性功能*/
    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

在config中声明注解方法实现AOP

1
2
3
4
5
@Configuration
@ComponentScan("cola")
@EnableAspectJAutoProxy
public class SpringConfig {
}

实现

在切入点update方法中就可以实现共性方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
@Repository
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");
    }

    @Override
    public void update() {
        System.out.println("book dao update...");
    }
}

AOP工作流程

注意AOP底层是通过代理对象的方式实现的。

image.png

image.png

AOP切入点表达式

1
execution(public void cola.dao.BookDao.update())

可以使用通配符描述切入点，快速描述

*：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现，切入点表达式标准格式∶动作关键字（访问修饰符﹐返回值﹐包名.类/接口名.方法名（参数）异常名)，匹配cola包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法。

1
execution (public * cola.*.UserService.find*(*))

..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写，匹配com包下的任意包中的UserService类或接口中所有名称为findByld的方法

1
execution (public User cola..UserService.findById (..) )

＋：专用于匹配子类类型

1
execution(* *..*Service+.*(..))*

image.png

AOP通知类型

注意由于代理模式，环绕通知如果需要有返回值，则需要提供返回值，且这个返回值会覆盖原切入点中产生的返回值。如果环绕通知中不使用ProceedingJoinPoint，将跳过原始方法的执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Component
@Aspect
public class MyAdvice {
    /*定义切入点*/
    @Pointcut("execution(void cola.dao.BookDao.update())")
    private void pt() {
    }
    @Pointcut("execution(int cola.dao.BookDao.select())")
    private void pt1() {
    }

    @Before("pt()")
    public void before() {
        System.out.println(System.currentTimeMillis());
    }
    @After("pt()")
    public void after() {
        System.out.println(System.currentTimeMillis());
    }
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println(System.currentTimeMillis());
        Object ret = pjp.proceed();
        System.out.println(System.currentTimeMillis());
        return ret;
    }
    @Around("pt1()")
    public Object around1(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println(System.currentTimeMillis());
        Integer num = (Integer) pjp.proceed();
        System.out.println(System.currentTimeMillis());
        return num;
    }
}

AOP通知获取数据

加入JoinPoint形参调用参数。ProceedingJoinPoint一样可以，而且可以改变传入的参数后再用proceed方法传回原方法中执行。

1
2
3
4
5
@Before("pt1()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs();
    System.out.println(Arrays.toString(args));
}
]]> <h1 id="AOP-面向切面编程"><a href="#AOP-面向切面编程" class="headerlink" title="AOP 面向切面编程"></a>AOP 面向切面编程</h1><p>在不改变原始设计的基础上进行功能增强，</p> <p><img src="h 如何用Spring整合MyBatis开发 https://colazii.github.io/posts/cc1f.html 2022-09-03T17:05:47.000Z 2022-10-09T14:34:40.052Z

基础不牢，地动山摇！！！

基础不牢，地动山摇！！！

基础不牢，地动山摇！！！

MyBatis独立开发

在之前的mybatis开发中，我们首先要配置mybatis xml文件，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///db1?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="mapper"/>
    </mappers>
</configuration>

然后通过xml文件得到SqlSessionFactoryBuilder对象，通过builder得到SqlSessionFactory对象，SqlSessionFactory对象开启Session，Session调用到数据层mapper里的方法，实现sql语句，调用数据库。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class mybatisDemo {
    public static void main(String[] args) throws IOException {
        
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        
        SqlSession sqlSession = sqlSessionFactory.openSession();

        userMapper userMapper = sqlSession.getMapper(userMapper.class);
        
        List<user> userList = userMapper.selectAll();

        System.out.println(userList);

        sqlSession.close();
    }
}

Spring整合开发

为了干掉之前复杂的xml配置文件，我们直接创建通过Spring管理的Bean来实现之前xml文件实现的功能。

导包

这里，我将所有需要的包列入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.22</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.12</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

创建数据库连接池Config

druid数据库连接池：

注意，其中的properties文件是通过最上层的SpringConfig调用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Configuration
public class jdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
   }
}

上面用到的properties文件：

1
2
3
4
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///db1
jdbc.username=root
jdbc.password=root

创建MybatisConfig并加入两个Bean

创建一个MybatisConfig来代替之前mybatis xml中所有的功能，例如创建SqlSessionFactory。

MyBatisConfig配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MybatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("cola.dao");
        return msc;
    }
}

注意，其中的MapperScannerConfigurer可以使用mybatis的自动代理功能，也就是扫描包（cola.dao）中的类，里面的类被加入到Spring Bean后就可以直接使用sql注解来实现sql语句。

例如在cola.dao路径下有一个实现类：

1
2
3
4
5
@Repository
public interface BrandDao {
    @Select("select id, brand_name brandName, company_name companyName, ordered, description, status from tb_brand")
    List<brand> selectAll() ;
}

配置SpringConfig

最后配置一下SpringConfig：

1
2
3
4
5
6
@Configuration
@ComponentScan("cola")
@PropertySource("classpath:jdbc.properties")
@Import({jdbcConfig.class, MybatisConfig.class})
public class SpringConfig {
}

完成

这样我们就干掉了之前mybatis中复杂的过程，在app中直接拿到Bean就可以完成业务。

1
2
3
4
5
6
7
8
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BrandService brandService = ctx.getBean(BrandService.class);
        List<brand> brands = brandService.selectAll();
        System.out.println(brands);
    }
}

Spring整合JUnit测试

照着这种格式写就完了。

1
2
3
4
5
6
7
8
9
10
11
12
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BrandServiceTest {

    @Autowired
    private BrandService brandService;

    @Test
    public void test(){
        System.out.println(brandService.selectAll());
    }
}
]]> <div class="tip warning"><p>基础不牢，地动山摇！！！</p> </div> <div class="tip warning"><p>基础不牢，地动山摇！！！</p> </div> <div class="tip warning"><p>基础不牢，地动山 Spring学习：注解开发 https://colazii.github.io/posts/1f68.html 2022-09-03T12:56:59.000Z 2022-10-09T14:34:40.052Z 注解开发

在使用@Component注解时出现ASM ClassReader failed to parse class file - probably due to a new Java class file version that isn’t supported yet错误。

原因：Spring Framework 5.3.x 版本只能支持 JDK 8-17 (expected)，而我原来是JDK 18。

解决：在Project Structure中将project和modules中sources和dependencies的SDK和language level修改为1.8。

之后又出现了java: 错误: 无效的源发行版：18，还需要修改编译器版本。

在setting-build,execution,deployment-compiler-java compiler中将project bytecode version和target byte从的version改为1.8。

定义Bean

注解开发中定义Bean需要先在xml文件中定义注解扫描的包位置，其中base-package可以递归扫描其子路径中所有的包。

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="dao"/>

</beans>

然后在要定义的类上添加@Component注解即可。注释掉的另外三种意义等同于Component，可以用来区分MVC结构中的三个层次。

1
2
3
4
5
6
7
8
9
10
@Component("bookDao")
//@Service
//@Repository
//@Controller
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("save...");
    }
}

注解中可以不加Bean名，那么在获取Bean时需要填入类。

1
BookDao bookDao = (BookDao) ctx.getBean(BookDao.class);

纯注解开发模式

为了简化开发，可以不使用xml配置文件，直接纯注解开发。

首先需要配置一个Config类，对其加入注解@Configuration表示其是配置类，加入@ComponentScan来扫描路径，使用方式和xml中是一样的。

1
2
3
4
@Configuration
@ComponentScan("dao")
public class SpringConfig {
}

获取容器的方法从配置文件改为从类中获取。

1
2
3
4
5
6
7
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
    }
}

作用范围和生命周期

一样只需要添加注解即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Repository
@Scope("prototype")
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("save...");
    }
    @PostConstruct
    public void init() {
        System.out.println("init...");
    }
    @PreDestroy
    public void destroy() {
        System.out.println("destroy...");
    }
}

依赖注入

加入@Autowired即可自动注入，不需要set方法。（使用暴力反射，无参构造方法，需要提供。）

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    /*如果有多个相同类型的Bean，可以这样指定名称。
    @Qualifier("bookDao")*/
    private BookDao bookDao;

    @Override
    public void save() {
        System.out.println("service save...");
        bookDao.save();
    }
}

在config中加入@PropertySource注解（不允许使用通配符），也可以从外部properties文件中注入常量，使用@Value注解。

1
2
3
4
5
@Configuration
@ComponentScan({"dao", "service"})
@PropertySource("jdbc.properties")
public class SpringConfig {
}
1
2
3
4
5
6
7
8
9
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("${name}")
    private String name;
    @Override
    public void save() {
        System.out.println("dao save..." + name);
    }
}

第三方Bean

通过配置文件注入第三方Bean

一般来说Spring的每个配置文件都需要单独配置，然后通过@Import导入一个配置文件。

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class jdbcConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql:///db1?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
   }
}
1
2
3
4
@Configuration
@Import(jdbcConfig.class)
public class SpringConfig {
}

如果需要引用类型的依赖注入，则在Bean中添加形参即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
@ComponentScan("dao")
public class jdbcConfig {
    @Bean
    public DataSource dataSource(BookDao bookDao){
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql:///db1?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
   }
}
]]> <h1 id="注解开发"><a href="#注解开发" class="headerlink" title="注解开发"></a>注解开发</h1><p>在使用@Component注解时出现ASM ClassReader failed to parse class file - Spring学习：Bean https://colazii.github.io/posts/788d.html 2022-09-02T20:05:15.000Z 2022-10-09T14:34:40.052Z Bean

Bean配置

Bean中可以通过name属性给该Bean添加别名，可通过别名引用Bean，name可以有多个，可用逗号分号或空格分开。

1
2
<!--name别名-->
<bean id="bookDao" name="book book1,book2;book3" class="dao.impl.BookDaoImpl"/>
1
2
3
4
5
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao book = (BookDao) ctx.getBean("book");
BookDao newBook = (BookDao) ctx.getBean("book1");
System.out.println(book);
System.out.println(newBook);

控制台输出为：

1
2
dao.impl.BookDaoImpl@60dcc9fe
dao.impl.BookDaoImpl@60dcc9fe

可见Spring在创建Bean的时候默认使用的是单例创建，若需要非单例创建，则需要在Bean中添加属性scope，scope默认为singleton为单例创建，prototype则为非单例创建

1
<bean id="bookService" class="service.impl.BookServiceImpl" scope="prototype"/>

为什么Spring默认为单例创建？

适合交给容器管理的都应该是只创建一次可以复用的对象，例如表现层对象，业务层对象，数据层对象，工具对象。封装实体的域对象不应交给容器管理。

Bean实例化

构造方法

Spring创建Bean时需要使用反射调用构造方法，且必须是无参构造方法。

无参构造方法如果不存在，将抛出异常BeanCreationException。

静态工厂

若需要使用静态工厂方式获得实现类对象，则bean的配置中需加入factory-method属性。

1
2
3
4
5
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}
1
<bean id="orderDao" class="service.OrderDaoFactory" factory-method="getOrderDao"/>

实例工厂与FactoryBean

原始方法

若工厂中使用的不是静态方法

1
2
3
4
5
public class OrderDaoFactory {
    public OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

则bean配置中需要加入factory-bean属性

1
2
<bean id="orderDaoFactory" class="service.OrderDaoFactory"/>
<bean id="orderDao" factory-bean="orderDaoFactory" factory-method="getOrderDao"/>

代替方法

可以通过创建一个FactoryBean对象来替代上述两个步骤。

1
2
3
4
5
6
7
8
9
10
11
public class OrderDaoFactoryBean implements FactoryBean<OrderDao> {
    @Override
    public OrderDao getObject() throws Exception {
        return new OrderDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return OrderDao.class;
    }
}

配置中只需加入一条即可。

1
<bean id="orderDao" class="service.OrderDaoFactoryBean"/>

如果需要更改bean是否是单例实现，只需在FactoryBean对象中多重写一个方法。（默认就为单例）

1
2
3
4
@Override
public boolean isSingleton() {
    return true;
}

Bean的生命周期

可以在实现类中配置方法，并在xml文件中添加属性。

1
<bean id="bookDao" class="dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

也可以在实现类中实现两个接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {
    @Override
    public void save() {
        System.out.println("book dao save...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("init...");
    }
}

Bean注入

setter注入

在最开始的DI案例中，若注入的是一个简单类型，也是需要提供一个set方法，而xml配置中则需要的是value属性而非ref属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class BookServiceImpl implements BookService {

    private BookDao bookDao;
    private String databaseName;

    @Override
    public void save() {
        System.out.println("book service save..." + databaseName);
        bookDao.save();
    }

    //    提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }
}
1
2
3
4
5
6
7
<bean id="bookDao" class="dao.impl.BookDaoImpl"/>

<bean id="bookService" class="service.impl.BookServiceImpl">
    <!--注意这里-->
    <property name="bookDao" ref="bookDao"></property>
    <property name="databaseName" value="sql"></property>
</bean>

构造器注入

还可以提供构造方法来注入，xml中需要加入constructor-arg标签，这种方式一样可以注入简单类型，将ref改为value即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BookServiceImpl implements BookService {

    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}
1
2
3
4
5
6
<bean id="bookDao" class="dao.impl.BookDaoImpl"/>

<bean id="bookService" class="service.impl.BookServiceImpl">
    <!--这里的name指的是构造方法中形参的名字-->
    <constructor-arg name="bookDao" ref="bookDao"></constructor-arg>
</bean>

以上constructor-arg中的name也可以替换成type或index，用来指定构造方法中的形参。

依赖自动装配

如果提供了set方法，Spring可以自动装配注入，只需要添加autowire属性即可，但只能用于引用类型。

1
2
3
<!--id是可以省略的-->
<bean class="dao.impl.BookDaoImpl"/>
<bean id="bookService" class="service.impl.BookServiceImpl" autowire="byType"/>

加载properties文件

开启context命名空间，location属性中加逗号可以加载多个文件，也可以直接使用classpath*:*.properties加载所有。可以在context中加属性system-properties-mode=”NEVER”避免系统变量优先级更高问题。

1
2
3
4
5
6
7
8
9
10
11
<?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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
<!--classpath*代表除了当前工程，也加载所有jar包的文件-->
    <context:property-placeholder location="classpath*:*.properties,jdbc.properties" system-properties-mode="NEVER"/>

使用context命名空间加载指定properties文件，使用${}读取加载的属性值。

1
2
3
4
5
6
7
<!--使用属性占位符${}读取propertie中的属性-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</bean>
]]> <h1 id="Bean"><a href="#Bean" class="headerlink" title="Bean"></a>Bean</h1><h2 id="Bean配置"><a href="#Bean配置" class="headerlink" title="Bean配 Spring学习：IoC思想 https://colazii.github.io/posts/a407.html 2022-09-02T14:08:19.000Z 2022-10-09T14:34:40.052Z IoC（Inversion of Control） 控制反转

在之前MVC开发架构的学习中，业务层实现需要调用数据层接口实现类，如果想改变实现方式，需要更改业务层代码，这就导致代码耦合度偏高。

为了解决这个问题，就有了IoC设计思想。

IoC思想，也就是在使用对象时，在程序中不主动使用new产生对象，改为外部提供对象。对象的创建控制权由程序转移到外部，这就是控制反转思想。

Spring实现了IoC思想，提供了一个容器，称为IoC容器，充当IoC思想的“外部”，被管理的对象称作Bean。

DI（Dependency Injection）依赖注入

IoC思想的合理实现方法就是DI。

在Spring的IoC容器中如果两个对象间有依赖关系，则容器会帮助建立关系，称为依赖注入。

例如Service对象依赖Dao对象，那么我们只需要在Spring xml文件中配置好关系，使用对象时不仅会帮助获取到Bean，还会自动绑定所有关系。

IoC案例

导包

1
2
3
4
5
6
7
8
<!--导入Spring的坐标-->
<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    </dependencies>

在resources中创建Spring Config XML文件并配置bean

1
2
3
<!--id为bean的名字，class表示bean的定义类-->
<bean id="bookDao" class="dao.impl.BookDaoImpl"/>
<bean id="bookService" class="service.impl.BookServiceImpl"/>

初始化IoC容器，通过容器获取Bean

1
2
3
4
5
//        获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//        获取Bean 需要转型
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        BookService bookService = (BookService) ctx.getBean("bookService");

DI案例

为了解耦，Service中不应再有new出来的Dao对象，我们需要一个描述Service与Dao之间关系的方法，即set方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class BookServiceImpl implements BookService {
//    删除new出来的Dao对象
//    private BookDao bookDao = new BookDaoImpl();
    private BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

//    提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

再在XML文件中配置Bean，需要注意的是，ref属性指的是参照哪一个Bean，name属性表示配置进当前Bean对象中的属性。

1
2
3
4
5
6
7
8
9
<!--id为bean的名字，class表示bean的定义类-->
<bean id="bookDao" class="dao.impl.BookDaoImpl"/>

<bean id="bookService" class="service.impl.BookServiceImpl">
    <!--property标签表示配置当前bean的属性
    name属性表示配置哪一个具体的属性
    ref属性表示参照哪一个bean-->
    <property name="bookDao" ref="bookDao"></property>
</bean>

之后在App中即可直接调用Service完成功能实现。

1
2
3
4
5
6
7
8
9
10
public class App {
    public static void main(String[] args) {
//        获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//        获取Bean 需要转型
        BookService bookService = (BookService) ctx.getBean("bookService");

        bookService.save();
    }
}
]]> <h1 id="IoC（Inversion-of-Control）-控制反转"><a href="#IoC（Inversion-of-Control）-控制反转" class="headerlink" title="IoC（Inversion of Control） 控制反转"> Hello World https://colazii.github.io/posts/24c0.html 2022-09-01T19:37:13.000Z 2022-10-09T14:34:40.052Z

开发日志

2022-9-1 Colazi’s nest V1.0.0

Hello World

用了整整两天，终于做完了这个博客。可以说是把能踩的坑都踩了一遍，不得不佩服做前端的兄弟。

以后终于有个地方可以放东西了，放点图库，分享点音乐，记录下生活，也不用再去什么qq空间，很开心。

以下是V1.0.0版本实现的功能

以及未实现的
而且我真的还会更新吗

基于Hexo框架和GitHub托管，使用Butterfly主题的个人博客。

网页主体背景和底部背景透明，实现背景一图流。

aplayer插件添加网页播放器，以及缩小隐藏在左下角。

live2d插件生成网页看板娘（猫 ）。

PWA实现生成小型博客web app，可以部署到电脑或手机桌面，且文章更新时会提醒。好像网页端并不会提醒

使用Github Action实现全自动部署。还不知道怎么用VScode和其交互

Gitalk和Valine双重评论系统。

hexo-renderer-kramed渲染更多的外挂标签。都不会用

下个版本想实现的？

自建图床。

添加自定义live2d模型。

说说和在线聊天功能。

该学习了，以上都是有生之年。（这里用密文标签怎么会使上面的分割线和标题失效？）

END~♪♫♬♩♪

]]> <div class="timeline purple"><div class='timeline-item headline'><div class='timeline-item-title'><div class='item-circle'><p>开发日志</p> </div