AOP-03 7.AOP-切入表達式 7.1切入表達式的具體使用 1.切入表達式的作用: 通過表達式的方式定義一個或多個具體的連接點。 2.語法細節: (1)切入表達式的語法格式: execution([許可權修飾符] [返回值類型] [簡單類名/全類名] [方法名]([參數列表]) 若目標類、介面與 ...
AOP-03
7.AOP-切入表達式
7.1切入表達式的具體使用
1.切入表達式的作用:
通過表達式的方式定義一個或多個具體的連接點。
2.語法細節:
(1)切入表達式的語法格式:
execution([許可權修飾符] [返回值類型] [簡單類名/全類名] [方法名]([參數列表])
若目標類、介面與該切麵類在用同一個包中,可以省略包名,只寫簡單類名
(2)舉例說明:
例子1:
表達式:execution(* com.sina.spring.ArithmeticCalculator.*(..))
含義:ArithmeticCalculator.* :介面中聲明的所有方法。第一個 *
代表任意修飾符和任意返回值。 第二個 *
代表任意方法。..
代表匹配任意數量和任意類型的參數,若目標類、介面與該切麵類在用同一個包中,可以省略包名。
例子2:
表達式:execution(public * ArithmeticCalculator.*(..))
含義:ArithmeticCalculator 介面中的所有公有方法
例子3:
表達式:execution(public double ArithmeticCalculator.*(..))
含義:ArithmeticCalculator 介面中返回 double 類型數值的方法
例子4:
表達式:execution(public double ArithmeticCalculator.*(double, ..))
含義:第一個參數為double 類型的方法。..
匹配任意數量、任意類型的參數。
例子5:
表達式:execution(public double ArithmeticCalculator.*(double, double))
含義:參數類型為double ,double 類型的方法。
(3)在AspectJ中,切入點表達式可以通過 &&
或者 ||
或者 !
等操作符結合起來
例子:
表達式:execution(* *.add(int, ..))|| exexution(* *.sub(int, ..))
含義:任意類中第一個參數為 int 類型的 add 方法或 sub 方法
7.2註意事項和細節
-
切入表達式可以指向(實現了介面的)類的方法,這時切入表達式會對該類/對象生效
-
切入表達式也可以指向介面的方法,這時切入表達式會對實現了介面的類/對象生效
-
切入表達式可以對沒有實現介面的類進行切入。
這涉及到CGlib動態代理:動態代理jdk的Proxy與spring的CGlib
-
兩個動態代理的區別:
-
JDK動態代理是面向介面的,只能增強實現類中介面中存在的方法。CGlib是面向父類的,可以增強父類的所有方法
-
JDK得到的對象是JDK代理對象實例,而CGlib得到的對象是被代理對象的子類
-
靜態代理例子:
一個普通類Car:
package com.li.aop.hw;
import org.springframework.stereotype.Component;
/**
* @author 李
* @version 1.0
*/
@Component
public class Car {
public void run() {
System.out.println("小汽車在running...");
}
}
MyAspect切麵類:
package com.li.aop.hw;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 切麵類
*/
@Component
@Aspect
public class MyAspect {
//CGlib
//給沒有實現介面的一個普通類設置前置通知,其他通知亦可以設置
@Before(value = "execution(public void Car.run())")
public void ok(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
System.out.println("MyAspect前置通知ok()-目標方法-" + methodName +
" 參數-" + Arrays.toString(joinPoint.getArgs()));
}
}
測試類:
package com.li.aop.hw;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;
/**
* @author 李
* @version 1.0
*/
public class UsbTest {
@Test
public void UsbAspectTest() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans08.xml");
//carProxy是 被代理對象的子類
Car carProxy = ioc.getBean(Car.class);
System.out.println("carProxy的實際運行類型=" + carProxy.getClass());
carProxy.run();
}
}
測試結果:
8.AOP-JoinPoint
在切麵類的通知方法中,可以通過 JoinPoint對象獲取到目標方法的一系列信息:
JoinPoint對象的方法 | 釋義 |
---|---|
getSignature().getName() | 獲取目標方法名 |
getSignature().getDeclaringType().getSimpleName() | 獲取目標方法所屬類的簡單類名 |
getSignature().getDeclaringTypeName() | 獲取目標方法所屬類的全類名 |
getSignature().getModifiers() | 獲取目標方法聲明類型(public/private/protected) |
getArgs() | 獲取傳入目標方法的參數,返回一個數組 |
getTarget() | 獲取被代理的對象 |
getThis() | 獲取代理對象自己 |
9.AOP-返回通知獲取結果
- 在返回通知 @AfterReturning 中,可以獲取目標方法返回的結果。
我們在 @AfterReturning (返回通知)的註解源碼中可以看到有一個returning屬性。通過 returning 屬性可以獲取目標方法執行完畢後,返回的結果。
底層大概是:在反射執行目標方法時,將目標方法返回的結果賦給 returning 的定義的變數,然後賦給切入方法同名的參數。
例子
-
必須在返回通知中,才能獲取目標方法的返回值
-
returning 屬性定義的變數,要和切入方法接收的參數名稱一致。
10.AOP-異常通知中獲取異常
- 在異常通知中,可以獲取目標方法出現異常的信息
異常通知 @AfterThrowing 中有一個throwing 的屬性,它可以接收異常信息
例子
11.AOP-環繞通知
- 環繞通知可以完成其他四個通知要做的事情(瞭解即可)
以AOP-02-6.2 快速入門為例子
介面為 SmartAnimal.java,實現類為 SmartDog.java
切麵類為 SmartAnimalAspect2.java:
package com.li.aop.aspectj;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
/**
* @author 李
* @version 1.0
* 切麵類-這裡主要演示環繞通知
*/
@Aspect
@Component
public class SmartAnimalAspect2 {
//環繞通知
/**
* 1.@Around 表示環繞通知,它可以完成其他四個通知的功能
* 2.value = "execution(...)" 切入表達式
* 3.doAround() 表示要切入的方法,調用結構為 try-catch-finally
*
* @param joinPoint 如果是環繞通知,需要用到 ProceedingJoinPoint
* @return
*/
@Around(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
public Object doAround(ProceedingJoinPoint joinPoint) {
Object result = null;
String methodName = joinPoint.getSignature().getName();
try {
//1.相當於前置通知完成的事情
Object[] args = joinPoint.getArgs();
List<Object> argList = Arrays.asList(args);
System.out.println("AOP 環繞通知 " + methodName + "方法開始了--參數有:" + argList);
//在環繞通知中一定要調用 joinPoint.proceed()來執行目標方法
result = joinPoint.proceed();
//2.相當於返回通知完成的事情
System.out.println("AOP 環繞通知 " + methodName + "方法結束了--結果是:" + result);
} catch (Throwable throwable) {
//3.相當於異常通知完成的事情
System.out.println("AOP 環繞通知 " + methodName + "方法拋異常了--異常對象:" + throwable);
} finally {
//4.相當於最終通知完成的事情
System.out.println("AOP 環繞通知 " + methodName + "方法最終結束了...");
}
return result;
}
}
測試方法:
@Test
public void testDoAround(){
//得到ioc容器
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans07.xml");
//獲取代理對象
SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
//執行方法
smartAnimal.getSum(99,88);
}
測試結果:
12.AOP-切入點表達式重用
-
切入點表達式重用
為了統一管理切入點表達式,可以使用切入點表達式重用/復用技術。
以AOP-02-6.2 快速入門為例子
介面為 SmartAnimal.java,實現類為 SmartDog.java
切麵類為 SmartAnimalAspect.java:
package com.li.aop.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 切麵類
*/
@Aspect
@Component
public class SmartAnimalAspect {
//定義一個切入點,在後面使用時可以直接引用,提高復用性
@Pointcut(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
public void myPointCut() {
}
//前置通知
//@Before(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
//這裡我們使用定義好的切入點
@Before(value = "myPointCut()")
public void f1(JoinPoint joinPoint) {
//通過連接點對象joinPoint 拿到方法簽名
Signature signature = joinPoint.getSignature();
System.out.println("切麵類f1()-方法執行開始-日誌-方法名-" + signature.getName() +
"-參數 " + Arrays.toString(joinPoint.getArgs()));
}
//返回通知
//@AfterReturning(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", returning = "res")
@AfterReturning(value = "myPointCut()", returning = "res")
public void f2(JoinPoint joinPoint, Object res) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類f2()-方法執行正常結束-日誌-方法名-" + signature.getName());
System.out.println("目標方法返回的結果=" + res);
}
//異常通知
//@AfterThrowing(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", throwing = "throwable")
@AfterThrowing(value = "myPointCut()", throwing = "throwable")
public void f3(JoinPoint joinPoint, Throwable throwable) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類f3()-方法執行異常-日誌-方法名-" + signature.getName() + "異常信息-" + throwable);
}
//最終通知
//@After(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
@After(value = "myPointCut()")
public void f4(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類f4()-方法最終執行完畢-日誌-方法名-" + signature.getName());
}
}
測試:
@Test
public void test(){
//得到ioc容器
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans07.xml");
//獲取代理對象
SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
//執行方法
smartAnimal.getSum(99,88);
}
測試結果:
13.AOP-切麵優先順序問題
如果同一個方法,有多個切麵在同一個切入點切入,那麼執行的優先順序如何控制?
答:在切麵類聲明時,使用@Order註解控制優先順序:n值越小,優先順序越高
@Order(value=n) //n值越小,優先順序越高
例子-以AOP-02-6.2 快速入門為例子
介面為 SmartAnimal.java,實現類為 SmartDog.java,兩個切麵類: SmartAnimalAspect.java 和 SmartAnimalAspect2.java
SmartAnimalAspect.java:
package com.li.aop.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 切麵類1
*/
@Aspect
@Component
@Order(value = 2)//表示該切麵類執行的順序,value越小,優先順序越高
public class SmartAnimalAspect {
//定義一個切入點,在後面使用時可以直接引用,提高復用性
@Pointcut(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
public void myPointCut() {
}
//前置通知
@Before(value = "myPointCut()")
public void f1(JoinPoint joinPoint) {
//通過連接點對象joinPoint 拿到方法簽名
Signature signature = joinPoint.getSignature();
System.out.println("切麵類1-f1()-方法執行開始-日誌-方法名-" + signature.getName() +
"-參數 " + Arrays.toString(joinPoint.getArgs()));
}
//返回通知
@AfterReturning(value = "myPointCut()", returning = "res")
public void f2(JoinPoint joinPoint, Object res) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類1-f2()-方法執行正常結束-日誌-方法名-" + signature.getName() + " 目標方法返回的結果=" + res);
}
//異常通知
@AfterThrowing(value = "myPointCut()", throwing = "throwable")
public void f3(JoinPoint joinPoint, Throwable throwable) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類1-f3()-方法執行異常-日誌-方法名-" + signature.getName() + "異常信息-" + throwable);
}
//最終通知
@After(value = "myPointCut()")
public void f4(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類1-f4()-方法最終執行完畢-日誌-方法名-" + signature.getName());
}
}
SmartAnimalAspect2.java:
package com.li.aop.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 切麵類 2
*/
@Aspect
@Component
@Order(value = 1)
public class SmartAnimalAspect2 {
@Before(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
public void f1(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類2-f1()-方法執行開始-日誌-方法名-" + signature.getName() +
"-參數 " + Arrays.toString(joinPoint.getArgs()));
}
//返回通知:
@AfterReturning(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", returning = "res")
public void f2(JoinPoint joinPoint, Object res) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類2-f2()-方法執行正常結束-日誌-方法名-" + signature.getName() + " 目標方法返回的結果=" + res);
}
//異常通知:
@AfterThrowing(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", throwing = "throwable")
public void f3(JoinPoint joinPoint, Throwable throwable) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類2-f3()-方法執行異常-日誌-方法名-" + signature.getName() + "異常信息-" + throwable);
}
//最終通知:
@After(value = "execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
public void f4(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切麵類2-f4()-方法最終執行完畢-日誌-方法名-" + signature.getName());
}
}
測試方法:
@Test
public void smartDogTestByAspectj() {
//得到Spring容器
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans07.xml");
//通過介面類型來獲得註入的SmartDog對象(實際上是代理對象proxy)
SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
smartAnimal.getSum(100, 48);
}
測試結果:
註意事項和細節:
不能理解成:優先順序高的切麵類,每個消息通知都先執行。
真實的執行順序和 Filter 過濾器鏈式調用類似:
14.基於XML配置AOP
前面我們都是通過註解來配置aop的,在spring中,同樣支持通過xml的方式來配置aop
例子
1.SmartAnimal 介面:
package com.li.aop.xml;
/**
* @author 李
* @version 1.0
*/
public interface SmartAnimal {
//求和
float getSum(float a, float b);
//求差
float getSub(float a, float b);
}
2.SmartDog 實現類:
package com.li.aop.xml;
/**
* @author 李
* @version 1.0
*/
public class SmartDog implements SmartAnimal {
@Override
public float getSum(float a, float b) {
float result = a + b;
System.out.println("方法內部列印 result = " + result);
return result;
}
@Override
public float getSub(float a, float b) {
float result = a - b;
System.out.println("方法內部列印 result = " + result);
return result;
}
}
3.SmartAnimalAspect 切麵類:
package com.li.aop.xml;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 這是一個切麵類,使用xml的方法配置
*/
public class SmartAnimalAspect {
public void showBeginLog(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("xml-showBeginLog()-方法執行開始-日誌-方法名-" + signature.getName() +
"-參數 " + Arrays.toString(joinPoint.getArgs()));
}
public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
Signature signature = joinPoint.getSignature();
System.out.println("xml-showSuccessEndLog()-方法執行正常結束-日誌-方法名-" + signature.getName() + " 目標方法返回的結果=" + res);
}
public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
Signature signature = joinPoint.getSignature();
System.out.println("xml-showExceptionLog()-方法執行異常-日誌-方法名-" + signature.getName() + "異常信息-" + throwable);
}
public void showFinallyEndLog(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("xml-showFinallyEndLog()-方法最終執行完畢-日誌-方法名-" + signature.getName());
}
}
4.xml容器文件:
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--使用xml配置完成aop編程-->
<!--配置一個切麵類對象 bean-->
<bean class="com.li.aop.xml.SmartAnimalAspect" id="smartAnimalAspect"/>
<!--配置一個SmartDog對象-->
<bean class="com.li.aop.xml.SmartDog" id="smartDog"/>
<!--配置切麵類 (註意要引入aop名稱空間)-->
<aop:config>
<!--先配置切入點-->
<aop:pointcut id="myPointCut" expression="execution(public float com.li.aop.xml.SmartDog.*(float, float))"/>
<!--配置切麵的前置/返回/異常/最終通知-->
<aop:aspect ref="smartAnimalAspect" order="10">
<!--配置前置通知-->
<aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
<!--配置返回通知-->
<aop:after-returning method="showSuccessEndLog" pointcut-ref="myPointCut" returning="res"/>
<!--配置異常通知-->
<aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="throwable"/>
<!--最終通知-->
<aop:after method="showFinallyEndLog" pointcut-ref="myPointCut"/>
<!--還可以配置環繞通知...-->
</aop:aspect>
</aop:config>
</beans>
5.測試類:
package com.li.aop.xml;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;
/**
* @author 李
* @version 1.0
* 測試類
*/
public class AopAspectjXMLTest {
@Test
public void testAspectjByXML() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans09.xml");
SmartAnimal smartAnimalProxy = ioc.getBean(SmartAnimal.class);
smartAnimalProxy.getSum(1000, 888);
}
}
測試結果:
15.aop練習
-
請編寫一個Cal介面,該介面有兩個方法:
- cal1(int n),計算1 + 2 + ... + n
- cal2(int n),計算1 * 2 *... * n
-
Cal 實現類為 MyCal
-
請分別使用註解方式和xml配置的方式,完成aop編程
- 在執行 cal2 前列印開始執行的時間,在執行完後列印時間
- 在執行 cal2 前列印開始執行的時間,在執行完後列印時間
(1)xml配置的方式:
Cal:
package com.li.aop.hw2;
/**
* @author 李
* @version 1.0
*/
public interface Cal {
//累加
public void cal1(int n);
//累乘
public void cal2(int n);
}
MyCal:
package com.li.aop.hw2;
/**
* @author 李
* @version 1.0
*/
public class MyCal implements Cal {
@Override
public void cal1(int n) {
int result = 0;
if (n >= 1) {
for (int i = 0; i <= n; i++) {
result += i;
}
System.out.println("cal1-result=" + result);
return;
}
System.out.println("cal1-參數有誤");
}
@Override
public void cal2(int n) {
int result = 1;
if (n >= 1) {
for (int i = 1; i <= n; i++) {
result *= i;
}
System.out.println("cal2-result=" + result);
return;
}
System.out.println("cal2-參數有誤");
}
}
切麵類:
package com.li.aop.hw2;
/**
* @author 李
* @version 1.0
* 切麵類
*/
public class CalAspect {
//前置通知
public void beforeTime() {
System.out.println("開始執行計算 "+System.currentTimeMillis());
}
//返回通知
public void returningTime() {
System.out.println("結束執行計算 "+System.currentTimeMillis());
}
}
xml容器配置文件:
<!--配置實現類對象bean-->
<bean class="com.li.aop.hw2.MyCal" id="myCal"/>
<!--配置切麵類對象bean-->
<bean class="com.li.aop.hw2.CalAspect" id="calAspect"/>
<aop:config>
<!--配置切入點表達式-->
<aop:pointcut id="myPointCut" expression="execution(public void com.li.aop.hw2.MyCal.*(int))"/>
<!--配置切麵類-->
<aop:aspect ref="calAspect">
<!--前置通知-->
<aop:before method="beforeTime" pointcut-ref="myPointCut"/>
<!--返回通知-->
<aop:after-returning method="returningTime" pointcut-ref="myPointCut"/>
</aop:aspect>
</aop:config>
測試方法:
@Test
public void myCalTest() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans10.xml");
//因為這裡只有一個實現對象,因此用類型獲取
Cal myCalProxy = ioc.getBean(Cal.class);
myCalProxy.cal1(200);
System.out.println("===============");
myCalProxy.cal2(5);
}
測試結果:
(2)基於註解的配置方式
Cal 介面不變,在MyCal 實現類上添加 @Component 註解:
@Component
public class MyCal implements Cal {...}
切麵類:
package com.li.aop.hw2;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
* @author 李
* @version 1.0
* 切麵類
*/
@Component
@Aspect
public class CalAspect {
//前置通知
//如果切麵類和目標類在同一個包,可以省略包名
@Before(value = "execution(public void com.li.aop.hw2.Cal.*(int))")
public void beforeTime(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println(signature.getName() + " 開始時間: " + System.currentTimeMillis());
}
//返回通知
@AfterReturning(value = "execution(public void com.li.aop.hw2.Cal.*(int))")
public void returningTime(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println(signature.getName() + " 結束時間: " + System.currentTimeMillis());
}
}
xml容器配置文件:
<!--配置要掃描的包-->
<context:component-scan base-package="com.li.aop.hw2"/>
<!--開啟基於註解的aop功能-->
<aop:aspectj-autoproxy/>
測試方法不變:
@Test
public void myCalTest() {
ApplicationContext ioc = new ClassPathXmlApplicationContext("beans10.xml");
//因為這裡只有一個實現對象,因此用類型獲取
//又因為是代理對象,因此使用介面類型獲取
Cal myCalProxy = ioc.getBean(Cal.class);
myCalProxy.cal1(200);
System.out.println("===============");
myCalProxy.cal2(5);
}
測試結果: